Allow mathematical database operations with decimal and non-decimal columns

[Kakadus]

Rust Version

1.90.0 (1159e78c4 2025-09-14)

Diesel Version

2.3.2

Diesel Features

"numeric", "postgres"

Database Version

PostgreSQL 18

Operating System Version

Arch Linux

What happened?

First of all: Thanks for this awesome, well-maintained project.

Mathematical database operations between decimal and non-decimal column in a select block do not seem to be supported. The column types are not up/downcasted properly, and compilation fails.
See steps to reproduce for showcasing Numeric + Int4. Subtraction, multiplication, division etc follow analogous. Note that this is not dependent on the bigdecimal implementation, because these operations are performed in the database. No additional dependencies are needed.

PostgreSQL defines the type mappings here in their math docs.

What did you expect to happen?

I would expected diesel to support all mathematical operations which the underlying database supports.

Additional details

No response

Steps to reproduce

// schema.rs
diesel::table! {
    test (id) {
        id -> Uuid,
        integer -> Int4,
        decimal -> Numeric,
    }
}

// main.rs
mod schema;
use schema::test::dsl::*;
use diesel::prelude::*;

fn main() {
    let _ = test.select(decimal + integer);
}

Compile time error

❯ cargo build
   Compiling diesel-test v0.1.0 (/home/jonas/development/tmp/diesel-test)
error[E0271]: type mismatch resolving `<integer as Expression>::SqlType == Numeric`
 --> src/main.rs:8:33
  |
8 |     let _ = test.select(decimal + integer);
  |                                 ^ type mismatch resolving `<integer as Expression>::SqlType == Numeric`
  |
note: expected this to be `diesel::sql_types::Numeric`
 --> src/schema.rs:5:20
  |
5 |         integer -> Int4,
  |                    ^^^^
  = note: required for `columns::integer` to implement `AsExpression<diesel::sql_types::Numeric>`
note: required for `columns::decimal` to implement `std::ops::Add<columns::integer>`
 --> src/schema.rs:2:1
  |
2 | / diesel::table! {
3 | |     test (id) {
4 | |         id -> Uuid,
5 | |         integer -> Int4,
6 | |         decimal -> Numeric,
  | |         ^^^^^^^
7 | |     }
8 | | }
  | |_^
  = note: this error originates in the macro `diesel::table` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0271`.
error: could not compile `diesel-test` (bin "diesel-test") due to 1 previous error

Checklist

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

• This issue can be reproduced on Rust's stable channel. (Please submit the issue in the Rust issue tracker instead if that's not the case)

• This issue can be reproduced without requiring a third party crate

[weiznich]

@Kakadus Thanks for opening this. I converted this to a discussion as this is strictly speaking a feature request and not a bug.

I agree that this would be good to have, but unfortunately I do not see an easy way to add this. The problem here is that we rely on rustc to resolve generic types for expr_a + expr_b in such a way that it uses a T: AsExpression<SqlTypeOf<expr_a>> bound. This only works if we assume that expr_b has the same SQL type than expr_a. For this requested addition this wouldn't be the case anymore.

That written: I'm still open to suggestions how to implement this without breaking existing usages. Maybe a more flexible expr_a.add(expr_b) function can be helpful here?