Struct Store 

pub struct Store<E, K, V, T>
where
    E: RStorage + Clock + Metrics,
    K: Array,
    V: Codec,
    T: Translator,
{ /* private fields */ }

An unauthenticated key-value database based off of an append-only VJournal of operations.

Implementations

impl<E, K, V, T> Store<E, K, V, T>

where E: RStorage + Clock + Metrics, K: Array, V: Codec, T: Translator,

pub async fn init( context: E, cfg: Config<T, <Operation<K, V> as Read>::Cfg>, ) -> Result<Self, Error>

Initializes a new Store database with the given configuration.

Rollback

Any uncommitted operations will be rolled back if the Store was previously closed without committing.

pub async fn get(&self, key: &K) -> Result<Option<V>, Error>

Gets the value associated with the given key in the store.

If the key does not exist, returns Ok(None).

pub async fn get_loc(&self, loc: u64) -> Result<Option<V>, Error>

Get the value of the operation with location loc in the db. Returns Error::OperationPruned if loc precedes the oldest retained location. The location is otherwise assumed valid.

pub async fn update(&mut self, key: K, value: V) -> Result<(), Error>

Updates the value associated with the given key in the store.

The operation is immediately visible in the snapshot for subsequent queries, but remains uncommitted until Store::commit is called. Uncommitted operations will be rolled back if the store is closed without committing.

pub async fn delete(&mut self, key: K) -> Result<(), Error>

Deletes the value associated with the given key in the store. If the key has no value, the operation is a no-op.

pub async fn commit(&mut self, metadata: Option<V>) -> Result<(), Error>

Commit any pending operations to the database, ensuring their durability upon return from this function. Also raises the inactivity floor according to the schedule. Caller can associate an arbitrary metadata value with the commit.

Failures after commit (but before sync or close) may still require reprocessing to recover the database on restart.

pub async fn sync(&mut self) -> Result<(), Error>

Sync all database state to disk. While this isn’t necessary to ensure durability of committed operations, periodic invocation may reduce memory usage and the time required to recover the database on restart.

pub async fn prune(&mut self, target_prune_loc: u64) -> Result<(), Error>

Prune historical operations that are behind the inactivity floor. This does not affect the state root.

Panics

Panics if target_prune_loc is greater than the inactivity floor.

pub async fn get_metadata(&self) -> Result<Option<(u64, Option<V>)>, Error>

Get the location and metadata associated with the last commit, or None if no commit has been made.

pub async fn close(self) -> Result<(), Error>

Closes the store. Any uncommitted operations will be lost if they have not been committed via Store::commit.

pub async fn destroy(self) -> Result<(), Error>

Destroys the store permanently, removing all persistent data associated with it.

Warning

This operation is irreversible. Do not call this method unless you are sure you want to delete all data associated with this store permanently!

pub fn op_count(&self) -> u64

Returns the number of operations that have been applied to the store, including those that are not yet committed.

pub fn inactivity_floor_loc(&self) -> u64

Return the inactivity floor location. This is the location before which all operations are known to be inactive.