Struct sqlx::Transaction

#[must_use = "transaction rolls back if not explicitly `.commit()`ed"]pub struct Transaction<C> where
    C: Connection,  { /* fields omitted */ }

Represents an in-progress database transaction.

A transaction ends with a call to commit or rollback in which the wrapped connection ( or outer transaction) is returned. 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.

// Acquire a new connection and immediately begin a transaction
let mut tx = pool.begin().await?;

sqlx::query("INSERT INTO articles (slug) VALUES ('this-is-a-slug')")
    .execute(&mut tx)
    // As we didn't fill in all the required fields in this INSERT,
    // this statement will fail. Since we used `?`, this function
    // will immediately return with the error which will cause
    // this transaction to be rolled back.
    .await?;

Methods

impl<C> Transaction<C> where
    C: Connection, 

pub async fn begin(self) -> Result<Transaction<Transaction<C>>, Error>

Creates a new save point in the current transaction and returns a new Transaction object to manage its scope.

pub async fn commit(__arg0: Self) -> Result<C, Error>

Commits the current transaction or save point. Returns the inner connection or transaction.

pub async fn rollback(__arg0: Self) -> Result<C, Error>

Rollback the current transaction or save point. Returns the inner connection or transaction.

Trait Implementations

impl<C> Connection for Transaction<C> where
    C: Connection, 

fn close(
    self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static + Send>>

Explicitly close this database connection.

fn ping(&mut self) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send>>

Checks if a connection to the database is still valid.

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

Starts a new transaction.

impl<C> Deref for Transaction<C> where
    C: Connection, 

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &<Transaction<C> as Deref>::Target

Dereferences the value.

impl<C> DerefMut for Transaction<C> where
    C: Connection, 

fn deref_mut(&mut self) -> &mut <Transaction<C> as Deref>::Target

Mutably dereferences the value.

impl<C> Drop for Transaction<C> where
    C: Connection, 

fn drop(&mut self)

Executes the destructor for this type.

impl<DB, C> Executor for Transaction<C> where
    C: Connection<Database = DB>,
    DB: Database, 

type Database = <C as Executor>::Database

The specific database that this type is implemented for.

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <Transaction<C> as Executor>::Database>, 

Executes the query for its side-effects and discarding any potential result rows.

fn fetch<'q, E>(
    &'e mut self,
    query: E
) -> <<Transaction<C> as Executor>::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, <Transaction<C> as Executor>::Database>, 

Executes a query for its result.

impl<'e, DB, C> RefExecutor<'e> for &'e mut Transaction<C> where
    C: Connection<Database = DB>,
    DB: Database, 

type Database = DB

fn fetch_by_ref<'q, E>(
    self,
    query: E
) -> <<&'e mut Transaction<C> as RefExecutor<'e>>::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, <&'e mut Transaction<C> as RefExecutor<'e>>::Database>,