From 0464fd302cabe46463a9447d82aafa7676939dda Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 15:16:26 +0900
Subject: [PATCH 01/11] Impl sort mig

---
 crates/vespertide-core/src/schema/column.rs   |  532 ++---
 crates/vespertide-exporter/src/seaorm/mod.rs  |  320 ++-
 ...napshots@params_enum_multiple_columns.snap |   39 +
 ...entity_snapshots@params_enum_nullable.snap |   29 +
 ...r_entity_snapshots@params_enum_shared.snap |   28 +
 ..._snapshots@params_enum_special_values.snap |   29 +
 ...der_entity_snapshots@params_enum_type.snap |   27 +
 crates/vespertide-planner/src/diff.rs         | 2085 ++++++++++-------
 crates/vespertide-query/src/sql/helpers.rs    |    7 +
 crates/vespertide-query/src/sql/mod.rs        |   40 +-
 .../src/sql/modify_column_type.rs             |    5 +-
 .../src/sql/remove_constraint.rs              |  247 +-
 examples/app/migrations/0001_init.json        |  494 ++--
 examples/app/src/main.rs                      |   56 +-
 14 files changed, 2351 insertions(+), 1587 deletions(-)
 create mode 100644 crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_multiple_columns.snap
 create mode 100644 crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_nullable.snap
 create mode 100644 crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_shared.snap
 create mode 100644 crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_special_values.snap
 create mode 100644 crates/vespertide-exporter/src/seaorm/snapshots/vespertide_exporter__seaorm__tests__render_entity_snapshots@params_enum_type.snap

