Struct bb8_diesel::DieselConnection

pub struct DieselConnection<C>(_);

An async-safe analogue of any connection that implements diesel::Connection.

All blocking methods within this type delegate to block_in_place. The number of threads is not unbounded, however, as they are controlled by the truly asynchronous bb8::Pool owner. This type makes it easy to use diesel without fear of blocking the runtime and without fear of spawning too many child threads.

Note that trying to construct this type via Connection::establish will panic. The only correct way to construct this type is by using a bb8 pool.

Trait Implementations

impl<C> Connection for DieselConnection<C> where
    C: Connection<TransactionManager = AnsiTransactionManager>,
    C::Backend: UsesAnsiSavepointSyntax, 

type Backend = C::Backend

The backend this type connects to

type TransactionManager = AnsiTransactionManager

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

Establishes a new connection to the database

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.

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

impl<C> Deref for DieselConnection<C>

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<C> DerefMut for DieselConnection<C>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<C> SimpleConnection for DieselConnection<C> where
    C: SimpleConnection, 

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

Execute multiple SQL statements within the same string.