Rust Diesel duplicate column name when using paginate - mysql

Question

I have a query that loads an Expense, with a child Currency.
let res: Vec<JoinedExpenses> = expenses
.inner_join(currencies::table.on(currencies::id.eq(expenses::currency_id)
.select(
(
expenses::id,
...,
(
currencies::id,
currencies::shortcode,
currencies::name
),
expenses::currency_id,
...,
)
)
.load::<JoinedExpenses>(conn)?;
The Structs look like this:
#[derive(Debug, Queryable, Serialize, Deserialize)]
pub struct JoinedExpense {
pub id: i64,
...,
pub currency: Currency,
pub currency_id: i64,
...
}
#[derive(Debug, Queryable, Serialize, Deserialize)]
pub struct Currency {
pub id: i64,
pub shortcode: String,
pub name: String,
...
}
This works fine and generates the following (simplified) query:
SELECT
`expenses`.`id`,
...,
`currencies`.`id`,
`currencies`.`shortcode`,
`currencies`.`name`,
`expenses`.`currency_id`,
..
FROM ((
`expenses` INNER JOIN `currencies`
ON (`currencies`.`id` = `expenses`.`currency_id`))
Now I tried paginating this result with the following code:
#[derive(Debug, Serialize, Deserialize)]
pub struct PagedResponse<T> {
data: Vec<T>,
pages: i64,
}
pub trait Paginate: Sized {
fn paginate(self, page: Option<i64>) -> Paginated<Self>;
}
impl<T> Paginate for T {
fn paginate(self, page: Option<i64>) -> Paginated<Self> {
let _page = match page {
None => 1,
Some(p) => p
};
Paginated {
query: self,
per_page: DEFAULT_PER_PAGE,
page: _page,
offset: (_page - 1) * DEFAULT_PER_PAGE,
}
}
}
const DEFAULT_PER_PAGE: i64 = 10;
#[derive(Debug, Clone, Copy, QueryId)]
pub struct Paginated<T> {
query: T,
page: i64,
per_page: i64,
offset: i64,
}
impl<T> Paginated<T> {
pub fn per_page(self, per_page: i64) -> Self {
Paginated {
per_page,
offset: (self.page - 1) * per_page,
..self
}
}
pub fn load_and_count_pages<'a, U>(self, conn: &mut mysql::ConnectionPool) -> Result<PagedResponse<U>, CustomError>
where
Self: LoadQuery<'a, mysql::ConnectionPool, (U, i64)>,
{
let per_page = self.per_page;
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();
let total_pages = (total as f64 / per_page as f64).ceil() as i64;
let paged: PagedResponse<U> = PagedResponse {
data: records,
pages: total_pages,
};
Ok(paged)
}
}
impl<T: Query> Query for Paginated<T> {
type SqlType = (T::SqlType, BigInt);
}
impl<T> RunQueryDsl<mysql::ConnectionPool> for Paginated<T> {}
impl<T> QueryFragment<Mysql> for Paginated<T>
where
T: QueryFragment<Mysql>,
{
fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Mysql>) -> QueryResult<()> {
out.push_sql("SELECT *, COUNT(*) OVER () FROM (");
self.query.walk_ast(out.reborrow())?;
out.push_sql(") t LIMIT ");
out.push_bind_param::<BigInt, _>(&self.per_page)?;
out.push_sql(" OFFSET ");
out.push_bind_param::<BigInt, _>(&self.offset)?;
Ok(())
}
}
I get the result like this:
let res: Vec<JoinedExpenses> = expenses
.inner_join(currencies::table.on(currencies::id.eq(expenses::currency_id)
.select(
(
expenses::id,
...,
(
currencies::id,
currencies::shortcode,
currencies::name
),
expenses::currency_id,
...,
)
)
.paginate(1)
.load_and_count_pages::<JoinedExpenses>(conn)?;
This code works if I don't join the currency to the expense, i.e. if I load Expenses only for example. But if I try to use pagination together with the JoinedExpense, I get an error:
DatabaseError(
Unknown,
"Duplicate column name 'id'",
),
The resulting query from the paginated case is:
SELECT *,
COUNT(*) OVER ()
FROM (
SELECT
`expenses`.`id`,
...,
`currencies`.`id`,
`currencies`.`shortcode`,
`currencies`.`name`,
`expenses`.`currency_id`,
..
FROM
((`expenses` INNER JOIN `currencies`
ON (`currencies`.`id` = `expenses`.`currency_id`))
LIMIT ? OFFSET ?
I think I can avoid the issue by changing the Type of Currency to not contain an id field, but I want to understand the underlying issue.
Update 1:
If I implement the pagination manually for the specified query, then I don't run into the same Issue.
The following code produces the output I want without issues:
let test = expenses::dsl::expenses
.filter(
expenses::tenant_id.eq(session.tenant_id))
.inner_join(
currencies::table.on(
currencies::id.eq(expenses::currency_id)
)
)
.inner_join(
expense_types::table.on(
expense_types::id.eq(expenses::type_id)
)
)
.select((
JoinedExpense::COLUMNS,
diesel::dsl::sql::<diesel::sql_types::BigInt>("count(*) over ()")
)).limit(10).offset(0).load::<(JoinedExpense, i64)>(conn);
Now it remains to figure out what the difference is with this query, as compared to the one generated by the pagination code.