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

use super::{utils::node_to_string, EnumType};
use crate::{MigrationPlanner, MigrationResult, NodeDiff, NodeItem};
use itertools::Itertools;
use pg_query::{protobuf::CreateEnumStmt, NodeEnum, NodeRef};

impl NodeItem for EnumType {
    type Inner = CreateEnumStmt;
    fn id(&self) -> String {
        self.id.to_string()
    }

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

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

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

    fn revert(&self) -> anyhow::Result<NodeEnum> {
        let sql = format!("DROP TYPE {}", self.id);
        let parsed = pg_query::parse(&sql)?;
        let node = parsed.protobuf.nodes()[0].0;
        match node {
            NodeRef::DropStmt(stmt) => Ok(NodeEnum::DropStmt(stmt.clone())),
            _ => anyhow::bail!("not a drop type statement"),
        }
    }
}

impl TryFrom<&CreateEnumStmt> for EnumType {
    type Error = anyhow::Error;
    fn try_from(stmt: &CreateEnumStmt) -> Result<Self, Self::Error> {
        let id = stmt
            .type_name
            .iter()
            .filter_map(node_to_string)
            .join(".")
            .parse()?;
        let node = NodeEnum::CreateEnumStmt(stmt.clone());
        let items = stmt.vals.iter().filter_map(node_to_string).collect();
        Ok(Self { id, items, node })
    }
}

impl MigrationPlanner for NodeDiff<EnumType> {
    type Migration = String;

    fn drop(&self) -> MigrationResult<Self::Migration> {
        if let Some(old) = &self.old {
            let sqls = vec![old.revert()?.deparse()?];
            Ok(sqls)
        } else {
            Ok(vec![])
        }
    }

    fn create(&self) -> MigrationResult<Self::Migration> {
        if let Some(new) = &self.new {
            let sqls = vec![new.node.deparse()?];
            Ok(sqls)
        } else {
            Ok(vec![])
        }
    }

    fn alter(&self) -> MigrationResult<Self::Migration> {
        match (&self.old, &self.new) {
            (Some(old), Some(new)) => {
                let added = new.items.difference(&old.items).collect::<Vec<_>>();
                let removed = old.items.difference(&new.items).collect::<Vec<_>>();
                if removed.is_empty() {
                    let migrations = added
                        .iter()
                        .map(|s| format!("ALTER TYPE {} ADD VALUE '{}'", old.id, s))
                        .collect();
                    return Ok(migrations);
                }

                if removed.len() == added.len() && removed.len() == 1 {
                    let sql = format!(
                        "ALTER TYPE {} RENAME VALUE '{}' TO '{}'",
                        old.id,
                        removed.get(0).unwrap(),
                        added.get(0).unwrap()
                    );
                    return Ok(vec![sql]);
                }

                if atty::is(atty::Stream::Stdout) {
                    println!("WARNING: recreate enum type {} because of incompatible changes. Be CAUTIOUS this migration might fail if you referenced the type in other places.", old.id);
                }
                Ok(vec![])
            }
            _ => Ok(vec![]),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{Differ, MigrationPlanner};

    #[test]
    fn enum_type_should_parse() {
        let sql = "CREATE TYPE enum_type AS ENUM ('a', 'b', 'c')";
        let enum_type: EnumType = sql.parse().unwrap();
        assert_eq!(enum_type.id.to_string(), "public.enum_type");
    }

    #[test]
    fn composite_type_should_generate_drop_create_plan() {
        let sql1 = "CREATE TYPE enum_type AS ENUM ('a', 'b', 'c')";
        let sql2 = "CREATE TYPE enum_type AS ENUM ('a', 'b', 'c', 'd', 'e')";
        let old: EnumType = sql1.parse().unwrap();
        let new: EnumType = sql2.parse().unwrap();
        let diff = old.diff(&new).unwrap().unwrap();
        let plan = diff.plan().unwrap();
        assert_eq!(plan.len(), 2);
        assert_eq!(plan[0], "ALTER TYPE public.enum_type ADD VALUE 'd'");
        assert_eq!(plan[1], "ALTER TYPE public.enum_type ADD VALUE 'e'");
    }
}