Struct sqlx_core::transaction::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: Database> Acquire<'t> for &'t mut Transaction<'c, DB>

type Database = DB

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

fn acquire(self) -> BoxFuture<'t, Result<Self::Connection, Error>>

fn begin(self) -> BoxFuture<'t, Result<Transaction<'t, DB>, Error>>

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

fn as_mut(&mut self) -> &mut DB::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

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) -> &Self::Target

Dereferences the value.

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

where DB: Database,

fn deref_mut(&mut self) -> &mut Self::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.