That means I can't define a function to return an UpdateStatement like this ?

    fn update_by_goods_id(
        id: &str,
    ) -> UpdateStatement<member_exchange_goods::table, Eq<member_exchange_goods::columns::id, String>>
    {
        use member_exchange_goods::dsl;
        diesel::update(dsl::member_exchange_goods.filter(dsl::goods_id.eq(id.to_string())))
    }

That doesn't help as you don't call .set() in your function, but the definition of the typedef shows how you could get the correct type for the WhereClause via the corresponding public trait + the associated type there.

Essentially you could define your own type alias without the changes like that:

pub type Update2<Target, > = UpdateStatement<<Target as HasTable>::Table, <Target as IntoUpdateTarget>::WhereClause>;

and then just use the type of the expression that you passed to update(…) as Target type (should be something like dsl::Filter<member_exchange_goods::table, dsl::Eq<…>>)

In reply to @weiznich-55bcb4c20fc9f982beabc3ad:gitter.im
It's not supported in the built-in DSL. It might be possible to extend the DSL, but I cannot give a specific example for full join there.

Json deserialized values that implement FromSql<Json, _> don't seem to automatically implement Queryable, while Option<T> of the same type does. Is this intended or just unfortunately necessary? Just a little confusing trying to debug why.

For example:

use diesel::{
    deserialize::FromSql,
    mysql::{Mysql, MysqlValue},
    prelude::*,
    sql_types, AsExpression,
};
use serde::Deserialize;

table! {
  example_table (id) {
    id -> Unsigned<Bigint>,
    nullable -> Nullable<Json>,
    non_nullable -> Json,
  }
}

#[derive(Debug, Deserialize, AsExpression)]
#[diesel(sql_type = sql_types::Json)]
struct MyJsonValue {
    hello: String,
}

impl FromSql<sql_types::Json, Mysql> for MyJsonValue {
    fn from_sql(value: MysqlValue<'_>) -> diesel::deserialize::Result<Self> {
        let result = <serde_json::Value as FromSql<sql_types::Json, Mysql>>::from_sql(value)?;
        Ok(serde_json::from_value(result)?)
    }
}

fn select_nullable(conn: &mut MysqlConnection) {
    let result: Option<MyJsonValue> = example_table::table
        .select(example_table::nullable)
        .first(conn)
        .unwrap(); // compiles fine
}

fn select_non_nullable(conn: &mut MysqlConnection) {
    let result: MyJsonValue = example_table::table
        .select(example_table::non_nullable)
        .first(conn) // fails with: the trait `Queryable<diesel::sql_types::Json, Mysql>` is not implemented for `MyJsonValue`
        .unwrap();
}

After some type tracking I discovered it's because Option<T> implements Queryable where Option<T>: FromSql, but the same is not true for just T. Is perhaps another broad Queryable implementation that would cover this case? i.e. in the above, the issue is solved with:

impl Queryable<sql_types::Json, Mysql> for MyJsonValue {
    type Row = MyJsonValue;

    fn build(row: Self::Row) -> deserialize::Result<Self> {
        Ok(row)
    }
}

Do you have suggestions how to make that more clear. The documentation of FromSql already states:

Types which implement this trait should also have #[derive(FromSqlRow)]

How can I define a type this code

dsl::qty.eq(dsl::qty-1)

Do you use an ssl connection for the remote instance? There was a libpq bug in versions prior to 16.2 to might cause issues with newer OpenSSL versions.

That written: diesel 1.4.8 is out of support for some years now. It might also be that updating to 2.1 will fix the problem. (Although that will likely require quite a few code changes)