Struct Transaction 

pub struct Transaction { /* private fields */ }

A database transaction — the explicit write scope.

Transactions provide ACID guarantees for multiple operations. Changes are isolated until commit().

Concurrency

Uses commit-time serialization: each transaction owns a private L0 buffer. tx() only takes a reader lock (to snapshot the version); the writer lock is acquired briefly per-mutation and once at commit for WAL + merge. Multiple transactions can coexist; isolation is provided by private L0 buffers.

Drop Behavior

If dropped without calling commit() or rollback(), the private L0 is simply discarded (no writer lock needed) and a warning is logged if dirty.

Implementations

impl Transaction

pub async fn query(&self, cypher: &str) -> Result<QueryResult>

Execute a Cypher query within the transaction. Reads see the private L0 buffer (uncommitted writes).

pub fn query_with(&self, cypher: &str) -> TxQueryBuilder<'_>

Execute a Cypher query with parameters.

pub async fn execute(&self, cypher: &str) -> Result<ExecuteResult>

Execute a Cypher mutation within the transaction. Mutation count is read from the private L0 (not the global writer).

pub fn execute_with(&self, cypher: &str) -> ExecuteBuilder<'_>

Execute a mutation with parameters using a builder.

Returns an ExecuteBuilder that provides .param() chaining and a .run() method that returns ExecuteResult.

pub async fn apply(&self, derived: DerivedFactSet) -> Result<ApplyResult>

Apply a DerivedFactSet (from a session-level DERIVE) to this transaction.

Replays the collected Cypher mutation ASTs against the transaction’s private L0 buffer. Logs an info-level warning if the database version has advanced since the DERIVE was evaluated (version gap > 0).

pub fn apply_with(&self, derived: DerivedFactSet) -> ApplyBuilder<'_>

Start building an apply operation with staleness controls.

pub async fn bulk_insert_vertices( &self, label: &str, properties_list: Vec<Properties>, ) -> Result<Vec<Vid>>

Bulk insert vertices for a given label within this transaction.

Mutations are written to the transaction’s private L0 and become visible on commit. Returns the allocated VIDs in input order.

pub async fn bulk_insert_edges( &self, edge_type: &str, edges: Vec<(Vid, Vid, Properties)>, ) -> Result<()>

Bulk insert edges for a given edge type within this transaction.

Mutations are written to the transaction’s private L0 and become visible on commit.

pub fn bulk_writer(&self) -> BulkWriterBuilder

Create a bulk writer builder for efficient data loading within this transaction.

The bulk writer writes directly to storage (bypassing the L0 buffer). The Transaction’s write guard ensures mutual exclusion — the BulkWriter does not manage the guard itself.

pub fn appender(&self, label: &str) -> AppenderBuilder

Create a streaming appender for row-by-row data loading within this transaction.

The appender writes directly to storage (bypassing the L0 buffer). The Transaction’s write guard ensures mutual exclusion.

pub async fn locy(&self, program: &str) -> Result<LocyResult>

Evaluate a Locy program within the transaction.

DERIVE commands auto-apply to the transaction’s write buffer.

pub fn locy_with(&self, program: &str) -> TxLocyBuilder<'_>

Evaluate a Locy program with parameters using a builder.

pub async fn prepare(&self, cypher: &str) -> Result<PreparedQuery>

Prepare a Cypher query for repeated execution within this transaction.

The query is parsed and planned once; subsequent executions skip those phases. If the schema changes, the prepared query auto-replans.

pub async fn prepare_locy(&self, program: &str) -> Result<PreparedLocy>

Prepare a Locy program for repeated evaluation within this transaction.

pub fn rules(&self) -> RuleRegistry<'_>

Access the transaction-scoped rule registry. On commit, new rules are promoted to the session (best-effort).

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

Commit the transaction.

Persists all changes made during the transaction. Returns a CommitResult with commit metadata.

pub fn rollback(self)

Rollback the transaction, discarding all changes.

No writer lock needed — the private L0 is simply dropped. This method is infallible and synchronous. If the transaction is already completed, this is a silent no-op (idempotent).

pub fn is_dirty(&self) -> bool

Check if the transaction has uncommitted changes.

pub fn id(&self) -> &str

Get the transaction ID.

pub fn started_at_version(&self) -> u64

Database version when this transaction was started.

pub fn cancel(&self)

Cancel all in-flight queries in this transaction.

pub fn cancellation_token(&self) -> CancellationToken

Get a clone of this transaction’s cancellation token.

Trait Implementations

impl Drop for Transaction

fn drop(&mut self)

Executes the destructor for this type.