Trait Acquire

pub trait Acquire<'c> {
    type Database: Database;
    type Connection: Deref<Target = <Self::Database as Database>::Connection> + DerefMut + Send;

    // Required methods
    fn acquire(self) -> BoxFuture<'c, Result<Self::Connection, Error>>;
    fn begin(
        self,
    ) -> BoxFuture<'c, Result<Transaction<'c, Self::Database>, Error>>;
}

Acquire connections or transactions from a database in a generic way.

If you want to accept generic database connections that implement Acquire which then allows you to acquire a connection or begin a transaction, then you can do it like that:

async fn run_query<'a, A>(conn: A) -> Result<(), BoxDynError>
where
    A: Acquire<'a, Database = Postgres>,
{
    let mut conn = conn.acquire().await?;

    sqlx::query!("SELECT 1 as v").fetch_one(&mut *conn).await?;
    sqlx::query!("SELECT 2 as v").fetch_one(&mut *conn).await?;

    Ok(())
}

If you run into a lifetime error about “implementation of sqlx::Acquire is not general enough”, the workaround looks like this:

fn run_query<'a, 'c, A>(conn: A) -> impl Future<Output = Result<(), BoxDynError>> + Send + 'a
where
    A: Acquire<'c, Database = Postgres> + Send + 'a,
{
    async move {
        let mut conn = conn.acquire().await?;

        sqlx::query!("SELECT 1 as v").fetch_one(&mut *conn).await?;
        sqlx::query!("SELECT 2 as v").fetch_one(&mut *conn).await?;

        Ok(())
    }
}

However, if you really just want to accept both, a transaction or a connection as an argument to a function, then it’s easier to just accept a mutable reference to a database connection like so:

async fn run_query(conn: &mut PgConnection) -> Result<(), BoxDynError> {
    sqlx::query!("SELECT 1 as v").fetch_one(&mut *conn).await?;
    sqlx::query!("SELECT 2 as v").fetch_one(&mut *conn).await?;

    Ok(())
}

The downside of this approach is that you have to acquire a connection from a pool first and can’t directly pass the pool as argument.

Required Associated Types

type Database: Database

type Connection: Deref<Target = <Self::Database as Database>::Connection> + DerefMut + Send

Required Methods

fn acquire(self) -> BoxFuture<'c, Result<Self::Connection, Error>>

fn begin(self) -> BoxFuture<'c, Result<Transaction<'c, Self::Database>, Error>>

Implementors

impl<'a, DB: Database> Acquire<'a> for &Pool<DB>

type Database = DB

type Connection = PoolConnection<DB>

impl<'c> Acquire<'c> for &'c mut AnyConnection

type Database = Any

type Connection = &'c mut <Any as Database>::Connection

impl<'c> Acquire<'c> for &'c mut MssqlConnection

Available on crate feature mssql only.

type Database = Mssql

type Connection = &'c mut <Mssql as Database>::Connection

impl<'c> Acquire<'c> for &'c mut MySqlConnection

Available on crate feature mysql only.

type Database = MySql

type Connection = &'c mut <MySql as Database>::Connection

impl<'c> Acquire<'c> for &'c mut PoolConnection<Any>

type Database = Any

type Connection = &'c mut <Any as Database>::Connection

impl<'c> Acquire<'c> for &'c mut PoolConnection<Mssql>

Available on crate feature mssql only.

type Database = Mssql

type Connection = &'c mut <Mssql as Database>::Connection

impl<'c> Acquire<'c> for &'c mut PoolConnection<MySql>

Available on crate feature mysql only.

type Database = MySql

type Connection = &'c mut <MySql as Database>::Connection

impl<'c> Acquire<'c> for &'c mut PoolConnection<Postgres>

Available on crate feature postgres only.

type Database = Postgres

type Connection = &'c mut <Postgres as Database>::Connection

impl<'c> Acquire<'c> for &'c mut PoolConnection<Sqlite>

Available on crate feature sqlite only.

type Database = Sqlite

type Connection = &'c mut <Sqlite as Database>::Connection

impl<'c> Acquire<'c> for &'c mut PgConnection

Available on crate feature postgres only.

type Database = Postgres

type Connection = &'c mut <Postgres as Database>::Connection

impl<'c> Acquire<'c> for &'c mut SqliteConnection

Available on crate feature sqlite only.

type Database = Sqlite

type Connection = &'c mut <Sqlite as Database>::Connection

impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Any>

type Database = Any

type Connection = &'t mut <Any as Database>::Connection

impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Mssql>

Available on crate feature mssql only.

type Database = Mssql

type Connection = &'t mut <Mssql as Database>::Connection

impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, MySql>

Available on crate feature mysql only.

type Database = MySql

type Connection = &'t mut <MySql as Database>::Connection

impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Postgres>

Available on crate feature postgres only.

type Database = Postgres

type Connection = &'t mut <Postgres as Database>::Connection

impl<'c, 't> Acquire<'t> for &'t mut Transaction<'c, Sqlite>

Available on crate feature sqlite only.

type Database = Sqlite

type Connection = &'t mut <Sqlite as Database>::Connection