Struct Transaction 

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

A wrapper around a SQLx transaction.

Provides a way to execute multiple queries atomically. If any query fails, the transaction can be rolled back. If all succeed, it can be committed.

Type Parameters

• 'a - The lifetime of the database connection source

Fields

• tx - The underlying SQLx transaction
• driver - The database driver type (for query syntax handling)

Implementations

impl<'a> Transaction<'a>

pub fn model<T: Model + Send + Sync + Unpin>( &mut self, ) -> QueryBuilder<'a, T, &mut Transaction<'a, Any>>

Starts building a query within this transaction.

This method creates a new QueryBuilder that will execute its queries as part of this transaction.

Type Parameters

• T - The Model type to query.

Returns

A new QueryBuilder instance bound to this transaction.

Example

let mut tx = db.begin().await?;

// These operations are part of the transaction
tx.model::<User>().insert(&user).await?;
tx.model::<Post>().insert(&post).await?;

tx.commit().await?;

pub async fn commit(self) -> Result<(), Error>

Commits the transaction.

Persists all changes made during the transaction to the database. This consumes the Transaction instance.

Returns

• Ok(()) - Transaction committed successfully
• Err(sqlx::Error) - Database error during commit

pub async fn rollback(self) -> Result<(), Error>

Rolls back the transaction.

Reverts all changes made during the transaction. This happens automatically if the Transaction is dropped without being committed, but this method allows for explicit rollback.

Returns

• Ok(()) - Transaction rolled back successfully
• Err(sqlx::Error) - Database error during rollback

Trait Implementations

impl<'a, 'b> Connection for &'a mut Transaction<'b>

Implementation of Connection for a mutable reference to Transaction.

type Exec<'c> = &'c mut AnyConnection where Self: 'c

The type of the executor returned by this connection.

fn executor<'c>(&'c mut self) -> Self::Exec<'c>

Returns a mutable reference to the SQLx executor.

impl<'a> Connection for Transaction<'a>

Implementation of Connection for a Transaction.

Allows the QueryBuilder to use a transaction for executing queries. Supports generic borrow lifetimes to allow multiple operations within the same transaction scope.

type Exec<'c> = &'c mut AnyConnection where Self: 'c

The type of the executor returned by this connection.

fn executor<'c>(&'c mut self) -> Self::Exec<'c>

Returns a mutable reference to the SQLx executor.

impl<'a> Debug for Transaction<'a>

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

Formats the value using the given formatter.