Struct PoolConnection 

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

A pooled connection instrumented for OpenTelemetry.

Acquired via Pool::acquire(). Implements sqlx::Executor so it can be used directly with SQLx query builders.

When dropped, records db.client.connection.use_time – the time between acquiring the connection and returning it to the pool.

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