diff --git a/.changepacks/changepack_log_4sB2YBEV80GvtBNjS_r76.json b/.changepacks/changepack_log_4sB2YBEV80GvtBNjS_r76.json
new file mode 100644
index 0000000..f58c0dc
--- /dev/null
+++ b/.changepacks/changepack_log_4sB2YBEV80GvtBNjS_r76.json
@@ -0,0 +1 @@
+{"changes":{"crates/vespertide-core/Cargo.toml":"Patch","crates/vespertide-config/Cargo.toml":"Patch","crates/vespertide-exporter/Cargo.toml":"Patch","crates/vespertide-cli/Cargo.toml":"Patch","crates/vespertide-planner/Cargo.toml":"Patch","crates/vespertide-loader/Cargo.toml":"Patch","crates/vespertide-query/Cargo.toml":"Patch","crates/vespertide-macro/Cargo.toml":"Patch","crates/vespertide/Cargo.toml":"Patch"},"note":"Support enum","date":"2025-12-17T11:30:23.776147Z"}
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index 9dccd7d..3700bff 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -523,19 +523,6 @@ dependencies = [
  "syn 2.0.111",
 ]
 
-[[package]]
-name = "dashmap"
-version = "5.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
-dependencies = [
- "cfg-if",
- "hashbrown 0.14.5",
- "lock_api",
- "once_cell",
- "parking_lot_core",
-]
-
 [[package]]
 name = "der"
 version = "0.7.10"
@@ -901,12 +888,6 @@ dependencies = [
  "ahash",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.14.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
-
 [[package]]
 name = "hashbrown"
 version = "0.15.5"
@@ -2251,20 +2232,6 @@ dependencies = [
  "unsafe-libyaml",
 ]
 
-[[package]]
-name = "serial_test"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "538c30747ae860d6fb88330addbbd3e0ddbe46d662d032855596d8a8ca260611"
-dependencies = [
- "dashmap",
- "futures",
- "lazy_static",
- "log",
- "parking_lot",
- "serial_test_derive 1.0.0",
-]
-
 [[package]]
 name = "serial_test"
 version = "3.2.0"
@@ -2276,18 +2243,7 @@ dependencies = [
  "once_cell",
  "parking_lot",
  "scc",
- "serial_test_derive 3.2.0",
-]
-
-[[package]]
-name = "serial_test_derive"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "079a83df15f85d89a68d64ae1238f142f172b1fa915d0d76b26a7cba1b659a69"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
+ "serial_test_derive",
 ]
 
 [[package]]
@@ -2982,7 +2938,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vespertide"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "vespertide-core",
  "vespertide-macro",
