Struct Transaction 

pub struct Transaction<'db> { /* private fields */ }

An in-flight cross-table transaction. Holds a read snapshot taken at begin and stages writes; nothing is durable or visible until Self::commit.

S1B-001 state: the transaction carries its IsolationLevel, the HLC read timestamp captured at begin, its read/predicate sets, and a formal TransactionState inspectable through Self::state/Self::state_handle.

Implementations

impl<'db> Transaction<'db>

pub fn read_snapshot(&self) -> Snapshot

pub fn txn_id(&self) -> u64

The transaction’s id (generation-scoped: high 32 bits = open generation, low 32 = per-open counter). Mainly diagnostic / test-facing.

pub fn isolation(&self) -> IsolationLevel

The isolation level this transaction was begun with (S1B-001/002).

pub fn read_ts(&self) -> Option<HlcTimestamp>

The HLC read timestamp captured at begin (spec §8.2). None when clock-skew rejection deferred allocation to the commit path.

pub fn state(&self) -> TransactionState

The current formal state (S1B-001).

pub fn state_handle(&self) -> TxnStateHandle

A cloneable handle to the formal state, inspectable after this value is consumed by commit/rollback (S1B-001).

pub fn read_set(&self) -> &ReadSet

Point reads recorded so far (S1B-001; certified at Serializable).

pub fn predicate_set(&self) -> &PredicateSet

Predicate/range reads recorded so far (S1B-001/002).

pub fn get(&mut self, table: &str, row_id: RowId) -> Result<Option<OwnedRow>>

Read one row at this transaction’s current statement snapshot and record the point read in the transaction’s read set. ReadCommitted statements observe commits that landed since the previous statement; RepeatableRead/Serializable observe the fixed begin snapshot.

pub fn track_predicate_read(&mut self, table: &str) -> Result<()>

Register a table-granularity predicate/range read (S1B-002). Scan and range-lookup paths report here so Serializable certification detects phantoms: any concurrent write on the table then invalidates the read.

pub fn put( &mut self, table: &str, cells: Vec<(u16, Value)>, ) -> Result<Option<i64>>

pub fn put_returning( &mut self, table: &str, cells: Vec<(u16, Value)>, ) -> Result<PutResult>

pub fn put_batch( &mut self, table: &str, rows: Vec<Vec<(u16, Value)>>, ) -> Result<Vec<Option<i64>>>

Stage many puts on the same table with one table-id lookup + one auto-inc lock pass. Each row is staged individually (same as repeated put); the savings are the amortized lookups/locks for bulk guard-row writes and batched application-row inserts. Returns the assigned auto-increment values (Some only where the engine filled the column).

pub fn delete(&mut self, table: &str, row_id: RowId) -> Result<()>

Stage a delete of row_id on table.

pub fn delete_batch(&mut self, table: &str, row_ids: Vec<RowId>) -> Result<()>

Stage deletes without materializing pre-images.

pub fn put_external_state(&mut self, table: &str, state: Vec<u8>) -> Result<()>

Stage opaque external-table module state. The payload is committed under the same WAL TxnCommit as ordinary table writes.

pub fn set_materialized_view_definition( &mut self, definition: MaterializedViewEntry, ) -> Result<()>

Stage a materialized-view checkpoint in the same durable commit as its row deltas. This makes incremental refresh replay idempotent after a crash: data and the Last-Event-ID watermark advance together.

pub fn delete_many( &mut self, table: &str, row_ids: Vec<RowId>, ) -> Result<Vec<OwnedRow>>

pub fn update_many( &mut self, table: &str, updates: Vec<(RowId, Vec<(u16, Value)>)>, ) -> Result<Vec<OwnedRow>>

pub fn upsert( &mut self, table: &str, insert_cells: Vec<(u16, Value)>, action: UpsertAction, ) -> Result<UpsertResult>

pub fn truncate(&mut self, table: &str) -> Result<()>

pub fn commit(self) -> Result<Epoch>

Commit: durably seal the staging under one epoch and publish it.

pub fn commit_idempotent(self, request: IdempotencyRequest) -> Result<Epoch>

Commit with idempotency parameters (spec §10.2, S1B-005): a repeated key with an identical request fingerprint returns the original commit epoch (the original receipt is visible through the state handle); a repeated key with a different fingerprint returns Conflict.

pub fn commit_with_row_ids(self) -> Result<(Epoch, Vec<RowId>)>

pub fn commit_controlled<F>( self, control: &ExecutionControl, before_commit: F, ) -> Result<Epoch>

where F: FnMut() -> Result<()>,

Cooperatively prepare this transaction, then invoke before_commit immediately before the first WAL append can occur. If cancellation or the callback wins, no commit epoch or WAL record is produced.

pub fn commit_controlled_with_row_ids<F>( self, control: &ExecutionControl, before_commit: F, ) -> Result<(Epoch, Vec<RowId>)>

where F: FnMut() -> Result<()>,

pub fn rollback(self)

Rollback: discard staging. Nothing is appended to the WAL.

Trait Implementations

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.