uqa-sql 0.5.2

PostgreSQL-compatible SQL compiler built on libpg_query
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

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Catalog names carried by references to user-defined types. Identity is the OID; a rename or schema move gives every reference the type's current name.

use super::ColumnType;
use uqa_core::RelationIdentity;

impl ColumnType {
    /// Give every reference to the user-defined type `oid`, including array elements and domain bases, the type's current schema and name. Returns whether a reference changed.
    pub fn rename_user_type(&mut self, oid: u32, identity: &RelationIdentity) -> bool {
        match self {
            ColumnType::Enum(reference) if reference.oid == oid => {
                let changed =
                    reference.schema != identity.schema || reference.name != identity.name;
                reference.schema.clone_from(&identity.schema);
                reference.name.clone_from(&identity.name);
                changed
            }
            ColumnType::Composite(reference) if reference.oid == oid => {
                let changed =
                    reference.schema != identity.schema || reference.name != identity.name;
                reference.schema.clone_from(&identity.schema);
                reference.name.clone_from(&identity.name);
                changed
            }
            ColumnType::Domain {
                schema,
                name,
                oid: domain_oid,
                base,
                ..
            } => {
                let mut changed = base.rename_user_type(oid, identity);
                if *domain_oid == oid {
                    changed |= *schema != identity.schema || *name != identity.name;
                    schema.clone_from(&identity.schema);
                    name.clone_from(&identity.name);
                }
                changed
            }
            ColumnType::Array(element) => element.rename_user_type(oid, identity),
            _ => false,
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::ast::{ColumnType, EnumTypeReference};
    use uqa_core::RelationIdentity;

    #[test]
    fn renames_follow_type_identity_through_arrays_and_domain_bases() {
        let mood = ColumnType::Enum(EnumTypeReference {
            schema: "public".into(),
            name: "mood".into(),
            oid: 20_000,
            array_oid: 20_001,
        });
        let mut column = ColumnType::Array(Box::new(ColumnType::Domain {
            schema: "public".into(),
            name: "good_mood".into(),
            oid: 20_002,
            array_oid: None,
            base: Box::new(mood),
        }));
        let feeling = RelationIdentity::new("other", "feeling");
        assert!(column.rename_user_type(20_000, &feeling));
        assert!(!column.rename_user_type(20_000, &feeling));
        let ColumnType::Array(element) = &column else {
            panic!("array column");
        };
        let ColumnType::Domain { name, base, .. } = element.as_ref() else {
            panic!("domain element");
        };
        assert_eq!(name, "good_mood");
        assert!(
            matches!(base.as_ref(), ColumnType::Enum(reference) if reference.schema == "other" && reference.name == "feeling")
        );
        assert!(!column.rename_user_type(30_000, &feeling));
    }
}