Interfaces to work with persisted data.
Database is a container for data persistence. Internally, a
a collection of named key-value stores (aka column families)
with reading isolation and atomic writes. The database is assumed to be embedded,
that is, the application process has exclusive access to the DB during operation.
You can interact with the
Database from multiple threads by cloning its instance.
Snapshots and forks facilitate access to the database.
If you need to read the data, you can create a
Snapshot using the
Database instance. Snapshots provide read isolation, so you are guaranteed to work
with consistent values even if the data in the database changes between reads.
provides all the necessary methods for reading data from the database, so
is used as a storage view for creating a read-only representation of the indexes.
If you need to make changes to the database, you need to create a
fork method of the
Fork provides read isolation,
but also allows creating a sequence of changes to the database that are specified
Patch. A patch can be atomically
merged into a database. Different threads
If you need to use your own data types as keys or values in the storage, you need to implement
BinaryValue traits respectively. These traits have already been
implemented for most standard types.
Indexes are structures representing data collections stored in the database. This concept is similar to tables in relational databases. The interfaces of the indexes are similar to ordinary collections (like arrays, maps and sets).
Each index occupies a certain set of keys in a single column family of the
On the other hand, multiple indexes can be stored in the same column family, provided
that their key spaces do not intersect. Isolation is commonly achieved with the help
Groups or keyed
This crate provides the following index types:
Entryis a specific index that stores only one value. Useful for global values, such as configuration. Similar to a combination of
ListIndexis a list of items stored in a sequential order. Similar to
SparseListIndexis a list of items stored in a sequential order. Similar to
ListIndex, but may contain indexes without elements.
MapIndexis a map of keys and values. Similar to
ValueSetIndexare sets of items, similar to
The database provides tooling for data migrations. With the help of migration, it is possible to gradually accumulate changes to a set of indexes (including across process restarts) and then atomically apply or discard these changes.
High-level access to database.
Access generalizations, mainly useful for bindings.
An implementation of
Validation helpers for index names.
Hex conversions for the given
Options for the database.
The error type for I/O operations with the
A combination of a database snapshot and changes on top of it.
Represents the address of an index in the database.
Lazily initialized object in the database.
A set of changes that can be atomically applied to a
Readonly wrapper for a
Resolved address of a view.
Database implementation on top of
This in-memory database is only used for testing and experimenting; is not designed to operate under load in production.
Type of an index supported by
Converts index access to a readonly presentation. The conversion operation is cheap.
A type that can be (de)serialized as a key in the blockchain storage.
A type that can be (de)serialized as a value in the blockchain storage.
Low-level storage backend implementing a collection of named key-value stores (aka column families).
Extension trait for
A trait that defines a streaming iterator over storage view entries. Unlike
A read-only snapshot of a storage backend.
A generalized iterator over the storage views.