Type of a BoxedQuery on two tables joined

[lmdamato]

Backend

PostgreSQL

Diesel version

2.3.0

Diesel Features

postgres

Operating System Version

Amazon Linux 2023

Third party libraries

No response

What do you want to do?

I want to unit test a query on two tables, joined. The query can conditionally have/not have certain filters, so I'm using .into_boxed() to build the query. The table names are vendors and vendor_locations.

However, when I try to write the return type for the function, I can't find a correct type. The closest I got to is something like:

diesel::query_builder::BoxedSelectStatement<
    'a,
    (diesel::expression::select_by::SelectBy<DbVendor, diesel::pg::Pg>, diesel::sql_types::Double),
    diesel::query_builder::FromClause<JoinOn<Join<vendors, vendor_locations, Inner>, Grouped<...>>>, 
    diesel::pg::Pg,
>

But this won't compile because SelectBy and JoinOn are not public. I also tried a bunch of BoxedQuery variants, but nothing seemed to satisfy the compiler.

What's the correct return type here? Ideally I'd be able to do something simple, like:

vendors::BoxedQuery<'a, diesel::pg::Pg>

Compile time error

No response

What code do you already have?

vendors::dsl::vendors
    .inner_join(
        vendor_locations::table.on(
            vendor_locations::vendor_id.eq(vendors::id),
        ),
    )
    .into_boxed()

Additional details

If I just use the query, it works fine. So I don't think it's an issue with how I build it. I just can't figure out a correct type, for when I want to extract this to its own function. VSCode and RustRover's autocomplete were of no help, either.

Checklist

• I have already looked over the issue tracker and the discussion forum for similar possible closed issues.

[weiznich]

Any diesel query DSL function returns exactly that type that is shown in the documentation. For inner_join that dsl::InnerJoin<Self, Rhs>, where Self corresponds to the type you are calling .inner_join() on and Rhs corresponds to the type of the expression you are passing into .inner_join(). The same remains true for any other QueryDsl and ExpressionMethods method, including .into_boxed(). So you just need to put together the right type based on this pattern.

Unfortunately neither RustRover nor Rustc are a help here as they ignore these type definitions and rather show private not-accessible types instead. That's a bug on their side.

[lmdamato]

Thanks @weiznich here's what I tried next:

let mut query: vendors::BoxedQuery<'a, diesel::pg::Pg> = vendors::dsl::vendors.into_boxed();

// a bunch of if let Some(...) { query = query.filter(...); }

if some_cond {
    // This works, but the type is not boxed
    let join_query: InnerJoin<
        vendors::BoxedQuery<'_, diesel::pg::Pg>, 
        helper_types::On<vendor_locations::table, diesel::dsl::Eq<vendor_locations::vendor_id, vendors::id>>
    > = query.inner_join(
        vendor_locations::table.on(vendor_locations::vendor_id.eq(vendors::id))
    );

    // This doesn't work
    let join_query_boxed = join_query.into_boxed();
}

The former works, but of course the size of the type explodes quite rapidly. I guess if I add another .filter() or an .order_by(), things will only grow further.

The latter, instead, shows two errors:

error[E0277]: the trait bound `BoxedSelectStatement<'_, (BigInt, Text, Text, Text, Nullable<Text>, Nullable<Text>, Array<...>, ...), ..., ...>: Table` is not satisfied

and

error[E0277]: cannot box `BoxedSelectStatement<'_, (BigInt, Text, Text, Text, Nullable<Text>, Nullable<Text>, Array<Nullable<Text>>, ...), ..., ...>` for backend `_`

[lmdamato]

After some more fidgeting, I managed to write this type for the function signature:

helper_types::Select<
    helper_types::Order<
        helper_types::Filter<
            InnerJoin<
                vendors::BoxedQuery<'a, diesel::pg::Pg>, 
                helper_types::On<
                    vendor_locations::table, 
                    diesel::dsl::Eq<vendor_locations::vendor_id, 
                    vendors::id>
                >
            >,
            _,
        >,
        _
    >,
    _,
>

The extra types were so that I could add some more details to the query. @weiznich is there a way to have a more concise expression for this? Or perhaps we can have a feature request for this?

[weiznich]

This type cannot be simplified in a meaningful way with what's currently implemented. We are open to suggestions how to actually change the implementation to make this easier, but that either will require large scale changes to diesel (unclear which exactly), which is something we just don't have the capacity for or it requires losing compile time checks which is not an option at least for me.

Conceptually speaking there is the #[auto_type] macro, which allows to infer similar types in some situations if the query part is returned by a function. For technical reasons it doesn't work with boxed queries, so I did not suggest that before

[lmdamato]

I agree that losing compile-time checks is not an option. However I have another problem with the function return type I wrote above, as it causes a circular dependency error:

error[E0391]: cycle detected when computing the variances for items in this crate
    |
note: ...which requires computing function signature of `db::diesel::accessor::<impl at src/db/diesel/accessor.rs:21:1: 21:28>::augment_vendor_query_with_location`...
   --> src/db/diesel/accessor.rs:111:5
    |
111 | /     fn augment_vendor_query_with_location<'a>(
112 | |         db_query: &mut vendors::BoxedQuery<'_, diesel::pg::Pg>,
113 | |         lat: f64,
114 | |         long: f64,
...   |
131 | |             _,
132 | |         > 
    | |_________^
note: ...which requires type-checking `db::diesel::accessor::<impl at src/db/diesel/accessor.rs:21:1: 21:28>::augment_vendor_query_with_location`...
   --> src/db/diesel/accessor.rs:111:5
    |
111 | /     fn augment_vendor_query_with_location<'a>(
112 | |         db_query: &mut vendors::BoxedQuery<'_, diesel::pg::Pg>,
113 | |         lat: f64,
114 | |         long: f64,
...   |
131 | |             _,
132 | |         > 
    | |_________^
note: ...which requires computing the variances of `db::diesel::functions::st_setsrid_utils::st_setsrid`...
   --> src/db/diesel/functions.rs:25:1
    |
 25 | #[declare_sql_function]
    | ^^^^^^^^^^^^^^^^^^^^^^^
    = note: ...which again requires computing the variances for items in this crate, completing the cycle
    = note: cycle used when checking that types are well-formed

[weiznich]

I haven't seen such an error before and honestly that sounds more like a bug in rustc. Might be worth to fill an issue there include and example how to get the error. Feel free to tag me from that issue, so that I can skim in and potentially help debugging it there.

[lmdamato]

@weiznich for future reference, I found two ways around this:

1. Use a raw SQL:

fn query<'a>() -> BoxedSqlQuery<'a, diesel::pg::Pg, SqlQuery> {
  sql_query("SELECT ... INNER JOIN ...")
    .into_boxed()
    .bind::<Double, _>(...)
}

2. Just return the traits I need:

fn query() -> impl ExecuteDsl<PgConnection> + QueryFragment<diesel::pg::Pg>