Struct DieselAsyncPostgresBackend

pub struct DieselAsyncPostgresBackend<P: DieselPoolAssociation<AsyncPgConnection>> { /* private fields */ }

Diesel async Postgres backend

Implementations

impl<P: DieselPoolAssociation<AsyncPgConnection>> DieselAsyncPostgresBackend<P>

pub async fn new( privileged_config: PrivilegedPostgresConfig, create_privileged_pool: impl Fn(AsyncDieselConnectionManager<AsyncPgConnection>) -> P::Builder, create_restricted_pool: impl Fn(AsyncDieselConnectionManager<AsyncPgConnection>) -> P::Builder + Send + Sync + 'static, custom_create_connection: Option<Box<dyn Fn() -> SetupCallback<AsyncPgConnection> + Send + Sync + 'static>>, create_entities: impl Fn(AsyncPgConnection) -> Pin<Box<dyn Future<Output = Option<AsyncPgConnection>> + Send + 'static>> + Send + Sync + 'static, ) -> Result<Self, P::BuildError>

Creates a new Diesel async Postgres backend

Example

use bb8::Pool;
use db_pool::{
    r#async::{DieselAsyncPostgresBackend, DieselBb8},
    PrivilegedPostgresConfig,
};
use diesel::sql_query;
use diesel_async::RunQueryDsl;
use dotenvy::dotenv;

async fn f() {
    dotenv().ok();

    let config = PrivilegedPostgresConfig::from_env().unwrap();

    let backend = DieselAsyncPostgresBackend::<DieselBb8>::new(
        config,
        |_| Pool::builder().max_size(10),
        |_| Pool::builder().max_size(2),
        None,
        move |mut conn| {
            Box::pin(async {
                sql_query("CREATE TABLE book(id SERIAL PRIMARY KEY, title TEXT NOT NULL)")
                    .execute(&mut conn)
                    .await
                    .unwrap();
                Some(conn)
            })
        },
    )
    .await
    .unwrap();
}

tokio_test::block_on(f());

If, after running migrations, the connection has not been moved, it is preferable to return the connection with Some(conn). However, if after running migrations, the connection has been moved, None can be returned at the expense of the backend having to establish the same connection again for some of its internal work.

pub fn drop_previous_databases(self, value: bool) -> Self

Drop databases created in previous runs upon initialization

Trait Implementations

impl<P: DieselPoolAssociation<AsyncPgConnection>> Backend for DieselAsyncPostgresBackend<P>

type Pool = <P as DieselPoolAssociation<AsyncPgConnection>>::Pool

Connection pool type that implements Send

type BuildError = <P as DieselPoolAssociation<AsyncPgConnection>>::BuildError

Connection pool build error type that implements Debug and Send

type PoolError = <P as DieselPoolAssociation<AsyncPgConnection>>::PoolError

Connection pool error type that implements Debug and Send

type ConnectionError = ConnectionError

Connection error type that implements Debug

type QueryError = Error

Query error type that implements Debug

fn init<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error<P::BuildError, P::PoolError, ConnectionError, Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Initializes the backend

fn create<'life0, 'async_trait>( &'life0 self, db_id: Uuid, restrict_privileges: bool, ) -> Pin<Box<dyn Future<Output = Result<P::Pool, Error<P::BuildError, P::PoolError, ConnectionError, Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Creates a database

fn clean<'life0, 'async_trait>( &'life0 self, db_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<(), Error<P::BuildError, P::PoolError, ConnectionError, Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cleans a database

fn drop<'life0, 'async_trait>( &'life0 self, db_id: Uuid, is_restricted: bool, ) -> Pin<Box<dyn Future<Output = Result<(), Error<P::BuildError, P::PoolError, ConnectionError, Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Drops a database