Skip to main content

uqa_sql/schema/
schema_remap.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Logical identity remapping over shared physical row slots.
8
9use crate::ast::ColumnType;
10
11use super::{ColumnIdentity, RowSchema, SchemaBuildMetadata, SchemaMap, NULL_SLOT};
12
13impl RowSchema {
14    /// Select explicit physical slots with fresh public identities. This is
15    /// the structural equivalent of executor target entries whose values may
16    /// come from anonymous computed slots rather than SQL-named columns.
17    pub fn remap_typed_physical_identities(
18        input: &Self,
19        columns: &[(String, ColumnIdentity, usize, Option<ColumnType>)],
20        aliases: &[(ColumnIdentity, usize, Option<ColumnType>)],
21    ) -> Self {
22        let mut collations = input.index.cold.collations.clone();
23        collations.clear_columns();
24        for (position, (_, _, source, ty)) in columns.iter().enumerate() {
25            collations.column(
26                position,
27                input.inherited_physical_collation(*source),
28                ty.as_ref(),
29            );
30        }
31        let output_names = columns
32            .iter()
33            .map(|(output, _, _, _)| output.clone())
34            .collect();
35        let identities = columns
36            .iter()
37            .map(|(_, identity, _, _)| identity.clone())
38            .collect();
39        let slots = columns
40            .iter()
41            .map(|(_, _, physical, _)| {
42                if *physical < input.physical_width() {
43                    *physical
44                } else {
45                    NULL_SLOT
46                }
47            })
48            .collect();
49        let types = columns.iter().map(|(_, _, _, ty)| ty.clone()).collect();
50        let wildcard_hidden = columns
51            .iter()
52            .enumerate()
53            .filter_map(|(output, (_, _, physical, _))| {
54                input
55                    .index
56                    .cold
57                    .wildcard_hidden
58                    .iter()
59                    .any(|logical| input.slot(*logical) == Some(*physical))
60                    .then_some(output)
61            })
62            .collect();
63        let mut lookup_aliases = input.index.aliases.clone();
64        let mut alias_types = input.index.cold.aliases.clone();
65        for (identity, physical, ty) in aliases {
66            collations.alias(
67                identity,
68                input.inherited_physical_collation(*physical),
69                ty.as_ref(),
70            );
71            lookup_aliases.insert(
72                identity.clone(),
73                if *physical < input.physical_width() {
74                    *physical
75                } else {
76                    NULL_SLOT
77                },
78            );
79            alias_types.insert(identity.clone(), ty.clone());
80        }
81        Self::from_typed_parts_with_aliases_and_exact_precedence(
82            output_names,
83            identities,
84            types,
85            slots,
86            input.physical_width(),
87            SchemaBuildMetadata {
88                collations,
89                record_fields: input.index.cold.record_fields.clone(),
90                aliases: lookup_aliases,
91                alias_types,
92                internal: input.index.executor_attributes.clone(),
93                internal_types: input.index.cold.executor_attribute_types.clone(),
94                score_sources: input.index.cold.score_sources.clone(),
95                wildcard_hidden,
96                binding_only: input.index.cold.binding_only.clone(),
97                row_types: input.index.cold.row_types.clone(),
98                row_presence: input.index.cold.row_presence.clone(),
99                open_qualifiers: input.index.cold.open_qualifiers.clone(),
100                ..SchemaBuildMetadata::default()
101            },
102        )
103    }
104
105    /// Select logical positions with explicit public labels, SQL identities, and types while preserving hidden aliases and physical fragments.
106    pub fn remap_typed_identities(
107        input: &Self,
108        columns: &[(String, ColumnIdentity, usize, Option<ColumnType>)],
109        aliases: &[(ColumnIdentity, usize)],
110    ) -> Self {
111        let mut collations = input.index.cold.collations.clone();
112        collations.clear_columns();
113        for (position, (_, _, source, ty)) in columns.iter().enumerate() {
114            collations.column(
115                position,
116                input.inherited_column_collation(*source),
117                ty.as_ref(),
118            );
119        }
120        let output_names = columns
121            .iter()
122            .map(|(output, _, _, _)| output.clone())
123            .collect();
124        let identities = columns
125            .iter()
126            .map(|(_, identity, _, _)| identity.clone())
127            .collect();
128        let slots = columns
129            .iter()
130            .map(|(_, _, logical, _)| input.slot(*logical).unwrap_or(NULL_SLOT))
131            .collect();
132        let types = columns.iter().map(|(_, _, _, ty)| ty.clone()).collect();
133        let wildcard_hidden = columns
134            .iter()
135            .enumerate()
136            .filter_map(|(output, (_, _, logical, _))| {
137                input
138                    .index
139                    .cold
140                    .wildcard_hidden
141                    .contains(logical)
142                    .then_some(output)
143            })
144            .collect();
145        let mut lookup_aliases = input.index.aliases.clone();
146        let mut alias_types = input.index.cold.aliases.clone();
147        for (identity, logical) in aliases {
148            collations.alias(
149                identity,
150                input.inherited_column_collation(*logical),
151                input.column_type(*logical),
152            );
153            lookup_aliases.insert(identity.clone(), input.slot(*logical).unwrap_or(NULL_SLOT));
154            alias_types.insert(identity.clone(), input.column_type(*logical).cloned());
155        }
156        Self::from_typed_parts_with_aliases_and_exact_precedence(
157            output_names,
158            identities,
159            types,
160            slots,
161            input.physical_width(),
162            SchemaBuildMetadata {
163                collations,
164                record_fields: input.index.cold.record_fields.clone(),
165                aliases: lookup_aliases,
166                alias_types,
167                internal: input.index.executor_attributes.clone(),
168                internal_types: input.index.cold.executor_attribute_types.clone(),
169                score_sources: input.index.cold.score_sources.clone(),
170                wildcard_hidden,
171                binding_only: input.index.cold.binding_only.clone(),
172                row_types: input.index.cold.row_types.clone(),
173                row_presence: input.index.cold.row_presence.clone(),
174                open_qualifiers: input.index.cold.open_qualifiers.clone(),
175                ..SchemaBuildMetadata::default()
176            },
177        )
178    }
179
180    /// Select logical positions with fresh SQL identities while deliberately dropping every input lookup alias. A relation alias on a complete parenthesized JOIN uses this boundary because `PostgreSQL` hides all names exposed by the joined inputs.
181    pub fn remap_typed_identities_without_input_aliases(
182        input: &Self,
183        columns: &[(String, ColumnIdentity, usize, Option<ColumnType>)],
184    ) -> Self {
185        let mut collations = input.index.cold.collations.clone();
186        collations.clear_columns();
187        for (position, (_, _, source, ty)) in columns.iter().enumerate() {
188            collations.column(
189                position,
190                input.inherited_column_collation(*source),
191                ty.as_ref(),
192            );
193        }
194        let output_names = columns
195            .iter()
196            .map(|(output, _, _, _)| output.clone())
197            .collect();
198        let identities = columns
199            .iter()
200            .map(|(_, identity, _, _)| identity.clone())
201            .collect();
202        let slots = columns
203            .iter()
204            .map(|(_, _, logical, _)| input.slot(*logical).unwrap_or(NULL_SLOT))
205            .collect();
206        let types = columns.iter().map(|(_, _, _, ty)| ty.clone()).collect();
207        let wildcard_hidden = columns
208            .iter()
209            .enumerate()
210            .filter_map(|(output, (_, _, logical, _))| {
211                input
212                    .index
213                    .cold
214                    .wildcard_hidden
215                    .contains(logical)
216                    .then_some(output)
217            })
218            .collect();
219        Self::from_typed_parts_with_aliases_and_exact_precedence(
220            output_names,
221            identities,
222            types,
223            slots,
224            input.physical_width(),
225            SchemaBuildMetadata {
226                collations,
227                record_fields: input.index.cold.record_fields.clone(),
228                aliases: SchemaMap::default(),
229                alias_types: SchemaMap::default(),
230                internal: input.index.executor_attributes.clone(),
231                internal_types: input.index.cold.executor_attribute_types.clone(),
232                score_sources: input.index.cold.score_sources.clone(),
233                wildcard_hidden,
234                binding_only: SchemaMap::default(),
235                ..SchemaBuildMetadata::default()
236            },
237        )
238    }
239}