Skip to main content

uqa_sql/ast/types/
identity.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! OID identities of user-defined types. Stored syntax, routine signatures and bound casts name a user-defined type by identity, so a rename, a schema move or a different search path cannot change which type they mean; output spells the type's current name. `#` cannot occur in an unquoted type name, and quoted names keep their quotes, so an identity never collides with a name as written.
8
9use super::ColumnType;
10
11const ENUM_PREFIX: &str = "enum#";
12const DOMAIN_PREFIX: &str = "domain#";
13const COMPOSITE_PREFIX: &str = "composite#";
14const RANGE_PREFIX: &str = "range#";
15const MULTIRANGE_PREFIX: &str = "multirange#";
16
17pub(super) fn write_identity(ty: &ColumnType, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18    match ty {
19        ColumnType::Enum(reference) => write!(f, "{ENUM_PREFIX}{}", reference.oid),
20        ColumnType::Composite(reference) => write!(f, "{COMPOSITE_PREFIX}{}", reference.oid),
21        ColumnType::DeclaredRange(reference) => write!(f, "{RANGE_PREFIX}{}", reference.oid),
22        ColumnType::DeclaredMultirange(reference) => {
23            write!(f, "{MULTIRANGE_PREFIX}{}", reference.oid)
24        }
25        ColumnType::Domain { oid, .. } => write!(f, "{DOMAIN_PREFIX}{oid}"),
26        _ => unreachable!("catalog identity formatter requires a user-defined scalar type"),
27    }
28}
29
30#[derive(Debug, Clone, Copy, PartialEq, Eq)]
31pub enum UserTypeKind {
32    Enum,
33    Domain,
34    Composite,
35    Range,
36    Multirange,
37}
38
39/// A parsed identity: the type's kind and OID, and the number of array dimensions around it.
40#[derive(Debug, Clone, Copy, PartialEq, Eq)]
41pub struct UserTypeIdentity {
42    pub kind: UserTypeKind,
43    pub oid: u32,
44    pub dimensions: usize,
45}
46
47impl UserTypeIdentity {
48    /// Parse `enum#<oid>`, `domain#<oid>` or `composite#<oid>` with any number of `[]` suffixes.
49    #[must_use]
50    pub fn parse(name: &str) -> Option<Self> {
51        let mut element = name.trim();
52        let mut dimensions = 0usize;
53        while let Some(inner) = element.strip_suffix("[]") {
54            element = inner;
55            dimensions += 1;
56        }
57        let (kind, oid) = if let Some(oid) = element.strip_prefix(ENUM_PREFIX) {
58            (UserTypeKind::Enum, oid)
59        } else if let Some(oid) = element.strip_prefix(COMPOSITE_PREFIX) {
60            (UserTypeKind::Composite, oid)
61        } else if let Some(oid) = element.strip_prefix(RANGE_PREFIX) {
62            (UserTypeKind::Range, oid)
63        } else if let Some(oid) = element.strip_prefix(MULTIRANGE_PREFIX) {
64            (UserTypeKind::Multirange, oid)
65        } else {
66            (UserTypeKind::Domain, element.strip_prefix(DOMAIN_PREFIX)?)
67        };
68        if oid.is_empty() || !oid.bytes().all(|byte| byte.is_ascii_digit()) {
69            return None;
70        }
71        Some(Self {
72            kind,
73            oid: oid.parse().ok()?,
74            dimensions,
75        })
76    }
77}
78
79impl ColumnType {
80    /// The identity of a user-defined type or an array of one; built-in types have none.
81    #[must_use]
82    pub fn user_type_identity(&self) -> Option<String> {
83        match self {
84            ColumnType::Enum(reference) => Some(format!("{ENUM_PREFIX}{}", reference.oid)),
85            ColumnType::Composite(reference) => {
86                Some(format!("{COMPOSITE_PREFIX}{}", reference.oid))
87            }
88            ColumnType::Domain { oid, .. } => Some(format!("{DOMAIN_PREFIX}{oid}")),
89            ColumnType::DeclaredRange(reference) => {
90                Some(format!("{RANGE_PREFIX}{}", reference.oid))
91            }
92            ColumnType::DeclaredMultirange(reference) => {
93                Some(format!("{MULTIRANGE_PREFIX}{}", reference.oid))
94            }
95            ColumnType::Array(element) => element
96                .user_type_identity()
97                .map(|element| format!("{element}[]")),
98            _ => None,
99        }
100    }
101}
102
103#[cfg(test)]
104mod tests {
105    use super::{UserTypeIdentity, UserTypeKind};
106    use crate::ast::{ColumnType, EnumTypeReference};
107
108    #[test]
109    fn identities_round_trip_through_arrays() {
110        let mood = ColumnType::Enum(EnumTypeReference {
111            schema: "public".into(),
112            name: "mood".into(),
113            oid: 20_000,
114            array_oid: 20_001,
115        });
116        let array = ColumnType::Array(Box::new(ColumnType::Array(Box::new(mood))));
117        let identity = array.user_type_identity().unwrap();
118        assert_eq!(identity, "enum#20000[][]");
119        assert_eq!(
120            UserTypeIdentity::parse(&identity),
121            Some(UserTypeIdentity {
122                kind: UserTypeKind::Enum,
123                oid: 20_000,
124                dimensions: 2,
125            })
126        );
127        assert_eq!(
128            UserTypeIdentity::parse("composite#9[]"),
129            Some(UserTypeIdentity {
130                kind: UserTypeKind::Composite,
131                oid: 9,
132                dimensions: 1,
133            })
134        );
135        assert_eq!(
136            UserTypeIdentity::parse("domain#7"),
137            Some(UserTypeIdentity {
138                kind: UserTypeKind::Domain,
139                oid: 7,
140                dimensions: 0,
141            })
142        );
143        for name in ["\"enum#1\"", "enum#", "enum#x", "domain#-1", "integer"] {
144            assert_eq!(UserTypeIdentity::parse(name), None, "{name}");
145        }
146        assert_eq!(ColumnType::Integer.user_type_identity(), None);
147    }
148}