uqa_sql/schema/
relation_types.rs1use super::{Arc, ColumnIdentity, ColumnType, HashMap, RowSchema};
10use crate::SQLError;
11
12#[derive(Debug, Default, Clone, PartialEq, Eq)]
14pub(super) struct RelationRowTypes(Option<Arc<RelationRows>>);
15
16#[derive(Debug, Default, Clone, PartialEq, Eq)]
17struct RelationRows {
18 types: HashMap<Box<str>, Option<ColumnType>>,
19 source: Option<Box<str>>,
21}
22
23impl RelationRowTypes {
24 pub(super) fn get(&self, qualifier: &str) -> Option<&ColumnType> {
25 self.0.as_ref()?.types.get(qualifier)?.as_ref()
26 }
27
28 pub(super) fn contains(&self, qualifier: &str) -> bool {
29 self.0
30 .as_ref()
31 .is_some_and(|rows| rows.types.contains_key(qualifier))
32 }
33
34 pub(super) fn anonymous(qualifier: &str) -> Self {
35 let mut result = Self::default();
36 result.insert(qualifier, None);
37 Arc::make_mut(result.0.as_mut().unwrap()).source = Some(qualifier.into());
38 result
39 }
40
41 pub(super) fn qualifiers(&self) -> impl Iterator<Item = &str> {
42 self.0
43 .iter()
44 .flat_map(|rows| rows.types.keys().map(std::convert::AsRef::as_ref))
45 }
46
47 fn insert(&mut self, qualifier: &str, ty: Option<ColumnType>) {
48 let rows = self
49 .0
50 .get_or_insert_with(|| Arc::new(RelationRows::default()));
51 Arc::make_mut(rows).types.insert(qualifier.into(), ty);
52 }
53
54 pub(super) fn requalified(&self, input: &RowSchema, qualifier: &str) -> Self {
56 let anonymous = || {
57 if input.is_empty() {
58 Self::anonymous(qualifier)
59 } else {
60 Self::default()
61 }
62 };
63 let Some(rows) = self.0.as_ref() else {
64 return anonymous();
65 };
66 let Some(source) = rows.source.as_deref() else {
67 return anonymous();
68 };
69 if input
70 .identities()
71 .iter()
72 .enumerate()
73 .any(|(position, column)| {
74 input.wildcard_position_visible(position) && column.qualifier() != Some(source)
75 })
76 {
77 return anonymous();
78 }
79 let mut result = Self::default();
80 result.insert(qualifier, rows.types[source].clone());
81 Arc::make_mut(result.0.as_mut().unwrap()).source = Some(qualifier.into());
82 result
83 }
84
85 pub(super) fn joined(left: &RowSchema, right: &RowSchema) -> Self {
86 if left.index.cold.row_types.0.is_none() && right.index.cold.row_types.0.is_none() {
87 return Self::default();
88 }
89 let mut result = Self::default();
90 for (source, other) in [(left, right), (right, left)] {
91 if let Some(rows) = &source.index.cold.row_types.0 {
92 for (qualifier, ty) in &rows.types {
93 if !other.has_qualifier(qualifier) {
94 result.insert(qualifier, ty.clone());
95 }
96 }
97 }
98 }
99 result
100 }
101
102 pub(super) fn with_outer(input: &RowSchema, outer: &RowSchema) -> Self {
103 let mut result = input.index.cold.row_types.clone();
104 if let Some(rows) = &outer.index.cold.row_types.0 {
105 for (qualifier, ty) in &rows.types {
106 if !input.has_qualifier(qualifier) {
107 result.insert(qualifier, ty.clone());
108 }
109 }
110 }
111 result
112 }
113}
114
115impl RowSchema {
116 pub(super) fn relation_qualifiers(&self) -> impl Iterator<Item = &str> {
117 self.index
118 .qualified
119 .keys()
120 .chain(self.index.aliases.keys())
121 .filter_map(ColumnIdentity::qualifier)
122 .chain(self.index.cold.row_types.qualifiers())
123 .chain(self.whole_row_presences().map(|(qualifier, _)| qualifier))
124 }
125
126 pub fn with_relation_row_type(
128 mut self,
129 qualifier: &str,
130 ty: ColumnType,
131 ) -> Result<Self, SQLError> {
132 if !matches!(ty, ColumnType::Composite(_))
133 || (!self.is_empty() && !self.has_qualifier(qualifier))
134 {
135 return Err(SQLError::Internal(
136 "a relation row type requires its named composite and source namespace".into(),
137 ));
138 }
139 let rows = &mut Arc::make_mut(&mut self.index).cold.row_types;
140 rows.insert(qualifier, Some(ty));
141 let rows = Arc::make_mut(rows.0.as_mut().unwrap());
142 rows.source = (rows.types.len() == 1).then(|| qualifier.into());
143 Ok(self)
144 }
145}
146
147#[cfg(test)]
148mod tests;