Mismatched types error in generic code

1

I've been trying to generalize a function to accept an sqlx::Executor. This is what I came up with:

pub async fn create_sign_request<'e, 'c: 'e, E>(
    executor: &'e E,
    params: SignRequestParams,
) -> Result<SignRequest>
where
    &'e E: SqliteExecutor<'c>,
{
    let record = sqlx::query_file_as!(
        SignRequest,
        "sql/insert_sign_request.sql",
        params.id,
        params.kind,
        params.url,
        params.timeout
    )
    .fetch_one(executor)
    .await
    .context("insert signing request")?;

    sqlx::query_file!("sql/insert_pending_request.sql", params.id)
        .execute(executor)
        .await
        .context("insert pending request")?;

    Ok(record)
}

This works nice when passed &Pool<Sqlite>. But when passed &mut SqliteConnection it yells at me with:

error[E0308]: mismatched types
  --> src/bin/signer-webapi/handlers/sign.rs:45:17
   |
44 |             let record = signer::db::create_sign_request(
   |                          ------------------------------- arguments to this function are incorrect
45 |                 &mut *txn,
   |                 ^^^^^^^^^ expected `&Pool<Sqlite>`, found `&mut SqliteConnection`
   |
   = note:      expected reference `&Pool<Sqlite>`
           found mutable reference `&mut SqliteConnection`

Why is the compiler expecting &Pool<Sqlite> where no place in the function definition even mentions this type?

2

I don't know why you would get that error, maybe just forgot to save the file or something? :sweat_smile:
I think the function itself won't even compile, because fetch_one and execute expect an Executor, not a reference to one and references to Executors don't themselves implement Executor. You will almost certainly have to use Acquire instead - there are some example for using it in the docs.

1 Like
3

I think because &Pool<Sqlite> is the only applicable implementor.

your trait bound is too specific, it explicitly requires the implementor to be a shared reference type:

where
    &'e E: SqliteExecutor<'c>,

looking at the implementors of the trait, &Pool<_> is the only one in the form of shared reference, all other implementors are in the form of exclusive references, like &'c mut MysqlConnection, &'c mut SqliteConnection.

you can just simply the signature like this:

pub async fn create_sign_request<'c>(
    executor: impl SqliteExecutor<'c>,
    params: SignRequestParams,
) -> Result<SignRequest>;
1 Like
4

@nerditation I started with impl SqliteExecutor but my function calls two methods on Executor (fetch_one and execute) which consume it and so the second one ends with "use of moved value executor" error. This is why I started playing with references.

5

@jplatte thanks for the tip! It seems that Executor is not the right tool for this task and Acquire is the way to go. When I looked at definitions of fetch_one and execute I came to the wrong conclusion that I need to use Executor.

6

due to the way the Executor trait is defined, where all methods consumes self, it is not directly expressible using generics, since exlusive references and shared references are different.

in non-generic code, shared references are Copy, and exclusive references can be reborrowed, so it's ok to call the trait methods multiple times.

ideally, you want the Executor trait to get an update, but for now, you'll need to create another helper trait to abstract away the difference between the shared references and exclusive references. here's an example using GAT:

trait AsSqliteExecutor {
    type Executor<'c>: SqliteExecutor<'c> where Self: 'c;
    // use exclusive borrow `&mut self` so it can 
    fn as_sqlite_executor(&mut self) -> Self::Executor<'_>;
}

note this doesn't allow a blanket implementation, since the SqliteExecutor<'c> trait doesn't have an explicit reborrow method, so you have to manually implement it for the types you used, like &Pool<_> and &mut SqliteConnection.

1 Like