Struct Immutable 

pub struct Immutable<E: RStorage + Clock + Metrics, K: Array, V: VariableValue, H: CHasher, T: Translator, S: State<DigestOf<H>> = Clean<DigestOf<H>>> { /* private fields */ }

An authenticated database that only supports adding new keyed values (no updates or deletions), where values can have varying sizes.

Implementations

impl<E: RStorage + Clock + Metrics, K: Array, V: VariableValue, H: CHasher, T: Translator, S: State<DigestOf<H>>> Immutable<E, K, V, H, T, S>

pub fn oldest_retained_loc(&self) -> Location

Return the oldest location that remains retrievable.

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 or its corresponding operation has been pruned.

pub fn op_count(&self) -> Location

Get the number of operations that have been applied to this db, including those that are not yet committed.

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

Get the metadata associated with the last commit.

impl<E: RStorage + Clock + Metrics, K: Array, V: VariableValue, H: CHasher, T: Translator> Immutable<E, K, V, H, T, Clean<H::Digest>>

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

Returns an Immutable qmdb initialized from cfg. Any uncommitted log operations will be discarded and the state of the db will be as of the last committed operation.

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

Returns an Immutable built from the config and sync data in cfg.

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

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

Errors

• Returns Error::PruneBeyondMinRequired if prune_loc > inactivity floor.
• Returns crate::mmr::Error::LocationOverflow if prune_loc > crate::mmr::MAX_LOCATION.

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

Sets key to have value value, assuming key hasn’t already been assigned. The operation is reflected in the snapshot, but will be subject to rollback until the next successful commit. Attempting to set an already-set key results in undefined behavior.

Any keys that have been pruned and map to the same translated key will be dropped during this call.

pub const fn root(&self) -> H::Digest

Return the root of the db.

pub async fn proof( &self, start_index: Location, max_ops: NonZeroU64, ) -> Result<(Proof<H::Digest>, Vec<Operation<K, V>>), Error>

Generate and return:

1. a proof of all operations applied to the db in the range starting at (and including) location start_loc, and ending at the first of either:
   • the last operation performed, or
   • the operation max_ops from the start.
2. the operations corresponding to the leaves in this range.

pub async fn historical_proof( &self, op_count: Location, start_loc: Location, max_ops: NonZeroU64, ) -> Result<(Proof<H::Digest>, Vec<Operation<K, V>>), Error>

Analogous to proof but with respect to the state of the database when it had op_count operations.

Errors

Returns crate::mmr::Error::LocationOverflow if op_count or start_loc > crate::mmr::MAX_LOCATION. Returns crate::mmr::Error::RangeOutOfBounds if op_count > number of operations, or if start_loc >= op_count. Returns Error::OperationPruned if start_loc has been pruned.

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

Close the db. Operations that have not been committed will be lost.

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

Destroy the db, removing all data from disk.

pub fn into_dirty(self) -> Immutable<E, K, V, H, T, Dirty>

Convert this database into its dirty counterpart for batched updates.

impl<E: RStorage + Clock + Metrics, K: Array, V: VariableValue, H: CHasher, T: Translator> Immutable<E, K, V, H, T, Dirty>

pub fn merkleize(self) -> Immutable<E, K, V, H, T, Clean<H::Digest>>

Merkleize the database and compute the root digest.

Trait Implementations

impl<E: RStorage + Clock + Metrics, K: Array, V: VariableValue, H: CHasher, T: Translator> CleanStore for Immutable<E, K, V, H, T, Clean<H::Digest>>

type Digest = <H as Hasher>::Digest

The digest type used for authentication.

type Operation = Operation<K, V>

The operation type stored in the log.

type Dirty = Immutable<E, K, V, H, T, Dirty>

The dirty state type that this clean store transitions to.

fn root(&self) -> Self::Digest

Returns the root digest of the authenticated store.

async fn proof( &self, start_loc: Location, max_ops: NonZeroU64, ) -> Result<(Proof<Self::Digest>, Vec<Self::Operation>), Error>

Generate and return:

async fn historical_proof( &self, historical_size: Location, start_loc: Location, max_ops: NonZeroU64, ) -> Result<(Proof<Self::Digest>, Vec<Self::Operation>), Error>

Generate and return:

fn into_dirty(self) -> Self::Dirty

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

impl<E: RStorage + Clock + Metrics, K: Array, V: VariableValue, H: CHasher, T: Translator> DirtyStore for Immutable<E, K, V, H, T, Dirty>

type Digest = <H as Hasher>::Digest

The digest type used for authentication.

type Operation = Operation<K, V>

The operation type stored in the log.

type Clean = Immutable<E, K, V, H, T>

The clean state type that this dirty store transitions to.

async fn merkleize(self) -> Result<Self::Clean, Error>

Merkleize the store and compute the root digest.

impl<E: RStorage + Clock + Metrics, K: Array, V: VariableValue, H: CHasher, T: Translator, S: State<DigestOf<H>>> LogStore for Immutable<E, K, V, H, T, S>

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.

fn is_empty(&self) -> bool

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

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

Get the metadata associated with the last commit.

impl<E: RStorage + Clock + Metrics, K: Array, V: VariableValue, H: CHasher, T: Translator> Store for Immutable<E, K, V, H, T, Clean<H::Digest>>

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.