SchemaManager 与从实体建表

pub struct SchemaManager<'c> {
    conn: SchemaManagerConnection<'c>,
}

    pub async fn execute<S>(&self, stmt: S) -> Result<(), DbErr>
    where
        S: StatementBuilder,
    {
        self.conn.execute(&stmt).await.map(|_| ())
    }

    pub async fn create_table(&self, stmt: TableCreateStatement) -> Result<(), DbErr> {
        self.execute(stmt).await
    }

... db.statement="\n\nSELECT COUNT(*) > 0 AS \"has_table\" FROM (SELECT \"table_name\" AS \"table_name\" FROM \"information_schema\".\"tables\" WHERE (CURRENT_SCHEMA()) = \"tables\".\"table_schema\" AND \"table_type\" = $1 AND \"table_name\" = $2) AS \"subquery\"\n" rows_affected=1 rows_returned=1 ...
has_table(author) = true
...
has_table(nope) = false
... db.statement="\n\nSELECT COUNT(*) > 0 AS \"has_column\" FROM \"information_schema\".\"columns\" WHERE (CURRENT_SCHEMA()) = \"columns\".\"table_schema\" AND \"table_name\" = $1 AND \"column_name\" = $2\n" rows_affected=1 rows_returned=1 ...
has_column(author, email) = true
... db.statement="\n\nSELECT COUNT(*) > 0 AS \"has_index\" FROM \"pg_indexes\" WHERE \"schemaname\" = (CURRENT_SCHEMA()) AND \"tablename\" = $1 AND \"indexname\" = $2\n" rows_affected=1 rows_returned=1 ...
has_index(author, idx-author-name) = true
...
has_index(author, author_email_key) = true

    let mut stmt = TableCreateStatement::new();

    if let Some(comment) = entity.comment() {
        stmt.comment(comment);
    }

    for column in E::Column::iter() {
        let mut column_def = column_def_from_entity_column::<E>(column, backend);
        stmt.col(&mut column_def);
    }

    if <<E::PrimaryKey as PrimaryKeyTrait>::ValueType as PrimaryKeyArity>::ARITY > 1 {
        let mut idx_pk = Index::create();
        for primary_key in E::PrimaryKey::iter() {
            idx_pk.col(primary_key);
        }
        stmt.primary_key(idx_pk.name(format!("pk-{}", entity.to_string())).primary());
    }

    for relation in E::Relation::iter() {
        let relation = relation.def();
        if relation.is_owner || relation.skip_fk {
            continue;
        }
        stmt.foreign_key(&mut relation.into());
    }

    stmt.table(entity.table_ref()).take()

    let orm_column_def = column.def();
    let types = match &orm_column_def.col_type {
        ColumnType::Enum { name, variants } => match backend {
            DbBackend::MySql => {
                let variants: Vec<String> = variants.iter().map(|v| v.to_string()).collect();
                ColumnType::custom(format!("ENUM('{}')", variants.join("', '")))
            }
            DbBackend::Postgres => ColumnType::Custom(name.clone()),
            DbBackend::Sqlite => orm_column_def.col_type,
        },
        _ => orm_column_def.col_type,
    };
    let mut column_def = ColumnDef::new_with_type(column, types);
    if !orm_column_def.null {
        column_def.not_null();
    }
    if orm_column_def.unique {
        column_def.unique_key();
    }
    if let Some(default) = orm_column_def.default {
        column_def.default(default);
    }
    // ... comment、extra、renamed_from 写进注释
    for primary_key in E::PrimaryKey::iter() {
        if column.as_str() == primary_key.into_column().as_str() {
            if E::PrimaryKey::auto_increment() {
                column_def.auto_increment();
            }
            if <<E::PrimaryKey as PrimaryKeyTrait>::ValueType as PrimaryKeyArity>::ARITY == 1 {
                column_def.primary_key();
            }
        }
    }

#[derive(Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "author_status")]
pub enum Status {
  #[sea_orm(string_value = "active")]
  Active,
  #[sea_orm(string_value = "banned")]
  Banned,
}

