Documentation
¶
Index ¶
Constants ¶
const ( KiB = 10 MiB = 20 )
Variables ¶
This section is empty.
Functions ¶
func IsNotFound ¶
Types ¶
type Backend ¶
type Backend interface {
Reader
Writer
NewReadTransaction() (ReadTransaction, error)
NewWriteTransaction() (WriteTransaction, error)
Close() error
Compact() error
}
The Backend interface represents the main database handle. It supports both read/write operations and opening read-only or writable transactions. Depending on the actual implementation, individual read/write operations may be implicitly wrapped in transactions, making them perform quite badly when used repeatedly. For bulk operations, consider always using a transaction of the appropriate type. The transaction isolation level is "read committed" - there are no dirty reads.
func OpenLevelDB ¶
Open attempts to open the database at the given location, and runs recovery on it if opening fails. Worst case, if recovery is not possible, the database is erased and created from scratch.
func OpenLevelDBMemory ¶
func OpenLevelDBMemory() Backend
OpenMemory returns a new Backend referencing an in-memory database.
func OpenLevelDBRO ¶
OpenRO attempts to open the database at the given location, read only.
func OpenMemory ¶
func OpenMemory() Backend
type Iterator ¶
The Iterator interface specifies the operations available on iterators returned by NewPrefixIterator and NewRangeIterator. The iterator pattern is to loop while Next returns true, then check Error after the loop. Next will return false when iteration is complete (Error() == nil) or when there is an error preventing iteration, which is then returned by Error(). For example:
it, err := db.NewPrefixIterator(nil)
if err != nil {
// problem preventing iteration
}
defer it.Release()
for it.Next() {
// ...
}
if err := it.Error(); err != nil {
// there was a database problem while iterating
}
An iterator must be Released when no longer required. The Error method can be called either before or after Release with the same results. If an iterator was created in a transaction (whether read-only or write) it must be released before the transaction is released (or committed).
type ReadTransaction ¶
type ReadTransaction interface {
Reader
Release()
}
The ReadTransaction interface specifies the operations on read-only transactions. Every ReadTransaction must be released when no longer required.
type Reader ¶
type Reader interface {
Get(key []byte) ([]byte, error)
NewPrefixIterator(prefix []byte) (Iterator, error)
NewRangeIterator(first, last []byte) (Iterator, error)
}
The Reader interface specifies the read-only operations available on the main database and on read-only transactions (snapshots). Note that when called directly on the database handle these operations may take implicit transactions and performance may suffer.
type WriteTransaction ¶
type WriteTransaction interface {
ReadTransaction
Writer
Checkpoint(...func() error) error
Commit() error
}
The WriteTransaction interface specifies the operations on writable transactions. Every WriteTransaction must be either committed or released (i.e., discarded) when no longer required. No further operations must be performed after release or commit (regardless of whether commit succeeded), with one exception -- it's fine to release an already committed or released transaction.
A Checkpoint is a potential partial commit of the transaction so far, for purposes of saving memory when transactions are in-RAM. Note that transactions may be checkpointed *anyway* even if this is not called, due to resource constraints, but this gives you a chance to decide when.
Functions can be passed to Checkpoint. These are run if and only if the checkpoint will result in a flush, and will run before the flush. The transaction can be accessed via a closure. If an error is returned from these functions the flush will be aborted and the error bubbled.
Source Files