Struct sqlx_core::pool::PoolConnection

pub struct PoolConnection<C> where
    C: Connect,  { /* fields omitted */ }

A connection checked out from Pool.

Will be returned to the pool on-drop.

Trait Implementations

impl<C> Borrow<C> for PoolConnection<C> where
    C: Connect, 

fn borrow(&self) -> &C

Immutably borrows from an owned value.

impl<C> BorrowMut<C> for PoolConnection<C> where
    C: Connect, 

fn borrow_mut(&mut self) -> &mut C

Mutably borrows from an owned value.

impl<C> Connection for PoolConnection<C> where
    C: Connect, 

fn close(self) -> BoxFuture<'static, Result<()>>

Explicitly close this database connection.

fn ping(&mut self) -> BoxFuture<Result<()>>

Checks if a connection to the database is still valid.

fn begin(self) -> BoxFuture<'static, Result<Transaction<Self>>> where
    Self: Sized, 

Starts a new transaction.

impl<C> Deref for PoolConnection<C> where
    C: Connect, 

type Target = C

The resulting type after dereferencing.

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

Dereferences the value.

impl<C> DerefMut for PoolConnection<C> where
    C: Connect, 

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

Mutably dereferences the value.

impl<C> Drop for PoolConnection<C> where
    C: Connect, 

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

fn drop(&mut self)

Executes the destructor for this type.

impl<C> Executor for PoolConnection<C> where
    C: Connect, 

type Database = C::Database

The specific database that this type is implemented for.

fn execute<'e, 'q: 'e, 'c: 'e, E: 'e>(
    &'c mut self,
    query: E
) -> BoxFuture<'e, Result<u64>> where
    E: Execute<'q, Self::Database>, 

Executes the query for its side-effects and discarding any potential result rows.

fn fetch<'e, 'q, E>(
    &'e mut self,
    query: E
) -> <C::Database as HasCursor<'_, 'q>>::Cursor where
    E: Execute<'q, Self::Database>, 

Executes a query for its result.

impl<'c, C, DB> RefExecutor<'c> for &'c mut PoolConnection<C> where
    C: Connect<Database = DB>,
    DB: Database<Connection = C>,
    DB: for<'c2, 'q> HasCursor<'c2, 'q, Database = DB>,
    &'c mut C: RefExecutor<'c, Database = DB>, 

type Database = DB

fn fetch_by_ref<'q, E>(
    self,
    query: E
) -> <Self::Database as HasCursor<'c, 'q>>::Cursor where
    E: Execute<'q, Self::Database>,