question about custom QueryFragment

[Zstorm999]

Hello !

I have a question (and a problem) about implementing a custom QueryFragment. I followed the steps in the guide, a wrote my query fragment with a custom load_with_infos method:

impl<T> Pagination<T> {
    /// Load the requested page, returning the content and page metadata
    pub async fn load_with_info<'query, U>(
        self,
        conn: &mut Object<AsyncPgConnection>,
    ) -> QueryResult<(Vec<U>, PageInfo)>
    where
        Self: LoadQuery<'query, Object<AsyncPgConnection>, (U, i64)>,
        U: Send,
        T: 'query,
    {
        let page_size = self.limit;
        let offset = self.offset;
        let results = self.load::<(U, i64)>(conn).await?;

        let total_records = results.get(0).map(|x| x.1).unwrap_or(0);
        let records = results.into_iter().map(|x| x.0).collect();

        // Note: the float conversion is wrong only if total_records > 2^52
        let (total_pages, page_num) = match page_size {
            Some(page_size) => (
                (total_records as f64 / page_size as f64).ceil() as i64,
                offset / page_size,
            ),
            None => (1, 0),
        };

        Ok((
            records,
            PageInfo {
                page_size,
                total_pages,
                page_num,
            },
        ))
    }
}

(don’t mind the async, I’m using diesel_async)

This implementation is working fine for most cases, but I have a special use case somewhere.
I have to structs querying different information on the same table, like this:

#[derive(Queryable, Selectable)]
#[diesel(table_name = "my_table")]
struct PartA {
    field_a: i32,
}

#[derive(Queryable, Selectable)]
#[diesel(table_name = "my_table")]
struct PartB {
    field_b: i32,
}

My original intent was to query both structs at once with a tuple (this works with regular load):

let (content, page_info = my_table::table
    .select((PartA::as_select(), PartB::as_select()))
   .load_with_infos()
   .await?;

However, I get an error from the compiler:

the trait bound `(diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>): diesel::util::TupleSize` is not satisfied

Any idea where this might come from ?

[weiznich]

Would it be possible to provide the complete error message as emitted by rustc and not a truncated version? That makes it much easier for us to see what's wrong here. Also you might want to include more information in your source code as well. Ideally that should be a self contained minimal example. At least it should contain definitions and trait implementations for all types not from diesel.

[Zstorm999]

According to your suggestion, I wrote a "simple" example displaying this behaviour.

Minimum reproduction

use std::error::Error;

use diesel::{
    pg::Pg,
    query_builder::{Query, QueryFragment, QueryId},
    query_dsl::methods::{LoadQuery, SelectDsl},
    sql_types::BigInt,
    Connection, PgConnection, QueryResult, Queryable, RunQueryDsl, Selectable, SelectableHelper,
};

pub trait Paginate: Sized {
    fn paginate(self) -> Pagination<Self>;
}

impl<T> Paginate for T {
    fn paginate(self) -> Pagination<Self> {
        Pagination { query: self }
    }
}

#[derive(Debug, Clone, Copy, QueryId)]
pub struct Pagination<T> {
    query: T,
}

impl<T> QueryFragment<Pg> for Pagination<T>
where
    T: QueryFragment<Pg>,
{
    fn walk_ast<'b>(
        &'b self,
        mut out: diesel::query_builder::AstPass<'_, 'b, Pg>,
    ) -> QueryResult<()> {
        out.push_sql("SELECT *, COUNT(*) OVER () FROM(");
        self.query.walk_ast(out.reborrow())?;
        out.push_sql(")");
        Ok(())
    }
}

impl<T: Query> Query for Pagination<T> {
    type SqlType = (T::SqlType, BigInt);
}

impl<T> diesel::RunQueryDsl<PgConnection> for Pagination<T> {}

// this is the function not working
impl<T> Pagination<T> {
    pub fn load_with_info<'a, U>(self, conn: &mut PgConnection) -> QueryResult<(Vec<U>, i64)>
    where
        Self: LoadQuery<'a, PgConnection, (U, i64)>,
    {
        let results = self.load::<(U, i64)>(conn)?;

        let total = results.get(0).map(|x| x.1).unwrap_or(0);
        let records = results.into_iter().map(|x| x.0).collect();

        Ok((records, total))
    }
}

// define a simple table
diesel::table! {
    my_table (field_a) {
        field_a -> Int4,
        field_b -> Int4,
    }
}

// define 2 query structs on this table
#[derive(Queryable, Selectable)]
#[diesel(table_name = my_table)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct PartA {
    field_a: i32,
}

