Skip to main content

risingwave_meta_model_migration/
m20261103_000000_function_purity_options.rs

1use sea_orm_migration::prelude::{Table as MigrationTable, *};
2
3#[derive(DeriveMigrationName)]
4pub struct Migration;
5
6const COLUMNS: [Function; 2] = [
7    Function::UnsafeSkipMaterializingExprs,
8    Function::IsImmutable,
9];
10
11#[async_trait::async_trait]
12impl MigrationTrait for Migration {
13    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
14        assert!(manager.has_table(Function::Table.to_string()).await?);
15
16        for column in COLUMNS {
17            manager
18                .alter_table(
19                    MigrationTable::alter()
20                        .table(Function::Table)
21                        .add_column(ColumnDef::new(column).boolean().not_null().default(false))
22                        .to_owned(),
23                )
24                .await?;
25        }
26
27        Ok(())
28    }
29
30    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
31        assert!(manager.has_table(Function::Table.to_string()).await?);
32
33        for column in COLUMNS {
34            manager
35                .alter_table(
36                    MigrationTable::alter()
37                        .table(Function::Table)
38                        .drop_column(column)
39                        .to_owned(),
40                )
41                .await?;
42        }
43
44        Ok(())
45    }
46}
47
48#[derive(DeriveIden, Clone, Copy)]
49enum Function {
50    Table,
51    UnsafeSkipMaterializingExprs,
52    IsImmutable,
53}
54
55#[cfg(test)]
56mod tests {
57    use sea_orm::{ConnectionTrait, Database, DatabaseBackend, Statement, TryGetable};
58
59    use super::*;
60
61    #[tokio::test]
62    async fn test_adds_purity_options_with_false_default() {
63        let db = Database::connect("sqlite::memory:").await.unwrap();
64        db.execute(Statement::from_string(
65            DatabaseBackend::Sqlite,
66            r#"CREATE TABLE "function" ("function_id" INTEGER PRIMARY KEY)"#,
67        ))
68        .await
69        .unwrap();
70        db.execute(Statement::from_string(
71            DatabaseBackend::Sqlite,
72            r#"INSERT INTO "function" ("function_id") VALUES (1)"#,
73        ))
74        .await
75        .unwrap();
76
77        let manager = SchemaManager::new(&db);
78        Migration.up(&manager).await.unwrap();
79
80        db.execute(Statement::from_string(
81            DatabaseBackend::Sqlite,
82            r#"INSERT INTO "function" ("function_id", "unsafe_skip_materializing_exprs", "is_immutable") VALUES (2, TRUE, TRUE)"#,
83        ))
84        .await
85        .unwrap();
86
87        for column in ["unsafe_skip_materializing_exprs", "is_immutable"] {
88            assert!(manager.has_column("function", column).await.unwrap());
89            for (function_id, expected) in [(1, 0), (2, 1)] {
90                let row = db
91                    .query_one(Statement::from_string(
92                        DatabaseBackend::Sqlite,
93                        format!(
94                            r#"SELECT CAST("{column}" AS INTEGER) AS "{column}" FROM "function" WHERE "function_id" = {function_id}"#
95                        ),
96                    ))
97                    .await
98                    .unwrap()
99                    .unwrap();
100                assert_eq!(i32::try_get(&row, "", column).unwrap(), expected);
101            }
102        }
103
104        Migration.down(&manager).await.unwrap();
105        for column in ["unsafe_skip_materializing_exprs", "is_immutable"] {
106            assert!(!manager.has_column("function", column).await.unwrap());
107        }
108    }
109}