Skip to main content

uqa_sql/schema/production/
remapping.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! JOIN output identities select borrowed physical positions and retain independently admitted metadata.
8
9use 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    /// A scan alias selects logical fields while retaining hidden physical attributes and lock lineage.
165    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    /// Select borrowed output/source names while retaining the original physical fragments and executor metadata.
188    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;