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

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 const fn root(&self) -> H::Digest

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) -> CompactTarget<F, H::Digest>

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

This reflects the most recently applied batch. The target remains non-durable until a covering Self::commit, Self::sync, or Self::start_sync completes.

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 validate_batch( &self, batch: &MerkleizedBatch<F, H::Digest, K, V, S>, ) -> Result<(), Error<F>>

Check that batch can be applied to the database in its current state, without applying it.

Self::apply_batch runs the same validation but consumes the database when it fails; callers that want to reject a bad batch and keep the handle can check first.

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

Apply a merkleized batch to the database.

Returns the range of locations written. The state is updated in memory and appended to the witness journal. Call Self::commit or Self::sync, or await the handle returned by Self::start_sync, to make the applied state durable.

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 start_sync(self) -> Result<(Self, Handle<()>), Error<F>>

Begin durably persisting the current db state to disk.

Awaiting the returned Handle provides the same durability guarantee as Self::commit, plus a best-effort attempt to bound the recovery needed on reopen. Use Self::sync to guarantee none is needed. A new sync waits for the prior sync before starting. Failures of the deferred durability work surface on the returned handle and the next durability operation.

pub async fn commit(self) -> Result<Self, 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(self) -> Result<Self, Error<F>>

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

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

where F: Family,

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

Errors

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

pub async fn prune( self, pruning_boundary: Location<F>, ) -> Result<Self, 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 applied to the witness journal.

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 Journal = Memory<F, E, Operation<F, K, V>>

type Config = Config<Cfg, S>

type Digest = <H as Hasher>::Digest

type Context = E

type Hasher = H

async fn from_sync_result( context: Self::Context, config: Self::Config, log: Self::Journal, pinned_nodes: Option<Vec<Self::Digest>>, range: NonEmptyRange<Location<F>>, _apply_batch_size: NonZeroU64, ) -> Result<Self, Error<F>>

Build a database from the journal and pinned nodes populated by the sync engine.

async fn persist_sync_result(self) -> Result<Self, Error<F>>

Persist any state that must remain provisional until the engine verifies the rebuilt root.

async fn local_pinned_nodes( _context: Self::Context, _config: &Self::Config, _target: &Target<F, Self::Digest>, _journal: &Self::Journal, ) -> Result<Option<Vec<Self::Digest>>, Error<F>>

Return locally available pinned nodes for the target, if persisted local state can authenticate them.

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

Get the root digest of the database for verification

impl<F, E, K, V, H, C, S: Strategy> Debug for Db<F, E, K, V, H, C, S>

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

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

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

type Family = F

The merkle family backing this source’s proofs.

type Digest = <H as Hasher>::Digest

The digest type used in this source’s proofs.

type Op = Operation<F, K, V>

The type of operations this source yields.

type Error = Error<F>

Why this source could not answer.

async fn serve( &self, request: Request<F>, ) -> Result<(Response<F, Self::Op, H::Digest>, FeedbackTx), Self::Error>

Serve a request.