incdb

Documentation

Index

• Constants
• Variables
• func OpenMultipleDB(typ string, dbPath string) (map[int]Database, error)
• func RegisterDriver(d Driver) error
• type Batch
• type BatchData
• type Batcher
• type Compacter
• type Database
  • func Open(typ string, args ...interface{}) (Database, error)
• type DbLogger
  • func (dbLogger *DbLogger) Init(inst common.Logger)
• type Driver
• type Iteratee
• type Iterator
• type KeyValueReader
• type KeyValueWriter
• type Stater

Constants

const IdealBatchSize = 100 * 1024

IdealBatchSize defines the size of the data batches should ideally add in one write.

Variables

var Logger = DbLogger{}

Global instant to use

Functions

func OpenMultipleDB

func OpenMultipleDB(typ string, dbPath string) (map[int]Database, error)

Open opens the db connection.

func RegisterDriver

func RegisterDriver(d Driver) error

RegisterDriver registers the driver d.

Types

type Batch

type Batch interface {
	KeyValueWriter

	// ValueSize retrieves the amount of data queued up for writing.
	ValueSize() int

	// Write flushes any accumulated data to disk.
	Write() error

	// Reset resets the batch for reuse.
	Reset()

	// Replay replays the batch contents.
	Replay(w KeyValueWriter) error
}

Batch is a write-only database that commits changes to its host database when Write is called. A batch cannot be used concurrently.

type BatchData

type BatchData struct {
	Key   []byte
	Value []byte
}

type Batcher

type Batcher interface {
	// NewBatch creates a write-only database that buffers changes to its host db
	// until a final write is called.
	NewBatch() Batch
}

Batcher wraps the NewBatch method of a backing data store.

type Compacter

type Compacter interface {
	// Compact flattens the underlying data store for the given key range. In essence,
	// deleted and overwritten versions are discarded, and the data is rearranged to
	// reduce the cost of operations needed to access them.
	//
	// A nil start is treated as a key before all keys in the data store; a nil limit
	// is treated as a key after all keys in the data store. If both is nil then it
	// will compact entire data store.
	Compact(start []byte, limit []byte) error
}

Compacter wraps the Compact method of a backing data store.

type Database

type Database interface {
	KeyValueReader
	KeyValueWriter
	Batcher
	Iteratee
	Stater
	Compacter
	io.Closer
	RemoveBackup(string)
	Backup(backupFolder string) error
	LatestBackup(backupFolder string) (int, string)
	PreloadBackup(backupFile string) error
	ReOpen() error
	Clear() error
}

KeyValueStore contains all the methods required to allow handling different key-value data stores backing the high level database.

func Open

func Open(typ string, args ...interface{}) (Database, error)

Open opens the db connection.

type DbLogger

type DbLogger struct {
	Log common.Logger
}

func (*DbLogger) Init

func (dbLogger *DbLogger) Init(inst common.Logger)

type Driver

type Driver struct {
	DbType string
	Open   func(args ...interface{}) (Database, error)
}

Driver defines a structure for backend drivers to use when they registered themselves as a backend which implements the Database interface.

type Iteratee

type Iteratee interface {
	// NewIterator creates a binary-alphabetical iterator over the entire keyspace
	// contained within the key-value database.
	NewIterator() Iterator

	// NewIteratorWithStart creates a binary-alphabetical iterator over a subset of
	// database content starting at a particular initial key (or after, if it does
	// not exist).
	NewIteratorWithStart(start []byte) Iterator

	// NewIteratorWithPrefix creates a binary-alphabetical iterator over a subset
	// of database content with a particular key prefix.
	NewIteratorWithPrefix(prefix []byte) Iterator

	// NewIteratorWithPrefixStart creates a binary-alphabetical iterator over a subset
	// of database content with a particular key prefix, starting at a particular
	// initial key (or after, if it does not exist).
	//
	// Note: This method assumes that the prefix is NOT part of the start, so there's
	// no need for the caller to prepend the prefix to the start
	NewIteratorWithPrefixStart(prefix []byte, start []byte) Iterator
}

Iteratee wraps the NewIterator methods of a backing data store.

type Iterator

type Iterator interface {
	// Next moves the iterator to the next key/value pair. It returns whether 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. The caller
	// should not modify the contents of the returned slice, and its contents may
	// change on the next call to Next.
	Key() []byte

	// Value returns the value of the current key/value pair, or nil if done. The
	// caller should not modify the contents of the returned slice, and its contents
	// may change on the next call to Next.
	Value() []byte

	// Last moves the iterator to the last key/value pair. If the iterator
	// only contains one key/value pair then First and Last would moves
	// to the same key/value pair.
	// It returns whether such pair exist.
	Last() bool
	// Release releases associated resources. Release should always succeed and can
	// be called multiple times without causing error.
	Release()
}

Iterator iterates over a database's key/value pairs in ascending key order.

When it encounters an error any seek will return false and will yield no key/ value pairs. The error can be queried by calling the Error method. Calling Release is still necessary.

An iterator must be released after use, but it is not necessary to read an iterator until exhaustion. An iterator is not safe for concurrent use, but it is safe to use multiple iterators concurrently.

type KeyValueReader

type KeyValueReader interface {
	// Has retrieves if a key is present in the key-value data store.
	Has(key []byte) (bool, error)

	// Get retrieves the given key if it's present in the key-value data store.
	Get(key []byte) ([]byte, error)
}

KeyValueReader wraps the Has and Get method of a backing data store.

type KeyValueWriter

type KeyValueWriter interface {
	// Put inserts the given value into the key-value data store.
	Put(key []byte, value []byte) error

	// Delete removes the key from the key-value data store.
	Delete(key []byte) error
}

KeyValueWriter wraps the Put method of a backing data store.

type Stater

type Stater interface {
	// Stat returns a particular internal stat of the database.
	Stat(property string) (string, error)
}

Stater wraps the Stat method of a backing data store.