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    /// Whether a retained value of this type may name database-owned catalog identities. Anonymous records and polymorphic arrays may contain user-defined fields or elements, so their original database remains required even without a declared outer OID.
81    #[must_use]
82    pub fn is_catalog_dependent(&self) -> bool {
83        let mut ty = self;
84        while let Self::Array(element) = ty {
85            ty = element;
86        }
87        matches!(
88            ty,
89            Self::Named(_)
90                | Self::Enum(_)
91                | Self::Composite(_)
92                | Self::Domain { .. }
93                | Self::DeclaredRange(_)
94                | Self::DeclaredMultirange(_)
95                | Self::Record
96                | Self::AnyArray
97        )
98    }
99
100    /// The identity of a user-defined type or an array of one; built-in types have none.
101    #[must_use]
102    pub fn user_type_identity(&self) -> Option<String> {
103        match self {
104            ColumnType::Enum(reference) => Some(format!("{ENUM_PREFIX}{}", reference.oid)),
105            ColumnType::Composite(reference) => {
106                Some(format!("{COMPOSITE_PREFIX}{}", reference.oid))
107            }
108            ColumnType::Domain { oid, .. } => Some(format!("{DOMAIN_PREFIX}{oid}")),
109            ColumnType::DeclaredRange(reference) => {
110                Some(format!("{RANGE_PREFIX}{}", reference.oid))
111            }
112            ColumnType::DeclaredMultirange(reference) => {
113                Some(format!("{MULTIRANGE_PREFIX}{}", reference.oid))
114            }
115            ColumnType::Array(element) => element
116                .user_type_identity()
117                .map(|element| format!("{element}[]")),
118            _ => None,
119        }
120    }
121}
122
123#[cfg(test)]
124mod tests {
125    use super::{UserTypeIdentity, UserTypeKind};
126    use crate::ast::{ColumnType, EnumTypeReference};
127
128    #[test]
129    fn identities_round_trip_through_arrays() {
130        let mood = ColumnType::Enum(EnumTypeReference {
131            schema: "public".into(),
132            name: "mood".into(),
133            oid: 20_000,
134            array_oid: 20_001,
135        });
136        let array = ColumnType::Array(Box::new(ColumnType::Array(Box::new(mood))));
137        assert!(array.is_catalog_dependent());
138        assert!(ColumnType::Record.is_catalog_dependent());
139        assert!(!ColumnType::Array(Box::new(ColumnType::Integer)).is_catalog_dependent());
140        let identity = array.user_type_identity().unwrap();
141        assert_eq!(identity, "enum#20000[][]");
142        assert_eq!(
143            UserTypeIdentity::parse(&identity),
144            Some(UserTypeIdentity {
145                kind: UserTypeKind::Enum,
146                oid: 20_000,
147                dimensions: 2,
148            })
149        );
150        assert_eq!(
151            UserTypeIdentity::parse("composite#9[]"),
152            Some(UserTypeIdentity {
153                kind: UserTypeKind::Composite,
154                oid: 9,
155                dimensions: 1,
156            })
157        );
158        assert_eq!(
159            UserTypeIdentity::parse("domain#7"),
160            Some(UserTypeIdentity {
161                kind: UserTypeKind::Domain,
162                oid: 7,
163                dimensions: 0,
164            })
165        );
166        for name in ["\"enum#1\"", "enum#", "enum#x", "domain#-1", "integer"] {
167            assert_eq!(UserTypeIdentity::parse(name), None, "{name}");
168        }
169        assert_eq!(ColumnType::Integer.user_type_identity(), None);
170    }
171}