Struct DatabaseTransaction 

pub struct DatabaseTransaction<Manifest> { /* private fields */ }

A database transaction that accumulates low-level byte operations (writes and deletes) without immediately applying them to storage.

This struct is always available, but the commit method is only available when the “atomic” feature is enabled.

Implementations

impl<M: Manifest> DatabaseTransaction<M>

pub fn new<S: Storage>(database: &Database<S, M>) -> Self

Creates a new empty transaction. Should be used by Database::create_transaction.

pub fn new_with_serialization_config( serialization_config: Configuration, ) -> Self

pub fn insert<K: RecordKey<Record = R>, R>( &mut self, record: R, ) -> Result<K, SerializationError>

where R: DeriveKey<Key = K> + DatabaseEntry<Key = K>, M: Manifests<R>,

pub fn put<S: Storage, R: DatabaseEntry>( &mut self, record: R, database: &mut Database<S, M>, ) -> Result<R::Key, DatabaseError<S::StoreError>>

where R::Key: RecordKey<Record = R> + Incrementable + Ord, M: Manifests<R>,

pub fn write(&mut self, key: Vec<u8>, value: Vec<u8>)

Adds a write operation to the transaction.

If the same key is written multiple times, only the last value is kept. If a key is both written and deleted, the write takes precedence.

pub fn delete(&mut self, key: Vec<u8>)

Adds a delete operation to the transaction.

If a key is both written and deleted, the write takes precedence (so this delete will be ignored if the key was already written).

pub fn is_empty(&self) -> bool

Returns true if the transaction has no pending operations.

pub fn write_count(&self) -> usize

Returns the number of pending write operations.

pub fn delete_count(&self) -> usize

Returns the number of pending delete operations.

pub fn pending_writes(&self) -> impl Iterator<Item = &(Vec<u8>, Vec<u8>)>

Returns an iterator over the pending write operations.

pub fn pending_deletes(&self) -> impl Iterator<Item = &Vec<u8>>

Returns an iterator over the pending delete keys.

pub fn commit<S: AtomicStorage>( self, storage: &mut S, ) -> Result<Vec<Option<Vec<u8>>>, DatabaseError<S::StoreError>>

Commits all pending operations to the storage atomically.

Either all operations succeed, or none of them are applied. The transaction is consumed by this operation.

This method is only available when the “atomic” feature is enabled.

pub fn rollback(self)

Discards all pending operations without applying them. The transaction is consumed by this operation.

pub fn consume( self, ) -> (impl Iterator<Item = (Vec<u8>, Vec<u8>)>, impl Iterator<Item = Vec<u8>>)