Passing Executor types for reads that may be within a write context

[psionic-k]

When reading from within a transaction, such as for tests, I need to pass in the transaction, not a pool that has no idea about the in-progress writes. This makes my read APIs need to be compatible with any Executor, not just pools. My write functions always accept a transaction, and there is no conflict.

Whenever I tried to write functions that would accept Executor types, I was unable to convince the type system to do this. Does anyone have a working example?

An example of using a transaction for a read request so that I can pass it open transactions and read from any checkpoints within.

    pub async fn from_id(tx: &mut PgTransaction<'_>, user_id: &UserId) ->
    Result<Option<User>, ModelError> {
        let found: Option<User> = sqlx::query_as!(User,
            r#"
            SELECT user_id as "user_id: UserId",
                   display_name,
                   account_email as "account_email: DbMail",
                   flags as "flags: UserFlags"
            FROM users WHERE user_id = $1 LIMIT 1;
            "#,
            user_id as &UserId
        ).fetch_optional(&mut **tx)
            .await?;
        Ok(found)
    }

I didn't try calling acquire on the transaction yet, but doesn't that just obtain a unique connection that would not see the transaction's checkpoints? In the end, I'm still curious how others handle the general issue.

[kirillsalykin]

If I understand you correctly you want something like this?

async fn insert_thing<'e, E>(executor: E, thing: Thing)
where
    E: Executor<'e, Database = Postgres>,
{
...
}

and then call it like this:

    let mut tx = db.begin().await.unwrap();
    insert_thing(&mut *tx, thing).await;
    tx.commit().await.unwrap();