Struct mz_persist_txn::txn_write::Txn

pub struct Txn<K, V, T, D>
where
    T: Timestamp + Lattice + Codec64,
{ /* private fields */ }

An in-progress transaction.

Implementations

impl<K, V, T, D> Txn<K, V, T, D>

where K: Debug + Codec, V: Debug + Codec, T: Timestamp + Lattice + TotalOrder + StepForward + Codec64, D: Semigroup + Codec64 + Send + Sync,

pub async fn write(&mut self, data_id: &ShardId, key: K, val: V, diff: D)

Stage a write to the in-progress txn.

The timestamp will be assigned at commit time.

TODO: Allow this to spill to s3 (for bounded memory) once persist can make the ts rewrite op efficient.

pub async fn commit_at<O, C>( &mut self, handle: &mut TxnsHandle<K, V, T, D, O, C>, commit_ts: T ) -> Result<TxnApply<T>, T>

where O: Opaque + Debug + Codec64, C: TxnsCodec,

Commit this transaction at commit_ts.

This either atomically commits all staged writes or, if that’s no longer possible at the requested timestamp, returns an error with the least commit-able timestamp.

On success a token is returned representing apply work expected to be promptly performed by the caller. At this point, the txn is durable and it’s safe to bubble up success, but reads at the commit timestamp will block until this apply work finishes. In the event of a crash, neither correctness nor liveness require this followup be done.

Panics if any involved data shards were not registered before commit ts.

pub fn merge(&mut self, other: Self)

Merges the staged writes in the other txn into this one.

pub fn tidy(&mut self, tidy: Tidy)

Merges the work represented by given tidy into this txn.

If this txn commits, the tidy work will be written at the commit ts.

pub fn take_tidy(&mut self) -> Tidy

Extracts any tidy work that has been merged into this txn with Self::tidy.

Trait Implementations

impl<K: Debug, V: Debug, T, D: Debug> Debug for Txn<K, V, T, D>

where T: Timestamp + Lattice + Codec64 + Debug,

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

Formats the value using the given formatter.