Struct PooledConnection 

pub struct PooledConnection<D: Driver> { /* private fields */ }

A database connection borrowed from a ConnectionPool.

Implements both Executor and Connection, so it can be used anywhere a plain connection is expected. Deref-coerces to the underlying driver connection (D::Connection) via Deref/DerefMut, giving access to any driver-specific extension methods.

The borrowed connection is automatically returned to the pool when this value is dropped. If you need to take full ownership of the connection outside pool management, call ConnectionPool::detach instead.

Obtaining a PooledConnection

Call ConnectionPool::get or ConnectionPool::timeout_get on a pool:

let mut pool = PostgresDriver::new()
    .connect_pool("postgres://localhost/mydb".into(), PoolConfig::new())
    .await?;

let mut conn = pool.get().await?;
Tank::create_table(&mut conn, true, true).await?;

Trait Implementations

impl<D: Driver> AsMut<<D as Driver>::Connection> for PooledConnection<D>

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

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

impl<D: Driver> AsRef<<D as Driver>::Connection> for PooledConnection<D>

fn as_ref(&self) -> &D::Connection

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

impl<D: Driver> Connection for PooledConnection<D>

fn connect( _driver: &D, _url: Cow<'static, str>, ) -> impl Future<Output = Result<<D as Driver>::Connection>> + Send

where Self: Sized,

Establishes a connection (or pool) to the database specified by the URL.

fn begin( &mut self, ) -> impl Future<Output = Result<<D as Driver>::Transaction<'_>>> + Send

Starts a new transaction on this connection.

fn sanitize_url(driver: &Self::Driver, url: Cow<'static, str>) -> Result<Url>

where Self: Sized,

Validates and normalizes the connection URL, handling special cases like in-memory databases.

fn disconnect(self) -> impl Future<Output = Result<()>> + Send

where Self: Sized,

Closes the connection and releases any session resources.

impl<D: Debug + Driver> Debug for PooledConnection<D>

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

Formats the value using the given formatter.

impl<D: Driver> Deref for PooledConnection<D>

type Target = <D as Driver>::Connection

The resulting type after dereferencing.

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

Dereferences the value.

impl<D: Driver> DerefMut for PooledConnection<D>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<D: Driver> Executor for PooledConnection<D>

type Driver = D

Associated driver.

fn accepts_multiple_statements(&self) -> bool

Checks if the driver supports multiple SQL statements in a single request.

fn driver(&self) -> D

Returns the driver instance associated with this executor.

fn prepare<'s>( &'s mut self, query: impl AsQuery<D> + 's, ) -> impl Future<Output = Result<Query<D>>> + Send

Prepares a query for execution, returning a handle to the prepared statement.

fn do_prepare( &mut self, sql: String, ) -> impl Future<Output = Result<Query<D>>> + Send

Internal hook for implementing prepared statement support.

fn run<'s>( &'s mut self, query: impl AsQuery<D> + 's, ) -> impl Stream<Item = Result<QueryResult>> + Send

Executes a query and streams the results (rows or affected counts).

fn fetch<'s>( &'s mut self, query: impl AsQuery<D> + 's, ) -> impl Stream<Item = Result<Row>> + Send

Executes a query and streams the resulting rows, ignoring affected counts.

fn execute<'s>( &'s mut self, query: impl AsQuery<D> + 's, ) -> impl Future<Output = Result<RowsAffected>> + Send

Executes a query and returns the total number of affected rows.

fn append<'a, E, It>( &mut self, entities: It, ) -> impl Future<Output = Result<RowsAffected>> + Send

where E: Entity + 'a, It: IntoIterator<Item = &'a E> + Send, <It as IntoIterator>::IntoIter: Send,

Efficiently inserts a collection of entities bypassing regular SQL execution when supported by the driver.