Struct Transaction 

pub struct Transaction { /* private fields */ }

Transaction represents a database transaction

Provides ACID guarantees for a series of database operations. Must be explicitly committed or rolled back.

Implementations

impl Transaction

pub fn id(&self) -> i64

Get the transaction ID

pub fn execute<P: Params>(&mut self, sql: &str, params: P) -> Result<i64>

Execute a SQL statement within the transaction

Parameters

Parameters can be passed using:

• Empty tuple () for no parameters
• Tuple syntax (1, "Alice", 30) for multiple parameters
• params! macro params![1, "Alice", 30]

Examples

let mut tx = db.begin()?;
tx.execute("INSERT INTO users VALUES ($1, $2)", (1, "Alice"))?;
tx.execute("UPDATE accounts SET balance = balance - $1 WHERE user_id = $2", (100, 1))?;
tx.commit()?;

pub fn execute_prepared<P: Params>( &mut self, statement: &Statement, params: P, ) -> Result<i64>

Execute a pre-parsed statement with parameters.

Avoids re-parsing SQL on every call — ideal for batch operations where the same statement is executed many times with different params.

Use Parser::new(sql).parse_program() to pre-parse the SQL once.

pub fn query<P: Params>(&mut self, sql: &str, params: P) -> Result<Rows>

Execute a query within the transaction

Examples

let mut tx = db.begin()?;
for row in tx.query("SELECT * FROM users WHERE age > $1", (18,))? {
    let row = row?;
    println!("{}", row.get::<String>("name")?);
}
tx.commit()?;

pub fn query_one<T: FromValue, P: Params>( &mut self, sql: &str, params: P, ) -> Result<T>

Execute a query and return a single value

Examples

let mut tx = db.begin()?;
let count: i64 = tx.query_one("SELECT COUNT(*) FROM users", ())?;
tx.commit()?;

pub fn query_opt<T: FromValue, P: Params>( &mut self, sql: &str, params: P, ) -> Result<Option<T>>

Execute a query and return an optional single value

Examples

let mut tx = db.begin()?;
let name: Option<String> = tx.query_opt("SELECT name FROM users WHERE id = $1", (999,))?;
tx.commit()?;

pub fn execute_named(&mut self, sql: &str, params: NamedParams) -> Result<i64>

Execute a SQL statement with named parameters within the transaction

Examples

use stoolap::named_params;

let mut tx = db.begin()?;
tx.execute_named(
    "INSERT INTO users VALUES (:id, :name)",
    named_params!{ id: 1, name: "Alice" }
)?;
tx.commit()?;

pub fn query_named(&mut self, sql: &str, params: NamedParams) -> Result<Rows>

Execute a query with named parameters within the transaction

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

Commit the transaction

All changes made within the transaction become permanent.

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

Roll back the transaction

All changes made within the transaction are discarded.

Trait Implementations

impl Drop for Transaction

fn drop(&mut self)

Executes the destructor for this type.