Struct SqlxOpStoreTx 

#[non_exhaustive]
pub struct SqlxOpStoreTx<DB: Database> { /* private fields */ }

A SqlxOpStore scoped to one open sqlx transaction — every store method called on it runs inside that transaction, and nothing lands until commit.

Obtain one from [SqlxOpStore::begin_tx]. Dropping it without committing rolls back, so an early ? in the middle of a composed unit of work cannot leave a half-written state behind.

Composing with the host application’s own writes

This is the point of the type. as_mut hands back the live connection, so the application’s own statements and the store’s run in the same transaction and commit or roll back together:

let mut tx = store.begin_tx().await?;

sqlx::query("INSERT INTO app_users (id, email) VALUES (?1, ?2)")
    .bind(&user_id)
    .bind(&email)
    .execute(tx.as_mut())
    .await?;

tx.store_token(refresh_token).await?;   // same transaction

tx.commit().await?;                     // both, or neither

Reaching the native connection is deliberately an inherent method rather than something on the OpStoreTransaction trait: the host’s own queries are written against a concrete driver, so there is nothing for a backend-agnostic trait to usefully return here. Keeping it off the trait is what lets the trait stay dyn-compatible.

Implementations

impl<DB: Database> SqlxOpStoreTx<DB>

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

Commit, making every write in this transaction durable at once.

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

Roll back, discarding every write in this transaction.

Dropping does this too; calling it explicitly is how a caller gets to see a rollback failure rather than have Drop swallow it.

Trait Implementations

impl<DB: Database> AsMut<<DB as Database>::Connection> for SqlxOpStoreTx<DB>

The live connection inside this transaction, for the host application’s own statements — tx.as_mut(), exactly as it reads on a bare sqlx::Transaction, so a caller’s queries look the way they would anywhere else in their code.

fn as_mut(&mut self) -> &mut DB::Connection

Converts this type into a mutable reference of the (usually inferred) input type.

impl<DB: Debug + Database> Debug for SqlxOpStoreTx<DB>

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

Formats the value using the given formatter.