Struct Transaction

Source

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

Expand description

Represents an active database transaction

Transactions provide ACID guarantees for multi-statement operations. Following the rusqlite pattern:

Transactions automatically roll back when dropped
Must explicitly call commit() to persist changes
This prevents accidentally forgetting to commit or rollback

§Examples

// Transaction with explicit commit
let mut tx = session.transaction()?;
tx.execute("CREATE (p:Person {name: 'Alice'})")?;
tx.execute("CREATE (p:Person {name: 'Bob'})")?;
tx.commit()?;  // Changes are persisted

// Transaction that rolls back (dropped without commit)
{
    let mut tx = session.transaction()?;
    tx.execute("CREATE (p:Person {name: 'Charlie'})")?;
    // tx is dropped here, changes are automatically rolled back
}

Implementations§

Source §

impl<'conn> Transaction<'conn>

Source

pub fn execute(&mut self, statement: &str) -> Result<()>

Execute a GQL statement within this transaction

§Arguments

statement - GQL statement to execute

§Examples

let mut tx = session.transaction()?;
tx.execute("CREATE (p:Person {name: 'Alice'})")?;
tx.execute("CREATE (p:Person {name: 'Bob'})")?;
tx.commit()?;

Source

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

Execute a query within this transaction and return results

§Arguments

query - GQL query to execute

§Examples

let mut tx = session.transaction()?;
tx.execute("CREATE (p:Person {name: 'Alice', age: 30})")?;
let result = tx.query("MATCH (p:Person) RETURN p")?;
tx.commit()?;

Source

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

Commit the transaction

Persists all changes made within this transaction. After calling commit(), the transaction is consumed and cannot be used further.

§Examples

let mut tx = session.transaction()?;
tx.execute("CREATE (p:Person {name: 'Alice'})")?;
tx.commit()?;  // Changes are now persistent

Source

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

Rollback the transaction

Discards all changes made within this transaction. This is called automatically when the transaction is dropped, so explicit rollback is rarely needed.

§Examples

let mut tx = session.transaction()?;
tx.execute("CREATE (p:Person {name: 'Alice'})")?;
tx.rollback()?;  // Explicit rollback (optional, automatic on drop)

Source

pub fn set_drop_behavior(&mut self, behavior: DropBehavior)

Set the behavior when this transaction is dropped

By default, transactions roll back when dropped. This can be changed to:

DropBehavior::Commit - Auto-commit on drop
DropBehavior::Panic - Panic if dropped without explicit commit/rollback
DropBehavior::Ignore - Do nothing (dangerous)

§Examples

let mut tx = session.transaction()?;
tx.set_drop_behavior(DropBehavior::Panic);
tx.execute("CREATE (p:Person {name: 'Alice'})")?;
// Must explicitly commit or rollback, or will panic on drop
tx.commit()?;