Support sqlite enum

Author: owjs3901

crates/vespertide-query/src/sql/add_column.rs

@@ -3,9 +3,12 @@ use sea_query::{Alias, Expr, Query, Table, TableAlterStatement};
 use vespertide_core::{ColumnDef, TableDef};
 
 use super::create_table::build_create_table_for_backend;
-use super::helpers::{build_create_enum_type_sql, build_sea_column_def};
+use super::helpers::{
+    build_create_enum_type_sql, build_schema_statement, build_sea_column_def,
+    collect_sqlite_enum_check_clauses,
+};
 use super::rename_table::build_rename_table;
-use super::types::{BuiltQuery, DatabaseBackend};
+use super::types::{BuiltQuery, DatabaseBackend, RawSql};
 use crate::error::QueryError;
 
 fn build_add_column_alter_for_backend(
@@ -20,15 +23,27 @@ fn build_add_column_alter_for_backend(
         .to_owned()
 }
 
+/// Check if the column type is an enum
+fn is_enum_column(column: &ColumnDef) -> bool {
+    matches!(
+        column.r#type,
+        vespertide_core::ColumnType::Complex(vespertide_core::ComplexColumnType::Enum { .. })
+    )
+}
+
 pub fn build_add_column(
     backend: &DatabaseBackend,
     table: &str,
     column: &ColumnDef,
     fill_with: Option<&str>,
     current_schema: &[TableDef],
 ) -> Result<Vec<BuiltQuery>, QueryError> {
-    // SQLite: only NOT NULL additions require table recreation
-    if *backend == DatabaseBackend::Sqlite && !column.nullable {
+    // SQLite: NOT NULL additions or enum columns require table recreation
+    // (enum columns need CHECK constraint which requires table recreation in SQLite)
+    let sqlite_needs_recreation =
+        *backend == DatabaseBackend::Sqlite && (!column.nullable || is_enum_column(column));
+
+    if sqlite_needs_recreation {
         let table_def = current_schema
             .iter()
             .find(|t| t.name == table)
@@ -47,7 +62,25 @@ pub fn build_add_column(
             &new_columns,
             &table_def.constraints,
         );
-        let create_query = BuiltQuery::CreateTable(Box::new(create_temp));
+
+        // For SQLite, add CHECK constraints for enum columns
+        // Use original table name for constraint naming (table will be renamed back)
+        let enum_check_clauses = collect_sqlite_enum_check_clauses(table, &new_columns);
+        let create_query = if !enum_check_clauses.is_empty() {
+            let base_sql = build_schema_statement(&create_temp, *backend);
+            let mut modified_sql = base_sql;
+            if let Some(pos) = modified_sql.rfind(')') {
+                let check_sql = enum_check_clauses.join(", ");
+                modified_sql.insert_str(pos, &format!(", {}", check_sql));
+            }
+            BuiltQuery::Raw(RawSql::per_backend(
+                modified_sql.clone(),
+                modified_sql.clone(),
+                modified_sql,
+            ))
+        } else {
+            BuiltQuery::CreateTable(Box::new(create_temp))
+        };
 
         // Copy existing data, filling new column
         let mut select_query = Query::select();

crates/vespertide-query/src/sql/create_table.rs

@@ -2,8 +2,11 @@ use sea_query::{Alias, ForeignKey, Index, Table, TableCreateStatement};
 
 use vespertide_core::{ColumnDef, ColumnType, ComplexColumnType, TableConstraint};
 
-use super::helpers::{build_create_enum_type_sql, build_sea_column_def, to_sea_fk_action};
-use super::types::{BuiltQuery, DatabaseBackend};
+use super::helpers::{
+    build_create_enum_type_sql, build_schema_statement, build_sea_column_def,
+    collect_sqlite_enum_check_clauses, to_sea_fk_action,
+};
+use super::types::{BuiltQuery, DatabaseBackend, RawSql};
 use crate::error::QueryError;
 
 pub(crate) fn build_create_table_for_backend(
@@ -145,7 +148,29 @@ pub fn build_create_table(
             table_constraints.iter().cloned().cloned().collect();
         build_create_table_for_backend(backend, table, columns, &table_constraints_owned)
     };
-    queries.push(BuiltQuery::CreateTable(Box::new(create_table_stmt)));
+
+    // For SQLite, add CHECK constraints for enum columns
+    if matches!(backend, DatabaseBackend::Sqlite) {
+        let enum_check_clauses = collect_sqlite_enum_check_clauses(table, columns);
+        if !enum_check_clauses.is_empty() {
+            // Embed CHECK constraints into CREATE TABLE statement
+            let base_sql = build_schema_statement(&create_table_stmt, *backend);
+            let mut modified_sql = base_sql;
+            if let Some(pos) = modified_sql.rfind(')') {
+                let check_sql = enum_check_clauses.join(", ");
+                modified_sql.insert_str(pos, &format!(", {}", check_sql));
+            }
+            queries.push(BuiltQuery::Raw(RawSql::per_backend(
+                modified_sql.clone(),
+                modified_sql.clone(),
+                modified_sql,
+            )));
+        } else {
+            queries.push(BuiltQuery::CreateTable(Box::new(create_table_stmt)));
+        }
+    } else {
+        queries.push(BuiltQuery::CreateTable(Box::new(create_table_stmt)));
+    }
 
     // For Postgres and SQLite, add unique constraints as separate CREATE UNIQUE INDEX statements
     if matches!(backend, DatabaseBackend::Postgres | DatabaseBackend::Sqlite) {

crates/vespertide-query/src/sql/helpers.rs

@@ -228,6 +228,43 @@ pub fn is_enum_type(column_type: &ColumnType) -> bool {
     )
 }
 
+/// Generate CHECK constraint name for SQLite enum column
+/// Format: chk_{table}_{column}
+pub fn build_sqlite_enum_check_name(table: &str, column: &str) -> String {
+    format!("chk_{}_{}", table, column)
+}
+
+/// Generate CHECK constraint expression for SQLite enum column
+/// Returns the constraint clause like: CONSTRAINT "chk_table_col" CHECK (col IN ('val1', 'val2'))
+pub fn build_sqlite_enum_check_clause(
+    table: &str,
+    column: &str,
+    column_type: &ColumnType,
+) -> Option<String> {
+    if let ColumnType::Complex(ComplexColumnType::Enum { values, .. }) = column_type {
+        let name = build_sqlite_enum_check_name(table, column);
+        let values_sql = values
+            .iter()
+            .map(|v| format!("'{}'", v.replace('\'', "''")))
+            .collect::<Vec<_>>()
+            .join(", ");
+        Some(format!(
+            "CONSTRAINT \"{}\" CHECK (\"{}\" IN ({}))",
+            name, column, values_sql
+        ))
+    } else {
+        None
+    }
+}
+
+/// Collect all CHECK constraints for enum columns in a table (for SQLite)
+pub fn collect_sqlite_enum_check_clauses(table: &str, columns: &[ColumnDef]) -> Vec<String> {
+    columns
+        .iter()
+        .filter_map(|col| build_sqlite_enum_check_clause(table, &col.name, &col.r#type))
+        .collect()
+}
+
 /// Extract enum name from column type if it's an enum
 pub fn get_enum_name(column_type: &ColumnType) -> Option<&str> {
     if let ColumnType::Complex(ComplexColumnType::Enum { name, .. }) = column_type {

crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Sqlite.snap

@@ -2,5 +2,7 @@
 source: crates/vespertide-query/src/sql/add_column.rs
 expression: sql
 ---
-;
-ALTER TABLE "users" ADD COLUMN "status" enum_text
+CREATE TABLE "users_temp" ( "id" integer NOT NULL, "status" enum_text , CONSTRAINT "chk_users_status" CHECK ("status" IN ('active', 'inactive')));
+INSERT INTO "users_temp" ("id", "status") SELECT "id", NULL AS "status" FROM "users";
+DROP TABLE "users";
+ALTER TABLE "users_temp" RENAME TO "users"

crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Sqlite.snap

@@ -3,4 +3,4 @@ source: crates/vespertide-query/src/sql/create_table.rs
 expression: sql
 ---
 ;
-CREATE TABLE "users" ( "id" integer NOT NULL, "status" enum_text NOT NULL DEFAULT 'active', PRIMARY KEY ("id") )
+CREATE TABLE "users" ( "id" integer NOT NULL, "status" enum_text NOT NULL DEFAULT 'active', PRIMARY KEY ("id") , CONSTRAINT "chk_users_status" CHECK ("status" IN ('active', 'inactive', 'pending')))