Struct MvccEngine 

pub struct MvccEngine<B: Backend> { /* private fields */ }

The central state machine for executing MVCC operations.

MvccEngine wraps a durable Backend and provides high-level APIs for single-key and multi-key reads, transactional intents, and direct batches.

Implementations

impl<B: Backend> MvccEngine<B>

pub fn new(backend: B) -> Self

Creates a new MvccEngine with the given backend.

pub fn backend(&self) -> &B

Returns an immutable reference to the underlying backend.

pub fn backend_mut(&mut self) -> &mut B

Returns a mutable reference to the underlying backend.

pub fn read( &self, key: &[u8], read_ts: Timestamp, ) -> Result<Option<Vec<u8>>, ReadError>

Reads the visible value for a key at a given logical read_ts.

This method ignores uncommitted intents and finds the newest committed version that has a commit_ts <= read_ts.

pub fn read_with_version( &self, key: &[u8], read_ts: Timestamp, ) -> Result<Option<(Timestamp, Option<Vec<u8>>)>, ReadError>

Reads the visible value for a key at read_ts and returns its commit timestamp and value.

If no version is visible at or before read_ts, returns Ok(None). If a tombstone is visible, returns Ok(Some((ts, None))). If a value is visible, returns Ok(Some((ts, Some(value)))).

pub fn read_own_write( &self, key: &[u8], txn_id: TxnId, start_ts: Timestamp, read_ts: Timestamp, ) -> Result<Option<Vec<u8>>, ReadError>

Reads the visible value for a key, prioritizing the transaction’s own active intent.

If the transaction has an active intent on the key, its value is returned. Otherwise, it falls back to a normal historical read at read_ts.

pub fn prewrite( &mut self, txn_id: TxnId, start_ts: Timestamp, key: Vec<u8>, mutation: Mutation, ) -> Result<(), PrewriteError>

Prewrites a single intent for a distributed transaction.

Fails if another transaction holds an intent on the key, or if a newer committed version exists (write conflict). It is idempotent for the same transaction and start_ts.

pub fn commit( &mut self, txn_id: TxnId, key: &[u8], start_ts: Timestamp, commit_ts: Timestamp, ) -> Result<(), CommitError>

Commits a single intent, creating a durable version.

Converts the intent at start_ts into a committed version at commit_ts. The backend must execute this atomically (create version and remove intent).

pub fn abort( &mut self, txn_id: TxnId, key: &[u8], start_ts: Timestamp, ) -> Result<(), AbortError>

Aborts a single intent, removing it from the backend.

This method is idempotent: if the intent is not found, it returns Ok(()).

pub fn prewrite_batch( &mut self, txn_id: TxnId, start_ts: Timestamp, writes: Vec<PhysicalWrite>, ) -> Result<(), BatchPrewriteError>

Prewrites multiple intents atomically for a transaction.

Rejects empty batches with EmptyBatch. Identical replay semantics apply as in single-key prewrite.

pub fn commit_batch( &mut self, txn_id: TxnId, start_ts: Timestamp, commit_ts: Timestamp, keys: Vec<Vec<u8>>, ) -> Result<(), BatchCommitError>

Commits multiple intents atomically, creating durable versions.

Rejects empty batches with EmptyBatch.

pub fn abort_batch( &mut self, txn_id: TxnId, start_ts: Timestamp, keys: Vec<Vec<u8>>, ) -> Result<(), BatchAbortError>

Aborts multiple intents, removing them atomically.

If the key list is empty, it returns Ok(()) (idempotent).

pub fn apply_direct_batch( &mut self, commit_ts: Timestamp, writes: Vec<PhysicalWrite>, ) -> Result<(), BatchError>

Applies a batch of writes directly, bypassing intents.

Rejects empty batches with EmptyBatch. Fails if any key has an active intent or if commit_ts is not strictly greater than the latest committed version.

pub fn apply_guarded_batch( &mut self, commit_ts: Timestamp, guards: Vec<ReadGuard>, writes: Vec<PhysicalWrite>, ) -> Result<(), BatchError>

Applies a batch of writes conditionally, validating read guards first.

Useful for Read-Modify-Write operations (e.g. Compare-And-Swap) without interactive two-phase commit transactions. Rejects empty writes or empty guards.

pub fn plan_key_gc( &self, key: &[u8], safe_point_ts: Timestamp, options: KeyGcOptions, ) -> Result<KeyGcPlan, GcError>

Produces a bounded, deterministic GC plan for one logical key.

Planning never mutates the backend. The newest committed version visible at safe_point_ts is the keeper, and ordinary removals are restricted to explicit timestamps strictly older than that keeper. Versions newer than the safe point are never included.

A final tombstone can be returned in KeyGcPlan::collapse_tombstone only when the caller opted in, the key has no active intent, the tombstone is the latest committed version, and the complete older history fits below the planning budget. The caller must remove the tombstone and every timestamp in KeyGcPlan::versions_to_remove atomically.

pub fn gc_incremental( &mut self, safe_point_ts: Timestamp, cursor: Option<IncrementalGcCursor>, options: GcOptions, ) -> Result<IncrementalGcResult, GcError>

Performs an incremental step of garbage collection.

Obsolete versions older than safe_point_ts are removed up to the budget.

pub fn gc( &mut self, safe_point_ts: Timestamp, options: GcOptions, ) -> Result<GcStats, GcError>

👎Deprecated:

unbounded: loops gc_incremental to completion and materializes the whole keyspace via all_keys(); production must use budgeted gc_incremental

Performs a full garbage collection by repeatedly calling gc_incremental.

This is maintained for compatibility.