Struct OptimisticTransaction

pub struct OptimisticTransaction<K, V, S: AsyncSpawner> { /* private fields */ }

A optimistic concurrency control transaction over the SerializableDb.

Implementations

impl<K, V, S> OptimisticTransaction<K, V, S>

where K: CheapClone + Ord + Send + Sync + 'static, V: Send + Sync + 'static, S: AsyncSpawner,

pub async fn commit( &mut self, ) -> Result<(), WtmError<Infallible, Infallible, Infallible>>

Commits the transaction, following these steps:

1. If there are no writes, return immediately.

2. Check if read rows were updated since txn started. If so, return TransactionError::Conflict.

3. If no conflict, generate a commit timestamp and update written rows’ commit ts.

4. Batch up all writes, write them to database.

5. If callback is provided, database will return immediately after checking for conflicts. Writes to the database will happen in the background. If there is a conflict, an error will be returned and the callback will not run. If there are no conflicts, the callback will be called in the background upon successful completion of writes or any error during write.

impl<K, V, S> OptimisticTransaction<K, V, S>

where K: CheapClone + Ord + Send + Sync + 'static, V: Send + Sync + 'static, S: AsyncSpawner,

pub async fn commit_with_task<Fut, E, R>( &mut self, callback: impl FnOnce(Result<(), E>) -> Fut + Send + 'static, ) -> Result<S::JoinHandle<R>, WtmError<Infallible, Infallible, E>>

where E: Error + Send, Fut: Future<Output = R> + Send + 'static, R: Send + 'static,

Acts like commit, but takes a callback, which gets run via a thread to avoid blocking this function. Following these steps:

1. If there are no writes, return immediately, callback will be invoked.

2. Check if read rows were updated since txn started. If so, return TransactionError::Conflict.

3. If no conflict, generate a commit timestamp and update written rows’ commit ts.

4. Batch up all writes, write them to database.

5. Return immediately after checking for conflicts. If there is a conflict, an error will be returned immediately and the callback will not run. If there are no conflicts, the callback will be called in the background upon successful completion of writes or any error during write.

impl<K, V, S> OptimisticTransaction<K, V, S>

where K: CheapClone + Ord, S: AsyncSpawner,

pub fn version(&self) -> u64

Returns the read version of the transaction.

pub fn rollback( &mut self, ) -> Result<(), TransactionError<Infallible, Infallible>>

Rollback the transaction.

pub fn contains_key( &mut self, key: &K, ) -> Result<bool, TransactionError<Infallible, Infallible>>

Returns true if the given key exists in the database.

pub fn get<'a, 'b: 'a>( &'a mut self, key: &'b K, ) -> Result<Option<Ref<'a, K, V>>, TransactionError<Infallible, Infallible>>

Get a value from the database.

pub fn insert( &mut self, key: K, value: V, ) -> Result<(), TransactionError<Infallible, Infallible>>

Insert a new key-value pair.

pub fn remove( &mut self, key: K, ) -> Result<(), TransactionError<Infallible, Infallible>>

Remove a key.

pub fn iter( &mut self, ) -> Result<TransactionIter<'_, K, V, BTreeCm<K>>, TransactionError<Infallible, Infallible>>

Iterate over the entries of the write transaction.

pub fn iter_rev( &mut self, ) -> Result<WriteTransactionRevIter<'_, K, V, BTreeCm<K>>, TransactionError<Infallible, Infallible>>

Iterate over the entries of the write transaction in reverse order.

pub fn range<'a, Q, R>( &'a mut self, range: R, ) -> Result<TransactionRange<'a, Q, R, K, V, BTreeCm<K>>, TransactionError<Infallible, Infallible>>

where K: Borrow<Q>, R: RangeBounds<Q> + 'a, Q: Ord + ?Sized,

Returns an iterator over the subset of entries of the database.

pub fn range_rev<'a, Q, R>( &'a mut self, range: R, ) -> Result<WriteTransactionRevRange<'a, Q, R, K, V, BTreeCm<K>>, TransactionError<Infallible, Infallible>>

where K: Borrow<Q>, R: RangeBounds<Q> + 'a, Q: Ord + ?Sized,

Returns an iterator over the subset of entries of the database in reverse order.