gokvstore

type CFHandle interface {
	UnderlyingHandle() interface{}
	Name() string
	Get(key []byte) (value []byte, err error)
	GetMulti(keys [][]byte) (values [][]byte, err error)

	// Iterator creates and allocates a new KVIndexedBulkIterator
	// with the given elems as basis, the implementation is dependent
	// on the underlying store.
	Iterator(
		sortOrder goiterator.IteratorSortOrder,
		readaheadLimitByteSize uint64,
		readaheadLimitCnt uint64,
		elems ...IteratorElementInfo) goiterator.KVIndexedBulkIterator

	PutToWriteBatch(key, value []byte, batch WriteBatch) (err error)
	PutMultiToWriteBatch(keys, values [][]byte, batch WriteBatch) (err error)

	DeleteToWriteBatch(key []byte, batch WriteBatch) (err error)
	DeleteMultiToWriteBatch(keys [][]byte, batch WriteBatch) (err error)
	DeleteBetweenToWriteBatch(
		begKey, endKey []byte, returnDeletedKeys bool, batch WriteBatch) (deletedKeys [][]byte, err error)
}

type CFKeys struct {
	CF   CFHandle
	Keys [][]byte
}

type CFKeysValues struct {
	CF     CFHandle
	Keys   [][]byte
	Values [][]byte
}

type CommandHandle interface {
	MarshalSerializer
	ErrorsProvider

	// KVCommandType returns the KVCommandType of the CommandHandle.
	KVCommandType() KVCommandType

	// Reset, resets the CommandHandle for reuse.
	// Currently not tested, allocate new objects to be sure.
	Reset()
}

type ContextSetting struct {
	Path   string            `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Params map[string]string `` /* 146-byte string literal not displayed */
}

type DeleteCommand struct {
	Elems   []DeleteElement `protobuf:"bytes,1,rep,name=elems" json:"elems"`
	Timeout int64           `protobuf:"varint,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// contextPath is implementation dependent and could be DB or DB/table, DSN etc.
	ContextPath string `protobuf:"bytes,3,opt,name=contextPath,proto3" json:"contextPath,omitempty"`
	Sync        bool   `protobuf:"varint,4,opt,name=sync,proto3" json:"sync,omitempty"`
}

type DeleteCommandHandle interface {
	WriteCommandHandle
	DeleteCommand() *DeleteCommand
	SetDeletedKeys(deletedKeys [][]byte)
}

type DeleteCommandResponse struct {
	Response    `protobuf:"bytes,1,opt,name=response,embedded=response" json:"response"`
	DeletedKeys [][]byte          `protobuf:"bytes,2,rep,name=deletedKeys" json:"deletedKeys,omitempty"`
	EventID     uint64            `protobuf:"varint,3,opt,name=eventID,proto3" json:"eventID,omitempty"`
	Params      map[string]string `` /* 146-byte string literal not displayed */
}

type DeleteCommandType int32

type DeleteElement struct {
	ContextPath       string            `protobuf:"bytes,1,opt,name=contextPath,proto3" json:"contextPath,omitempty"`
	DeleteCommandType DeleteCommandType `protobuf:"varint,2,opt,name=deleteCommandType,proto3,enum=gokvstore.DeleteCommandType" json:"deleteCommandType,omitempty"`
	Keys              [][]byte          `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"`
	EndKeys           [][]byte          `protobuf:"bytes,4,rep,name=endKeys" json:"endKeys,omitempty"`
	ReturnDeletedKeys bool              `protobuf:"varint,5,opt,name=returnDeletedKeys,proto3" json:"returnDeletedKeys,omitempty"`
}

type DirectIterateStore interface {
	StoreContextProvider
	// CreateIterator creates a new iterator for the handle.
	CreateIterator(handle IteratorQueryHandle)
	// ModifyIterator modifies the handle iterator if necessary.
	ModifyIterator(handle IteratorQueryHandle)
}

type DirectIteratorQueryStore interface {
	Iterate(handle IteratorQueryHandle)
}

type DirectKVCommandStore interface {
	// Put inserts the handles elements into the store.
	Put(handle PutCommandHandle)
	// Delete removes the handles elements from the store.
	Delete(handle DeleteCommandHandle)
	// Pipelined tries to run multiple commands in row.
	Pipelined(handle PipelineCommandHandle)
}

