Struct Transaction 

pub struct Transaction<'p, DB> { /* private fields */ }

Transaction builder for composing multi-entity operations.

Use Transaction::new to create a builder, chain .with_*() methods to declare which entities you’ll use, then call .run() to execute.

Type Parameters

• 'p — Pool lifetime
• DB — Database pool type (e.g., PgPool)

Example

Transaction::new(&pool)
    .with_users()
    .with_orders()
    .run(async |ctx| {
        let user = ctx.users().find_by_id(id).await?;
        ctx.orders().create(order).await?;
        Ok(())
    })
    .await?;

Implementations

impl<'p, DB> Transaction<'p, DB>

pub const fn new(pool: &'p DB) -> Self

Create a new transaction builder.

Arguments

• pool — Database connection pool

Example

let tx = Transaction::new(&pool);

pub const fn pool(&self) -> &'p DB

Get reference to the underlying pool.

impl Transaction<'_, PgPool>

pub async fn run<F, T, E>(self, f: F) -> Result<T, E>

where F: AsyncFnOnce(&mut TransactionContext) -> Result<T, E>, E: From<Error>,

Execute a closure within a PostgreSQL transaction.

Commits the transaction explicitly when the closure returns Ok. On Err, the transaction context is dropped and sqlx rolls back automatically via its Drop implementation.

The closure receives &mut TransactionContext (not by value) so that run retains ownership and can invoke commit().await on success.

Type Parameters

• F — Async closure
• T — Success type
• E — Error type (must be convertible from sqlx::Error)

Example

Transaction::new(&pool)
    .with_users()
    .run(async |ctx| {
        let user = ctx.users().create(dto).await?;
        Ok(user)
    })
    .await?;

Errors

Propagates any error from the closure, from begin, or from commit.

pub async fn run_with_commit<F, Fut, T, E>(self, f: F) -> Result<T, E>

where F: FnOnce(TransactionContext) -> Fut + Send, Fut: Future<Output = Result<T, E>> + Send, E: From<Error>,

Execute a closure within a transaction with explicit commit.

Unlike run, this method passes TransactionContext by value so the closure can call ctx.commit().await (or ctx.rollback().await) itself. If the closure returns without committing, the transaction is rolled back when ctx is dropped.

Use this when you need conditional commit logic; otherwise prefer run.

Example

Transaction::new(&pool)
    .run_with_commit(|mut ctx| async move {
        let user = ctx.users().create(dto).await?;
        ctx.commit().await?;
        Ok(user)
    })
    .await?;

Errors

Propagates any error from the closure or database transaction.