1use super::{copy, lease::SchemaMemory, optional_type, parts};
10use crate::{
11 schema::{
12 collations::composition::Selection, ColumnIdentity, RowSchema, SchemaBuildMetadata,
13 SchemaMap, SchemaSet, ScoreSource, NULL_SLOT,
14 },
15 ColumnType, SQLError,
16};
17use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
18
19mod metadata;
20
21pub(in crate::schema) type OutputColumn<'a> =
22 (&'a str, &'a ColumnIdentity, usize, Option<&'a ColumnType>);
23pub(in crate::schema) type OutputAlias<'a> = (&'a ColumnIdentity, usize, Option<&'a ColumnType>);
24
25struct Layout<'a, 'c> {
26 input: &'a RowSchema,
27 control: ProductionControl<'c>,
28 names: ProductionVec<'c, String>,
29 identities: ProductionVec<'c, ColumnIdentity>,
30 types: ProductionVec<'c, Option<ColumnType>>,
31 slots: ProductionVec<'c, usize>,
32 hidden: ProductionVec<'c, usize>,
33 collations: Selection<'a, 'c>,
34}
35
36impl<'a, 'c> Layout<'a, 'c> {
37 fn new(input: &'a RowSchema, control: &ProductionControl<'c>) -> Result<Self, SQLError> {
38 let mut collations = Selection::new(&input.index.cold.collations, control)?;
39 collations.clear_columns(control);
40 Ok(Self {
41 input,
42 control: *control,
43 names: ProductionVec::new(*control),
44 identities: ProductionVec::new(*control),
45 types: ProductionVec::new(*control),
46 slots: ProductionVec::new(*control),
47 hidden: ProductionVec::new(*control),
48 collations,
49 })
50 }
51
52 fn push(
53 &mut self,
54 label: &str,
55 identity: (Option<&str>, &str),
56 slot: usize,
57 ty: Option<&ColumnType>,
58 collation: Option<u32>,
59 hidden: bool,
60 ) -> Result<(), SQLError> {
61 let control = &self.control;
62 let position = self.names.len();
63 self.names.push_produced(control.copy_text(label)?)?;
64 self.identities
65 .push_produced(ColumnIdentity::from_parts_with_control(
66 identity.0, identity.1, control,
67 )?)?;
68 self.types.push_produced(optional_type(ty, control)?)?;
69 self.slots.push_copy(slot)?;
70 self.collations.column(position, collation, ty)?;
71 if hidden {
72 self.hidden.push_copy(position)?;
73 }
74 Ok(())
75 }
76
77 fn finish(
78 self,
79 width: usize,
80 aliases: &[OutputAlias<'a>],
81 keep_input_aliases: bool,
82 rebound_score: Option<&str>,
83 control: &ProductionControl<'_>,
84 ) -> Result<RowSchema, SQLError> {
85 let hidden = SchemaSet::from_produced(
86 self.hidden
87 .iter()
88 .map(|position| inline(*position, control)),
89 control,
90 )?;
91 let metadata = metadata::produce(
92 self.input,
93 aliases,
94 self.collations.finish(control)?,
95 hidden,
96 keep_input_aliases,
97 rebound_score,
98 control,
99 )?;
100 parts::produce(
101 self.names.finish()?,
102 self.identities.finish()?,
103 self.types.finish()?,
104 self.slots.finish()?,
105 width,
106 metadata,
107 control,
108 )
109 }
110}
111
112pub(in crate::schema) fn physical<'a>(
113 input: &'a RowSchema,
114 columns: impl IntoIterator<Item = OutputColumn<'a>>,
115 aliases: impl IntoIterator<Item = OutputAlias<'a>>,
116 physical_width: usize,
117 control: &ProductionControl<'_>,
118) -> Result<RowSchema, SQLError> {
119 control.check()?;
120 let mut layout = Layout::new(input, control)?;
121 for (label, identity, physical, ty) in columns {
122 control.check()?;
123 let hidden = input
124 .index
125 .cold
126 .wildcard_hidden
127 .iter()
128 .any(|logical| input.slot(*logical) == Some(physical));
129 layout.push(
130 label,
131 (identity.qualifier(), identity.column()),
132 if physical < physical_width {
133 physical
134 } else {
135 NULL_SLOT
136 },
137 ty,
138 input.inherited_physical_collation(physical),
139 hidden,
140 )?;
141 }
142 let mut selected = ProductionVec::new(*control);
143 for (identity, physical, ty) in aliases {
144 control.check()?;
145 layout.collations.alias(
146 (identity.qualifier(), identity.column()),
147 input.inherited_physical_collation(physical),
148 ty,
149 )?;
150 selected.push_copy((
151 identity,
152 if physical < physical_width {
153 physical
154 } else {
155 NULL_SLOT
156 },
157 ty,
158 ))?;
159 }
160 layout.finish(physical_width, &selected, true, None, control)
161}
162
163impl RowSchema {
164 pub fn with_scan_projection_with_control<'a>(
166 input: &Self,
167 qualifier: &str,
168 columns: impl IntoIterator<Item = (&'a str, usize)>,
169 control: &ProductionControl<'_>,
170 ) -> Result<Self, SQLError> {
171 let mut layout = Layout::new(input, control)?;
172 for (name, logical) in columns {
173 layout.push(
174 name,
175 (Some(qualifier), name),
176 input.slot(logical).unwrap_or(NULL_SLOT),
177 input.column_type(logical),
178 input.inherited_column_collation(logical),
179 input.index.cold.wildcard_hidden.contains(&logical),
180 )?;
181 }
182 layout.finish(input.physical_width(), &[], true, None, control)
183 }
184}
185
186impl RowSchema {
187 pub fn select_with_control<'a>(
189 input: &Self,
190 columns: impl IntoIterator<Item = (&'a str, &'a str)>,
191 control: &ProductionControl<'_>,
192 ) -> Result<Self, SQLError> {
193 let mut layout = Layout::new(input, control)?;
194 for (output, source) in columns {
195 control.check()?;
196 layout.push(
197 output,
198 (None, output),
199 input.exact_slot(source).unwrap_or(NULL_SLOT),
200 input.exact_type(source),
201 input
202 .position(source)
203 .and_then(|position| input.inherited_column_collation(position)),
204 false,
205 )?;
206 }
207 layout.finish(input.physical_width(), &[], false, None, control)
208 }
209
210 pub(crate) fn remap_join_alias_with_control(
211 input: &Self,
212 qualifier: &str,
213 columns: &[String],
214 control: &ProductionControl<'_>,
215 ) -> Result<Self, SQLError> {
216 let mut layout = Layout::new(input, control)?;
217 layout.collations.clear_lookup_aliases(control);
218 for (position, name) in columns.iter().enumerate() {
219 layout.push(
220 name,
221 (Some(qualifier), name),
222 input.slot(position).unwrap_or(NULL_SLOT),
223 input.column_type(position),
224 input.inherited_column_collation(position),
225 input.index.cold.wildcard_hidden.contains(&position),
226 )?;
227 }
228 let schema = layout.finish(input.physical_width(), &[], false, Some(qualifier), control)?;
229 if schema.is_empty() {
230 Self::with_relation_qualifier_with_control(&schema, qualifier, control)
231 } else {
232 Ok(schema)
233 }
234 }
235
236 pub(crate) fn canonical_join_alias_with_control(
237 input: &Self,
238 qualifier: &str,
239 columns: &[String],
240 control: &ProductionControl<'_>,
241 ) -> Result<Self, SQLError> {
242 let metadata = SchemaBuildMetadata {
243 lateral_restrictions: Self::requalified_column_names_with_control(input, control)?,
244 ..SchemaBuildMetadata::empty_with_control(control)
245 };
246 super::columns_with_metadata(
247 Some(qualifier),
248 None,
249 columns
250 .iter()
251 .enumerate()
252 .map(|(position, name)| (name.as_str(), input.column_type(position), None, None)),
253 false,
254 metadata,
255 control,
256 )
257 }
258}
259
260fn inline<T>(value: T, control: &ProductionControl<'_>) -> Result<Produced<T>, SQLError> {
261 Ok(control.finish(value, control.empty_reservation())?)
262}
263
264#[cfg(test)]
265mod tests;