kv

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

type Driver interface {
	// Open opens access to the database store. Implementations give access to the same storage based on the dsn.
	// Implementation can return the same Storage instance based on dsn or new one as long as it provides access to
	// the same storage.
	Open(ctx context.Context, params kvparams.Config) (Store, error)
}

type EntriesIterator interface {
	// Next should be called first before access Entry.
	// it will process the next entry and return true if there is one.
	Next() bool

	// SeekGE moves the iterator to the first Entry with a key equal or greater to the given key.
	// A call to Next is required after calling this method.
	SeekGE(key []byte)

	// Entry current entry read after calling Next, set to nil in case of an error or no more entries.
	Entry() *Entry

	// Err set to last error by reading or parse the next entry.
	Err() error

	// Close should be called at the end of processing entries, required to release resources used to scan entries.
	// After calling 'Close' the instance should not be used as the behaviour will not be defined.
	Close()
}

type Entry struct {
	PartitionKey []byte
	Key          []byte
	Value        []byte
}

type IteratorOptions interface {
	// Start returns the starting point of the iterator
	Start() []byte

	// IncludeStart determines whether to include Start() value in the iterator
	IncludeStart() bool
}

type MatchRecord struct {
	PartitionPattern string
	PathPattern      string
	MessageType      protoreflect.MessageType
}

type MessageEntry struct {
	Key   []byte
	Value protoreflect.ProtoMessage
}

type MessageIterator interface {
	Next() bool
	Entry() *MessageEntry
	Err() error
	Close()
}

type Migrator interface {
	Migrate(ctx context.Context) error
}

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

type Precond string

type Predicate interface{}

type PrefixIterator struct {
	Iterator     EntriesIterator
	Prefix       []byte
	PartitionKey []byte
	// contains filtered or unexported fields
}

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

type Record struct {
	Partition string      `json:"partition"`
	Key       string      `json:"key"`
	Value     interface{} `json:"value"`
}

type ScanOptions struct {
	// KeyStart start key to seek the scan
	KeyStart []byte
	// BatchSize used by each implementation to perform limited query or fetching of data while scanning.
	// The 0 value means - use the default by the implementation.
	BatchSize int
}

type SecondaryIndex struct {
	PrimaryKey []byte `protobuf:"bytes,1,opt,name=primary_key,json=primaryKey,proto3" json:"primary_key,omitempty"`
	// contains filtered or unexported fields
}

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

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

type Store interface {
	// Get returns a result containing the Value and Predicate for the given key, or ErrNotFound if key doesn't exist
	//   Predicate can be used for SetIf operation
	Get(ctx context.Context, partitionKey, key []byte) (*ValueWithPredicate, error)

	// Set stores the given value, overwriting an existing value if one exists
	Set(ctx context.Context, partitionKey, key, value []byte) error

	// SetIf returns an ErrPredicateFailed error if the key with valuePredicate passed
	//  doesn't match the currently stored value. SetIf is a simple compare-and-swap operator:
	//  valuePredicate is either the existing value, or nil for no previous key exists.
	//  this is intentionally simplistic: we can model a better abstraction on top, keeping this interface simple for implementors
	SetIf(ctx context.Context, partitionKey, key, value []byte, valuePredicate Predicate) error

	// Delete will delete the key, no error in if key doesn't exist
	Delete(ctx context.Context, partitionKey, key []byte) error

	// Scan returns entries of partitionKey, by key order.
	// 'options' holds optional parameters to control the batch size and the key to start the scan with.
	Scan(ctx context.Context, partitionKey []byte, options ScanOptions) (EntriesIterator, error)

	// Close access to the database store. After calling Close the instance is unusable.
	Close()
}

type StoreLimiter struct {
	Store   Store
	Limiter ratelimit.Limiter
}

type StoreMetricsWrapper struct {
	Store
	StoreType string
}

type ValueWithPredicate struct {
	Value     []byte
	Predicate Predicate
}