kv

type BufferStore struct {
	MemBuffer
	// contains filtered or unexported fields
}

type Client interface {
	// Send sends request to KV layer, returns a Response.
	Send(req *Request) Response

	// SupportRequestType checks if reqType and subType is supported.
	SupportRequestType(reqType, subType int64) bool
}

type Driver interface {
	// Open returns a new Storage.
	// The path is the string for storage specific format.
	Open(path string) (Storage, error)
}

type EncodedKey []byte

type FnKeyCmp func(key Key) bool

type Index interface {
	// Create supports insert into statement.
	Create(rm RetrieverMutator, indexedValues []types.Datum, h int64) error
	// Delete supports delete from statement.
	Delete(m Mutator, indexedValues []types.Datum, h int64) error
	// Drop supports drop table, drop index statements.
	Drop(rm RetrieverMutator) error
	// Exist supports check index exists or not.
	Exist(rm RetrieverMutator, indexedValues []types.Datum, h int64) (bool, int64, error)
	// GenIndexKey generates an index key.
	GenIndexKey(indexedValues []types.Datum, h int64) (key []byte, distinct bool, err error)
	// Seek supports where clause.
	Seek(r Retriever, indexedValues []types.Datum) (iter IndexIterator, hit bool, err error)
	// SeekFirst supports aggregate min and ascend order by.
	SeekFirst(r Retriever) (iter IndexIterator, err error)
}

type IndexIterator interface {
	Next() (k []types.Datum, h int64, err error)
	Close()
}

type Iterator interface {
	Valid() bool
	Key() Key
	Value() []byte
	Next() error
	Close()
}

type Key []byte

type KeyRange struct {
	StartKey Key
	EndKey   Key
}

type MemBuffer interface {
	RetrieverMutator
	// Release releases the buffer.
	Release()
}

type Mutator interface {
	// Set sets the value for key k as v into kv store.
	// v must NOT be nil or empty, otherwise it returns ErrCannotSetNilValue.
	Set(k Key, v []byte) error
	// Delete removes the entry for key k from kv store.
	Delete(k Key) error
}

type Option int

type Options interface {
	// Get gets an option value.
	Get(opt Option) (v interface{}, ok bool)
}

type Request struct {
	// The request type.
	Tp   int64
	Data []byte
	// Key Ranges
	KeyRanges []KeyRange
	// If desc is true, the request is sent in descending order.
	Desc bool
	// If concurrency is 1, it only sends the request to a single storage unit when
	// ResponseIterator.Next is called. If concurrency is greater than 1, the request will be
	// sent to multiple storage units concurrently.
	Concurrency int
}

type Response interface {
	// Next returns a resultSubset from a single storage unit.
	// When full result set is returned, nil is returned.
	Next() (resultSubset io.ReadCloser, err error)
	// Close response.
	Close() error
}

type Retriever interface {
	// Get gets the value for key k from kv store.
	// If corresponding kv pair does not exist, it returns nil and ErrNotExist.
	Get(k Key) ([]byte, error)
	// Seek creates an Iterator positioned on the first entry that k <= entry's key.
	// If such entry is not found, it returns an invalid Iterator with no error.
	// The Iterator must be Closed after use.
	Seek(k Key) (Iterator, error)

	// SeekReverse creates a reversed Iterator positioned on the first entry which key is less than k.
	// The returned iterator will iterate from greater key to smaller key.
	// If k is nil, the returned iterator will be positioned at the last key.
	SeekReverse(k Key) (Iterator, error)
}

type RetrieverMutator interface {
	Retriever
	Mutator
}

type Snapshot interface {
	Retriever
	// BatchGet gets a batch of values from snapshot.
	BatchGet(keys []Key) (map[string][]byte, error)
	// Release releases the snapshot to store.
	Release()
}

type Storage interface {
	// Begin transaction
	Begin() (Transaction, error)
	// GetSnapshot gets a snapshot that is able to read any data which data is <= ver.
	// if ver is MaxVersion or > current max committed version, we will use current version for this snapshot.
	GetSnapshot(ver Version) (Snapshot, error)
	// Close store
	Close() error
	// Storage's unique ID
	UUID() string
	// CurrentVersion returns current max committed version.
	CurrentVersion() (Version, error)
}

type Transaction interface {
	RetrieverMutator
	// Commit commits the transaction operations to KV store.
	Commit() error
	// Rollback undoes the transaction operations to KV store.
	Rollback() error
	// String implements fmt.Stringer interface.
	String() string
	// LockKeys tries to lock the entries with the keys in KV store.
	LockKeys(keys ...Key) error
	// SetOption sets an option with a value, when val is nil, uses the default
	// value of this option.
	SetOption(opt Option, val interface{})
	// DelOption deletes an option.
	DelOption(opt Option)
	// IsReadOnly checks if the transaction has only performed read operations.
	IsReadOnly() bool
	// GetClient gets a client instance.
	GetClient() Client
	// StartTS returns the transaction start timestamp.
	StartTS() uint64
}

type UnionIter struct {
	// contains filtered or unexported fields
}

type UnionStore interface {
	MemBuffer
	// CheckLazyConditionPairs loads all lazy values from store then checks if all values are matched.
	// Lazy condition pairs should be checked before transaction commit.
	CheckLazyConditionPairs() error
	// WalkBuffer iterates all buffered kv pairs.
	WalkBuffer(f func(k Key, v []byte) error) error
	// SetOption sets an option with a value, when val is nil, uses the default
	// value of this option.
	SetOption(opt Option, val interface{})
	// DelOption deletes an option.
	DelOption(opt Option)
}

type Version struct {
	Ver uint64
}

type VersionProvider interface {
	CurrentVersion() (Version, error)
}