Struct AsyncVersionedMap 

pub struct AsyncVersionedMap<'a, S: AsyncStore> { /* private fields */ }

Async counterpart to VersionedMap for remote and browser stores.

Implementations

impl<'a, S: AsyncStore> AsyncVersionedMap<'a, S>

pub fn new(prolly: &'a AsyncProlly<S>, id: impl AsRef<[u8]>) -> Self

Create an async managed-map handle.

pub fn id(&self) -> &[u8]

Application map identifier.

pub fn head_name(&self) -> &[u8]

Full durable named-root key used for the current head.

pub fn versions_prefix(&self) -> &[u8]

Prefix containing this map’s immutable version roots.

pub fn version_root_name(&self, id: &MapVersionId) -> Vec<u8>

Full durable named-root key for one content-derived version.

impl<'a, S> AsyncVersionedMap<'a, S>

where S: AsyncStore + AsyncManifestStore, <S as AsyncStore>::Error: Send + Sync, <S as AsyncManifestStore>::Error: Send + Sync,

pub async fn head(&self) -> Result<Option<MapVersion>, Error>

Load current async head.

pub async fn version( &self, id: &MapVersionId, ) -> Result<Option<MapVersion>, Error>

Load a cataloged immutable version.

pub async fn snapshot(&self) -> Result<Option<AsyncMapSnapshot<'a, S>>, Error>

Pin current head for repeatable async reads.

pub async fn snapshot_at( &self, id: &MapVersionId, ) -> Result<Option<AsyncMapSnapshot<'a, S>>, Error>

Pin one cataloged historical version for repeatable async reads.

pub async fn subscribe( &self, ) -> Result<AsyncMapChangeSubscription<'a, S>, Error>

Start observing future async head transitions from the current head.

pub fn subscribe_from( &self, last_seen: Option<MapVersionId>, ) -> AsyncMapChangeSubscription<'a, S>

Resume async observation from a previously persisted version.

pub async fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Error>

Read one key from current head.

pub async fn get_large_value<B>( &self, blob_store: &B, key: &[u8], ) -> Result<Option<Vec<u8>>, Error>

where B: AsyncBlobStore, B::Error: Send + Sync,

Read one inline or blob-backed value from current head.

impl<S> AsyncVersionedMap<'_, S>

where S: AsyncStore + AsyncManifestStore + AsyncManifestStoreScan, <S as AsyncStore>::Error: Send + Sync, <S as AsyncManifestStore>::Error: Send + Sync,

pub async fn versions_page( &self, cursor: Option<&MapVersionCursor>, limit: usize, ) -> Result<MapVersionPage, Error>

List a bounded page of cataloged versions in stable version-ID order.

Unlike Self::versions, this method never needs to enumerate other maps’ roots. Cloud backends can implement it as one bounded range query.

pub async fn versions(&self) -> Result<Vec<MapVersion>, Error>

List cataloged versions newest first.

impl<S> AsyncVersionedMap<'_, S>

where S: AsyncStore + AsyncManifestStore + AsyncTransactionalStore, <S as AsyncStore>::Error: Send + Sync, <S as AsyncManifestStore>::Error: Send + Sync,

pub async fn diff( &self, base: &MapVersionId, target: &MapVersionId, ) -> Result<Vec<Diff>, Error>

Diff two cataloged immutable versions.

pub async fn diff_page( &self, base: &MapVersionId, target: &MapVersionId, cursor: &RangeCursor, end: Option<&[u8]>, limit: usize, ) -> Result<DiffPage, Error>

Read one resumable key-cursor page between cataloged versions.

pub async fn structural_diff_page( &self, base: &MapVersionId, target: &MapVersionId, cursor: Option<&StructuralDiffCursor>, limit: usize, ) -> Result<StructuralDiffPage, Error>

Read one resumable structural page between cataloged versions.

pub async fn changes_since( &self, base: &MapVersionId, ) -> Result<Vec<Diff>, Error>

Diff one cataloged version against current head.

pub async fn apply(&self, mutations: Vec<Mutation>) -> Result<MapVersion, Error>

Atomically apply a batch and retry optimistic head conflicts.

pub async fn apply_at_millis( &self, mutations: Vec<Mutation>, timestamp_millis: u64, ) -> Result<MapVersion, Error>

Atomically apply a batch with an explicit catalog timestamp.

pub async fn apply_if( &self, expected: Option<&MapVersionId>, mutations: Vec<Mutation>, ) -> Result<VersionedMapUpdate, Error>

Apply a batch only when expected is still the current version.

pub async fn apply_if_at_millis( &self, expected: Option<&MapVersionId>, mutations: Vec<Mutation>, timestamp_millis: u64, ) -> Result<VersionedMapUpdate, Error>

Apply a batch only when expected is still the current version, with an explicit catalog timestamp.

pub async fn restore_if( &self, expected: Option<&MapVersionId>, target: &MapVersionId, ) -> Result<VersionedMapUpdate, Error>

Move head to an existing version when expected is still current.

The target must remain in the immutable version catalog. A concurrent head movement is reported as VersionedMapUpdate::Conflict.

pub async fn put( &self, key: impl Into<Vec<u8>>, value: impl Into<Vec<u8>>, ) -> Result<MapVersion, Error>

Put one key asynchronously.

pub async fn put_large_value<B>( &self, blob_store: &B, key: impl Into<Vec<u8>>, value: impl Into<Vec<u8>>, config: LargeValueConfig, ) -> Result<MapVersion, Error>

where B: AsyncBlobStore, B::Error: Send + Sync,

Put one value, offloading large bytes, and retry head conflicts.

pub async fn delete(&self, key: impl Into<Vec<u8>>) -> Result<MapVersion, Error>

Delete one key asynchronously.

pub async fn edit( &self, edit: impl FnOnce(&mut VersionedMapEditor), ) -> Result<MapVersion, Error>

Collect and apply several asynchronous managed-map edits.

impl<S> AsyncVersionedMap<'_, S>

where S: AsyncStore + AsyncManifestStore + AsyncManifestStoreScan + AsyncTransactionalStore, <S as AsyncStore>::Error: Send + Sync, <S as AsyncManifestStore>::Error: Send + Sync,

pub async fn prune_versions( &self, keep_latest: usize, ) -> Result<VersionPruneResult, Error>

Keep the newest keep_latest versions plus the current head.

pub async fn keep_last(&self, count: usize) -> Result<VersionPruneResult, Error>

Retain the newest count versions plus the current head.

pub async fn keep_for( &self, max_age: Duration, ) -> Result<VersionPruneResult, Error>

Retain versions newer than max_age plus the current head.

pub async fn keep_for_at( &self, now_millis: u64, max_age: Duration, ) -> Result<VersionPruneResult, Error>

Deterministic form of AsyncVersionedMap::keep_for with an explicit clock.

pub async fn keep_versions<I, V>( &self, ids: I, ) -> Result<VersionPruneResult, Error>

where I: IntoIterator<Item = V>, V: Borrow<MapVersionId>,

Retain an explicit version set plus the current head.

Missing requested IDs are rejected so a typo cannot silently discard more history than intended.