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 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) -> Result<(), Error>

Commits all uncommitted operations to the store, making them persistent and recoverable.

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.