pgevolve-core 0.4.2

Postgres declarative schema management — core library (parser, IR, diff, planner) powering the pgevolve CLI.
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

//! Canon for `Catalog::aggregates`: sort by `(schema, name, arg_types)` and
//! reject duplicate `(qname, arg_types)` overload identities.

use crate::ir::IrError;
use crate::ir::catalog::Catalog;
use crate::ir::column_type::ColumnType;

/// Build a stable sort/identity string for a slice of [`ColumnType`].
///
/// `ColumnType` does not implement `Ord`, so we derive a key from
/// [`ColumnType::render_sql`] which is stable and unique for each type.
fn arg_types_key(arg_types: &[ColumnType]) -> String {
    arg_types
        .iter()
        .map(ColumnType::render_sql)
        .collect::<Vec<_>>()
        .join(",")
}

/// Canonicalize all aggregates in `cat`.
///
/// - The collection is sorted by `(schema, name, arg_types_key)`.
/// - A duplicate `(qname, arg_types)` identity raises [`IrError::DuplicateAggregate`].
pub fn run(cat: &mut Catalog) -> Result<(), IrError> {
    cat.aggregates.sort_by(|a, b| {
        a.qname
            .schema
            .cmp(&b.qname.schema)
            .then_with(|| a.qname.name.cmp(&b.qname.name))
            .then_with(|| arg_types_key(&a.arg_types).cmp(&arg_types_key(&b.arg_types)))
    });
    for w in cat.aggregates.windows(2) {
        if w[0].qname == w[1].qname && w[0].arg_types == w[1].arg_types {
            return Err(IrError::DuplicateAggregate(w[0].qname.clone()));
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::identifier::{Identifier, QualifiedName};
    use crate::ir::aggregate::Aggregate;
    use crate::ir::column_type::ColumnType;

    fn id(s: &str) -> Identifier {
        Identifier::from_unquoted(s).unwrap()
    }

    fn qname(schema: &str, name: &str) -> QualifiedName {
        QualifiedName::new(id(schema), id(name))
    }

    fn agg(schema: &str, name: &str, arg_types: Vec<ColumnType>) -> Aggregate {
        Aggregate {
            qname: qname(schema, name),
            arg_types,
            state_type: ColumnType::BigInt,
            sfunc: qname("app", "sfunc"),
            finalfunc: None,
            initcond: None,
            owner: None,
            comment: None,
        }
    }

    #[test]
    fn sorts_by_name() {
        let mut cat = Catalog::empty();
        cat.aggregates
            .push(agg("app", "zzz_agg", vec![ColumnType::Integer]));
        cat.aggregates
            .push(agg("app", "aaa_agg", vec![ColumnType::Integer]));
        run(&mut cat).unwrap();
        assert_eq!(cat.aggregates[0].qname.name.as_str(), "aaa_agg");
        assert_eq!(cat.aggregates[1].qname.name.as_str(), "zzz_agg");
    }

    #[test]
    fn rejects_duplicate_overload_identity() {
        let mut cat = Catalog::empty();
        cat.aggregates
            .push(agg("app", "my_sum", vec![ColumnType::Integer]));
        cat.aggregates
            .push(agg("app", "my_sum", vec![ColumnType::Integer]));
        assert!(matches!(
            run(&mut cat).unwrap_err(),
            IrError::DuplicateAggregate(_)
        ));
    }

    #[test]
    fn allows_distinct_overloads_same_name() {
        let mut cat = Catalog::empty();
        cat.aggregates
            .push(agg("app", "my_sum", vec![ColumnType::Integer]));
        cat.aggregates
            .push(agg("app", "my_sum", vec![ColumnType::BigInt]));
        run(&mut cat).unwrap();
        assert_eq!(cat.aggregates.len(), 2);
    }
}