Using generic structs with Insertable

[ahmed-said-jax]

I want to create a struct that can be parametrized such that I can create two versions on need - one that owns strings and one that borrows them. Here's a first implementation:

use std::borrow::Borrow;
use diesel::prelude::*;

diesel::table! {
    foo (id) {
        id -> Int4,
        name -> Text,
    }
}

#[derive(Insertable)]
#[diesel(table_name = foo)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct NewFoo<Str: Borrow<str>> {
    name: Str
}

fn main() {
    let new_foo = NewFoo { name: String::new() };
}

this fails to compile, throwing the following error:

error[E0277]: the trait bound `Str: diesel::Expression` is not satisfied
  --> src/main.rs:11:10
   |
11 | #[derive(Insertable)]
   |          ^^^^^^^^^^ the trait `diesel::Expression` is not implemented for `Str`, which is required by `Str: AsExpression<diesel::sql_types::Text>`
   |
   = note: required for `Str` to implement `AsExpression<diesel::sql_types::Text>`
   = note: this error originates in the derive macro `Insertable` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider further restricting this bound
   |
14 | struct NewFoo<Str: Borrow<str> + diesel::Expression> {

Okay, simple. Just add another trait bound, as the compiler suggests (relevant snippet shown):

#[derive(Insertable)]
#[diesel(table_name = foo)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct NewFoo<Str: Borrow<str> + diesel::Expression<SqlType = diesel::sql_types::Text>> {
    name: Str
}

this now fails to compile as well:

error[E0277]: the trait bound `str: diesel::Expression` is not satisfied
  --> src/main.rs:19:28
   |
19 |     let _ = NewFoo { name: "hello" };
   |                            ^^^^^^^ the trait `diesel::Expression` is not implemented for `str`, which is required by `&str: diesel::Expression`
   |
   = help: the following other types implement trait `diesel::Expression`:
             &'a T
             (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)
           and 134 others
   = note: required for `&str` to implement `diesel::Expression`
note: required by a bound in `NewFoo`
  --> src/main.rs:14:34
   |
14 | struct NewFoo<Str: Borrow<str> + diesel::Expression<SqlType = diesel::sql_types::Text>> {
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `NewFoo`

I also tried using the following trait bounds (separately), both returning the first error:

• ToSql<Text, Pg>
• AsExpression<Text> (this comment suggests this would be the correct trait bound)

this discussion seems to suggest that what I'm trying to do isn't even possible. Is that correct?

Thanks!

[weiznich]

The following definition works:

#[derive(Insertable)]
#[diesel(table_name = foo)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct NewFoo<Str: AsExpression<diesel::sql_types::Text>>
where
    for<'a> &'a Str: AsExpression<diesel::sql_types::Text>,
{
    name: Str,
}

We require bounds for the owned type and for the reference type as the insertable derive generates implementations for both NewFoo and &NewFoo.

[ahmed-said-jax]

Ahhh that makes sense. I really appreciate your swift and super helpful reply!