How to use an optional custom type with Insertable?

[ISibboI]

I have the following table:

CREATE TABLE users (
	name TEXT PRIMARY KEY,
        password_hash TEXT
);

And the following Insertable:

#[derive(Insertable, Clone, Debug)]
#[diesel(table_name = crate::database::schema::users)]
#[diesel(primary_key(name))]
#[diesel(check_for_backend(diesel::pg::Pg))]
#[diesel(treat_none_as_default_value = false)]
pub struct User {
    #[diesel(serialize_as = String)]
    pub name: Username,
    #[diesel(serialize_as = Option<String>)]
    pub password_hash: Option<PasswordHash>,
}

PasswordHash implements Into<String>, but it is impossible to implement Into<Option<String>> for Option<PasswordHash> due to the orphan rule. Hence this insertable does not work. I tried creating a custom type for serialize_as instead:

#[derive(Serialize, Deserialize, Debug, AsExpression)]
#[diesel(sql_type = Nullable<Text>)]
pub struct OptionalPasswordHashSerde(Option<String>);

impl From<Option<PasswordHash>> for OptionalPasswordHashSerde {
    fn from(value: Option<PasswordHash>) -> Self {
        Self(value.map(Into::into))
    }
}

impl From<OptionalPasswordHashSerde> for Option<PasswordHash> {
    fn from(value: OptionalPasswordHashSerde) -> Self {
        value.0.map(Into::into)
    }
}

impl<DB: Backend> ToSql<Nullable<Text>, DB> for OptionalPasswordHashSerde {
    fn to_sql<'b>(&'b self, out: &mut diesel::serialize::Output<'b, '_, DB>) -> diesel::serialize::Result {
        self.0.to_sql(out) // does not work
    }
}

But creating this custom type requires me to manually implement ToSql, which I cannot get correct. This specific attempt gives me the following error:

    |
193 |         self.0.to_sql(out)
    |                ^^^^^^ the trait `diesel::serialize::ToSql<_, DB>` is not implemented for `std::string::String`
    |
    = help: the following other types implement trait `diesel::serialize::ToSql<A, DB>`:
              <std::string::String as diesel::serialize::ToSql<diesel::sql_types::Text, DB>>
              <std::string::String as diesel::serialize::ToSql<diesel::sql_types::Nullable<diesel::sql_types::Text>, __DB>>
    = note: required for `std::option::Option<std::string::String>` to implement `diesel::serialize::ToSql<diesel::sql_types::Nullable<_>, DB>`

How do I easily implement Insertable for the struct above while serializing Option<PasswordHash> as Option<String>, without having to use any extra types? There is no way to specify a serialization_function instead of a serialize_as, right? Because if I could just specify a function, that would make things a lot easier.

[weiznich]

The following code works for me:

use diesel::prelude::*;

table! {
    users(name) {
        name -> Text,
        password_hash -> Nullable<Text>,
    }
}

#[derive(Insertable, Clone, Debug)]
#[diesel(table_name = users)]
#[diesel(primary_key(name))]
#[diesel(check_for_backend(diesel::pg::Pg))]
#[diesel(treat_none_as_default_value = false)]
pub struct User {
    #[diesel(serialize_as = String)]
    pub name: UserName,
    #[diesel(serialize_as = Option<String>)]
    pub password_hash: PasswordHash,
}

#[derive(Clone, Debug)]
pub struct UserName(String);

impl From<String> for UserName {
    fn from(value: String) -> Self {
        Self(value)
    }
}

impl From<UserName> for String {
    fn from(value: UserName) -> Self {
        value.0
    }
}

#[derive(Clone, Debug)]
pub struct PasswordHash(Option<String>);

impl From<Option<String>> for PasswordHash {
    fn from(value: Option<String>) -> Self {
        Self(value)
    }
}

impl From<PasswordHash> for Option<String> {
    fn from(value: PasswordHash) -> Self {
        value.0
    }
}

Essentially you need to make PasswordHash a wrapper around the Option<> type as well.

[ISibboI]

Thanks, I will try that! I would still be interested into allowing an arbitrary function to transform into the supported type, I'll make an issue for that.

[tifrel]

I have a similar where I need both the optional and non-optional type. This is a minimum example:

use diesel::prelude::*;

mod schema {
    diesel::table! {
        users (name) {
            name -> Text,
            password_hash -> Text,
            recovery_hash -> Nullable<Text>,
        }
    }
}
use schema::*;

#[derive(Debug)]
struct Hash(String);

impl From<Hash> for String {
    fn from(value: Hash) -> String {
        value.0
    }
}

impl From<String> for Hash {
    fn from(value: String) -> Hash {
        Hash(value)
    }
}

#[derive(Queryable, Selectable, Insertable, AsChangeset, Debug)]
struct User {
    name: String,
    #[diesel(serialize_as = String)]
    password_hash: Hash,
    #[diesel(serialize_as = Option<String>)]
    recovery_hash: Option<Hash>,
}