diff --git a/crates/vespertide-core/src/schema/column.rs b/crates/vespertide-core/src/schema/column.rs
index 8173f5bd..23fd5a3b 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-exporter/src/seaorm/mod.rs b/crates/vespertide-exporter/src/seaorm/mod.rs
index e95d9b13..7c84e169 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 00000000..e05fdcac
--- /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 00000000..e4c41cad
--- /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 00000000..34ed6be0
--- /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 00000000..88493e58
--- /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 00000000..0f48299e
--- /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-planner/src/diff.rs b/crates/vespertide-planner/src/diff.rs
index f5a450a9..f02a58b4 100644
--- a/crates/vespertide-planner/src/diff.rs
+++ b/crates/vespertide-planner/src/diff.rs
@@ -1,801 +1,1284 @@
-use std::collections::HashMap;
-
-use vespertide_core::{MigrationAction, MigrationPlan, TableDef};
-
-use crate::error::PlannerError;
-
-/// 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.
-pub fn diff_schemas(from: &[TableDef], to: &[TableDef]) -> Result<MigrationPlan, PlannerError> {
-    let mut actions: Vec<MigrationAction> = Vec::new();
-
-    // Normalize both schemas to ensure inline constraints are converted to table-level
-    let from_normalized: Vec<TableDef> = from
-        .iter()
-        .map(|t| {
-            t.normalize().map_err(|e| {
-                PlannerError::TableValidation(format!(
-                    "Failed to normalize table '{}': {}",
-                    t.name, e
-                ))
-            })
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-    let to_normalized: Vec<TableDef> = to
-        .iter()
-        .map(|t| {
-            t.normalize().map_err(|e| {
-                PlannerError::TableValidation(format!(
-                    "Failed to normalize table '{}': {}",
-                    t.name, e
-                ))
-            })
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-
-    let from_map: HashMap<_, _> = from_normalized
-        .iter()
-        .map(|t| (t.name.as_str(), t))
-        .collect();
-    let to_map: HashMap<_, _> = to_normalized.iter().map(|t| (t.name.as_str(), t)).collect();
-
-    // Drop tables that disappeared.
-    for name in from_map.keys() {
-        if !to_map.contains_key(name) {
-            actions.push(MigrationAction::DeleteTable {
-                table: (*name).to_string(),
-            });
-        }
-    }
-
-    // Update existing tables and their indexes/columns.
-    for (name, to_tbl) in &to_map {
-        if let Some(from_tbl) = from_map.get(name) {
-            // Columns
-            let from_cols: HashMap<_, _> = from_tbl
-                .columns
-                .iter()
-                .map(|c| (c.name.as_str(), c))
-                .collect();
-            let to_cols: HashMap<_, _> = to_tbl
-                .columns
-                .iter()
-                .map(|c| (c.name.as_str(), c))
-                .collect();
-
-            // Deleted columns
-            for col in from_cols.keys() {
-                if !to_cols.contains_key(col) {
-                    actions.push(MigrationAction::DeleteColumn {
-                        table: (*name).to_string(),
-                        column: (*col).to_string(),
-                    });
-                }
-            }
-
-            // Modified columns
-            for (col, to_def) in &to_cols {
-                if let Some(from_def) = from_cols.get(col)
-                    && from_def.r#type != to_def.r#type
-                {
-                    actions.push(MigrationAction::ModifyColumnType {
-                        table: (*name).to_string(),
-                        column: (*col).to_string(),
-                        new_type: to_def.r#type.clone(),
-                    });
-                }
-            }
-
-            // Added columns
-            // Note: Inline foreign keys are already converted to TableConstraint::ForeignKey
-            // by normalize(), so they will be handled in the constraint diff below.
-            for (col, def) in &to_cols {
-                if !from_cols.contains_key(col) {
-                    actions.push(MigrationAction::AddColumn {
-                        table: (*name).to_string(),
-                        column: (*def).clone(),
-                        fill_with: None,
-                    });
-                }
-            }
-
-            // Indexes
-            let from_indexes: HashMap<_, _> = from_tbl
-                .indexes
-                .iter()
-                .map(|i| (i.name.as_str(), i))
-                .collect();
-            let to_indexes: HashMap<_, _> = to_tbl
-                .indexes
-                .iter()
-                .map(|i| (i.name.as_str(), i))
-                .collect();
-
-            for idx in from_indexes.keys() {
-                if !to_indexes.contains_key(idx) {
-                    actions.push(MigrationAction::RemoveIndex {
-                        table: (*name).to_string(),
-                        name: (*idx).to_string(),
-                    });
-                }
-            }
-            for (idx, def) in &to_indexes {
-                if !from_indexes.contains_key(idx) {
-                    actions.push(MigrationAction::AddIndex {
-                        table: (*name).to_string(),
-                        index: (*def).clone(),
-                    });
-                }
-            }
-
-            // Constraints - compare and detect additions/removals
-            for from_constraint in &from_tbl.constraints {
-                if !to_tbl.constraints.contains(from_constraint) {
-                    actions.push(MigrationAction::RemoveConstraint {
-                        table: (*name).to_string(),
-                        constraint: from_constraint.clone(),
-                    });
-                }
-            }
-            for to_constraint in &to_tbl.constraints {
-                if !from_tbl.constraints.contains(to_constraint) {
-                    actions.push(MigrationAction::AddConstraint {
-                        table: (*name).to_string(),
-                        constraint: to_constraint.clone(),
-                    });
-                }
-            }
-        }
-    }
-
-    // Create new tables (and their indexes).
-    for (name, tbl) in &to_map {
-        if !from_map.contains_key(name) {
-            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(),
-                    index: idx.clone(),
-                });
-            }
-        }
-    }
-
-    Ok(MigrationPlan {
-        comment: None,
-        created_at: None,
-        version: 0,
-        actions,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rstest::rstest;
-    use vespertide_core::{ColumnDef, ColumnType, IndexDef, 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<IndexDef>,
-    ) -> TableDef {
-        TableDef {
-            name: name.to_string(),
-            columns,
-            constraints,
-            indexes,
-        }
-    }
-
-    #[rstest]
-    #[case::add_column_and_index(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![table(
-            "users",
-            vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col("name", ColumnType::Simple(SimpleColumnType::Text)),
-            ],
-            vec![],
-            vec![IndexDef {
-                name: "idx_users_name".into(),
-                columns: vec!["name".into()],
-                unique: false,
-            }],
-        )],
-        vec![
-            MigrationAction::AddColumn {
-                table: "users".into(),
-                column: col("name", ColumnType::Simple(SimpleColumnType::Text)),
-                fill_with: None,
-            },
-            MigrationAction::AddIndex {
-                table: "users".into(),
-                index: IndexDef {
-                    name: "idx_users_name".into(),
-                    columns: vec!["name".into()],
-                    unique: false,
-                },
-            },
-        ]
-    )]
-    #[case::drop_table(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![],
-        vec![MigrationAction::DeleteTable {
-            table: "users".into()
-        }]
-    )]
-    #[case::add_table(
-        vec![],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![IndexDef {
-                name: "idx_users_id".into(),
-                columns: vec!["id".into()],
-                unique: true,
-            }],
-        )],
-        vec![
-            MigrationAction::CreateTable {
-                table: "users".into(),
-                columns: vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-                constraints: vec![],
-            },
-            MigrationAction::AddIndex {
-                table: "users".into(),
-                index: IndexDef {
-                    name: "idx_users_id".into(),
-                    columns: vec!["id".into()],
-                    unique: true,
-                },
-            },
-        ]
-    )]
-    #[case::delete_column(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer)), col("name", ColumnType::Simple(SimpleColumnType::Text))],
-            vec![],
-            vec![],
-        )],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![MigrationAction::DeleteColumn {
-            table: "users".into(),
-            column: "name".into(),
-        }]
-    )]
-    #[case::modify_column_type(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Text))],
-            vec![],
-            vec![],
-        )],
-        vec![MigrationAction::ModifyColumnType {
-            table: "users".into(),
-            column: "id".into(),
-            new_type: ColumnType::Simple(SimpleColumnType::Text),
-        }]
-    )]
-    #[case::remove_index(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![IndexDef {
-                name: "idx_users_id".into(),
-                columns: vec!["id".into()],
-                unique: false,
-            }],
-        )],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![MigrationAction::RemoveIndex {
-            table: "users".into(),
-            name: "idx_users_id".into(),
-        }]
-    )]
-    #[case::add_index_existing_table(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![IndexDef {
-                name: "idx_users_id".into(),
-                columns: vec!["id".into()],
-                unique: true,
-            }],
-        )],
-        vec![MigrationAction::AddIndex {
-            table: "users".into(),
-            index: IndexDef {
-                name: "idx_users_id".into(),
-                columns: vec!["id".into()],
-                unique: true,
-            },
-        }]
-    )]
-    fn diff_schemas_detects_additions(
-        #[case] from_schema: Vec<TableDef>,
-        #[case] to_schema: Vec<TableDef>,
-        #[case] expected_actions: Vec<MigrationAction>,
-    ) {
-        let plan = diff_schemas(&from_schema, &to_schema).unwrap();
-        assert_eq!(plan.actions, expected_actions);
-    }
-
-    // Tests for inline column constraints normalization
-    mod inline_constraints {
-        use super::*;
-        use vespertide_core::schema::foreign_key::ForeignKeyDef;
-        use vespertide_core::schema::foreign_key::ForeignKeySyntax;
-        use vespertide_core::schema::primary_key::PrimaryKeySyntax;
-        use vespertide_core::{StrOrBoolOrArray, TableConstraint};
-
-        fn col_with_pk(name: &str, ty: ColumnType) -> ColumnDef {
-            ColumnDef {
-                name: name.to_string(),
-                r#type: ty,
-                nullable: false,
-                default: None,
-                comment: None,
-                primary_key: Some(PrimaryKeySyntax::Bool(true)),
-                unique: None,
-                index: None,
-                foreign_key: None,
-            }
-        }
-
-        fn col_with_unique(name: &str, ty: ColumnType) -> ColumnDef {
-            ColumnDef {
-                name: name.to_string(),
-                r#type: ty,
-                nullable: true,
-                default: None,
-                comment: None,
-                primary_key: None,
-                unique: Some(StrOrBoolOrArray::Bool(true)),
-                index: None,
-                foreign_key: None,
-            }
-        }
-
-        fn col_with_index(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: Some(StrOrBoolOrArray::Bool(true)),
-                foreign_key: None,
-            }
-        }
-
-        fn col_with_fk(name: &str, ty: ColumnType, ref_table: &str, ref_col: &str) -> ColumnDef {
-            ColumnDef {
-                name: name.to_string(),
-                r#type: ty,
-                nullable: true,
-                default: None,
-                comment: None,
-                primary_key: None,
-                unique: None,
-                index: None,
-                foreign_key: Some(ForeignKeySyntax::Object(ForeignKeyDef {
-                    ref_table: ref_table.to_string(),
-                    ref_columns: vec![ref_col.to_string()],
-                    on_delete: None,
-                    on_update: None,
-                })),
-            }
-        }
-
-        #[test]
-        fn create_table_with_inline_pk() {
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "users",
-                    vec![
-                        col_with_pk("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
-                assert_eq!(constraints.len(), 1);
-                assert!(matches!(
-                    &constraints[0],
-                    TableConstraint::PrimaryKey { columns, .. } if columns == &["id".to_string()]
-                ));
-            } else {
-                panic!("Expected CreateTable action");
-            }
-        }
-
-        #[test]
-        fn create_table_with_inline_unique() {
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "users",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col_with_unique("email", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
-                assert_eq!(constraints.len(), 1);
-                assert!(matches!(
-                    &constraints[0],
-                    TableConstraint::Unique { name: None, columns } if columns == &["email".to_string()]
-                ));
-            } else {
-                panic!("Expected CreateTable action");
-            }
-        }
-
-        #[test]
-        fn create_table_with_inline_index() {
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "users",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col_with_index("name", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            // Should have CreateTable + AddIndex
-            assert_eq!(plan.actions.len(), 2);
-            assert!(matches!(
-                &plan.actions[0],
-                MigrationAction::CreateTable { .. }
-            ));
-            if let MigrationAction::AddIndex { index, .. } = &plan.actions[1] {
-                assert_eq!(index.name, "idx_users_name");
-                assert_eq!(index.columns, vec!["name".to_string()]);
-            } else {
-                panic!("Expected AddIndex action");
-            }
-        }
-
-        #[test]
-        fn create_table_with_inline_fk() {
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "posts",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col_with_fk(
-                            "user_id",
-                            ColumnType::Simple(SimpleColumnType::Integer),
-                            "users",
-                            "id",
-                        ),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
-                assert_eq!(constraints.len(), 1);
-                assert!(matches!(
-                    &constraints[0],
-                    TableConstraint::ForeignKey { columns, ref_table, ref_columns, .. }
-                        if columns == &["user_id".to_string()]
-                        && ref_table == "users"
-                        && ref_columns == &["id".to_string()]
-                ));
-            } else {
-                panic!("Expected CreateTable action");
-            }
-        }
-
-        #[test]
-        fn add_index_via_inline_constraint() {
-            // Existing table without index -> table with inline index
-            let plan = diff_schemas(
-                &[table(
-                    "users",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-                &[table(
-                    "users",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col_with_index("name", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::AddIndex { table, index } = &plan.actions[0] {
-                assert_eq!(table, "users");
-                assert_eq!(index.name, "idx_users_name");
-                assert_eq!(index.columns, vec!["name".to_string()]);
-            } else {
-                panic!("Expected AddIndex action, got {:?}", plan.actions[0]);
-            }
-        }
-
-        #[test]
-        fn create_table_with_all_inline_constraints() {
-            let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
-            id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
-            id_col.nullable = false;
-
-            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 org_id_col = col("org_id", ColumnType::Simple(SimpleColumnType::Integer));
-            org_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
-                ref_table: "orgs".into(),
-                ref_columns: vec!["id".into()],
-                on_delete: None,
-                on_update: None,
-            }));
-
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "users",
-                    vec![id_col, email_col, name_col, org_id_col],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            // Should have CreateTable + AddIndex
-            assert_eq!(plan.actions.len(), 2);
-
-            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
-                // Should have: PrimaryKey, Unique, ForeignKey (3 constraints)
-                assert_eq!(constraints.len(), 3);
-            } else {
-                panic!("Expected CreateTable action");
-            }
-
-            // Check for AddIndex action
-            assert!(matches!(&plan.actions[1], MigrationAction::AddIndex { .. }));
-        }
-
-        #[test]
-        fn add_constraint_to_existing_table() {
-            // Add a unique constraint to an existing table
-            let from_schema = vec![table(
-                "users",
-                vec![
-                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
-                ],
-                vec![],
-                vec![],
-            )];
-
-            let to_schema = vec![table(
-                "users",
-                vec![
-                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
-                ],
-                vec![vespertide_core::TableConstraint::Unique {
-                    name: Some("uq_users_email".into()),
-                    columns: vec!["email".into()],
-                }],
-                vec![],
-            )];
-
-            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::AddConstraint { table, constraint } = &plan.actions[0] {
-                assert_eq!(table, "users");
-                assert!(matches!(
-                    constraint,
-                    vespertide_core::TableConstraint::Unique { name: Some(n), columns }
-                        if n == "uq_users_email" && columns == &vec!["email".to_string()]
-                ));
-            } else {
-                panic!("Expected AddConstraint action, got {:?}", plan.actions[0]);
-            }
-        }
-
-        #[test]
-        fn remove_constraint_from_existing_table() {
-            // Remove a unique constraint from an existing table
-            let from_schema = vec![table(
-                "users",
-                vec![
-                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
-                ],
-                vec![vespertide_core::TableConstraint::Unique {
-                    name: Some("uq_users_email".into()),
-                    columns: vec!["email".into()],
-                }],
-                vec![],
-            )];
-
-            let to_schema = vec![table(
-                "users",
-                vec![
-                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
-                ],
-                vec![],
-                vec![],
-            )];
-
-            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::RemoveConstraint { table, constraint } = &plan.actions[0] {
-                assert_eq!(table, "users");
-                assert!(matches!(
-                    constraint,
-                    vespertide_core::TableConstraint::Unique { name: Some(n), columns }
-                        if n == "uq_users_email" && columns == &vec!["email".to_string()]
-                ));
-            } else {
-                panic!(
-                    "Expected RemoveConstraint action, got {:?}",
-                    plan.actions[0]
-                );
-            }
-        }
-
-        #[test]
-        fn diff_schemas_with_normalize_error() {
-            // Test that normalize errors are properly propagated
-            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 - should error
-                        let mut c = col1.clone();
-                        c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
-                        c
-                    },
-                ],
-                constraints: vec![],
-                indexes: vec![],
-            };
-
-            let result = diff_schemas(&[], &[table]);
-            assert!(result.is_err());
-            if let Err(PlannerError::TableValidation(msg)) = result {
-                assert!(msg.contains("Failed to normalize table"));
-                assert!(msg.contains("Duplicate index"));
-            } else {
-                panic!("Expected TableValidation error, got {:?}", result);
-            }
-        }
-
-        #[test]
-        fn diff_schemas_with_normalize_error_in_from_schema() {
-            // Test that normalize errors in 'from' schema are properly propagated
-            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 - should error
-                        let mut c = col1.clone();
-                        c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
-                        c
-                    },
-                ],
-                constraints: vec![],
-                indexes: vec![],
-            };
-
-            // 'from' schema has the invalid table
-            let result = diff_schemas(&[table], &[]);
-            assert!(result.is_err());
-            if let Err(PlannerError::TableValidation(msg)) = result {
-                assert!(msg.contains("Failed to normalize table"));
-                assert!(msg.contains("Duplicate index"));
-            } else {
-                panic!("Expected TableValidation error, got {:?}", result);
-            }
-        }
-    }
-}
+use std::collections::{HashMap, HashSet, VecDeque};
+
+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.
+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_tables: Vec<&str> = delete_indices
+        .iter()
+        .filter_map(|&i| {
+            if let MigrationAction::DeleteTable { table } = &actions[i] {
+                Some(table.as_str())
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // Build dependency graph for tables being deleted
+    let mut dependencies: HashMap<&str, Vec<&str>> = HashMap::new();
+    for &table_name in &delete_tables {
+        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_tables.contains(&ref_table.as_str())
+                    && ref_table != table_name
+                {
+                    deps.push(ref_table.as_str());
+                }
+            }
+        }
+        dependencies.insert(table_name, deps);
+    }
+
+    // Sort: tables that depend on others should be deleted first
+    // (reverse topological order)
+    let mut sorted_tables = delete_tables.clone();
+    sorted_tables.sort_by(|a, b| {
+        let a_depends_on_b = dependencies.get(a).is_some_and(|deps| deps.contains(b));
+        let b_depends_on_a = dependencies.get(b).is_some_and(|deps| deps.contains(a));
+
+        if a_depends_on_b {
+            std::cmp::Ordering::Less // a depends on b, so delete a first
+        } else if b_depends_on_a {
+            std::cmp::Ordering::Greater // b depends on a, so delete b first
+        } else {
+            std::cmp::Ordering::Equal
+        }
+    });
+
+    // Reorder the DeleteTable actions in place
+    let mut delete_actions: Vec<MigrationAction> = delete_indices
+        .iter()
+        .map(|&i| actions[i].clone())
+        .collect();
+
+    // Sort delete_actions according to sorted_tables order
+    delete_actions.sort_by(|a, b| {
+        let a_name = if let MigrationAction::DeleteTable { table } = a {
+            table.as_str()
+        } else {
+            ""
+        };
+        let b_name = if let MigrationAction::DeleteTable { table } = b {
+            table.as_str()
+        } else {
+            ""
+        };
+
+        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.
+pub fn diff_schemas(from: &[TableDef], to: &[TableDef]) -> Result<MigrationPlan, PlannerError> {
+    let mut actions: Vec<MigrationAction> = Vec::new();
+
+    // Normalize both schemas to ensure inline constraints are converted to table-level
+    let from_normalized: Vec<TableDef> = from
+        .iter()
+        .map(|t| {
+            t.normalize().map_err(|e| {
+                PlannerError::TableValidation(format!(
+                    "Failed to normalize table '{}': {}",
+                    t.name, e
+                ))
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let to_normalized: Vec<TableDef> = to
+        .iter()
+        .map(|t| {
+            t.normalize().map_err(|e| {
+                PlannerError::TableValidation(format!(
+                    "Failed to normalize table '{}': {}",
+                    t.name, e
+                ))
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let from_map: HashMap<_, _> = from_normalized
+        .iter()
+        .map(|t| (t.name.as_str(), t))
+        .collect();
+    let to_map: HashMap<_, _> = to_normalized.iter().map(|t| (t.name.as_str(), t)).collect();
+
+    // Drop tables that disappeared.
+    for name in from_map.keys() {
+        if !to_map.contains_key(name) {
+            actions.push(MigrationAction::DeleteTable {
+                table: (*name).to_string(),
+            });
+        }
+    }
+
+    // Update existing tables and their indexes/columns.
+    for (name, to_tbl) in &to_map {
+        if let Some(from_tbl) = from_map.get(name) {
+            // Columns
+            let from_cols: HashMap<_, _> = from_tbl
+                .columns
+                .iter()
+                .map(|c| (c.name.as_str(), c))
+                .collect();
+            let to_cols: HashMap<_, _> = to_tbl
+                .columns
+                .iter()
+                .map(|c| (c.name.as_str(), c))
+                .collect();
+
+            // Deleted columns
+            for col in from_cols.keys() {
+                if !to_cols.contains_key(col) {
+                    actions.push(MigrationAction::DeleteColumn {
+                        table: (*name).to_string(),
+                        column: (*col).to_string(),
+                    });
+                }
+            }
+
+            // Modified columns
+            for (col, to_def) in &to_cols {
+                if let Some(from_def) = from_cols.get(col)
+                    && from_def.r#type != to_def.r#type
+                {
+                    actions.push(MigrationAction::ModifyColumnType {
+                        table: (*name).to_string(),
+                        column: (*col).to_string(),
+                        new_type: to_def.r#type.clone(),
+                    });
+                }
+            }
+
+            // Added columns
+            // Note: Inline foreign keys are already converted to TableConstraint::ForeignKey
+            // by normalize(), so they will be handled in the constraint diff below.
+            for (col, def) in &to_cols {
+                if !from_cols.contains_key(col) {
+                    actions.push(MigrationAction::AddColumn {
+                        table: (*name).to_string(),
+                        column: (*def).clone(),
+                        fill_with: None,
+                    });
+                }
+            }
+
+            // Indexes
+            let from_indexes: HashMap<_, _> = from_tbl
+                .indexes
+                .iter()
+                .map(|i| (i.name.as_str(), i))
+                .collect();
+            let to_indexes: HashMap<_, _> = to_tbl
+                .indexes
+                .iter()
+                .map(|i| (i.name.as_str(), i))
+                .collect();
+
+            for idx in from_indexes.keys() {
+                if !to_indexes.contains_key(idx) {
+                    actions.push(MigrationAction::RemoveIndex {
+                        table: (*name).to_string(),
+                        name: (*idx).to_string(),
+                    });
+                }
+            }
+            for (idx, def) in &to_indexes {
+                if !from_indexes.contains_key(idx) {
+                    actions.push(MigrationAction::AddIndex {
+                        table: (*name).to_string(),
+                        index: (*def).clone(),
+                    });
+                }
+            }
+
+            // Constraints - compare and detect additions/removals
+            for from_constraint in &from_tbl.constraints {
+                if !to_tbl.constraints.contains(from_constraint) {
+                    actions.push(MigrationAction::RemoveConstraint {
+                        table: (*name).to_string(),
+                        constraint: from_constraint.clone(),
+                    });
+                }
+            }
+            for to_constraint in &to_tbl.constraints {
+                if !from_tbl.constraints.contains(to_constraint) {
+                    actions.push(MigrationAction::AddConstraint {
+                        table: (*name).to_string(),
+                        constraint: to_constraint.clone(),
+                    });
+                }
+            }
+        }
+    }
+
+    // Create new tables (and their indexes).
+    // 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(),
+                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,
+        version: 0,
+        actions,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rstest::rstest;
+    use vespertide_core::{ColumnDef, ColumnType, IndexDef, 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<IndexDef>,
+    ) -> TableDef {
+        TableDef {
+            name: name.to_string(),
+            columns,
+            constraints,
+            indexes,
+        }
+    }
+
+    #[rstest]
+    #[case::add_column_and_index(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![table(
+            "users",
+            vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col("name", ColumnType::Simple(SimpleColumnType::Text)),
+            ],
+            vec![],
+            vec![IndexDef {
+                name: "idx_users_name".into(),
+                columns: vec!["name".into()],
+                unique: false,
+            }],
+        )],
+        vec![
+            MigrationAction::AddColumn {
+                table: "users".into(),
+                column: col("name", ColumnType::Simple(SimpleColumnType::Text)),
+                fill_with: None,
+            },
+            MigrationAction::AddIndex {
+                table: "users".into(),
+                index: IndexDef {
+                    name: "idx_users_name".into(),
+                    columns: vec!["name".into()],
+                    unique: false,
+                },
+            },
+        ]
+    )]
+    #[case::drop_table(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![],
+        vec![MigrationAction::DeleteTable {
+            table: "users".into()
+        }]
+    )]
+    #[case::add_table(
+        vec![],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![IndexDef {
+                name: "idx_users_id".into(),
+                columns: vec!["id".into()],
+                unique: true,
+            }],
+        )],
+        vec![
+            MigrationAction::CreateTable {
+                table: "users".into(),
+                columns: vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+                constraints: vec![],
+            },
+            MigrationAction::AddIndex {
+                table: "users".into(),
+                index: IndexDef {
+                    name: "idx_users_id".into(),
+                    columns: vec!["id".into()],
+                    unique: true,
+                },
+            },
+        ]
+    )]
+    #[case::delete_column(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer)), col("name", ColumnType::Simple(SimpleColumnType::Text))],
+            vec![],
+            vec![],
+        )],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![MigrationAction::DeleteColumn {
+            table: "users".into(),
+            column: "name".into(),
+        }]
+    )]
+    #[case::modify_column_type(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Text))],
+            vec![],
+            vec![],
+        )],
+        vec![MigrationAction::ModifyColumnType {
+            table: "users".into(),
+            column: "id".into(),
+            new_type: ColumnType::Simple(SimpleColumnType::Text),
+        }]
+    )]
+    #[case::remove_index(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![IndexDef {
+                name: "idx_users_id".into(),
+                columns: vec!["id".into()],
+                unique: false,
+            }],
+        )],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![MigrationAction::RemoveIndex {
+            table: "users".into(),
+            name: "idx_users_id".into(),
+        }]
+    )]
+    #[case::add_index_existing_table(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![IndexDef {
+                name: "idx_users_id".into(),
+                columns: vec!["id".into()],
+                unique: true,
+            }],
+        )],
+        vec![MigrationAction::AddIndex {
+            table: "users".into(),
+            index: IndexDef {
+                name: "idx_users_id".into(),
+                columns: vec!["id".into()],
+                unique: true,
+            },
+        }]
+    )]
+    fn diff_schemas_detects_additions(
+        #[case] from_schema: Vec<TableDef>,
+        #[case] to_schema: Vec<TableDef>,
+        #[case] expected_actions: Vec<MigrationAction>,
+    ) {
+        let plan = diff_schemas(&from_schema, &to_schema).unwrap();
+        assert_eq!(plan.actions, expected_actions);
+    }
+
+    // Tests for inline column constraints normalization
+    mod inline_constraints {
+        use super::*;
+        use vespertide_core::schema::foreign_key::ForeignKeyDef;
+        use vespertide_core::schema::foreign_key::ForeignKeySyntax;
+        use vespertide_core::schema::primary_key::PrimaryKeySyntax;
+        use vespertide_core::{StrOrBoolOrArray, TableConstraint};
+
+        fn col_with_pk(name: &str, ty: ColumnType) -> ColumnDef {
+            ColumnDef {
+                name: name.to_string(),
+                r#type: ty,
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: Some(PrimaryKeySyntax::Bool(true)),
+                unique: None,
+                index: None,
+                foreign_key: None,
+            }
+        }
+
+        fn col_with_unique(name: &str, ty: ColumnType) -> ColumnDef {
+            ColumnDef {
+                name: name.to_string(),
+                r#type: ty,
+                nullable: true,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: Some(StrOrBoolOrArray::Bool(true)),
+                index: None,
+                foreign_key: None,
+            }
+        }
+
+        fn col_with_index(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: Some(StrOrBoolOrArray::Bool(true)),
+                foreign_key: None,
+            }
+        }
+
+        fn col_with_fk(name: &str, ty: ColumnType, ref_table: &str, ref_col: &str) -> ColumnDef {
+            ColumnDef {
+                name: name.to_string(),
+                r#type: ty,
+                nullable: true,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: Some(ForeignKeySyntax::Object(ForeignKeyDef {
+                    ref_table: ref_table.to_string(),
+                    ref_columns: vec![ref_col.to_string()],
+                    on_delete: None,
+                    on_update: None,
+                })),
+            }
+        }
+
+        #[test]
+        fn create_table_with_inline_pk() {
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "users",
+                    vec![
+                        col_with_pk("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
+                assert_eq!(constraints.len(), 1);
+                assert!(matches!(
+                    &constraints[0],
+                    TableConstraint::PrimaryKey { columns, .. } if columns == &["id".to_string()]
+                ));
+            } else {
+                panic!("Expected CreateTable action");
+            }
+        }
+
+        #[test]
+        fn create_table_with_inline_unique() {
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_unique("email", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
+                assert_eq!(constraints.len(), 1);
+                assert!(matches!(
+                    &constraints[0],
+                    TableConstraint::Unique { name: None, columns } if columns == &["email".to_string()]
+                ));
+            } else {
+                panic!("Expected CreateTable action");
+            }
+        }
+
+        #[test]
+        fn create_table_with_inline_index() {
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_index("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            // Should have CreateTable + AddIndex
+            assert_eq!(plan.actions.len(), 2);
+            assert!(matches!(
+                &plan.actions[0],
+                MigrationAction::CreateTable { .. }
+            ));
+            if let MigrationAction::AddIndex { index, .. } = &plan.actions[1] {
+                assert_eq!(index.name, "idx_users_name");
+                assert_eq!(index.columns, vec!["name".to_string()]);
+            } else {
+                panic!("Expected AddIndex action");
+            }
+        }
+
+        #[test]
+        fn create_table_with_inline_fk() {
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "posts",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_fk(
+                            "user_id",
+                            ColumnType::Simple(SimpleColumnType::Integer),
+                            "users",
+                            "id",
+                        ),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
+                assert_eq!(constraints.len(), 1);
+                assert!(matches!(
+                    &constraints[0],
+                    TableConstraint::ForeignKey { columns, ref_table, ref_columns, .. }
+                        if columns == &["user_id".to_string()]
+                        && ref_table == "users"
+                        && ref_columns == &["id".to_string()]
+                ));
+            } else {
+                panic!("Expected CreateTable action");
+            }
+        }
+
+        #[test]
+        fn add_index_via_inline_constraint() {
+            // Existing table without index -> table with inline index
+            let plan = diff_schemas(
+                &[table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+                &[table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_index("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::AddIndex { table, index } = &plan.actions[0] {
+                assert_eq!(table, "users");
+                assert_eq!(index.name, "idx_users_name");
+                assert_eq!(index.columns, vec!["name".to_string()]);
+            } else {
+                panic!("Expected AddIndex action, got {:?}", plan.actions[0]);
+            }
+        }
+
+        #[test]
+        fn create_table_with_all_inline_constraints() {
+            let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+            id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
+            id_col.nullable = false;
+
+            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 org_id_col = col("org_id", ColumnType::Simple(SimpleColumnType::Integer));
+            org_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
+                ref_table: "orgs".into(),
+                ref_columns: vec!["id".into()],
+                on_delete: None,
+                on_update: None,
+            }));
+
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "users",
+                    vec![id_col, email_col, name_col, org_id_col],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            // Should have CreateTable + AddIndex
+            assert_eq!(plan.actions.len(), 2);
+
+            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
+                // Should have: PrimaryKey, Unique, ForeignKey (3 constraints)
+                assert_eq!(constraints.len(), 3);
+            } else {
+                panic!("Expected CreateTable action");
+            }
+
+            // Check for AddIndex action
+            assert!(matches!(&plan.actions[1], MigrationAction::AddIndex { .. }));
+        }
+
+        #[test]
+        fn add_constraint_to_existing_table() {
+            // Add a unique constraint to an existing table
+            let from_schema = vec![table(
+                "users",
+                vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
+                ],
+                vec![],
+                vec![],
+            )];
+
+            let to_schema = vec![table(
+                "users",
+                vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
+                ],
+                vec![vespertide_core::TableConstraint::Unique {
+                    name: Some("uq_users_email".into()),
+                    columns: vec!["email".into()],
+                }],
+                vec![],
+            )];
+
+            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::AddConstraint { table, constraint } = &plan.actions[0] {
+                assert_eq!(table, "users");
+                assert!(matches!(
+                    constraint,
+                    vespertide_core::TableConstraint::Unique { name: Some(n), columns }
+                        if n == "uq_users_email" && columns == &vec!["email".to_string()]
+                ));
+            } else {
+                panic!("Expected AddConstraint action, got {:?}", plan.actions[0]);
+            }
+        }
+
+        #[test]
+        fn remove_constraint_from_existing_table() {
+            // Remove a unique constraint from an existing table
+            let from_schema = vec![table(
+                "users",
+                vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
+                ],
+                vec![vespertide_core::TableConstraint::Unique {
+                    name: Some("uq_users_email".into()),
+                    columns: vec!["email".into()],
+                }],
+                vec![],
+            )];
+
+            let to_schema = vec![table(
+                "users",
+                vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
+                ],
+                vec![],
+                vec![],
+            )];
+
+            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::RemoveConstraint { table, constraint } = &plan.actions[0] {
+                assert_eq!(table, "users");
+                assert!(matches!(
+                    constraint,
+                    vespertide_core::TableConstraint::Unique { name: Some(n), columns }
+                        if n == "uq_users_email" && columns == &vec!["email".to_string()]
+                ));
+            } else {
+                panic!(
+                    "Expected RemoveConstraint action, got {:?}",
+                    plan.actions[0]
+                );
+            }
+        }
+
+        #[test]
+        fn diff_schemas_with_normalize_error() {
+            // Test that normalize errors are properly propagated
+            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 - should error
+                        let mut c = col1.clone();
+                        c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
+                        c
+                    },
+                ],
+                constraints: vec![],
+                indexes: vec![],
+            };
+
+            let result = diff_schemas(&[], &[table]);
+            assert!(result.is_err());
+            if let Err(PlannerError::TableValidation(msg)) = result {
+                assert!(msg.contains("Failed to normalize table"));
+                assert!(msg.contains("Duplicate index"));
+            } else {
+                panic!("Expected TableValidation error, got {:?}", result);
+            }
+        }
+
+        #[test]
+        fn diff_schemas_with_normalize_error_in_from_schema() {
+            // Test that normalize errors in 'from' schema are properly propagated
+            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 - should error
+                        let mut c = col1.clone();
+                        c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
+                        c
+                    },
+                ],
+                constraints: vec![],
+                indexes: vec![],
+            };
+
+            // 'from' schema has the invalid table
+            let result = diff_schemas(&[table], &[]);
+            assert!(result.is_err());
+            if let Err(PlannerError::TableValidation(msg)) = result {
+                assert!(msg.contains("Failed to normalize table"));
+                assert!(msg.contains("Duplicate index"));
+            } else {
+                panic!("Expected TableValidation error, got {:?}", result);
+            }
+        }
+    }
+
+    // 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"
+            );
+        }
+    }
+}
diff --git a/crates/vespertide-query/src/sql/helpers.rs b/crates/vespertide-query/src/sql/helpers.rs
index 07c0c963..51ce76de 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>>(),
+                );
+            }
         },
     }
 }
