uqa_sql/ast/types/
identity.rs1use 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#[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 #[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 #[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 #[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}