Struct Store 

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

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

Implementations

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

where E: Storage + Clock + Metrics, K: Array, V: VariableValue, 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>

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

pub const fn is_empty(&self) -> bool

Whether the db currently has no active keys.

pub const 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.

pub const 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.

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

Get the metadata associated with the last commit.

pub 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.

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

Creates a new key-value pair in the db. The operation is reflected in the snapshot, but will be subject to rollback until the next successful commit. Returns true if the key was created, false if it already existed.

pub async fn delete(&mut self, key: K) -> Result<bool, 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. Returns true if the key was deleted, false if it was already inactive.

pub async fn commit( &mut self, metadata: Option<V>, ) -> Result<Range<Location>, 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. Returns the (start_loc, end_loc] location range of committed operations. The end of the returned range includes the commit operation itself, and hence will always be equal to op_count.

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

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

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

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

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

Destroy the db, removing all data from disk.

Trait Implementations

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

where E: Storage + Clock + Metrics, K: Array, V: VariableValue, T: Translator,

fn start_batch(&self) -> Batch<'_, Self::Key, Self::Value, Self>

where Self: Sized,

Returns a new empty batch of changes.

fn write_batch( &mut self, iter: impl Iterator<Item = (Self::Key, Option<Self::Value>)>, ) -> impl Future<Output = Result<(), Error>>

Writes a batch of changes to the database.

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

where E: Storage + Clock + Metrics, K: Array, V: VariableValue, T: Translator,

type Value = V

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_metadata(&self) -> Result<Option<V>, Error>

Get the metadata associated with the last commit.

fn is_empty(&self) -> bool

Returns true if there are no active keys in the database.

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

where E: Storage + Clock + Metrics, K: Array, V: VariableValue, T: Translator,

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

Prune historical operations prior to prune_loc.

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

where E: Storage + Clock + Metrics, K: Array, V: VariableValue, T: Translator,

type Key = K

type Value = V

type Error = Error

async fn get(&self, key: &Self::Key) -> Result<Option<Self::Value>, Self::Error>

Get the value of a key.

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

where E: Storage + Clock + Metrics, K: Array, V: VariableValue, T: Translator,

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

Delete the value of a key.

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

where E: Storage + Clock + Metrics, K: Array, V: VariableValue, T: Translator,

async fn update( &mut self, key: Self::Key, value: Self::Value, ) -> Result<(), Self::Error>

Update the value of a key.

fn upsert( &mut self, key: Self::Key, update: impl FnOnce(&mut Self::Value), ) -> impl Future<Output = Result<(), Self::Error>>

where Self::Value: Default,

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

fn create( &mut self, key: Self::Key, value: Self::Value, ) -> impl Future<Output = Result<bool, Self::Error>>

Creates a new key-value pair in the db. Returns true if the key was created, false if it already existed.

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

where E: Storage + Clock + Metrics, K: Array, V: VariableValue, T: Translator,

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

Commit the store to disk, ensuring all changes are durably persisted.

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

Destroy the store, removing all persisted data.