There are a bunch of impls on the actual Hash that I am working with, so implementing a second struct OptionHash(Option<Hash>) looks like a bunch of boilerplate to me. Is it the only option?

[Ten0]

In order to not rewrite that every time I just have a generic OptTryInto type that I reuse everytime:

use diesel::{backend::Backend, deserialize, Queryable};

pub struct OptTryInto<T>(Option<T>);

impl<ST, DB, T> Queryable<ST, DB> for OptTryInto<T>
where
	Option<T>: Queryable<ST, DB>,
	DB: Backend,
{
	type Row = <Option<T> as Queryable<ST, DB>>::Row;

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

impl<T> OptTryInto<T> {
	// This is a hack based on how the queryable derive works (by calling `.try_into()`)
	pub fn try_into<O, E>(self) -> diesel::deserialize::Result<Option<O>>
	where
		T: TryInto<O, Error = E>,
		E: Into<Box<(dyn std::error::Error + Send + Sync + 'static)>>,
	{
		self.0.map(TryInto::try_into).transpose().map_err(Into::into)
	}
}

#[cfg(test)]
#[allow(unused)]
mod test {
	use super::*;

	#[derive(diesel::Queryable)]
	struct Inner {
		#[diesel(deserialize_as = OptTryInto<i32>)]
		value: Option<u32>,
	}
}

(IIRC the hack part is just for slightly more flexible generic try into support, probably not needed for just into and maybe not even needed in the general case)

[ISibboI]

I'm working on this pull request #3837 which will probably make your thing easier to implement. Feel free to contribute to the pull request, by forking my branch and making a pull request to my fork of the repo.

…

On Fri, 24 Nov 2023, 12.34 Till, ***@***.***> wrote: I have a similar where I need both the optional and non-optional type. This is a minimum example: use diesel::prelude::*; mod schema { diesel::table! { users (name) { name -> Text, password_hash -> Text, recovery_hash -> Nullable<Text>, } }}use schema::*; #[derive(Debug)]struct Hash(String); impl From<Hash> for String { fn from(value: Hash) -> String { value.0 }} impl From<String> for Hash { fn from(value: String) -> Hash { Hash(value) }} #[derive(Queryable, Selectable, Insertable, AsChangeset, Debug)]struct User { name: String, #[diesel(serialize_as = String)] password_hash: Hash, #[diesel(serialize_as = Option<String>)] recovery_hash: Option<Hash>,} There are a bunch of impls on the actual Hash that I am working with, so implementing a second struct OptionHash(Option<Hash>) looks like a bunch of boilerplate to me. Is it the only option? — Reply to this email directly, view it on GitHub <#3835 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AASATXQQB5MR5JV6CFH24VTYGBZ27AVCNFSM6AAAAAA6FLY6KGVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM3TMNJZGMYTO> . You are receiving this because you authored the thread.Message ID: ***@***.***>

[Stygmates]

How would you implement a structure that updates the hash in database?
Something like this:

#[derive(AsChangeset)]
#[diesel(table_name = users)]
pub struct UpdateUser {
    #[diesel(serialize_as = Option<Option<String>>)]
    pub password_hash: Option<PasswordHash>,
}

I'm getting an error on this:

error[E0277]: the trait bound `Option<Option<String>>: From<PasswordHash>` is not satisfied
  --> src/user.rs:22:10
   |
22 | #[derive(AsChangeset)]
   |          ^^^^^^^^^^^ the trait `From<PasswordHash>` is not implemented for `Option<Option<String>>`
   |
   = help: the following other types implement trait `From<T>`:
             <Option<Box<(dyn QueryFragment<DB> + Send + 'a)>> as From<query_builder::order_clause::OrderClause<Expr>>>
             <Option<Box<(dyn QueryFragment<DB> + Send + 'a)>> as From<query_builder::order_clause::NoOrderClause>>
             <Option<String> as From<OptionUtf8PathBuf>>
             <Option<String> as From<PasswordHash>>
             <Option<&'a T> as From<&'a Option<T>>>
             <Option<&'a mut T> as From<&'a mut Option<T>>>
             <Option<T> as From<T>>
   = note: required for `PasswordHash` to implement `Into<Option<Option<String>>>`
   = note: this error originates in the derive macro `AsChangeset` (in Nightly builds, run with -Z macro-backtrace for more info)

I'm not sure about the implementation of the Into trait because from what I understand, I need to turn an Option<PasswordHash> into an Option<Option<String>> and not just a PasswordHash into an Option<Option<String>>

[weiznich]

For cases where you own the inner type there is always the possibility to just implement ToSql (and derive AsExpression) for that type. This allows you to use that type for inserts/updates without using serialize_as. The later is more or less meant to be a quick way to provide one of conversions, but if you hit situations where you want to use something in and outside an option it's probably more appropriated to go the way and implement proper support for that type anyway.