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: Location) -> 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 upsert( &mut self, key: K, update: impl FnOnce(&mut V), ) -> Result<(), Error>

where V: Default,

Updates the value associated with the given key in the store, inserting a default value if the key does not already exist.

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: Location) -> 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<(Location, Option<V>)>, Error>

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

Errors

Returns Error if there is some underlying storage failure.

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) -> Location

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

pub fn is_empty(&self) -> bool

Whether the db currently has no active keys.

pub fn inactivity_floor_loc(&self) -> Location

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

Trait Implementations

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

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

fn op_count(&self) -> Location

The number of operations that have been applied to this db, including those that have been pruned and those that are not yet committed.

fn inactivity_floor_loc(&self) -> Location

Return the inactivity floor location. This is the location before which all operations are known to be inactive. Operations before this point can be safely pruned.

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

Get the value of key in the db, or None if it has no value.

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

Updates key to have value value. The operation is reflected in the snapshot, but will be subject to rollback until the next successful commit.

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

Delete key and its value from the db. Deleting a key that already has no value is a no-op. The operation is reflected in the snapshot, but will be subject to rollback until the next successful commit.

async fn commit(&mut self) -> 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.

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.

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

Prune historical operations prior to target_prune_loc. This does not affect the db’s root or current snapshot.

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

Close the db. Operations that have not been committed will be lost or rolled back on restart.

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

Destroy the db, removing all data from disk.