#[derive(Queryable, Selectable)]
#[diesel(table_name = my_table)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct PartB {
    field_b: i32,
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut conn = PgConnection::establish("").expect("Error connecting to database");

    // this works
    let result: Vec<(_, _)> = my_table::table
        .select((PartA::as_select(), PartB::as_select()))
        .load(&mut conn)?;

    // this does not compile
    let (result, size): (Vec<(_, _)>, i64) = my_table::table
        .select((PartA::as_select(), PartB::as_select()))
        .paginate()
        .load_with_info(&mut conn)?;

    Ok(())
}

Here is the error produced by the compiler:

cargo error message

error[E0277]: the trait bound `(diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>): diesel::util::TupleSize` is not satisfied
  --> src/main.rs:96:10
   |
96 |         .load_with_info(&mut conn)?;
   |          ^^^^^^^^^^^^^^ the trait `diesel::util::TupleSize` is not implemented for `(diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>)`, which is required by `Pagination<SelectStatement<FromClause<table>, query_builder::select_clause::SelectClause<(diesel::expression::select_by::SelectBy<PartA, _>, diesel::expression::select_by::SelectBy<PartB, _>)>>>: LoadQuery<'_, PgConnection, (_, i64)>`
   |
   = help: the following other types implement trait `diesel::util::TupleSize`:
             (T0, T1)
             (T0, T1, T2)
             (T0, T1, T2, T3)
             (T0, T1, T2, T3, T4)
             (T0, T1, T2, T3, T4, T5)
             (T0, T1, T2, T3, T4, T5, T6)
             (T0, T1, T2, T3, T4, T5, T6, T7)
             (T0, T1, T2, T3, T4, T5, T6, T7, T8)
           and 24 others
   = note: required for `(PartA, PartB)` to implement `StaticallySizedRow<(diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>), Pg>`
   = note: required for `((PartA, PartB), i64)` to implement `FromStaticSqlRow<((diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>), BigInt), Pg>`
   = note: required for `((PartA, PartB), i64)` to implement `Queryable<((diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>), BigInt), Pg>`
   = note: required for `((PartA, PartB), i64)` to implement `FromSqlRow<((diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>), BigInt), Pg>`
   = note: required for `((diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>), BigInt)` to implement `load_dsl::private::CompatibleType<((PartA, PartB), i64), Pg>`
   = note: required for `Pagination<SelectStatement<FromClause<table>, query_builder::select_clause::SelectClause<(diesel::expression::select_by::SelectBy<PartA, Pg>, diesel::expression::select_by::SelectBy<PartB, Pg>)>>>` to implement `LoadQuery<'_, PgConnection, ((PartA, PartB), i64)>`
note: required by a bound in `Pagination::<T>::load_with_info`
  --> src/main.rs:29:15
   |
27 |     pub fn load_with_info<'a, U>(self, conn: &mut PgConnection) -> QueryResult<(Vec<U>, i64)>
   |            -------------- required by a bound in this associated function
28 |     where
29 |         Self: LoadQuery<'a, PgConnection, (U, i64)>,
   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Pagination::<T>::load_with_info`

[weiznich]

I think that might be caused by a missing impl in diesel. The relevant FromSqlRow impl as mentioned by the error message is this one:

diesel/diesel/src/type_impls/tuples.rs

Lines 371 to 384 in 79399de

	impl<$T1, $ST1, __DB> crate::deserialize::FromStaticSqlRow<($ST1,), __DB> for ($T1,) where
	__DB: Backend,
	$ST1: CompatibleType<$T1, __DB>,
	$T1: FromSqlRow<<$ST1 as CompatibleType<$T1, __DB>>::SqlType, __DB>,
	{
	#[allow(non_snake_case, unused_variables, unused_mut)]
	fn build_from_row<'a>(row: &impl Row<'a, __DB>)
	-> deserialize::Result<Self>
	{
	Ok(($T1::build_from_row(row)?,))
	}
	}
	};

This requires that the type tuple implements CompatibleType, which means that impl is used:

diesel/diesel/src/type_impls/tuples.rs

Lines 342 to 349 in 79399de

	impl<__T, $($ST,)* __DB> CompatibleType<__T, __DB> for ($($ST,)*)
	where
	__DB: Backend,
	__T: FromSqlRow<($($ST,)*), __DB>,
	{
	type SqlType = Self;
	}

but that one doesn't apply as it's not for SelectBy

That written: I don't know if that's easy to fix or if you are otherwise able to workaround that issue.

[Zstorm999]

I have a workaround (performing 2 requests), and this is not a critical issue for me, just something interesting I found.

Thanks for the reply ! should I create an issue ?

[weiznich]

Yes, it would be helpful to have an issue with the minimal example so that we are at least aware of this. Maybe someone finds the time to try adding the missing impl in the future.