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( fs: Arc<FxFilesystem>, 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 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 includes_write(&self) -> 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).

pub async fn commit_prepare(&self)

Prepares to commit by upgrading transaction locks to write locks and waiting for active readers to finish.

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.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.