kv

type BatchGetter interface {
	// BatchGet gets a batch of values.
	BatchGet(ctx context.Context, keys []Key) (map[string][]byte, error)
}

type Entry struct {
	Key   Key
	Value []byte
}

type ErrConflict struct {
	StartVer          Version
	ConflictStartVer  Version
	ConflictCommitVer Version
	Key               Key
}

type ErrEntryTooLarge struct {
	Limit uint64
	Size  uint64
}

type ErrGroup struct {
	Errors []error
}

type ErrKeyAlreadyExist struct {
	Key []byte
}

type ErrTxnTooLarge struct {
	Size int
}

type FlagsOp uint32

type Getter interface {
	// Get gets the value for key k from kv db.
	// If corresponding kv pair does not exist, it returns nil and ErrNotExist.
	Get(ctx context.Context, k Key) ([]byte, error)
}

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

type Key []byte

type KeyFlags uint16

type KeyRange struct {
	StartKey Key
	EndKey   Key

	XXXNoUnkeyedLiteral struct{}
	XXXunrecognized     []byte
	XXXsizecache        int32
}

type Mutator interface {
	// Set sets the value for key k as v into kv db.
	// 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 db.
	Delete(k Key) error
}

type Pair struct {
	Key Key
	Val []byte
}

type Retriever interface {
	Getter
	// Iter 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.
	// It yields only keys that < upperBound. If upperBound is nil, it means the upperBound is unbounded.
	// The Iterator must be Closed after use.
	Iter(lowerBound Key, upperBound Key) (Iterator, error)

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

type RetrieverMutator interface {
	Retriever
	Mutator
}

type Snapshot interface {
	Retriever
	BatchGetter
	// StartVer returns the start verstion of the current snapshot.
	StartVer() Version
}

type Storage interface {
	VersionProvider

	Begin() (Transaction, error)
	Snapshot(ver Version) (Snapshot, error)
	Close() error
}

type Transaction interface {
	RetrieverMutator

	StartVer() Version
	// Snapshot returns the Snapshot binding to this transaction.
	Snapshot() Snapshot
	// BatchGet gets kv from the memory buffer of statement and transaction, and the kv storage.
	// Do not use len(value) == 0 or value == nil to represent non-exist.
	// If a key doesn't exist, there shouldn't be any corresponding entry in the result map.
	BatchGet(ctx context.Context, keys []Key) (map[string][]byte, error)
	// Size returns sum of keys and values length.
	Size() int
	// Len returns the number of entries in the DB.
	Len() int
	// Reset reset the Transaction to initial states.
	Reset()
	// Commit commits the transaction operations to KV db.
	Commit(context.Context) error
	// Rollback undoes the transaction operations to KV db.
	Rollback() error
	// String implements fmt.Stringer interface.
	String() string
}

type Version uint64

type VersionPair struct {
	StartVer  Version
	CommitVer Version
}

type VersionProvider interface {
	CurrentVersion() Version
}