In migration use enumeration

[fan-tastic-z]

Description

According to the example in the document, using enumeration in migration will prompt an error

https://www.sea-ql.org/SeaORM/docs/migration/writing-migration/#schema-creation-methods

use sea_orm::{EnumIter, Iterable};
use sea_orm_migration::prelude::*;

#[derive(DeriveMigrationName)]
pub struct Migration;

#[async_trait::async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .create_table(
                Table::create()
                    .table(Post::Table)
                    .if_not_exists()
                    .col(
                        ColumnDef::new(Post::Id)
                            .integer()
                            .not_null()
                            .auto_increment()
                            .primary_key(),
                    )
                    .col(ColumnDef::new(Post::Title).string().not_null())
                    .col(ColumnDef::new(Post::Text).string().not_null())
                    .col(
                        ColumnDef::new(Post::Category)
                            .enumeration(Alias::new("category"), Category::iter()),
                    )
                    .to_owned(),
            )
            .await
    }

    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .drop_table(Table::drop().table(Post::Table).to_owned())
            .await
    }
}

#[derive(DeriveIden)]
enum Post {
    Table,
    Id,
    Title,
    Text,
    Category,
}

#[derive(Iden, EnumIter)]
pub enum Category {
    #[iden = "Feed"]
    Feed,
    #[iden = "Story"]
    Story,
}

Execute sea-orm-cli migrate up

Applying all pending migrations
Applying migration 'm20220101_000001_create_table'
Execution Error: error returned from database: type "category" does not exist
Fail to run migration

sea-orm-cli version: sea-orm-cli 0.12.10
sea-orm-migration: 0.12.0
database: postgres

[tyt2y3]

You can create the types as stated in https://www.sea-ql.org/SeaORM/docs/generate-entity/enumeration/#postgres

[scott-wilson]

I'm running into a similar issue, and I think it could be because when creating the table, the type should be quoted. Here's what I'm seeing on my end:

If I run the following raw SQL that's generated from the SeaQL builder:

CREATE TYPE "PermissionState" AS ENUM ('unset', 'allow', 'deny');
CREATE TABLE "authPermissionGroup" (
      "permission_id" uuid NOT NULL PRIMARY KEY,
  "group_id" uuid NOT NULL,
  "permission_state" PermissionState NOT NULL
);

Then it fails. But, if I comment out the PermissionState, it works

CREATE TYPE "PermissionState" AS ENUM ('unset', 'allow', 'deny');
CREATE TABLE "authPermissionGroup" (
      "permission_id" uuid NOT NULL PRIMARY KEY,
  "group_id" uuid NOT NULL,
  "permission_state" "PermissionState" NOT NULL
);

The Rust code in the migrations looks something like this:

#[derive(DeriveIden)]
enum PermissionState {
    #[sea_orm(iden = "PermissionState")]
    Enum,
    #[sea_orm(iden = "unset")]
    Unset,
    #[sea_orm(iden = "allow")]
    Allow,
    #[sea_orm(iden = "deny")]
    Deny,
}

#[derive(DeriveIden)]
enum AuthPermissionGroup {
    #[sea_orm(iden = "authPermissionGroup")]
    Table,
    PermissionId,
    GroupId,
    PermissionState,
}

manager
    .create_type(
        Type::create()
            .as_enum(PermissionState::Enum)
            .values([
                PermissionState::Unset,
                PermissionState::Allow,
                PermissionState::Deny,
            ])
            .to_owned(),
    )
    .await?;

manager
    .create_table(
        Table::create()
            .table(AuthPermissionGroup::Table)
            .col(
                ColumnDef::new(AuthPermissionGroup::PermissionId)
                    .uuid()
                    .not_null(),
            )
            .col(
                ColumnDef::new(AuthPermissionGroup::GroupId)
                    .uuid()
                    .not_null(),
            )
            .col(
                ColumnDef::new(AuthPermissionGroup::PermissionState)
                    .enumeration(
                        PermissionState::Enum,
                        [
                            PermissionState::Unset,
                            PermissionState::Allow,
                            PermissionState::Deny,
                        ],
                    )
                    .not_null(),
            )
            .to_owned(),
    )
    .await?;

[scott-wilson]

Adding onto this, if I change the signature of the enum type from PermissionState to permission_state, then it works as expected.

[tyt2y3]

This is one of the caveats of using camel case in SQL. It must be properly quoted throughout.