@@ -2990,7 +2946,7 @@ dependencies = [
 
 [[package]]
 name = "vespertide-cli"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -3002,7 +2958,7 @@ dependencies = [
  "schemars",
  "serde_json",
  "serde_yaml",
- "serial_test 3.2.0",
+ "serial_test",
  "tempfile",
  "vespertide-config",
  "vespertide-core",
@@ -3014,7 +2970,7 @@ dependencies = [
 
 [[package]]
 name = "vespertide-config"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "clap",
  "serde",
@@ -3022,7 +2978,7 @@ dependencies = [
 
 [[package]]
 name = "vespertide-core"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "rstest",
  "schemars",
@@ -3032,7 +2988,7 @@ dependencies = [
 
 [[package]]
 name = "vespertide-exporter"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "insta",
  "rstest",
@@ -3042,13 +2998,13 @@ dependencies = [
 
 [[package]]
 name = "vespertide-loader"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "anyhow",
  "rstest",
  "serde_json",
  "serde_yaml",
- "serial_test 1.0.0",
+ "serial_test",
  "tempfile",
  "vespertide-config",
  "vespertide-core",
@@ -3057,7 +3013,7 @@ dependencies = [
 
 [[package]]
 name = "vespertide-macro"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3067,12 +3023,13 @@ dependencies = [
  "vespertide-config",
  "vespertide-core",
  "vespertide-loader",
+ "vespertide-planner",
  "vespertide-query",
 ]
 
 [[package]]
 name = "vespertide-planner"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "rstest",
  "thiserror",
@@ -3081,13 +3038,14 @@ dependencies = [
 
 [[package]]
 name = "vespertide-query"
-version = "0.1.9"
+version = "0.1.10"
 dependencies = [
  "insta",
  "rstest",
  "sea-query 0.32.7",
  "thiserror",
  "vespertide-core",
+ "vespertide-planner",
 ]
 
 [[package]]
diff --git a/crates/vespertide-cli/src/commands/log.rs b/crates/vespertide-cli/src/commands/log.rs
index f9db36f..ca519cf 100644
--- a/crates/vespertide-cli/src/commands/log.rs
+++ b/crates/vespertide-cli/src/commands/log.rs
@@ -1,6 +1,7 @@
 use anyhow::Result;
 use colored::Colorize;
-use vespertide_loader::{load_config, load_models};
+use vespertide_loader::load_config;
+use vespertide_planner::apply_action;
 use vespertide_query::{DatabaseBackend, build_plan_queries};
 
 use crate::utils::load_migrations;
@@ -21,7 +22,10 @@ pub fn cmd_log(backend: DatabaseBackend) -> Result<()> {
         plans.len().to_string().bright_yellow().bold()
     );
     println!();
-    let current_models = load_models(&config)?;
+
+    // Build baseline schema incrementally as we iterate through migrations
+    let mut baseline_schema = Vec::new();
+
     for plan in &plans {
         println!(
             "{} {}",
@@ -44,9 +48,15 @@ pub fn cmd_log(backend: DatabaseBackend) -> Result<()> {
             plan.actions.len().to_string().bright_yellow()
         );
 
-        let plan_queries = build_plan_queries(plan, &current_models)
+        // Use the current baseline schema (from all previous migrations)
+        let plan_queries = build_plan_queries(plan, &baseline_schema)
             .map_err(|e| anyhow::anyhow!("query build error for v{}: {}", plan.version, e))?;
 
+        // Update baseline schema incrementally by applying each action
+        for action in &plan.actions {
+            let _ = apply_action(&mut baseline_schema, action);
+        }
+
         for (i, pq) in plan_queries.iter().enumerate() {
             println!(
                 "    {}. {}",
diff --git a/crates/vespertide-cli/src/commands/sql.rs b/crates/vespertide-cli/src/commands/sql.rs
index e7b2a31..465e339 100644
--- a/crates/vespertide-cli/src/commands/sql.rs
+++ b/crates/vespertide-cli/src/commands/sql.rs
@@ -1,6 +1,6 @@
 use anyhow::Result;
 use colored::Colorize;
-use vespertide_planner::plan_next_migration;
+use vespertide_planner::{plan_next_migration_with_baseline, schema_from_plans};
 use vespertide_query::{DatabaseBackend, build_plan_queries};
 
 use crate::utils::{load_config, load_migrations, load_models};
@@ -10,10 +10,15 @@ pub fn cmd_sql(backend: DatabaseBackend) -> Result<()> {
     let current_models = load_models(&config)?;
     let applied_plans = load_migrations(&config)?;
 
-    let plan = plan_next_migration(&current_models, &applied_plans)
+    // Reconstruct the baseline schema from applied migrations
+    let baseline_schema = schema_from_plans(&applied_plans)
+        .map_err(|e| anyhow::anyhow!("failed to reconstruct schema: {}", e))?;
+
+    // Plan next migration using the pre-computed baseline
+    let plan = plan_next_migration_with_baseline(&current_models, &applied_plans, &baseline_schema)
         .map_err(|e| anyhow::anyhow!("planning error: {}", e))?;
 
-    emit_sql(&plan, backend, &current_models)
+    emit_sql(&plan, backend, &baseline_schema)
 }
 
 fn emit_sql(
diff --git a/crates/vespertide-core/src/schema/column.rs b/crates/vespertide-core/src/schema/column.rs
index 8173f5b..23fd5a3 100644
--- a/crates/vespertide-core/src/schema/column.rs
+++ b/crates/vespertide-core/src/schema/column.rs
@@ -1,306 +1,226 @@
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
-use crate::schema::{
-    foreign_key::ForeignKeySyntax, names::ColumnName, primary_key::PrimaryKeySyntax,
-    str_or_bool::StrOrBoolOrArray,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub struct ColumnDef {
-    pub name: ColumnName,
-    pub r#type: ColumnType,
-    pub nullable: bool,
-    pub default: Option<String>,
-    pub comment: Option<String>,
-    pub primary_key: Option<PrimaryKeySyntax>,
-    pub unique: Option<StrOrBoolOrArray>,
-    pub index: Option<StrOrBoolOrArray>,
-    pub foreign_key: Option<ForeignKeySyntax>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "snake_case", untagged)]
-pub enum ColumnType {
-    Simple(SimpleColumnType),
-    Complex(ComplexColumnType),
-}
-
-impl ColumnType {
-    /// Convert column type to SQL type string
-    pub fn to_sql(&self) -> String {
-        match self {
-            ColumnType::Simple(ty) => match ty {
-                SimpleColumnType::SmallInt => "SMALLINT".into(),
-                SimpleColumnType::Integer => "INTEGER".into(),
-                SimpleColumnType::BigInt => "BIGINT".into(),
-                SimpleColumnType::Real => "REAL".into(),
-                SimpleColumnType::DoublePrecision => "DOUBLE PRECISION".into(),
-                SimpleColumnType::Text => "TEXT".into(),
-                SimpleColumnType::Boolean => "BOOLEAN".into(),
-                SimpleColumnType::Date => "DATE".into(),
-                SimpleColumnType::Time => "TIME".into(),
-                SimpleColumnType::Timestamp => "TIMESTAMP".into(),
-                SimpleColumnType::Timestamptz => "TIMESTAMPTZ".into(),
-                SimpleColumnType::Interval => "INTERVAL".into(),
-                SimpleColumnType::Bytea => "BYTEA".into(),
-                SimpleColumnType::Uuid => "UUID".into(),
-                SimpleColumnType::Json => "JSON".into(),
-                SimpleColumnType::Jsonb => "JSONB".into(),
-                SimpleColumnType::Inet => "INET".into(),
-                SimpleColumnType::Cidr => "CIDR".into(),
-                SimpleColumnType::Macaddr => "MACADDR".into(),
-                SimpleColumnType::Xml => "XML".into(),
-            },
-            ColumnType::Complex(ty) => match ty {
-                ComplexColumnType::Varchar { length } => format!("VARCHAR({})", length),
-                ComplexColumnType::Numeric { precision, scale } => {
-                    format!("NUMERIC({}, {})", precision, scale)
-                }
-                ComplexColumnType::Char { length } => format!("CHAR({})", length),
-                ComplexColumnType::Custom { custom_type } => custom_type.clone(),
-            },
-        }
-    }
-
-    /// Convert column type to Rust type string (for SeaORM entity generation)
-    pub fn to_rust_type(&self, nullable: bool) -> String {
-        let base = match self {
-            ColumnType::Simple(ty) => match ty {
-                SimpleColumnType::SmallInt => "i16".to_string(),
-                SimpleColumnType::Integer => "i32".to_string(),
-                SimpleColumnType::BigInt => "i64".to_string(),
-                SimpleColumnType::Real => "f32".to_string(),
-                SimpleColumnType::DoublePrecision => "f64".to_string(),
-                SimpleColumnType::Text => "String".to_string(),
-                SimpleColumnType::Boolean => "bool".to_string(),
-                SimpleColumnType::Date => "Date".to_string(),
-                SimpleColumnType::Time => "Time".to_string(),
-                SimpleColumnType::Timestamp => "DateTime".to_string(),
-                SimpleColumnType::Timestamptz => "DateTimeWithTimeZone".to_string(),
-                SimpleColumnType::Interval => "String".to_string(),
-                SimpleColumnType::Bytea => "Vec<u8>".to_string(),
-                SimpleColumnType::Uuid => "Uuid".to_string(),
-                SimpleColumnType::Json | SimpleColumnType::Jsonb => "Json".to_string(),
-                SimpleColumnType::Inet | SimpleColumnType::Cidr => "String".to_string(),
-                SimpleColumnType::Macaddr => "String".to_string(),
-                SimpleColumnType::Xml => "String".to_string(),
-            },
-            ColumnType::Complex(ty) => match ty {
-                ComplexColumnType::Varchar { .. } => "String".to_string(),
-                ComplexColumnType::Numeric { .. } => "Decimal".to_string(),
-                ComplexColumnType::Char { .. } => "String".to_string(),
-                ComplexColumnType::Custom { .. } => "String".to_string(), // Default for custom types
-            },
-        };
-
-        if nullable {
-            format!("Option<{}>", base)
-        } else {
-            base
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum SimpleColumnType {
-    SmallInt,
-    Integer,
-    BigInt,
-    Real,
-    DoublePrecision,
-
-    // Text types
-    Text,
-
-    // Boolean type
-    Boolean,
-
-    // Date/Time types
-    Date,
-    Time,
-    Timestamp,
-    Timestamptz,
-    Interval,
-
-    // Binary type
-    Bytea,
-
-    // UUID type
-    Uuid,
-
-    // JSON types
-    Json,
-    Jsonb,
-
-    // Network types
-    Inet,
-    Cidr,
-    Macaddr,
-
-    // XML type
-    Xml,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "snake_case", tag = "kind")]
-pub enum ComplexColumnType {
-    Varchar { length: u32 },
-    Numeric { precision: u32, scale: u32 },
-    Char { length: u32 },
-    Custom { custom_type: String },
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rstest::rstest;
-
-    #[rstest]
-    #[case(SimpleColumnType::SmallInt, "SMALLINT")]
-    #[case(SimpleColumnType::Integer, "INTEGER")]
-    #[case(SimpleColumnType::BigInt, "BIGINT")]
-    #[case(SimpleColumnType::Real, "REAL")]
-    #[case(SimpleColumnType::DoublePrecision, "DOUBLE PRECISION")]
-    #[case(SimpleColumnType::Text, "TEXT")]
-    #[case(SimpleColumnType::Boolean, "BOOLEAN")]
-    #[case(SimpleColumnType::Date, "DATE")]
-    #[case(SimpleColumnType::Time, "TIME")]
-    #[case(SimpleColumnType::Timestamp, "TIMESTAMP")]
-    #[case(SimpleColumnType::Timestamptz, "TIMESTAMPTZ")]
-    #[case(SimpleColumnType::Interval, "INTERVAL")]
-    #[case(SimpleColumnType::Bytea, "BYTEA")]
-    #[case(SimpleColumnType::Uuid, "UUID")]
-    #[case(SimpleColumnType::Json, "JSON")]
-    #[case(SimpleColumnType::Jsonb, "JSONB")]
-    #[case(SimpleColumnType::Inet, "INET")]
-    #[case(SimpleColumnType::Cidr, "CIDR")]
-    #[case(SimpleColumnType::Macaddr, "MACADDR")]
-    #[case(SimpleColumnType::Xml, "XML")]
-    fn test_simple_column_type_to_sql(
-        #[case] column_type: SimpleColumnType,
-        #[case] expected: &str,
-    ) {
-        assert_eq!(ColumnType::Simple(column_type).to_sql(), expected);
-    }
-
-    #[rstest]
-    #[case(ComplexColumnType::Varchar { length: 255 }, "VARCHAR(255)")]
-    #[case(ComplexColumnType::Varchar { length: 50 }, "VARCHAR(50)")]
-    #[case(ComplexColumnType::Varchar { length: 1 }, "VARCHAR(1)")]
-    #[case(ComplexColumnType::Numeric { precision: 10, scale: 2 }, "NUMERIC(10, 2)")]
-    #[case(ComplexColumnType::Numeric { precision: 5, scale: 0 }, "NUMERIC(5, 0)")]
-    #[case(ComplexColumnType::Numeric { precision: 18, scale: 4 }, "NUMERIC(18, 4)")]
-    #[case(ComplexColumnType::Char { length: 10 }, "CHAR(10)")]
-    #[case(ComplexColumnType::Char { length: 1 }, "CHAR(1)")]
-    #[case(ComplexColumnType::Char { length: 255 }, "CHAR(255)")]
-    #[case(ComplexColumnType::Custom { custom_type: "MONEY".into() }, "MONEY")]
-    #[case(ComplexColumnType::Custom { custom_type: "JSONB".into() }, "JSONB")]
-    #[case(ComplexColumnType::Custom { custom_type: "CUSTOM_TYPE".into() }, "CUSTOM_TYPE")]
-    fn test_complex_column_type_to_sql(
-        #[case] column_type: ComplexColumnType,
-        #[case] expected: &str,
-    ) {
-        assert_eq!(ColumnType::Complex(column_type).to_sql(), expected);
-    }
-
-    #[rstest]
-    #[case(SimpleColumnType::SmallInt, "i16")]
-    #[case(SimpleColumnType::Integer, "i32")]
-    #[case(SimpleColumnType::BigInt, "i64")]
-    #[case(SimpleColumnType::Real, "f32")]
-    #[case(SimpleColumnType::DoublePrecision, "f64")]
-    #[case(SimpleColumnType::Text, "String")]
-    #[case(SimpleColumnType::Boolean, "bool")]
-    #[case(SimpleColumnType::Date, "Date")]
-    #[case(SimpleColumnType::Time, "Time")]
-    #[case(SimpleColumnType::Timestamp, "DateTime")]
-    #[case(SimpleColumnType::Timestamptz, "DateTimeWithTimeZone")]
-    #[case(SimpleColumnType::Interval, "String")]
-    #[case(SimpleColumnType::Bytea, "Vec<u8>")]
-    #[case(SimpleColumnType::Uuid, "Uuid")]
-    #[case(SimpleColumnType::Json, "Json")]
-    #[case(SimpleColumnType::Jsonb, "Json")]
-    #[case(SimpleColumnType::Inet, "String")]
-    #[case(SimpleColumnType::Cidr, "String")]
-    #[case(SimpleColumnType::Macaddr, "String")]
-    #[case(SimpleColumnType::Xml, "String")]
-    fn test_simple_column_type_to_rust_type_not_nullable(
-        #[case] column_type: SimpleColumnType,
-        #[case] expected: &str,
-    ) {
-        assert_eq!(
-            ColumnType::Simple(column_type).to_rust_type(false),
-            expected
-        );
-    }
-
-    #[rstest]
-    #[case(SimpleColumnType::SmallInt, "Option<i16>")]
-    #[case(SimpleColumnType::Integer, "Option<i32>")]
-    #[case(SimpleColumnType::BigInt, "Option<i64>")]
-    #[case(SimpleColumnType::Real, "Option<f32>")]
-    #[case(SimpleColumnType::DoublePrecision, "Option<f64>")]
-    #[case(SimpleColumnType::Text, "Option<String>")]
-    #[case(SimpleColumnType::Boolean, "Option<bool>")]
-    #[case(SimpleColumnType::Date, "Option<Date>")]
-    #[case(SimpleColumnType::Time, "Option<Time>")]
-    #[case(SimpleColumnType::Timestamp, "Option<DateTime>")]
-    #[case(SimpleColumnType::Timestamptz, "Option<DateTimeWithTimeZone>")]
-    #[case(SimpleColumnType::Interval, "Option<String>")]
-    #[case(SimpleColumnType::Bytea, "Option<Vec<u8>>")]
-    #[case(SimpleColumnType::Uuid, "Option<Uuid>")]
-    #[case(SimpleColumnType::Json, "Option<Json>")]
-    #[case(SimpleColumnType::Jsonb, "Option<Json>")]
-    #[case(SimpleColumnType::Inet, "Option<String>")]
-    #[case(SimpleColumnType::Cidr, "Option<String>")]
-    #[case(SimpleColumnType::Macaddr, "Option<String>")]
-    #[case(SimpleColumnType::Xml, "Option<String>")]
-    fn test_simple_column_type_to_rust_type_nullable(
-        #[case] column_type: SimpleColumnType,
-        #[case] expected: &str,
-    ) {
-        assert_eq!(ColumnType::Simple(column_type).to_rust_type(true), expected);
-    }
-
-    #[rstest]
-    #[case(ComplexColumnType::Varchar { length: 255 }, false, "String")]
-    #[case(ComplexColumnType::Varchar { length: 50 }, false, "String")]
-    #[case(ComplexColumnType::Numeric { precision: 10, scale: 2 }, false, "Decimal")]
-    #[case(ComplexColumnType::Numeric { precision: 5, scale: 0 }, false, "Decimal")]
-    #[case(ComplexColumnType::Char { length: 10 }, false, "String")]
-    #[case(ComplexColumnType::Char { length: 1 }, false, "String")]
-    #[case(ComplexColumnType::Custom { custom_type: "MONEY".into() }, false, "String")]
-    #[case(ComplexColumnType::Custom { custom_type: "JSONB".into() }, false, "String")]
-    fn test_complex_column_type_to_rust_type_not_nullable(
-        #[case] column_type: ComplexColumnType,
-        #[case] nullable: bool,
-        #[case] expected: &str,
-    ) {
-        assert_eq!(
-            ColumnType::Complex(column_type).to_rust_type(nullable),
-            expected
-        );
-    }
-
-    #[rstest]
-    #[case(ComplexColumnType::Varchar { length: 255 }, "Option<String>")]
-    #[case(ComplexColumnType::Varchar { length: 50 }, "Option<String>")]
-    #[case(ComplexColumnType::Numeric { precision: 10, scale: 2 }, "Option<Decimal>")]
-    #[case(ComplexColumnType::Numeric { precision: 5, scale: 0 }, "Option<Decimal>")]
-    #[case(ComplexColumnType::Char { length: 10 }, "Option<String>")]
-    #[case(ComplexColumnType::Char { length: 1 }, "Option<String>")]
-    #[case(ComplexColumnType::Custom { custom_type: "MONEY".into() }, "Option<String>")]
-    #[case(ComplexColumnType::Custom { custom_type: "JSONB".into() }, "Option<String>")]
-    fn test_complex_column_type_to_rust_type_nullable(
-        #[case] column_type: ComplexColumnType,
-        #[case] expected: &str,
-    ) {
-        assert_eq!(
-            ColumnType::Complex(column_type).to_rust_type(true),
-            expected
-        );
-    }
-}
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::schema::{
+    foreign_key::ForeignKeySyntax, names::ColumnName, primary_key::PrimaryKeySyntax,
+    str_or_bool::StrOrBoolOrArray,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct ColumnDef {
+    pub name: ColumnName,
+    pub r#type: ColumnType,
+    pub nullable: bool,
+    pub default: Option<String>,
+    pub comment: Option<String>,
+    pub primary_key: Option<PrimaryKeySyntax>,
+    pub unique: Option<StrOrBoolOrArray>,
+    pub index: Option<StrOrBoolOrArray>,
+    pub foreign_key: Option<ForeignKeySyntax>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case", untagged)]
+pub enum ColumnType {
+    Simple(SimpleColumnType),
+    Complex(ComplexColumnType),
+}
+
+impl ColumnType {
+    /// Convert column type to Rust type string (for SeaORM entity generation)
+    pub fn to_rust_type(&self, nullable: bool) -> String {
+        let base = match self {
+            ColumnType::Simple(ty) => match ty {
+                SimpleColumnType::SmallInt => "i16".to_string(),
+                SimpleColumnType::Integer => "i32".to_string(),
+                SimpleColumnType::BigInt => "i64".to_string(),
+                SimpleColumnType::Real => "f32".to_string(),
+                SimpleColumnType::DoublePrecision => "f64".to_string(),
+                SimpleColumnType::Text => "String".to_string(),
+                SimpleColumnType::Boolean => "bool".to_string(),
+                SimpleColumnType::Date => "Date".to_string(),
+                SimpleColumnType::Time => "Time".to_string(),
+                SimpleColumnType::Timestamp => "DateTime".to_string(),
+                SimpleColumnType::Timestamptz => "DateTimeWithTimeZone".to_string(),
+                SimpleColumnType::Interval => "String".to_string(),
+                SimpleColumnType::Bytea => "Vec<u8>".to_string(),
+                SimpleColumnType::Uuid => "Uuid".to_string(),
+                SimpleColumnType::Json | SimpleColumnType::Jsonb => "Json".to_string(),
+                SimpleColumnType::Inet | SimpleColumnType::Cidr => "String".to_string(),
+                SimpleColumnType::Macaddr => "String".to_string(),
+                SimpleColumnType::Xml => "String".to_string(),
+            },
+            ColumnType::Complex(ty) => match ty {
+                ComplexColumnType::Varchar { .. } => "String".to_string(),
+                ComplexColumnType::Numeric { .. } => "Decimal".to_string(),
+                ComplexColumnType::Char { .. } => "String".to_string(),
+                ComplexColumnType::Custom { .. } => "String".to_string(), // Default for custom types
+                ComplexColumnType::Enum { .. } => "String".to_string(),
+            },
+        };
+
+        if nullable {
+            format!("Option<{}>", base)
+        } else {
+            base
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum SimpleColumnType {
+    SmallInt,
+    Integer,
+    BigInt,
+    Real,
+    DoublePrecision,
+
+    // Text types
+    Text,
+
+    // Boolean type
+    Boolean,
+
+    // Date/Time types
+    Date,
+    Time,
+    Timestamp,
+    Timestamptz,
+    Interval,
+
+    // Binary type
+    Bytea,
+
+    // UUID type
+    Uuid,
+
+    // JSON types
+    Json,
+    Jsonb,
+
+    // Network types
+    Inet,
+    Cidr,
+    Macaddr,
+
+    // XML type
+    Xml,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case", tag = "kind")]
+pub enum ComplexColumnType {
+    Varchar { length: u32 },
+    Numeric { precision: u32, scale: u32 },
+    Char { length: u32 },
+    Custom { custom_type: String },
+    Enum { name: String, values: Vec<String> },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rstest::rstest;
+
+    #[rstest]
+    #[case(SimpleColumnType::SmallInt, "i16")]
+    #[case(SimpleColumnType::Integer, "i32")]
+    #[case(SimpleColumnType::BigInt, "i64")]
+    #[case(SimpleColumnType::Real, "f32")]
+    #[case(SimpleColumnType::DoublePrecision, "f64")]
+    #[case(SimpleColumnType::Text, "String")]
+    #[case(SimpleColumnType::Boolean, "bool")]
+    #[case(SimpleColumnType::Date, "Date")]
+    #[case(SimpleColumnType::Time, "Time")]
+    #[case(SimpleColumnType::Timestamp, "DateTime")]
+    #[case(SimpleColumnType::Timestamptz, "DateTimeWithTimeZone")]
+    #[case(SimpleColumnType::Interval, "String")]
+    #[case(SimpleColumnType::Bytea, "Vec<u8>")]
+    #[case(SimpleColumnType::Uuid, "Uuid")]
+    #[case(SimpleColumnType::Json, "Json")]
+    #[case(SimpleColumnType::Jsonb, "Json")]
+    #[case(SimpleColumnType::Inet, "String")]
+    #[case(SimpleColumnType::Cidr, "String")]
+    #[case(SimpleColumnType::Macaddr, "String")]
+    #[case(SimpleColumnType::Xml, "String")]
+    fn test_simple_column_type_to_rust_type_not_nullable(
+        #[case] column_type: SimpleColumnType,
+        #[case] expected: &str,
+    ) {
+        assert_eq!(
+            ColumnType::Simple(column_type).to_rust_type(false),
+            expected
+        );
+    }
+
+    #[rstest]
+    #[case(SimpleColumnType::SmallInt, "Option<i16>")]
+    #[case(SimpleColumnType::Integer, "Option<i32>")]
+    #[case(SimpleColumnType::BigInt, "Option<i64>")]
+    #[case(SimpleColumnType::Real, "Option<f32>")]
+    #[case(SimpleColumnType::DoublePrecision, "Option<f64>")]
+    #[case(SimpleColumnType::Text, "Option<String>")]
+    #[case(SimpleColumnType::Boolean, "Option<bool>")]
+    #[case(SimpleColumnType::Date, "Option<Date>")]
+    #[case(SimpleColumnType::Time, "Option<Time>")]
+    #[case(SimpleColumnType::Timestamp, "Option<DateTime>")]
+    #[case(SimpleColumnType::Timestamptz, "Option<DateTimeWithTimeZone>")]
+    #[case(SimpleColumnType::Interval, "Option<String>")]
+    #[case(SimpleColumnType::Bytea, "Option<Vec<u8>>")]
+    #[case(SimpleColumnType::Uuid, "Option<Uuid>")]
+    #[case(SimpleColumnType::Json, "Option<Json>")]
+    #[case(SimpleColumnType::Jsonb, "Option<Json>")]
+    #[case(SimpleColumnType::Inet, "Option<String>")]
+    #[case(SimpleColumnType::Cidr, "Option<String>")]
+    #[case(SimpleColumnType::Macaddr, "Option<String>")]
+    #[case(SimpleColumnType::Xml, "Option<String>")]
+    fn test_simple_column_type_to_rust_type_nullable(
+        #[case] column_type: SimpleColumnType,
+        #[case] expected: &str,
+    ) {
+        assert_eq!(ColumnType::Simple(column_type).to_rust_type(true), expected);
+    }
+
+    #[rstest]
+    #[case(ComplexColumnType::Varchar { length: 255 }, false, "String")]
+    #[case(ComplexColumnType::Varchar { length: 50 }, false, "String")]
+    #[case(ComplexColumnType::Numeric { precision: 10, scale: 2 }, false, "Decimal")]
+    #[case(ComplexColumnType::Numeric { precision: 5, scale: 0 }, false, "Decimal")]
+    #[case(ComplexColumnType::Char { length: 10 }, false, "String")]
+    #[case(ComplexColumnType::Char { length: 1 }, false, "String")]
+    #[case(ComplexColumnType::Custom { custom_type: "MONEY".into() }, false, "String")]
+    #[case(ComplexColumnType::Custom { custom_type: "JSONB".into() }, false, "String")]
+    #[case(ComplexColumnType::Enum { name: "status".into(), values: vec!["active".into(), "inactive".into()] }, false, "String")]
+    fn test_complex_column_type_to_rust_type_not_nullable(
+        #[case] column_type: ComplexColumnType,
+        #[case] nullable: bool,
+        #[case] expected: &str,
+    ) {
+        assert_eq!(
+            ColumnType::Complex(column_type).to_rust_type(nullable),
+            expected
+        );
+    }
+
+    #[rstest]
+    #[case(ComplexColumnType::Varchar { length: 255 }, "Option<String>")]
+    #[case(ComplexColumnType::Varchar { length: 50 }, "Option<String>")]
+    #[case(ComplexColumnType::Numeric { precision: 10, scale: 2 }, "Option<Decimal>")]
+    #[case(ComplexColumnType::Numeric { precision: 5, scale: 0 }, "Option<Decimal>")]
+    #[case(ComplexColumnType::Char { length: 10 }, "Option<String>")]
+    #[case(ComplexColumnType::Char { length: 1 }, "Option<String>")]
+    #[case(ComplexColumnType::Custom { custom_type: "MONEY".into() }, "Option<String>")]
+    #[case(ComplexColumnType::Custom { custom_type: "JSONB".into() }, "Option<String>")]
+    #[case(ComplexColumnType::Enum { name: "status".into(), values: vec!["active".into(), "inactive".into()] }, "Option<String>")]
+    fn test_complex_column_type_to_rust_type_nullable(
+        #[case] column_type: ComplexColumnType,
+        #[case] expected: &str,
+    ) {
+        assert_eq!(
+            ColumnType::Complex(column_type).to_rust_type(true),
+            expected
+        );
+    }
+}
diff --git a/crates/vespertide-core/src/schema/table.rs b/crates/vespertide-core/src/schema/table.rs
index e5cda51..63ce663 100644
--- a/crates/vespertide-core/src/schema/table.rs
+++ b/crates/vespertide-core/src/schema/table.rs
@@ -1,1376 +1,1413 @@
-use schemars::JsonSchema;
-
-use serde::{Deserialize, Serialize};
-use std::collections::{HashMap, HashSet};
-
-use crate::schema::{
-    StrOrBoolOrArray, column::ColumnDef, constraint::TableConstraint,
-    foreign_key::ForeignKeySyntax, index::IndexDef, names::TableName,
-    primary_key::PrimaryKeySyntax,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum TableValidationError {
-    DuplicateIndexColumn {
-        index_name: String,
-        column_name: String,
-    },
-    InvalidForeignKeyFormat {
-        column_name: String,
-        value: String,
-    },
-}
-
-impl std::fmt::Display for TableValidationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            TableValidationError::DuplicateIndexColumn {
-                index_name,
-                column_name,
-            } => {
-                write!(
-                    f,
-                    "Duplicate index '{}' on column '{}': the same index name cannot be applied to the same column multiple times",
-                    index_name, column_name
-                )
-            }
-            TableValidationError::InvalidForeignKeyFormat { column_name, value } => {
-                write!(
-                    f,
-                    "Invalid foreign key format '{}' on column '{}': expected 'table.column' format",
-                    value, column_name
-                )
-            }
-        }
-    }
-}
-
-impl std::error::Error for TableValidationError {}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub struct TableDef {
-    pub name: TableName,
-    pub columns: Vec<ColumnDef>,
-    pub constraints: Vec<TableConstraint>,
-    pub indexes: Vec<IndexDef>,
-}
-
-impl TableDef {
-    /// Normalizes inline column constraints (primary_key, unique, index, foreign_key)
-    /// into table-level constraints and indexes.
-    /// Returns a new TableDef with all inline constraints converted to table-level.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the same index name is applied to the same column multiple times.
-    pub fn normalize(&self) -> Result<Self, TableValidationError> {
-        let mut constraints = self.constraints.clone();
-        let mut indexes = self.indexes.clone();
-
-        // Collect columns with inline primary_key and check for auto_increment
-        let mut pk_columns: Vec<String> = Vec::new();
-        let mut pk_auto_increment = false;
-
-        for col in &self.columns {
-            if let Some(ref pk) = col.primary_key {
-                match pk {
-                    PrimaryKeySyntax::Bool(true) => {
-                        pk_columns.push(col.name.clone());
-                    }
-                    PrimaryKeySyntax::Bool(false) => {}
-                    PrimaryKeySyntax::Object(pk_def) => {
-                        pk_columns.push(col.name.clone());
-                        if pk_def.auto_increment {
-                            pk_auto_increment = true;
-                        }
-                    }
-                }
-            }
-        }
-
-        // Add primary key constraint if any columns have inline pk and no existing pk constraint.
-        if !pk_columns.is_empty() {
-            let has_pk_constraint = constraints
-                .iter()
-                .any(|c| matches!(c, TableConstraint::PrimaryKey { .. }));
-
-            if !has_pk_constraint {
-                constraints.push(TableConstraint::PrimaryKey {
-                    auto_increment: pk_auto_increment,
-                    columns: pk_columns,
-                });
-            }
-        }
-
-        // Process inline unique and index for each column
-        for col in &self.columns {
-            // Handle inline unique
-            if let Some(ref unique_val) = col.unique {
-                match unique_val {
-                    StrOrBoolOrArray::Str(name) => {
-                        let constraint_name = Some(name.clone());
-
-                        // Check if this unique constraint already exists
-                        let exists = constraints.iter().any(|c| {
-                            if let TableConstraint::Unique {
-                                name: c_name,
-                                columns,
-                            } = c
-                            {
-                                c_name.as_ref() == Some(name)
-                                    && columns.len() == 1
-                                    && columns[0] == col.name
-                            } else {
-                                false
-                            }
-                        });
-
-                        if !exists {
-                            constraints.push(TableConstraint::Unique {
-                                name: constraint_name,
-                                columns: vec![col.name.clone()],
-                            });
-                        }
-                    }
-                    StrOrBoolOrArray::Bool(true) => {
-                        let exists = constraints.iter().any(|c| {
-                            if let TableConstraint::Unique {
-                                name: None,
-                                columns,
-                            } = c
-                            {
-                                columns.len() == 1 && columns[0] == col.name
-                            } else {
-                                false
-                            }
-                        });
-
-                        if !exists {
-                            constraints.push(TableConstraint::Unique {
-                                name: None,
-                                columns: vec![col.name.clone()],
-                            });
-                        }
-                    }
-                    StrOrBoolOrArray::Bool(false) => continue,
-                    StrOrBoolOrArray::Array(names) => {
-                        // Array format: each element is a constraint name
-                        // This column will be part of all these named constraints
-                        for constraint_name in names {
-                            // Check if constraint with this name already exists
-                            if let Some(existing) = constraints.iter_mut().find(|c| {
-                                if let TableConstraint::Unique { name: Some(n), .. } = c {
-                                    n == constraint_name
-                                } else {
-                                    false
-                                }
-                            }) {
-                                // Add this column to existing composite constraint
-                                if let TableConstraint::Unique { columns, .. } = existing
-                                    && !columns.contains(&col.name)
-                                {
-                                    columns.push(col.name.clone());
-                                }
-                            } else {
-                                // Create new constraint with this column
-                                constraints.push(TableConstraint::Unique {
-                                    name: Some(constraint_name.clone()),
-                                    columns: vec![col.name.clone()],
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Handle inline foreign_key
-            if let Some(ref fk_syntax) = col.foreign_key {
-                // Convert ForeignKeySyntax to ForeignKeyDef
-                let (ref_table, ref_columns, on_delete, on_update) = match fk_syntax {
-                    ForeignKeySyntax::String(s) => {
-                        // Parse "table.column" format
-                        let parts: Vec<&str> = s.split('.').collect();
-                        if parts.len() != 2 || parts[0].is_empty() || parts[1].is_empty() {
-                            return Err(TableValidationError::InvalidForeignKeyFormat {
-                                column_name: col.name.clone(),
-                                value: s.clone(),
-                            });
-                        }
-                        (parts[0].to_string(), vec![parts[1].to_string()], None, None)
-                    }
-                    ForeignKeySyntax::Object(fk_def) => (
-                        fk_def.ref_table.clone(),
-                        fk_def.ref_columns.clone(),
-                        fk_def.on_delete.clone(),
-                        fk_def.on_update.clone(),
-                    ),
-                };
-
-                // Check if this foreign key already exists
-                let exists = constraints.iter().any(|c| {
-                    if let TableConstraint::ForeignKey { columns, .. } = c {
-                        columns.len() == 1 && columns[0] == col.name
-                    } else {
-                        false
-                    }
-                });
-
-                if !exists {
-                    constraints.push(TableConstraint::ForeignKey {
-                        name: None,
-                        columns: vec![col.name.clone()],
-                        ref_table,
-                        ref_columns,
-                        on_delete,
-                        on_update,
-                    });
-                }
-            }
-        }
-
-        // Group columns by index name to create composite indexes
-        // Use a HashMap to group, but preserve column order by tracking first occurrence
-        let mut index_groups: HashMap<String, Vec<String>> = HashMap::new();
-        let mut index_order: Vec<String> = Vec::new(); // Preserve order of first occurrence
-        // Track which columns are already in each index from inline definitions to detect duplicates
-        // Only track inline definitions, not existing table-level indexes (they can be extended)
-        let mut inline_index_column_tracker: HashMap<String, HashSet<String>> = HashMap::new();
-
-        for col in &self.columns {
-            if let Some(ref index_val) = col.index {
-                match index_val {
-                    StrOrBoolOrArray::Str(name) => {
-                        // Named index - group by name
-                        let index_name = name.clone();
-
-                        // Check for duplicate - only check inline definitions, not existing table-level indexes
-                        if let Some(columns) = inline_index_column_tracker.get(name.as_str())
-                            && columns.contains(col.name.as_str())
-                        {
-                            return Err(TableValidationError::DuplicateIndexColumn {
-                                index_name: name.clone(),
-                                column_name: col.name.clone(),
-                            });
-                        }
-
-                        if !index_groups.contains_key(&index_name) {
-                            index_order.push(index_name.clone());
-                        }
-
-                        index_groups
-                            .entry(index_name.clone())
-                            .or_default()
-                            .push(col.name.clone());
-
-                        inline_index_column_tracker
-                            .entry(index_name)
-                            .or_default()
-                            .insert(col.name.clone());
-                    }
-                    StrOrBoolOrArray::Bool(true) => {
-                        // Auto-generated index name
-                        let index_name = format!("idx_{}_{}", self.name, col.name);
-
-                        // Check for duplicate (auto-generated names are unique per column, so this shouldn't happen)
-                        // But we check anyway for consistency - only check inline definitions
-                        if let Some(columns) = inline_index_column_tracker.get(index_name.as_str())
-                            && columns.contains(col.name.as_str())
-                        {
-                            return Err(TableValidationError::DuplicateIndexColumn {
-                                index_name: index_name.clone(),
-                                column_name: col.name.clone(),
-                            });
-                        }
-
-                        if !index_groups.contains_key(&index_name) {
-                            index_order.push(index_name.clone());
-                        }
-
-                        index_groups
-                            .entry(index_name.clone())
-                            .or_default()
-                            .push(col.name.clone());
-
-                        inline_index_column_tracker
-                            .entry(index_name)
-                            .or_default()
-                            .insert(col.name.clone());
-                    }
-                    StrOrBoolOrArray::Bool(false) => continue,
-                    StrOrBoolOrArray::Array(names) => {
-                        // Array format: each element is an index name
-                        // This column will be part of all these named indexes
-                        // Check for duplicates within the array
-                        let mut seen_in_array = HashSet::new();
-                        for index_name in names {
-                            // Check for duplicate within the same array
-                            if seen_in_array.contains(index_name.as_str()) {
-                                return Err(TableValidationError::DuplicateIndexColumn {
-                                    index_name: index_name.clone(),
-                                    column_name: col.name.clone(),
-                                });
-                            }
-                            seen_in_array.insert(index_name.clone());
-
-                            // Check for duplicate across different inline definitions
-                            // Only check inline definitions, not existing table-level indexes
-                            if let Some(columns) =
-                                inline_index_column_tracker.get(index_name.as_str())
-                                && columns.contains(col.name.as_str())
-                            {
-                                return Err(TableValidationError::DuplicateIndexColumn {
-                                    index_name: index_name.clone(),
-                                    column_name: col.name.clone(),
-                                });
-                            }
-
-                            if !index_groups.contains_key(index_name.as_str()) {
-                                index_order.push(index_name.clone());
-                            }
-
-                            index_groups
-                                .entry(index_name.clone())
-                                .or_default()
-                                .push(col.name.clone());
-
-                            inline_index_column_tracker
-                                .entry(index_name.clone())
-                                .or_default()
-                                .insert(col.name.clone());
-                        }
-                    }
-                }
-            }
-        }
-
-        // Create indexes from grouped columns in order
-        for index_name in index_order {
-            let columns = index_groups.get(&index_name).unwrap().clone();
-
-            // Check if this index already exists (by name only, not by column match)
-            // Multiple indexes can have the same columns but different names
-            let exists = indexes.iter().any(|i| i.name == index_name);
-
-            if !exists {
-                indexes.push(IndexDef {
-                    name: index_name,
-                    columns,
-                    unique: false,
-                });
-            }
-        }
-
-        Ok(TableDef {
-            name: self.name.clone(),
-            columns: self.columns.clone(),
-            constraints,
-            indexes,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::schema::column::{ColumnType, SimpleColumnType};
-    use crate::schema::foreign_key::{ForeignKeyDef, ForeignKeySyntax};
-    use crate::schema::primary_key::PrimaryKeySyntax;
-    use crate::schema::reference::ReferenceAction;
-    use crate::schema::str_or_bool::StrOrBoolOrArray;
-
-    fn col(name: &str, ty: ColumnType) -> ColumnDef {
-        ColumnDef {
-            name: name.to_string(),
-            r#type: ty,
-            nullable: true,
-            default: None,
-            comment: None,
-            primary_key: None,
-            unique: None,
-            index: None,
-            foreign_key: None,
-        }
-    }
-
-    #[test]
-    fn normalize_inline_primary_key() {
-        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
-        id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                id_col,
-                col("name", ColumnType::Simple(SimpleColumnType::Text)),
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-        assert!(matches!(
-            &normalized.constraints[0],
-            TableConstraint::PrimaryKey { columns, .. } if columns == &["id".to_string()]
-        ));
-    }
-
-    #[test]
-    fn normalize_multiple_inline_primary_keys() {
-        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
-        id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
-
-        let mut tenant_col = col("tenant_id", ColumnType::Simple(SimpleColumnType::Integer));
-        tenant_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![id_col, tenant_col],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-        assert!(matches!(
-            &normalized.constraints[0],
-            TableConstraint::PrimaryKey { columns, .. } if columns == &["id".to_string(), "tenant_id".to_string()]
-        ));
-    }
-
-    #[test]
-    fn normalize_does_not_duplicate_existing_pk() {
-        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
-        id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![id_col],
-            constraints: vec![TableConstraint::PrimaryKey {
-                auto_increment: false,
-                columns: vec!["id".into()],
-            }],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-    }
-
-    #[test]
-    fn normalize_ignores_primary_key_false() {
-        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
-        id_col.primary_key = Some(PrimaryKeySyntax::Bool(false));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                id_col,
-                col("name", ColumnType::Simple(SimpleColumnType::Text)),
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // primary_key: false should be ignored, so no primary key constraint should be added
-        assert_eq!(normalized.constraints.len(), 0);
-    }
-
-    #[test]
-    fn normalize_inline_unique_bool() {
-        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
-        email_col.unique = Some(StrOrBoolOrArray::Bool(true));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                email_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-        assert!(matches!(
-            &normalized.constraints[0],
-            TableConstraint::Unique { name: None, columns } if columns == &["email".to_string()]
-        ));
-    }
-
-    #[test]
-    fn normalize_inline_unique_with_name() {
-        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
-        email_col.unique = Some(StrOrBoolOrArray::Str("uq_users_email".into()));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                email_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-        assert!(matches!(
-            &normalized.constraints[0],
-            TableConstraint::Unique { name: Some(n), columns }
-                if n == "uq_users_email" && columns == &["email".to_string()]
-        ));
-    }
-
-    #[test]
-    fn normalize_inline_index_bool() {
-        let mut name_col = col("name", ColumnType::Simple(SimpleColumnType::Text));
-        name_col.index = Some(StrOrBoolOrArray::Bool(true));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                name_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.indexes.len(), 1);
-        assert_eq!(normalized.indexes[0].name, "idx_users_name");
-        assert_eq!(normalized.indexes[0].columns, vec!["name".to_string()]);
-        assert!(!normalized.indexes[0].unique);
-    }
-
-    #[test]
-    fn normalize_inline_index_with_name() {
-        let mut name_col = col("name", ColumnType::Simple(SimpleColumnType::Text));
-        name_col.index = Some(StrOrBoolOrArray::Str("custom_idx_name".into()));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                name_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.indexes.len(), 1);
-        assert_eq!(normalized.indexes[0].name, "custom_idx_name");
-    }
-
-    #[test]
-    fn normalize_inline_foreign_key() {
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
-            ref_table: "users".into(),
-            ref_columns: vec!["id".into()],
-            on_delete: Some(ReferenceAction::Cascade),
-            on_update: None,
-        }));
-
-        let table = TableDef {
-            name: "posts".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                user_id_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-        assert!(matches!(
-            &normalized.constraints[0],
-            TableConstraint::ForeignKey {
-                name: None,
-                columns,
-                ref_table,
-                ref_columns,
-                on_delete: Some(ReferenceAction::Cascade),
-                on_update: None,
-            } if columns == &["user_id".to_string()]
-                && ref_table == "users"
-                && ref_columns == &["id".to_string()]
-        ));
-    }
-
-    #[test]
-    fn normalize_all_inline_constraints() {
-        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
-        id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
-
-        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
-        email_col.unique = Some(StrOrBoolOrArray::Bool(true));
-
-        let mut name_col = col("name", ColumnType::Simple(SimpleColumnType::Text));
-        name_col.index = Some(StrOrBoolOrArray::Bool(true));
-
-        let mut user_id_col = col("org_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
-            ref_table: "orgs".into(),
-            ref_columns: vec!["id".into()],
-            on_delete: None,
-            on_update: None,
-        }));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![id_col, email_col, name_col, user_id_col],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // Should have: PrimaryKey, Unique, ForeignKey
-        assert_eq!(normalized.constraints.len(), 3);
-        // Should have: 1 index
-        assert_eq!(normalized.indexes.len(), 1);
-    }
-
-    #[test]
-    fn normalize_composite_index_from_string_name() {
-        let mut updated_at_col = col(
-            "updated_at",
-            ColumnType::Simple(SimpleColumnType::Timestamp),
-        );
-        updated_at_col.index = Some(StrOrBoolOrArray::Str("tuple".into()));
-
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.index = Some(StrOrBoolOrArray::Str("tuple".into()));
-
-        let table = TableDef {
-            name: "post".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                updated_at_col,
-                user_id_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.indexes.len(), 1);
-        assert_eq!(normalized.indexes[0].name, "tuple");
-        assert_eq!(
-            normalized.indexes[0].columns,
-            vec!["updated_at".to_string(), "user_id".to_string()]
-        );
-        assert!(!normalized.indexes[0].unique);
-    }
-
-    #[test]
-    fn normalize_multiple_different_indexes() {
-        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
-        col1.index = Some(StrOrBoolOrArray::Str("idx_a".into()));
-
-        let mut col2 = col("col2", ColumnType::Simple(SimpleColumnType::Text));
-        col2.index = Some(StrOrBoolOrArray::Str("idx_a".into()));
-
-        let mut col3 = col("col3", ColumnType::Simple(SimpleColumnType::Text));
-        col3.index = Some(StrOrBoolOrArray::Str("idx_b".into()));
-
-        let mut col4 = col("col4", ColumnType::Simple(SimpleColumnType::Text));
-        col4.index = Some(StrOrBoolOrArray::Bool(true));
-
-        let table = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1,
-                col2,
-                col3,
-                col4,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.indexes.len(), 3);
-
-        // Check idx_a composite index
-        let idx_a = normalized
-            .indexes
-            .iter()
-            .find(|i| i.name == "idx_a")
-            .unwrap();
-        assert_eq!(idx_a.columns, vec!["col1".to_string(), "col2".to_string()]);
-
-        // Check idx_b single column index
-        let idx_b = normalized
-            .indexes
-            .iter()
-            .find(|i| i.name == "idx_b")
-            .unwrap();
-        assert_eq!(idx_b.columns, vec!["col3".to_string()]);
-
-        // Check auto-generated index for col4
-        let idx_col4 = normalized
-            .indexes
-            .iter()
-            .find(|i| i.name == "idx_test_col4")
-            .unwrap();
-        assert_eq!(idx_col4.columns, vec!["col4".to_string()]);
-    }
-
-    #[test]
-    fn normalize_false_values_are_ignored() {
-        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
-        email_col.unique = Some(StrOrBoolOrArray::Bool(false));
-        email_col.index = Some(StrOrBoolOrArray::Bool(false));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                email_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 0);
-        assert_eq!(normalized.indexes.len(), 0);
-    }
-
-    #[test]
-    fn normalize_table_without_primary_key() {
-        // Test normalize with a table that has no primary key columns
-        // This should cover lines 67-69, 72-73, and 93 (pk_columns.is_empty() branch)
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("name", ColumnType::Simple(SimpleColumnType::Text)),
-                col("email", ColumnType::Simple(SimpleColumnType::Text)),
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // Should not add any primary key constraint
-        assert_eq!(normalized.constraints.len(), 0);
-        assert_eq!(normalized.indexes.len(), 0);
-    }
-
-    #[test]
-    fn normalize_multiple_indexes_from_same_array() {
-        // Multiple columns with same array of index names should create multiple composite indexes
-        let mut updated_at_col = col(
-            "updated_at",
-            ColumnType::Simple(SimpleColumnType::Timestamp),
-        );
-        updated_at_col.index = Some(StrOrBoolOrArray::Array(vec![
-            "tuple".into(),
-            "tuple2".into(),
-        ]));
-
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.index = Some(StrOrBoolOrArray::Array(vec![
-            "tuple".into(),
-            "tuple2".into(),
-        ]));
-
-        let table = TableDef {
-            name: "post".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                updated_at_col,
-                user_id_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // Should have: tuple (composite: updated_at, user_id), tuple2 (composite: updated_at, user_id)
-        assert_eq!(normalized.indexes.len(), 2);
-
-        let tuple_idx = normalized
-            .indexes
-            .iter()
-            .find(|i| i.name == "tuple")
-            .unwrap();
-        let mut sorted_cols = tuple_idx.columns.clone();
-        sorted_cols.sort();
-        assert_eq!(
-            sorted_cols,
-            vec!["updated_at".to_string(), "user_id".to_string()]
-        );
-
-        let tuple2_idx = normalized
-            .indexes
-            .iter()
-            .find(|i| i.name == "tuple2")
-            .unwrap();
-        let mut sorted_cols2 = tuple2_idx.columns.clone();
-        sorted_cols2.sort();
-        assert_eq!(
-            sorted_cols2,
-            vec!["updated_at".to_string(), "user_id".to_string()]
-        );
-    }
-
-    #[test]
-    fn normalize_inline_unique_with_array_existing_constraint() {
-        // Test Array format where constraint already exists - should add column to existing
-        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
-        col1.unique = Some(StrOrBoolOrArray::Array(vec!["uq_group".into()]));
-
-        let mut col2 = col("col2", ColumnType::Simple(SimpleColumnType::Text));
-        col2.unique = Some(StrOrBoolOrArray::Array(vec!["uq_group".into()]));
-
-        let table = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1,
-                col2,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-        let unique_constraint = &normalized.constraints[0];
-        assert!(matches!(
-            unique_constraint,
-            TableConstraint::Unique { name: Some(n), columns: _ }
-                if n == "uq_group"
-        ));
-        if let TableConstraint::Unique { columns, .. } = unique_constraint {
-            let mut sorted_cols = columns.clone();
-            sorted_cols.sort();
-            assert_eq!(sorted_cols, vec!["col1".to_string(), "col2".to_string()]);
-        }
-    }
-
-    #[test]
-    fn normalize_inline_unique_with_array_column_already_in_constraint() {
-        // Test Array format where column is already in constraint - should not duplicate
-        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
-        col1.unique = Some(StrOrBoolOrArray::Array(vec!["uq_group".into()]));
-
-        let table = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1.clone(),
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized1 = table.normalize().unwrap();
-        assert_eq!(normalized1.constraints.len(), 1);
-
-        // Add same column again - should not create duplicate
-        let table2 = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1,
-            ],
-            constraints: normalized1.constraints.clone(),
-            indexes: vec![],
-        };
-
-        let normalized2 = table2.normalize().unwrap();
-        assert_eq!(normalized2.constraints.len(), 1);
-        if let TableConstraint::Unique { columns, .. } = &normalized2.constraints[0] {
-            assert_eq!(columns.len(), 1);
-            assert_eq!(columns[0], "col1");
-        }
-    }
-
-    #[test]
-    fn normalize_inline_unique_str_already_exists() {
-        // Test that existing unique constraint with same name and column is not duplicated
-        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
-        email_col.unique = Some(StrOrBoolOrArray::Str("uq_email".into()));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                email_col,
-            ],
-            constraints: vec![TableConstraint::Unique {
-                name: Some("uq_email".into()),
-                columns: vec!["email".into()],
-            }],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // Should not duplicate the constraint
-        let unique_constraints: Vec<_> = normalized
-            .constraints
-            .iter()
-            .filter(|c| matches!(c, TableConstraint::Unique { .. }))
-            .collect();
-        assert_eq!(unique_constraints.len(), 1);
-    }
-
-    #[test]
-    fn normalize_inline_unique_bool_already_exists() {
-        // Test that existing unnamed unique constraint with same column is not duplicated
-        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
-        email_col.unique = Some(StrOrBoolOrArray::Bool(true));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                email_col,
-            ],
-            constraints: vec![TableConstraint::Unique {
-                name: None,
-                columns: vec!["email".into()],
-            }],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // Should not duplicate the constraint
-        let unique_constraints: Vec<_> = normalized
-            .constraints
-            .iter()
-            .filter(|c| matches!(c, TableConstraint::Unique { .. }))
-            .collect();
-        assert_eq!(unique_constraints.len(), 1);
-    }
-
-    #[test]
-    fn normalize_inline_foreign_key_already_exists() {
-        // Test that existing foreign key constraint is not duplicated
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
-            ref_table: "users".into(),
-            ref_columns: vec!["id".into()],
-            on_delete: None,
-            on_update: None,
-        }));
-
-        let table = TableDef {
-            name: "posts".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                user_id_col,
-            ],
-            constraints: vec![TableConstraint::ForeignKey {
-                name: None,
-                columns: vec!["user_id".into()],
-                ref_table: "users".into(),
-                ref_columns: vec!["id".into()],
-                on_delete: None,
-                on_update: None,
-            }],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // Should not duplicate the foreign key
-        let fk_constraints: Vec<_> = normalized
-            .constraints
-            .iter()
-            .filter(|c| matches!(c, TableConstraint::ForeignKey { .. }))
-            .collect();
-        assert_eq!(fk_constraints.len(), 1);
-    }
-
-    #[test]
-    fn normalize_duplicate_index_same_column_str() {
-        // Same index name applied to the same column multiple times should error
-        // This tests inline index duplicate, not table-level index
-        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
-        col1.index = Some(StrOrBoolOrArray::Str("idx1".into()));
-
-        let table = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1.clone(),
-                {
-                    // Same column with same index name again
-                    let mut c = col1.clone();
-                    c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
-                    c
-                },
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let result = table.normalize();
-        assert!(result.is_err());
-        if let Err(TableValidationError::DuplicateIndexColumn {
-            index_name,
-            column_name,
-        }) = result
-        {
-            assert_eq!(index_name, "idx1");
-            assert_eq!(column_name, "col1");
-        } else {
-            panic!("Expected DuplicateIndexColumn error");
-        }
-    }
-
-    #[test]
-    fn normalize_duplicate_index_same_column_array() {
-        // Same index name in array applied to the same column should error
-        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
-        col1.index = Some(StrOrBoolOrArray::Array(vec!["idx1".into(), "idx1".into()]));
-
-        let table = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let result = table.normalize();
-        assert!(result.is_err());
-        if let Err(TableValidationError::DuplicateIndexColumn {
-            index_name,
-            column_name,
-        }) = result
-        {
-            assert_eq!(index_name, "idx1");
-            assert_eq!(column_name, "col1");
-        } else {
-            panic!("Expected DuplicateIndexColumn error");
-        }
-    }
-
-    #[test]
-    fn normalize_duplicate_index_same_column_multiple_definitions() {
-        // Same index name applied to the same column in different ways should error
-        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
-        col1.index = Some(StrOrBoolOrArray::Str("idx1".into()));
-
-        let table = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1.clone(),
-                {
-                    let mut c = col1.clone();
-                    c.index = Some(StrOrBoolOrArray::Array(vec!["idx1".into()]));
-                    c
-                },
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let result = table.normalize();
-        assert!(result.is_err());
-        if let Err(TableValidationError::DuplicateIndexColumn {
-            index_name,
-            column_name,
-        }) = result
-        {
-            assert_eq!(index_name, "idx1");
-            assert_eq!(column_name, "col1");
-        } else {
-            panic!("Expected DuplicateIndexColumn error");
-        }
-    }
-
-    #[test]
-    fn test_table_validation_error_display() {
-        let error = TableValidationError::DuplicateIndexColumn {
-            index_name: "idx_test".into(),
-            column_name: "col1".into(),
-        };
-        let error_msg = format!("{}", error);
-        assert!(error_msg.contains("idx_test"));
-        assert!(error_msg.contains("col1"));
-        assert!(error_msg.contains("Duplicate index"));
-    }
-
-    #[test]
-    fn normalize_inline_unique_str_with_different_constraint_type() {
-        // Test that other constraint types don't match in the exists check
-        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
-        email_col.unique = Some(StrOrBoolOrArray::Str("uq_email".into()));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                email_col,
-            ],
-            constraints: vec![
-                // Add a PrimaryKey constraint (different type) - should not match
-                TableConstraint::PrimaryKey {
-                    auto_increment: false,
-                    columns: vec!["id".into()],
-                },
-            ],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // Should have: PrimaryKey (existing) + Unique (new)
-        assert_eq!(normalized.constraints.len(), 2);
-    }
-
-    #[test]
-    fn normalize_inline_unique_array_with_different_constraint_type() {
-        // Test that other constraint types don't match in the exists check for Array case
-        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
-        col1.unique = Some(StrOrBoolOrArray::Array(vec!["uq_group".into()]));
-
-        let table = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1,
-            ],
-            constraints: vec![
-                // Add a PrimaryKey constraint (different type) - should not match
-                TableConstraint::PrimaryKey {
-                    auto_increment: false,
-                    columns: vec!["id".into()],
-                },
-            ],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        // Should have: PrimaryKey (existing) + Unique (new)
-        assert_eq!(normalized.constraints.len(), 2);
-    }
-
-    #[test]
-    fn normalize_duplicate_index_bool_true_same_column() {
-        // Test that Bool(true) with duplicate on same column errors
-        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
-        col1.index = Some(StrOrBoolOrArray::Bool(true));
-
-        let table = TableDef {
-            name: "test".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col1.clone(),
-                {
-                    // Same column with Bool(true) again
-                    let mut c = col1.clone();
-                    c.index = Some(StrOrBoolOrArray::Bool(true));
-                    c
-                },
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let result = table.normalize();
-        assert!(result.is_err());
-        if let Err(TableValidationError::DuplicateIndexColumn {
-            index_name,
-            column_name,
-        }) = result
-        {
-            assert!(index_name.contains("idx_test"));
-            assert!(index_name.contains("col1"));
-            assert_eq!(column_name, "col1");
-        } else {
-            panic!("Expected DuplicateIndexColumn error");
-        }
-    }
-
-    #[test]
-    fn normalize_inline_foreign_key_string_syntax() {
-        // Test ForeignKeySyntax::String with valid "table.column" format
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.foreign_key = Some(ForeignKeySyntax::String("users.id".into()));
-
-        let table = TableDef {
-            name: "posts".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                user_id_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-        assert!(matches!(
-            &normalized.constraints[0],
-            TableConstraint::ForeignKey {
-                name: None,
-                columns,
-                ref_table,
-                ref_columns,
-                on_delete: None,
-                on_update: None,
-            } if columns == &["user_id".to_string()]
-                && ref_table == "users"
-                && ref_columns == &["id".to_string()]
-        ));
-    }
-
-    #[test]
-    fn normalize_inline_foreign_key_invalid_format_no_dot() {
-        // Test ForeignKeySyntax::String with invalid format (no dot)
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.foreign_key = Some(ForeignKeySyntax::String("usersid".into()));
-
-        let table = TableDef {
-            name: "posts".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                user_id_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let result = table.normalize();
-        assert!(result.is_err());
-        if let Err(TableValidationError::InvalidForeignKeyFormat { column_name, value }) = result {
-            assert_eq!(column_name, "user_id");
-            assert_eq!(value, "usersid");
-        } else {
-            panic!("Expected InvalidForeignKeyFormat error");
-        }
-    }
-
-    #[test]
-    fn normalize_inline_foreign_key_invalid_format_empty_table() {
-        // Test ForeignKeySyntax::String with empty table part
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.foreign_key = Some(ForeignKeySyntax::String(".id".into()));
-
-        let table = TableDef {
-            name: "posts".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                user_id_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let result = table.normalize();
-        assert!(result.is_err());
-        if let Err(TableValidationError::InvalidForeignKeyFormat { column_name, value }) = result {
-            assert_eq!(column_name, "user_id");
-            assert_eq!(value, ".id");
-        } else {
-            panic!("Expected InvalidForeignKeyFormat error");
-        }
-    }
-
-    #[test]
-    fn normalize_inline_foreign_key_invalid_format_empty_column() {
-        // Test ForeignKeySyntax::String with empty column part
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.foreign_key = Some(ForeignKeySyntax::String("users.".into()));
-
-        let table = TableDef {
-            name: "posts".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                user_id_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let result = table.normalize();
-        assert!(result.is_err());
-        if let Err(TableValidationError::InvalidForeignKeyFormat { column_name, value }) = result {
-            assert_eq!(column_name, "user_id");
-            assert_eq!(value, "users.");
-        } else {
-            panic!("Expected InvalidForeignKeyFormat error");
-        }
-    }
-
-    #[test]
-    fn normalize_inline_foreign_key_invalid_format_too_many_parts() {
-        // Test ForeignKeySyntax::String with too many parts
-        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
-        user_id_col.foreign_key = Some(ForeignKeySyntax::String("schema.users.id".into()));
-
-        let table = TableDef {
-            name: "posts".into(),
-            columns: vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                user_id_col,
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let result = table.normalize();
-        assert!(result.is_err());
-        if let Err(TableValidationError::InvalidForeignKeyFormat { column_name, value }) = result {
-            assert_eq!(column_name, "user_id");
-            assert_eq!(value, "schema.users.id");
-        } else {
-            panic!("Expected InvalidForeignKeyFormat error");
-        }
-    }
-
-    #[test]
-    fn normalize_inline_primary_key_with_auto_increment() {
-        use crate::schema::primary_key::PrimaryKeyDef;
-
-        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
-        id_col.primary_key = Some(PrimaryKeySyntax::Object(PrimaryKeyDef {
-            auto_increment: true,
-            columns: vec![], // columns is ignored for inline definition
-        }));
-
-        let table = TableDef {
-            name: "users".into(),
-            columns: vec![
-                id_col,
-                col("name", ColumnType::Simple(SimpleColumnType::Text)),
-            ],
-            constraints: vec![],
-            indexes: vec![],
-        };
-
-        let normalized = table.normalize().unwrap();
-        assert_eq!(normalized.constraints.len(), 1);
-        assert!(matches!(
-            &normalized.constraints[0],
-            TableConstraint::PrimaryKey { auto_increment: true, columns } if columns == &["id".to_string()]
-        ));
-    }
-
-    #[test]
-    fn test_invalid_foreign_key_format_error_display() {
-        let error = TableValidationError::InvalidForeignKeyFormat {
-            column_name: "user_id".into(),
-            value: "invalid".into(),
-        };
-        let error_msg = format!("{}", error);
-        assert!(error_msg.contains("user_id"));
-        assert!(error_msg.contains("invalid"));
-        assert!(error_msg.contains("table.column"));
-    }
-}
+use schemars::JsonSchema;
+
+use serde::{Deserialize, Serialize};
+use std::collections::{HashMap, HashSet};
+
+use crate::schema::{
+    StrOrBoolOrArray, column::ColumnDef, constraint::TableConstraint,
+    foreign_key::ForeignKeySyntax, index::IndexDef, names::TableName,
+    primary_key::PrimaryKeySyntax,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TableValidationError {
+    DuplicateIndexColumn {
+        index_name: String,
+        column_name: String,
+    },
+    InvalidForeignKeyFormat {
+        column_name: String,
+        value: String,
+    },
+}
+
+impl std::fmt::Display for TableValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TableValidationError::DuplicateIndexColumn {
+                index_name,
+                column_name,
+            } => {
+                write!(
+                    f,
+                    "Duplicate index '{}' on column '{}': the same index name cannot be applied to the same column multiple times",
+                    index_name, column_name
+                )
+            }
+            TableValidationError::InvalidForeignKeyFormat { column_name, value } => {
+                write!(
+                    f,
+                    "Invalid foreign key format '{}' on column '{}': expected 'table.column' format",
+                    value, column_name
+                )
+            }
+        }
+    }
+}
+
+impl std::error::Error for TableValidationError {}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct TableDef {
+    pub name: TableName,
+    pub columns: Vec<ColumnDef>,
+    pub constraints: Vec<TableConstraint>,
+    pub indexes: Vec<IndexDef>,
+}
+
+impl TableDef {
+    /// Normalizes inline column constraints (primary_key, unique, index, foreign_key)
+    /// into table-level constraints and indexes.
+    /// Returns a new TableDef with all inline constraints converted to table-level.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the same index name is applied to the same column multiple times.
+    pub fn normalize(&self) -> Result<Self, TableValidationError> {
+        let mut constraints = self.constraints.clone();
+        let mut indexes = self.indexes.clone();
+
+        // Collect columns with inline primary_key and check for auto_increment
+        let mut pk_columns: Vec<String> = Vec::new();
+        let mut pk_auto_increment = false;
+
+        for col in &self.columns {
+            if let Some(ref pk) = col.primary_key {
+                match pk {
+                    PrimaryKeySyntax::Bool(true) => {
+                        pk_columns.push(col.name.clone());
+                    }
+                    PrimaryKeySyntax::Bool(false) => {}
+                    PrimaryKeySyntax::Object(pk_def) => {
+                        pk_columns.push(col.name.clone());
+                        if pk_def.auto_increment {
+                            pk_auto_increment = true;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Add primary key constraint if any columns have inline pk and no existing pk constraint.
+        if !pk_columns.is_empty() {
+            let has_pk_constraint = constraints
+                .iter()
+                .any(|c| matches!(c, TableConstraint::PrimaryKey { .. }));
+
+            if !has_pk_constraint {
+                constraints.push(TableConstraint::PrimaryKey {
+                    auto_increment: pk_auto_increment,
+                    columns: pk_columns,
+                });
+            }
+        }
+
+        // Process inline unique and index for each column
+        for col in &self.columns {
+            // Handle inline unique
+            if let Some(ref unique_val) = col.unique {
+                match unique_val {
+                    StrOrBoolOrArray::Str(name) => {
+                        let constraint_name = Some(name.clone());
+
+                        // Check if this unique constraint already exists
+                        let exists = constraints.iter().any(|c| {
+                            if let TableConstraint::Unique {
+                                name: c_name,
+                                columns,
+                            } = c
+                            {
+                                c_name.as_ref() == Some(name)
+                                    && columns.len() == 1
+                                    && columns[0] == col.name
+                            } else {
+                                false
+                            }
+                        });
+
+                        if !exists {
+                            constraints.push(TableConstraint::Unique {
+                                name: constraint_name,
+                                columns: vec![col.name.clone()],
+                            });
+                        }
+                    }
+                    StrOrBoolOrArray::Bool(true) => {
+                        let exists = constraints.iter().any(|c| {
+                            if let TableConstraint::Unique {
+                                name: None,
+                                columns,
+                            } = c
+                            {
+                                columns.len() == 1 && columns[0] == col.name
+                            } else {
+                                false
+                            }
+                        });
+
+                        if !exists {
+                            constraints.push(TableConstraint::Unique {
+                                name: None,
+                                columns: vec![col.name.clone()],
+                            });
+                        }
+                    }
+                    StrOrBoolOrArray::Bool(false) => continue,
+                    StrOrBoolOrArray::Array(names) => {
+                        // Array format: each element is a constraint name
+                        // This column will be part of all these named constraints
+                        for constraint_name in names {
+                            // Check if constraint with this name already exists
+                            if let Some(existing) = constraints.iter_mut().find(|c| {
+                                if let TableConstraint::Unique { name: Some(n), .. } = c {
+                                    n == constraint_name
+                                } else {
+                                    false
+                                }
+                            }) {
+                                // Add this column to existing composite constraint
+                                if let TableConstraint::Unique { columns, .. } = existing
+                                    && !columns.contains(&col.name)
+                                {
+                                    columns.push(col.name.clone());
+                                }
+                            } else {
+                                // Create new constraint with this column
+                                constraints.push(TableConstraint::Unique {
+                                    name: Some(constraint_name.clone()),
+                                    columns: vec![col.name.clone()],
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Handle inline foreign_key
+            if let Some(ref fk_syntax) = col.foreign_key {
+                // Convert ForeignKeySyntax to ForeignKeyDef
+                let (ref_table, ref_columns, on_delete, on_update) = match fk_syntax {
+                    ForeignKeySyntax::String(s) => {
+                        // Parse "table.column" format
+                        let parts: Vec<&str> = s.split('.').collect();
+                        if parts.len() != 2 || parts[0].is_empty() || parts[1].is_empty() {
+                            return Err(TableValidationError::InvalidForeignKeyFormat {
+                                column_name: col.name.clone(),
+                                value: s.clone(),
+                            });
+                        }
+                        (parts[0].to_string(), vec![parts[1].to_string()], None, None)
+                    }
+                    ForeignKeySyntax::Object(fk_def) => (
+                        fk_def.ref_table.clone(),
+                        fk_def.ref_columns.clone(),
+                        fk_def.on_delete.clone(),
+                        fk_def.on_update.clone(),
+                    ),
+                };
+
+                // Check if this foreign key already exists
+                let exists = constraints.iter().any(|c| {
+                    if let TableConstraint::ForeignKey { columns, .. } = c {
+                        columns.len() == 1 && columns[0] == col.name
+                    } else {
+                        false
+                    }
+                });
+
+                if !exists {
+                    constraints.push(TableConstraint::ForeignKey {
+                        name: None,
+                        columns: vec![col.name.clone()],
+                        ref_table,
+                        ref_columns,
+                        on_delete,
+                        on_update,
+                    });
+                }
+            }
+        }
+
+        // Group columns by index name to create composite indexes
+        // Use a HashMap to group, but preserve column order by tracking first occurrence
+        let mut index_groups: HashMap<String, Vec<String>> = HashMap::new();
+        let mut index_order: Vec<String> = Vec::new(); // Preserve order of first occurrence
+        // Track which columns are already in each index from inline definitions to detect duplicates
+        // Only track inline definitions, not existing table-level indexes (they can be extended)
+        let mut inline_index_column_tracker: HashMap<String, HashSet<String>> = HashMap::new();
+
+        for col in &self.columns {
+            if let Some(ref index_val) = col.index {
+                match index_val {
+                    StrOrBoolOrArray::Str(name) => {
+                        // Named index - group by name
+                        let index_name = name.clone();
+
+                        // Check for duplicate - only check inline definitions, not existing table-level indexes
+                        if let Some(columns) = inline_index_column_tracker.get(name.as_str())
+                            && columns.contains(col.name.as_str())
+                        {
+                            return Err(TableValidationError::DuplicateIndexColumn {
+                                index_name: name.clone(),
+                                column_name: col.name.clone(),
+                            });
+                        }
+
+                        if !index_groups.contains_key(&index_name) {
+                            index_order.push(index_name.clone());
+                        }
+
+                        index_groups
+                            .entry(index_name.clone())
+                            .or_default()
+                            .push(col.name.clone());
+
+                        inline_index_column_tracker
+                            .entry(index_name)
+                            .or_default()
+                            .insert(col.name.clone());
+                    }
+                    StrOrBoolOrArray::Bool(true) => {
+                        // Auto-generated index name
+                        let index_name = format!("idx_{}_{}", self.name, col.name);
+
+                        // Check for duplicate (auto-generated names are unique per column, so this shouldn't happen)
+                        // But we check anyway for consistency - only check inline definitions
+                        if let Some(columns) = inline_index_column_tracker.get(index_name.as_str())
+                            && columns.contains(col.name.as_str())
+                        {
+                            return Err(TableValidationError::DuplicateIndexColumn {
+                                index_name: index_name.clone(),
+                                column_name: col.name.clone(),
+                            });
+                        }
+
+                        if !index_groups.contains_key(&index_name) {
+                            index_order.push(index_name.clone());
+                        }
+
+                        index_groups
+                            .entry(index_name.clone())
+                            .or_default()
+                            .push(col.name.clone());
+
+                        inline_index_column_tracker
+                            .entry(index_name)
+                            .or_default()
+                            .insert(col.name.clone());
+                    }
+                    StrOrBoolOrArray::Bool(false) => continue,
+                    StrOrBoolOrArray::Array(names) => {
+                        // Array format: each element is an index name
+                        // This column will be part of all these named indexes
+                        // Check for duplicates within the array
+                        let mut seen_in_array = HashSet::new();
+                        for index_name in names {
+                            // Check for duplicate within the same array
+                            if seen_in_array.contains(index_name.as_str()) {
+                                return Err(TableValidationError::DuplicateIndexColumn {
+                                    index_name: index_name.clone(),
+                                    column_name: col.name.clone(),
+                                });
+                            }
+                            seen_in_array.insert(index_name.clone());
+
+                            // Check for duplicate across different inline definitions
+                            // Only check inline definitions, not existing table-level indexes
+                            if let Some(columns) =
+                                inline_index_column_tracker.get(index_name.as_str())
+                                && columns.contains(col.name.as_str())
+                            {
+                                return Err(TableValidationError::DuplicateIndexColumn {
+                                    index_name: index_name.clone(),
+                                    column_name: col.name.clone(),
+                                });
+                            }
+
+                            if !index_groups.contains_key(index_name.as_str()) {
+                                index_order.push(index_name.clone());
+                            }
+
+                            index_groups
+                                .entry(index_name.clone())
+                                .or_default()
+                                .push(col.name.clone());
+
+                            inline_index_column_tracker
+                                .entry(index_name.clone())
+                                .or_default()
+                                .insert(col.name.clone());
+                        }
+                    }
+                }
+            }
+        }
+
+        // Create indexes from grouped columns in order
+        for index_name in index_order {
+            let columns = index_groups.get(&index_name).unwrap().clone();
+
+            // Check if this index already exists (by name only, not by column match)
+            // Multiple indexes can have the same columns but different names
+            let exists = indexes.iter().any(|i| i.name == index_name);
+
+            if !exists {
+                indexes.push(IndexDef {
+                    name: index_name,
+                    columns,
+                    unique: false,
+                });
+            }
+        }
+
+        Ok(TableDef {
+            name: self.name.clone(),
+            columns: self.columns.clone(),
+            constraints,
+            indexes,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::schema::column::{ColumnType, SimpleColumnType};
+    use crate::schema::foreign_key::{ForeignKeyDef, ForeignKeySyntax};
+    use crate::schema::primary_key::PrimaryKeySyntax;
+    use crate::schema::reference::ReferenceAction;
+    use crate::schema::str_or_bool::StrOrBoolOrArray;
+
+    fn col(name: &str, ty: ColumnType) -> ColumnDef {
+        ColumnDef {
+            name: name.to_string(),
+            r#type: ty,
+            nullable: true,
+            default: None,
+            comment: None,
+            primary_key: None,
+            unique: None,
+            index: None,
+            foreign_key: None,
+        }
+    }
+
+    #[test]
+    fn normalize_inline_primary_key() {
+        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+        id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                id_col,
+                col("name", ColumnType::Simple(SimpleColumnType::Text)),
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+        assert!(matches!(
+            &normalized.constraints[0],
+            TableConstraint::PrimaryKey { columns, .. } if columns == &["id".to_string()]
+        ));
+    }
+
+    #[test]
+    fn normalize_multiple_inline_primary_keys() {
+        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+        id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
+
+        let mut tenant_col = col("tenant_id", ColumnType::Simple(SimpleColumnType::Integer));
+        tenant_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![id_col, tenant_col],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+        assert!(matches!(
+            &normalized.constraints[0],
+            TableConstraint::PrimaryKey { columns, .. } if columns == &["id".to_string(), "tenant_id".to_string()]
+        ));
+    }
+
+    #[test]
+    fn normalize_does_not_duplicate_existing_pk() {
+        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+        id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![id_col],
+            constraints: vec![TableConstraint::PrimaryKey {
+                auto_increment: false,
+                columns: vec!["id".into()],
+            }],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+    }
+
+    #[test]
+    fn normalize_ignores_primary_key_false() {
+        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+        id_col.primary_key = Some(PrimaryKeySyntax::Bool(false));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                id_col,
+                col("name", ColumnType::Simple(SimpleColumnType::Text)),
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // primary_key: false should be ignored, so no primary key constraint should be added
+        assert_eq!(normalized.constraints.len(), 0);
+    }
+
+    #[test]
+    fn normalize_inline_unique_bool() {
+        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        email_col.unique = Some(StrOrBoolOrArray::Bool(true));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                email_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+        assert!(matches!(
+            &normalized.constraints[0],
+            TableConstraint::Unique { name: None, columns } if columns == &["email".to_string()]
+        ));
+    }
+
+    #[test]
+    fn normalize_inline_unique_with_name() {
+        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        email_col.unique = Some(StrOrBoolOrArray::Str("uq_users_email".into()));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                email_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+        assert!(matches!(
+            &normalized.constraints[0],
+            TableConstraint::Unique { name: Some(n), columns }
+                if n == "uq_users_email" && columns == &["email".to_string()]
+        ));
+    }
+
+    #[test]
+    fn normalize_inline_index_bool() {
+        let mut name_col = col("name", ColumnType::Simple(SimpleColumnType::Text));
+        name_col.index = Some(StrOrBoolOrArray::Bool(true));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                name_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.indexes.len(), 1);
+        assert_eq!(normalized.indexes[0].name, "idx_users_name");
+        assert_eq!(normalized.indexes[0].columns, vec!["name".to_string()]);
+        assert!(!normalized.indexes[0].unique);
+    }
+
+    #[test]
+    fn normalize_inline_index_with_name() {
+        let mut name_col = col("name", ColumnType::Simple(SimpleColumnType::Text));
+        name_col.index = Some(StrOrBoolOrArray::Str("custom_idx_name".into()));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                name_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.indexes.len(), 1);
+        assert_eq!(normalized.indexes[0].name, "custom_idx_name");
+    }
+
+    #[test]
+    fn normalize_inline_foreign_key() {
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
+            ref_table: "users".into(),
+            ref_columns: vec!["id".into()],
+            on_delete: Some(ReferenceAction::Cascade),
+            on_update: None,
+        }));
+
+        let table = TableDef {
+            name: "posts".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                user_id_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+        assert!(matches!(
+            &normalized.constraints[0],
+            TableConstraint::ForeignKey {
+                name: None,
+                columns,
+                ref_table,
+                ref_columns,
+                on_delete: Some(ReferenceAction::Cascade),
+                on_update: None,
+            } if columns == &["user_id".to_string()]
+                && ref_table == "users"
+                && ref_columns == &["id".to_string()]
+        ));
+    }
+
+    #[test]
+    fn normalize_all_inline_constraints() {
+        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+        id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
+
+        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        email_col.unique = Some(StrOrBoolOrArray::Bool(true));
+
+        let mut name_col = col("name", ColumnType::Simple(SimpleColumnType::Text));
+        name_col.index = Some(StrOrBoolOrArray::Bool(true));
+
+        let mut user_id_col = col("org_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
+            ref_table: "orgs".into(),
+            ref_columns: vec!["id".into()],
+            on_delete: None,
+            on_update: None,
+        }));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![id_col, email_col, name_col, user_id_col],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // Should have: PrimaryKey, Unique, ForeignKey
+        assert_eq!(normalized.constraints.len(), 3);
+        // Should have: 1 index
+        assert_eq!(normalized.indexes.len(), 1);
+    }
+
+    #[test]
+    fn normalize_composite_index_from_string_name() {
+        let mut updated_at_col = col(
+            "updated_at",
+            ColumnType::Simple(SimpleColumnType::Timestamp),
+        );
+        updated_at_col.index = Some(StrOrBoolOrArray::Str("tuple".into()));
+
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.index = Some(StrOrBoolOrArray::Str("tuple".into()));
+
+        let table = TableDef {
+            name: "post".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                updated_at_col,
+                user_id_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.indexes.len(), 1);
+        assert_eq!(normalized.indexes[0].name, "tuple");
+        assert_eq!(
+            normalized.indexes[0].columns,
+            vec!["updated_at".to_string(), "user_id".to_string()]
+        );
+        assert!(!normalized.indexes[0].unique);
+    }
+
+    #[test]
+    fn normalize_multiple_different_indexes() {
+        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
+        col1.index = Some(StrOrBoolOrArray::Str("idx_a".into()));
+
+        let mut col2 = col("col2", ColumnType::Simple(SimpleColumnType::Text));
+        col2.index = Some(StrOrBoolOrArray::Str("idx_a".into()));
+
+        let mut col3 = col("col3", ColumnType::Simple(SimpleColumnType::Text));
+        col3.index = Some(StrOrBoolOrArray::Str("idx_b".into()));
+
+        let mut col4 = col("col4", ColumnType::Simple(SimpleColumnType::Text));
+        col4.index = Some(StrOrBoolOrArray::Bool(true));
+
+        let table = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1,
+                col2,
+                col3,
+                col4,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.indexes.len(), 3);
+
+        // Check idx_a composite index
+        let idx_a = normalized
+            .indexes
+            .iter()
+            .find(|i| i.name == "idx_a")
+            .unwrap();
+        assert_eq!(idx_a.columns, vec!["col1".to_string(), "col2".to_string()]);
+
+        // Check idx_b single column index
+        let idx_b = normalized
+            .indexes
+            .iter()
+            .find(|i| i.name == "idx_b")
+            .unwrap();
+        assert_eq!(idx_b.columns, vec!["col3".to_string()]);
+
+        // Check auto-generated index for col4
+        let idx_col4 = normalized
+            .indexes
+            .iter()
+            .find(|i| i.name == "idx_test_col4")
+            .unwrap();
+        assert_eq!(idx_col4.columns, vec!["col4".to_string()]);
+    }
+
+    #[test]
+    fn normalize_false_values_are_ignored() {
+        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        email_col.unique = Some(StrOrBoolOrArray::Bool(false));
+        email_col.index = Some(StrOrBoolOrArray::Bool(false));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                email_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 0);
+        assert_eq!(normalized.indexes.len(), 0);
+    }
+
+    #[test]
+    fn normalize_table_without_primary_key() {
+        // Test normalize with a table that has no primary key columns
+        // This should cover lines 67-69, 72-73, and 93 (pk_columns.is_empty() branch)
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("name", ColumnType::Simple(SimpleColumnType::Text)),
+                col("email", ColumnType::Simple(SimpleColumnType::Text)),
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // Should not add any primary key constraint
+        assert_eq!(normalized.constraints.len(), 0);
+        assert_eq!(normalized.indexes.len(), 0);
+    }
+
+    #[test]
+    fn normalize_multiple_indexes_from_same_array() {
+        // Multiple columns with same array of index names should create multiple composite indexes
+        let mut updated_at_col = col(
+            "updated_at",
+            ColumnType::Simple(SimpleColumnType::Timestamp),
+        );
+        updated_at_col.index = Some(StrOrBoolOrArray::Array(vec![
+            "tuple".into(),
+            "tuple2".into(),
+        ]));
+
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.index = Some(StrOrBoolOrArray::Array(vec![
+            "tuple".into(),
+            "tuple2".into(),
+        ]));
+
+        let table = TableDef {
+            name: "post".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                updated_at_col,
+                user_id_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // Should have: tuple (composite: updated_at, user_id), tuple2 (composite: updated_at, user_id)
+        assert_eq!(normalized.indexes.len(), 2);
+
+        let tuple_idx = normalized
+            .indexes
+            .iter()
+            .find(|i| i.name == "tuple")
+            .unwrap();
+        let mut sorted_cols = tuple_idx.columns.clone();
+        sorted_cols.sort();
+        assert_eq!(
+            sorted_cols,
+            vec!["updated_at".to_string(), "user_id".to_string()]
+        );
+
+        let tuple2_idx = normalized
+            .indexes
+            .iter()
+            .find(|i| i.name == "tuple2")
+            .unwrap();
+        let mut sorted_cols2 = tuple2_idx.columns.clone();
+        sorted_cols2.sort();
+        assert_eq!(
+            sorted_cols2,
+            vec!["updated_at".to_string(), "user_id".to_string()]
+        );
+    }
+
+    #[test]
+    fn normalize_inline_unique_with_array_existing_constraint() {
+        // Test Array format where constraint already exists - should add column to existing
+        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
+        col1.unique = Some(StrOrBoolOrArray::Array(vec!["uq_group".into()]));
+
+        let mut col2 = col("col2", ColumnType::Simple(SimpleColumnType::Text));
+        col2.unique = Some(StrOrBoolOrArray::Array(vec!["uq_group".into()]));
+
+        let table = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1,
+                col2,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+        let unique_constraint = &normalized.constraints[0];
+        assert!(matches!(
+            unique_constraint,
+            TableConstraint::Unique { name: Some(n), columns: _ }
+                if n == "uq_group"
+        ));
+        if let TableConstraint::Unique { columns, .. } = unique_constraint {
+            let mut sorted_cols = columns.clone();
+            sorted_cols.sort();
+            assert_eq!(sorted_cols, vec!["col1".to_string(), "col2".to_string()]);
+        }
+    }
+
+    #[test]
+    fn normalize_inline_unique_with_array_column_already_in_constraint() {
+        // Test Array format where column is already in constraint - should not duplicate
+        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
+        col1.unique = Some(StrOrBoolOrArray::Array(vec!["uq_group".into()]));
+
+        let table = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1.clone(),
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized1 = table.normalize().unwrap();
+        assert_eq!(normalized1.constraints.len(), 1);
+
+        // Add same column again - should not create duplicate
+        let table2 = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1,
+            ],
+            constraints: normalized1.constraints.clone(),
+            indexes: vec![],
+        };
+
+        let normalized2 = table2.normalize().unwrap();
+        assert_eq!(normalized2.constraints.len(), 1);
+        if let TableConstraint::Unique { columns, .. } = &normalized2.constraints[0] {
+            assert_eq!(columns.len(), 1);
+            assert_eq!(columns[0], "col1");
+        }
+    }
+
+    #[test]
+    fn normalize_inline_unique_str_already_exists() {
+        // Test that existing unique constraint with same name and column is not duplicated
+        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        email_col.unique = Some(StrOrBoolOrArray::Str("uq_email".into()));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                email_col,
+            ],
+            constraints: vec![TableConstraint::Unique {
+                name: Some("uq_email".into()),
+                columns: vec!["email".into()],
+            }],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // Should not duplicate the constraint
+        let unique_constraints: Vec<_> = normalized
+            .constraints
+            .iter()
+            .filter(|c| matches!(c, TableConstraint::Unique { .. }))
+            .collect();
+        assert_eq!(unique_constraints.len(), 1);
+    }
+
+    #[test]
+    fn normalize_inline_unique_bool_already_exists() {
+        // Test that existing unnamed unique constraint with same column is not duplicated
+        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        email_col.unique = Some(StrOrBoolOrArray::Bool(true));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                email_col,
+            ],
+            constraints: vec![TableConstraint::Unique {
+                name: None,
+                columns: vec!["email".into()],
+            }],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // Should not duplicate the constraint
+        let unique_constraints: Vec<_> = normalized
+            .constraints
+            .iter()
+            .filter(|c| matches!(c, TableConstraint::Unique { .. }))
+            .collect();
+        assert_eq!(unique_constraints.len(), 1);
+    }
+
+    #[test]
+    fn normalize_inline_foreign_key_already_exists() {
+        // Test that existing foreign key constraint is not duplicated
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
+            ref_table: "users".into(),
+            ref_columns: vec!["id".into()],
+            on_delete: None,
+            on_update: None,
+        }));
+
+        let table = TableDef {
+            name: "posts".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                user_id_col,
+            ],
+            constraints: vec![TableConstraint::ForeignKey {
+                name: None,
+                columns: vec!["user_id".into()],
+                ref_table: "users".into(),
+                ref_columns: vec!["id".into()],
+                on_delete: None,
+                on_update: None,
+            }],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // Should not duplicate the foreign key
+        let fk_constraints: Vec<_> = normalized
+            .constraints
+            .iter()
+            .filter(|c| matches!(c, TableConstraint::ForeignKey { .. }))
+            .collect();
+        assert_eq!(fk_constraints.len(), 1);
+    }
+
+    #[test]
+    fn normalize_duplicate_index_same_column_str() {
+        // Same index name applied to the same column multiple times should error
+        // This tests inline index duplicate, not table-level index
+        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
+        col1.index = Some(StrOrBoolOrArray::Str("idx1".into()));
+
+        let table = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1.clone(),
+                {
+                    // Same column with same index name again
+                    let mut c = col1.clone();
+                    c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
+                    c
+                },
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::DuplicateIndexColumn {
+            index_name,
+            column_name,
+        }) = result
+        {
+            assert_eq!(index_name, "idx1");
+            assert_eq!(column_name, "col1");
+        } else {
+            panic!("Expected DuplicateIndexColumn error");
+        }
+    }
+
+    #[test]
+    fn normalize_duplicate_index_same_column_array() {
+        // Same index name in array applied to the same column should error
+        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
+        col1.index = Some(StrOrBoolOrArray::Array(vec!["idx1".into(), "idx1".into()]));
+
+        let table = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::DuplicateIndexColumn {
+            index_name,
+            column_name,
+        }) = result
+        {
+            assert_eq!(index_name, "idx1");
+            assert_eq!(column_name, "col1");
+        } else {
+            panic!("Expected DuplicateIndexColumn error");
+        }
+    }
+
+    #[test]
+    fn normalize_duplicate_index_same_column_multiple_definitions() {
+        // Same index name applied to the same column in different ways should error
+        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
+        col1.index = Some(StrOrBoolOrArray::Str("idx1".into()));
+
+        let table = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1.clone(),
+                {
+                    let mut c = col1.clone();
+                    c.index = Some(StrOrBoolOrArray::Array(vec!["idx1".into()]));
+                    c
+                },
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::DuplicateIndexColumn {
+            index_name,
+            column_name,
+        }) = result
+        {
+            assert_eq!(index_name, "idx1");
+            assert_eq!(column_name, "col1");
+        } else {
+            panic!("Expected DuplicateIndexColumn error");
+        }
+    }
+
+    #[test]
+    fn test_table_validation_error_display() {
+        let error = TableValidationError::DuplicateIndexColumn {
+            index_name: "idx_test".into(),
+            column_name: "col1".into(),
+        };
+        let error_msg = format!("{}", error);
+        assert!(error_msg.contains("idx_test"));
+        assert!(error_msg.contains("col1"));
+        assert!(error_msg.contains("Duplicate index"));
+    }
+
+    #[test]
+    fn normalize_inline_unique_str_with_different_constraint_type() {
+        // Test that other constraint types don't match in the exists check
+        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        email_col.unique = Some(StrOrBoolOrArray::Str("uq_email".into()));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                email_col,
+            ],
+            constraints: vec![
+                // Add a PrimaryKey constraint (different type) - should not match
+                TableConstraint::PrimaryKey {
+                    auto_increment: false,
+                    columns: vec!["id".into()],
+                },
+            ],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // Should have: PrimaryKey (existing) + Unique (new)
+        assert_eq!(normalized.constraints.len(), 2);
+    }
+
+    #[test]
+    fn normalize_inline_unique_array_with_different_constraint_type() {
+        // Test that other constraint types don't match in the exists check for Array case
+        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
+        col1.unique = Some(StrOrBoolOrArray::Array(vec!["uq_group".into()]));
+
+        let table = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1,
+            ],
+            constraints: vec![
+                // Add a PrimaryKey constraint (different type) - should not match
+                TableConstraint::PrimaryKey {
+                    auto_increment: false,
+                    columns: vec!["id".into()],
+                },
+            ],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        // Should have: PrimaryKey (existing) + Unique (new)
+        assert_eq!(normalized.constraints.len(), 2);
+    }
+
+    #[test]
+    fn normalize_duplicate_index_bool_true_same_column() {
+        // Test that Bool(true) with duplicate on same column errors
+        let mut col1 = col("col1", ColumnType::Simple(SimpleColumnType::Text));
+        col1.index = Some(StrOrBoolOrArray::Bool(true));
+
+        let table = TableDef {
+            name: "test".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col1.clone(),
+                {
+                    // Same column with Bool(true) again
+                    let mut c = col1.clone();
+                    c.index = Some(StrOrBoolOrArray::Bool(true));
+                    c
+                },
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::DuplicateIndexColumn {
+            index_name,
+            column_name,
+        }) = result
+        {
+            assert!(index_name.contains("idx_test"));
+            assert!(index_name.contains("col1"));
+            assert_eq!(column_name, "col1");
+        } else {
+            panic!("Expected DuplicateIndexColumn error");
+        }
+    }
+
+    #[test]
+    fn normalize_inline_foreign_key_string_syntax() {
+        // Test ForeignKeySyntax::String with valid "table.column" format
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.foreign_key = Some(ForeignKeySyntax::String("users.id".into()));
+
+        let table = TableDef {
+            name: "posts".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                user_id_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+        assert!(matches!(
+            &normalized.constraints[0],
+            TableConstraint::ForeignKey {
+                name: None,
+                columns,
+                ref_table,
+                ref_columns,
+                on_delete: None,
+                on_update: None,
+            } if columns == &["user_id".to_string()]
+                && ref_table == "users"
+                && ref_columns == &["id".to_string()]
+        ));
+    }
+
+    #[test]
+    fn normalize_inline_foreign_key_invalid_format_no_dot() {
+        // Test ForeignKeySyntax::String with invalid format (no dot)
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.foreign_key = Some(ForeignKeySyntax::String("usersid".into()));
+
+        let table = TableDef {
+            name: "posts".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                user_id_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::InvalidForeignKeyFormat { column_name, value }) = result {
+            assert_eq!(column_name, "user_id");
+            assert_eq!(value, "usersid");
+        } else {
+            panic!("Expected InvalidForeignKeyFormat error");
+        }
+    }
+
+    #[test]
+    fn normalize_inline_foreign_key_invalid_format_empty_table() {
+        // Test ForeignKeySyntax::String with empty table part
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.foreign_key = Some(ForeignKeySyntax::String(".id".into()));
+
+        let table = TableDef {
+            name: "posts".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                user_id_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::InvalidForeignKeyFormat { column_name, value }) = result {
+            assert_eq!(column_name, "user_id");
+            assert_eq!(value, ".id");
+        } else {
+            panic!("Expected InvalidForeignKeyFormat error");
+        }
+    }
+
+    #[test]
+    fn normalize_inline_foreign_key_invalid_format_empty_column() {
+        // Test ForeignKeySyntax::String with empty column part
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.foreign_key = Some(ForeignKeySyntax::String("users.".into()));
+
+        let table = TableDef {
+            name: "posts".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                user_id_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::InvalidForeignKeyFormat { column_name, value }) = result {
+            assert_eq!(column_name, "user_id");
+            assert_eq!(value, "users.");
+        } else {
+            panic!("Expected InvalidForeignKeyFormat error");
+        }
+    }
+
+    #[test]
+    fn normalize_inline_foreign_key_invalid_format_too_many_parts() {
+        // Test ForeignKeySyntax::String with too many parts
+        let mut user_id_col = col("user_id", ColumnType::Simple(SimpleColumnType::Integer));
+        user_id_col.foreign_key = Some(ForeignKeySyntax::String("schema.users.id".into()));
+
+        let table = TableDef {
+            name: "posts".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                user_id_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::InvalidForeignKeyFormat { column_name, value }) = result {
+            assert_eq!(column_name, "user_id");
+            assert_eq!(value, "schema.users.id");
+        } else {
+            panic!("Expected InvalidForeignKeyFormat error");
+        }
+    }
+
+    #[test]
+    fn normalize_inline_primary_key_with_auto_increment() {
+        use crate::schema::primary_key::PrimaryKeyDef;
+
+        let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+        id_col.primary_key = Some(PrimaryKeySyntax::Object(PrimaryKeyDef {
+            auto_increment: true,
+            columns: vec![], // columns is ignored for inline definition
+        }));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                id_col,
+                col("name", ColumnType::Simple(SimpleColumnType::Text)),
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let normalized = table.normalize().unwrap();
+        assert_eq!(normalized.constraints.len(), 1);
+        assert!(matches!(
+            &normalized.constraints[0],
+            TableConstraint::PrimaryKey { auto_increment: true, columns } if columns == &["id".to_string()]
+        ));
+    }
+
+    #[test]
+    fn normalize_duplicate_inline_index_on_same_column() {
+        // This test triggers the DuplicateIndexColumn error (lines 251-253)
+        // by having the same column appear twice in the same named index group
+        use crate::schema::str_or_bool::StrOrBoolOrArray;
+
+        // Create a column that references the same index name twice (via Array)
+        let mut email_col = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        email_col.index = Some(StrOrBoolOrArray::Array(vec![
+            "idx_email".into(),
+            "idx_email".into(), // Duplicate reference
+        ]));
+
+        let table = TableDef {
+            name: "users".into(),
+            columns: vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                email_col,
+            ],
+            constraints: vec![],
+            indexes: vec![],
+        };
+
+        let result = table.normalize();
+        assert!(result.is_err());
+        if let Err(TableValidationError::DuplicateIndexColumn {
+            index_name,
+            column_name,
+        }) = result
+        {
+            assert_eq!(index_name, "idx_email");
+            assert_eq!(column_name, "email");
+        } else {
+            panic!("Expected DuplicateIndexColumn error, got: {:?}", result);
+        }
+    }
+
+    #[test]
+    fn test_invalid_foreign_key_format_error_display() {
+        let error = TableValidationError::InvalidForeignKeyFormat {
+            column_name: "user_id".into(),
+            value: "invalid".into(),
+        };
+        let error_msg = format!("{}", error);
+        assert!(error_msg.contains("user_id"));
+        assert!(error_msg.contains("invalid"));
+        assert!(error_msg.contains("table.column"));
+    }
+}
diff --git a/crates/vespertide-exporter/src/seaorm/mod.rs b/crates/vespertide-exporter/src/seaorm/mod.rs
index e95d9b1..7c84e16 100644
--- a/crates/vespertide-exporter/src/seaorm/mod.rs
+++ b/crates/vespertide-exporter/src/seaorm/mod.rs
@@ -1,7 +1,9 @@
 use std::collections::HashSet;
 
 use crate::orm::OrmExporter;
-use vespertide_core::{ColumnDef, IndexDef, TableConstraint, TableDef};
+use vespertide_core::{
+    ColumnDef, ColumnType, ComplexColumnType, IndexDef, TableConstraint, TableDef,
+};
 
 pub struct SeaOrmExporter;
 
@@ -24,6 +26,19 @@ pub fn render_entity(table: &TableDef) -> String {
     let mut lines: Vec<String> = Vec::new();
     lines.push("use sea_orm::entity::prelude::*;".into());
     lines.push(String::new());
+
+    // Generate Enum definitions first
+    let mut processed_enums = HashSet::new();
+    for column in &table.columns {
+        if let ColumnType::Complex(ComplexColumnType::Enum { name, values }) = &column.r#type {
+            // Avoid duplicate enum definitions if multiple columns use the same enum
+            if !processed_enums.contains(name) {
+                render_enum(&mut lines, name, values);
+                processed_enums.insert(name.clone());
+            }
+        }
+    }
+
     lines.push("#[sea_orm::model]".into());
     lines.push("#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]".into());
     lines.push(format!("#[sea_orm(table_name = \"{}\")]", table.name));
@@ -64,7 +79,19 @@ fn render_column(
     }
 
     let field_name = sanitize_field_name(&column.name);
-    let ty = column.r#type.to_rust_type(column.nullable);
+
+    let ty = match &column.r#type {
+        ColumnType::Complex(ComplexColumnType::Enum { name, .. }) => {
+            let enum_type = to_pascal_case(name);
+            if column.nullable {
+                format!("Option<{}>", enum_type)
+            } else {
+                enum_type
+            }
+        }
+        _ => column.r#type.to_rust_type(column.nullable),
+    };
+
     lines.push(format!("    pub {}: {},", field_name, ty));
 }
 
@@ -176,6 +203,64 @@ fn unique_name(base: &str, used: &mut HashSet<String>) -> String {
     name
 }
 
+fn render_enum(lines: &mut Vec<String>, name: &str, values: &[String]) {
+    let enum_name = to_pascal_case(name);
+
+    lines.push("#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]".into());
+    lines.push(format!(
+        "#[sea_orm(rs_type = \"String\", db_type = \"Enum\", enum_name = \"{}\")]",
+        name
+    ));
+    lines.push(format!("pub enum {} {{", enum_name));
+
+    for value in values {
+        let variant_name = enum_variant_name(value);
+        lines.push(format!("    #[sea_orm(string_value = \"{}\")]", value));
+        lines.push(format!("    {},", variant_name));
+    }
+    lines.push("}".into());
+    lines.push(String::new());
+}
+
+/// Convert a string to a valid Rust enum variant name (PascalCase).
+/// Handles edge cases like numeric prefixes, special characters, and reserved words.
+fn enum_variant_name(s: &str) -> String {
+    let pascal = to_pascal_case(s);
+
+    // Handle empty string
+    if pascal.is_empty() {
+        return "Value".to_string();
+    }
+
+    // Handle numeric prefix: prefix with underscore or 'N'
+    if pascal
+        .chars()
+        .next()
+        .map(|c| c.is_ascii_digit())
+        .unwrap_or(false)
+    {
+        return format!("N{}", pascal);
+    }
+
+    pascal
+}
+
+fn to_pascal_case(s: &str) -> String {
+    let mut result = String::new();
+    let mut capitalize = true;
+    for c in s.chars() {
+        if c == '_' || c == '-' {
+            capitalize = true;
+        } else if capitalize {
+            result.push(c.to_ascii_uppercase());
+            capitalize = false;
+        } else {
+            result.push(c);
+        }
+    }
+    result
+}
+
 #[cfg(test)]
 mod helper_tests {
     use super::*;
@@ -388,6 +473,99 @@ mod helper_tests {
         assert_eq!(unique_name("other", &mut used), "other");
         assert_eq!(unique_name("other", &mut used), "other_1");
     }
+
+    #[test]
+    fn test_to_pascal_case() {
+        // Basic snake_case conversion
+        assert_eq!(to_pascal_case("hello_world"), "HelloWorld");
+        assert_eq!(to_pascal_case("order_status"), "OrderStatus");
+
+        // Kebab-case conversion
+        assert_eq!(to_pascal_case("hello-world"), "HelloWorld");
+        assert_eq!(to_pascal_case("info-level"), "InfoLevel");
+
+        // Already PascalCase
+        assert_eq!(to_pascal_case("HelloWorld"), "HelloWorld");
+
+        // Single word
+        assert_eq!(to_pascal_case("hello"), "Hello");
+        assert_eq!(to_pascal_case("pending"), "Pending");
+
+        // Mixed delimiters
+        assert_eq!(to_pascal_case("hello_world-test"), "HelloWorldTest");
+
+        // Uppercase input
+        assert_eq!(to_pascal_case("HELLO_WORLD"), "HELLOWORLD");
+        assert_eq!(to_pascal_case("ERROR_LEVEL"), "ERRORLEVEL");
+
+        // With numbers
+        assert_eq!(to_pascal_case("level_1"), "Level1");
+        assert_eq!(to_pascal_case("1_critical"), "1Critical");
+
+        // Empty string
+        assert_eq!(to_pascal_case(""), "");
+    }
+
+    #[test]
+    fn test_enum_variant_name() {
+        // Normal cases
+        assert_eq!(enum_variant_name("pending"), "Pending");
+        assert_eq!(enum_variant_name("in_stock"), "InStock");
+        assert_eq!(enum_variant_name("info-level"), "InfoLevel");
+
+        // Numeric prefix - should add 'N' prefix
+        // Note: to_pascal_case("1critical") returns "1critical" (starts with digit, so no uppercase)
+        // then enum_variant_name adds 'N' prefix
+        assert_eq!(enum_variant_name("1critical"), "N1critical");
+        assert_eq!(enum_variant_name("123abc"), "N123abc");
+        // With underscore separator, the part after underscore gets capitalized
+        assert_eq!(enum_variant_name("1_critical"), "N1Critical");
+
+        // Empty string - should return default
+        assert_eq!(enum_variant_name(""), "Value");
+    }
+
+    #[test]
+    fn test_render_enum() {
+        let mut lines = Vec::new();
+        render_enum(
+            &mut lines,
+            "order_status",
+            &["pending".into(), "shipped".into()],
+        );
+
+        assert!(lines.iter().any(|l| l.contains("pub enum OrderStatus")));
+        assert!(lines.iter().any(|l| l.contains("Pending")));
+        assert!(lines.iter().any(|l| l.contains("Shipped")));
+        assert!(lines.iter().any(|l| l.contains("DeriveActiveEnum")));
+        assert!(lines.iter().any(|l| l.contains("EnumIter")));
+        assert!(
+            lines
+                .iter()
+                .any(|l| l.contains("enum_name = \"order_status\""))
+        );
+    }
+
+    #[test]
+    fn test_render_enum_with_numeric_prefix_value() {
+        let mut lines = Vec::new();
+        render_enum(
+            &mut lines,
+            "priority",
+            &["1_high".into(), "2_medium".into(), "3_low".into()],
+        );
+
+        // Numeric prefixed values should be prefixed with 'N'
+        assert!(lines.iter().any(|l| l.contains("N1High")));
+        assert!(lines.iter().any(|l| l.contains("N2Medium")));
+        assert!(lines.iter().any(|l| l.contains("N3Low")));
+        // But the string_value should remain original
+        assert!(
+            lines
+                .iter()
+                .any(|l| l.contains("string_value = \"1_high\""))
+        );
+    }
 }
 
 #[cfg(test)]
@@ -556,6 +734,144 @@ mod tests {
         table = table.normalize().unwrap();
         table
     })]
+    #[case("enum_type", TableDef {
+        name: "orders".into(),
+        columns: vec![
+            ColumnDef { name: "id".into(), r#type: ColumnType::Simple(SimpleColumnType::Integer), nullable: false, default: None, comment: None, primary_key: Some(PrimaryKeySyntax::Bool(true)), unique: None, index: None, foreign_key: None },
+            ColumnDef {
+                name: "status".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "order_status".into(),
+                    values: vec!["pending".into(), "shipped".into(), "delivered".into()]
+                }),
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+        ],
+        constraints: vec![],
+        indexes: vec![],
+    })]
+    #[case("enum_nullable", TableDef {
+        name: "tasks".into(),
+        columns: vec![
+            ColumnDef { name: "id".into(), r#type: ColumnType::Simple(SimpleColumnType::Integer), nullable: false, default: None, comment: None, primary_key: Some(PrimaryKeySyntax::Bool(true)), unique: None, index: None, foreign_key: None },
+            ColumnDef {
+                name: "priority".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "task_priority".into(),
+                    values: vec!["low".into(), "medium".into(), "high".into(), "critical".into()]
+                }),
+                nullable: true,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+        ],
+        constraints: vec![],
+        indexes: vec![],
+    })]
+    #[case("enum_multiple_columns", TableDef {
+        name: "products".into(),
+        columns: vec![
+            ColumnDef { name: "id".into(), r#type: ColumnType::Simple(SimpleColumnType::Integer), nullable: false, default: None, comment: None, primary_key: Some(PrimaryKeySyntax::Bool(true)), unique: None, index: None, foreign_key: None },
+            ColumnDef {
+                name: "category".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "product_category".into(),
+                    values: vec!["electronics".into(), "clothing".into(), "food".into()]
+                }),
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+            ColumnDef {
+                name: "availability".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "availability_status".into(),
+                    values: vec!["in_stock".into(), "out_of_stock".into(), "pre_order".into()]
+                }),
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+        ],
+        constraints: vec![],
+        indexes: vec![],
+    })]
+    #[case("enum_shared", TableDef {
+        name: "documents".into(),
+        columns: vec![
+            ColumnDef { name: "id".into(), r#type: ColumnType::Simple(SimpleColumnType::Integer), nullable: false, default: None, comment: None, primary_key: Some(PrimaryKeySyntax::Bool(true)), unique: None, index: None, foreign_key: None },
+            ColumnDef {
+                name: "status".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "doc_status".into(),
+                    values: vec!["draft".into(), "published".into(), "archived".into()]
+                }),
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+            ColumnDef {
+                name: "review_status".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "doc_status".into(),
+                    values: vec!["draft".into(), "published".into(), "archived".into()]
+                }),
+                nullable: true,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+        ],
+        constraints: vec![],
+        indexes: vec![],
+    })]
+    #[case("enum_special_values", TableDef {
+        name: "events".into(),
+        columns: vec![
+            ColumnDef { name: "id".into(), r#type: ColumnType::Simple(SimpleColumnType::Integer), nullable: false, default: None, comment: None, primary_key: Some(PrimaryKeySyntax::Bool(true)), unique: None, index: None, foreign_key: None },
+            ColumnDef {
+                name: "severity".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "event_severity".into(),
+                    values: vec!["info-level".into(), "warning_level".into(), "ERROR_LEVEL".into(), "1critical".into()]
+                }),
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+        ],
+        constraints: vec![],
+        indexes: vec![],
+    })]
     fn render_entity_snapshots(#[case] name: &str, #[case] table: TableDef) {
         let rendered = render_entity(&table);
         with_settings!({ snapshot_suffix => format!("params_{}", name) }, {
diff --git a/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_multiple_columns.snap b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_multiple_columns.snap
new file mode 100644
index 0000000..e05fdca
--- /dev/null
+++ b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_multiple_columns.snap
@@ -0,0 +1,39 @@
+---
+source: crates/vespertide-exporter/src/seaorm/mod.rs
+expression: rendered
+---
+use sea_orm::entity::prelude::*;
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "product_category")]
+pub enum ProductCategory {
+    #[sea_orm(string_value = "electronics")]
+    Electronics,
+    #[sea_orm(string_value = "clothing")]
+    Clothing,
+    #[sea_orm(string_value = "food")]
+    Food,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "availability_status")]
+pub enum AvailabilityStatus {
+    #[sea_orm(string_value = "in_stock")]
+    InStock,
+    #[sea_orm(string_value = "out_of_stock")]
+    OutOfStock,
+    #[sea_orm(string_value = "pre_order")]
+    PreOrder,
+}
+
+#[sea_orm::model]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "products")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub category: ProductCategory,
+    pub availability: AvailabilityStatus,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_nullable.snap b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_nullable.snap
new file mode 100644
index 0000000..e4c41ca
--- /dev/null
+++ b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_nullable.snap
@@ -0,0 +1,29 @@
+---
+source: crates/vespertide-exporter/src/seaorm/mod.rs
+expression: rendered
+---
+use sea_orm::entity::prelude::*;
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "task_priority")]
+pub enum TaskPriority {
+    #[sea_orm(string_value = "low")]
+    Low,
+    #[sea_orm(string_value = "medium")]
+    Medium,
+    #[sea_orm(string_value = "high")]
+    High,
+    #[sea_orm(string_value = "critical")]
+    Critical,
+}
+
+#[sea_orm::model]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "tasks")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub priority: Option<TaskPriority>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_shared.snap b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_shared.snap
new file mode 100644
index 0000000..34ed6be
--- /dev/null
+++ b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_shared.snap
@@ -0,0 +1,28 @@
+---
+source: crates/vespertide-exporter/src/seaorm/mod.rs
+expression: rendered
+---
+use sea_orm::entity::prelude::*;
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "doc_status")]
+pub enum DocStatus {
+    #[sea_orm(string_value = "draft")]
+    Draft,
+    #[sea_orm(string_value = "published")]
+    Published,
+    #[sea_orm(string_value = "archived")]
+    Archived,
+}
+
+#[sea_orm::model]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "documents")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub status: DocStatus,
+    pub review_status: Option<DocStatus>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_special_values.snap b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_special_values.snap
new file mode 100644
index 0000000..88493e5
--- /dev/null
+++ b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_special_values.snap
@@ -0,0 +1,29 @@
+---
+source: crates/vespertide-exporter/src/seaorm/mod.rs
+expression: rendered
+---
+use sea_orm::entity::prelude::*;
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "event_severity")]
+pub enum EventSeverity {
+    #[sea_orm(string_value = "info-level")]
+    InfoLevel,
+    #[sea_orm(string_value = "warning_level")]
+    WarningLevel,
+    #[sea_orm(string_value = "ERROR_LEVEL")]
+    ERRORLEVEL,
+    #[sea_orm(string_value = "1critical")]
+    N1critical,
+}
+
+#[sea_orm::model]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "events")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub severity: EventSeverity,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_type.snap b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_type.snap
new file mode 100644
index 0000000..0f48299
--- /dev/null
+++ b/crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_type.snap
@@ -0,0 +1,27 @@
+---
+source: crates/vespertide-exporter/src/seaorm/mod.rs
+expression: rendered
+---
+use sea_orm::entity::prelude::*;
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "order_status")]
+pub enum OrderStatus {
+    #[sea_orm(string_value = "pending")]
+    Pending,
+    #[sea_orm(string_value = "shipped")]
+    Shipped,
+    #[sea_orm(string_value = "delivered")]
+    Delivered,
+}
+
+#[sea_orm::model]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "orders")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub status: OrderStatus,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/vespertide-loader/Cargo.toml b/crates/vespertide-loader/Cargo.toml
index 97d6b5e..76b4d1e 100644
--- a/crates/vespertide-loader/Cargo.toml
+++ b/crates/vespertide-loader/Cargo.toml
@@ -19,4 +19,4 @@ serde_yaml = "0.9"
 [dev-dependencies]
 tempfile = "3"
 rstest = "0.26"
