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

use crate::parser::ConstraintInfo;
use itertools::Itertools;
use pg_query::{
    protobuf::{AExprKind, RoleSpecType, SqlValueFunctionOp, TypeName},
    Node, NodeEnum,
};

pub fn node_to_embed_constraint(node: &Node) -> Option<ConstraintInfo> {
    match &node.node {
        Some(NodeEnum::Constraint(v)) => ConstraintInfo::try_from(v.as_ref()).ok(),
        _ => None,
    }
}

pub fn type_name_to_string(n: &TypeName) -> String {
    let typname = n.names.iter().filter_map(node_to_string).join(".");
    let typmod = n.typmods.iter().filter_map(node_to_string).join("");
    let array_bounds = array_bounds_to_string(&n.array_bounds);

    match (typmod.as_str(), array_bounds.as_str()) {
        ("", "") => typname,
        ("", b) => format!("{}{}", typname, b),
        (m, "") => format!("{}({})", typname, m),
        (m, b) => format!("{}({}){}", typname, m, b),
    }
}

pub fn array_bounds_to_string(bounds: &[Node]) -> String {
    bounds
        .iter()
        .filter_map(node_to_string)
        .map(|s| {
            if s == "-1" {
                "[]".to_owned()
            } else {
                format!("[{}]", s)
            }
        })
        .join("")
}

pub fn node_to_string(node: &Node) -> Option<String> {
    match &node.node {
        Some(n) => node_enum_to_string(n),
        _ => None,
    }
}

pub fn node_enum_to_string(node: &NodeEnum) -> Option<String> {
    match node {
        NodeEnum::String(s) => Some(s.str.clone()),
        NodeEnum::Integer(i) => Some(i.ival.to_string()),
        NodeEnum::AConst(a) => a.val.as_ref().and_then(|v| match &v.node {
            Some(NodeEnum::String(s)) => Some(format!("'{}'", s.str)),
            Some(NodeEnum::Integer(i)) => Some(i.ival.to_string()),
            _ => None,
        }),
        NodeEnum::FuncCall(f) => {
            let fname = f.funcname.iter().filter_map(node_to_string).join(".");
            let args = f.args.iter().filter_map(node_to_string).join(", ");
            Some(format!("{}({})", fname, args))
        }
        NodeEnum::AExpr(e) => {
            let left = e.lexpr.as_deref().and_then(node_to_string);
            let right = e.rexpr.as_deref().and_then(node_to_string);
            let op = e.name.iter().filter_map(node_to_string).join(".");
            let op_kind = e.kind();
            match (left, right) {
                (Some(l), Some(r)) => match e.kind() {
                    AExprKind::AexprOp => Some(format!("{} {} {}", l, op, r)),
                    AExprKind::AexprOpAll => Some(format!("{} {} ALL ({})", l, op, r)),
                    AExprKind::AexprOpAny => Some(format!("{} {} ANY ({})", l, op, r)),
                    _ => panic!("Unsupported AExprKind: {:?}", op_kind),
                },
                (l, r) => panic!("Expect left and right to exists. Got {:?} and {:?}", l, r),
            }
        }
        NodeEnum::TypeCast(c) => {
            let arg = c.arg.as_deref().and_then(node_to_string);
            let typname = c
                .type_name
                .as_ref()
                .map(|t| t.names.iter().filter_map(node_to_string).join("."));
            match (arg, typname) {
                (Some(a), Some(t)) => Some(format!("{}::{}", a, t)),
                _ => None,
            }
        }
        NodeEnum::TypeName(t) => Some(type_name_to_string(t)),
        NodeEnum::ColumnRef(c) => {
            let fields = c.fields.iter().filter_map(node_to_string).join(",");
            Some(fields)
        }
        NodeEnum::SqlvalueFunction(f) => match f.op() {
            SqlValueFunctionOp::SvfopCurrentUser => Some("CURRENT_USER".to_owned()),
            SqlValueFunctionOp::SvfopCurrentRole => Some("CURRENT_ROLE".to_owned()),
            op => unimplemented!("Unsupported SqlValueFunctionOp: {:?}", op),
        },
        NodeEnum::AArrayExpr(a) => {
            let elements = a.elements.iter().filter_map(node_to_string).join(",");
            Some(format!("ARRAY [{}]", elements))
        }
        NodeEnum::RoleSpec(r) => match r.roletype() {
            RoleSpecType::RolespecCstring => Some(r.rolename.clone()),
            RoleSpecType::RolespecCurrentUser => Some("CURRENT_USER".to_owned()),
            RoleSpecType::RolespecSessionUser => Some("SESSION_USER".to_owned()),
            RoleSpecType::RolespecPublic => None,
            RoleSpecType::Undefined => None,
        },
        _ => None,
    }
}