Schema Manager

[tyt2y3]

To support SeaORM, we want to develop SeaSchema into a fully-featured schema manager.

Functionalities:

• A cli client (to be wrapped by sea-orm-cli as a sub command)
• Migration manager
• Migration codegen
• Schema manager

Migration Manager

The migration manager would work like sqlx-cli migration, keeping track of executed migrations.
Our private table would be named seaql_migrations.

The migration 'script' would look like:

use sea_schema::*;

#[derive(Migrator)]
pub struct M20210101020202CreateGlyphTable;

#[derive(Iden)]
pub enum Glyph {
    Table,
    Id,
    Image,
    Aspect,
}

#[async_trait]
impl MigratorTrait for M20210101020202CreateGlyphTable {
    async fn up(mg: &SchemaManager) -> Result<(), DbErr> {
        mg.create_table(
            // TableCreateStatement
            Table::create()
                .table(Glyph::Table)
                .col(
                    ColumnDef::new(Glyph::Id)
                        .integer_len(11)
                        .not_null()
                        .auto_increment()
                        .primary_key()
                )
                .col(ColumnDef::new(Glyph::Aspect).double().not_null())
                .col(ColumnDef::new(Glyph::Image).text())
        ).await?;

        Ok(())
    }

    async fn down(mg: &SchemaManager) -> Result<(), DbErr> {
        mg.drop_table(Glyph::Table).await?;

        Ok(())
    }
}

Migration Codegen

The migration should scaffold a rust project with the following structure:

\migration
    Cargo.toml
    \src
        m20210101020202_create_glyph_table.rs
        lib.rs
        main.rs

The project would serve two functions: as an executable to be executed:

cd migration
cargo run -- run

On the other hand, it can also be used as a library, to be required by the web server when deployed:

use migration::Migrator;

async fn main() {
    Migrator::run().await;
    WebServer::start().await;
}

Schema Manager

The SchemaManager will provide 3 categories of APIs:

1. Definition: create_table, create_index, create_foreign_key etc
2. Mutation: add_column, rename_column etc
3. Inspection: has_table, has_column etc

[JonasCir]

Hi, thank you for creating all these great libs, I'm really happy to see progress on this! 🚀

Not certain if this was brought up before, but I think it could be beneficial to support:

1. SchemaManager.migrateFromRawSql(sql:&str)
2. SchemaManager.migrateFromFile(path: &impl AsRef<Path>)

A disadvantage I see is that adding these functions breaks the strict structure the current implementation enforces. On the other hand, it might help people to experiment with this tool stack as their current migrations might be plain SQL. Not supporting this would require them to rewrite everything in plain Rust just to test a few things.

Personally, I also prefer writing my migrations in plain SQL, so that's also a reason why I raised this :D

[billy1624]

Hey @JonasCir, nice observations! This is actually supported, you can define migration with raw SQL in string literal or from SQL file using include_str! macro.

sea-schema/src/migration/manager.rs

Lines 20 to 28 in 3309d13

	pub async fn exec_stmt<S>(&self, stmt: S) -> Result<(), DbErr>
	where
	S: StatementBuilder,
	{
	let builder = self.conn.get_database_backend();
	self.conn.execute(builder.build(&stmt)).await.map(|_| ())
	}

[JonasCir]

Hi thanks for the prompt answer, happy to see it being supported then 👍
Maybe it is worth to state this somewhere in the docs or on the website b/c I'm pretty certain a lot of people will search for this.

[tasn]

This looks like a related effort that can be reused: https://github.com/rust-db/refinery