Skip to main content

uqa_sql/schema/
relation_types.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Whole-row namespaces survive empty rows independently of named type identity.
8
9use super::{Arc, ColumnIdentity, ColumnType, HashMap, RowSchema};
10use crate::SQLError;
11
12/// Absent namespaces allocate no map; copies of a retained scope share its identities.
13#[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    /// The complete local row denotes this one source. A join or an outer-only namespace has no such identity.
20    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    /// An alias of one retained relation keeps that relation's named type. A boundary over several relations produces an anonymous row.
55    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    /// Retain a relation's actual named composite identity without adding an ordinary column or a physical value slot. The existing source namespace must belong to that relation; a zero-column relation acquires its namespace here.
127    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;