Struct Transaction 

pub struct Transaction { /* private fields */ }

A database transaction.

Created by Pool::begin(). Must be explicitly committed via commit(). If dropped without commit(), the connection is discarded from the pool and a warning is logged.

Use .defer(&mut tx) on queries to buffer writes, then tx.commit() to flush them all in a single pipeline. Use .execute(&mut tx) or .fetch(&mut tx) for immediate execution within the transaction.

Example

use bsql::Pool;

let pool = Pool::connect("postgres://user:pass@localhost/mydb")?;
let tx = pool.begin()?;

// Buffer writes with .defer() — nothing hits the network yet
bsql::query!("INSERT INTO log (msg) VALUES ($msg: &str)")
    .defer(&mut tx)?;

// Or execute immediately within the transaction
bsql::query!("UPDATE accounts SET balance = 0 WHERE id = $id: i32")
    .execute(&mut tx)?;

// commit() flushes all deferred operations, then commits
tx.commit()?;

Implementations

impl Transaction

pub async fn commit(self) -> BsqlResult<()>

Commit the transaction and return the connection to the pool.

Consumes self — the transaction cannot be used after commit.

pub async fn rollback(self) -> BsqlResult<()>

Explicitly roll back the transaction and return the connection to the pool.

Consumes self — the transaction cannot be used after rollback.

pub async fn savepoint(&mut self, name: &str) -> BsqlResult<()>

Create a savepoint within the transaction.

The name must be a valid SQL identifier: ASCII alphanumeric and underscores only, starting with a letter or underscore. Maximum 63 characters.

pub async fn release_savepoint(&mut self, name: &str) -> BsqlResult<()>

Release (destroy) a savepoint, keeping its effects.

The name must match a previously created savepoint.

pub async fn rollback_to(&mut self, name: &str) -> BsqlResult<()>

Roll back to a savepoint, undoing changes made after it was created.

The savepoint remains valid after this call (can be rolled back to again).

pub async fn set_isolation(&mut self, level: IsolationLevel) -> BsqlResult<()>

Set the isolation level for this transaction.

Must be called before the first query in the transaction (immediately after begin()). PostgreSQL rejects SET TRANSACTION after any data-modifying statement.

pub async fn execute_pipeline( &mut self, sql: &str, sql_hash: u64, param_sets: &[&[&(dyn Encode + Sync)]], ) -> BsqlResult<Vec<u64>>

Execute the same statement N times with different params in one pipeline.

Sends all N Bind+Execute messages + one Sync. One round-trip for N operations within the transaction. Returns the affected row count for each parameter set.

pub async fn for_each_raw<F>( &mut self, sql: &str, sql_hash: u64, params: &[&(dyn Encode + Sync)], f: F, ) -> BsqlResult<()>

where F: FnMut(PgDataRow<'_>) -> BsqlResult<()>,

Process each row directly from the wire buffer within this transaction.

Zero arena allocation — the closure receives a PgDataRow that reads columns directly from the DataRow message bytes.

Trait Implementations

impl Debug for Transaction

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

Formats the value using the given formatter.

impl Drop for Transaction

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> From<&'a mut Transaction> for QueryTarget<'a>

fn from(tx: &'a mut Transaction) -> Self

Converts to this type from the input type.