Struct Transaction 

pub struct Transaction { /* private fields */ }

A single transaction

Transactions buffer writes and commit them atomically to the WAL.

Implementations

impl Transaction

pub fn id(&self) -> u64

Get transaction ID

pub fn state(&self) -> TxState

Get transaction state

pub fn is_active(&self) -> bool

Check if transaction is active

pub fn read_page(&mut self, page_id: u32) -> Result<Page, TxError>

Read a page through this transaction

If the page has been written in this transaction, returns the buffered version. Otherwise, reads from the pager.

pub fn write_page(&mut self, page_id: u32, page: Page) -> Result<(), TxError>

Write a page through this transaction

The write is buffered and will be committed to the WAL on commit.

pub fn commit(self) -> Result<(), TxError>

Commit the transaction

Writes all buffered pages to the WAL, then writes a Commit record.

Read-only fast path: when write_set is empty, the transaction wrote nothing, so there is nothing to make durable. We skip the WAL append, the wal.sync() (which costs ~100 µs of fsync), and the pager apply loop entirely. The transaction still transitions to Committed and unregisters from the manager so subsequent state checks work correctly. This mirrors postgres’ optimisation in RecordTransactionCommit (xact.c) which skips XLogFlush when nothing was written.

pub fn rollback(self) -> Result<(), TxError>

Rollback the transaction

Discards all buffered writes and writes a Rollback record 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.