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(|mut ctx| async move {
        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) -> Transaction<'p, DB>

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<'p> Transaction<'p, Pool<Postgres>>

pub async fn run<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>,

Available on crate feature postgres only.

Execute a closure within a PostgreSQL transaction.

Automatically commits on Ok, rolls back on Err or drop.

Type Parameters

• F — Closure type
• Fut — Future returned by closure
• T — Success type
• E — Error type (must be convertible from sqlx::Error)

Example

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

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>,

Available on crate feature postgres only.

Execute a closure within a transaction with explicit commit.

Unlike run, this method requires the closure to explicitly commit the transaction by calling ctx.commit().

Example

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