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.

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.

impl<S> AsyncVersionedMap<'_, S>

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

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

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