-serial_test = "1.0"
+serial_test = "3.2"
diff --git a/crates/vespertide-macro/Cargo.toml b/crates/vespertide-macro/Cargo.toml
index d63d6f5..66b1df8 100644
--- a/crates/vespertide-macro/Cargo.toml
+++ b/crates/vespertide-macro/Cargo.toml
@@ -16,6 +16,7 @@ vespertide-core = { workspace = true }
 vespertide-config = { workspace = true }
 vespertide-loader = { workspace = true }
 vespertide-query = { workspace = true }
+vespertide-planner = { workspace = true }
 thiserror = "2"
 syn = { version = "2.0", features = ["full"] }
 quote = "1.0"
diff --git a/crates/vespertide-macro/src/lib.rs b/crates/vespertide-macro/src/lib.rs
index 83ef878..1dd22ca 100644
--- a/crates/vespertide-macro/src/lib.rs
+++ b/crates/vespertide-macro/src/lib.rs
@@ -5,6 +5,7 @@ use quote::quote;
 use syn::parse::{Parse, ParseStream};
 use syn::{Expr, Ident, Token, parse_macro_input};
 use vespertide_loader::{load_migrations_at_compile_time, load_models_at_compile_time};
+use vespertide_planner::apply_action;
 use vespertide_query::{DatabaseBackend, build_plan_queries};
 
 struct MacroInput {
@@ -64,7 +65,7 @@ pub fn vespertide_migration(input: TokenStream) -> TokenStream {
             .into();
         }
     };
