Struct sqlx_core::transaction::Transaction

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>>>

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>

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

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

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) -> BoxFuture<'static, Result<()>>

Explicitly close this database connection.

fn ping(&mut self) -> BoxFuture<Result<()>>

Checks if a connection to the database is still valid.

fn begin(self) -> BoxFuture<'static, Result<Transaction<Self>>> where
    Self: Sized, 

Starts a new transaction.

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

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

fn deref_mut(&mut self) -> &mut Self::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
    DB: Database,
    C: Connection<Database = DB>, 

type Database = C::Database

The specific database that this type is implemented for.

fn execute<'e, 'q: 'e, 'c: 'e, E: 'e>(
    &'c mut self,
    query: E
) -> BoxFuture<'e, Result<u64>> where
    E: Execute<'q, Self::Database>, 

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

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

Executes a query for its result.

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

type Database = DB

fn fetch_by_ref<'q, E>(
    self,
    query: E
) -> <Self::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, Self::Database>,