Struct CompactDb 

pub struct CompactDb<F, E, K, V, H, C, S: Strategy>
where
    F: Family,
    E: Context,
    K: Key,
    V: ValueEncoding,
    H: Hasher,
    Operation<F, K, V>: EncodeShared + Read<Cfg = C>,
    C: Clone + Send + Sync + 'static,
{ /* private fields */ }

An immutable authenticated db that discards historical operations, retaining only a witness for each synced commit.

Implementations

impl<F, E, K, V, H, C, S> Db<F, E, K, V, H, C, S>

where F: Family, E: Context, K: Key, V: ValueEncoding, H: Hasher, S: Strategy, Operation<F, K, V>: EncodeShared + Read<Cfg = C>, C: Clone + Send + Sync + 'static,

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

where F: Family,

Return the root of the db.

pub const fn strategy(&self) -> &S

Return a reference to the merkleization strategy.

pub const fn last_commit_loc(&self) -> Location<F>

Return the location of the last commit.

pub const fn inactivity_floor_loc(&self) -> Location<F>

Return the inactivity floor declared by the last committed batch.

pub fn size(&self) -> Location<F>

Return the location of the next operation appended to this db.

pub fn get_metadata(&self) -> Option<V::Value>

Get the metadata associated with the last commit.

pub fn target(&self) -> Target<F, H::Digest>

Return the compact-sync target described by the current witness.

This reflects the last durably persisted commit, which may lag behind live in-memory mutations until Self::commit or Self::sync is called.

pub fn new_batch(&self) -> UnmerkleizedBatch<F, H, K, V, S>

Create a new speculative batch of operations with this database as its parent.

pub fn to_batch(&self) -> Arc<MerkleizedBatch<F, H::Digest, K, V, S>>

where F: Family,

Create an owned merkleized batch representing the current applied state.

pub fn apply_batch( &mut self, batch: Arc<MerkleizedBatch<F, H::Digest, K, V, S>>, ) -> Result<Range<Location<F>>, Error<F>>

Apply a merkleized batch to the database.

Returns the range of locations written. The state is updated in memory only; call Self::commit or Self::sync to persist.

Errors

• Error::StaleBatch if the batch is detected as stale (see crate::qmdb::batch_chain for more details).
• Error::FloorRegressed if any commit in the chain declares a floor below the previous commit’s floor.
• Error::FloorBeyondSize if any commit in the chain declares a floor beyond its own commit location.

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

Durably persist the current db state to disk. This is faster than Self::sync but reopen may need to replay the witness journal’s tail to recover.

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

Durably persist the current db state to disk, also persisting journal metadata to minimize recovery work on reopen.

pub async fn rewind(&mut self, target: Location<F>) -> Result<(), Error<F>>

where F: Family,

Rewind the db to the synced commit with exactly target operations, discarding any uncommitted batches and any later commits. The rewind is made durable before this method returns.

Errors

Returns crate::merkle::Error::RewindBeyondHistory (wrapped as Error::Merkle) if no retained commit has exactly target operations (never synced, or pruned).

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

Drop witnesses for commits with fewer than pruning_boundary operations. Some witness below the boundary may survive.

Pruning bounds how far back Self::rewind can reach; the current commit’s witness always survives. The prune is made durable before this method returns.

Errors

Fails if a compact-sync import has not yet been persisted by Self::commit or Self::sync.

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

Destroy all persisted state associated with this database.

impl<F: Family, E: Context, K: Array, V: FixedValue, H: Hasher, S: Strategy> Db<F, E, K, FixedEncoding<V>, H, (), S>

pub async fn init(context: E, cfg: CompactConfig<S>) -> Result<Self, Error<F>>

Returns a CompactDb initialized from cfg.

impl<F: Family, E: Context, K: Key, V: VariableValue, H: Hasher, C: Clone + Send + Sync + 'static, S: Strategy> Db<F, E, K, VariableEncoding<V>, H, C, S>

where Operation<F, K, V>: Read<Cfg = C>,

pub async fn init( context: E, cfg: CompactConfig<C, S>, ) -> Result<Self, Error<F>>

Returns a CompactDb initialized from cfg.

Trait Implementations

impl<F, E, K, V, H, Cfg, S> Database for CompactDb<F, E, K, V, H, Cfg, S>

where F: Family, E: Context, K: Key, V: ValueEncoding, H: Hasher, S: Strategy, Operation<F, K, V>: EncodeShared + Read<Cfg = Cfg>, Cfg: Clone + Send + Sync + 'static,

type Family = F

type Op = Operation<F, K, V>

type Config = Config<Cfg, S>

type Digest = <H as Hasher>::Digest

type Context = E

type Hasher = H

async fn from_validated_state( context: Self::Context, config: Self::Config, state: ValidatedState<Self::Family, Self::Op, Self::Digest>, ) -> Result<Self, Error<F>>

Build a database from authenticated state in memory.

fn inactivity_floor(op: &Self::Op) -> Option<Location<Self::Family>>

Return the inactivity floor if the operation is a commit.

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

Get the root digest for final verification.

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

Persist the compact-initialized state once the caller has verified its root.