Struct Transaction

pub struct Transaction<'a> {
    pub allocator_reservation: Option<&'a Reservation>,
    pub metadata_reservation: MetadataReservation,
    /* private fields */
}

A transaction groups mutation records to be committed as a group.

Fields

allocator_reservation: Option<&'a Reservation>

If set, an allocator reservation that should be used for allocations.

metadata_reservation: MetadataReservation

The reservation for the metadata for this transaction.

Implementations

impl<'a> Transaction<'a>

pub async fn new( txn_guard: TxnGuard<'a>, options: Options<'a>, txn_locks: LockKeys, ) -> Result<Transaction<'a>, Error>

Creates a new transaction. txn_locks are read locks that can be upgraded to write locks at commit time.

pub fn txn_guard(&self) -> &TxnGuard<'_>

pub fn mutations(&self) -> &BTreeSet<TxnMutation<'a>>

pub fn take_mutations(&mut self) -> BTreeSet<TxnMutation<'a>>

pub fn add(&mut self, object_id: u64, mutation: Mutation) -> Option<Mutation>

Adds a mutation to this transaction. If the mutation already exists, it is replaced and the old mutation is returned.

pub fn remove(&mut self, object_id: u64, mutation: Mutation)

Removes a mutation that matches mutation.

pub fn add_with_object( &mut self, object_id: u64, mutation: Mutation, associated_object: AssocObj<'a>, ) -> Option<Mutation>

Adds a mutation with an associated object. If the mutation already exists, it is replaced and the old mutation is returned.

pub fn add_checksum( &mut self, range: Range<u64>, checksums: Vec<Checksum>, first_write: bool, )

pub fn checksums(&self) -> &[(Range<u64>, Vec<Checksum>, bool)]

pub fn take_checksums(&mut self) -> Vec<(Range<u64>, Vec<Checksum>, bool)>

pub fn is_empty(&self) -> bool

Returns true if this transaction has no mutations.

pub fn get_object_mutation( &self, store_object_id: u64, key: ObjectKey, ) -> Option<&ObjectStoreMutation>

Searches for an existing object mutation within the transaction that has the given key and returns it if found.

pub async fn commit(self) -> Result<u64, Error>

Commits a transaction. If successful, returns the journal offset of the transaction.

pub async fn commit_with_callback<R: Send>( self, f: impl FnOnce(u64) -> R + Send, ) -> Result<R, Error>

Commits and then runs the callback whilst locks are held. The callback accepts a single parameter which is the journal offset of the transaction.

pub async fn commit_and_continue(&mut self) -> Result<(), Error>

Commits the transaction, but allows the transaction to be used again. The locks are not dropped (but transaction locks will get downgraded to read locks).

Trait Implementations

impl Debug for Transaction<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Transaction<'_>

fn drop(&mut self)

Executes the destructor for this type.