Struct Transaction

pub struct Transaction<'c, DB>
where
    DB: Database,
{ /* private fields */ }

An in-progress database transaction or savepoint.

A transaction starts with a call to Pool::begin or Connection::begin.

A transaction should end with a call to commit or rollback. If neither are called before the transaction goes out-of-scope, rollback is called. In other words, rollback is called on drop if the transaction is still in-progress.

A savepoint is a special mark inside a transaction that allows all commands that are executed after it was established to be rolled back, restoring the transaction state to what it was at the time of the savepoint.

A transaction can be used as an Executor when performing queries:

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

let result = sqlx::query("DELETE FROM \"testcases\" WHERE id = $1")
    .bind(id)
    .execute(&mut *tx)
    .await?
    .rows_affected();

tx.commit().await

Implementations

impl<'c, DB> Transaction<'c, DB>

where DB: Database,

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

Commits this transaction or savepoint.

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

Aborts this transaction or savepoint.

Trait Implementations

impl<'c, 't, DB> Acquire<'t> for &'t mut Transaction<'c, DB>

where DB: Database,

type Database = DB

type Connection = &'t mut <DB as Database>::Connection

fn acquire( self, ) -> Pin<Box<dyn Future<Output = Result<<&'t mut Transaction<'c, DB> as Acquire<'t>>::Connection, Error>> + Send + 't>>

fn begin( self, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'t, DB>, Error>> + Send + 't>>

impl<'c, DB> AsMut<<DB as Database>::Connection> for Transaction<'c, DB>

where DB: Database,

fn as_mut(&mut self) -> &mut <DB as Database>::Connection

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'c, DB> Debug for Transaction<'c, DB>

where DB: Database,

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

Formats the value using the given formatter.

impl<'c, DB> Deref for Transaction<'c, DB>

where DB: Database,

type Target = <DB as Database>::Connection

The resulting type after dereferencing.

fn deref(&self) -> &<Transaction<'c, DB> as Deref>::Target

Dereferences the value.

impl<'c, DB> DerefMut for Transaction<'c, DB>

where DB: Database,

fn deref_mut(&mut self) -> &mut <Transaction<'c, DB> as Deref>::Target

Mutably dereferences the value.

impl<'c, DB> Drop for Transaction<'c, DB>

where DB: Database,

fn drop(&mut self)

Executes the destructor for this type.