Struct Transaction 

pub struct Transaction { /* private fields */ }

An open database transaction.

Wraps a pinned connection with an active BEGIN. Implements Executor so it can be passed directly to any ORM query method in place of a Database.

Drop the handle without calling commit and the transaction is rolled back automatically.

Implementations

impl Transaction

pub async fn commit(&mut self) -> Result<()>

Commits the transaction.

If the COMMIT statement fails, a best-effort ROLLBACK is issued before the error is returned so the connection is always left in a clean state.

Errors

Returns the database error if COMMIT fails.

pub async fn rollback(&mut self) -> Result<()>

Rolls back the transaction explicitly.

Errors

Returns the database error if ROLLBACK fails.

pub async fn savepoint<F, R>(&self, f: F) -> Result<R>

where F: for<'a> FnOnce(&'a Transaction) -> BoxFuture<'a, Result<R>>, R: Send + 'static,

Runs f inside a savepoint nested within this transaction.

The savepoint is committed (released) on Ok and rolled back on Err. Unlike a top-level transaction rollback, rolling back a savepoint only undoes the work done inside f; the outer transaction continues.

Examples

use tork_orm_core::{Database, Executor, OrmError};

let db = Database::connect("sqlite::memory:", 1).await?;
db.execute("CREATE TABLE t (x INTEGER)".into(), vec![]).await?;
db.transaction(|tx| Box::pin(async move {
    tx.execute("INSERT INTO t VALUES (1)".into(), vec![]).await?;
    // This inner failure only undoes the INSERT of 2; the INSERT of 1 survives.
    let _ = tx.savepoint(|sp| Box::pin(async move {
        sp.execute("INSERT INTO t VALUES (2)".into(), vec![]).await?;
        Err::<(), _>(OrmError::query("oops"))
    })).await;
    Ok(())
})).await?;

Errors

Returns an error if the savepoint SQL fails or if f returns an error (after rolling back the savepoint).

Trait Implementations

impl Drop for Transaction

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Executor for Transaction

fn dialect(&self) -> &dyn Dialect

Returns the dialect SQL should be rendered with before running.

fn fetch_all( &self, sql: String, params: Vec<Value>, ) -> impl Future<Output = Result<Vec<Row>>> + Send

Runs a row-returning query.

fn execute( &self, sql: String, params: Vec<Value>, ) -> impl Future<Output = Result<ExecuteResult>> + Send

Runs a statement that returns no rows.