@@ -223,6 +229,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));
diff --git a/crates/vespertide-query/src/sql/mod.rs b/crates/vespertide-query/src/sql/mod.rs
index 9d30fbe9..43eddfd9 100644
--- a/crates/vespertide-query/src/sql/mod.rs
+++ b/crates/vespertide-query/src/sql/mod.rs
@@ -333,9 +333,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 +356,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 +377,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 +418,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 +439,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 +461,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 +517,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 +576,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 +628,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 +653,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 c291b6a0..fca6b9be 100644
--- a/crates/vespertide-query/src/sql/modify_column_type.rs
+++ b/crates/vespertide-query/src/sql/modify_column_type.rs
@@ -260,10 +260,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;
 
diff --git a/crates/vespertide-query/src/sql/remove_constraint.rs b/crates/vespertide-query/src/sql/remove_constraint.rs
index bcf039a6..1bf9b73b 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/examples/app/migrations/0001_init.json b/examples/app/migrations/0001_init.json
index 8afd78ef..24c3d2da 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/src/main.rs b/examples/app/src/main.rs
index bc9619be..acfa29c8 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(())
+}

From fc4a0776d0e4288047720245737ff62074de9582 Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 15:23:34 +0900
Subject: [PATCH 02/11] Impl sort mig

---
 crates/vespertide-macro/src/lib.rs     |  49 ++++----
 crates/vespertide-planner/src/diff.rs  |  59 ++++++----
 examples/app/migrations/0002_enum.json |  31 +++++
 examples/app/models/article.json       | 152 ++++++++++++-------------
 examples/app/models/user.json          |   5 +
 5 files changed, 179 insertions(+), 117 deletions(-)
 create mode 100644 examples/app/migrations/0002_enum.json

diff --git a/crates/vespertide-macro/src/lib.rs b/crates/vespertide-macro/src/lib.rs
index 83ef8780..8c2d79c5 100644
--- a/crates/vespertide-macro/src/lib.rs
+++ b/crates/vespertide-macro/src/lib.rs
@@ -96,36 +96,43 @@ pub fn vespertide_migration(input: TokenStream) -> TokenStream {
         };
 
         // Pre-generate SQL for all backends at compile time
+        // Each query may produce multiple SQL statements, so we flatten them
         let sql_statements: Vec<_> = queries
             .iter()
