renovate 0.2.23

A new way to handle Postgres schema migration.
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
129
130
131
132
133
134
135
136
137
138
139

use crate::{
    parser::{AlterTable, AlterTableAction, ConstraintInfo, RelationId, SchemaId, TableConstraint},
    NodeItem,
};
use pg_query::{
    protobuf::{AlterTableStmt, Constraint as PgConstraint},
    NodeEnum, NodeRef,
};

impl NodeItem for TableConstraint {
    type Inner = AlterTableStmt;

    fn id(&self) -> String {
        self.id.name.clone()
    }

    fn type_name(&self) -> &'static str {
        "constraint"
    }

    fn node(&self) -> &NodeEnum {
        &self.node
    }

    fn inner(&self) -> anyhow::Result<&Self::Inner> {
        match &self.node {
            NodeEnum::AlterTableStmt(stmt) => Ok(stmt),
            _ => anyhow::bail!("not a alter table statement"),
        }
    }

    fn revert(&self) -> anyhow::Result<NodeEnum> {
        let sql = format!(
            "ALTER TABLE ONLY {} DROP CONSTRAINT {}",
            self.id.schema_id, self.id.name
        );
        let parsed = pg_query::parse(&sql)?;
        let node = parsed.protobuf.nodes()[0].0;
        match node {
            NodeRef::AlterTableStmt(stmt) => Ok(NodeEnum::AlterTableStmt(stmt.clone())),
            _ => anyhow::bail!("not a alter table drop constraint statement"),
        }
    }
}

impl TryFrom<AlterTable> for TableConstraint {
    type Error = anyhow::Error;
    fn try_from(AlterTable { id, action, node }: AlterTable) -> Result<Self, Self::Error> {
        match action {
            AlterTableAction::Constraint(info) => Ok(TableConstraint::new(id, *info, node)),
            _ => anyhow::bail!("not an add constraint"),
        }
    }
}

impl TableConstraint {
    fn new(id: SchemaId, info: ConstraintInfo, node: NodeEnum) -> Self {
        let id = RelationId::new_with(id, info.name.clone());
        Self { id, info, node }
    }
}

impl TryFrom<&PgConstraint> for ConstraintInfo {
    type Error = anyhow::Error;
    fn try_from(constraint: &PgConstraint) -> Result<Self, Self::Error> {
        let con_type = constraint.contype();
        let node = NodeEnum::Constraint(Box::new(constraint.clone()));
        let name = constraint.conname.clone();
        Ok(Self {
            name,
            con_type,
            node,
        })
    }
}

#[cfg(test)]
mod tests {
    use pg_query::protobuf::ConstrType;

    use super::*;
    use crate::{Differ, MigrationPlanner};

    #[test]
    fn alter_table_constraint_should_parse() {
        let sql = "ALTER TABLE ONLY users ADD CONSTRAINT users_pkey PRIMARY KEY (id)";
        let parsed: TableConstraint = sql.parse().unwrap();
        assert_eq!(parsed.id.name, "users_pkey");
        assert_eq!(parsed.id.schema_id.to_string(), "public.users");
        assert_eq!(parsed.info.name, "users_pkey");
        assert_eq!(parsed.info.con_type, ConstrType::ConstrPrimary);
    }

    #[test]
    fn alter_table_constraint_should_revert() {
        let sql = "ALTER TABLE ONLY users ADD CONSTRAINT users_pkey PRIMARY KEY (id)";
        let parsed: TableConstraint = sql.parse().unwrap();
        let reverted = parsed.revert().unwrap().deparse().unwrap();
        assert_eq!(
            reverted,
            "ALTER TABLE ONLY public.users DROP CONSTRAINT users_pkey"
        );
    }

    #[test]
    fn alter_table_constraint_migration_should_drop_and_create() {
        let sql1 = "ALTER TABLE ONLY users ADD CONSTRAINT users_pkey PRIMARY KEY (id)";
        let sql2 = "ALTER TABLE ONLY users ADD CONSTRAINT users_pkey PRIMARY KEY (id, name)";
        let old: TableConstraint = sql1.parse().unwrap();
        let new: TableConstraint = sql2.parse().unwrap();
        let diff = Differ::diff(&old, &new).unwrap().unwrap();
        let plan = diff.plan().unwrap();
        assert_eq!(plan.len(), 2);
        assert_eq!(
            plan[0],
            "ALTER TABLE ONLY public.users DROP CONSTRAINT users_pkey"
        );
        assert_eq!(
            plan[1],
            "ALTER TABLE ONLY users ADD CONSTRAINT users_pkey PRIMARY KEY (id, name)"
        );
    }

    #[test]
    fn alter_table_unique_constraint_migration_should_drop_and_create() {
        let sql1 = "ALTER TABLE ONLY users ADD CONSTRAINT c1 UNIQUE (name)";
        let sql2 = "ALTER TABLE ONLY users ADD CONSTRAINT c1 UNIQUE (id, name)";
        let old: TableConstraint = sql1.parse().unwrap();
        let new: TableConstraint = sql2.parse().unwrap();
        let diff = Differ::diff(&old, &new).unwrap().unwrap();
        let plan = diff.plan().unwrap();
        assert_eq!(plan.len(), 2);
        assert_eq!(plan[0], "ALTER TABLE ONLY public.users DROP CONSTRAINT c1");
        assert_eq!(
            plan[1],
            "ALTER TABLE ONLY users ADD CONSTRAINT c1 UNIQUE (id, name)"
        );
    }
}