-    let models = match load_models_at_compile_time() {
+    let _models = match load_models_at_compile_time() {
         Ok(models) => models,
         Err(e) => {
             return syn::Error::new(
@@ -76,11 +77,16 @@ pub fn vespertide_migration(input: TokenStream) -> TokenStream {
         }
     };
 
-    // Build SQL for each migration
+    // Build SQL for each migration using incremental baseline schema
+    // This is the same approach as cmd_log: start with empty schema and apply each migration
+    let mut baseline_schema = Vec::new();
     let mut migration_blocks = Vec::new();
+
     for migration in &migrations {
         let version = migration.version;
-        let queries = match build_plan_queries(migration, &models) {
+
+        // Use the current baseline schema (from all previous migrations)
+        let queries = match build_plan_queries(migration, &baseline_schema) {
             Ok(queries) => queries,
             Err(e) => {
                 return syn::Error::new(
@@ -95,39 +101,28 @@ pub fn vespertide_migration(input: TokenStream) -> TokenStream {
             }
         };
 
+        // Update baseline schema incrementally by applying each action
+        for action in &migration.actions {
+            let _ = apply_action(&mut baseline_schema, action);
+        }
+
         // Pre-generate SQL for all backends at compile time
-        let sql_statements: Vec<_> = queries
-            .iter()
-            .map(|q| {
-                let pg_sql = q
-                    .postgres
-                    .iter()
-                    .map(|q| q.build(DatabaseBackend::Postgres))
-                    .collect::<Vec<_>>()
-                    .join(";\n");
-                let mysql_sql = q
-                    .mysql
-                    .iter()
-                    .map(|q| q.build(DatabaseBackend::MySql))
-                    .collect::<Vec<_>>()
-                    .join(";\n");
-                let sqlite_sql = q
-                    .sqlite
-                    .iter()
-                    .map(|q| q.build(DatabaseBackend::Sqlite))
-                    .collect::<Vec<_>>()
-                    .join(";\n");
-
-                quote! {
-                    match backend {
-                        sea_orm::DatabaseBackend::Postgres => #pg_sql,
-                        sea_orm::DatabaseBackend::MySql => #mysql_sql,
-                        sea_orm::DatabaseBackend::Sqlite => #sqlite_sql,
-                        _ => #pg_sql, // Fallback to PostgreSQL syntax for unknown backends
-                    }
-                }
-            })
-            .collect();
+        // Each query may produce multiple SQL statements, so we flatten them
+        let mut pg_sqls = Vec::new();
+        let mut mysql_sqls = Vec::new();
+        let mut sqlite_sqls = Vec::new();
+
+        for q in &queries {
+            for stmt in &q.postgres {
+                pg_sqls.push(stmt.build(DatabaseBackend::Postgres));
+            }
+            for stmt in &q.mysql {
+                mysql_sqls.push(stmt.build(DatabaseBackend::MySql));
+            }
+            for stmt in &q.sqlite {
+                sqlite_sqls.push(stmt.build(DatabaseBackend::Sqlite));
+            }
+        }
 
         // Generate version guard and SQL execution block
         let block = quote! {
@@ -137,16 +132,23 @@ pub fn vespertide_migration(input: TokenStream) -> TokenStream {
                     ::vespertide::MigrationError::DatabaseError(format!("Failed to begin transaction: {}", e))
                 })?;
 
+                // Select SQL statements based on backend
+                let sqls: &[&str] = match backend {
+                    sea_orm::DatabaseBackend::Postgres => &[#(#pg_sqls),*],
+                    sea_orm::DatabaseBackend::MySql => &[#(#mysql_sqls),*],
+                    sea_orm::DatabaseBackend::Sqlite => &[#(#sqlite_sqls),*],
+                    _ => &[#(#pg_sqls),*], // Fallback to PostgreSQL syntax for unknown backends
+                };
+
                 // Execute SQL statements
-                #(
-                    {
-                        let sql: &str = #sql_statements;
-                        let stmt = sea_orm::Statement::from_string(backend, sql);
+                for sql in sqls {
+                    if !sql.is_empty() {
+                        let stmt = sea_orm::Statement::from_string(backend, *sql);
                         txn.execute_raw(stmt).await.map_err(|e| {
                             ::vespertide::MigrationError::DatabaseError(format!("Failed to execute SQL '{}': {}", sql, e))
                         })?;
                     }
-                )*
+                }
 
                 // Insert version record for this migration
                 let q = if matches!(backend, sea_orm::DatabaseBackend::MySql) { '`' } else { '"' };
diff --git a/crates/vespertide-planner/src/diff.rs b/crates/vespertide-planner/src/diff.rs
index f5a450a..94e238b 100644
--- a/crates/vespertide-planner/src/diff.rs
+++ b/crates/vespertide-planner/src/diff.rs
@@ -1,9 +1,209 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet, VecDeque};
 
-use vespertide_core::{MigrationAction, MigrationPlan, TableDef};
+use vespertide_core::{MigrationAction, MigrationPlan, TableConstraint, TableDef};
 
 use crate::error::PlannerError;
 
+/// Topologically sort tables based on foreign key dependencies.
+/// Returns tables in order where tables with no FK dependencies come first,
+/// and tables that reference other tables come after their referenced tables.
+fn topological_sort_tables<'a>(tables: &[&'a TableDef]) -> Result<Vec<&'a TableDef>, PlannerError> {
+    if tables.is_empty() {
+        return Ok(vec![]);
+    }
+
+    // Build a map of table names for quick lookup
+    let table_names: HashSet<&str> = tables.iter().map(|t| t.name.as_str()).collect();
+
+    // Build adjacency list: for each table, list the tables it depends on (via FK)
+    let mut dependencies: HashMap<&str, Vec<&str>> = HashMap::new();
+    for table in tables {
+        let mut deps = Vec::new();
+        for constraint in &table.constraints {
+            if let TableConstraint::ForeignKey { ref_table, .. } = constraint {
+                // Only consider dependencies within the set of tables being created
+                if table_names.contains(ref_table.as_str()) && ref_table != &table.name {
+                    deps.push(ref_table.as_str());
+                }
+            }
+        }
+        dependencies.insert(table.name.as_str(), deps);
+    }
+
+    // Kahn's algorithm for topological sort
+    // Calculate in-degrees (number of tables that depend on each table)
+    let mut in_degree: HashMap<&str, usize> = HashMap::new();
+    for table in tables {
+        in_degree.entry(table.name.as_str()).or_insert(0);
+    }
+
+    // For each dependency, increment the in-degree of the dependent table
+    for (table_name, deps) in &dependencies {
+        for _dep in deps {
+            // The table has dependencies, so those referenced tables must come first
+            // We actually want the reverse: tables with dependencies have higher in-degree
+        }
+        // Actually, we need to track: if A depends on B, then A has in-degree from B
+        // So A cannot be processed until B is processed
+        *in_degree.entry(table_name).or_insert(0) += deps.len();
+    }
+
+    // Start with tables that have no dependencies
+    let mut queue: VecDeque<&str> = VecDeque::new();
+    for table in tables {
+        if in_degree.get(table.name.as_str()) == Some(&0) {
+            queue.push_back(table.name.as_str());
+        }
+    }
+
+    let mut result: Vec<&TableDef> = Vec::new();
+    let table_map: HashMap<&str, &TableDef> =
+        tables.iter().map(|t| (t.name.as_str(), *t)).collect();
+
+    while let Some(table_name) = queue.pop_front() {
+        if let Some(&table) = table_map.get(table_name) {
+            result.push(table);
+        }
+
+        // For each table that depends on this one, decrement its in-degree
+        for (dependent, deps) in &dependencies {
+            if deps.contains(&table_name)
+                && let Some(degree) = in_degree.get_mut(dependent)
+            {
+                *degree -= 1;
+                if *degree == 0 {
+                    queue.push_back(dependent);
+                }
+            }
+        }
+    }
+
+    // Check for cycles
+    if result.len() != tables.len() {
+        let remaining: Vec<&str> = tables
+            .iter()
+            .map(|t| t.name.as_str())
+            .filter(|name| !result.iter().any(|t| t.name.as_str() == *name))
+            .collect();
+        return Err(PlannerError::TableValidation(format!(
+            "Circular foreign key dependency detected among tables: {:?}",
+            remaining
+        )));
+    }
+
+    Ok(result)
+}
+
+/// Sort DeleteTable actions so that tables with FK references are deleted first.
+/// This is the reverse of creation order - use topological sort then reverse.
+/// Helper function to extract table name from DeleteTable action
+/// Safety: should only be called on DeleteTable actions
+fn extract_delete_table_name(action: &MigrationAction) -> &str {
+    match action {
+        MigrationAction::DeleteTable { table } => table.as_str(),
+        _ => panic!("Expected DeleteTable action"),
+    }
+}
+
+fn sort_delete_tables(actions: &mut [MigrationAction], all_tables: &HashMap<&str, &TableDef>) {
+    // Collect DeleteTable actions and their indices
+    let delete_indices: Vec<usize> = actions
+        .iter()
+        .enumerate()
+        .filter_map(|(i, a)| {
+            if matches!(a, MigrationAction::DeleteTable { .. }) {
+                Some(i)
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    if delete_indices.len() <= 1 {
+        return;
+    }
+
+    // Extract table names being deleted
+    let delete_table_names: HashSet<&str> = delete_indices
+        .iter()
+        .map(|&i| extract_delete_table_name(&actions[i]))
+        .collect();
+
+    // Build dependency graph for tables being deleted
+    // dependencies[A] = [B] means A has FK referencing B
+    let mut dependencies: HashMap<&str, Vec<&str>> = HashMap::new();
+    for &table_name in &delete_table_names {
+        let mut deps = Vec::new();
+        if let Some(table_def) = all_tables.get(table_name) {
+            for constraint in &table_def.constraints {
+                if let TableConstraint::ForeignKey { ref_table, .. } = constraint
+                    && delete_table_names.contains(ref_table.as_str())
+                    && ref_table != table_name
+                {
+                    deps.push(ref_table.as_str());
+                }
+            }
+        }
+        dependencies.insert(table_name, deps);
+    }
+
+    // Use Kahn's algorithm for topological sort
+    // in_degree[A] = number of tables A depends on
+    let mut in_degree: HashMap<&str, usize> = HashMap::new();
+    for &table_name in &delete_table_names {
+        in_degree.insert(
+            table_name,
+            dependencies.get(table_name).map_or(0, |d| d.len()),
+        );
+    }
+
+    // Start with tables that have no dependencies (can be deleted last in creation order)
+    let mut queue: VecDeque<&str> = VecDeque::new();
+    for &table_name in &delete_table_names {
+        if in_degree.get(table_name) == Some(&0) {
+            queue.push_back(table_name);
+        }
+    }
+
+    let mut sorted_tables: Vec<&str> = Vec::new();
+    while let Some(table_name) = queue.pop_front() {
+        sorted_tables.push(table_name);
+
+        // For each table that has this one as a dependency, decrement its in-degree
+        for (&dependent, deps) in &dependencies {
+            if deps.contains(&table_name)
+                && let Some(degree) = in_degree.get_mut(dependent)
+            {
+                *degree -= 1;
+                if *degree == 0 {
+                    queue.push_back(dependent);
+                }
+            }
+        }
+    }
+
+    // Reverse to get deletion order (tables with dependencies should be deleted first)
+    sorted_tables.reverse();
+
+    // Reorder the DeleteTable actions according to sorted order
+    let mut delete_actions: Vec<MigrationAction> =
+        delete_indices.iter().map(|&i| actions[i].clone()).collect();
+
+    delete_actions.sort_by(|a, b| {
+        let a_name = extract_delete_table_name(a);
+        let b_name = extract_delete_table_name(b);
+
+        let a_pos = sorted_tables.iter().position(|&t| t == a_name).unwrap_or(0);
+        let b_pos = sorted_tables.iter().position(|&t| t == b_name).unwrap_or(0);
+        a_pos.cmp(&b_pos)
+    });
+
+    // Put them back
+    for (i, idx) in delete_indices.iter().enumerate() {
+        actions[*idx] = delete_actions[i].clone();
+    }
+}
+
 /// Diff two schema snapshots into a migration plan.
 /// Both schemas are normalized to convert inline column constraints
 /// (primary_key, unique, index, foreign_key) to table-level constraints.
@@ -150,22 +350,32 @@ pub fn diff_schemas(from: &[TableDef], to: &[TableDef]) -> Result<MigrationPlan,
     }
 
     // Create new tables (and their indexes).
-    for (name, tbl) in &to_map {
-        if !from_map.contains_key(name) {
-            actions.push(MigrationAction::CreateTable {
+    // Collect new tables first, then topologically sort them by FK dependencies.
+    let new_tables: Vec<&TableDef> = to_map
+        .iter()
+        .filter(|(name, _)| !from_map.contains_key(*name))
+        .map(|(_, tbl)| *tbl)
+        .collect();
+
+    let sorted_new_tables = topological_sort_tables(&new_tables)?;
+
+    for tbl in sorted_new_tables {
+        actions.push(MigrationAction::CreateTable {
+            table: tbl.name.clone(),
+            columns: tbl.columns.clone(),
+            constraints: tbl.constraints.clone(),
+        });
+        for idx in &tbl.indexes {
+            actions.push(MigrationAction::AddIndex {
                 table: tbl.name.clone(),
-                columns: tbl.columns.clone(),
-                constraints: tbl.constraints.clone(),
+                index: idx.clone(),
             });
-            for idx in &tbl.indexes {
-                actions.push(MigrationAction::AddIndex {
-                    table: tbl.name.clone(),
-                    index: idx.clone(),
-                });
-            }
         }
     }
 
+    // Sort DeleteTable actions so tables with FK dependencies are deleted first
+    sort_delete_tables(&mut actions, &from_map);
+
     Ok(MigrationPlan {
         comment: None,
         created_at: None,
@@ -798,4 +1008,371 @@ mod tests {
             }
         }
     }
+
+    // Tests for foreign key dependency ordering
+    mod fk_ordering {
+        use super::*;
+        use vespertide_core::TableConstraint;
+
+        fn table_with_fk(
+            name: &str,
+            ref_table: &str,
+            fk_column: &str,
+            ref_column: &str,
+        ) -> TableDef {
+            TableDef {
+                name: name.to_string(),
+                columns: vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col(fk_column, ColumnType::Simple(SimpleColumnType::Integer)),
+                ],
+                constraints: vec![TableConstraint::ForeignKey {
+                    name: None,
+                    columns: vec![fk_column.to_string()],
+                    ref_table: ref_table.to_string(),
+                    ref_columns: vec![ref_column.to_string()],
+                    on_delete: None,
+                    on_update: None,
+                }],
+                indexes: vec![],
+            }
+        }
+
+        fn simple_table(name: &str) -> TableDef {
+            TableDef {
+                name: name.to_string(),
+                columns: vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+                constraints: vec![],
+                indexes: vec![],
+            }
+        }
+
+        #[test]
+        fn create_tables_respects_fk_order() {
+            // Create users and posts tables where posts references users
+            // The order should be: users first, then posts
+            let users = simple_table("users");
+            let posts = table_with_fk("posts", "users", "user_id", "id");
+
+            let plan = diff_schemas(&[], &[posts.clone(), users.clone()]).unwrap();
+
+            // Extract CreateTable actions in order
+            let create_order: Vec<&str> = plan
+                .actions
+                .iter()
+                .filter_map(|a| {
+                    if let MigrationAction::CreateTable { table, .. } = a {
+                        Some(table.as_str())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            assert_eq!(create_order, vec!["users", "posts"]);
+        }
+
+        #[test]
+        fn create_tables_chain_dependency() {
+            // Chain: users <- media <- articles
+            // users has no FK
+            // media references users
+            // articles references media
+            let users = simple_table("users");
+            let media = table_with_fk("media", "users", "owner_id", "id");
+            let articles = table_with_fk("articles", "media", "media_id", "id");
+
+            // Pass in reverse order to ensure sorting works
+            let plan =
+                diff_schemas(&[], &[articles.clone(), media.clone(), users.clone()]).unwrap();
+
+            let create_order: Vec<&str> = plan
+                .actions
+                .iter()
+                .filter_map(|a| {
+                    if let MigrationAction::CreateTable { table, .. } = a {
+                        Some(table.as_str())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            assert_eq!(create_order, vec!["users", "media", "articles"]);
+        }
+
+        #[test]
+        fn create_tables_multiple_independent_branches() {
+            // Two independent branches:
+            // users <- posts
+            // categories <- products
+            let users = simple_table("users");
+            let posts = table_with_fk("posts", "users", "user_id", "id");
+            let categories = simple_table("categories");
+            let products = table_with_fk("products", "categories", "category_id", "id");
+
+            let plan = diff_schemas(
+                &[],
+                &[
+                    products.clone(),
+                    posts.clone(),
+                    categories.clone(),
+                    users.clone(),
+                ],
+            )
+            .unwrap();
+
+            let create_order: Vec<&str> = plan
+                .actions
+                .iter()
+                .filter_map(|a| {
+                    if let MigrationAction::CreateTable { table, .. } = a {
+                        Some(table.as_str())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            // users must come before posts
+            let users_pos = create_order.iter().position(|&t| t == "users").unwrap();
+            let posts_pos = create_order.iter().position(|&t| t == "posts").unwrap();
+            assert!(
+                users_pos < posts_pos,
+                "users should be created before posts"
+            );
+
+            // categories must come before products
+            let categories_pos = create_order
+                .iter()
+                .position(|&t| t == "categories")
+                .unwrap();
+            let products_pos = create_order.iter().position(|&t| t == "products").unwrap();
+            assert!(
+                categories_pos < products_pos,
+                "categories should be created before products"
+            );
+        }
+
+        #[test]
+        fn delete_tables_respects_fk_order() {
+            // When deleting users and posts where posts references users,
+            // posts should be deleted first (reverse of creation order)
+            let users = simple_table("users");
+            let posts = table_with_fk("posts", "users", "user_id", "id");
+
+            let plan = diff_schemas(&[users.clone(), posts.clone()], &[]).unwrap();
+
+            let delete_order: Vec<&str> = plan
+                .actions
+                .iter()
+                .filter_map(|a| {
+                    if let MigrationAction::DeleteTable { table } = a {
+                        Some(table.as_str())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            assert_eq!(delete_order, vec!["posts", "users"]);
+        }
+
+        #[test]
+        fn delete_tables_chain_dependency() {
+            // Chain: users <- media <- articles
+            // Delete order should be: articles, media, users
+            let users = simple_table("users");
+            let media = table_with_fk("media", "users", "owner_id", "id");
+            let articles = table_with_fk("articles", "media", "media_id", "id");
+
+            let plan =
+                diff_schemas(&[users.clone(), media.clone(), articles.clone()], &[]).unwrap();
+
+            let delete_order: Vec<&str> = plan
+                .actions
+                .iter()
+                .filter_map(|a| {
+                    if let MigrationAction::DeleteTable { table } = a {
+                        Some(table.as_str())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            // articles must be deleted before media
+            let articles_pos = delete_order.iter().position(|&t| t == "articles").unwrap();
+            let media_pos = delete_order.iter().position(|&t| t == "media").unwrap();
+            assert!(
+                articles_pos < media_pos,
+                "articles should be deleted before media"
+            );
+
+            // media must be deleted before users
+            let users_pos = delete_order.iter().position(|&t| t == "users").unwrap();
+            assert!(
+                media_pos < users_pos,
+                "media should be deleted before users"
+            );
+        }
+
+        #[test]
+        fn circular_fk_dependency_returns_error() {
+            // Create circular dependency: A -> B -> A
+            let table_a = TableDef {
+                name: "table_a".to_string(),
+                columns: vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("b_id", ColumnType::Simple(SimpleColumnType::Integer)),
+                ],
+                constraints: vec![TableConstraint::ForeignKey {
+                    name: None,
+                    columns: vec!["b_id".to_string()],
+                    ref_table: "table_b".to_string(),
+                    ref_columns: vec!["id".to_string()],
+                    on_delete: None,
+                    on_update: None,
+                }],
+                indexes: vec![],
+            };
+
+            let table_b = TableDef {
+                name: "table_b".to_string(),
+                columns: vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("a_id", ColumnType::Simple(SimpleColumnType::Integer)),
+                ],
+                constraints: vec![TableConstraint::ForeignKey {
+                    name: None,
+                    columns: vec!["a_id".to_string()],
+                    ref_table: "table_a".to_string(),
+                    ref_columns: vec!["id".to_string()],
+                    on_delete: None,
+                    on_update: None,
+                }],
+                indexes: vec![],
+            };
+
+            let result = diff_schemas(&[], &[table_a, table_b]);
+            assert!(result.is_err());
+            if let Err(PlannerError::TableValidation(msg)) = result {
+                assert!(
+                    msg.contains("Circular foreign key dependency"),
+                    "Expected circular dependency error, got: {}",
+                    msg
+                );
+            } else {
+                panic!("Expected TableValidation error, got {:?}", result);
+            }
+        }
+
+        #[test]
+        fn fk_to_external_table_is_ignored() {
+            // FK referencing a table not in the migration should not affect ordering
+            let posts = table_with_fk("posts", "users", "user_id", "id");
+            let comments = table_with_fk("comments", "posts", "post_id", "id");
+
+            // users is NOT being created in this migration
+            let plan = diff_schemas(&[], &[comments.clone(), posts.clone()]).unwrap();
+
+            let create_order: Vec<&str> = plan
+                .actions
+                .iter()
+                .filter_map(|a| {
+                    if let MigrationAction::CreateTable { table, .. } = a {
+                        Some(table.as_str())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            // posts must come before comments (comments depends on posts)
+            let posts_pos = create_order.iter().position(|&t| t == "posts").unwrap();
+            let comments_pos = create_order.iter().position(|&t| t == "comments").unwrap();
+            assert!(
+                posts_pos < comments_pos,
+                "posts should be created before comments"
+            );
+        }
+
+        #[test]
+        fn delete_tables_mixed_with_other_actions() {
+            // Test that sort_delete_actions correctly handles actions that are not DeleteTable
+            // This tests lines 124, 193, 198 (the else branches)
+            use crate::diff::diff_schemas;
+
+            let from_schema = vec![
+                table(
+                    "users",
+                    vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+                    vec![],
+                    vec![],
+                ),
+                table(
+                    "posts",
+                    vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+                    vec![],
+                    vec![],
+                ),
+            ];
+
+            let to_schema = vec![
+                // Drop posts table, but also add a new column to users
+                table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                ),
+            ];
+
+            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
+
+            // Should have: AddColumn (for users.name) and DeleteTable (for posts)
+            assert!(
+                plan.actions
+                    .iter()
+                    .any(|a| matches!(a, MigrationAction::AddColumn { .. }))
+            );
+            assert!(
+                plan.actions
+                    .iter()
+                    .any(|a| matches!(a, MigrationAction::DeleteTable { .. }))
+            );
+
+            // The else branches in sort_delete_actions should handle AddColumn gracefully
+            // (returning empty string for table name, which sorts it to position 0)
+        }
+
+        #[test]
+        #[should_panic(expected = "Expected DeleteTable action")]
+        fn test_extract_delete_table_name_panics_on_non_delete_action() {
+            // Test that extract_delete_table_name panics when called with non-DeleteTable action
+            use super::extract_delete_table_name;
+
+            let action = MigrationAction::AddColumn {
+                table: "users".into(),
+                column: ColumnDef {
+                    name: "email".into(),
+                    r#type: ColumnType::Simple(SimpleColumnType::Text),
+                    nullable: true,
+                    default: None,
+                    comment: None,
+                    primary_key: None,
+                    unique: None,
+                    index: None,
+                    foreign_key: None,
+                },
+                fill_with: None,
+            };
+
+            // This should panic
+            extract_delete_table_name(&action);
+        }
+    }
 }
diff --git a/crates/vespertide-planner/src/lib.rs b/crates/vespertide-planner/src/lib.rs
index 932f42d..51d542c 100644
--- a/crates/vespertide-planner/src/lib.rs
+++ b/crates/vespertide-planner/src/lib.rs
@@ -1,13 +1,13 @@
-pub mod apply;
-pub mod diff;
-pub mod error;
-pub mod plan;
-pub mod schema;
-pub mod validate;
-
-pub use apply::apply_action;
-pub use diff::diff_schemas;
-pub use error::PlannerError;
-pub use plan::plan_next_migration;
-pub use schema::schema_from_plans;
-pub use validate::{validate_migration_plan, validate_schema};
+pub mod apply;
+pub mod diff;
+pub mod error;
+pub mod plan;
+pub mod schema;
+pub mod validate;
+
+pub use apply::apply_action;
+pub use diff::diff_schemas;
+pub use error::PlannerError;
+pub use plan::{plan_next_migration, plan_next_migration_with_baseline};
+pub use schema::schema_from_plans;
+pub use validate::{validate_migration_plan, validate_schema};
diff --git a/crates/vespertide-planner/src/plan.rs b/crates/vespertide-planner/src/plan.rs
index 4180427..e28b41a 100644
--- a/crates/vespertide-planner/src/plan.rs
+++ b/crates/vespertide-planner/src/plan.rs
@@ -1,89 +1,100 @@
-use vespertide_core::{MigrationPlan, TableDef};
-
-use crate::error::PlannerError;
-use crate::{diff_schemas, schema_from_plans};
-
-/// Build the next migration plan given the current schema and existing plans.
-/// The baseline schema is reconstructed from already-applied plans and then
-/// diffed against the target `current` schema.
-pub fn plan_next_migration(
-    current: &[TableDef],
-    applied_plans: &[MigrationPlan],
-) -> Result<MigrationPlan, PlannerError> {
-    let baseline = schema_from_plans(applied_plans)?;
-    let mut plan = diff_schemas(&baseline, current)?;
-
-    let next_version = applied_plans
-        .iter()
-        .map(|p| p.version)
-        .max()
-        .unwrap_or(0)
-        .saturating_add(1);
-    plan.version = next_version;
-    Ok(plan)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rstest::rstest;
-    use vespertide_core::{ColumnDef, ColumnType, MigrationAction, SimpleColumnType};
-
-    fn col(name: &str, ty: ColumnType) -> ColumnDef {
-        ColumnDef {
-            name: name.to_string(),
-            r#type: ty,
-            nullable: true,
-            default: None,
-            comment: None,
-            primary_key: None,
-            unique: None,
-            index: None,
-            foreign_key: None,
-        }
-    }
-
-    fn table(
-        name: &str,
-        columns: Vec<ColumnDef>,
-        constraints: Vec<vespertide_core::TableConstraint>,
-        indexes: Vec<vespertide_core::IndexDef>,
-    ) -> TableDef {
-        TableDef {
-            name: name.to_string(),
-            columns,
-            constraints,
-            indexes,
-        }
-    }
-
-    #[rstest]
-    fn plan_next_migration_sets_next_version() {
-        let applied = vec![MigrationPlan {
-            comment: None,
-            created_at: None,
-            version: 1,
-            actions: vec![MigrationAction::CreateTable {
-                table: "users".into(),
-                columns: vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-                constraints: vec![],
-            }],
-        }];
-
-        let target_schema = vec![table(
-            "users",
-            vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col("name", ColumnType::Simple(SimpleColumnType::Text)),
-            ],
-            vec![],
-            vec![],
-        )];
-
-        let plan = plan_next_migration(&target_schema, &applied).unwrap();
-        assert_eq!(plan.version, 2);
-        assert!(plan.actions.iter().any(
-            |a| matches!(a, MigrationAction::AddColumn { column, .. } if column.name == "name")
-        ));
-    }
-}
+use vespertide_core::{MigrationPlan, TableDef};
+
+use crate::error::PlannerError;
+use crate::{diff_schemas, schema_from_plans};
+
+/// Build the next migration plan given the current schema and existing plans.
+/// The baseline schema is reconstructed from already-applied plans and then
+/// diffed against the target `current` schema.
+pub fn plan_next_migration(
+    current: &[TableDef],
+    applied_plans: &[MigrationPlan],
+) -> Result<MigrationPlan, PlannerError> {
+    let baseline = schema_from_plans(applied_plans)?;
+    plan_next_migration_with_baseline(current, applied_plans, &baseline)
+}
+
+/// Build the next migration plan given the current schema, existing plans, and
+/// a pre-computed baseline schema. This is more efficient when the baseline
+/// schema is already available, avoiding redundant calls to `schema_from_plans`.
+pub fn plan_next_migration_with_baseline(
+    current: &[TableDef],
+    applied_plans: &[MigrationPlan],
+    baseline: &[TableDef],
+) -> Result<MigrationPlan, PlannerError> {
+    let mut plan = diff_schemas(baseline, current)?;
+
+    let next_version = applied_plans
+        .iter()
+        .map(|p| p.version)
+        .max()
+        .unwrap_or(0)
+        .saturating_add(1);
+    plan.version = next_version;
+    Ok(plan)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rstest::rstest;
+    use vespertide_core::{ColumnDef, ColumnType, MigrationAction, SimpleColumnType};
+
+    fn col(name: &str, ty: ColumnType) -> ColumnDef {
+        ColumnDef {
+            name: name.to_string(),
+            r#type: ty,
+            nullable: true,
+            default: None,
+            comment: None,
+            primary_key: None,
+            unique: None,
+            index: None,
+            foreign_key: None,
+        }
+    }
+
+    fn table(
+        name: &str,
+        columns: Vec<ColumnDef>,
+        constraints: Vec<vespertide_core::TableConstraint>,
+        indexes: Vec<vespertide_core::IndexDef>,
+    ) -> TableDef {
+        TableDef {
+            name: name.to_string(),
+            columns,
+            constraints,
+            indexes,
+        }
+    }
+
+    #[rstest]
+    fn plan_next_migration_sets_next_version() {
+        let applied = vec![MigrationPlan {
+            comment: None,
+            created_at: None,
+            version: 1,
+            actions: vec![MigrationAction::CreateTable {
+                table: "users".into(),
+                columns: vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+                constraints: vec![],
+            }],
+        }];
+
+        let target_schema = vec![table(
+            "users",
+            vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col("name", ColumnType::Simple(SimpleColumnType::Text)),
+            ],
+            vec![],
+            vec![],
+        )];
+
+        let plan = plan_next_migration(&target_schema, &applied).unwrap();
+        assert_eq!(plan.version, 2);
+        assert!(plan.actions.iter().any(
+            |a| matches!(a, MigrationAction::AddColumn { column, .. } if column.name == "name")
+        ));
+    }
+}
diff --git a/crates/vespertide-query/Cargo.toml b/crates/vespertide-query/Cargo.toml
index e7be3dd..a4a993b 100644
--- a/crates/vespertide-query/Cargo.toml
+++ b/crates/vespertide-query/Cargo.toml
@@ -10,6 +10,7 @@ description = "Converts migration actions into SQL statements with bind paramete
 
 [dependencies]
 vespertide-core = { workspace = true }
+vespertide-planner = { workspace = true }
 thiserror = "2"
 sea-query = "0.32"
 
diff --git a/crates/vespertide-query/src/builder.rs b/crates/vespertide-query/src/builder.rs
index 4c468ff..0c6cecc 100644
--- a/crates/vespertide-query/src/builder.rs
+++ b/crates/vespertide-query/src/builder.rs
@@ -1,4 +1,5 @@
 use vespertide_core::{MigrationAction, MigrationPlan, TableDef};
+use vespertide_planner::apply_action;
 
 use crate::DatabaseBackend;
 use crate::error::QueryError;
@@ -16,18 +17,29 @@ pub fn build_plan_queries(
     current_schema: &[TableDef],
 ) -> Result<Vec<PlanQueries>, QueryError> {
     let mut queries: Vec<PlanQueries> = Vec::new();
+    // Clone the schema so we can mutate it as we apply actions
+    let mut evolving_schema = current_schema.to_vec();
+
     for action in &plan.actions {
+        // Build queries with the current state of the schema
         let postgres_queries =
-            build_action_queries(&DatabaseBackend::Postgres, action, current_schema)?;
-        let mysql_queries = build_action_queries(&DatabaseBackend::MySql, action, current_schema)?;
+            build_action_queries(&DatabaseBackend::Postgres, action, &evolving_schema)?;
+        let mysql_queries =
+            build_action_queries(&DatabaseBackend::MySql, action, &evolving_schema)?;
         let sqlite_queries =
-            build_action_queries(&DatabaseBackend::Sqlite, action, current_schema)?;
+            build_action_queries(&DatabaseBackend::Sqlite, action, &evolving_schema)?;
         queries.push(PlanQueries {
             action: action.clone(),
             postgres: postgres_queries,
             mysql: mysql_queries,
             sqlite: sqlite_queries,
         });
+
+        // Apply the action to update the schema for the next iteration
+        // Note: We ignore errors here because some actions (like DeleteTable) may reference
+        // tables that don't exist in the provided current_schema. This is OK for SQL generation
+        // purposes - we still generate the correct SQL, and the schema evolution is best-effort.
+        let _ = apply_action(&mut evolving_schema, action);
     }
     Ok(queries)
 }
diff --git a/crates/vespertide-query/src/sql/add_column.rs b/crates/vespertide-query/src/sql/add_column.rs
index 0ac0be8..fdeb7bb 100644
--- a/crates/vespertide-query/src/sql/add_column.rs
+++ b/crates/vespertide-query/src/sql/add_column.rs
@@ -3,7 +3,7 @@ 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_sea_column_def;
+use super::helpers::{build_create_enum_type_sql, build_sea_column_def};
 use super::rename_table::build_rename_table;
 use super::types::{BuiltQuery, DatabaseBackend};
 use crate::error::QueryError;
@@ -105,6 +105,11 @@ pub fn build_add_column(
 
     let mut stmts: Vec<BuiltQuery> = Vec::new();
 
+    // If column type is an enum, create the type first (PostgreSQL only)
+    if let Some(create_type_sql) = build_create_enum_type_sql(&column.r#type) {
+        stmts.push(BuiltQuery::Raw(create_type_sql));
+    }
+
     // If adding NOT NULL without default, we need special handling
     let needs_backfill = !column.nullable && column.default.is_none() && fill_with.is_some();
 
@@ -487,4 +492,57 @@ mod tests {
         assert!(sql.contains("CREATE UNIQUE INDEX"));
         assert!(sql.contains("idx_email"));
     }
+
+    #[rstest]
+    #[case::add_column_with_enum_type_postgres(DatabaseBackend::Postgres)]
+    #[case::add_column_with_enum_type_mysql(DatabaseBackend::MySql)]
+    #[case::add_column_with_enum_type_sqlite(DatabaseBackend::Sqlite)]
+    fn test_add_column_with_enum_type(#[case] backend: DatabaseBackend) {
+        use insta::{assert_snapshot, with_settings};
+        use vespertide_core::ComplexColumnType;
+
+        // Test that adding an enum column creates the enum type first (PostgreSQL only)
+        let column = ColumnDef {
+            name: "status".into(),
+            r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                name: "status_type".into(),
+                values: vec!["active".into(), "inactive".into()],
+            }),
+            nullable: true,
+            default: None,
+            comment: None,
+            primary_key: None,
+            unique: None,
+            index: None,
+            foreign_key: None,
+        };
+        let current_schema = vec![TableDef {
+            name: "users".into(),
+            columns: vec![ColumnDef {
+                name: "id".into(),
+                r#type: ColumnType::Simple(SimpleColumnType::Integer),
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            }],
+            constraints: vec![],
+            indexes: vec![],
+        }];
+        let result = build_add_column(&backend, "users", &column, None, &current_schema);
+        assert!(result.is_ok());
+        let queries = result.unwrap();
+        let sql = queries
+            .iter()
+            .map(|q| q.build(backend))
+            .collect::<Vec<String>>()
+            .join(";\n");
+
+        with_settings!({ snapshot_suffix => format!("add_column_with_enum_type_{:?}", backend) }, {
+            assert_snapshot!(sql);
+        });
+    }
 }
diff --git a/crates/vespertide-query/src/sql/create_table.rs b/crates/vespertide-query/src/sql/create_table.rs
index e5bb4aa..feaaf21 100644
--- a/crates/vespertide-query/src/sql/create_table.rs
+++ b/crates/vespertide-query/src/sql/create_table.rs
@@ -1,8 +1,8 @@
 use sea_query::{Alias, ForeignKey, Index, Table, TableCreateStatement};
 
-use vespertide_core::{ColumnDef, TableConstraint};
+use vespertide_core::{ColumnDef, ColumnType, ComplexColumnType, TableConstraint};
 
-use super::helpers::{build_sea_column_def, to_sea_fk_action};
+use super::helpers::{build_create_enum_type_sql, build_sea_column_def, to_sea_fk_action};
 use super::types::{BuiltQuery, DatabaseBackend};
 use crate::error::QueryError;
 
@@ -115,6 +115,18 @@ pub fn build_create_table(
 ) -> Result<Vec<BuiltQuery>, QueryError> {
     let mut queries = Vec::new();
 
+    // Create enum types first (PostgreSQL only)
+    // Collect unique enum types to avoid duplicates
+    let mut created_enums = std::collections::HashSet::new();
+    for column in columns {
+        if let ColumnType::Complex(ComplexColumnType::Enum { name, .. }) = &column.r#type
+            && created_enums.insert(name.clone())
+            && let Some(create_type_sql) = build_create_enum_type_sql(&column.r#type)
+        {
+            queries.push(BuiltQuery::Raw(create_type_sql));
+        }
+    }
+
     // Separate unique constraints for Postgres and SQLite (they need separate CREATE INDEX statements)
     // For MySQL, unique constraints are added directly in CREATE TABLE via build_create_table_for_backend
     let (table_constraints, unique_constraints): (Vec<&TableConstraint>, Vec<&TableConstraint>) =
@@ -353,4 +365,56 @@ mod tests {
             assert_snapshot!(sql);
         });
     }
+
+    #[rstest]
+    #[case::postgres(DatabaseBackend::Postgres)]
+    #[case::mysql(DatabaseBackend::MySql)]
+    #[case::sqlite(DatabaseBackend::Sqlite)]
+    fn test_create_table_with_enum_column(#[case] backend: DatabaseBackend) {
+        // Test creating a table with an enum column (should create enum type first for PostgreSQL)
+        let columns = vec![
+            ColumnDef {
+                name: "id".into(),
+                r#type: ColumnType::Simple(SimpleColumnType::Integer),
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+            ColumnDef {
+                name: "status".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "user_status".into(),
+                    values: vec!["active".into(), "inactive".into(), "pending".into()],
+                }),
+                nullable: false,
+                default: Some("'active'".into()),
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+        ];
+        let constraints = vec![TableConstraint::PrimaryKey {
+            auto_increment: false,
+            columns: vec!["id".into()],
+        }];
+
+        let result = build_create_table(&backend, "users", &columns, &constraints);
+        assert!(result.is_ok());
+        let queries = result.unwrap();
+        let sql = queries
+            .iter()
+            .map(|q| q.build(backend))
+            .collect::<Vec<String>>()
+            .join(";\n");
+
+        with_settings!({ snapshot_suffix => format!("create_table_with_enum_column_{:?}", backend) }, {
+            assert_snapshot!(sql);
+        });
+    }
 }
diff --git a/crates/vespertide-query/src/sql/delete_column.rs b/crates/vespertide-query/src/sql/delete_column.rs
index 1492778..6f67445 100644
--- a/crates/vespertide-query/src/sql/delete_column.rs
+++ b/crates/vespertide-query/src/sql/delete_column.rs
@@ -1,13 +1,34 @@
 use sea_query::{Alias, Table};
 
+use vespertide_core::ColumnType;
+
+use super::helpers::build_drop_enum_type_sql;
 use super::types::BuiltQuery;
 
-pub fn build_delete_column(table: &str, column: &str) -> BuiltQuery {
+/// Build SQL to delete a column, optionally with DROP TYPE for enum columns (PostgreSQL)
+pub fn build_delete_column(
+    table: &str,
+    column: &str,
+    column_type: Option<&ColumnType>,
+) -> Vec<BuiltQuery> {
+    let mut stmts = Vec::new();
+
+    // Drop the column first
     let stmt = Table::alter()
         .table(Alias::new(table))
         .drop_column(Alias::new(column))
         .to_owned();
-    BuiltQuery::AlterTable(Box::new(stmt))
+    stmts.push(BuiltQuery::AlterTable(Box::new(stmt)));
+
+    // If column type is an enum, drop the type after (PostgreSQL only)
+    // Note: Only drop if this is the last column using this enum type
+    if let Some(col_type) = column_type
+        && let Some(drop_type_sql) = build_drop_enum_type_sql(col_type)
+    {
+        stmts.push(BuiltQuery::Raw(drop_type_sql));
+    }
+
+    stmts
 }
 
 #[cfg(test)]
@@ -16,6 +37,7 @@ mod tests {
     use crate::sql::types::DatabaseBackend;
     use insta::{assert_snapshot, with_settings};
     use rstest::rstest;
+    use vespertide_core::{ComplexColumnType, SimpleColumnType};
 
     #[rstest]
     #[case::delete_column_postgres(
@@ -38,8 +60,8 @@ mod tests {
         #[case] backend: DatabaseBackend,
         #[case] expected: &[&str],
     ) {
-        let result = build_delete_column("users", "email");
-        let sql = result.build(backend);
+        let result = build_delete_column("users", "email", None);
+        let sql = result[0].build(backend);
         for exp in expected {
             assert!(
                 sql.contains(exp),
@@ -53,4 +75,35 @@ mod tests {
             assert_snapshot!(sql);
         });
     }
+
+    #[test]
+    fn test_delete_enum_column_postgres() {
+        let enum_type = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        });
+        let result = build_delete_column("users", "status", Some(&enum_type));
+
+        // Should have 2 statements: ALTER TABLE and DROP TYPE
+        assert_eq!(result.len(), 2);
+
+        let alter_sql = result[0].build(DatabaseBackend::Postgres);
+        assert!(alter_sql.contains("DROP COLUMN"));
+
+        let drop_type_sql = result[1].build(DatabaseBackend::Postgres);
+        assert!(drop_type_sql.contains("DROP TYPE IF EXISTS \"status\""));
+
+        // MySQL and SQLite should have empty DROP TYPE
+        let drop_type_mysql = result[1].build(DatabaseBackend::MySql);
+        assert!(drop_type_mysql.is_empty());
+    }
+
+    #[test]
+    fn test_delete_non_enum_column_no_drop_type() {
+        let text_type = ColumnType::Simple(SimpleColumnType::Text);
+        let result = build_delete_column("users", "name", Some(&text_type));
+
+        // Should only have 1 statement: ALTER TABLE
+        assert_eq!(result.len(), 1);
+    }
 }
diff --git a/crates/vespertide-query/src/sql/helpers.rs b/crates/vespertide-query/src/sql/helpers.rs
index 07c0c96..d230345 100644
--- a/crates/vespertide-query/src/sql/helpers.rs
+++ b/crates/vespertide-query/src/sql/helpers.rs
@@ -111,6 +111,12 @@ pub fn apply_column_type(col: &mut SeaColumnDef, ty: &ColumnType) {
             ComplexColumnType::Custom { custom_type } => {
                 col.custom(Alias::new(custom_type));
             }
+            ComplexColumnType::Enum { name, values } => {
+                col.enumeration(
+                    Alias::new(name),
+                    values.iter().map(Alias::new).collect::<Vec<Alias>>(),
+                );
+            }
         },
     }
 }
@@ -171,6 +177,66 @@ pub fn build_sea_column_def(backend: &DatabaseBackend, column: &ColumnDef) -> Se
     col
 }
 
+/// Generate CREATE TYPE SQL for an enum type (PostgreSQL only)
+/// Returns None for non-PostgreSQL backends or non-enum types
+pub fn build_create_enum_type_sql(column_type: &ColumnType) -> Option<super::types::RawSql> {
+    if let ColumnType::Complex(ComplexColumnType::Enum { name, values }) = column_type {
+        let values_sql = values
+            .iter()
+            .map(|v| format!("'{}'", v.replace('\'', "''")))
+            .collect::<Vec<_>>()
+            .join(", ");
+
+        // PostgreSQL: CREATE TYPE name AS ENUM (...)
+        let pg_sql = format!("CREATE TYPE \"{}\" AS ENUM ({})", name, values_sql);
+
+        // MySQL: ENUMs are inline, no CREATE TYPE needed
+        // SQLite: Uses TEXT, no CREATE TYPE needed
+        Some(super::types::RawSql::per_backend(
+            pg_sql,
+            String::new(),
+            String::new(),
+        ))
+    } else {
+        None
+    }
+}
+
+/// Generate DROP TYPE SQL for an enum type (PostgreSQL only)
+/// Returns None for non-PostgreSQL backends or non-enum types
+pub fn build_drop_enum_type_sql(column_type: &ColumnType) -> Option<super::types::RawSql> {
+    if let ColumnType::Complex(ComplexColumnType::Enum { name, .. }) = column_type {
+        // PostgreSQL: DROP TYPE IF EXISTS name
+        let pg_sql = format!("DROP TYPE IF EXISTS \"{}\"", name);
+
+        // MySQL/SQLite: No action needed
+        Some(super::types::RawSql::per_backend(
+            pg_sql,
+            String::new(),
+            String::new(),
+        ))
+    } else {
+        None
+    }
+}
+
+/// Check if a column type is an enum
+pub fn is_enum_type(column_type: &ColumnType) -> bool {
+    matches!(
+        column_type,
+        ColumnType::Complex(ComplexColumnType::Enum { .. })
+    )
+}
+
+/// 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 {
+        Some(name.as_str())
+    } else {
+        None
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -223,6 +289,7 @@ mod tests {
     #[case(ComplexColumnType::Numeric { precision: 8, scale: 3 })]
     #[case(ComplexColumnType::Char { length: 3 })]
     #[case(ComplexColumnType::Custom { custom_type: "GEOGRAPHY".into() })]
+    #[case(ComplexColumnType::Enum { name: "status".into(), values: vec!["active".into(), "inactive".into()] })]
     fn test_all_complex_types_cover_branches(#[case] ty: ComplexColumnType) {
         let mut col = SeaColumnDef::new(Alias::new("t"));
         apply_column_type(&mut col, &ColumnType::Complex(ty));
@@ -314,4 +381,34 @@ mod tests {
         let result = convert_default_for_backend(default, &backend);
         assert_eq!(result, expected);
     }
+
+    #[test]
+    fn test_is_enum_type_true() {
+        let enum_type = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        });
+        assert!(is_enum_type(&enum_type));
+    }
+
+    #[test]
+    fn test_is_enum_type_false() {
+        let text_type = ColumnType::Simple(SimpleColumnType::Text);
+        assert!(!is_enum_type(&text_type));
+    }
+
+    #[test]
+    fn test_get_enum_name_some() {
+        let enum_type = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "user_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        });
+        assert_eq!(get_enum_name(&enum_type), Some("user_status"));
+    }
+
+    #[test]
+    fn test_get_enum_name_none() {
+        let text_type = ColumnType::Simple(SimpleColumnType::Text);
+        assert_eq!(get_enum_name(&text_type), None);
+    }
 }
diff --git a/crates/vespertide-query/src/sql/mod.rs b/crates/vespertide-query/src/sql/mod.rs
index 9d30fbe..4e034d7 100644
--- a/crates/vespertide-query/src/sql/mod.rs
+++ b/crates/vespertide-query/src/sql/mod.rs
@@ -53,7 +53,13 @@ pub fn build_action_queries(
         }
 
         MigrationAction::DeleteColumn { table, column } => {
-            Ok(vec![build_delete_column(table, column)])
+            // Find the column type from current schema for enum DROP TYPE support
+            let column_type = current_schema
+                .iter()
+                .find(|t| t.name == *table)
+                .and_then(|t| t.columns.iter().find(|c| c.name == *column))
+                .map(|c| &c.r#type);
+            Ok(build_delete_column(table, column, column_type))
         }
 
         MigrationAction::ModifyColumnType {
@@ -333,9 +339,7 @@ mod tests {
     #[case::rename_column_postgres(DatabaseBackend::Postgres)]
     #[case::rename_column_mysql(DatabaseBackend::MySql)]
     #[case::rename_column_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_rename_column(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_rename_column(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::RenameColumn (lines 51-52)
         let action = MigrationAction::RenameColumn {
             table: "users".into(),
@@ -358,9 +362,7 @@ mod tests {
     #[case::delete_column_postgres(DatabaseBackend::Postgres)]
     #[case::delete_column_mysql(DatabaseBackend::MySql)]
     #[case::delete_column_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_delete_column(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_delete_column(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::DeleteColumn (lines 55-56)
         let action = MigrationAction::DeleteColumn {
             table: "users".into(),
@@ -381,9 +383,7 @@ mod tests {
     #[case::modify_column_type_postgres(DatabaseBackend::Postgres)]
     #[case::modify_column_type_mysql(DatabaseBackend::MySql)]
     #[case::modify_column_type_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_modify_column_type(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_modify_column_type(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::ModifyColumnType (lines 60-63)
         let action = MigrationAction::ModifyColumnType {
             table: "users".into(),
@@ -424,9 +424,7 @@ mod tests {
     #[case::remove_index_postgres(DatabaseBackend::Postgres)]
     #[case::remove_index_mysql(DatabaseBackend::MySql)]
     #[case::remove_index_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_remove_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_remove_index(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::RemoveIndex (line 67)
         let action = MigrationAction::RemoveIndex {
             table: "users".into(),
@@ -447,9 +445,7 @@ mod tests {
     #[case::rename_table_postgres(DatabaseBackend::Postgres)]
     #[case::rename_table_mysql(DatabaseBackend::MySql)]
     #[case::rename_table_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_rename_table(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_rename_table(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::RenameTable (line 69)
         let action = MigrationAction::RenameTable {
             from: "old_table".into(),
@@ -471,9 +467,7 @@ mod tests {
     #[case::add_constraint_postgres(DatabaseBackend::Postgres)]
     #[case::add_constraint_mysql(DatabaseBackend::MySql)]
     #[case::add_constraint_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_add_constraint(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_add_constraint(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::AddConstraint (lines 73-74)
         let action = MigrationAction::AddConstraint {
             table: "users".into(),
@@ -529,9 +523,7 @@ mod tests {
     #[case::remove_constraint_postgres(DatabaseBackend::Postgres)]
     #[case::remove_constraint_mysql(DatabaseBackend::MySql)]
     #[case::remove_constraint_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_remove_constraint(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_remove_constraint(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::RemoveConstraint (lines 77-78)
         let action = MigrationAction::RemoveConstraint {
             table: "users".into(),
@@ -590,9 +582,7 @@ mod tests {
     #[case::add_column_postgres(DatabaseBackend::Postgres)]
     #[case::add_column_mysql(DatabaseBackend::MySql)]
     #[case::add_column_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_add_column(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_add_column(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::AddColumn (lines 46-49)
         let action = MigrationAction::AddColumn {
             table: "users".into(),
@@ -644,9 +634,7 @@ mod tests {
     #[case::add_index_postgres(DatabaseBackend::Postgres)]
     #[case::add_index_mysql(DatabaseBackend::MySql)]
     #[case::add_index_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_add_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_add_index(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::AddIndex (line 65)
         let action = MigrationAction::AddIndex {
             table: "users".into(),
@@ -671,9 +659,7 @@ mod tests {
     #[case::raw_sql_postgres(DatabaseBackend::Postgres)]
     #[case::raw_sql_mysql(DatabaseBackend::MySql)]
     #[case::raw_sql_sqlite(DatabaseBackend::Sqlite)]
-    fn test_build_action_queries_raw_sql(
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_build_action_queries_raw_sql(#[case] backend: DatabaseBackend) {
         // Test MigrationAction::RawSql (line 71)
         let action = MigrationAction::RawSql {
             sql: "SELECT 1;".into(),
diff --git a/crates/vespertide-query/src/sql/modify_column_type.rs b/crates/vespertide-query/src/sql/modify_column_type.rs
index c291b6a..48a543c 100644
--- a/crates/vespertide-query/src/sql/modify_column_type.rs
+++ b/crates/vespertide-query/src/sql/modify_column_type.rs
@@ -1,9 +1,9 @@
 use sea_query::{Alias, ColumnDef as SeaColumnDef, Query, Table};
 
-use vespertide_core::{ColumnType, TableDef};
+use vespertide_core::{ColumnType, ComplexColumnType, TableDef};
 
 use super::create_table::build_create_table_for_backend;
-use super::helpers::apply_column_type;
+use super::helpers::{apply_column_type, build_create_enum_type_sql};
 use super::rename_table::build_rename_table;
 use super::types::{BuiltQuery, DatabaseBackend};
 use crate::error::QueryError;
@@ -100,14 +100,139 @@ pub fn build_modify_column_type(
         Ok(queries)
     } else {
         // PostgreSQL, MySQL, etc. can use ALTER TABLE directly
-        let mut col = SeaColumnDef::new(Alias::new(column));
-        apply_column_type(&mut col, new_type);
+        let mut queries = Vec::new();
 
-        let stmt = Table::alter()
-            .table(Alias::new(table))
-            .modify_column(col)
-            .to_owned();
-        Ok(vec![BuiltQuery::AlterTable(Box::new(stmt))])
+        // Get the old column type to check if we need special enum handling
+        let old_type = current_schema
+            .iter()
+            .find(|t| t.name == table)
+            .and_then(|t| t.columns.iter().find(|c| c.name == column))
+            .map(|c| &c.r#type);
+
+        // Check if this is an enum-to-enum migration that needs special handling (PostgreSQL only)
+        let needs_enum_migration = if *backend == DatabaseBackend::Postgres {
+            matches!(
+                (old_type, new_type),
+                (
+                    Some(ColumnType::Complex(ComplexColumnType::Enum { name: old_name, values: old_values })),
+                    ColumnType::Complex(ComplexColumnType::Enum { name: new_name, values: new_values })
+                ) if old_name == new_name && old_values != new_values
+            )
+        } else {
+            false
+        };
+
+        if needs_enum_migration {
+            // Use the safe temp type + USING + RENAME approach for enum value changes
+            if let (
+                Some(ColumnType::Complex(ComplexColumnType::Enum {
+                    name: enum_name, ..
+                })),
+                ColumnType::Complex(ComplexColumnType::Enum {
+                    values: new_values, ..
+                }),
+            ) = (old_type, new_type)
+            {
+                let temp_type_name = format!("{}_new", enum_name);
+
+                // 1. CREATE TYPE {enum}_new AS ENUM (new values)
+                let create_temp_values = new_values
+                    .iter()
+                    .map(|v| format!("'{}'", v.replace('\'', "''")))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                queries.push(BuiltQuery::Raw(super::types::RawSql::per_backend(
+                    format!(
+                        "CREATE TYPE \"{}\" AS ENUM ({})",
+                        temp_type_name, create_temp_values
+                    ),
+                    String::new(),
+                    String::new(),
+                )));
+
+                // 2. ALTER TABLE ... ALTER COLUMN ... TYPE {enum}_new USING {column}::text::{enum}_new
+                queries.push(BuiltQuery::Raw(super::types::RawSql::per_backend(
+                    format!(
+                        "ALTER TABLE \"{}\" ALTER COLUMN \"{}\" TYPE \"{}\" USING \"{}\"::text::\"{}\"",
+                        table, column, temp_type_name, column, temp_type_name
+                    ),
+                    String::new(),
+                    String::new(),
+                )));
+
+                // 3. DROP TYPE {enum}
+                queries.push(BuiltQuery::Raw(super::types::RawSql::per_backend(
+                    format!("DROP TYPE \"{}\"", enum_name),
+                    String::new(),
+                    String::new(),
+                )));
+
+                // 4. ALTER TYPE {enum}_new RENAME TO {enum}
+                queries.push(BuiltQuery::Raw(super::types::RawSql::per_backend(
+                    format!(
+                        "ALTER TYPE \"{}\" RENAME TO \"{}\"",
+                        temp_type_name, enum_name
+                    ),
+                    String::new(),
+                    String::new(),
+                )));
+            }
+        } else {
+            // Standard column type modification
+
+            // If new type is an enum and different from old, create the type first (PostgreSQL only)
+            if let ColumnType::Complex(ComplexColumnType::Enum { name: new_name, .. }) = new_type {
+                // Determine if we need to create a new enum type
+                // - If old type was a different enum, we need to create the new one
+                // - If old type was not an enum, we need to create the enum type
+                let should_create = if let Some(ColumnType::Complex(ComplexColumnType::Enum {
+                    name: old_name,
+                    ..
+                })) = old_type
+                {
+                    old_name != new_name
+                } else {
+                    // Either old_type is None or it wasn't an enum - need to create enum type
+                    true
+                };
+
+                if should_create && let Some(create_type_sql) = build_create_enum_type_sql(new_type)
+                {
+                    queries.push(BuiltQuery::Raw(create_type_sql));
+                }
+            }
+
+            let mut col = SeaColumnDef::new(Alias::new(column));
+            apply_column_type(&mut col, new_type);
+
+            let stmt = Table::alter()
+                .table(Alias::new(table))
+                .modify_column(col)
+                .to_owned();
+            queries.push(BuiltQuery::AlterTable(Box::new(stmt)));
+
+            // If old type was an enum and new type is different, drop the old enum type
+            if let Some(ColumnType::Complex(ComplexColumnType::Enum { name: old_name, .. })) =
+                old_type
+            {
+                let should_drop = match new_type {
+                    ColumnType::Complex(ComplexColumnType::Enum { name: new_name, .. }) => {
+                        old_name != new_name
+                    }
+                    _ => true, // New type is not an enum
+                };
+
+                if should_drop {
+                    queries.push(BuiltQuery::Raw(super::types::RawSql::per_backend(
+                        format!("DROP TYPE IF EXISTS \"{}\"", old_name),
+                        String::new(),
+                        String::new(),
+                    )));
+                }
+            }
+        }
+
+        Ok(queries)
     }
 }
 
@@ -202,23 +327,25 @@ mod tests {
     }
 
     #[test]
-    fn test_modify_column_type_sqlite_table_not_found() {
-        // Test error when table is not found in current schema (line 25)
+    fn test_modify_column_type_table_not_found() {
         let result = build_modify_column_type(
             &DatabaseBackend::Sqlite,
             "nonexistent_table",
             "age",
             &ColumnType::Simple(SimpleColumnType::BigInt),
-            &[], // Empty schema
+            &[],
         );
         assert!(result.is_err());
-        let err_msg = result.unwrap_err().to_string();
-        assert!(err_msg.contains("Table 'nonexistent_table' not found in current schema"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("Table 'nonexistent_table' not found")
+        );
     }
 
     #[test]
-    fn test_modify_column_type_sqlite_column_not_found() {
-        // Test error when column is not found in table (lines 35-37)
+    fn test_modify_column_type_column_not_found() {
         let current_schema = vec![TableDef {
             name: "users".into(),
             columns: vec![ColumnDef {
@@ -243,8 +370,12 @@ mod tests {
             &current_schema,
         );
         assert!(result.is_err());
-        let err_msg = result.unwrap_err().to_string();
-        assert!(err_msg.contains("Column 'nonexistent_column' not found in table 'users'"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("Column 'nonexistent_column' not found")
+        );
     }
 
     #[rstest]
@@ -260,10 +391,7 @@ mod tests {
         "modify_column_type_with_index_sqlite",
         DatabaseBackend::Sqlite
     )]
-    fn test_modify_column_type_with_index(
-        #[case] title: &str,
-        #[case] backend: DatabaseBackend,
-    ) {
+    fn test_modify_column_type_with_index(#[case] title: &str, #[case] backend: DatabaseBackend) {
         // Test modify column type with indexes (lines 85-88, 90-91, 93-94)
         use vespertide_core::IndexDef;
 
@@ -406,4 +534,236 @@ mod tests {
             assert_snapshot!(sql);
         });
     }
+
+    #[rstest]
+    #[case::enum_values_changed_postgres(
+        "enum_values_changed_postgres",
+        DatabaseBackend::Postgres,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into(), "pending".into()],
+        })
+    )]
+    #[case::enum_values_changed_mysql(
+        "enum_values_changed_mysql",
+        DatabaseBackend::MySql,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into(), "pending".into()],
+        })
+    )]
+    #[case::enum_values_changed_sqlite(
+        "enum_values_changed_sqlite",
+        DatabaseBackend::Sqlite,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into(), "pending".into()],
+        })
+    )]
+    #[case::enum_same_values_postgres(
+        "enum_same_values_postgres",
+        DatabaseBackend::Postgres,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::enum_same_values_mysql(
+        "enum_same_values_mysql",
+        DatabaseBackend::MySql,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::enum_same_values_sqlite(
+        "enum_same_values_sqlite",
+        DatabaseBackend::Sqlite,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::enum_name_changed_postgres(
+        "enum_name_changed_postgres",
+        DatabaseBackend::Postgres,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "old_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "new_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::enum_name_changed_mysql(
+        "enum_name_changed_mysql",
+        DatabaseBackend::MySql,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "old_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "new_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::enum_name_changed_sqlite(
+        "enum_name_changed_sqlite",
+        DatabaseBackend::Sqlite,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "old_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "new_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::text_to_enum_postgres(
+        "text_to_enum_postgres",
+        DatabaseBackend::Postgres,
+        ColumnType::Simple(SimpleColumnType::Text),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "user_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::text_to_enum_mysql(
+        "text_to_enum_mysql",
+        DatabaseBackend::MySql,
+        ColumnType::Simple(SimpleColumnType::Text),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "user_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::text_to_enum_sqlite(
+        "text_to_enum_sqlite",
+        DatabaseBackend::Sqlite,
+        ColumnType::Simple(SimpleColumnType::Text),
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "user_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        })
+    )]
+    #[case::enum_to_text_postgres(
+        "enum_to_text_postgres",
+        DatabaseBackend::Postgres,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "user_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Simple(SimpleColumnType::Text)
+    )]
+    #[case::enum_to_text_mysql(
+        "enum_to_text_mysql",
+        DatabaseBackend::MySql,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "user_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Simple(SimpleColumnType::Text)
+    )]
+    #[case::enum_to_text_sqlite(
+        "enum_to_text_sqlite",
+        DatabaseBackend::Sqlite,
+        ColumnType::Complex(ComplexColumnType::Enum {
+            name: "user_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        }),
+        ColumnType::Simple(SimpleColumnType::Text)
+    )]
+    fn test_modify_enum_types(
+        #[case] title: &str,
+        #[case] backend: DatabaseBackend,
+        #[case] old_type: ColumnType,
+        #[case] new_type: ColumnType,
+    ) {
+        let current_schema = vec![TableDef {
+            name: "users".into(),
+            columns: vec![ColumnDef {
+                name: "status".into(),
+                r#type: old_type,
+                nullable: true,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            }],
+            constraints: vec![],
+            indexes: vec![],
+        }];
+
+        let result =
+            build_modify_column_type(&backend, "users", "status", &new_type, &current_schema)
+                .unwrap();
+
+        let sql = result
+            .iter()
+            .map(|q| q.build(backend))
+            .collect::<Vec<_>>()
+            .join(";\n");
+
+        with_settings!({ snapshot_suffix => format!("modify_enum_types_{}", title) }, {
+            assert_snapshot!(sql);
+        });
+    }
+
+    #[test]
+    fn test_modify_column_type_to_enum_with_empty_schema() {
+        // Test the None branch in line 195-200
+        // When current_schema is empty, old_type will be None
+        use vespertide_core::ComplexColumnType;
+
+        let result = build_modify_column_type(
+            &DatabaseBackend::Postgres,
+            "users",
+            "status",
+            &ColumnType::Complex(ComplexColumnType::Enum {
+                name: "status_type".into(),
+                values: vec!["active".into(), "inactive".into()],
+            }),
+            &[], // Empty schema - old_type will be None
+        );
+
+        assert!(result.is_ok());
+        let queries = result.unwrap();
+        let sql = queries
+            .iter()
+            .map(|q| q.build(DatabaseBackend::Postgres))
+            .collect::<Vec<String>>()
+            .join(";\n");
+
+        // Should create the enum type since old_type is None
+        assert!(sql.contains("CREATE TYPE"));
+        assert!(sql.contains("status_type"));
+        assert!(sql.contains("ALTER TABLE"));
+    }
 }
diff --git a/crates/vespertide-query/src/sql/remove_constraint.rs b/crates/vespertide-query/src/sql/remove_constraint.rs
index bcf039a..1bf9b73 100644
--- a/crates/vespertide-query/src/sql/remove_constraint.rs
+++ b/crates/vespertide-query/src/sql/remove_constraint.rs
@@ -634,18 +634,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_primary_key_with_index_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_primary_key_with_index_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_primary_key_with_index_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_primary_key_with_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_primary_key_with_index_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_primary_key_with_index_mysql(DatabaseBackend::MySql)]
+    #[case::remove_primary_key_with_index_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_primary_key_with_index(#[case] backend: DatabaseBackend) {
         // Test PrimaryKey removal with indexes (lines 75-78, 83-84)
         use vespertide_core::IndexDef;
 
@@ -674,7 +666,8 @@ mod tests {
             }],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -692,18 +685,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_primary_key_with_unique_index_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_primary_key_with_unique_index_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_primary_key_with_unique_index_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_primary_key_with_unique_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_primary_key_with_unique_index_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_primary_key_with_unique_index_mysql(DatabaseBackend::MySql)]
+    #[case::remove_primary_key_with_unique_index_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_primary_key_with_unique_index(#[case] backend: DatabaseBackend) {
         // Test PrimaryKey removal with unique index (lines 75-78, 80-81, 83-84)
         use vespertide_core::IndexDef;
 
@@ -732,7 +717,8 @@ mod tests {
             }],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -768,18 +754,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_unique_without_name_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_unique_without_name_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_unique_without_name_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_unique_without_name(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_unique_without_name_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_unique_without_name_mysql(DatabaseBackend::MySql)]
+    #[case::remove_unique_without_name_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_unique_without_name(#[case] backend: DatabaseBackend) {
         // Test Unique removal without name (lines 134, 137, 210)
         let constraint = TableConstraint::Unique {
             name: None,
@@ -815,7 +793,8 @@ mod tests {
             indexes: vec![],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -833,18 +812,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_unique_with_index_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_unique_with_index_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_unique_with_index_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_unique_with_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_unique_with_index_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_unique_with_index_mysql(DatabaseBackend::MySql)]
+    #[case::remove_unique_with_index_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_unique_with_index(#[case] backend: DatabaseBackend) {
         // Test Unique removal with indexes (lines 185-188, 193-194)
         use vespertide_core::IndexDef;
 
@@ -886,7 +857,8 @@ mod tests {
             }],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -904,18 +876,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_unique_with_unique_index_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_unique_with_unique_index_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_unique_with_unique_index_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_unique_with_unique_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_unique_with_unique_index_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_unique_with_unique_index_mysql(DatabaseBackend::MySql)]
+    #[case::remove_unique_with_unique_index_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_unique_with_unique_index(#[case] backend: DatabaseBackend) {
         // Test Unique removal with unique index (lines 185-188, 190-191, 193-194)
         use vespertide_core::IndexDef;
 
@@ -957,7 +921,8 @@ mod tests {
             }],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -997,18 +962,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_foreign_key_without_name_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_foreign_key_without_name_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_foreign_key_without_name_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_foreign_key_without_name(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_foreign_key_without_name_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_foreign_key_without_name_mysql(DatabaseBackend::MySql)]
+    #[case::remove_foreign_key_without_name_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_foreign_key_without_name(#[case] backend: DatabaseBackend) {
         // Test ForeignKey removal without name (lines 260, 263, 329)
         let constraint = TableConstraint::ForeignKey {
             name: None,
@@ -1048,7 +1005,8 @@ mod tests {
             indexes: vec![],
         }];
 
-        let result = build_remove_constraint(&backend, "posts", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "posts", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -1066,18 +1024,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_foreign_key_with_index_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_foreign_key_with_index_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_foreign_key_with_index_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_foreign_key_with_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_foreign_key_with_index_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_foreign_key_with_index_mysql(DatabaseBackend::MySql)]
+    #[case::remove_foreign_key_with_index_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_foreign_key_with_index(#[case] backend: DatabaseBackend) {
         // Test ForeignKey removal with indexes (lines 309-312, 317-318)
         use vespertide_core::IndexDef;
 
@@ -1123,7 +1073,8 @@ mod tests {
             }],
         }];
 
-        let result = build_remove_constraint(&backend, "posts", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "posts", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -1141,18 +1092,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_foreign_key_with_unique_index_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_foreign_key_with_unique_index_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_foreign_key_with_unique_index_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_foreign_key_with_unique_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_foreign_key_with_unique_index_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_foreign_key_with_unique_index_mysql(DatabaseBackend::MySql)]
+    #[case::remove_foreign_key_with_unique_index_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_foreign_key_with_unique_index(#[case] backend: DatabaseBackend) {
         // Test ForeignKey removal with unique index (lines 309-312, 314-315, 317-318)
         use vespertide_core::IndexDef;
 
@@ -1198,7 +1141,8 @@ mod tests {
             }],
         }];
 
-        let result = build_remove_constraint(&backend, "posts", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "posts", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -1234,18 +1178,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_check_with_index_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_check_with_index_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_check_with_index_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_check_with_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_check_with_index_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_check_with_index_mysql(DatabaseBackend::MySql)]
+    #[case::remove_check_with_index_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_check_with_index(#[case] backend: DatabaseBackend) {
         // Test Check removal with indexes (lines 402-405, 410-411)
         use vespertide_core::IndexDef;
 
@@ -1287,7 +1223,8 @@ mod tests {
             }],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -1305,18 +1242,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_check_with_unique_index_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_check_with_unique_index_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_check_with_unique_index_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_check_with_unique_index(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_check_with_unique_index_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_check_with_unique_index_mysql(DatabaseBackend::MySql)]
+    #[case::remove_check_with_unique_index_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_check_with_unique_index(#[case] backend: DatabaseBackend) {
         // Test Check removal with unique index (lines 402-405, 407-408, 410-411)
         use vespertide_core::IndexDef;
 
@@ -1358,7 +1287,8 @@ mod tests {
             }],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -1376,18 +1306,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_unique_with_other_constraints_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_unique_with_other_constraints_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_unique_with_other_constraints_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_unique_with_other_constraints(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_unique_with_other_constraints_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_unique_with_other_constraints_mysql(DatabaseBackend::MySql)]
+    #[case::remove_unique_with_other_constraints_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_unique_with_other_constraints(#[case] backend: DatabaseBackend) {
         // Test Unique removal with other constraint types (line 137)
         let constraint = TableConstraint::Unique {
             name: Some("uq_email".into()),
@@ -1433,7 +1355,8 @@ mod tests {
             indexes: vec![],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -1449,18 +1372,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_foreign_key_with_other_constraints_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_foreign_key_with_other_constraints_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_foreign_key_with_other_constraints_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_foreign_key_with_other_constraints(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_foreign_key_with_other_constraints_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_foreign_key_with_other_constraints_mysql(DatabaseBackend::MySql)]
+    #[case::remove_foreign_key_with_other_constraints_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_foreign_key_with_other_constraints(#[case] backend: DatabaseBackend) {
         // Test ForeignKey removal with other constraint types (line 263)
         let constraint = TableConstraint::ForeignKey {
             name: Some("fk_user".into()),
@@ -1514,7 +1429,8 @@ mod tests {
             indexes: vec![],
         }];
 
-        let result = build_remove_constraint(&backend, "posts", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "posts", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
@@ -1530,18 +1446,10 @@ mod tests {
     }
 
     #[rstest]
-    #[case::remove_check_with_other_constraints_postgres(
-        DatabaseBackend::Postgres
-    )]
-    #[case::remove_check_with_other_constraints_mysql(
-        DatabaseBackend::MySql
-    )]
-    #[case::remove_check_with_other_constraints_sqlite(
-        DatabaseBackend::Sqlite
-    )]
-    fn test_remove_constraint_check_with_other_constraints(
-        #[case] backend: DatabaseBackend,
-    ) {
+    #[case::remove_check_with_other_constraints_postgres(DatabaseBackend::Postgres)]
+    #[case::remove_check_with_other_constraints_mysql(DatabaseBackend::MySql)]
+    #[case::remove_check_with_other_constraints_sqlite(DatabaseBackend::Sqlite)]
+    fn test_remove_constraint_check_with_other_constraints(#[case] backend: DatabaseBackend) {
         // Test Check removal with other constraint types (line 357)
         let constraint = TableConstraint::Check {
             name: "chk_age".into(),
@@ -1587,7 +1495,8 @@ mod tests {
             indexes: vec![],
         }];
 
-        let result = build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
+        let result =
+            build_remove_constraint(&backend, "users", &constraint, &current_schema).unwrap();
         let sql = result
             .iter()
             .map(|q| q.build(backend))
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_MySql.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_MySql.snap
new file mode 100644
index 0000000..c0eac35
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_MySql.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/add_column.rs
+expression: sql
+---
+;
+ALTER TABLE `users` ADD COLUMN `status` ENUM('active', 'inactive')
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Postgres.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Postgres.snap
new file mode 100644
index 0000000..779b019
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Postgres.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/add_column.rs
+expression: sql
+---
+CREATE TYPE "status_type" AS ENUM ('active', 'inactive');
+ALTER TABLE "users" ADD COLUMN "status" status_type
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Sqlite.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Sqlite.snap
new file mode 100644
index 0000000..3636fee
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Sqlite.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/add_column.rs
+expression: sql
+---
+;
+ALTER TABLE "users" ADD COLUMN "status" enum_text
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_MySql.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_MySql.snap
new file mode 100644
index 0000000..c7b1fd8
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_MySql.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/create_table.rs
+expression: sql
+---
+;
+CREATE TABLE `users` ( `id` int NOT NULL, `status` ENUM('active', 'inactive', 'pending') NOT NULL DEFAULT 'active', PRIMARY KEY (`id`) )
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Postgres.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Postgres.snap
new file mode 100644
index 0000000..cdaeea8
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Postgres.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/create_table.rs
+expression: sql
+---
+CREATE TYPE "user_status" AS ENUM ('active', 'inactive', 'pending');
+CREATE TABLE "users" ( "id" integer NOT NULL, "status" user_status NOT NULL DEFAULT 'active', PRIMARY KEY ("id") )
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Sqlite.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Sqlite.snap
new file mode 100644
index 0000000..c930924
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Sqlite.snap
@@ -0,0 +1,6 @@
+---
+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") )
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_mysql.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_mysql.snap
new file mode 100644
index 0000000..4179df4
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_mysql.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+;
+ALTER TABLE `users` MODIFY COLUMN `status` ENUM('active', 'inactive');
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_postgres.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_postgres.snap
new file mode 100644
index 0000000..1d15b02
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_postgres.snap
@@ -0,0 +1,7 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+CREATE TYPE "new_status" AS ENUM ('active', 'inactive');
+ALTER TABLE "users" ALTER COLUMN "status" TYPE new_status;
+DROP TYPE IF EXISTS "old_status"
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_sqlite.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_sqlite.snap
new file mode 100644
index 0000000..edd151e
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_sqlite.snap
@@ -0,0 +1,8 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+CREATE TABLE "users_temp" ( "status" enum_text );
+INSERT INTO "users_temp" ("status") SELECT "status" FROM "users";
+DROP TABLE "users";
+ALTER TABLE "users_temp" RENAME TO "users"
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_mysql.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_mysql.snap
new file mode 100644
index 0000000..610b221
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_mysql.snap
@@ -0,0 +1,5 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+ALTER TABLE `users` MODIFY COLUMN `status` ENUM('active', 'inactive')
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_postgres.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_postgres.snap
new file mode 100644
index 0000000..c13f674
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_postgres.snap
@@ -0,0 +1,5 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+ALTER TABLE "users" ALTER COLUMN "status" TYPE status
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_sqlite.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_sqlite.snap
new file mode 100644
index 0000000..edd151e
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_sqlite.snap
@@ -0,0 +1,8 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+CREATE TABLE "users_temp" ( "status" enum_text );
+INSERT INTO "users_temp" ("status") SELECT "status" FROM "users";
+DROP TABLE "users";
+ALTER TABLE "users_temp" RENAME TO "users"
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_mysql.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_mysql.snap
new file mode 100644
index 0000000..39872f7
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_mysql.snap
@@ -0,0 +1,5 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+ALTER TABLE `users` MODIFY COLUMN `status` text;
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_postgres.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_postgres.snap
new file mode 100644
index 0000000..cc1af40
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_postgres.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+ALTER TABLE "users" ALTER COLUMN "status" TYPE text;
+DROP TYPE IF EXISTS "user_status"
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_sqlite.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_sqlite.snap
new file mode 100644
index 0000000..b3f2ca0
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_sqlite.snap
@@ -0,0 +1,8 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+CREATE TABLE "users_temp" ( "status" text );
+INSERT INTO "users_temp" ("status") SELECT "status" FROM "users";
+DROP TABLE "users";
+ALTER TABLE "users_temp" RENAME TO "users"
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_mysql.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_mysql.snap
new file mode 100644
index 0000000..4925759
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_mysql.snap
@@ -0,0 +1,5 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+ALTER TABLE `users` MODIFY COLUMN `status` ENUM('active', 'inactive', 'pending')
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_postgres.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_postgres.snap
new file mode 100644
index 0000000..cc7060c
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_postgres.snap
@@ -0,0 +1,8 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+CREATE TYPE "status_new" AS ENUM ('active', 'inactive', 'pending');
+ALTER TABLE "users" ALTER COLUMN "status" TYPE "status_new" USING "status"::text::"status_new";
+DROP TYPE "status";
+ALTER TYPE "status_new" RENAME TO "status"
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_sqlite.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_sqlite.snap
new file mode 100644
index 0000000..edd151e
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_sqlite.snap
@@ -0,0 +1,8 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+CREATE TABLE "users_temp" ( "status" enum_text );
+INSERT INTO "users_temp" ("status") SELECT "status" FROM "users";
+DROP TABLE "users";
+ALTER TABLE "users_temp" RENAME TO "users"
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_mysql.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_mysql.snap
new file mode 100644
index 0000000..cd5181a
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_mysql.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+;
+ALTER TABLE `users` MODIFY COLUMN `status` ENUM('active', 'inactive')
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_postgres.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_postgres.snap
new file mode 100644
index 0000000..1cbd184
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_postgres.snap
@@ -0,0 +1,6 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+CREATE TYPE "user_status" AS ENUM ('active', 'inactive');
+ALTER TABLE "users" ALTER COLUMN "status" TYPE user_status
diff --git a/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_sqlite.snap b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_sqlite.snap
new file mode 100644
index 0000000..edd151e
--- /dev/null
+++ b/crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_sqlite.snap
@@ -0,0 +1,8 @@
+---
+source: crates/vespertide-query/src/sql/modify_column_type.rs
+expression: sql
+---
+CREATE TABLE "users_temp" ( "status" enum_text );
+INSERT INTO "users_temp" ("status") SELECT "status" FROM "users";
+DROP TABLE "users";
+ALTER TABLE "users_temp" RENAME TO "users"
diff --git a/crates/vespertide-query/tests/enum_migration_test.rs b/crates/vespertide-query/tests/enum_migration_test.rs
new file mode 100644
index 0000000..97ef8a1
--- /dev/null
+++ b/crates/vespertide-query/tests/enum_migration_test.rs
@@ -0,0 +1,117 @@
+use vespertide_core::schema::primary_key::PrimaryKeySyntax;
+use vespertide_core::{
+    ColumnDef, ColumnType, ComplexColumnType, MigrationAction, MigrationPlan, SimpleColumnType,
+    TableDef,
+};
+use vespertide_query::{DatabaseBackend, build_plan_queries};
+
+#[test]
+fn test_enum_value_change_generates_correct_sql() {
+    // Simulate migration 0003: changing enum from ["active", "inactive"] to ["active", "inactive", "pending"]
+    let plan = MigrationPlan {
+        comment: Some("Fix enum".into()),
+        created_at: Some("2025-12-17T07:57:14Z".into()),
+        version: 3,
+        actions: vec![MigrationAction::ModifyColumnType {
+            table: "user".into(),
+            column: "status".into(),
+            new_type: ColumnType::Complex(ComplexColumnType::Enum {
+                name: "status".into(),
+                values: vec!["active".into(), "inactive".into(), "pending".into()],
+            }),
+        }],
+    };
+
+    // Baseline schema after migration 0002 (with 2-value enum)
+    let baseline_schema = vec![TableDef {
+        name: "user".into(),
+        columns: vec![
+            ColumnDef {
+                name: "id".into(),
+                r#type: ColumnType::Simple(SimpleColumnType::Uuid),
+                nullable: false,
+                default: Some("gen_random_uuid()".into()),
+                comment: None,
+                primary_key: Some(PrimaryKeySyntax::Bool(true)),
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+            ColumnDef {
+                name: "status".into(),
+                r#type: ColumnType::Complex(ComplexColumnType::Enum {
+                    name: "status".into(),
+                    values: vec!["active".into(), "inactive".into()],
+                }),
+                nullable: true,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: None,
+            },
+        ],
+        constraints: vec![],
+        indexes: vec![],
+    }];
+
+    let queries = build_plan_queries(&plan, &baseline_schema).unwrap();
+
+    assert_eq!(queries.len(), 1, "Should have 1 action");
+
+    let postgres_queries = &queries[0].postgres;
+    println!("\n=== PostgreSQL SQL for enum migration ===");
+    for (i, q) in postgres_queries.iter().enumerate() {
+        let sql = q.build(DatabaseBackend::Postgres);
+        println!("{}: {}", i + 1, sql);
+    }
+
+    // Should have 4 queries for the temp type approach
+    assert_eq!(
+        postgres_queries.len(),
+        4,
+        "Should generate 4 SQL statements for enum value change"
+    );
+
+    let sql0 = postgres_queries[0].build(DatabaseBackend::Postgres);
+    let sql1 = postgres_queries[1].build(DatabaseBackend::Postgres);
+    let sql2 = postgres_queries[2].build(DatabaseBackend::Postgres);
+    let sql3 = postgres_queries[3].build(DatabaseBackend::Postgres);
+
+    // 1. CREATE TYPE status_new
+    assert!(
+        sql0.contains("CREATE TYPE \"status_new\""),
+        "Step 1 should create temp type"
+    );
+    assert!(
+        sql0.contains("'active', 'inactive', 'pending'"),
+        "Should include all 3 enum values"
+    );
+
+    // 2. ALTER TABLE with USING
+    assert!(
+        sql1.contains("ALTER TABLE \"user\""),
+        "Step 2 should alter table"
+    );
+    assert!(
+        sql1.contains("ALTER COLUMN \"status\" TYPE \"status_new\""),
+        "Should change column type to temp"
+    );
+    assert!(
+        sql1.contains("USING \"status\"::text::\"status_new\""),
+        "Should use USING clause"
+    );
+
+    // 3. DROP TYPE status
+    assert!(
+        sql2.contains("DROP TYPE \"status\""),
+        "Step 3 should drop old type"
+    );
+
+    // 4. RENAME TYPE
+    assert!(
+        sql3.contains("ALTER TYPE \"status_new\" RENAME TO \"status\""),
+        "Step 4 should rename temp type back"
+    );
+}
diff --git a/examples/app/migrations/0001_init.json b/examples/app/migrations/0001_init.json
index 8afd78e..24c3d2d 100644
--- a/examples/app/migrations/0001_init.json
+++ b/examples/app/migrations/0001_init.json
@@ -18,36 +18,28 @@
           "comment": null,
           "default": null,
           "foreign_key": null,
-          "index": null,
-          "name": "title",
+          "index": true,
+          "name": "email",
           "nullable": false,
           "primary_key": null,
           "type": {
             "kind": "varchar",
-            "length": 500
+            "length": 255
           },
-          "unique": null
+          "unique": true
         },
         {
           "comment": null,
           "default": null,
           "foreign_key": null,
           "index": null,
-          "name": "content",
+          "name": "password",
           "nullable": false,
           "primary_key": null,
-          "type": "text",
-          "unique": null
-        },
-        {
-          "comment": null,
-          "default": null,
-          "foreign_key": null,
-          "index": null,
-          "name": "summary",
-          "nullable": true,
-          "primary_key": null,
-          "type": "text",
+          "type": {
+            "kind": "varchar",
+            "length": 255
+          },
           "unique": null
         },
         {
@@ -55,41 +47,12 @@
           "default": null,
           "foreign_key": null,
           "index": null,
-          "name": "thumbnail",
-          "nullable": true,
-          "primary_key": null,
-          "type": "text",
-          "unique": null
-        },
-        {
-          "comment": null,
-          "default": null,
-          "foreign_key": {
-            "on_delete": "cascade",
-            "on_update": null,
-            "ref_columns": [
-              "id"
-            ],
-            "ref_table": "media"
-          },
-          "index": true,
-          "name": "media_id",
-          "nullable": false,
-          "primary_key": null,
-          "type": "uuid",
-          "unique": null
-        },
-        {
-          "comment": null,
-          "default": "'draft'",
-          "foreign_key": null,
-          "index": true,
-          "name": "status",
+          "name": "name",
           "nullable": false,
           "primary_key": null,
           "type": {
             "kind": "varchar",
-            "length": 20
+            "length": 100
           },
           "unique": null
         },
@@ -97,11 +60,11 @@
           "comment": null,
           "default": null,
           "foreign_key": null,
-          "index": true,
-          "name": "published_at",
+          "index": null,
+          "name": "profile_image",
           "nullable": true,
           "primary_key": null,
-          "type": "timestamptz",
+          "type": "text",
           "unique": null
         },
         {
@@ -128,11 +91,6 @@
         }
       ],
       "constraints": [
-        {
-          "expr": "status IN ('draft', 'review', 'published', 'archived')",
-          "name": "chk_article_status",
-          "type": "check"
-        },
         {
           "auto_increment": false,
           "columns": [
@@ -142,188 +100,24 @@
         },
         {
           "columns": [
-            "media_id"
-          ],
-          "name": null,
-          "on_delete": "cascade",
-          "on_update": null,
-          "ref_columns": [
-            "id"
-          ],
-          "ref_table": "media",
-          "type": "foreign_key"
-        }
-      ],
-      "table": "article",
-      "type": "create_table"
-    },
-    {
-      "index": {
-        "columns": [
-          "media_id"
-        ],
-        "name": "idx_article_media_id",
-        "unique": false
-      },
-      "table": "article",
-      "type": "add_index"
-    },
-    {
-      "index": {
-        "columns": [
-          "status"
-        ],
-        "name": "idx_article_status",
-        "unique": false
-      },
-      "table": "article",
-      "type": "add_index"
-    },
-    {
-      "index": {
-        "columns": [
-          "published_at"
-        ],
-        "name": "idx_article_published_at",
-        "unique": false
-      },
-      "table": "article",
-      "type": "add_index"
-    },
-    {
-      "columns": [
-        {
-          "comment": null,
-          "default": null,
-          "foreign_key": {
-            "on_delete": "cascade",
-            "on_update": null,
-            "ref_columns": [
-              "id"
-            ],
-            "ref_table": "article"
-          },
-          "index": true,
-          "name": "article_id",
-          "nullable": false,
-          "primary_key": true,
-          "type": "uuid",
-          "unique": null
-        },
-        {
-          "comment": null,
-          "default": null,
-          "foreign_key": {
-            "on_delete": "cascade",
-            "on_update": null,
-            "ref_columns": [
-              "id"
-            ],
-            "ref_table": "user"
-          },
-          "index": true,
-          "name": "user_id",
-          "nullable": false,
-          "primary_key": true,
-          "type": "uuid",
-          "unique": null
-        },
-        {
-          "comment": null,
-          "default": "1",
-          "foreign_key": null,
-          "index": null,
-          "name": "author_order",
-          "nullable": false,
-          "primary_key": null,
-          "type": "integer",
-          "unique": null
-        },
-        {
-          "comment": null,
-          "default": "'contributor'",
-          "foreign_key": null,
-          "index": null,
-          "name": "role",
-          "nullable": false,
-          "primary_key": null,
-          "type": {
-            "kind": "varchar",
-            "length": 20
-          },
-          "unique": null
-        },
-        {
-          "comment": null,
-          "default": "now()",
-          "foreign_key": null,
-          "index": null,
-          "name": "created_at",
-          "nullable": false,
-          "primary_key": null,
-          "type": "timestamptz",
-          "unique": null
-        }
-      ],
-      "constraints": [
-        {
-          "auto_increment": false,
-          "columns": [
-            "article_id",
-            "user_id"
-          ],
-          "type": "primary_key"
-        },
-        {
-          "columns": [
-            "article_id"
-          ],
-          "name": null,
-          "on_delete": "cascade",
-          "on_update": null,
-          "ref_columns": [
-            "id"
-          ],
-          "ref_table": "article",
-          "type": "foreign_key"
-        },
-        {
-          "columns": [
-            "user_id"
+            "email"
           ],
           "name": null,
-          "on_delete": "cascade",
-          "on_update": null,
-          "ref_columns": [
-            "id"
-          ],
-          "ref_table": "user",
-          "type": "foreign_key"
+          "type": "unique"
         }
       ],
-      "table": "article_user",
+      "table": "user",
       "type": "create_table"
     },
     {
       "index": {
         "columns": [
-          "article_id"
-        ],
-        "name": "idx_article_user_article_id",
-        "unique": false
-      },
-      "table": "article_user",
-      "type": "add_index"
-    },
-    {
-      "index": {
-        "columns": [
-          "user_id"
+          "email"
         ],
-        "name": "idx_article_user_user_id",
+        "name": "idx_user_email",
         "unique": false
       },
-      "table": "article_user",
+      "table": "user",
       "type": "add_index"
     },
     {
@@ -469,28 +263,25 @@
           "comment": null,
           "default": null,
           "foreign_key": null,
-          "index": true,
-          "name": "email",
+          "index": null,
+          "name": "title",
           "nullable": false,
           "primary_key": null,
           "type": {
             "kind": "varchar",
-            "length": 255
+            "length": 499
           },
-          "unique": true
+          "unique": null
         },
         {
           "comment": null,
           "default": null,
           "foreign_key": null,
           "index": null,
-          "name": "password",
+          "name": "content",
           "nullable": false,
           "primary_key": null,
-          "type": {
-            "kind": "varchar",
-            "length": 255
-          },
+          "type": "text",
           "unique": null
         },
         {
@@ -498,12 +289,52 @@
           "default": null,
           "foreign_key": null,
           "index": null,
-          "name": "name",
+          "name": "summary",
+          "nullable": true,
+          "primary_key": null,
+          "type": "text",
+          "unique": null
+        },
+        {
+          "comment": null,
+          "default": null,
+          "foreign_key": null,
+          "index": null,
+          "name": "thumbnail",
+          "nullable": true,
+          "primary_key": null,
+          "type": "text",
+          "unique": null
+        },
+        {
+          "comment": null,
+          "default": null,
+          "foreign_key": {
+            "on_delete": "cascade",
+            "on_update": null,
+            "ref_columns": [
+              "id"
+            ],
+            "ref_table": "media"
+          },
+          "index": true,
+          "name": "media_id",
+          "nullable": false,
+          "primary_key": null,
+          "type": "uuid",
+          "unique": null
+        },
+        {
+          "comment": null,
+          "default": "'draft'",
+          "foreign_key": null,
+          "index": true,
+          "name": "status",
           "nullable": false,
           "primary_key": null,
           "type": {
             "kind": "varchar",
-            "length": 100
+            "length": 19
           },
           "unique": null
         },
@@ -511,11 +342,11 @@
           "comment": null,
           "default": null,
           "foreign_key": null,
-          "index": null,
-          "name": "profile_image",
+          "index": true,
+          "name": "published_at",
           "nullable": true,
           "primary_key": null,
-          "type": "text",
+          "type": "timestamptz",
           "unique": null
         },
         {
@@ -542,6 +373,11 @@
         }
       ],
       "constraints": [
+        {
+          "expr": "status IN ('draft', 'review', 'published', 'archived')",
+          "name": "chk_article_status",
+          "type": "check"
+        },
         {
           "auto_increment": false,
           "columns": [
@@ -551,24 +387,52 @@
         },
         {
           "columns": [
-            "email"
+            "media_id"
           ],
           "name": null,
-          "type": "unique"
+          "on_delete": "cascade",
+          "on_update": null,
+          "ref_columns": [
+            "id"
+          ],
+          "ref_table": "media",
+          "type": "foreign_key"
         }
       ],
-      "table": "user",
+      "table": "article",
       "type": "create_table"
     },
     {
       "index": {
         "columns": [
-          "email"
+          "media_id"
         ],
-        "name": "idx_user_email",
+        "name": "idx_article_media_id",
         "unique": false
       },
-      "table": "user",
+      "table": "article",
+      "type": "add_index"
+    },
+    {
+      "index": {
+        "columns": [
+          "status"
+        ],
+        "name": "idx_article_status",
+        "unique": false
+      },
+      "table": "article",
+      "type": "add_index"
+    },
+    {
+      "index": {
+        "columns": [
+          "published_at"
+        ],
+        "name": "idx_article_published_at",
+        "unique": false
+      },
+      "table": "article",
       "type": "add_index"
     },
     {
@@ -706,9 +570,145 @@
       },
       "table": "user_media_role",
       "type": "add_index"
+    },
+    {
+      "columns": [
+        {
+          "comment": null,
+          "default": null,
+          "foreign_key": {
+            "on_delete": "cascade",
+            "on_update": null,
+            "ref_columns": [
+              "id"
+            ],
+            "ref_table": "article"
+          },
+          "index": true,
+          "name": "article_id",
+          "nullable": false,
+          "primary_key": true,
+          "type": "uuid",
+          "unique": null
+        },
+        {
+          "comment": null,
+          "default": null,
+          "foreign_key": {
+            "on_delete": "cascade",
+            "on_update": null,
+            "ref_columns": [
+              "id"
+            ],
+            "ref_table": "user"
+          },
+          "index": true,
+          "name": "user_id",
+          "nullable": false,
+          "primary_key": true,
+          "type": "uuid",
+          "unique": null
+        },
+        {
+          "comment": null,
+          "default": "1",
+          "foreign_key": null,
+          "index": null,
+          "name": "author_order",
+          "nullable": false,
+          "primary_key": null,
+          "type": "integer",
+          "unique": null
+        },
+        {
+          "comment": null,
+          "default": "'contributor'",
+          "foreign_key": null,
+          "index": null,
+          "name": "role",
+          "nullable": false,
+          "primary_key": null,
+          "type": {
+            "kind": "varchar",
+            "length": 20
+          },
+          "unique": null
+        },
+        {
+          "comment": null,
+          "default": "now()",
+          "foreign_key": null,
+          "index": null,
+          "name": "created_at",
+          "nullable": false,
+          "primary_key": null,
+          "type": "timestamptz",
+          "unique": null
+        }
+      ],
+      "constraints": [
+        {
+          "auto_increment": false,
+          "columns": [
+            "article_id",
+            "user_id"
+          ],
+          "type": "primary_key"
+        },
+        {
+          "columns": [
+            "article_id"
+          ],
+          "name": null,
+          "on_delete": "cascade",
+          "on_update": null,
+          "ref_columns": [
+            "id"
+          ],
+          "ref_table": "article",
+          "type": "foreign_key"
+        },
+        {
+          "columns": [
+            "user_id"
+          ],
+          "name": null,
+          "on_delete": "cascade",
+          "on_update": null,
+          "ref_columns": [
+            "id"
+          ],
+          "ref_table": "user",
+          "type": "foreign_key"
+        }
+      ],
+      "table": "article_user",
+      "type": "create_table"
+    },
+    {
+      "index": {
+        "columns": [
+          "article_id"
+        ],
+        "name": "idx_article_user_article_id",
+        "unique": false
+      },
+      "table": "article_user",
+      "type": "add_index"
+    },
+    {
+      "index": {
+        "columns": [
+          "user_id"
+        ],
+        "name": "idx_article_user_user_id",
+        "unique": false
+      },
+      "table": "article_user",
+      "type": "add_index"
     }
   ],
   "comment": "init",
-  "created_at": "2025-12-15T14:08:11Z",
+  "created_at": "2025-12-17T05:37:33Z",
   "version": 1
 }
\ No newline at end of file
diff --git a/examples/app/migrations/0002_add_enum.json b/examples/app/migrations/0002_add_enum.json
new file mode 100644
index 0000000..6bd130b
--- /dev/null
+++ b/examples/app/migrations/0002_add_enum.json
@@ -0,0 +1,31 @@
+{
+  "$schema": "https://raw.githubusercontent.com/dev-five-git/vespertide/refs/heads/main/schemas/migration.schema.json",
+  "actions": [
+    {
+      "column": {
+        "comment": null,
+        "default": null,
+        "foreign_key": null,
+        "index": null,
+        "name": "status",
+        "nullable": true,
+        "primary_key": null,
+        "type": {
+          "kind": "enum",
+          "name": "status",
+          "values": [
+            "active",
+            "inactive"
+          ]
+        },
+        "unique": null
+      },
+      "fill_with": null,
+      "table": "user",
+      "type": "add_column"
+    }
+  ],
+  "comment": "Add enum",
+  "created_at": "2025-12-17T07:03:38Z",
+  "version": 2
+}
\ No newline at end of file
diff --git a/examples/app/migrations/0003_fix_enum.json b/examples/app/migrations/0003_fix_enum.json
new file mode 100644
index 0000000..dd0f9d6
--- /dev/null
+++ b/examples/app/migrations/0003_fix_enum.json
@@ -0,0 +1,22 @@
+{
+  "$schema": "https://raw.githubusercontent.com/dev-five-git/vespertide/refs/heads/main/schemas/migration.schema.json",
+  "actions": [
+    {
+      "column": "status",
+      "new_type": {
+        "kind": "enum",
+        "name": "status",
+        "values": [
+          "active",
+          "inactive",
+          "pending"
+        ]
+      },
+      "table": "user",
+      "type": "modify_column_type"
+    }
+  ],
+  "comment": "Fix enum",
+  "created_at": "2025-12-17T08:43:19Z",
+  "version": 3
+}
\ No newline at end of file
diff --git a/examples/app/models/article.json b/examples/app/models/article.json
index 2099518..96c9ac8 100644
--- a/examples/app/models/article.json
+++ b/examples/app/models/article.json
@@ -1,76 +1,76 @@
-{
-  "$schema": "https://raw.githubusercontent.com/dev-five-git/vespertide/refs/heads/main/schemas/model.schema.json",
-  "name": "article",
-  "columns": [
-    {
-      "name": "id",
-      "type": "uuid",
-      "nullable": false,
-      "default": "gen_random_uuid()",
-      "primary_key": true
-    },
-    {
-      "name": "title",
-      "type": { "kind": "varchar", "length": 499 },
-      "nullable": false
-    },
-    {
-      "name": "content",
-      "type": "text",
-      "nullable": false
-    },
-    {
-      "name": "summary",
-      "type": "text",
-      "nullable": true
-    },
-    {
-      "name": "thumbnail",
-      "type": "text",
-      "nullable": true
-    },
-    {
-      "name": "media_id",
-      "type": "uuid",
-      "nullable": false,
-      "foreign_key": {
-        "ref_table": "media",
-        "ref_columns": ["id"],
-        "on_delete": "cascade"
-      },
-      "index": true
-    },
-    {
-      "name": "status",
-      "type": { "kind": "varchar", "length": 19 },
-      "nullable": false,
-      "default": "'draft'",
-      "index": true
-    },
-    {
-      "name": "published_at",
-      "type": "timestamptz",
-      "nullable": true,
-      "index": true
-    },
-    {
-      "name": "created_at",
-      "type": "timestamptz",
-      "nullable": false,
-      "default": "now()"
-    },
-    {
-      "name": "updated_at",
-      "type": "timestamptz",
-      "nullable": true
-    }
-  ],
-  "constraints": [
-    {
-      "type": "check",
-      "name": "chk_article_status",
-      "expr": "status IN ('draft', 'review', 'published', 'archived')"
-    }
-  ],
-  "indexes": []
-}
+{
+  "$schema": "https://raw.githubusercontent.com/dev-five-git/vespertide/refs/heads/main/schemas/model.schema.json",
+  "name": "article",
+  "columns": [
+    {
+      "name": "id",
+      "type": "uuid",
+      "nullable": false,
+      "default": "gen_random_uuid()",
+      "primary_key": true
+    },
+    {
+      "name": "title",
+      "type": { "kind": "varchar", "length": 499 },
+      "nullable": false
+    },
+    {
+      "name": "content",
+      "type": "text",
+      "nullable": false
+    },
+    {
+      "name": "summary",
+      "type": "text",
+      "nullable": true
+    },
+    {
+      "name": "thumbnail",
+      "type": "text",
+      "nullable": true
+    },
+    {
+      "name": "media_id",
+      "type": "uuid",
+      "nullable": false,
+      "foreign_key": {
+        "ref_table": "media",
+        "ref_columns": ["id"],
+        "on_delete": "cascade"
+      },
+      "index": true
+    },
+    {
+      "name": "status",
+      "type": { "kind": "varchar", "length": 19 },
+      "nullable": false,
+      "default": "'draft'",
+      "index": true
+    },
+    {
+      "name": "published_at",
+      "type": "timestamptz",
+      "nullable": true,
+      "index": true
+    },
+    {
+      "name": "created_at",
+      "type": "timestamptz",
+      "nullable": false,
+      "default": "now()"
+    },
+    {
+      "name": "updated_at",
+      "type": "timestamptz",
+      "nullable": true
+    }
+  ],
+  "constraints": [
+    {
+      "type": "check",
+      "name": "chk_article_status",
+      "expr": "status IN ('draft', 'review', 'published', 'archived')"
+    }
+  ],
+  "indexes": []
+}
diff --git a/examples/app/models/user.json b/examples/app/models/user.json
index 7221fb1..452dee6 100644
--- a/examples/app/models/user.json
+++ b/examples/app/models/user.json
@@ -41,6 +41,11 @@
       "name": "updated_at",
       "type": "timestamptz",
       "nullable": true
+    },
+    {
+      "name": "status",
+      "type": { "kind": "enum", "name": "status", "values": ["active", "inactive", "pending"] },
+      "nullable": true
     }
   ],
   "constraints": [],
diff --git a/examples/app/src/main.rs b/examples/app/src/main.rs
index bc9619b..acfa29c 100644
--- a/examples/app/src/main.rs
+++ b/examples/app/src/main.rs
@@ -1,28 +1,28 @@
-use anyhow::Result;
-use sea_orm::{ConnectOptions, Database};
-use std::time::Duration;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    println!("Hello, world!");
-
-    // let mut opt = ConnectOptions::new("postgres://postgres:password@localhost:5432/postgres");
-    // Configure SQLite connection
-    let mut opt = ConnectOptions::new("sqlite://./local.db");
-    opt.max_connections(100)
-        .min_connections(5)
-        .connect_timeout(Duration::from_secs(8))
-        .acquire_timeout(Duration::from_secs(8))
-        .idle_timeout(Duration::from_secs(8))
-        .max_lifetime(Duration::from_secs(8))
-        .sqlx_logging(false); // Disable SQLx logging
-
-    // Connect to the database
-    let db = Database::connect(opt).await?;
-
-    println!("Successfully connected to SQLite database!");
-
-    vespertide::vespertide_migration!(db, version_table = "vespertide_version").await?;
-
-    Ok(())
-}
+use anyhow::Result;
+use sea_orm::{ConnectOptions, Database};
+use std::time::Duration;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    println!("Hello, world!");
+
+    let mut opt = ConnectOptions::new("postgres://postgres:password@localhost:5432/postgres");
+    // Configure SQLite connection
+    // let mut opt = ConnectOptions::new("sqlite://./local.db");
+    opt.max_connections(100)
+        .min_connections(5)
+        .connect_timeout(Duration::from_secs(8))
+        .acquire_timeout(Duration::from_secs(8))
+        .idle_timeout(Duration::from_secs(8))
+        .max_lifetime(Duration::from_secs(8))
+        .sqlx_logging(false); // Disable SQLx logging
+
+    // Connect to the database
+    let db = Database::connect(opt).await?;
+
+    println!("Successfully connected to SQLite database!");
+
+    vespertide::vespertide_migration!(db, version_table = "vespertide_version").await?;
+
+    Ok(())
+}