Selectable derive does not work with generic embed sub-fields

[Ten0]

Setup

Versions

• Diesel: Latest master (b2c5889)

What are you trying to accomplish?

#[derive(Queryable, Selectable)]
#[table_name = "schema::xxx"]
pub struct WithField<T> {
	pub field: i32,
	#[diesel(embed)]
	pub inner: T,
}

What is the expected output?

impl<T, __DB> Selectable<__DB> for WithField<T>
where T: Selectable<__DB> {}

What is the actual output?

impl<T, __DB> Selectable<__DB> for WithField<T> {}

-> fails to compile with "the trait bound T: diesel::Selectable<__DB> is not satisfied".

Solving

Looks like if a field has embed, the Selectable derive should add bounds FieldType: diesel::Selectable<__DB>, regardless of whether the type is generic or not.

This would also allow the Selectable derive to interact as expected with manual implementations of Selectable on a single backend (non-generic).

[weiznich]

I'm not sure if there is an easy way to fix this issue. We would need to do some simplified form of type resolution there to understand that the type T is a generic parameter to restrict it to T: Selectable. We cannot add this bound for any generic parameter, as this would potentially add the bound to non #[diesel(embedded)] fields as well, which may result in unwanted behaviour there.

To workaround this issue, you can add this bound directly to your struct definition. This should also force the bound in any generated code.

[Ten0]

We cannot add this bound for any generic parameter, as this would potentially add the bound to non #[diesel(embedded)] fields as well, which may result in unwanted behaviour there.

My suggestion was to add the bound not on the generic types, but on the field types that are embed.

e.g., here:

#[derive(Selectable)]
struct S<T> {
    #[diesel(embed)]
    a: SomeStruct,
    #[diesel(embed)]
    b: T,
    some_field: i32,
}

the where clause would be where SomeStruct: Selectable<__DB>, T: Selectable<__DB>

This would also allow the Selectable derive to interact as expected with manual implementations of Selectable on a single backend (non-generic).

e.g.

struct S {
   ...
}
impl Selectable<Pg> for S { ... }
#[derive(Selectable)]
struct S2 {
    #[diesel(embed)]
    f: S,
}

To workaround this issue, you can add this bound directly to your struct definition. This should also force the bound in any generated code.

I've considered this but the bound is relative to a __DB type that doesn't exist at that time. For now I've just written the impl manually.

[weiznich]

My suggestion was to add the bound not on the generic types, but on the field types that are embed.

e.g., here:

#[derive(Selectable)]
struct S<T> {
   #[diesel(embed)]
   a: SomeStruct,
   #[diesel(embed)]
   b: T,
   some_field: i32,
}

the where clause would be where SomeStruct: Selectable<__DB>, T: Selectable<__DB>>

That's a great idea and that should be really simple to add. Basically just add a loop over fields here and add the corresponding bounds to the where clause:

diesel/diesel_derives/src/selectable.rs

Lines 12 to 16 in b2c5889

	let mut generics = item.generics.clone();
	generics
	.params
	.push(parse_quote!(__DB: diesel::backend::Backend));
	let (impl_generics, _, where_clause) = generics.split_for_impl();

for field in model.fields() {
    if field.has_flag("embed") {
        let where_clause = generics.where_clause.get_or_insert(parse_quote!(where));
        let embed_ty = &field.ty;

        where_clause
                .predicates
                .push(parse_quote!(#embed_ty: Selectable<__DB>));
    }
}

Feel free to open a PR with this + a test case showing that it works as expected.