uqa_sql/schema/production/
wildcards.rs1use 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 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;