Struct Transaction 

pub struct Transaction<'c, DB: Database> { /* private fields */ }

An in-progress database transaction instrumented for OpenTelemetry.

Wraps a sqlx::Transaction and propagates the connection-level attributes and metric instruments. Pass &mut transaction directly to SQLx query builders – the sqlx::Executor impl on &mut Transaction produces the same per-operation spans and metrics as the parent pool.

Started by Pool::begin. Call commit or rollback to finish the transaction; dropping the value without committing rolls it back implicitly. Use with_annotations / with_operation to attach per-query semantic-convention attributes.

Example

let mut tx = pool.begin().await?;
sqlx::query("INSERT INTO orders (id) VALUES (1)")
    .execute(&mut tx)
    .await?;
tx.commit().await?;

Implementations

impl<DB> Transaction<'_, DB>

where DB: Database,

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

Commit the transaction.

Errors

Returns sqlx::Error if the commit fails.

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

Roll back the transaction.

Errors

Returns sqlx::Error if the rollback fails.

pub fn with_annotations( &mut self, annotations: QueryAnnotations, ) -> AnnotatedMut<'_, Self>

Return an annotated executor that attaches per-query semantic convention attributes to every span created by the next operation.

The returned wrapper borrows self mutably and implements sqlx::Executor with the same instrumentation, but with annotation values threaded through to span creation.

pub fn with_operation( &mut self, operation: impl Into<String>, collection: impl Into<String>, ) -> AnnotatedMut<'_, Self>

Shorthand for annotating the next operation with db.operation.name and db.collection.name.

Equivalent to self.with_annotations(QueryAnnotations::new().operation(op).collection(coll)).

Trait Implementations

impl<'c, DB: Debug + Database> Debug for Transaction<'c, DB>

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

Formats the value using the given formatter.

impl<'c, DB> Executor<'c> for &'c mut Transaction<'_, DB>

where DB: Database, for<'a> &'a mut DB::Connection: Executor<'a, Database = DB>,

fn execute<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<<DB as Database>::QueryResult, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and return the total number of rows affected.

fn execute_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<<DB as Database>::QueryResult, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<<DB as Database>::Row, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and return the generated results as a stream.

fn fetch_many<'e, 'q: 'e, E>( self, query: E, ) -> BoxStream<'e, Result<Either<<DB as Database>::QueryResult, <DB as Database>::Row>, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_all<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Vec<<DB as Database>::Row>, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<<DB as Database>::Row, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and returns exactly one row.

fn fetch_optional<'e, 'q: 'e, E>( self, query: E, ) -> BoxFuture<'e, Result<Option<<DB as Database>::Row>, Error>>

where E: 'q + Execute<'q, DB>, 'c: 'e,

Execute the query and returns at most one row.

fn prepare<'e, 'q: 'e>( self, query: &'q str, ) -> BoxFuture<'e, Result<<DB as Database>::Statement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.

Be advised that when using the query, query_as, or query_scalar functions, the query is transparently prepared and executed.

This explicit API is provided to allow access to the statement metadata available after it prepared but before the first row is returned.

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<DB as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<DB as Database>::Statement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

Only some database drivers (Postgres, MSSQL) can take advantage of this extra information to influence parameter type inference.

type Database = DB