Struct PooledConnection

pub struct PooledConnection<M>
where
    M: ManageConnection,
{ /* private fields */ }

Available on crate feature r2d2 only.

A smart pointer wrapping a connection.

Implementations

impl<M> PooledConnection<M>

where M: ManageConnection,

pub fn extensions(this: &PooledConnection<M>) -> &Extensions

Returns a shared reference to the extensions associated with this connection.

pub fn extensions_mut(this: &mut PooledConnection<M>) -> &mut Extensions

Returns a mutable reference to the extensions associated with this connection.

Trait Implementations

impl<M> Connection for PooledConnection<M>

where M: ManageConnection, M::Connection: Connection + R2D2Connection + Send + 'static,

type Backend = <<M as ManageConnection>::Connection as Connection>::Backend

The backend this type connects to

type TransactionManager = PoolTransactionManager<<<M as ManageConnection>::Connection as Connection>::TransactionManager>

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

The transaction manager implementation used by this connection

fn establish(_: &str) -> ConnectionResult<Self>

Establishes a new connection to the database

fn begin_test_transaction(&mut self) -> QueryResult<()>

Creates a transaction that will never be committed. This is useful for tests. Panics if called while inside of a transaction or if called with a connection containing a broken transaction

fn execute_returning_count<T>(&mut self, source: &T) -> QueryResult<usize>

where T: QueryFragment<Self::Backend> + QueryId,

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Execute a single SQL statements given by a query and return number of affected rows

fn transaction_state( &mut self, ) -> &mut <Self::TransactionManager as TransactionManager<Self>>::TransactionStateData

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Get access to the current transaction state of this connection

fn instrumentation(&mut self) -> &mut dyn Instrumentation

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Get the instrumentation instance stored in this connection

fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)

Set a specific Instrumentation implementation for this connection

fn set_prepared_statement_cache_size(&mut self, size: CacheSize)

Set the prepared statement cache size to CacheSize for this connection

fn transaction<T, E, F>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut Self) -> Result<T, E>, E: From<Error>,

Executes the given function inside of a database transaction

fn test_transaction<T, E, F>(&mut self, f: F) -> T

where F: FnOnce(&mut Self) -> Result<T, E>, E: Debug,

Executes the given function inside a transaction, but does not commit it. Panics if the given function returns an error.

impl<M> Debug for PooledConnection<M>

where M: ManageConnection, <M as ManageConnection>::Connection: Debug,

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

Formats the value using the given formatter.

impl<M> Deref for PooledConnection<M>

where M: ManageConnection,

type Target = <M as ManageConnection>::Connection

The resulting type after dereferencing.

fn deref(&self) -> &<M as ManageConnection>::Connection

Dereferences the value.

impl<M> DerefMut for PooledConnection<M>

where M: ManageConnection,

fn deref_mut(&mut self) -> &mut <M as ManageConnection>::Connection

Mutably dereferences the value.

impl<M> Drop for PooledConnection<M>

where M: ManageConnection,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A, C> ExecuteCopyFromDsl<PooledConnection<ConnectionManager<C>>> for CopyFromQuery<T, A>

where A: CopyFromExpression<T>, C: R2D2Connection<Backend = Pg> + 'static, Self: ExecuteCopyFromDsl<C>,

Available on crate feature postgres_backend only.

type Error = <CopyFromQuery<T, A> as ExecuteCopyFromDsl<C>>::Error

The error type returned by the execute function

fn execute( self, conn: &mut PooledConnection<ConnectionManager<C>>, ) -> Result<usize, Self::Error>

See the trait documentation for details

impl<B, M> LoadConnection<B> for PooledConnection<M>

where M: ManageConnection, M::Connection: LoadConnection<B> + R2D2Connection,

type Cursor<'conn, 'query> = <<M as ManageConnection>::Connection as LoadConnection<B>>::Cursor<'conn, 'query>

The cursor type returned by LoadConnection::load

type Row<'conn, 'query> = <<M as ManageConnection>::Connection as LoadConnection<B>>::Row<'conn, 'query>

The row type used as Iterator::Item for the iterator implementation of LoadConnection::Cursor

fn load<'conn, 'query, T>( &'conn mut self, source: T, ) -> QueryResult<Self::Cursor<'conn, 'query>>

where T: Query + QueryFragment<Self::Backend> + QueryId + 'query, Self::Backend: QueryMetadata<T::SqlType>,

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Executes a given query and returns any requested values

impl<M> MigrationConnection for PooledConnection<M>

where M: ManageConnection, M::Connection: MigrationConnection, Self: Connection,

fn setup(&mut self) -> QueryResult<usize>

Setup the following table:

impl<M> SimpleConnection for PooledConnection<M>

where M: ManageConnection, M::Connection: R2D2Connection + Send + 'static,

fn batch_execute(&mut self, query: &str) -> QueryResult<()>

Execute multiple SQL statements within the same string.

impl<Changes, Output, M> UpdateAndFetchResults<Changes, Output> for PooledConnection<M>

where M: ManageConnection, M::Connection: UpdateAndFetchResults<Changes, Output>, Self: Connection,

fn update_and_fetch(&mut self, changeset: Changes) -> QueryResult<Output>

See the traits documentation.

impl<M> ConnectionSealed for PooledConnection<M>

where M: ManageConnection, M::Connection: ConnectionSealed,