pgmt 0.5.0

PostgreSQL migration tool that keeps your schema files as the source of truth
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

use crate::catalog::table::Table;
use crate::diff::operations::{ColumnAction, MigrationStep, TableOperation};
use crate::diff::{columns, diff_list};

pub fn diff(old: Option<&Table>, new: Option<&Table>) -> Vec<MigrationStep> {
    match (old, new) {
        (None, Some(n)) => {
            let mut steps = vec![MigrationStep::Table(TableOperation::Create {
                schema: n.schema.clone(),
                name: n.name.clone(),
                columns: n.columns.clone(),
                primary_key: n.primary_key.clone(),
            })];

            // Add RLS settings if enabled
            if n.rls_enabled {
                steps.push(MigrationStep::Table(TableOperation::Alter {
                    schema: n.schema.clone(),
                    name: n.name.clone(),
                    actions: vec![ColumnAction::EnableRls],
                }));
            }

            if n.rls_forced {
                steps.push(MigrationStep::Table(TableOperation::Alter {
                    schema: n.schema.clone(),
                    name: n.name.clone(),
                    actions: vec![ColumnAction::ForceRls],
                }));
            }

            steps
        }
        (Some(o), None) => {
            vec![MigrationStep::Table(TableOperation::Drop {
                schema: o.schema.clone(),
                name: o.name.clone(),
            })]
        }
        (Some(o), Some(n)) => {
            // The old PK must drop before any column action: PostgreSQL silently
            // drops a constraint when one of its columns is dropped, so an explicit
            // DROP CONSTRAINT emitted afterwards fails. The new PK goes after the
            // column actions so it can reference freshly added columns.
            let (drop_pk, add_pk) = match (&o.primary_key, &n.primary_key) {
                (None, None) => (None, None),
                (Some(o_pk), Some(n_pk)) if o_pk == n_pk => (None, None),
                (None, Some(pk)) => (None, Some(pk.clone())),
                (Some(pk), None) => (Some(pk.name.clone()), None),
                (Some(o_pk), Some(n_pk)) => {
                    let structure_same = o_pk.name == n_pk.name && o_pk.columns == n_pk.columns;
                    if structure_same && o_pk.comment != n_pk.comment {
                        // Only the comment changed — keep the PK; its comment is
                        // handled centrally by `crate::diff::comments`.
                        (None, None)
                    } else {
                        (Some(o_pk.name.clone()), Some(n_pk.clone()))
                    }
                }
            };

            let mut actions: Vec<ColumnAction> = Vec::new();

            if let Some(name) = drop_pk {
                actions.push(ColumnAction::DropPrimaryKey { name });
            }

            actions.extend(diff_list(
                &o.columns,
                &n.columns,
                |c| c.name.clone(),
                columns::diff,
            ));

            if let Some(constraint) = add_pk {
                actions.push(ColumnAction::AddPrimaryKey { constraint });
            }

            // Check RLS settings changes
            if o.rls_enabled != n.rls_enabled {
                if n.rls_enabled {
                    actions.push(ColumnAction::EnableRls);
                } else {
                    actions.push(ColumnAction::DisableRls);
                }
            }

            if o.rls_forced != n.rls_forced {
                if n.rls_forced {
                    actions.push(ColumnAction::ForceRls);
                } else {
                    actions.push(ColumnAction::NoForceRls);
                }
            }

            let mut steps = Vec::new();

            if !actions.is_empty() {
                steps.push(MigrationStep::Table(TableOperation::Alter {
                    schema: n.schema.clone(),
                    name: n.name.clone(),
                    actions,
                }));
            }

            steps
        }
        _ => Vec::new(),
    }
}