Struct Db 

pub struct Db<E, K, V, T, S = Durable>
where
    E: Storage + Clock + Metrics,
    K: Array,
    V: VariableValue,
    T: Translator,
    S: State,
{
    pub inactivity_floor_loc: Location,
    pub last_commit_loc: Location,
    pub state: S,
    /* private fields */
}

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

Fields

inactivity_floor_loc: Location

A location before which all operations are “inactive” (that is, operations before this point are over keys that have been updated by some operation at or after this point).

last_commit_loc: Location

The location of the last commit operation.

state: S

The state of the store.

Implementations

impl<E, K, V, T, S> Db<E, K, V, T, S>

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

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

impl<E, K, V, T> Db<E, K, V, T, Durable>

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 Db with the given configuration.

pub fn into_dirty(self) -> Db<E, K, V, T, NonDurable>

Convert this clean store into its dirty counterpart for making updates.

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

Destroy the db, removing all data from disk.

impl<E, K, V, T> Db<E, K, V, T, NonDurable>

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

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( self, metadata: Option<V>, ) -> Result<(Db<E, K, V, T, Durable>, 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.

Note that even if no operations were added since the last commit, this is a root-state changing operation.

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

Consumes this dirty store and returns a clean one.

Trait Implementations

impl<E, K, V, T> Batchable for Db<E, K, V, T, NonDurable>

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

async fn write_batch<'a, Iter>( &'a mut self, iter: Iter, ) -> Result<(), Self::Error>

where Iter: Iterator<Item = (Self::Key, Option<Self::Value>)> + Send + 'a,

Writes a batch of changes to the store.

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

where Self: Sized + Sync, Self::Value: Send + Sync,

Returns a new empty batch of changes.

impl<E, K, V, T> Deletable for Db<E, K, V, T, NonDurable>

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, S> Gettable for Db<E, K, V, T, S>

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

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, S> LogStore for Db<E, K, V, T, S>

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

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> Persistable for Db<E, K, V, T, Durable>

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

type Error = Error

The error type returned when there is a failure from the underlying storage system.

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

Durably persist the structure, guaranteeing the current state will survive a crash.

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

Durably persist the structure, guaranteeing the current state will survive a crash, and that no recovery will be needed on startup.

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

Destroy the structure, removing all associated storage.

impl<E, K, V, T, S> PrunableStore for Db<E, K, V, T, S>

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

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

Prune historical operations prior to loc.

impl<E, K, V, T> Updatable for Db<E, K, V, T, NonDurable>

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 create<'a>( &'a mut self, key: Self::Key, value: Self::Value, ) -> impl Future<Output = Result<bool, Self::Error>> + Send + use<'a, Self>

where Self: Send,

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

fn upsert<'a, F>( &'a mut self, key: Self::Key, update: F, ) -> impl Future<Output = Result<(), Self::Error>> + Send + use<'a, Self, F>

where Self: Send, Self::Value: Default, F: FnOnce(&mut Self::Value) + Send + 'a,

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