vespertide-query 0.1.49

Converts migration actions into SQL statements with bind parameters
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use vespertide_core::schema::primary_key::PrimaryKeySyntax;
use vespertide_core::{
    ColumnDef, ColumnType, ComplexColumnType, EnumValues, 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 {
        id: String::new(),
        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: EnumValues::String(vec![
                    "active".into(),
                    "inactive".into(),
                    "pending".into(),
                ]),
            }),
            fill_with: None,
        }],
    };

    // Baseline schema after migration 0002 (with 2-value enum)
    let baseline_schema = vec![TableDef {
        name: "user".into(),
        description: None,
        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: EnumValues::String(vec!["active".into(), "inactive".into()]),
                }),
                nullable: true,
                default: None,
                comment: None,
                primary_key: None,
                unique: None,
                index: None,
                foreign_key: None,
            },
        ],
        constraints: 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 user_status_new (table-prefixed)
    assert!(
        sql0.contains("CREATE TYPE \"user_status_new\""),
        "Step 1 should create temp type with table prefix. Got: {}",
        sql0
    );
    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 \"user_status_new\""),
        "Should change column type to temp with table prefix. Got: {}",
        sql1
    );
    assert!(
        sql1.contains("USING \"status\"::text::\"user_status_new\""),
        "Should use USING clause with table prefix. Got: {}",
        sql1
    );

    // 3. DROP TYPE user_status (table-prefixed)
    assert!(
        sql2.contains("DROP TYPE \"user_status\""),
        "Step 3 should drop old type with table prefix. Got: {}",
        sql2
    );

    // 4. RENAME TYPE user_status_new to user_status (table-prefixed)
    assert!(
        sql3.contains("ALTER TYPE \"user_status_new\" RENAME TO \"user_status\""),
        "Step 4 should rename temp type back with table prefix. Got: {}",
        sql3
    );
}