Struct sqlx::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
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static + Send>>

Explicitly close this database connection.

fn ping(&mut self) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send>>

Checks if a connection to the database is still valid.

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

Starts a new transaction.

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

type Target = C

The resulting type after dereferencing.

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

Dereferences the value.

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

fn deref_mut(&mut self) -> &mut <PoolConnection<C> as Deref>::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 as Executor>::Database

The specific database that this type is implemented for.

fn execute<'e, 'q, 'c, E>(
    &'c mut self,
    query: E
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'e + Send>> where
    'q: 'e,
    'c: 'e,
    E: 'e + Execute<'q, <PoolConnection<C> as Executor>::Database>, 

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

fn fetch<'q, E>(
    &'e mut self,
    query: E
) -> <<C as Executor>::Database as HasCursor<'e, 'q>>::Cursor where
    E: Execute<'q, <PoolConnection<C> as Executor>::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, Database = DB> + HasCursor<'c2, 'q>,
    &'c mut C: RefExecutor<'c>,
    <&'c mut C as RefExecutor<'c>>::Database == DB, 

type Database = DB

fn fetch_by_ref<'q, E>(
    self,
    query: E
) -> <<&'c mut PoolConnection<C> as RefExecutor<'c>>::Database as HasCursor<'c, 'q>>::Cursor where
    E: Execute<'q, <&'c mut PoolConnection<C> as RefExecutor<'c>>::Database>,