Struct AncestryStore 

pub struct AncestryStore<S, B> { /* private fields */ }

Wraps a record Store and an ancestry BlobStore. On a committed put it also writes the record’s body.bytes() to the ancestry store; because Revision.hash == ContentHash::of(body.bytes()), each version’s body is later retrievable by its revision hash. get/list delegate unchanged.

Implementations

impl<S, B> AncestryStore<S, B>

pub fn new(inner: S, ancestry: B) -> Self

pub fn ancestry(&self) -> &B

The ancestry blob store (revision hash → body bytes), to hand to sync_with_ancestry.

pub fn inner(&self) -> &S

The wrapped record store.

Trait Implementations

impl<S: Store, B: BlobStore> Store for AncestryStore<S, B>

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, ) -> Pin<Box<dyn Future<Output = Result<Option<Record>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a record by key. Returns None for an absent key and for a tombstoned one: a delete is invisible on this surface, and only get_raw shows the tombstone. See ADR 0021.

fn put<'life0, 'async_trait>( &'life0 self, record: Record, expected: Option<Revision>, ) -> Pin<Box<dyn Future<Output = Result<PutResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Conditionally write record. expected is the revision the caller believes is current (None means “expect no existing record”). If the store’s current revision differs, returns PutResult::Conflict.

fn list<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 KeyPrefix, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordKey>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List keys matching prefix, excluding tombstoned keys. See list_raw for a listing that includes them.

fn delete_as<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, expected: Option<Revision>, author: Option<Identity>, ) -> Pin<Box<dyn Future<Output = Result<DeleteResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Conditionally delete the record at key. expected is the revision the caller believes is current: None deletes unconditionally; Some(rev) deletes only if the current revision matches, else DeleteResult::Conflict. Deleting an absent key is a no-op Deleted. Some(author) records who deleted (stores that write tombstones stamp it on the tombstone’s meta.author). See ADR 0018 and ADR 0021.

fn get_raw<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, ) -> Pin<Box<dyn Future<Output = Result<Option<Record>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Like get, but also returns tombstones. For replication (sync, pull, collection) only: consumers must use get. A store must never implement this by calling get, which would hide the deletions replication exists to carry. See ADR 0021.

fn list_raw<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 KeyPrefix, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordKey>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Like list, but also includes tombstoned keys. For replication only. See ADR 0021.

fn put_raw<'life0, 'async_trait>( &'life0 self, record: Record, expected: Option<Revision>, ) -> Pin<Box<dyn Future<Output = Result<PutResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Replication write: store record exactly as given, never re-stamping. A create (expected == None) that finds anything stored, tombstones included, is a Conflict carrying it. Sync and pull use this; consumers must use put. A store must never implement this by calling put, whose recreation rule would resurrect records mid-sync. See ADR 0021.

fn purge<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, expected: Revision, ) -> Pin<Box<dyn Future<Output = Result<DeleteResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Physically remove the record at key only if its current revision is expected; otherwise DeleteResult::Conflict. Absent is an idempotent Deleted. The only physical removal in the system: used by tombstone collection, which must pass the tombstone’s revision so a record recreated in the meantime survives. See ADR 0021.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 RecordKey, expected: Option<Revision>, ) -> Pin<Box<dyn Future<Output = Result<DeleteResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

delete_as without an author. Provided; stores implement delete_as.