db

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

type Batch interface {
	KeyValueWriterDeleter

	// Size returns the current size of the batch in bytes.
	Size() int

	// Write flushes the batch to the database.
	Write() error

	// Reset resets the batch to be empty.
	Reset()

	// Replay replays the operations in the batch on the provided writer.
	Replay(w KeyValueWriterDeleter) error

	// Inner returns the inner batch, if one exists.
	Inner() Batch
}

type Batcher interface {
	// NewBatch creates a new batch that can be used to perform multiple
	// operations atomically.
	NewBatch() Batch
}

type Compacter interface {
	// Compact flushes all writes to disk and performs any necessary cleanup.
	Compact(start []byte, limit []byte) error
}

type Database interface {
	KeyValueReader
	KeyValueWriterDeleter
	Batcher
	Iteratee
	Compacter
	io.Closer

	// HealthCheck returns nil if the database is healthy, non-nil otherwise.
	HealthCheck() error
}

type Iteratee interface {
	// NewIterator returns an iterator that will iterate over the key-value
	// pairs in the database in lexicographical order by key.
	NewIterator() Iterator

	// NewIteratorWithStart returns an iterator that will iterate over the
	// key-value pairs in the database in lexicographical order by key,
	// starting at the provided key (inclusive).
	NewIteratorWithStart(start []byte) Iterator

	// NewIteratorWithPrefix returns an iterator that will iterate over the
	// key-value pairs in the database in lexicographical order by key,
	// where each key has the provided prefix.
	NewIteratorWithPrefix(prefix []byte) Iterator

	// NewIteratorWithStartAndPrefix returns an iterator that will iterate over
	// the key-value pairs in the database in lexicographical order by key,
	// starting at the provided key (inclusive) and where each key has the
	// provided prefix.
	NewIteratorWithStartAndPrefix(start, prefix []byte) Iterator
}

type Iterator interface {
	// Next moves the iterator to the next key-value pair.
	// It returns false if the iterator is exhausted.
	Next() bool

	// Error returns any accumulated error. Exhausting all the key-value pairs
	// is not considered to be an error.
	Error() error

	// Key returns the key of the current key-value pair, or nil if done.
	Key() []byte

	// Value returns the value of the current key-value pair, or nil if done.
	Value() []byte

	// Release releases associated resources. Release should always succeed and
	// can be called multiple times without causing error.
	Release()
}

type IteratorError struct {
	Err error
}

type KeyValueDeleter interface {
	// Delete removes the key from the database.
	Delete(key []byte) error
}

type KeyValueReader interface {
	// Has returns if the database has a key with the provided value.
	Has(key []byte) (bool, error)

	// Get returns the value associated with the key.
	// If the key doesn't exist, ErrNotFound is returned.
	Get(key []byte) ([]byte, error)
}

type KeyValueReaderWriterDeleter interface {
	KeyValueReader
	KeyValueWriter
	KeyValueDeleter
}

type KeyValueWriter interface {
	// Put stores the key value pair in the database.
	// If the key already exists, it will be overwritten.
	Put(key []byte, value []byte) error
}

type KeyValueWriterDeleter interface {
	KeyValueWriter
	KeyValueDeleter
}

type Pool interface {
	// Get returns a database from the pool.
	// If there are no databases in the pool, a new one is created.
	Get() Database

	// Put returns a database to the pool.
	Put(Database)
}