Skip to main content

uqa_sql/schema/production/composition/
outer.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Correlated namespaces select physical aliases, ambiguity and virtual metadata before copying.
8
9use 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    /// Overlay an outer physical namespace with the same shadowing and ambiguity rules as lexical binding.
306    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}