Struct diesel::r2d2::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 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 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 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) -> Twhere 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<'conn, 'query, DB, M, B> ConnectionGatWorkaround<'conn, 'query, DB, B> for PooledConnection<M>where M: ManageConnection, M::Connection: Connection<Backend = DB> + ConnectionGatWorkaround<'conn, 'query, DB, B>, DB: Backend,

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

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

The cursor type returned by LoadConnection::load

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

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

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

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<B, M> LoadConnection<B> for PooledConnection<M>where M: ManageConnection, M::Connection: LoadConnection<B> + R2D2Connection,

fn load<'conn, 'query, T>( &'conn mut self, source: T ) -> QueryResult<LoadRowIter<'conn, 'query, Self, Self::Backend, B>>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.