Struct Transaction 

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

Explicit transaction over the in-memory graph.

The implementation is conservative: read-only transactions hold a database read lock, and read-write transactions hold the database write lock. Read-write transactions lazily create a cloned staging graph on the first mutating statement, then either swap that graph into place on commit or drop it on rollback. Explicit mutating statements capture a graph + WAL-buffer savepoint so a failed or dropped streaming statement only rolls back its own effects, not the transaction as a whole.

When a WAL is attached, mutation events fire into a tx-local buffer rather than the durable log. The buffer is replayed into the WAL exactly once at commit, so recovery never observes partial / aborted / dropped statements.

Implementations

impl<'db> Transaction<'db>

pub fn mode(&self) -> TransactionMode

Transaction mode chosen at begin time.

pub fn execute( &mut self, query: &str, options: Option<ExecuteOptions>, ) -> Result<QueryResult, LoraError>

Execute a query inside the transaction and return a materialized QueryResult.

pub fn execute_with_timeout( &mut self, query: &str, options: Option<ExecuteOptions>, timeout: Duration, ) -> Result<QueryResult, LoraError>

Execute a query inside the transaction with a cooperative deadline.

pub fn execute_with_params( &mut self, query: &str, options: Option<ExecuteOptions>, params: BTreeMap<String, LoraValue>, ) -> Result<QueryResult, LoraError>

Execute a parameterised query inside the transaction.

pub fn execute_with_params_timeout( &mut self, query: &str, options: Option<ExecuteOptions>, params: BTreeMap<String, LoraValue>, timeout: Duration, ) -> Result<QueryResult, LoraError>

Execute a parameterised query inside the transaction with a cooperative deadline.

pub fn execute_with_params_deadline( &mut self, query: &str, options: Option<ExecuteOptions>, params: BTreeMap<String, LoraValue>, deadline: Instant, ) -> Result<QueryResult, LoraError>

Execute a parameterised query inside the transaction that stops at an absolute deadline (see crate::Database::execute_with_params_deadline). Several statements can share one deadline to bound the whole transaction.

pub fn execute_rows(&mut self, query: &str) -> Result<Vec<Row>, LoraError>

Execute a query inside the transaction and return hydrated rows before final result-format projection.

pub fn execute_rows_with_params( &mut self, query: &str, params: BTreeMap<String, LoraValue>, ) -> Result<Vec<Row>, LoraError>

Execute a parameterised query inside the transaction and return hydrated rows before final result-format projection.

pub fn explain( &self, query: &str, _params: Option<BTreeMap<String, LoraValue>>, ) -> Result<QueryPlan, LoraError>

Compile query against the transaction’s view of the graph and return the plan that would run. Never executes the query, so running explain on a mutating statement leaves the transaction’s staged graph untouched.

pub fn profile( &mut self, query: &str, params: Option<BTreeMap<String, LoraValue>>, ) -> Result<QueryProfile, LoraError>

Execute query inside the transaction and return the plan plus runtime metrics.

PROFILE executes the query for real. Mutating statements affect the transaction’s staged graph and are persisted at the usual commit point. Use Transaction::explain to inspect a plan without running it.

pub fn stream(&mut self, query: &str) -> Result<QueryStream<'static>, LoraError>

Execute a query inside the transaction and return an owning row stream.

pub fn stream_with_params( &mut self, query: &str, params: BTreeMap<String, LoraValue>, ) -> Result<QueryStream<'static>, LoraError>

Execute a parameterised query inside the transaction and return an owning row stream.

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

Commit the transaction and publish staged changes.

When WAL is attached the buffered tx-local mutation log is replayed into the durable WAL as a single committed transaction; recovery therefore observes either every write in this transaction or none.

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

Roll back the transaction. Staged graph changes and buffered mutations are discarded; the WAL is never armed.

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.