Struct CompactDb 

pub struct CompactDb<F, E, V, H, S: Strategy>
where
    F: Family,
    E: Context,
    V: ValueEncoding,
    H: Hasher,
    Operation<F, V>: EncodeShared + Read,
{ /* private fields */ }

A keyless authenticated db that discards historical operations, retaining only a witness for each applied batch.

Implementations

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

where F: Family, E: Context, V: ValueEncoding, H: Hasher, S: Strategy, Operation<F, V>: EncodeShared + Read,

pub async fn init( context: E, cfg: Config<<Operation<F, V> as Read>::Cfg, S>, max_size: Option<Location<F>>, ) -> Result<Self, Error<F>>

Initialize from a retained witness. Some(max_size) selects the latest retained witness for at most max_size operations. None selects the latest retained state.

Fresh storage receives a durable bootstrap commit and witness.

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

Return the root of the db.

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

Return the inactivity floor declared by the last committed batch.

pub const 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 const 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, 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, V, S>>

Create an owned merkleized batch representing the current applied state.

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

Apply a merkleized batch to the database.

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

Returns Error::StaleBatch if the database is at neither the batch’s recorded database boundary nor an ancestor’s tip.

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

Bounded initialization and compact sync can only use witnesses that survive. 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.

Trait Implementations

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

where F: Family, E: Context, V: Codec, H: Hasher, S: Strategy, Operation<F, V>: EncodeShared + Read,

type Family = F

type Op = Operation<F, V>

type Journal = Memory<F, E, Operation<F, V>>

type Config = Config<<Operation<F, V> as Read>::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, V, H, S: Strategy> Debug for Db<F, E, V, H, S>

where F: Family, E: Context, V: ValueEncoding, H: Hasher, Operation<F, V>: EncodeShared + Read,

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

Formats the value using the given formatter.

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

where F: Family, E: Context, V: ValueEncoding, H: Hasher, Operation<F, V>: EncodeShared + Read, 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, 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<Self>

Serves a response with optional Feedback for reporting its validity.