-            .map(|q| {
-                let pg_sql = q
+            .flat_map(|q| {
+                // Collect all individual SQL statements from each backend
+                let pg_sqls: Vec<_> = q
                     .postgres
                     .iter()
-                    .map(|q| q.build(DatabaseBackend::Postgres))
-                    .collect::<Vec<_>>()
-                    .join(";\n");
-                let mysql_sql = q
+                    .map(|stmt| stmt.build(DatabaseBackend::Postgres))
+                    .collect();
+                let mysql_sqls: Vec<_> = q
                     .mysql
                     .iter()
-                    .map(|q| q.build(DatabaseBackend::MySql))
-                    .collect::<Vec<_>>()
-                    .join(";\n");
-                let sqlite_sql = q
+                    .map(|stmt| stmt.build(DatabaseBackend::MySql))
+                    .collect();
+                let sqlite_sqls: Vec<_> = 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
+                    .map(|stmt| stmt.build(DatabaseBackend::Sqlite))
+                    .collect();
+
+                // Generate a separate execution block for each SQL statement
+                let max_len = pg_sqls.len().max(mysql_sqls.len()).max(sqlite_sqls.len());
+                (0..max_len).map(move |i| {
+                    let pg_sql = pg_sqls.get(i).cloned().unwrap_or_default();
+                    let mysql_sql = mysql_sqls.get(i).cloned().unwrap_or_default();
+                    let sqlite_sql = sqlite_sqls.get(i).cloned().unwrap_or_default();
+
+                    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::<Vec<_>>()
             })
             .collect();
 
diff --git a/crates/vespertide-planner/src/diff.rs b/crates/vespertide-planner/src/diff.rs
index f02a58b4..cd96ae3e 100644
--- a/crates/vespertide-planner/src/diff.rs
+++ b/crates/vespertide-planner/src/diff.rs
@@ -94,7 +94,7 @@ fn topological_sort_tables<'a>(tables: &[&'a TableDef]) -> Result<Vec<&'a TableD
 }
 
 /// Sort DeleteTable actions so that tables with FK references are deleted first.
-/// This is the reverse of creation order.
+/// This is the reverse of creation order - use topological sort then reverse.
 fn sort_delete_tables(actions: &mut [MigrationAction], all_tables: &HashMap<&str, &TableDef>) {
     // Collect DeleteTable actions and their indices
     let delete_indices: Vec<usize> = actions
@@ -114,7 +114,7 @@ fn sort_delete_tables(actions: &mut [MigrationAction], all_tables: &HashMap<&str
     }
 
     // Extract table names being deleted
-    let delete_tables: Vec<&str> = delete_indices
+    let delete_table_names: HashSet<&str> = delete_indices
         .iter()
         .filter_map(|&i| {
             if let MigrationAction::DeleteTable { table } = &actions[i] {
@@ -126,13 +126,14 @@ fn sort_delete_tables(actions: &mut [MigrationAction], all_tables: &HashMap<&str
         .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_tables {
+    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_tables.contains(&ref_table.as_str())
+                    && delete_table_names.contains(ref_table.as_str())
                     && ref_table != table_name
                 {
                     deps.push(ref_table.as_str());
@@ -142,29 +143,47 @@ fn sort_delete_tables(actions: &mut [MigrationAction], all_tables: &HashMap<&str
         dependencies.insert(table_name, deps);
     }
 
-    // Sort: tables that depend on others should be deleted first
-    // (reverse topological order)
-    let mut sorted_tables = delete_tables.clone();
-    sorted_tables.sort_by(|a, b| {
-        let a_depends_on_b = dependencies.get(a).is_some_and(|deps| deps.contains(b));
-        let b_depends_on_a = dependencies.get(b).is_some_and(|deps| deps.contains(a));
-
-        if a_depends_on_b {
-            std::cmp::Ordering::Less // a depends on b, so delete a first
-        } else if b_depends_on_a {
-            std::cmp::Ordering::Greater // b depends on a, so delete b first
-        } else {
-            std::cmp::Ordering::Equal
+    // 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) {
+                if 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 in place
+    // Reorder the DeleteTable actions according to sorted order
     let mut delete_actions: Vec<MigrationAction> = delete_indices
         .iter()
         .map(|&i| actions[i].clone())
         .collect();
 
-    // Sort delete_actions according to sorted_tables order
     delete_actions.sort_by(|a, b| {
         let a_name = if let MigrationAction::DeleteTable { table } = a {
             table.as_str()
diff --git a/examples/app/migrations/0002_enum.json b/examples/app/migrations/0002_enum.json
new file mode 100644
index 00000000..a21a8c26
--- /dev/null
+++ b/examples/app/migrations/0002_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": "enum",
+  "created_at": "2025-12-17T06:21:26Z",
+  "version": 2
+}
\ No newline at end of file
diff --git a/examples/app/models/article.json b/examples/app/models/article.json
index 20995189..96c9ac83 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 7221fb1a..18b339b9 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"] },
+      "nullable": true
     }
   ],
   "constraints": [],

From 9548768153d834468f10cf97f84d3a1fb9fd5ec7 Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 17:28:09 +0900
Subject: [PATCH 03/11] Fix enum issue

---
 Cargo.lock                                    |   1 +
 crates/vespertide-cli/src/commands/log.rs     |  16 +-
 crates/vespertide-cli/src/commands/sql.rs     |  11 +-
 crates/vespertide-planner/src/diff.rs         |  12 +-
 crates/vespertide-planner/src/lib.rs          |  26 +-
 crates/vespertide-planner/src/plan.rs         | 189 ++++++------
 crates/vespertide-query/Cargo.toml            |  37 +--
 crates/vespertide-query/src/builder.rs        |  17 +-
 crates/vespertide-query/src/sql/add_column.rs |   7 +-
 .../vespertide-query/src/sql/create_table.rs  |  16 +-
 .../vespertide-query/src/sql/delete_column.rs |  57 +++-
 crates/vespertide-query/src/sql/helpers.rs    |  60 ++++
 crates/vespertide-query/src/sql/mod.rs        |   8 +-
 .../src/sql/modify_column_type.rs             | 287 +++++++++++++++++-
 .../tests/enum_migration_test.rs              | 117 +++++++
 .../{0002_enum.json => 0002_add_enum.json}    |   4 +-
 examples/app/migrations/0003_fix_enum.json    |  22 ++
 examples/app/models/user.json                 |   2 +-
 18 files changed, 734 insertions(+), 155 deletions(-)
 create mode 100644 crates/vespertide-query/tests/enum_migration_test.rs
 rename examples/app/migrations/{0002_enum.json => 0002_add_enum.json} (90%)
 create mode 100644 examples/app/migrations/0003_fix_enum.json

diff --git a/Cargo.lock b/Cargo.lock
index 9dccd7d7..7f7b2797 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3088,6 +3088,7 @@ dependencies = [
  "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 f9db36fe..ca519cf2 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 e7b2a319..465e339a 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-planner/src/diff.rs b/crates/vespertide-planner/src/diff.rs
index cd96ae3e..89533d1a 100644
--- a/crates/vespertide-planner/src/diff.rs
+++ b/crates/vespertide-planner/src/diff.rs
@@ -164,12 +164,12 @@ fn sort_delete_tables(actions: &mut [MigrationAction], all_tables: &HashMap<&str
 
         // For each table that has this one as a dependency, decrement its in-degree
         for (&dependent, deps) in &dependencies {
-            if deps.contains(&table_name) {
-                if let Some(degree) = in_degree.get_mut(dependent) {
-                    *degree -= 1;
-                    if *degree == 0 {
-                        queue.push_back(dependent);
-                    }
+            if deps.contains(&table_name)
+                && let Some(degree) = in_degree.get_mut(dependent)
+            {
+                *degree -= 1;
+                if *degree == 0 {
+                    queue.push_back(dependent);
                 }
             }
         }
diff --git a/crates/vespertide-planner/src/lib.rs b/crates/vespertide-planner/src/lib.rs
index 932f42d4..51d542c3 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 41804278..e28b41ae 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 a210b1a5..ceb81754 100644
--- a/crates/vespertide-query/Cargo.toml
+++ b/crates/vespertide-query/Cargo.toml
@@ -1,18 +1,19 @@
-[package]
-name = "vespertide-query"
-version = "0.1.9"
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-description = "Converts migration actions into SQL statements with bind parameters"
-
-[dependencies]
-vespertide-core = { workspace = true }
-thiserror = "2"
-sea-query = "0.32"
-
-[dev-dependencies]
-rstest = "0.26"
-insta = "1.44"
+[package]
+name = "vespertide-query"
+version = "0.1.9"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+description = "Converts migration actions into SQL statements with bind parameters"
+
+[dependencies]
+vespertide-core = { workspace = true }
+vespertide-planner = { workspace = true }
+thiserror = "2"
+sea-query = "0.32"
+
+[dev-dependencies]
+rstest = "0.26"
+insta = "1.44"
diff --git a/crates/vespertide-query/src/builder.rs b/crates/vespertide-query/src/builder.rs
index 4c468ff9..5ba23f4e 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,28 @@ 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 0ac0be87..99a853bd 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();
 
diff --git a/crates/vespertide-query/src/sql/create_table.rs b/crates/vespertide-query/src/sql/create_table.rs
index e5bb4aa8..4e6c6f43 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>) =
diff --git a/crates/vespertide-query/src/sql/delete_column.rs b/crates/vespertide-query/src/sql/delete_column.rs
index 14927781..5bf8f0e2 100644
--- a/crates/vespertide-query/src/sql/delete_column.rs
+++ b/crates/vespertide-query/src/sql/delete_column.rs
@@ -1,13 +1,30 @@
 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 +33,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 +56,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 +71,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 51ce76de..b4627896 100644
--- a/crates/vespertide-query/src/sql/helpers.rs
+++ b/crates/vespertide-query/src/sql/helpers.rs
@@ -177,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::*;
diff --git a/crates/vespertide-query/src/sql/mod.rs b/crates/vespertide-query/src/sql/mod.rs
index 43eddfd9..4e034d75 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 {
diff --git a/crates/vespertide-query/src/sql/modify_column_type.rs b/crates/vespertide-query/src/sql/modify_column_type.rs
index fca6b9be..3ea694a8 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,121 @@ 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 {
+                let should_create = match old_type {
+                    Some(ColumnType::Complex(ComplexColumnType::Enum { name: old_name, .. })) => {
+                        old_name != new_name
+                    }
+                    Some(_) => true, // Old type wasn't an enum
+                    None => true, // No old type
+                };
+
+                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)
     }
 }
 
@@ -403,4 +510,166 @@ mod tests {
             assert_snapshot!(sql);
         });
     }
+
+    #[test]
+    fn test_modify_enum_values_postgres() {
+        // Test that changing enum values uses the temp type + USING + RENAME approach
+        let old_enum = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        });
+
+        let new_enum = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into(), "pending".into()],
+        });
+
+        let current_schema = vec![TableDef {
+            name: "users".into(),
+            columns: vec![ColumnDef {
+                name: "status".into(),
+                r#type: old_enum,
+                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(
+            &DatabaseBackend::Postgres,
+            "users",
+            "status",
+            &new_enum,
+            &current_schema,
+        )
+        .unwrap();
+
+        let sql = result
+            .iter()
+            .map(|q| q.build(DatabaseBackend::Postgres))
+            .collect::<Vec<_>>()
+            .join(";\n");
+
+        // Should use the safe temp type approach:
+        // 1. CREATE TYPE status_new AS ENUM (...)
+        assert!(sql.contains("CREATE TYPE \"status_new\" AS ENUM ('active', 'inactive', 'pending')"));
+        // 2. ALTER TABLE ... USING column::text::status_new
+        assert!(sql.contains("ALTER TABLE \"users\" ALTER COLUMN \"status\" TYPE \"status_new\" USING \"status\"::text::\"status_new\""));
+        // 3. DROP TYPE status
+        assert!(sql.contains("DROP TYPE \"status\""));
+        // 4. ALTER TYPE status_new RENAME TO status
+        assert!(sql.contains("ALTER TYPE \"status_new\" RENAME TO \"status\""));
+    }
+
+    #[test]
+    fn test_modify_enum_same_values_postgres() {
+        // Test that keeping same enum values doesn't trigger DROP TYPE
+        let old_enum = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        });
+
+        let new_enum = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        });
+
+        let current_schema = vec![TableDef {
+            name: "users".into(),
+            columns: vec![ColumnDef {
+                name: "status".into(),
+                r#type: old_enum,
+                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(
+            &DatabaseBackend::Postgres,
+            "users",
+            "status",
+            &new_enum,
+            &current_schema,
+        )
+        .unwrap();
+
+        let sql = result
+            .iter()
+            .map(|q| q.build(DatabaseBackend::Postgres))
+            .collect::<Vec<_>>()
+            .join(";\n");
+
+        // Should NOT have CREATE TYPE (enum already exists)
+        assert!(!sql.contains("CREATE TYPE"));
+        // Should have ALTER TABLE
+        assert!(sql.contains("ALTER TABLE"));
+        // Should NOT have DROP TYPE (values haven't changed)
+        assert!(!sql.contains("DROP TYPE"));
+    }
+
+    #[test]
+    fn test_modify_enum_name_postgres() {
+        // Test that changing enum name triggers DROP TYPE for old and CREATE TYPE for new
+        let old_enum = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "old_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        });
+
+        let new_enum = ColumnType::Complex(ComplexColumnType::Enum {
+            name: "new_status".into(),
+            values: vec!["active".into(), "inactive".into()],
+        });
+
+        let current_schema = vec![TableDef {
+            name: "users".into(),
+            columns: vec![ColumnDef {
+                name: "status".into(),
+                r#type: old_enum,
+                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(
+            &DatabaseBackend::Postgres,
+            "users",
+            "status",
+            &new_enum,
+            &current_schema,
+        )
+        .unwrap();
+
+        let sql = result
+            .iter()
+            .map(|q| q.build(DatabaseBackend::Postgres))
+            .collect::<Vec<_>>()
+            .join(";\n");
+
+        // Should have CREATE TYPE with new name
+        assert!(sql.contains("CREATE TYPE \"new_status\""));
+        // Should have ALTER TABLE
+        assert!(sql.contains("ALTER TABLE"));
+        // Should have DROP TYPE for old name
+        assert!(sql.contains("DROP TYPE IF EXISTS \"old_status\""));
+    }
 }
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 00000000..13660745
--- /dev/null
+++ b/crates/vespertide-query/tests/enum_migration_test.rs
@@ -0,0 +1,117 @@
+use vespertide_core::{
+    ColumnDef, ColumnType, ComplexColumnType, MigrationAction, MigrationPlan,
+    SimpleColumnType, TableDef,
+};
+use vespertide_core::schema::primary_key::PrimaryKeySyntax;
+use vespertide_query::{build_plan_queries, DatabaseBackend};
+
+#[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/0002_enum.json b/examples/app/migrations/0002_add_enum.json
similarity index 90%
rename from examples/app/migrations/0002_enum.json
rename to examples/app/migrations/0002_add_enum.json
index a21a8c26..6bd130bd 100644
--- a/examples/app/migrations/0002_enum.json
+++ b/examples/app/migrations/0002_add_enum.json
@@ -25,7 +25,7 @@
       "type": "add_column"
     }
   ],
-  "comment": "enum",
-  "created_at": "2025-12-17T06:21:26Z",
+  "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 00000000..9f2502a2
--- /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:11:19Z",
+  "version": 3
+}
\ No newline at end of file
diff --git a/examples/app/models/user.json b/examples/app/models/user.json
index 18b339b9..452dee68 100644
--- a/examples/app/models/user.json
+++ b/examples/app/models/user.json
@@ -44,7 +44,7 @@
     },
     {
       "name": "status",
-      "type": { "kind": "enum", "name": "status", "values": ["active", "inactive"] },
+      "type": { "kind": "enum", "name": "status", "values": ["active", "inactive", "pending"] },
       "nullable": true
     }
   ],

From 1428b76b559a91b9c4e7552de608d276b5adc890 Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 17:44:14 +0900
Subject: [PATCH 04/11] Fix enum issue

---
 Cargo.lock                                 |  1 +
 crates/vespertide-macro/Cargo.toml         | 51 ++++++-------
 crates/vespertide-macro/src/lib.rs         | 87 ++++++++++------------
 examples/app/migrations/0003_fix_enum.json |  2 +-
 4 files changed, 69 insertions(+), 72 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7f7b2797..d96bc3df 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3067,6 +3067,7 @@ dependencies = [
  "vespertide-config",
  "vespertide-core",
  "vespertide-loader",
+ "vespertide-planner",
  "vespertide-query",
 ]
 
diff --git a/crates/vespertide-macro/Cargo.toml b/crates/vespertide-macro/Cargo.toml
index 1697f53b..869e6d96 100644
--- a/crates/vespertide-macro/Cargo.toml
+++ b/crates/vespertide-macro/Cargo.toml
@@ -1,25 +1,26 @@
-[package]
-name = "vespertide-macro"
-version = "0.1.9"
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-description = "Macro entry for runtime migration execution"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-vespertide-core = { workspace = true }
-vespertide-config = { workspace = true }
-vespertide-loader = { workspace = true }
-vespertide-query = { workspace = true }
-thiserror = "2"
-syn = { version = "2.0", features = ["full"] }
-quote = "1.0"
-proc-macro2 = "1.0"
-
-[dev-dependencies]
-tempfile = "3"
+[package]
+name = "vespertide-macro"
+version = "0.1.9"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+description = "Macro entry for runtime migration execution"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+vespertide-core = { workspace = true }
+vespertide-config = { workspace = true }
+vespertide-loader = { workspace = true }
+vespertide-planner = { workspace = true }
+vespertide-query = { workspace = true }
+thiserror = "2"
+syn = { version = "2.0", features = ["full"] }
+quote = "1.0"
+proc-macro2 = "1.0"
+
+[dev-dependencies]
+tempfile = "3"
diff --git a/crates/vespertide-macro/src/lib.rs b/crates/vespertide-macro/src/lib.rs
index 8c2d79c5..1dd22cab 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,46 +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
         // Each query may produce multiple SQL statements, so we flatten them
-        let sql_statements: Vec<_> = queries
-            .iter()
-            .flat_map(|q| {
-                // Collect all individual SQL statements from each backend
-                let pg_sqls: Vec<_> = q
-                    .postgres
-                    .iter()
-                    .map(|stmt| stmt.build(DatabaseBackend::Postgres))
-                    .collect();
-                let mysql_sqls: Vec<_> = q
-                    .mysql
-                    .iter()
-                    .map(|stmt| stmt.build(DatabaseBackend::MySql))
-                    .collect();
-                let sqlite_sqls: Vec<_> = q
-                    .sqlite
-                    .iter()
-                    .map(|stmt| stmt.build(DatabaseBackend::Sqlite))
-                    .collect();
-
-                // Generate a separate execution block for each SQL statement
-                let max_len = pg_sqls.len().max(mysql_sqls.len()).max(sqlite_sqls.len());
-                (0..max_len).map(move |i| {
-                    let pg_sql = pg_sqls.get(i).cloned().unwrap_or_default();
-                    let mysql_sql = mysql_sqls.get(i).cloned().unwrap_or_default();
-                    let sqlite_sql = sqlite_sqls.get(i).cloned().unwrap_or_default();
-
-                    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::<Vec<_>>()
-            })
-            .collect();
+        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! {
@@ -144,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/examples/app/migrations/0003_fix_enum.json b/examples/app/migrations/0003_fix_enum.json
index 9f2502a2..dd0f9d61 100644
--- a/examples/app/migrations/0003_fix_enum.json
+++ b/examples/app/migrations/0003_fix_enum.json
@@ -17,6 +17,6 @@
     }
   ],
   "comment": "Fix enum",
-  "created_at": "2025-12-17T08:11:19Z",
+  "created_at": "2025-12-17T08:43:19Z",
   "version": 3
 }
\ No newline at end of file

From 55ed56537971ca5e28fee755d6ae0d91288a5ba4 Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 17:45:04 +0900
Subject: [PATCH 05/11] Fix lint

---
 crates/vespertide-planner/src/diff.rs         | 2608 +++++++++--------
 crates/vespertide-query/src/builder.rs        |    3 +-
 .../vespertide-query/src/sql/delete_column.rs |    6 +-
 .../src/sql/modify_column_type.rs             |   40 +-
 .../tests/enum_migration_test.rs              |  234 +-
 5 files changed, 1456 insertions(+), 1435 deletions(-)

diff --git a/crates/vespertide-planner/src/diff.rs b/crates/vespertide-planner/src/diff.rs
index 89533d1a..640a4024 100644
--- a/crates/vespertide-planner/src/diff.rs
+++ b/crates/vespertide-planner/src/diff.rs
@@ -1,1303 +1,1305 @@
-use std::collections::{HashMap, HashSet, VecDeque};
-
-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.
-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()
-        .filter_map(|&i| {
-            if let MigrationAction::DeleteTable { table } = &actions[i] {
-                Some(table.as_str())
-            } else {
-                None
-            }
-        })
-        .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 = if let MigrationAction::DeleteTable { table } = a {
-            table.as_str()
-        } else {
-            ""
-        };
-        let b_name = if let MigrationAction::DeleteTable { table } = b {
-            table.as_str()
-        } else {
-            ""
-        };
-
-        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.
-pub fn diff_schemas(from: &[TableDef], to: &[TableDef]) -> Result<MigrationPlan, PlannerError> {
-    let mut actions: Vec<MigrationAction> = Vec::new();
-
-    // Normalize both schemas to ensure inline constraints are converted to table-level
-    let from_normalized: Vec<TableDef> = from
-        .iter()
-        .map(|t| {
-            t.normalize().map_err(|e| {
-                PlannerError::TableValidation(format!(
-                    "Failed to normalize table '{}': {}",
-                    t.name, e
-                ))
-            })
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-    let to_normalized: Vec<TableDef> = to
-        .iter()
-        .map(|t| {
-            t.normalize().map_err(|e| {
-                PlannerError::TableValidation(format!(
-                    "Failed to normalize table '{}': {}",
-                    t.name, e
-                ))
-            })
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-
-    let from_map: HashMap<_, _> = from_normalized
-        .iter()
-        .map(|t| (t.name.as_str(), t))
-        .collect();
-    let to_map: HashMap<_, _> = to_normalized.iter().map(|t| (t.name.as_str(), t)).collect();
-
-    // Drop tables that disappeared.
-    for name in from_map.keys() {
-        if !to_map.contains_key(name) {
-            actions.push(MigrationAction::DeleteTable {
-                table: (*name).to_string(),
-            });
-        }
-    }
-
-    // Update existing tables and their indexes/columns.
-    for (name, to_tbl) in &to_map {
-        if let Some(from_tbl) = from_map.get(name) {
-            // Columns
-            let from_cols: HashMap<_, _> = from_tbl
-                .columns
-                .iter()
-                .map(|c| (c.name.as_str(), c))
-                .collect();
-            let to_cols: HashMap<_, _> = to_tbl
-                .columns
-                .iter()
-                .map(|c| (c.name.as_str(), c))
-                .collect();
-
-            // Deleted columns
-            for col in from_cols.keys() {
-                if !to_cols.contains_key(col) {
-                    actions.push(MigrationAction::DeleteColumn {
-                        table: (*name).to_string(),
-                        column: (*col).to_string(),
-                    });
-                }
-            }
-
-            // Modified columns
-            for (col, to_def) in &to_cols {
-                if let Some(from_def) = from_cols.get(col)
-                    && from_def.r#type != to_def.r#type
-                {
-                    actions.push(MigrationAction::ModifyColumnType {
-                        table: (*name).to_string(),
-                        column: (*col).to_string(),
-                        new_type: to_def.r#type.clone(),
-                    });
-                }
-            }
-
-            // Added columns
-            // Note: Inline foreign keys are already converted to TableConstraint::ForeignKey
-            // by normalize(), so they will be handled in the constraint diff below.
-            for (col, def) in &to_cols {
-                if !from_cols.contains_key(col) {
-                    actions.push(MigrationAction::AddColumn {
-                        table: (*name).to_string(),
-                        column: (*def).clone(),
-                        fill_with: None,
-                    });
-                }
-            }
-
-            // Indexes
-            let from_indexes: HashMap<_, _> = from_tbl
-                .indexes
-                .iter()
-                .map(|i| (i.name.as_str(), i))
-                .collect();
-            let to_indexes: HashMap<_, _> = to_tbl
-                .indexes
-                .iter()
-                .map(|i| (i.name.as_str(), i))
-                .collect();
-
-            for idx in from_indexes.keys() {
-                if !to_indexes.contains_key(idx) {
-                    actions.push(MigrationAction::RemoveIndex {
-                        table: (*name).to_string(),
-                        name: (*idx).to_string(),
-                    });
-                }
-            }
-            for (idx, def) in &to_indexes {
-                if !from_indexes.contains_key(idx) {
-                    actions.push(MigrationAction::AddIndex {
-                        table: (*name).to_string(),
-                        index: (*def).clone(),
-                    });
-                }
-            }
-
-            // Constraints - compare and detect additions/removals
-            for from_constraint in &from_tbl.constraints {
-                if !to_tbl.constraints.contains(from_constraint) {
-                    actions.push(MigrationAction::RemoveConstraint {
-                        table: (*name).to_string(),
-                        constraint: from_constraint.clone(),
-                    });
-                }
-            }
-            for to_constraint in &to_tbl.constraints {
-                if !from_tbl.constraints.contains(to_constraint) {
-                    actions.push(MigrationAction::AddConstraint {
-                        table: (*name).to_string(),
-                        constraint: to_constraint.clone(),
-                    });
-                }
-            }
-        }
-    }
-
-    // Create new tables (and their indexes).
-    // 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(),
-                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,
-        version: 0,
-        actions,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rstest::rstest;
-    use vespertide_core::{ColumnDef, ColumnType, IndexDef, 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<IndexDef>,
-    ) -> TableDef {
-        TableDef {
-            name: name.to_string(),
-            columns,
-            constraints,
-            indexes,
-        }
-    }
-
-    #[rstest]
-    #[case::add_column_and_index(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![table(
-            "users",
-            vec![
-                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                col("name", ColumnType::Simple(SimpleColumnType::Text)),
-            ],
-            vec![],
-            vec![IndexDef {
-                name: "idx_users_name".into(),
-                columns: vec!["name".into()],
-                unique: false,
-            }],
-        )],
-        vec![
-            MigrationAction::AddColumn {
-                table: "users".into(),
-                column: col("name", ColumnType::Simple(SimpleColumnType::Text)),
-                fill_with: None,
-            },
-            MigrationAction::AddIndex {
-                table: "users".into(),
-                index: IndexDef {
-                    name: "idx_users_name".into(),
-                    columns: vec!["name".into()],
-                    unique: false,
-                },
-            },
-        ]
-    )]
-    #[case::drop_table(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![],
-        vec![MigrationAction::DeleteTable {
-            table: "users".into()
-        }]
-    )]
-    #[case::add_table(
-        vec![],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![IndexDef {
-                name: "idx_users_id".into(),
-                columns: vec!["id".into()],
-                unique: true,
-            }],
-        )],
-        vec![
-            MigrationAction::CreateTable {
-                table: "users".into(),
-                columns: vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-                constraints: vec![],
-            },
-            MigrationAction::AddIndex {
-                table: "users".into(),
-                index: IndexDef {
-                    name: "idx_users_id".into(),
-                    columns: vec!["id".into()],
-                    unique: true,
-                },
-            },
-        ]
-    )]
-    #[case::delete_column(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer)), col("name", ColumnType::Simple(SimpleColumnType::Text))],
-            vec![],
-            vec![],
-        )],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![MigrationAction::DeleteColumn {
-            table: "users".into(),
-            column: "name".into(),
-        }]
-    )]
-    #[case::modify_column_type(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Text))],
-            vec![],
-            vec![],
-        )],
-        vec![MigrationAction::ModifyColumnType {
-            table: "users".into(),
-            column: "id".into(),
-            new_type: ColumnType::Simple(SimpleColumnType::Text),
-        }]
-    )]
-    #[case::remove_index(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![IndexDef {
-                name: "idx_users_id".into(),
-                columns: vec!["id".into()],
-                unique: false,
-            }],
-        )],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![MigrationAction::RemoveIndex {
-            table: "users".into(),
-            name: "idx_users_id".into(),
-        }]
-    )]
-    #[case::add_index_existing_table(
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![],
-        )],
-        vec![table(
-            "users",
-            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
-            vec![],
-            vec![IndexDef {
-                name: "idx_users_id".into(),
-                columns: vec!["id".into()],
-                unique: true,
-            }],
-        )],
-        vec![MigrationAction::AddIndex {
-            table: "users".into(),
-            index: IndexDef {
-                name: "idx_users_id".into(),
-                columns: vec!["id".into()],
-                unique: true,
-            },
-        }]
-    )]
-    fn diff_schemas_detects_additions(
-        #[case] from_schema: Vec<TableDef>,
-        #[case] to_schema: Vec<TableDef>,
-        #[case] expected_actions: Vec<MigrationAction>,
-    ) {
-        let plan = diff_schemas(&from_schema, &to_schema).unwrap();
-        assert_eq!(plan.actions, expected_actions);
-    }
-
-    // Tests for inline column constraints normalization
-    mod inline_constraints {
-        use super::*;
-        use vespertide_core::schema::foreign_key::ForeignKeyDef;
-        use vespertide_core::schema::foreign_key::ForeignKeySyntax;
-        use vespertide_core::schema::primary_key::PrimaryKeySyntax;
-        use vespertide_core::{StrOrBoolOrArray, TableConstraint};
-
-        fn col_with_pk(name: &str, ty: ColumnType) -> ColumnDef {
-            ColumnDef {
-                name: name.to_string(),
-                r#type: ty,
-                nullable: false,
-                default: None,
-                comment: None,
-                primary_key: Some(PrimaryKeySyntax::Bool(true)),
-                unique: None,
-                index: None,
-                foreign_key: None,
-            }
-        }
-
-        fn col_with_unique(name: &str, ty: ColumnType) -> ColumnDef {
-            ColumnDef {
-                name: name.to_string(),
-                r#type: ty,
-                nullable: true,
-                default: None,
-                comment: None,
-                primary_key: None,
-                unique: Some(StrOrBoolOrArray::Bool(true)),
-                index: None,
-                foreign_key: None,
-            }
-        }
-
-        fn col_with_index(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: Some(StrOrBoolOrArray::Bool(true)),
-                foreign_key: None,
-            }
-        }
-
-        fn col_with_fk(name: &str, ty: ColumnType, ref_table: &str, ref_col: &str) -> ColumnDef {
-            ColumnDef {
-                name: name.to_string(),
-                r#type: ty,
-                nullable: true,
-                default: None,
-                comment: None,
-                primary_key: None,
-                unique: None,
-                index: None,
-                foreign_key: Some(ForeignKeySyntax::Object(ForeignKeyDef {
-                    ref_table: ref_table.to_string(),
-                    ref_columns: vec![ref_col.to_string()],
-                    on_delete: None,
-                    on_update: None,
-                })),
-            }
-        }
-
-        #[test]
-        fn create_table_with_inline_pk() {
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "users",
-                    vec![
-                        col_with_pk("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
-                assert_eq!(constraints.len(), 1);
-                assert!(matches!(
-                    &constraints[0],
-                    TableConstraint::PrimaryKey { columns, .. } if columns == &["id".to_string()]
-                ));
-            } else {
-                panic!("Expected CreateTable action");
-            }
-        }
-
-        #[test]
-        fn create_table_with_inline_unique() {
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "users",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col_with_unique("email", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
-                assert_eq!(constraints.len(), 1);
-                assert!(matches!(
-                    &constraints[0],
-                    TableConstraint::Unique { name: None, columns } if columns == &["email".to_string()]
-                ));
-            } else {
-                panic!("Expected CreateTable action");
-            }
-        }
-
-        #[test]
-        fn create_table_with_inline_index() {
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "users",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col_with_index("name", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            // Should have CreateTable + AddIndex
-            assert_eq!(plan.actions.len(), 2);
-            assert!(matches!(
-                &plan.actions[0],
-                MigrationAction::CreateTable { .. }
-            ));
-            if let MigrationAction::AddIndex { index, .. } = &plan.actions[1] {
-                assert_eq!(index.name, "idx_users_name");
-                assert_eq!(index.columns, vec!["name".to_string()]);
-            } else {
-                panic!("Expected AddIndex action");
-            }
-        }
-
-        #[test]
-        fn create_table_with_inline_fk() {
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "posts",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col_with_fk(
-                            "user_id",
-                            ColumnType::Simple(SimpleColumnType::Integer),
-                            "users",
-                            "id",
-                        ),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
-                assert_eq!(constraints.len(), 1);
-                assert!(matches!(
-                    &constraints[0],
-                    TableConstraint::ForeignKey { columns, ref_table, ref_columns, .. }
-                        if columns == &["user_id".to_string()]
-                        && ref_table == "users"
-                        && ref_columns == &["id".to_string()]
-                ));
-            } else {
-                panic!("Expected CreateTable action");
-            }
-        }
-
-        #[test]
-        fn add_index_via_inline_constraint() {
-            // Existing table without index -> table with inline index
-            let plan = diff_schemas(
-                &[table(
-                    "users",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-                &[table(
-                    "users",
-                    vec![
-                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                        col_with_index("name", ColumnType::Simple(SimpleColumnType::Text)),
-                    ],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::AddIndex { table, index } = &plan.actions[0] {
-                assert_eq!(table, "users");
-                assert_eq!(index.name, "idx_users_name");
-                assert_eq!(index.columns, vec!["name".to_string()]);
-            } else {
-                panic!("Expected AddIndex action, got {:?}", plan.actions[0]);
-            }
-        }
-
-        #[test]
-        fn create_table_with_all_inline_constraints() {
-            let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
-            id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
-            id_col.nullable = false;
-
-            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 org_id_col = col("org_id", ColumnType::Simple(SimpleColumnType::Integer));
-            org_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
-                ref_table: "orgs".into(),
-                ref_columns: vec!["id".into()],
-                on_delete: None,
-                on_update: None,
-            }));
-
-            let plan = diff_schemas(
-                &[],
-                &[table(
-                    "users",
-                    vec![id_col, email_col, name_col, org_id_col],
-                    vec![],
-                    vec![],
-                )],
-            )
-            .unwrap();
-
-            // Should have CreateTable + AddIndex
-            assert_eq!(plan.actions.len(), 2);
-
-            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
-                // Should have: PrimaryKey, Unique, ForeignKey (3 constraints)
-                assert_eq!(constraints.len(), 3);
-            } else {
-                panic!("Expected CreateTable action");
-            }
-
-            // Check for AddIndex action
-            assert!(matches!(&plan.actions[1], MigrationAction::AddIndex { .. }));
-        }
-
-        #[test]
-        fn add_constraint_to_existing_table() {
-            // Add a unique constraint to an existing table
-            let from_schema = vec![table(
-                "users",
-                vec![
-                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
-                ],
-                vec![],
-                vec![],
-            )];
-
-            let to_schema = vec![table(
-                "users",
-                vec![
-                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
-                ],
-                vec![vespertide_core::TableConstraint::Unique {
-                    name: Some("uq_users_email".into()),
-                    columns: vec!["email".into()],
-                }],
-                vec![],
-            )];
-
-            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::AddConstraint { table, constraint } = &plan.actions[0] {
-                assert_eq!(table, "users");
-                assert!(matches!(
-                    constraint,
-                    vespertide_core::TableConstraint::Unique { name: Some(n), columns }
-                        if n == "uq_users_email" && columns == &vec!["email".to_string()]
-                ));
-            } else {
-                panic!("Expected AddConstraint action, got {:?}", plan.actions[0]);
-            }
-        }
-
-        #[test]
-        fn remove_constraint_from_existing_table() {
-            // Remove a unique constraint from an existing table
-            let from_schema = vec![table(
-                "users",
-                vec![
-                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
-                ],
-                vec![vespertide_core::TableConstraint::Unique {
-                    name: Some("uq_users_email".into()),
-                    columns: vec!["email".into()],
-                }],
-                vec![],
-            )];
-
-            let to_schema = vec![table(
-                "users",
-                vec![
-                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
-                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
-                ],
-                vec![],
-                vec![],
-            )];
-
-            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
-            assert_eq!(plan.actions.len(), 1);
-            if let MigrationAction::RemoveConstraint { table, constraint } = &plan.actions[0] {
-                assert_eq!(table, "users");
-                assert!(matches!(
-                    constraint,
-                    vespertide_core::TableConstraint::Unique { name: Some(n), columns }
-                        if n == "uq_users_email" && columns == &vec!["email".to_string()]
-                ));
-            } else {
-                panic!(
-                    "Expected RemoveConstraint action, got {:?}",
-                    plan.actions[0]
-                );
-            }
-        }
-
-        #[test]
-        fn diff_schemas_with_normalize_error() {
-            // Test that normalize errors are properly propagated
-            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 - should error
-                        let mut c = col1.clone();
-                        c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
-                        c
-                    },
-                ],
-                constraints: vec![],
-                indexes: vec![],
-            };
-
-            let result = diff_schemas(&[], &[table]);
-            assert!(result.is_err());
-            if let Err(PlannerError::TableValidation(msg)) = result {
-                assert!(msg.contains("Failed to normalize table"));
-                assert!(msg.contains("Duplicate index"));
-            } else {
-                panic!("Expected TableValidation error, got {:?}", result);
-            }
-        }
-
-        #[test]
-        fn diff_schemas_with_normalize_error_in_from_schema() {
-            // Test that normalize errors in 'from' schema are properly propagated
-            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 - should error
-                        let mut c = col1.clone();
-                        c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
-                        c
-                    },
-                ],
-                constraints: vec![],
-                indexes: vec![],
-            };
-
-            // 'from' schema has the invalid table
-            let result = diff_schemas(&[table], &[]);
-            assert!(result.is_err());
-            if let Err(PlannerError::TableValidation(msg)) = result {
-                assert!(msg.contains("Failed to normalize table"));
-                assert!(msg.contains("Duplicate index"));
-            } else {
-                panic!("Expected TableValidation error, got {:?}", result);
-            }
-        }
-    }
-
-    // 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"
-            );
-        }
-    }
-}
+use std::collections::{HashMap, HashSet, VecDeque};
+
+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.
+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()
+        .filter_map(|&i| {
+            if let MigrationAction::DeleteTable { table } = &actions[i] {
+                Some(table.as_str())
+            } else {
+                None
+            }
+        })
+        .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 = if let MigrationAction::DeleteTable { table } = a {
+            table.as_str()
+        } else {
+            ""
+        };
+        let b_name = if let MigrationAction::DeleteTable { table } = b {
+            table.as_str()
+        } else {
+            ""
+        };
+
+        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.
+pub fn diff_schemas(from: &[TableDef], to: &[TableDef]) -> Result<MigrationPlan, PlannerError> {
+    let mut actions: Vec<MigrationAction> = Vec::new();
+
+    // Normalize both schemas to ensure inline constraints are converted to table-level
+    let from_normalized: Vec<TableDef> = from
+        .iter()
+        .map(|t| {
+            t.normalize().map_err(|e| {
+                PlannerError::TableValidation(format!(
+                    "Failed to normalize table '{}': {}",
+                    t.name, e
+                ))
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let to_normalized: Vec<TableDef> = to
+        .iter()
+        .map(|t| {
+            t.normalize().map_err(|e| {
+                PlannerError::TableValidation(format!(
+                    "Failed to normalize table '{}': {}",
+                    t.name, e
+                ))
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let from_map: HashMap<_, _> = from_normalized
+        .iter()
+        .map(|t| (t.name.as_str(), t))
+        .collect();
+    let to_map: HashMap<_, _> = to_normalized.iter().map(|t| (t.name.as_str(), t)).collect();
+
+    // Drop tables that disappeared.
+    for name in from_map.keys() {
+        if !to_map.contains_key(name) {
+            actions.push(MigrationAction::DeleteTable {
+                table: (*name).to_string(),
+            });
+        }
+    }
+
+    // Update existing tables and their indexes/columns.
+    for (name, to_tbl) in &to_map {
+        if let Some(from_tbl) = from_map.get(name) {
+            // Columns
+            let from_cols: HashMap<_, _> = from_tbl
+                .columns
+                .iter()
+                .map(|c| (c.name.as_str(), c))
+                .collect();
+            let to_cols: HashMap<_, _> = to_tbl
+                .columns
+                .iter()
+                .map(|c| (c.name.as_str(), c))
+                .collect();
+
+            // Deleted columns
+            for col in from_cols.keys() {
+                if !to_cols.contains_key(col) {
+                    actions.push(MigrationAction::DeleteColumn {
+                        table: (*name).to_string(),
+                        column: (*col).to_string(),
+                    });
+                }
+            }
+
+            // Modified columns
+            for (col, to_def) in &to_cols {
+                if let Some(from_def) = from_cols.get(col)
+                    && from_def.r#type != to_def.r#type
+                {
+                    actions.push(MigrationAction::ModifyColumnType {
+                        table: (*name).to_string(),
+                        column: (*col).to_string(),
+                        new_type: to_def.r#type.clone(),
+                    });
+                }
+            }
+
+            // Added columns
+            // Note: Inline foreign keys are already converted to TableConstraint::ForeignKey
+            // by normalize(), so they will be handled in the constraint diff below.
+            for (col, def) in &to_cols {
+                if !from_cols.contains_key(col) {
+                    actions.push(MigrationAction::AddColumn {
+                        table: (*name).to_string(),
+                        column: (*def).clone(),
+                        fill_with: None,
+                    });
+                }
+            }
+
+            // Indexes
+            let from_indexes: HashMap<_, _> = from_tbl
+                .indexes
+                .iter()
+                .map(|i| (i.name.as_str(), i))
+                .collect();
+            let to_indexes: HashMap<_, _> = to_tbl
+                .indexes
+                .iter()
+                .map(|i| (i.name.as_str(), i))
+                .collect();
+
+            for idx in from_indexes.keys() {
+                if !to_indexes.contains_key(idx) {
+                    actions.push(MigrationAction::RemoveIndex {
+                        table: (*name).to_string(),
+                        name: (*idx).to_string(),
+                    });
+                }
+            }
+            for (idx, def) in &to_indexes {
+                if !from_indexes.contains_key(idx) {
+                    actions.push(MigrationAction::AddIndex {
+                        table: (*name).to_string(),
+                        index: (*def).clone(),
+                    });
+                }
+            }
+
+            // Constraints - compare and detect additions/removals
+            for from_constraint in &from_tbl.constraints {
+                if !to_tbl.constraints.contains(from_constraint) {
+                    actions.push(MigrationAction::RemoveConstraint {
+                        table: (*name).to_string(),
+                        constraint: from_constraint.clone(),
+                    });
+                }
+            }
+            for to_constraint in &to_tbl.constraints {
+                if !from_tbl.constraints.contains(to_constraint) {
+                    actions.push(MigrationAction::AddConstraint {
+                        table: (*name).to_string(),
+                        constraint: to_constraint.clone(),
+                    });
+                }
+            }
+        }
+    }
+
+    // Create new tables (and their indexes).
+    // 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(),
+                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,
+        version: 0,
+        actions,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rstest::rstest;
+    use vespertide_core::{ColumnDef, ColumnType, IndexDef, 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<IndexDef>,
+    ) -> TableDef {
+        TableDef {
+            name: name.to_string(),
+            columns,
+            constraints,
+            indexes,
+        }
+    }
+
+    #[rstest]
+    #[case::add_column_and_index(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![table(
+            "users",
+            vec![
+                col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                col("name", ColumnType::Simple(SimpleColumnType::Text)),
+            ],
+            vec![],
+            vec![IndexDef {
+                name: "idx_users_name".into(),
+                columns: vec!["name".into()],
+                unique: false,
+            }],
+        )],
+        vec![
+            MigrationAction::AddColumn {
+                table: "users".into(),
+                column: col("name", ColumnType::Simple(SimpleColumnType::Text)),
+                fill_with: None,
+            },
+            MigrationAction::AddIndex {
+                table: "users".into(),
+                index: IndexDef {
+                    name: "idx_users_name".into(),
+                    columns: vec!["name".into()],
+                    unique: false,
+                },
+            },
+        ]
+    )]
+    #[case::drop_table(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![],
+        vec![MigrationAction::DeleteTable {
+            table: "users".into()
+        }]
+    )]
+    #[case::add_table(
+        vec![],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![IndexDef {
+                name: "idx_users_id".into(),
+                columns: vec!["id".into()],
+                unique: true,
+            }],
+        )],
+        vec![
+            MigrationAction::CreateTable {
+                table: "users".into(),
+                columns: vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+                constraints: vec![],
+            },
+            MigrationAction::AddIndex {
+                table: "users".into(),
+                index: IndexDef {
+                    name: "idx_users_id".into(),
+                    columns: vec!["id".into()],
+                    unique: true,
+                },
+            },
+        ]
+    )]
+    #[case::delete_column(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer)), col("name", ColumnType::Simple(SimpleColumnType::Text))],
+            vec![],
+            vec![],
+        )],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![MigrationAction::DeleteColumn {
+            table: "users".into(),
+            column: "name".into(),
+        }]
+    )]
+    #[case::modify_column_type(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Text))],
+            vec![],
+            vec![],
+        )],
+        vec![MigrationAction::ModifyColumnType {
+            table: "users".into(),
+            column: "id".into(),
+            new_type: ColumnType::Simple(SimpleColumnType::Text),
+        }]
+    )]
+    #[case::remove_index(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![IndexDef {
+                name: "idx_users_id".into(),
+                columns: vec!["id".into()],
+                unique: false,
+            }],
+        )],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![MigrationAction::RemoveIndex {
+            table: "users".into(),
+            name: "idx_users_id".into(),
+        }]
+    )]
+    #[case::add_index_existing_table(
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![],
+        )],
+        vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+            vec![IndexDef {
+                name: "idx_users_id".into(),
+                columns: vec!["id".into()],
+                unique: true,
+            }],
+        )],
+        vec![MigrationAction::AddIndex {
+            table: "users".into(),
+            index: IndexDef {
+                name: "idx_users_id".into(),
+                columns: vec!["id".into()],
+                unique: true,
+            },
+        }]
+    )]
+    fn diff_schemas_detects_additions(
+        #[case] from_schema: Vec<TableDef>,
+        #[case] to_schema: Vec<TableDef>,
+        #[case] expected_actions: Vec<MigrationAction>,
+    ) {
+        let plan = diff_schemas(&from_schema, &to_schema).unwrap();
+        assert_eq!(plan.actions, expected_actions);
+    }
+
+    // Tests for inline column constraints normalization
+    mod inline_constraints {
+        use super::*;
+        use vespertide_core::schema::foreign_key::ForeignKeyDef;
+        use vespertide_core::schema::foreign_key::ForeignKeySyntax;
+        use vespertide_core::schema::primary_key::PrimaryKeySyntax;
+        use vespertide_core::{StrOrBoolOrArray, TableConstraint};
+
+        fn col_with_pk(name: &str, ty: ColumnType) -> ColumnDef {
+            ColumnDef {
+                name: name.to_string(),
+                r#type: ty,
+                nullable: false,
+                default: None,
+                comment: None,
+                primary_key: Some(PrimaryKeySyntax::Bool(true)),
+                unique: None,
+                index: None,
+                foreign_key: None,
+            }
+        }
+
+        fn col_with_unique(name: &str, ty: ColumnType) -> ColumnDef {
+            ColumnDef {
+                name: name.to_string(),
+                r#type: ty,
+                nullable: true,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: Some(StrOrBoolOrArray::Bool(true)),
+                index: None,
+                foreign_key: None,
+            }
+        }
+
+        fn col_with_index(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: Some(StrOrBoolOrArray::Bool(true)),
+                foreign_key: None,
+            }
+        }
+
+        fn col_with_fk(name: &str, ty: ColumnType, ref_table: &str, ref_col: &str) -> ColumnDef {
+            ColumnDef {
+                name: name.to_string(),
+                r#type: ty,
+                nullable: true,
+                default: None,
+                comment: None,
+                primary_key: None,
+                unique: None,
+                index: None,
+                foreign_key: Some(ForeignKeySyntax::Object(ForeignKeyDef {
+                    ref_table: ref_table.to_string(),
+                    ref_columns: vec![ref_col.to_string()],
+                    on_delete: None,
+                    on_update: None,
+                })),
+            }
+        }
+
+        #[test]
+        fn create_table_with_inline_pk() {
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "users",
+                    vec![
+                        col_with_pk("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
+                assert_eq!(constraints.len(), 1);
+                assert!(matches!(
+                    &constraints[0],
+                    TableConstraint::PrimaryKey { columns, .. } if columns == &["id".to_string()]
+                ));
+            } else {
+                panic!("Expected CreateTable action");
+            }
+        }
+
+        #[test]
+        fn create_table_with_inline_unique() {
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_unique("email", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
+                assert_eq!(constraints.len(), 1);
+                assert!(matches!(
+                    &constraints[0],
+                    TableConstraint::Unique { name: None, columns } if columns == &["email".to_string()]
+                ));
+            } else {
+                panic!("Expected CreateTable action");
+            }
+        }
+
+        #[test]
+        fn create_table_with_inline_index() {
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_index("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            // Should have CreateTable + AddIndex
+            assert_eq!(plan.actions.len(), 2);
+            assert!(matches!(
+                &plan.actions[0],
+                MigrationAction::CreateTable { .. }
+            ));
+            if let MigrationAction::AddIndex { index, .. } = &plan.actions[1] {
+                assert_eq!(index.name, "idx_users_name");
+                assert_eq!(index.columns, vec!["name".to_string()]);
+            } else {
+                panic!("Expected AddIndex action");
+            }
+        }
+
+        #[test]
+        fn create_table_with_inline_fk() {
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "posts",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_fk(
+                            "user_id",
+                            ColumnType::Simple(SimpleColumnType::Integer),
+                            "users",
+                            "id",
+                        ),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
+                assert_eq!(constraints.len(), 1);
+                assert!(matches!(
+                    &constraints[0],
+                    TableConstraint::ForeignKey { columns, ref_table, ref_columns, .. }
+                        if columns == &["user_id".to_string()]
+                        && ref_table == "users"
+                        && ref_columns == &["id".to_string()]
+                ));
+            } else {
+                panic!("Expected CreateTable action");
+            }
+        }
+
+        #[test]
+        fn add_index_via_inline_constraint() {
+            // Existing table without index -> table with inline index
+            let plan = diff_schemas(
+                &[table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+                &[table(
+                    "users",
+                    vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_index("name", ColumnType::Simple(SimpleColumnType::Text)),
+                    ],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::AddIndex { table, index } = &plan.actions[0] {
+                assert_eq!(table, "users");
+                assert_eq!(index.name, "idx_users_name");
+                assert_eq!(index.columns, vec!["name".to_string()]);
+            } else {
+                panic!("Expected AddIndex action, got {:?}", plan.actions[0]);
+            }
+        }
+
+        #[test]
+        fn create_table_with_all_inline_constraints() {
+            let mut id_col = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+            id_col.primary_key = Some(PrimaryKeySyntax::Bool(true));
+            id_col.nullable = false;
+
+            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 org_id_col = col("org_id", ColumnType::Simple(SimpleColumnType::Integer));
+            org_id_col.foreign_key = Some(ForeignKeySyntax::Object(ForeignKeyDef {
+                ref_table: "orgs".into(),
+                ref_columns: vec!["id".into()],
+                on_delete: None,
+                on_update: None,
+            }));
+
+            let plan = diff_schemas(
+                &[],
+                &[table(
+                    "users",
+                    vec![id_col, email_col, name_col, org_id_col],
+                    vec![],
+                    vec![],
+                )],
+            )
+            .unwrap();
+
+            // Should have CreateTable + AddIndex
+            assert_eq!(plan.actions.len(), 2);
+
+            if let MigrationAction::CreateTable { constraints, .. } = &plan.actions[0] {
+                // Should have: PrimaryKey, Unique, ForeignKey (3 constraints)
+                assert_eq!(constraints.len(), 3);
+            } else {
+                panic!("Expected CreateTable action");
+            }
+
+            // Check for AddIndex action
+            assert!(matches!(&plan.actions[1], MigrationAction::AddIndex { .. }));
+        }
+
+        #[test]
+        fn add_constraint_to_existing_table() {
+            // Add a unique constraint to an existing table
+            let from_schema = vec![table(
+                "users",
+                vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
+                ],
+                vec![],
+                vec![],
+            )];
+
+            let to_schema = vec![table(
+                "users",
+                vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
+                ],
+                vec![vespertide_core::TableConstraint::Unique {
+                    name: Some("uq_users_email".into()),
+                    columns: vec!["email".into()],
+                }],
+                vec![],
+            )];
+
+            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::AddConstraint { table, constraint } = &plan.actions[0] {
+                assert_eq!(table, "users");
+                assert!(matches!(
+                    constraint,
+                    vespertide_core::TableConstraint::Unique { name: Some(n), columns }
+                        if n == "uq_users_email" && columns == &vec!["email".to_string()]
+                ));
+            } else {
+                panic!("Expected AddConstraint action, got {:?}", plan.actions[0]);
+            }
+        }
+
+        #[test]
+        fn remove_constraint_from_existing_table() {
+            // Remove a unique constraint from an existing table
+            let from_schema = vec![table(
+                "users",
+                vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
+                ],
+                vec![vespertide_core::TableConstraint::Unique {
+                    name: Some("uq_users_email".into()),
+                    columns: vec!["email".into()],
+                }],
+                vec![],
+            )];
+
+            let to_schema = vec![table(
+                "users",
+                vec![
+                    col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                    col("email", ColumnType::Simple(SimpleColumnType::Text)),
+                ],
+                vec![],
+                vec![],
+            )];
+
+            let plan = diff_schemas(&from_schema, &to_schema).unwrap();
+            assert_eq!(plan.actions.len(), 1);
+            if let MigrationAction::RemoveConstraint { table, constraint } = &plan.actions[0] {
+                assert_eq!(table, "users");
+                assert!(matches!(
+                    constraint,
+                    vespertide_core::TableConstraint::Unique { name: Some(n), columns }
+                        if n == "uq_users_email" && columns == &vec!["email".to_string()]
+                ));
+            } else {
+                panic!(
+                    "Expected RemoveConstraint action, got {:?}",
+                    plan.actions[0]
+                );
+            }
+        }
+
+        #[test]
+        fn diff_schemas_with_normalize_error() {
+            // Test that normalize errors are properly propagated
+            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 - should error
+                        let mut c = col1.clone();
+                        c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
+                        c
+                    },
+                ],
+                constraints: vec![],
+                indexes: vec![],
+            };
+
+            let result = diff_schemas(&[], &[table]);
+            assert!(result.is_err());
+            if let Err(PlannerError::TableValidation(msg)) = result {
+                assert!(msg.contains("Failed to normalize table"));
+                assert!(msg.contains("Duplicate index"));
+            } else {
+                panic!("Expected TableValidation error, got {:?}", result);
+            }
+        }
+
+        #[test]
+        fn diff_schemas_with_normalize_error_in_from_schema() {
+            // Test that normalize errors in 'from' schema are properly propagated
+            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 - should error
+                        let mut c = col1.clone();
+                        c.index = Some(StrOrBoolOrArray::Str("idx1".into()));
+                        c
+                    },
+                ],
+                constraints: vec![],
+                indexes: vec![],
+            };
+
+            // 'from' schema has the invalid table
+            let result = diff_schemas(&[table], &[]);
+            assert!(result.is_err());
+            if let Err(PlannerError::TableValidation(msg)) = result {
+                assert!(msg.contains("Failed to normalize table"));
+                assert!(msg.contains("Duplicate index"));
+            } else {
+                panic!("Expected TableValidation error, got {:?}", result);
+            }
+        }
+    }
+
+    // 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"
+            );
+        }
+    }
+}
diff --git a/crates/vespertide-query/src/builder.rs b/crates/vespertide-query/src/builder.rs
index 5ba23f4e..0c6cecce 100644
--- a/crates/vespertide-query/src/builder.rs
+++ b/crates/vespertide-query/src/builder.rs
@@ -24,7 +24,8 @@ pub fn build_plan_queries(
         // Build queries with the current state of the schema
         let postgres_queries =
             build_action_queries(&DatabaseBackend::Postgres, action, &evolving_schema)?;
-        let mysql_queries = build_action_queries(&DatabaseBackend::MySql, action, &evolving_schema)?;
+        let mysql_queries =
+            build_action_queries(&DatabaseBackend::MySql, action, &evolving_schema)?;
         let sqlite_queries =
             build_action_queries(&DatabaseBackend::Sqlite, action, &evolving_schema)?;
         queries.push(PlanQueries {
diff --git a/crates/vespertide-query/src/sql/delete_column.rs b/crates/vespertide-query/src/sql/delete_column.rs
index 5bf8f0e2..6f67445f 100644
--- a/crates/vespertide-query/src/sql/delete_column.rs
+++ b/crates/vespertide-query/src/sql/delete_column.rs
@@ -6,7 +6,11 @@ use super::helpers::build_drop_enum_type_sql;
 use super::types::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> {
+pub fn build_delete_column(
+    table: &str,
+    column: &str,
+    column_type: Option<&ColumnType>,
+) -> Vec<BuiltQuery> {
     let mut stmts = Vec::new();
 
     // Drop the column first
diff --git a/crates/vespertide-query/src/sql/modify_column_type.rs b/crates/vespertide-query/src/sql/modify_column_type.rs
index 3ea694a8..2550d4bf 100644
--- a/crates/vespertide-query/src/sql/modify_column_type.rs
+++ b/crates/vespertide-query/src/sql/modify_column_type.rs
@@ -125,9 +125,14 @@ pub fn build_modify_column_type(
         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) {
+                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)
@@ -137,7 +142,10 @@ pub fn build_modify_column_type(
                     .collect::<Vec<_>>()
                     .join(", ");
                 queries.push(BuiltQuery::Raw(super::types::RawSql::per_backend(
-                    format!("CREATE TYPE \"{}\" AS ENUM ({})", temp_type_name, create_temp_values),
+                    format!(
+                        "CREATE TYPE \"{}\" AS ENUM ({})",
+                        temp_type_name, create_temp_values
+                    ),
                     String::new(),
                     String::new(),
                 )));
@@ -161,7 +169,10 @@ pub fn build_modify_column_type(
 
                 // 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),
+                    format!(
+                        "ALTER TYPE \"{}\" RENAME TO \"{}\"",
+                        temp_type_name, enum_name
+                    ),
                     String::new(),
                     String::new(),
                 )));
@@ -172,15 +183,14 @@ pub fn build_modify_column_type(
             // 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 {
                 let should_create = match old_type {
-                    Some(ColumnType::Complex(ComplexColumnType::Enum { name: old_name, .. })) => {
-                        old_name != new_name
-                    }
+                    Some(ColumnType::Complex(ComplexColumnType::Enum {
+                        name: old_name, ..
+                    })) => old_name != new_name,
                     Some(_) => true, // Old type wasn't an enum
-                    None => true, // No old type
+                    None => true,    // No old type
                 };
 
-                if should_create
-                    && let Some(create_type_sql) = build_create_enum_type_sql(new_type)
+                if should_create && let Some(create_type_sql) = build_create_enum_type_sql(new_type)
                 {
                     queries.push(BuiltQuery::Raw(create_type_sql));
                 }
@@ -196,7 +206,9 @@ pub fn build_modify_column_type(
             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 {
+            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
@@ -558,7 +570,9 @@ mod tests {
 
         // Should use the safe temp type approach:
         // 1. CREATE TYPE status_new AS ENUM (...)
-        assert!(sql.contains("CREATE TYPE \"status_new\" AS ENUM ('active', 'inactive', 'pending')"));
+        assert!(
+            sql.contains("CREATE TYPE \"status_new\" AS ENUM ('active', 'inactive', 'pending')")
+        );
         // 2. ALTER TABLE ... USING column::text::status_new
         assert!(sql.contains("ALTER TABLE \"users\" ALTER COLUMN \"status\" TYPE \"status_new\" USING \"status\"::text::\"status_new\""));
         // 3. DROP TYPE status
diff --git a/crates/vespertide-query/tests/enum_migration_test.rs b/crates/vespertide-query/tests/enum_migration_test.rs
index 13660745..97ef8a10 100644
--- a/crates/vespertide-query/tests/enum_migration_test.rs
+++ b/crates/vespertide-query/tests/enum_migration_test.rs
@@ -1,117 +1,117 @@
-use vespertide_core::{
-    ColumnDef, ColumnType, ComplexColumnType, MigrationAction, MigrationPlan,
-    SimpleColumnType, TableDef,
-};
-use vespertide_core::schema::primary_key::PrimaryKeySyntax;
-use vespertide_query::{build_plan_queries, DatabaseBackend};
-
-#[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"
-    );
-}
+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"
+    );
+}

From f321125151404a9f4db8232c5daac32191f9c8ca Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 18:59:35 +0900
Subject: [PATCH 06/11] Add snapshot

---
 crates/vespertide-query/src/sql/add_column.rs |  59 ++++
 .../vespertide-query/src/sql/create_table.rs  |  53 +++
 crates/vespertide-query/src/sql/helpers.rs    |  30 ++
 .../src/sql/modify_column_type.rs             | 306 ++++++++++--------
 ..._type@add_column_with_enum_type_MySql.snap |   6 +
 ...pe@add_column_with_enum_type_Postgres.snap |   6 +
 ...type@add_column_with_enum_type_Sqlite.snap |   6 +
 ...n@create_table_with_enum_column_MySql.snap |   6 +
 ...reate_table_with_enum_column_Postgres.snap |   6 +
 ...@create_table_with_enum_column_Sqlite.snap |   6 +
 ...fy_enum_types_enum_name_changed_mysql.snap |   6 +
 ...enum_types_enum_name_changed_postgres.snap |   7 +
 ...y_enum_types_enum_name_changed_sqlite.snap |   8 +
 ...ify_enum_types_enum_same_values_mysql.snap |   5 +
 ..._enum_types_enum_same_values_postgres.snap |   5 +
 ...fy_enum_types_enum_same_values_sqlite.snap |   8 +
 ...@modify_enum_types_enum_to_text_mysql.snap |   5 +
 ...dify_enum_types_enum_to_text_postgres.snap |   6 +
 ...modify_enum_types_enum_to_text_sqlite.snap |   8 +
 ..._enum_types_enum_values_changed_mysql.snap |   5 +
 ...um_types_enum_values_changed_postgres.snap |   8 +
 ...enum_types_enum_values_changed_sqlite.snap |   8 +
 ...@modify_enum_types_text_to_enum_mysql.snap |   6 +
 ...dify_enum_types_text_to_enum_postgres.snap |   6 +
 ...modify_enum_types_text_to_enum_sqlite.snap |   8 +
 25 files changed, 452 insertions(+), 131 deletions(-)
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_MySql.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Postgres.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__add_column__tests__add_column_with_enum_type@add_column_with_enum_type_Sqlite.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_MySql.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Postgres.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__create_table__tests__create_table_with_enum_column@create_table_with_enum_column_Sqlite.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_mysql.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_postgres.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_name_changed_sqlite.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_mysql.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_postgres.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_same_values_sqlite.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_mysql.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_postgres.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_to_text_sqlite.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_mysql.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_postgres.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_enum_values_changed_sqlite.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_mysql.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_postgres.snap
 create mode 100644 crates/vespertide-query/src/sql/snapshots/vespertide_query__sql__modify_column_type__tests__modify_enum_types@modify_enum_types_text_to_enum_sqlite.snap

diff --git a/crates/vespertide-query/src/sql/add_column.rs b/crates/vespertide-query/src/sql/add_column.rs
index 99a853bd..4792bd90 100644
--- a/crates/vespertide-query/src/sql/add_column.rs
+++ b/crates/vespertide-query/src/sql/add_column.rs
@@ -492,4 +492,63 @@ 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 vespertide_core::ComplexColumnType;
+        use insta::{assert_snapshot, with_settings};
+
+        // 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 4e6c6f43..0198e6c0 100644
--- a/crates/vespertide-query/src/sql/create_table.rs
+++ b/crates/vespertide-query/src/sql/create_table.rs
@@ -365,4 +365,57 @@ 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/helpers.rs b/crates/vespertide-query/src/sql/helpers.rs
index b4627896..d2303451 100644
--- a/crates/vespertide-query/src/sql/helpers.rs
+++ b/crates/vespertide-query/src/sql/helpers.rs
@@ -381,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/modify_column_type.rs b/crates/vespertide-query/src/sql/modify_column_type.rs
index 2550d4bf..2f97c9ac 100644
--- a/crates/vespertide-query/src/sql/modify_column_type.rs
+++ b/crates/vespertide-query/src/sql/modify_column_type.rs
@@ -321,23 +321,23 @@ 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 {
@@ -362,8 +362,10 @@ 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]
@@ -523,135 +525,180 @@ mod tests {
         });
     }
 
-    #[test]
-    fn test_modify_enum_values_postgres() {
-        // Test that changing enum values uses the temp type + USING + RENAME approach
-        let old_enum = ColumnType::Complex(ComplexColumnType::Enum {
+    #[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()],
-        });
-
-        let new_enum = ColumnType::Complex(ComplexColumnType::Enum {
+        }),
+        ColumnType::Complex(ComplexColumnType::Enum {
             name: "status".into(),
             values: vec!["active".into(), "inactive".into(), "pending".into()],
-        });
-
-        let current_schema = vec![TableDef {
-            name: "users".into(),
-            columns: vec![ColumnDef {
-                name: "status".into(),
-                r#type: old_enum,
-                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(
-            &DatabaseBackend::Postgres,
-            "users",
-            "status",
-            &new_enum,
-            &current_schema,
-        )
-        .unwrap();
-
-        let sql = result
-            .iter()
-            .map(|q| q.build(DatabaseBackend::Postgres))
-            .collect::<Vec<_>>()
-            .join(";\n");
-
-        // Should use the safe temp type approach:
-        // 1. CREATE TYPE status_new AS ENUM (...)
-        assert!(
-            sql.contains("CREATE TYPE \"status_new\" AS ENUM ('active', 'inactive', 'pending')")
-        );
-        // 2. ALTER TABLE ... USING column::text::status_new
-        assert!(sql.contains("ALTER TABLE \"users\" ALTER COLUMN \"status\" TYPE \"status_new\" USING \"status\"::text::\"status_new\""));
-        // 3. DROP TYPE status
-        assert!(sql.contains("DROP TYPE \"status\""));
-        // 4. ALTER TYPE status_new RENAME TO status
-        assert!(sql.contains("ALTER TYPE \"status_new\" RENAME TO \"status\""));
-    }
-
-    #[test]
-    fn test_modify_enum_same_values_postgres() {
-        // Test that keeping same enum values doesn't trigger DROP TYPE
-        let old_enum = ColumnType::Complex(ComplexColumnType::Enum {
+        })
+    )]
+    #[case::enum_values_changed_mysql(
+        "enum_values_changed_mysql",
+        DatabaseBackend::MySql,
+        ColumnType::Complex(ComplexColumnType::Enum {
             name: "status".into(),
             values: vec!["active".into(), "inactive".into()],
-        });
-
-        let new_enum = ColumnType::Complex(ComplexColumnType::Enum {
+        }),
+        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()],
-        });
-
-        let current_schema = vec![TableDef {
-            name: "users".into(),
-            columns: vec![ColumnDef {
-                name: "status".into(),
-                r#type: old_enum,
-                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(
-            &DatabaseBackend::Postgres,
-            "users",
-            "status",
-            &new_enum,
-            &current_schema,
-        )
-        .unwrap();
-
-        let sql = result
-            .iter()
-            .map(|q| q.build(DatabaseBackend::Postgres))
-            .collect::<Vec<_>>()
-            .join(";\n");
-
-        // Should NOT have CREATE TYPE (enum already exists)
-        assert!(!sql.contains("CREATE TYPE"));
-        // Should have ALTER TABLE
-        assert!(sql.contains("ALTER TABLE"));
-        // Should NOT have DROP TYPE (values haven't changed)
-        assert!(!sql.contains("DROP TYPE"));
-    }
-
-    #[test]
-    fn test_modify_enum_name_postgres() {
-        // Test that changing enum name triggers DROP TYPE for old and CREATE TYPE for new
-        let old_enum = ColumnType::Complex(ComplexColumnType::Enum {
+        }),
+        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()],
-        });
-
-        let new_enum = ColumnType::Complex(ComplexColumnType::Enum {
+        }),
+        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_enum,
+                r#type: old_type,
                 nullable: true,
                 default: None,
                 comment: None,
@@ -665,25 +712,22 @@ mod tests {
         }];
 
         let result = build_modify_column_type(
-            &DatabaseBackend::Postgres,
+            &backend,
             "users",
             "status",
-            &new_enum,
+            &new_type,
             &current_schema,
         )
         .unwrap();
 
         let sql = result
             .iter()
-            .map(|q| q.build(DatabaseBackend::Postgres))
+            .map(|q| q.build(backend))
             .collect::<Vec<_>>()
             .join(";\n");
 
-        // Should have CREATE TYPE with new name
-        assert!(sql.contains("CREATE TYPE \"new_status\""));
-        // Should have ALTER TABLE
-        assert!(sql.contains("ALTER TABLE"));
-        // Should have DROP TYPE for old name
-        assert!(sql.contains("DROP TYPE IF EXISTS \"old_status\""));
+        with_settings!({ snapshot_suffix => format!("modify_enum_types_{}", title) }, {
+            assert_snapshot!(sql);
+        });
     }
 }
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 00000000..c0eac35a
--- /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 00000000..779b0194
--- /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 00000000..3636feea
--- /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 00000000..c7b1fd8b
--- /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 00000000..cdaeea89
--- /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 00000000..c9309244
--- /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 00000000..4179df46
--- /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 00000000..1d15b029
--- /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 00000000..edd151e9
--- /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 00000000..610b2213
--- /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 00000000..c13f6746
--- /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 00000000..edd151e9
--- /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 00000000..39872f7d
--- /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 00000000..cc1af409
--- /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 00000000..b3f2ca07
--- /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 00000000..49257590
--- /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 00000000..cc7060ca
--- /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 00000000..edd151e9
--- /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 00000000..cd5181a0
--- /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 00000000..1cbd184a
--- /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 00000000..edd151e9
--- /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"