#[sea_orm::model]
#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
#[sea_orm(table_name = "author")]
pub struct Model {
  #[sea_orm(primary_key)]
  pub id: i32,
  #[sea_orm(unique)]
  pub email: String,
  #[sea_orm(indexed)]
  pub name: String,
  #[sea_orm(default_value = 0)]
  pub score: i32,
  #[sea_orm(default_expr = "Expr::current_timestamp()")]
  pub created_at: DateTimeUtc,
  pub bio: Option<String>,
  pub status: Status,
  #[sea_orm(unique_key = "tenant_handle")]
  pub tenant: i32,
  #[sea_orm(unique_key = "tenant_handle")]
  pub handle: String,
  #[sea_orm(has_many)]
  pub posts: HasMany<super::post::Entity>,
}

// post
pub struct Model {
  #[sea_orm(primary_key)]
  pub id: i64,
  pub author_id: i32,
  #[sea_orm(column_type = "Text")]
  pub body: String,
  #[sea_orm(belongs_to, from = "author_id", to = "id", on_delete = "Cascade")]
  pub author: BelongsTo<super::author::Entity>,
}

let pg = DbBackend::Postgres;
let schema = Schema::new(pg);
p("table author", pg.build(&schema.create_table_from_entity(author::Entity)));
p("table post", pg.build(&schema.create_table_from_entity(post::Entity)));
for s in schema.create_enum_from_entity(author::Entity) { p("enum", pg.build(&s)); }
for s in schema.create_index_from_entity(author::Entity) { p("index", pg.build(&s)); }
println!("post indexes: {}", schema.create_index_from_entity(post::Entity).len());

table author: CREATE TABLE "author" ( "id" integer GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "email" varchar NOT NULL UNIQUE, "name" varchar NOT NULL, "score" integer NOT NULL DEFAULT 0, "created_at" timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, "bio" varchar, "status" author_status NOT NULL, "tenant" integer NOT NULL, "handle" varchar NOT NULL )
table post: CREATE TABLE "post" ( "id" bigint GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "author_id" integer NOT NULL, "body" text NOT NULL, CONSTRAINT "fk-post-author_id" FOREIGN KEY ("author_id") REFERENCES "author" ("id") ON DELETE CASCADE )
enum: CREATE TYPE "author_status" AS ENUM ('active', 'banned')
index: CREATE INDEX "idx-author-name" ON "author" ("name")
index: CREATE UNIQUE INDEX "idx-author-tenant_handle" ON "author" ("tenant", "handle")
post indexes: 0

--- create_table_from_entity(author) alone
=> Err("Execution Error: error returned from database: type \"author_status\" does not exist at line 270")

db.get_schema_builder().register(post::Entity).register(author::Entity).apply(&db).await?;

... db.statement="\n\nCREATE TYPE \"author_status\" AS ENUM ('active', 'banned')\n" ...
... db.statement="\n\nCREATE TABLE \"author\" ( \"id\" integer GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, \"email\" varchar NOT NULL UNIQUE, \"name\" varchar NOT NULL, \"score\" integer NOT NULL DEFAULT 0, \"created_at\" timestamp with time zone NOT NULL DEFAULT CURRENT_TIMESTAMP, \"bio\" varchar, \"status\" author_status NOT NULL, \"tenant\" integer NOT NULL, \"handle\" varchar NOT NULL )\n" ...
... db.statement="\n\nCREATE INDEX \"idx-author-name\" ON \"author\" (\"name\")\n" ...
... db.statement="\n\nCREATE UNIQUE INDEX \"idx-author-tenant_handle\" ON \"author\" (\"tenant\", \"handle\")\n" ...
... db.statement="\n\nCREATE TABLE \"post\" ( \"id\" bigint GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, \"author_id\" integer NOT NULL, \"body\" text NOT NULL, CONSTRAINT \"fk-post-author_id\" FOREIGN KEY (\"author_id\") REFERENCES \"author\" (\"id\") ON DELETE CASCADE )\n" ...

Applying all pending migrations
Applying migration 'm1_create_user'
Migration 'm1_create_user' has been applied
Applying migration 'm2_add_bio'
up: Err("Execution Error: error returned from database: column \"bio\" of relation \"user\" already exists at line 7347")

column def: ALTER TABLE "author" ADD COLUMN "score" integer NOT NULL DEFAULT 0

ALTER TABLE "author" ADD COLUMN "score" integer NOT NULL DEFAULT 0
  => Ok(())
ALTER TABLE "author" ADD COLUMN "rank" integer NOT NULL
  => Err("Execution Error: error returned from database: column \"rank\" of relation \"author\" contains null values at line 6111")
score of the existing row = 0