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> 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<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<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.