From 0b4753520c290109cfca9f9e7e4d3ed5256f1d7d Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 19:46:48 +0900
Subject: [PATCH 07/11] Add coverage

---
 crates/vespertide-core/src/schema/table.rs    | 2789 +++++++++--------
 crates/vespertide-planner/src/diff.rs         |   89 +-
 .../src/sql/modify_column_type.rs             |   52 +-
 3 files changed, 1531 insertions(+), 1399 deletions(-)

diff --git a/crates/vespertide-core/src/schema/table.rs b/crates/vespertide-core/src/schema/table.rs
index e5cda51c..63ce6634 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-planner/src/diff.rs b/crates/vespertide-planner/src/diff.rs
index 640a4024..735315db 100644
--- a/crates/vespertide-planner/src/diff.rs
+++ b/crates/vespertide-planner/src/diff.rs
@@ -96,6 +96,15 @@ fn topological_sort_tables<'a>(tables: &[&'a TableDef]) -> Result<Vec<&'a TableD
 
 /// 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
@@ -117,13 +126,7 @@ fn sort_delete_tables(actions: &mut [MigrationAction], all_tables: &HashMap<&str
     // Extract table names being deleted
     let delete_table_names: HashSet<&str> = delete_indices
         .iter()
-        .filter_map(|&i| {
-            if let MigrationAction::DeleteTable { table } = &actions[i] {
-                Some(table.as_str())
-            } else {
-                None
-            }
-        })
+        .map(|&i| extract_delete_table_name(&actions[i]))
         .collect();
 
     // Build dependency graph for tables being deleted
@@ -187,16 +190,8 @@ fn sort_delete_tables(actions: &mut [MigrationAction], all_tables: &HashMap<&str
         delete_indices.iter().map(|&i| actions[i].clone()).collect();
 
     delete_actions.sort_by(|a, b| {
-        let a_name = if let MigrationAction::DeleteTable { table } = a {
-            table.as_str()
-        } else {
-            ""
-        };
-        let b_name = if let MigrationAction::DeleteTable { table } = b {
-            table.as_str()
-        } else {
-            ""
-        };
+        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);
@@ -1301,5 +1296,65 @@ mod tests {
                 "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-query/src/sql/modify_column_type.rs b/crates/vespertide-query/src/sql/modify_column_type.rs
index 2f97c9ac..329abe18 100644
--- a/crates/vespertide-query/src/sql/modify_column_type.rs
+++ b/crates/vespertide-query/src/sql/modify_column_type.rs
@@ -182,12 +182,21 @@ pub fn build_modify_column_type(
 
             // 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 {
-                let should_create = match old_type {
-                    Some(ColumnType::Complex(ComplexColumnType::Enum {
-                        name: old_name, ..
-                    })) => old_name != new_name,
-                    Some(_) => true, // Old type wasn't an enum
-                    None => true,    // No old 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(old_col_type) = old_type {
+                    match old_col_type {
+                        ColumnType::Complex(ComplexColumnType::Enum { name: old_name, .. }) => {
+                            old_name != new_name
+                        }
+                        _ => true, // Old type wasn't an enum, need to create enum type
+                    }
+                } else {
+                    // old_type is None - this means the column wasn't found in current schema
+                    // This should not happen as we're modifying an existing column
+                    // But we'll create the type to be safe
+                    true
                 };
 
                 if should_create && let Some(create_type_sql) = build_create_enum_type_sql(new_type)
@@ -730,4 +739,35 @@ mod tests {
             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"));
+    }
 }

From 3537e75e314bbc1255d34841168baf585aea0bb8 Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 20:30:30 +0900
Subject: [PATCH 08/11] Support enum

---
 .changepacks/changepack_log_4sB2YBEV80GvtBNjS_r76.json | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .changepacks/changepack_log_4sB2YBEV80GvtBNjS_r76.json

diff --git a/.changepacks/changepack_log_4sB2YBEV80GvtBNjS_r76.json b/.changepacks/changepack_log_4sB2YBEV80GvtBNjS_r76.json
new file mode 100644
index 00000000..f58c0dcd
--- /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

From 94c02816c80362c6b9fa9be7e9756fb073d73126 Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 20:47:29 +0900
Subject: [PATCH 09/11] Support enum

---
 Cargo.lock                         | 1 +
 crates/vespertide-query/Cargo.toml | 1 +
 2 files changed, 2 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 5c9ec464..d5e50f28 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3044,6 +3044,7 @@ dependencies = [
  "sea-query 0.32.7",
  "thiserror",
  "vespertide-core",
+ "vespertide-planner",
 ]
 
 [[package]]
diff --git a/crates/vespertide-query/Cargo.toml b/crates/vespertide-query/Cargo.toml
index e7be3dd1..a4a993bf 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"
 

From 2665405f839ea6a5c1b217b4f99d389abc0b1639 Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 20:53:00 +0900
Subject: [PATCH 10/11] Support enum

---
 Cargo.lock                         | 1 +
 crates/vespertide-macro/Cargo.toml | 1 +
 2 files changed, 2 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index d5e50f28..3700bff3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3023,6 +3023,7 @@ dependencies = [
  "vespertide-config",
  "vespertide-core",
  "vespertide-loader",
+ "vespertide-planner",
  "vespertide-query",
 ]
 
diff --git a/crates/vespertide-macro/Cargo.toml b/crates/vespertide-macro/Cargo.toml
index d63d6f50..66b1df8e 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"

From 39e13a1a5b5721ff61cd988ac54bd60cda256bd3 Mon Sep 17 00:00:00 2001
From: owjs3901 <owjs3901@gmail.com>
Date: Wed, 17 Dec 2025 21:11:05 +0900
Subject: [PATCH 11/11] Support enum

---
 crates/vespertide-planner/src/diff.rs         | 26 ++++++++--
 crates/vespertide-query/src/sql/add_column.rs | 10 +---
 .../vespertide-query/src/sql/create_table.rs  |  3 +-
 .../src/sql/modify_column_type.rs             | 48 +++++++++----------
 4 files changed, 47 insertions(+), 40 deletions(-)

diff --git a/crates/vespertide-planner/src/diff.rs b/crates/vespertide-planner/src/diff.rs
index 735315db..94e238be 100644
--- a/crates/vespertide-planner/src/diff.rs
+++ b/crates/vespertide-planner/src/diff.rs
@@ -1304,8 +1304,18 @@ mod tests {
             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![]),
+                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![
@@ -1324,8 +1334,16 @@ mod tests {
             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 { .. })));
+            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)
diff --git a/crates/vespertide-query/src/sql/add_column.rs b/crates/vespertide-query/src/sql/add_column.rs
index 4792bd90..fdeb7bb1 100644
--- a/crates/vespertide-query/src/sql/add_column.rs
+++ b/crates/vespertide-query/src/sql/add_column.rs
@@ -498,8 +498,8 @@ mod tests {
     #[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 vespertide_core::ComplexColumnType;
         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 {
@@ -532,13 +532,7 @@ mod tests {
             constraints: vec![],
             indexes: vec![],
         }];
-        let result = build_add_column(
-            &backend,
-            "users",
-            &column,
-            None,
-            &current_schema,
-        );
+        let result = build_add_column(&backend, "users", &column, None, &current_schema);
         assert!(result.is_ok());
         let queries = result.unwrap();
         let sql = queries
diff --git a/crates/vespertide-query/src/sql/create_table.rs b/crates/vespertide-query/src/sql/create_table.rs
index 0198e6c0..feaaf21e 100644
--- a/crates/vespertide-query/src/sql/create_table.rs
+++ b/crates/vespertide-query/src/sql/create_table.rs
@@ -404,8 +404,7 @@ mod tests {
             columns: vec!["id".into()],
         }];
 
-        let result =
-            build_create_table(&backend, "users", &columns, &constraints);
+        let result = build_create_table(&backend, "users", &columns, &constraints);
         assert!(result.is_ok());
         let queries = result.unwrap();
         let sql = queries
diff --git a/crates/vespertide-query/src/sql/modify_column_type.rs b/crates/vespertide-query/src/sql/modify_column_type.rs
index 329abe18..48a543cc 100644
--- a/crates/vespertide-query/src/sql/modify_column_type.rs
+++ b/crates/vespertide-query/src/sql/modify_column_type.rs
@@ -185,17 +185,14 @@ pub fn build_modify_column_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(old_col_type) = old_type {
-                    match old_col_type {
-                        ColumnType::Complex(ComplexColumnType::Enum { name: old_name, .. }) => {
-                            old_name != new_name
-                        }
-                        _ => true, // Old type wasn't an enum, need to create enum type
-                    }
+                let should_create = if let Some(ColumnType::Complex(ComplexColumnType::Enum {
+                    name: old_name,
+                    ..
+                })) = old_type
+                {
+                    old_name != new_name
                 } else {
-                    // old_type is None - this means the column wasn't found in current schema
-                    // This should not happen as we're modifying an existing column
-                    // But we'll create the type to be safe
+                    // Either old_type is None or it wasn't an enum - need to create enum type
                     true
                 };
 
@@ -339,10 +336,12 @@ mod tests {
             &[],
         );
         assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("Table 'nonexistent_table' not found"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("Table 'nonexistent_table' not found")
+        );
     }
 
     #[test]
@@ -371,10 +370,12 @@ mod tests {
             &current_schema,
         );
         assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .to_string()
-            .contains("Column 'nonexistent_column' not found"));
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("Column 'nonexistent_column' not found")
+        );
     }
 
     #[rstest]
@@ -720,14 +721,9 @@ mod tests {
             indexes: vec![],
         }];
 
-        let result = build_modify_column_type(
-            &backend,
-            "users",
-            "status",
-            &new_type,
-            &current_schema,
-        )
-        .unwrap();
+        let result =
+            build_modify_column_type(&backend, "users", "status", &new_type, &current_schema)
+                .unwrap();
 
         let sql = result
             .iter()