Skip to main content

uqa_sql/schema/production/
wildcards.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7use crate::{
8    schema::{ColumnIdentity, RowSchema, NULL_SLOT},
9    ColumnType, SQLError,
10};
11use uqa_core::memory::{ProductionControl, ProductionMap, ProductionVec};
12
13#[derive(Clone, Copy)]
14struct Entry<'a> {
15    identity: &'a ColumnIdentity,
16    logical: Option<usize>,
17    slot: usize,
18    ty: Option<&'a ColumnType>,
19    ordinal: usize,
20}
21
22impl RowSchema {
23    /// Visit a relation's wildcard positions in the same physical order as `qualified_star_position_layout`, retaining visible logical positions and hidden aliases without copying their names or types.
24    pub fn visit_qualified_star_positions<'a>(
25        &'a self,
26        qualifier: &str,
27        control: &ProductionControl<'_>,
28        mut visit: impl FnMut(
29            &'a str,
30            Option<usize>,
31            usize,
32            Option<&'a ColumnType>,
33        ) -> Result<(), SQLError>,
34    ) -> Result<(), SQLError> {
35        self.visit_qualified_star_entries(qualifier, control, |entry| {
36            visit(entry.identity.column(), entry.logical, entry.slot, entry.ty)
37        })
38    }
39
40    pub(crate) fn visit_qualified_star_metadata<'a>(
41        &'a self,
42        qualifier: &str,
43        control: &ProductionControl<'_>,
44        mut visit: impl FnMut(
45            &'a str,
46            Option<usize>,
47            Option<&'a ColumnType>,
48            Option<u32>,
49            Option<&'a crate::schema::RecordMetadata>,
50        ) -> Result<(), SQLError>,
51    ) -> Result<(), SQLError> {
52        self.visit_qualified_star_entries(qualifier, control, |entry| {
53            let collation = entry.logical.map_or_else(
54                || self.qualified_identity_collation(entry.identity),
55                |logical| self.column_collation(logical),
56            );
57            visit(
58                entry.identity.column(),
59                entry.logical,
60                entry.ty,
61                collation,
62                self.physical_record_metadata(entry.slot),
63            )
64        })
65    }
66
67    fn visit_qualified_star_entries<'a>(
68        &'a self,
69        qualifier: &str,
70        control: &ProductionControl<'_>,
71        mut visit: impl FnMut(Entry<'a>) -> Result<(), SQLError>,
72    ) -> Result<(), SQLError> {
73        control.check()?;
74        let mut entries = ProductionVec::new(*control);
75        let mut visible = ProductionMap::new(*control);
76        for (logical, identity) in self.identities().iter().enumerate() {
77            control.check()?;
78            if identity.qualifier() == Some(qualifier) {
79                let slot = self.slot(logical).unwrap_or(NULL_SLOT);
80                visible.insert_copy((identity, slot), ())?;
81                entries.push_copy(Entry {
82                    identity,
83                    logical: Some(logical),
84                    slot,
85                    ty: self.column_type(logical),
86                    ordinal: entries.len(),
87                })?;
88            }
89        }
90        for (identity, slot) in &self.index.aliases {
91            control.check()?;
92            if identity.qualifier() == Some(qualifier) && visible.get(&(identity, *slot)).is_none()
93            {
94                entries.push_copy(Entry {
95                    identity,
96                    logical: None,
97                    slot: *slot,
98                    ty: self
99                        .index
100                        .cold
101                        .aliases
102                        .get(identity)
103                        .and_then(Option::as_ref),
104                    ordinal: entries.len(),
105                })?;
106            }
107        }
108        uqa_core::ordering::sort_by_with_control(
109            entries.as_mut_slice(),
110            &mut || control.check().map_err(SQLError::from),
111            |left, right, _| Ok((left.slot, left.ordinal).cmp(&(right.slot, right.ordinal))),
112        )?;
113        for entry in &*entries {
114            control.check()?;
115            visit(*entry)?;
116        }
117        Ok(())
118    }
119}
120
121#[cfg(test)]
122mod tests;