DeriveEntityModel failing compilation when using a stringy newtype

[angrynode]

on v2 rc18 I'm trying to use a stringy newtype in a model which derives DeriveEntityModel. Ideally i'd like to have a simpler TryFrom-based implementation but i'm ok to have some boilerplate.

So i followed the new type docs and added boilerplate for my MagnetLink type:

#[cfg(feature = "sea_orm")]
impl From<MagnetLink> for sea_orm::sea_query::Value {
    fn from(m: MagnetLink) -> Self {
        Self::String(Some(m.to_string()))
    }
}

#[cfg(feature = "sea_orm")]
impl sea_orm::TryGetable for MagnetLink {
    fn try_get_by<I: sea_orm::ColIdx>(
        res: &sea_orm::QueryResult,
        index: I,
    ) -> Result<Self, sea_orm::error::TryGetError> {
        let val: String = res.try_get_by(index)?;
        Ok(MagnetLink::new(&val).map_err(|e| {
            sea_orm::error::TryGetError::DbErr(sea_orm::DbErr::TryIntoErr {
                from: "String",
                into: "MagnetLink",
                source: std::sync::Arc::new(e),
            })
        })?)
    }
}

#[cfg(feature = "sea_orm")]
impl sea_orm::sea_query::ValueType for MagnetLink {
    fn try_from(v: sea_orm::Value) -> Result<Self, sea_orm::sea_query::ValueTypeErr> {
        match v {
            // TODO: What to do with None String?
            // This should probably work with Option<MagnetLink> but not with MagnetLink
            // but i have no idea how sea orm works...
            sea_orm::Value::String(Some(s)) => {
                MagnetLink::new(&s).map_err(|_e| sea_orm::sea_query::ValueTypeErr)
            }
            _ => {
                Err(sea_orm::sea_query::ValueTypeErr)
            }
        }
    }

    fn type_name() -> String {
        "MagnetLink".to_string()
    }

    
    fn array_type() -> sea_orm::sea_query::ArrayType {
        sea_orm::sea_query::ArrayType::String
    }

    fn column_type() -> sea_orm::sea_query::ColumnType {
        sea_orm::sea_query::ColumnType::String(sea_orm::sea_query::table::StringLen::None)
    }
}

impl sea_orm::sea_query::Nullable for MagnetLink {
    fn null() -> sea_orm::sea_query::Value {
        sea_orm::sea_query::Value::String(None)
    }
}

This code compiles, and i'm probably doing it all wrong (since i don't know what do do to return an Option<MagnetLink> in TryGetable since apparently a nulled value is String(None) but that's another problem). However now my Model fails to compile:

#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
#[sea_orm(table_name = "magnet")]
pub struct Model {
    #[sea_orm(primary_key)]
    pub id: i32,
    pub torrent_id: String,
    #[sea_orm(column_type = "String")]
    pub magnet: MagnetLink,
    pub name: String,
    pub resolved: bool,
}

Compilation produces the error:

error[E0277]: the trait bound `fn(StringLen) -> ColumnType {sea_orm::ColumnType::String}: ColumnTypeTrait` is not satisfied
  --> src/database/magnet.rs:18:35
   |
18 | #[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
   |                                   ^^^^^^^^^^^^^^^^^ the trait `ColumnTypeTrait` is not implemented for fn item `fn(StringLen) -> ColumnType {sea_orm::ColumnType::String}`
   |
   = help: the following other types implement trait `ColumnTypeTrait`:
             ColumnType
             sea_orm::ColumnDef
   = note: this error originates in the derive macro `DeriveEntityModel` (in Nightly builds, run with -Z macro-backtrace for more info)

This error may be produced by an error of my own making so it may not be a bug. I consider this a bug because:

• i followed the docs and implemented the 4 traits for my custom type
• the error produced does not mention my own types so i'm assuming either an assumption is wrong somewhere in the code or in the docs

I'd be happy if people can produce more examples (which we could link in the docs) about boilerplate to support new types in Models, because i probably did something very wrong :)

I did find this issue which mentioned needing to add ColumnTypeTrait to the current scope, but that doesn't solve the issue.

[tyt2y3]

how is your MagnetLink struct defined?

why can't you use the DeriveValueType macro? if there is something that doesn't fit your current usecase, we can add an attribute.

https://www.sea-ql.org/SeaORM/docs/generate-entity/newtype/#wrapping-scalar-types

[tyt2y3]

none of that looks any wrong but you don't need the extra #[sea_orm(column_type = "String")] it's already implied by the newtype

[angrynode]

why can't you use the DeriveValueType macro?

MagnetLink is not a simple newtype wrapper, it has several fields. Unless i'm mistaken, TryFrom support in derive is what i'd need to use it.

none of that looks any wrong but you don't need the extra #[sea_orm(column_type = "String")] it's already implied by the newtype

Actually removing that attribute makes it compile, thank you. I'm not sure if it's a bug that this redundant attribute fails compilation? I'll submit a PR to improve the docs, providing an example.

Regarding the docs, do you have maybe an insight about how to support Option<MagnetLink> in the model? My understanding is that null returns Value::String(None) but i'm not sure how to handle it in ValueType::try_from. Should i just return ValueTypeErr and then there's a blanket impl for Option<T> which allows me to use options in my model? Or is there something to do on my types supporting sea_orm?

[tyt2y3]

do you have maybe an insight about how to support Option

if MagnetLink works, then Option<MagnetLink> would automatically work. just define a field with type Option<MagnetLink>

[angrynode]

I'm actually failing with Option<MagnetLink>. The creation query fails with:

called `Result::unwrap()` on an `Err` value: Query(SqlxError(Database(SqliteError { code: 1299, message: "NOT NULL constraint failed: optional_mixed.torrent_id" })))

I've tried using both Set(None) and Unset in the active model in two tests in the latest commits of this PR. I'm not sure if that's wrong, or if i should use a different column type than string in my migrations.

To complete the docs i submitted in SeaQL/seaql.github.io#157 it would also be interesting to document what happens when the stringy newtype supports "" as a valid value. I don't see a lot of value in it and i think it's perfectly fine to mention it's just not supported, but maybe it actually is and in that case how do we differentiate between Some(T("")) and None, both in the DB representation and in the code?

[tyt2y3]

thanks for the PR. I will improve the macro to cover that use case

[tyt2y3]

just pushed an update to master, you can now do the following:

#[derive(Copy, Clone, Debug, PartialEq, Eq, DeriveValueType)]
#[sea_orm(value_type = "String")]
pub struct Tag3 {
    pub i: i64,
}

impl std::fmt::Display for Tag3 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.i)
    }
}

impl std::str::FromStr for Tag3 {
    type Err = std::num::ParseIntError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let i: i64 = s.parse()?;
        Ok(Self { i })
    }
}

it's possible to override the string conversion methods too:

#[derive(Copy, Clone, Debug, PartialEq, Eq, DeriveValueType)]
#[sea_orm(
    value_type = "String",
    from_str = "Tag2::from_str",
    to_str = "Tag2::to_str"
)]
pub enum Tag2 {
    Color,
    Grey,
}

impl Tag2 {
    fn to_str(&self) -> &'static str {
        match self {
            Self::Color => "color",
            Self::Grey => "grey",
        }
    }

    fn from_str(s: &str) -> Result<Self, sea_query::ValueTypeErr> {
        Ok(match s {
            "color" => Self::Color,
            "grey" => Self::Grey,
            _ => return Err(sea_query::ValueTypeErr),
        })
    }
}