Struct Transaction 

pub struct Transaction { /* private fields */ }

A database transaction, from Db::begin.

Implementations

impl Transaction

pub fn dialect(&self) -> Dialect

The engine this transaction runs on.

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

Commits the transaction.

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

Rolls the transaction back (dropping it uncommitted does the same).

pub async fn savepoint<T, F>(&mut self, work: F) -> Result<T>

where F: for<'t> FnOnce(&'t mut Transaction) -> BoxFuture<'t, Result<T>>,

Runs work inside a savepoint (a transaction inside the transaction): when it returns Err, only what it did is undone and the transaction goes on; when it returns Ok, its changes stay, to be committed (or rolled back) with the rest. Savepoints nest.

let mut tx = db.begin().await?;
renox::db::sql("INSERT INTO orders (total) VALUES (?)").bind(18_000).execute(&mut tx).await?;
// Optional: a voucher that may be used up already. If it is, the order stays.
let voucher = tx
    .savepoint(|tx| {
        Box::pin(async move {
            let used = renox::db::sql("UPDATE vouchers SET used = used + 1 WHERE code = ? AND used < max_uses")
                .bind("KOPI10")
                .execute(&mut *tx)
                .await?;
            renox::abort_if(used == 0, StatusCode::CONFLICT, "used up")?;
            Ok(())
        })
    })
    .await;
tx.commit().await?;

On PostgreSQL a failed statement stops the whole transaction until it rolls back; inside a savepoint only the savepoint rolls back, so the transaction can go on after an expected failure (a unique violation you handle, say).

Trait Implementations

impl Debug for Transaction

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

Formats the value using the given formatter.

impl<'c> Executor<'c> for &'c mut Transaction