Struct PoolConnection 

pub struct PoolConnection<DB>
where
    DB: Database,
{
    live: Option<Live<DB>>,
    close_on_drop: bool,
    pub(crate) pool: Arc<PoolInner<DB>>,
}

A connection managed by a Pool.

Will be returned to the pool on-drop.

Fields

live: Option<Live<DB>>

close_on_drop: bool

pool: Arc<PoolInner<DB>>

Implementations

impl<DB> PoolConnection<DB>

where DB: Database,

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

Close this connection, allowing the pool to open a replacement.

Equivalent to calling .detach() then .close(), but the connection permit is retained for the duration so that the pool may not exceed max_connections.

pub fn close_on_drop(&mut self)

Close this connection on-drop, instead of returning it to the pool.

May be used in cases where waiting for the .close() call to complete is unacceptable, but you still want the connection to be closed gracefully so that the server can clean up resources.

pub fn detach(self) -> <DB as Database>::Connection

Detach this connection from the pool, allowing it to open a replacement.

Note that if your application uses a single shared pool, this effectively lets the application exceed the max_connections setting.

If min_connections is nonzero, a task will be spawned to replace this connection.

If you want the pool to treat this connection as permanently checked-out, use .leak() instead.

pub fn leak(self) -> <DB as Database>::Connection

Detach this connection from the pool, treating it as permanently checked-out.

This effectively will reduce the maximum capacity of the pool by 1 every time it is used.

If you don’t want to impact the pool’s capacity, use .detach() instead.

Trait Implementations

impl<'c, DB> Acquire<'c> for &'c mut PoolConnection<DB>

where DB: Database,

type Database = DB

type Connection = &'c mut <DB as Database>::Connection

fn acquire( self, ) -> Pin<Box<dyn Future<Output = Result<<&'c mut PoolConnection<DB> as Acquire<'c>>::Connection, Error>> + Send + 'c>>

fn begin( self, ) -> Pin<Box<dyn Future<Output = Result<Transaction<'c, DB>, Error>> + Send + 'c>>

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

where DB: Database,

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

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

impl<DB> AsRef<<DB as Database>::Connection> for PoolConnection<DB>

where DB: Database,

fn as_ref(&self) -> &<DB as Database>::Connection

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

impl<DB> Debug for PoolConnection<DB>

where DB: Database,

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

Formats the value using the given formatter.

impl<DB> Deref for PoolConnection<DB>

where DB: Database,

type Target = <DB as Database>::Connection

The resulting type after dereferencing.

fn deref(&self) -> &<PoolConnection<DB> as Deref>::Target

Dereferences the value.

impl<DB> DerefMut for PoolConnection<DB>

where DB: Database,

fn deref_mut(&mut self) -> &mut <PoolConnection<DB> as Deref>::Target

Mutably dereferences the value.

impl<DB> Drop for PoolConnection<DB>

where DB: Database,

Returns the connection to the Pool it was checked-out from.

fn drop(&mut self)

Executes the destructor for this type.

impl<'c, DB> From<PoolConnection<DB>> for MaybePoolConnection<'c, DB>

where DB: Database,

fn from(v: PoolConnection<DB>) -> MaybePoolConnection<'c, DB>

Converts to this type from the input type.