Struct WriteTxn 

pub struct WriteTxn<'db, F: FileBackend> { /* private fields */ }

A write transaction.

Construct via WriteTxn::begin. Holds, for its entire lifetime:

1. A guard on the env’s in-process write-serialization Mutex — ensures at most one WriteTxn per env per process.
2. An optional cross-process WRITER_LOCK byte — ensures at most one WriteTxn across the cluster of processes that have opened the same file.

WriteTxn::commit finalises the transaction through the pager’s WAL; WriteTxn::rollback discards pending writes. Dropping an uncommitted WriteTxn rolls back automatically (and emits an eprintln! so the caller learns about the silent rollback).

Generic over F: FileBackend (Rule 9: no dyn).

Implementations

impl<'db, F: FileBackend> WriteTxn<'db, F>

pub fn begin(env: &'db TxnEnv<F>, timeout: Duration) -> Result<Self>

Begin a new write transaction against env.

Acquires the cross-process WRITER_LOCK (if env.lock_file is Some) with timeout, then the in-process write- serialization Mutex. Returns the busy variant of Error keyed by which lock blocked us.

Errors

• Error::Busy with LockKind::Writer if the cross- process lock did not become available within timeout.
• Error::Busy with LockKind::WriterInProcess if another thread in the same process is mid-write.
• Error::Io on lock syscall failure.

pub fn write_page(&self, id: PageId, page: &Page) -> Result<()>

Write page at id through the pager.

Errors

• Error::InvalidArgument if id is out of range.
• Error::Io on syscall failure.

pub fn read_page(&self, id: PageId) -> Result<Page>

Read id through the pager (sees pending + committed + main). Used inside a write txn that needs to read-modify- write a page. Returns an owned Page because the borrow chain through the pager’s mutex would otherwise tie the returned reference to the guard.

Errors

As Pager::read_page.

pub fn alloc_page(&self) -> Result<PageId>

Allocate a new page through the pager.

Errors

As Pager::alloc_page.

pub fn lock_pager(&self) -> Result<MutexGuard<'_, Pager<F>>>

Acquire the pager mutex. Bubble a poisoned mutex up as WriterInProcess — every txn method that takes the pager goes through here so the failure mode is uniform.

Errors

Returns Error::Busy with LockKind::WriterInProcess if the mutex is poisoned by a previous panic.

pub fn env(&self) -> &'db TxnEnv<F>

Access the underlying env. Used by callers (e.g. obj crate) that compose typed handles over the raw txn.

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

Commit the transaction. Calls Pager::commit to make the staged writes durable, then releases both lock layers.

Errors

Returns whatever Pager::commit returns.

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

Roll the transaction back, dropping all pending writes.

Errors

Returns Error::Busy only if the in-process pager mutex is poisoned; otherwise infallible.

Trait Implementations

impl<'db, F: Debug + FileBackend> Debug for WriteTxn<'db, F>

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

Formats the value using the given formatter.

impl<F: FileBackend> Drop for WriteTxn<'_, F>

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.