Struct diesel::r2d2::PooledConnection

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

A smart pointer wrapping a connection.

Trait Implementations

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> Drop for PooledConnection<M> where     M: ManageConnection,

fn drop(&mut self)

Executes the destructor for this type.

impl<M> DerefMut for PooledConnection<M> where     M: ManageConnection,

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

Mutably dereferences the value.

impl<T> SimpleConnection for PooledConnection<ConnectionManager<T>> where     T: Connection + Send + 'static,

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

Execute multiple SQL statements within the same string.

impl<C> Connection for PooledConnection<ConnectionManager<C>> where     C: Connection<TransactionManager = AnsiTransactionManager> + Send + 'static,     C::Backend: UsesAnsiSavepointSyntax,

type Backend = C::Backend

The backend this type connects to

type TransactionManager = C::TransactionManager

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

Establishes a new connection to the database

fn execute(&self, query: &str) -> QueryResult<usize>

fn query_by_index<T, U>(&self, source: T) -> QueryResult<Vec<U>> where     T: AsQuery,     T::Query: QueryFragment<Self::Backend> + QueryId,     Self::Backend: HasSqlType<T::SqlType>,     U: Queryable<T::SqlType, Self::Backend>,

fn query_by_name<T, U>(&self, source: &T) -> QueryResult<Vec<U>> where     T: QueryFragment<Self::Backend> + QueryId,     U: QueryableByName<Self::Backend>,

fn execute_returning_count<T>(&self, source: &T) -> QueryResult<usize> where     T: QueryFragment<Self::Backend> + QueryId,

fn transaction_manager(&self) -> &Self::TransactionManager

fn transaction<T, E, F>(&self, f: F) -> Result<T, E> where     F: FnOnce() -> Result<T, E>,     E: From<Error>,

Executes the given function inside of a database transaction

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

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

fn test_transaction<T, E, F>(&self, f: F) -> T where     F: FnOnce() -> 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.