type DirectKVQueryStore interface {
	// Get applies the handle on the store.
	// On success the resulting values of the handles keys
	// are stored int the handles ResponseData.
	Get(handle GetQueryHandle)
	// Iterate applies the handle on the store.
	// On success the resulting key value pairs
	// are stored int the handles ResponseData.
	Iterate(handle IteratorQueryHandle)
	// GetSettings gets the stores settings according to the handle query.
	GetSettings(handle SettingsQueryHandle)
}

type DirectKVRequestProviderStore interface {
	StoreContextProvider
	DirectKVRequestStore
}

type DirectKVRequestStore interface {
	DirectKVQueryStore
	DirectKVCommandStore
}

type DirectKVStore interface {
	DirectIterateStore
	DirectKVQueryStore
	DirectKVCommandStore
}

type DirectSettingsProviderStore interface {
	StoreContextProvider
	// GetSettings gets the settings of the store.
	GetSettings(handle SettingsQueryHandle)
}

type GetElement struct {
	// contextPath is implementation dependent and could be DB or DB/table, DSN etc.
	// if no contextPath is given, the one of the request is taken.
	ContextPath string   `protobuf:"bytes,1,opt,name=contextPath,proto3" json:"contextPath,omitempty"`
	Keys        [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"`
}

type GetQuery struct {
	Elems           []GetElement    `protobuf:"bytes,1,rep,name=elems" json:"elems"`
	GetReturnFormat GetReturnFormat `protobuf:"varint,2,opt,name=getReturnFormat,proto3,enum=gokvstore.GetReturnFormat" json:"getReturnFormat,omitempty"`
	// contextPath is implementation dependent and could be DB or DB/table etc.
	ContextPath string `protobuf:"bytes,3,opt,name=contextPath,proto3" json:"contextPath,omitempty"`
	WithEmpty   bool   `protobuf:"varint,4,opt,name=withEmpty,proto3" json:"withEmpty,omitempty"`
}

type GetQueryHandle interface {
	CommandHandle
	LargeCommandInfo
	ResponseData() goiterator.PositionedDataBuffer
	SetResponseData(resData goiterator.PositionedDataBuffer)
	GetQuery() *GetQuery
}

type GetQueryResponse struct {
	Response `protobuf:"bytes,1,opt,name=response,embedded=response" json:"response"`
	Params   map[string]string `` /* 146-byte string literal not displayed */
}

type GetReturnFormat int32

type IteratorCommandInfoType int32

type IteratorCommandInfoTypes struct {
	IteratorCommandInfoType []IteratorCommandInfoType `` /* 139-byte string literal not displayed */
}

type IteratorElement struct {
	IteratorElementInfo `protobuf:"bytes,1,opt,name=IteratorElementInfo,embedded=IteratorElementInfo" json:"IteratorElementInfo"`
}

type IteratorElementInfo struct {
	// contextPath is implementation dependent and could be DB or DB/table, DSN etc.
	ContextPath string `protobuf:"bytes,1,opt,name=contextPath,proto3" json:"contextPath,omitempty"`
	// beginKey is the key which is seeked to when Seek or SeekForPrev is set, it is GTE (>=) or LTE (<=).
	// if not set, the parent beginKey will be used.
	BeginKey []byte `protobuf:"bytes,2,opt,name=beginKey,proto3" json:"beginKey,omitempty"`
	// limitKey is the last key used by the source iterator and is LT (<)
	// the key which is used at max, requires an explicit comparator or implementation.
	// if not set, the parent limitKey will be used.
	LimitKey []byte `protobuf:"bytes,3,opt,name=limitKey,proto3" json:"limitKey,omitempty"`
	// how often should be iterated from the lastKey to be on right key
	// if not set, the parent beginKeyOffsCnt will be used.
	BeginKeyOffsCnt uint64 `protobuf:"varint,4,opt,name=beginKeyOffsCnt,proto3" json:"beginKeyOffsCnt,omitempty"`
}

type IteratorQuery struct {
	IteratorElementInfo `protobuf:"bytes,1,opt,name=IteratorElementInfo,embedded=IteratorElementInfo" json:"IteratorElementInfo"`
	// returnFormat is an implementation specific format.
	ReturnFormat uint64 `protobuf:"varint,2,opt,name=returnFormat,proto3" json:"returnFormat,omitempty"`
	// iteratorID will be set on the first IteratorCommand
	IteratorID uint64 `protobuf:"varint,3,opt,name=iteratorID,proto3" json:"iteratorID,omitempty"`
	// iteratorTypes is a bitfield of IteratorCommandInfoType.
	IteratorTypes uint64 `protobuf:"varint,4,opt,name=iteratorTypes,proto3" json:"iteratorTypes,omitempty"`
	Direction     uint64 `protobuf:"varint,5,opt,name=direction,proto3" json:"direction,omitempty"`
	// timeoutDurationMs specifies the timeout duration of the iterator in milliseconds.
	TimeoutDurationMs int64 `protobuf:"varint,6,opt,name=timeoutDurationMs,proto3" json:"timeoutDurationMs,omitempty"`
	// keyPrefix specifies the prefix which might be used for the iterator.
	KeyPrefix []byte `protobuf:"bytes,7,opt,name=keyPrefix,proto3" json:"keyPrefix,omitempty"`
	// keySuffix specifies the prefix which might be used for the iterator.
	KeySuffix []byte `protobuf:"bytes,8,opt,name=keySuffix,proto3" json:"keySuffix,omitempty"`
	// keyType is an implementation specific key type.
	KeyType                string                       `protobuf:"bytes,9,opt,name=keyType,proto3" json:"keyType,omitempty"`
	Elems                  []IteratorElementInfo        `protobuf:"bytes,11,rep,name=elems" json:"elems"`
	ReadaheadLimitKey      []byte                       `protobuf:"bytes,12,opt,name=readaheadLimitKey,proto3" json:"readaheadLimitKey,omitempty"`
	ReadaheadByteSize      uint64                       `protobuf:"varint,13,opt,name=readaheadByteSize,proto3" json:"readaheadByteSize,omitempty"`
	ReadaheadLimitByteSize uint64                       `protobuf:"varint,14,opt,name=readaheadLimitByteSize,proto3" json:"readaheadLimitByteSize,omitempty"`
	ReadaheadLimitCnt      uint64                       `protobuf:"varint,15,opt,name=readaheadLimitCnt,proto3" json:"readaheadLimitCnt,omitempty"`
	IteratorSortOrder      goiterator.IteratorSortOrder `protobuf:"varint,16,opt,name=IteratorSortOrder,proto3,enum=goiterator.IteratorSortOrder" json:"IteratorSortOrder,omitempty"`
	IsTailing              bool                         `protobuf:"varint,17,opt,name=isTailing,proto3" json:"isTailing,omitempty"`
	ReplaySetting          *ReplaySetting               `protobuf:"bytes,18,opt,name=replaySetting" json:"replaySetting,omitempty"`
	Params                 map[string]string            `` /* 147-byte string literal not displayed */
	Extension              []byte                       `protobuf:"bytes,20,opt,name=extension,proto3" json:"extension,omitempty"`
}

type IteratorQueryHandle interface {
	CommandHandle
	LargeCommandInfo
	ResponseData() goiterator.PositionedDataBuffer
	SetResponseData(resData goiterator.PositionedDataBuffer)
	UnderlyingIteratorHandle() (itr goiterator.KVBulkIterator)
	SetUnderlyingIteratorHandle(itr goiterator.KVBulkIterator)
	IteratorQuery() *IteratorQuery
}

type IteratorQueryResponse struct {
	Response   `protobuf:"bytes,1,opt,name=response,embedded=response" json:"response"`
	IteratorID uint64            `protobuf:"varint,2,opt,name=iteratorID,proto3" json:"iteratorID,omitempty"`
	LastKey    []byte            `protobuf:"bytes,3,opt,name=lastKey,proto3" json:"lastKey,omitempty"`
	Params     map[string]string `` /* 146-byte string literal not displayed */
}

type KVCommandStore interface {
	DirectKVCommandStore
	// PutKey puts the value for the key.
	PutKey(key, value []byte, cf CFHandle) (err error)
	// PutMulti puts the values for the keys.
	// If possible atomically.
	PutMulti(cfKeysValues ...CFKeysValues) (err error)
	// DeleteKey deletes the value associated with the key.
	DeleteKey(key []byte, cf CFHandle) (err error)
	// DeleteMulti deletes the valuse associated with the keys.
	// If possible atomically.
	DeleteMulti(cfKeys ...CFKeys) (err error)
}

type KVCommandType int32

type KVErrorCode int32

type KVQueryCommandStore interface {
	StoreContextProvider
	KVQueryStore
	KVCommandStore
}

type KVQueryStore interface {
	DirectKVQueryStore
	// Get returns the value associated with the key of the given cf.
	GetKey(key []byte, cf CFHandle) (value []byte, err error)
	// GetMulti returns the values associated with the keys of the given cfs.
	// Keys which are not found are returned as empty slice.
	// The returned result is not thread safe and if you use its
	// Keys or Values further, you have to copy these to new slices.
	GetMulti(cfKeys ...CFKeys) (result goiterator.KVKVForwardResultIterator, err error)
	// Iterator creates and allocates a new KVBulkIterator
	// with the given elems as basis, the implementation is dependent
	// on the underlying store.
	// if multiple elems are specified other cfs might be used as well.
	Iterator(
		cf CFHandle,
		sortOrder goiterator.IteratorSortOrder,
		readaheadLimitByteSize uint64,
		readaheadLimitCnt uint64,
		elems ...IteratorElementInfo) goiterator.KVIndexedBulkIterator
}

type KVStore interface {
	StoreContextProvider
}

type LargeCommandInfo interface {
	// PreDataPadByteSize returns the byte size of the pad before the data set later
	// via SetResponseData.
	PreDataPadByteSize() (size uint64)
	// PostDataPadByteSize returns the byte size of the pad after the data set later
	// via SetResponseData.
	PostDataPadByteSize() (size uint64)
}

type LoggingDirectKVRequestStore struct {
}

type PipelineCommandHandle interface {
	WriteCommandHandle
	PipelinedCommand() *PipelinedCommand
	PipelinedCommandResponse() *PipelinedCommandResponse
	CommandHandles() (handles []CommandHandle)
	SetCommandHandles(handles ...CommandHandle) (err error)
	// ConcurrencyHint returns the number of threads / routines to be used for processing
	// the pipeline command. Its only a hint and might be ignored.
	ConcurrencyHint() uint64
}

type PipelinedCommand struct {
	CommandTypes []KVCommandType `protobuf:"varint,1,rep,packed,name=commandTypes,enum=gokvstore.KVCommandType" json:"commandTypes,omitempty"`
	Commands     [][]byte        `protobuf:"bytes,2,rep,name=commands" json:"commands,omitempty"`
	// concurrencyHint may be accepted or not.
	// it, for example can tell how many threads or routines
	// should be used.
	ConcurrencyHint uint64 `protobuf:"varint,3,opt,name=concurrencyHint,proto3" json:"concurrencyHint,omitempty"`
	Sync            bool   `protobuf:"varint,4,opt,name=sync,proto3" json:"sync,omitempty"`
}

type PipelinedCommandResponse struct {
	Response     `protobuf:"bytes,1,opt,name=response,embedded=response" json:"response"`
	CommandTypes []KVCommandType `protobuf:"varint,2,rep,packed,name=commandTypes,enum=gokvstore.KVCommandType" json:"commandTypes,omitempty"`
	Commands     [][]byte        `protobuf:"bytes,3,rep,name=commands" json:"commands,omitempty"`
}

type PutCommand struct {
	Elems       []PutElement `protobuf:"bytes,1,rep,name=elems" json:"elems"`
	CommandType uint64       `protobuf:"varint,2,opt,name=commandType,proto3" json:"commandType,omitempty"`
	Timeout     int64        `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// contextPath is implementation dependent and could be DB or DB/table, DSN etc.
	ContextPath string `protobuf:"bytes,4,opt,name=contextPath,proto3" json:"contextPath,omitempty"`
	Sync        bool   `protobuf:"varint,5,opt,name=sync,proto3" json:"sync,omitempty"`
	Sequential  bool   `protobuf:"varint,6,opt,name=sequential,proto3" json:"sequential,omitempty"`
	// deleteBetween can only be used if sequential is true
	// and means that elements(elems) are considered to be sequential
	// and that the data in the stroe between elems[0] and elems[len(elems)-1]
	// should be deleted ... if possible(allowed by) atomically together with
	// the inseration.
	DeleteBetween bool `protobuf:"varint,7,opt,name=deleteBetween,proto3" json:"deleteBetween,omitempty"`
	// useCommandContextPath if true the contextPath is used, otherwise each elements`
	// contextPath is used, or if sequential and false the first elems element`s is used
	UseCommandContextPath bool `protobuf:"varint,8,opt,name=useCommandContextPath,proto3" json:"useCommandContextPath,omitempty"`
}

type PutCommandHandle interface {
	WriteCommandHandle
	PutCommand() *PutCommand
	SetDeletedKeys(deletedKeys [][]byte)
}

type PutCommandResponse struct {
	Response    `protobuf:"bytes,1,opt,name=Response,embedded=Response" json:"Response"`
	DeletedKeys [][]byte `protobuf:"bytes,2,rep,name=deletedKeys" json:"deletedKeys,omitempty"`
	// eventID only for use with a supported eventstore.
	EventID uint64            `protobuf:"varint,3,opt,name=eventID,proto3" json:"eventID,omitempty"`
	Params  map[string]string `` /* 146-byte string literal not displayed */
}

type PutElement struct {
	// contextPath is implementation dependent and could be DB or DB/table, DSN etc.
	// if no contextPath is given, the one of the request is taken.
	ContextPath       string   `protobuf:"bytes,1,opt,name=contextPath,proto3" json:"contextPath,omitempty"`
	Keys              [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"`
	Values            [][]byte `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"`
	ReturnDeletedKeys bool     `protobuf:"varint,4,opt,name=returnDeletedKeys,proto3" json:"returnDeletedKeys,omitempty"`
}

type ReplaySetting struct {
	ReplayTargetPath        string      `protobuf:"bytes,1,opt,name=replayTargetPath,proto3" json:"replayTargetPath,omitempty"`
	ReplayInterval          int64       `protobuf:"varint,2,opt,name=replayInterval,proto3" json:"replayInterval,omitempty"`
	ReplayIntervalVariation int64       `protobuf:"varint,3,opt,name=replayIntervalVariation,proto3" json:"replayIntervalVariation,omitempty"`
	ReplaySpeed             ReplaySpeed `protobuf:"varint,4,opt,name=replaySpeed,proto3,enum=gokvstore.ReplaySpeed" json:"replaySpeed,omitempty"`
}

type ReplaySpeed int32

type Request struct {
}

type Response struct {
	goerror.DefaultErrorList `protobuf:"bytes,1,opt,name=errorList,embedded=errorList" json:"errorList"`
}

type Settings struct {
	Contexts []ContextSetting `protobuf:"bytes,1,rep,name=contexts" json:"contexts"`
}

type SettingsCommand struct {
	ReturnOldValues bool              `protobuf:"varint,2,opt,name=returnOldValues,proto3" json:"returnOldValues,omitempty"`
	Params          map[string]string `` /* 146-byte string literal not displayed */
}

type SettingsCommandHandle interface {
	CommandHandle
	SettingsCommand() *SettingsCommand
}

type SettingsCommandResponse struct {
	SettingsQueryResponse `protobuf:"bytes,1,opt,name=srr,embedded=srr" json:"srr"`
}

type SettingsQuery struct {
	ReturnAll bool              `protobuf:"varint,1,opt,name=returnAll,proto3" json:"returnAll,omitempty"`
	Params    map[string]string `` /* 146-byte string literal not displayed */
}

type SettingsQueryHandle interface {
	CommandHandle
	SettingsQuery() *SettingsQuery
	SettingsQueryResponse() *SettingsQueryResponse
}

type SettingsQueryResponse struct {
	Response `protobuf:"bytes,1,opt,name=response,embedded=response" json:"response"`
	Settings Settings          `protobuf:"bytes,2,opt,name=settings" json:"settings"`
	Params   map[string]string `` /* 146-byte string literal not displayed */
}

type StoreContextProvider interface {
	WriteBatchProvider
	ColumnFamilyHandles() (cfHandles []CFHandle)
	ColumnFamilyHandleByName(contextPath string) (handle CFHandle, index int)
}

type WriteBatch interface {
	// AddCommand adds the command to the writable commands.
	AddCommand(command CommandHandle) (err error)
	// Clear clears the WriteBatch for reuse.
	Clear()
	// Count returns the count of the underlying commands or elements.
	Count() uint64
}

type WriteBatchCreator interface {
	// WriteBatch allocates and returns a new WriteBatch according to the
	// settings given with the handle. Handle can be nil and then default
	// settings are used.
	WriteBatch(handle WriteCommandHandle) WriteBatch
}

type WriteBatchProvider interface {
	WriteBatchCreator
	// WriteWriteBatch writes the WriteBatch to the underlying store
	// and waits until done (sync).
	// It is to be expected that batch can not be used afterwards.
	WriteWriteBatch(batch WriteBatch) (err error)
}

type WriteCommandHandle interface {
	CommandHandle
	// Synced defines whether the write should be synced
	// to disk/store/storage.
	Synced() bool
}