Lifetime issue with QueryBuilder and generics

[Naxdy]

Hey, I'm currently having an issue with using QueryBuilder in conjunction with generics. Consider the following minimal example:

async fn does_not_work<'c, E, DB>(executor: E)
where
    E: Executor<'c, Database = DB>,
    DB: Database,
    for<'q> <DB as Database>::Arguments<'q>: IntoArguments<'q, DB>,
{
    let mut builder = QueryBuilder::new("");
    let _ = executor.fetch_one(builder.build()).await;
}

This causes the compiler to complain that "builder does not live long enough", as apparently it's dropped when the function ends, but is still borrowed (according to the compiler anyway).

I can work around this, by adding 'c to Arguments, like so:

async fn does_not_work<'c, E, DB>(executor: E)
where
    E: Executor<'c, Database = DB>,
    DB: Database,
    for<'q> <DB as Database>::Arguments<'q>: IntoArguments<'q, DB> + 'c,
{
    let mut builder = QueryBuilder::new("");
    let _ = executor.fetch_one(builder.build()).await;
}

This lets me compile the function, but calling it with the Sqlite driver causes another compilation error, namely that "implementation of IntoArguments is not general enough".

Converting 'q to be a named lifetime does not work either:

async fn does_not_work<'c, 'q, E, DB>(executor: E)
where
    E: Executor<'c, Database = DB>,
    DB: Database,
   <DB as Database>::Arguments<'q>: IntoArguments<'q, DB>,
{
    let mut builder = QueryBuilder::new("");
    let _ = executor.fetch_one(builder.build()).await;
}

As in this scenario, the compiler mentions that "builder does not live long enough" as "argument requires that builder is borrowed for 'q".

Finally, for good measure, if I just specify the Sqlite driver directly, the function does compile and can be called properly:

async fn does_not_work<'c, E>(executor: E)
where
    E: Executor<'c, Database = Sqlite>,
{
    let mut builder = QueryBuilder::new("");
    let _ = executor.fetch_one(builder.build()).await;
}

But obviously, the latter is undesirable, as it is meant to be a driver-agnostic function.

My question is: What am I missing here? I was looking at sqlx' trait bounds for Database, Arguments, IntoArguments, Execute, and Executor but didn't manage to find anything. Is it even possible to get a function like this to compile with the current API?

[iamjpotts]

A modification of your first example which omits the lifetime arguments altogether will now compile with 0.9.0-alpha1

async fn does_not_work_in_08x_but_does_in_09x<'c, E, DB>(executor: E)
where
    E: Executor<'c, Database = DB>,
    DB: Database,
    <DB as Database>::Arguments: IntoArguments<DB>,
{
    let mut builder = QueryBuilder::new("");
    let _ = executor.fetch_one(builder.build()).await;
}

0.9.0 will have breaking changes from 0.8 (removal of lifetime parameter on Arguments trait and related items) which address the difficulty with the original version of your first example.