1use super::{
10 boxed_text, copy, inline, optional_text, optional_type, records, scores, shifted,
11 ColumnIdentity, ColumnType, Layout, ProductionControl, RowSchema, SQLError, SchemaMap,
12 SchemaMemory, SchemaSet, NULL_SLOT,
13};
14use crate::schema::{collations::composition::Selection as Collations, identity_lookup::ColumnKey};
15use uqa_core::memory::ProductionMap;
16
17type Key<'a> = (Option<&'a str>, &'a str);
18struct Aliases<'a, 'c> {
19 slots: ProductionMap<'c, Key<'a>, usize>,
20 types: ProductionMap<'c, Key<'a>, Option<&'a ColumnType>>,
21 ambiguous_unqualified: ProductionMap<'c, &'a str, ()>,
22 ambiguous_qualified: ProductionMap<'c, Key<'a>, ()>,
23 virtuals: ProductionMap<'c, Key<'a>, Option<&'a ColumnType>>,
24 collations: Collations<'a, 'c>,
25}
26
27impl<'a, 'c> Aliases<'a, 'c> {
28 fn new(input: &'a RowSchema, control: &ProductionControl<'c>) -> Result<Self, SQLError> {
29 let mut aliases = Self {
30 slots: ProductionMap::new(*control),
31 types: ProductionMap::new(*control),
32 ambiguous_unqualified: ProductionMap::new(*control),
33 ambiguous_qualified: ProductionMap::new(*control),
34 virtuals: ProductionMap::new(*control),
35 collations: Collations::new(&input.index.cold.collations, control)?,
36 };
37 for (identity, slot) in &input.index.aliases {
38 aliases.slots.insert_copy(key(identity), *slot)?;
39 }
40 for (identity, ty) in &input.index.cold.aliases {
41 aliases.types.insert_copy(key(identity), ty.as_ref())?;
42 }
43 for name in &input.index.ambiguous_unqualified {
44 aliases
45 .ambiguous_unqualified
46 .insert_copy(name.as_ref(), ())?;
47 }
48 for identity in &input.index.ambiguous_qualified {
49 aliases.ambiguous_qualified.insert_copy(key(identity), ())?;
50 }
51 for (identity, ty) in &input.index.cold.binding_only {
52 aliases.virtuals.insert_copy(key(identity), ty.as_ref())?;
53 }
54 Ok(aliases)
55 }
56
57 fn overlay(
58 &mut self,
59 input: &'a RowSchema,
60 outer: &'a RowSchema,
61 control: &ProductionControl<'c>,
62 ) -> Result<(), SQLError> {
63 self.overlay_qualified(input, outer, control)?;
64 self.overlay_unqualified(input, outer, control)?;
65 self.overlay_virtuals(input, outer, control)?;
66 Ok(())
67 }
68 fn overlay_qualified(
69 &mut self,
70 input: &'a RowSchema,
71 outer: &'a RowSchema,
72 control: &ProductionControl<'c>,
73 ) -> Result<(), SQLError> {
74 let mut identities = ProductionMap::new(*control);
75 for identity in outer
76 .index
77 .qualified
78 .keys()
79 .chain(
80 outer
81 .index
82 .aliases
83 .keys()
84 .filter(|key| key.qualifier().is_some()),
85 )
86 .chain(outer.index.ambiguous_qualified.iter())
87 {
88 identities.insert_copy(key(identity), identity)?;
89 }
90 for ((qualifier, column), identity) in &identities {
91 control.check()?;
92 let qualifier = qualifier.expect("qualified outer key");
93 if input
94 .relation_qualifiers()
95 .any(|candidate| candidate == qualifier)
96 {
97 continue;
98 }
99 let selected = (Some(qualifier), *column);
100 if outer.index.ambiguous_qualified.contains(*identity) {
101 self.slots.remove(&selected);
102 self.types.remove(&selected);
103 self.ambiguous_qualified.insert_copy(selected, ())?;
104 } else {
105 let slot = outer
106 .index
107 .qualified
108 .get(*identity)
109 .map(|position| outer.index.slots[*position])
110 .or_else(|| outer.index.aliases.get(*identity).copied())
111 .unwrap_or(NULL_SLOT);
112 let ty = outer.qualified_identity_type(identity);
113 self.slots
114 .insert_copy(selected, shifted(slot, input.physical_width()))?;
115 self.types.insert_copy(selected, ty)?;
116 self.collations.alias(
117 selected,
118 outer.qualified_collation(qualifier, column),
119 ty,
120 )?;
121 }
122 }
123 Ok(())
124 }
125
126 fn overlay_unqualified(
127 &mut self,
128 input: &'a RowSchema,
129 outer: &'a RowSchema,
130 control: &ProductionControl<'c>,
131 ) -> Result<(), SQLError> {
132 let mut unqualified = ProductionMap::new(*control);
133 for name in outer
134 .index
135 .unqualified
136 .keys()
137 .map(std::convert::AsRef::as_ref)
138 .chain(
139 outer
140 .index
141 .aliases
142 .keys()
143 .filter(|identity| identity.qualifier().is_none())
144 .map(ColumnIdentity::column),
145 )
146 .chain(
147 outer
148 .index
149 .ambiguous_unqualified
150 .iter()
151 .map(std::convert::AsRef::as_ref),
152 )
153 {
154 unqualified.insert_copy(name, ())?;
155 }
156 for (name, ()) in &unqualified {
157 let selected = (None, *name);
158 let lookup = &selected as &dyn ColumnKey;
159 if input.index.unqualified.contains_key(*name)
160 || input.index.aliases.contains_key(lookup)
161 {
162 continue;
163 }
164 if outer.column_is_ambiguous(name) {
165 self.slots.remove(&selected);
166 self.types.remove(&selected);
167 self.ambiguous_unqualified.insert_copy(name, ())?;
168 } else {
169 let slot = outer
170 .index
171 .unqualified
172 .get(*name)
173 .map(|position| outer.index.slots[*position])
174 .or_else(|| outer.index.aliases.get(lookup).copied())
175 .unwrap_or(NULL_SLOT);
176 let ty = outer
177 .index
178 .unqualified
179 .get(*name)
180 .and_then(|position| outer.column_type(*position))
181 .or_else(|| {
182 outer
183 .index
184 .cold
185 .aliases
186 .get(lookup)
187 .and_then(Option::as_ref)
188 })
189 .or_else(|| {
190 outer
191 .index
192 .cold
193 .binding_only
194 .get(lookup)
195 .and_then(Option::as_ref)
196 });
197 self.slots
198 .insert_copy(selected, shifted(slot, input.physical_width()))?;
199 self.types.insert_copy(selected, ty)?;
200 self.collations
201 .alias(selected, outer.collation_of(name), ty)?;
202 }
203 }
204 Ok(())
205 }
206
207 fn overlay_virtuals(
208 &mut self,
209 input: &'a RowSchema,
210 outer: &'a RowSchema,
211 control: &ProductionControl<'c>,
212 ) -> Result<(), SQLError> {
213 for (identity, ty) in outer.typed_virtual_identities() {
214 control.check()?;
215 let selected = key(identity);
216 if selected.0.is_some_and(|qualifier| {
217 input
218 .relation_qualifiers()
219 .any(|candidate| candidate == qualifier)
220 }) {
221 continue;
222 }
223 let visible = if selected.0.is_some() {
224 input.index.qualified.contains_key(identity)
225 || self.slots.get(&selected).is_some()
226 || self.virtuals.get(&selected).is_some()
227 } else {
228 self.ambiguous_unqualified.get(selected.1).is_some()
229 || input.index.unqualified.contains_key(selected.1)
230 || self.slots.get(&selected).is_some()
231 || self.virtuals.get(&selected).is_some()
232 };
233 if !visible {
234 self.virtuals.insert_copy(selected, ty)?;
235 }
236 if !input.index.cold.binding_only.contains_key(identity) {
237 if let Some(ty) = self.virtuals.get(&selected) {
238 self.collations.virtual_column(
239 selected,
240 outer.virtual_collation(identity),
241 *ty,
242 )?;
243 }
244 }
245 }
246 Ok(())
247 }
248
249 fn install_aliases(
250 &self,
251 metadata: &mut super::SchemaBuildMetadata,
252 control: &ProductionControl<'c>,
253 ) -> Result<(), SQLError> {
254 metadata.aliases = SchemaMap::from_produced(
255 self.slots.iter().map(|((qualifier, column), slot)| {
256 Ok((
257 ColumnIdentity::from_parts_with_control(*qualifier, column, control)?,
258 inline(*slot, control)?,
259 ))
260 }),
261 control,
262 )?;
263 metadata.alias_types = SchemaMap::from_produced(
264 self.types.iter().map(|((qualifier, column), ty)| {
265 Ok((
266 ColumnIdentity::from_parts_with_control(*qualifier, column, control)?,
267 optional_type(*ty, control)?,
268 ))
269 }),
270 control,
271 )?;
272 metadata.binding_only = SchemaMap::from_produced(
273 self.virtuals.iter().map(|((qualifier, column), ty)| {
274 Ok((
275 ColumnIdentity::from_parts_with_control(*qualifier, column, control)?,
276 optional_type(*ty, control)?,
277 ))
278 }),
279 control,
280 )?;
281 metadata.extra_ambiguous_unqualified = SchemaSet::from_produced(
282 self.ambiguous_unqualified
283 .iter()
284 .map(|(name, ())| boxed_text(name, control)),
285 control,
286 )?;
287 metadata.extra_ambiguous_qualified = SchemaSet::from_produced(
288 self.ambiguous_qualified
289 .iter()
290 .map(|((qualifier, column), ())| {
291 ColumnIdentity::from_parts_with_control(*qualifier, column, control)
292 .map_err(Into::into)
293 }),
294 control,
295 )?;
296 Ok(())
297 }
298}
299
300fn key(identity: &ColumnIdentity) -> Key<'_> {
301 (identity.qualifier(), identity.column())
302}
303
304impl RowSchema {
305 pub fn with_outer_schema_with_control(
307 input: &Self,
308 outer: &Self,
309 control: &ProductionControl<'_>,
310 ) -> Result<Self, SQLError> {
311 control.check()?;
312 let mut selected = Aliases::new(input, control)?;
313 selected.overlay(input, outer, control)?;
314 let mut metadata = copy::metadata(input, control)?;
315 selected.install_aliases(&mut metadata, control)?;
316 metadata.internal = SchemaMap::from_produced(
317 input
318 .index
319 .executor_attributes
320 .iter()
321 .filter(|(column, _)| !outer.index.executor_attributes.contains_key(*column))
322 .map(|(column, slot)| (*column, *slot))
323 .chain(
324 outer
325 .index
326 .executor_attributes
327 .iter()
328 .map(|(column, slot)| (*column, shifted(*slot, input.physical_width()))),
329 )
330 .map(|(column, slot)| Ok((inline(column, control)?, inline(slot, control)?))),
331 control,
332 )?;
333 for (column, ty) in &outer.index.cold.executor_attribute_types {
334 control.check()?;
335 if let Some(existing) = input.index.cold.executor_attribute_types.get(column) {
336 assert_eq!(
337 existing, ty,
338 "structural identity type changed across correlated scopes"
339 );
340 }
341 selected.collations.internal(
342 *column,
343 outer.internal_collation(*column),
344 ty.as_ref(),
345 )?;
346 }
347 metadata.internal_types =
348 SchemaMap::from_produced(
349 input
350 .index
351 .cold
352 .executor_attribute_types
353 .iter()
354 .chain(outer.index.cold.executor_attribute_types.iter().filter(
355 |(column, _)| {
356 !input
357 .index
358 .cold
359 .executor_attribute_types
360 .contains_key(*column)
361 },
362 ))
363 .map(|(column, ty)| {
364 Ok((
365 inline(*column, control)?,
366 optional_type(ty.as_ref(), control)?,
367 ))
368 }),
369 control,
370 )?;
371 metadata.collations = selected.collations.finish(control)?;
372 metadata.record_fields = records(input, outer, control)?;
373 let (score_sources, memory) = scores(
374 input
375 .index
376 .cold
377 .score_sources
378 .iter()
379 .chain(&outer.index.cold.score_sources),
380 control,
381 )?
382 .into_parts();
383 metadata.score_sources = score_sources;
384 metadata.memory = SchemaMemory::new(memory);
385 metadata.open_qualifiers = outer_open_qualifiers(input, outer, control)?;
386 metadata.row_types = crate::schema::relation_types::RelationRowTypes::compose_with_control(
387 input, outer, true, control,
388 )?;
389 metadata.row_presence =
390 crate::schema::relation_presence::RelationPresence::compose_with_control(
391 input, outer, true, control,
392 )?;
393 metadata.lateral_restrictions =
394 Self::outer_lateral_restrictions_with_control(input, outer, control)?;
395 metadata.local_width = Some(
396 input
397 .index
398 .cold
399 .local_width
400 .unwrap_or_else(|| input.physical_width()),
401 );
402 let mut layout = Layout::new(control);
403 layout.append(input, 0, None, control)?;
404 layout.finish(
405 input.physical_width() + outer.physical_width(),
406 metadata,
407 control,
408 )
409 }
410}
411
412fn outer_open_qualifiers(
413 input: &RowSchema,
414 outer: &RowSchema,
415 control: &ProductionControl<'_>,
416) -> Result<SchemaSet<Option<Box<str>>>, SQLError> {
417 SchemaSet::from_produced(
418 input
419 .index
420 .cold
421 .open_qualifiers
422 .iter()
423 .chain(outer.index.cold.open_qualifiers.iter().filter(|name| {
424 name.as_deref()
425 .is_none_or(|name| !input.has_qualifier(name))
426 }))
427 .map(|name| optional_text(name.as_deref(), control)),
428 control,
429 )
430}