go-ethereum: github.com/ethereum/go-ethereum/ethdb Index | Files | Directories

package ethdb

import "github.com/ethereum/go-ethereum/ethdb"

Package ethdb defines the interfaces for an Ethereum data store.

Index

Package Files

batch.go database.go iterator.go

Constants

const IdealBatchSize = 100 * 1024

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

type AncientReader Uses

type AncientReader interface {
    // HasAncient returns an indicator whether the specified data exists in the
    // ancient store.
    HasAncient(kind string, number uint64) (bool, error)

    // Ancient retrieves an ancient binary blob from the append-only immutable files.
    Ancient(kind string, number uint64) ([]byte, error)

    // Ancients returns the ancient item numbers in the ancient store.
    Ancients() (uint64, error)

    // AncientSize returns the ancient size of the specified category.
    AncientSize(kind string) (uint64, error)
}

AncientReader contains the methods required to read from immutable ancient data.

type AncientStore Uses

type AncientStore interface {
    AncientReader
    AncientWriter
    io.Closer
}

AncientStore contains all the methods required to allow handling different ancient data stores backing immutable chain data store.

type AncientWriter Uses

type AncientWriter interface {
    // AppendAncient injects all binary blobs belong to block at the end of the
    // append-only immutable table files.
    AppendAncient(number uint64, hash, header, body, receipt, td []byte) error

    // TruncateAncients discards all but the first n ancient data from the ancient store.
    TruncateAncients(n uint64) error

    // Sync flushes all in-memory ancient store data to disk.
    Sync() error
}

AncientWriter contains the methods required to write to immutable ancient data.

type Batch Uses

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 Batcher Uses

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 Uses

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 Uses

type Database interface {
    Reader
    Writer
    Batcher
    Iteratee
    Stater
    Compacter
    io.Closer
}

Database contains all the methods required by the high level database to not only access the key-value data store but also the chain freezer.

type Iteratee Uses

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
}

Iteratee wraps the NewIterator methods of a backing data store.

type Iterator Uses

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

    // 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 Uses

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 KeyValueStore Uses

type KeyValueStore interface {
    KeyValueReader
    KeyValueWriter
    Batcher
    Iteratee
    Stater
    Compacter
    io.Closer
}

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

type KeyValueWriter Uses

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 Reader Uses

type Reader interface {
    KeyValueReader
    AncientReader
}

Reader contains the methods required to read data from both key-value as well as immutable ancient data.

type Stater Uses

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.

type Writer Uses

type Writer interface {
    KeyValueWriter
    AncientWriter
}

Writer contains the methods required to write data to both key-value as well as immutable ancient data.

Directories

PathSynopsis
dbtest
leveldbPackage leveldb implements the key-value database layer based on LevelDB.
memorydbPackage memorydb implements the key-value database layer based on memory maps.

Package ethdb imports 1 packages (graph) and is imported by 1961 packages. Updated 2019-09-26. Refresh now. Tools for package owners.