How do I use custom and enumeration functions to set the type of Column

[khassar00]

  `    /// Use a custom type on this column.
pub fn custom<T>(&mut self, name: T) -> &mut Self
where
    T: IntoIden,
{
    self.types = Some(ColumnType::Custom(name.into_iden()));
    self
}

/// Set column type as enum.
pub fn enumeration<N, S, V>(&mut self, name: N, variants: V) -> &mut Self
where
    N: IntoIden,
    S: IntoIden,
    V: IntoIterator<Item = S>,
{
    self.types = Some(ColumnType::Enum {
        name: name.into_iden(),
        variants: variants.into_iter().map(IntoIden::into_iden).collect(),
    });
    self
}`

I am new to rust and I do not know how to use these 2 functions, can anyone help me?

[ikrivosheev]

@khassar00 hello! Welcome to SeaQL and Rust communities!
For example:

#[derive(Debug, Ident)]
pub enum Font {
    Table,
    Id,
    Name,
    Variant,
    Language,
}

// With enumaration
ColumnDef::new(Font::Id).enumeration(Alias::new("TestEnum"), [Alias::new("1"), Alias::new("2")]));
// With custom
ColumnDef::new(Font::Id).custom("Money");

[khassar00]

Thank you very much, but your answer is not detailed, I consulted discussions/402, use the following code work.
I would like more detailed documentation for this crates.

#[enum_def]
#[derive(Debug,sqlx::FromRow)]
pub struct TaskInfo  {
    pub id: i32,
    #[sqlx(flatten)]
    pub state: TaskState,

}
#[derive(Iden, Debug, Copy,Clone)]
pub enum TaskState {
    Sleep,
    Waiting,
    Running,
    Pause,
    Complete,
    Error,
    Cancel,
}

impl From<TaskState> for sea_query::Value {
    fn from(value: TaskState) -> Self {
        let str:&str=value.into();
        sea_query::Value::String(Some(Box::new(str.to_string())))
    }
}

impl FromRow<'_, SqliteRow> for TaskState {
    fn from_row(row: &SqliteRow) -> sqlx::Result<Self> {
        match row.try_get::<&str, &str>("state") {
            Ok(str) =>Ok(str.into()),
            _ =>Err(Error::RowNotFound)
        }
    }

}
impl From<&str> for TaskState{
    fn from(value: &str) -> Self {
        match value {
            "Sleep" => TaskState::Sleep,
            "Waiting" => TaskState::Waiting,
            "Running" => TaskState::Running,
            "Pause" => TaskState::Pause,
            "Complete" => TaskState::Complete,
            "Error" => TaskState::Error,
            "Cancel" => TaskState::Cancel,
            _ => TaskState::Sleep,
        }
    }
}
impl Into<&str> for TaskState{
    fn into(self) -> &'static str {
        match self {
            TaskState::Sleep => "Sleep",
            TaskState::Waiting => "Waiting",
            TaskState::Running => "Running",
            TaskState::Pause => "Pause",
            TaskState::Complete => "Complete",
            TaskState::Error => "Error",
            TaskState::Cancel => "Cancel",
        }
    }
}

    let sql = Table::create()
        .table(TaskInfoIden::Table)
        .if_not_exists()
        .col(
            ColumnDef::new(TaskInfoIden::Id)
                .integer()
                .not_null()
                .auto_increment()
                .primary_key(),
        )
        .col(ColumnDef::new(TaskInfoIden::State).custom(TaskState::Sleep))
        .build(SqliteQueryBuilder);
    let result = sqlx::query(&sql).execute(SQLITE_POOL.wait()).await;

    let (sql, values) = Query::insert()
        .into_table(TaskInfoIden::Table)
        .columns([
            TaskInfoIden::State,
        ])
        .values_panic([
            TaskState::Sleep.into()
        ])
        .values_panic([
            TaskState::Cancel.into()
        ])
        .build_sqlx(SqliteQueryBuilder);
    let row = sqlx::query_with(&sql, values).execute(SQLITE_POOL.wait()).await.unwrap();

    let (sql, values) = Query::select()
        .columns([
            TaskInfoIden::Id,
            TaskInfoIden::State,
        ])
        .from(TaskInfoIden::Table)
        .build_sqlx(SqliteQueryBuilder);
    let rows:Vec<TaskInfo> =sqlx::query_as_with::<_, TaskInfo, _>(&sql, values.clone())
        .fetch_all(SQLITE_POOL.wait())
        .await
        .unwrap();
    for row in rows.iter() {
        println!("{:?}", row);

[khassar00]

I don't need to use either of these functions at all to handle enum correctly.

#[enum_def]
#[derive(Debug,sqlx::FromRow)]
pub struct TaskInfo  {
    pub id: i32,
    #[sqlx(flatten)]
    pub state: TaskState,

}
#[derive(Debug, Copy,Clone,Deserialize,Serialize)]
pub enum TaskState {
    Sleep,
    Running,
    Pause,
    Complete,
    Error,
    Cancel,
}

impl From<TaskState> for sea_query::Value {
    fn from(value: TaskState) -> Self {
        sea_query::Value::Int(Some(value.into()))
    }
}

impl FromRow<'_, SqliteRow> for TaskState {
    fn from_row(row: &SqliteRow) -> sqlx::Result<Self> {
        match row.try_get::<i32, &str>("state") {
            Ok(value) =>Ok(value.into()),
            _ =>Err(Error::RowNotFound)
        }
    }

}
impl From<i32> for TaskState{
    fn from(value: i32) -> Self {
        match value {
            0=> TaskState::Sleep,
           1 => TaskState::Running,
            2 => TaskState::Pause,
            3 => TaskState::Complete,
            4 => TaskState::Error,
           5 => TaskState::Cancel,
            _ => TaskState::Sleep,
        }
    }
}
impl Into<i32> for TaskState{
    fn into(self) -> i32 {
        match self {
            TaskState::Sleep =>0,
            TaskState::Running => 1,
            TaskState::Pause => 2,
            TaskState::Complete => 3,
            TaskState::Error => 4,
            TaskState::Cancel => 5,
        }
    }
}

    let sql = Table::create()
        .table(TaskInfoIden::Table)
        .if_not_exists()
        .col(
            ColumnDef::new(TaskInfoIden::Id)
                .integer()
                .not_null()
                .auto_increment()
                .primary_key(),
        )
        .col(ColumnDef::new(TaskInfoIden::State).integer().default(TaskState::Sleep))
        .build(SqliteQueryBuilder);
    let result = sqlx::query(&sql).execute(SQLITE_POOL.wait()).await;

    let (sql, values) = Query::insert()
        .into_table(TaskInfoIden::Table)
        .columns([
            TaskInfoIden::State,
        ])
        .values_panic([
            TaskState::Sleep.into()
        ])
        .values_panic([
            TaskState::Cancel.into()
        ])
        .build_sqlx(SqliteQueryBuilder);
    let row = sqlx::query_with(&sql, values).execute(SQLITE_POOL.wait()).await.unwrap();

    let (sql, values) = Query::select()
        .columns([
            TaskInfoIden::State,
        ])
        .and_where(Expr::col(TaskInfoIden::State).eq(TaskState::Cancel))
        .from(TaskInfoIden::Table)
        .build_sqlx(SqliteQueryBuilder);
    let rows:Vec<TaskState> =sqlx::query_as_with::<_, TaskState, _>(&sql, values.clone())
        .fetch_all(SQLITE_POOL.wait())
        .await
        .unwrap();
    for row in rows.iter() {
        println!("{:?}", row);
    }