Struct Keyless 

pub struct Keyless<F, E, V, C, H>
where
    F: Family,
    E: Context,
    V: ValueEncoding,
    C: Contiguous<Item = Operation<V>>,
    H: Hasher,
    Operation<V>: EncodeShared,
{ /* private fields */ }

A keyless authenticated database.

Implementations

impl<F: Family, E: Storage + Clock + Metrics, V: FixedValue, H: Hasher> Keyless<F, E, FixedEncoding<V>, Journal<E, Operation<FixedEncoding<V>>>, H>

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

Returns a Db initialized from cfg. Any uncommitted operations will be discarded and the state of the db will be as of the last committed operation.

impl<F: Family, E: Storage + Clock + Metrics, V: VariableValue, H: Hasher> Keyless<F, E, VariableEncoding<V>, Journal<E, Operation<VariableEncoding<V>>>, H>

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

Returns a Db initialized from cfg. Any uncommitted operations will be discarded and the state of the db will be as of the last committed operation.

impl<F, E, V, C, H> Keyless<F, E, V, C, H>

where F: Family, E: Context, V: ValueEncoding, C: Mutable<Item = Operation<V>> + Persistable<Error = Error>, H: Hasher, Operation<V>: EncodeShared,

pub async fn get(&self, loc: Location<F>) -> Result<Option<V::Value>, Error<F>>

Get the value at location loc in the database.

Errors

Returns Error::LocationOutOfBounds if loc >= self.bounds().await.end.

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

Returns the location of the last commit.

pub async fn bounds(&self) -> Range<Location<F>>

Return [start, end) where start and end - 1 are the Locations of the oldest and newest retained operations respectively.

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

Get the metadata associated with the last commit.

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

Return the root of the db.

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

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.

Errors

• Returns Error::Merkle with crate::merkle::Error::RangeOutOfBounds if start_loc

  = the number of operations.

• Returns Error::Journal with crate::journal::Error::ItemPruned if start_loc has been pruned.

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

Analogous to proof, but with respect to the state of the Merkle structure when it had op_count operations.

Errors

• Returns Error::Merkle with crate::merkle::Error::RangeOutOfBounds if start_loc

  = op_count or op_count > number of operations.

• Returns Error::Journal with crate::journal::Error::ItemPruned if start_loc has been pruned.

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

Prune historical operations prior to loc. This does not affect the db’s root.

Errors

• Returns Error::PruneBeyondMinRequired if loc > last commit point.

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

Rewind the database to size operations, where size is the location of the next append.

This rewinds both the operations journal and its Merkle structure to the historical state at size.

Errors

• Returns Error::Journal with crate::journal::Error::InvalidRewind if size is 0 or exceeds the current committed size.
• Returns Error::Journal with crate::journal::Error::ItemPruned if the operation at size - 1 has been pruned.
• Returns Error::UnexpectedData if the operation at size - 1 is not a commit.

Any error from this method is fatal for this handle. Rewind may mutate journal state before this method finishes updating in-memory rewind state. Callers must drop this database handle after any Err from rewind and reopen from storage.

A successful rewind is not restart-stable until a subsequent Self::commit or Self::sync.

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

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 commit(&self) -> Result<(), Error<F>>

Durably commit the journal state published by prior Keyless::apply_batch calls.

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

Destroy the db, removing all data from disk.

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

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

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

Create an initial batch::MerkleizedBatch from the committed DB state.

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

Apply a batch::MerkleizedBatch to the database.

A batch is valid only if every batch applied to the database since this batch’s ancestor chain was created is an ancestor of this batch. Applying a batch from a different fork returns Error::StaleBatch.

Returns the range of locations written.

This publishes the batch to the in-memory database state and appends it to the journal, but does not durably commit it. Call Keyless::commit or Keyless::sync to guarantee durability.