Support enum

Author: owjs3901

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)

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

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

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()