Struct PoolConnection 

pub struct PoolConnection<DB: Database> { /* private fields */ }

A pooled connection instrumented for OpenTelemetry.

Acquired via Pool::acquire. &mut PoolConnection<DB> implements sqlx::Executor, so the value plugs straight into the standard SQLx query builders. When the value is dropped, the connection is returned to the pool and db.client.connection.use_time is recorded with the elapsed time between acquire and drop.

Use with_annotations / with_operation to attach per-query semantic-convention attributes – the methods are inherited via the same macro that powers the equivalents on Pool and Transaction.

Example

let mut conn = pool.acquire().await?;
let row: (i64,) = sqlx::query_as("SELECT 1").fetch_one(&mut conn).await?;
assert_eq!(row.0, 1);

Implementations

impl<DB: Database> PoolConnection<DB>

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<DB: Database> Debug for PoolConnection<DB>

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

Formats the value using the given formatter.

impl<DB: Database> Drop for PoolConnection<DB>

fn drop(&mut self)

Executes the destructor for this type.

impl<'c, DB> Executor<'c> for &'c mut PoolConnection<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