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                open_qualifiers: input.index.cold.open_qualifiers.clone(),
99                ..SchemaBuildMetadata::default()
100            },
101        )
102    }
103
104    /// Select logical positions with explicit public labels, SQL identities, and types while preserving hidden aliases and physical fragments.
105    pub fn remap_typed_identities(
106        input: &Self,
107        columns: &[(String, ColumnIdentity, usize, Option<ColumnType>)],
108        aliases: &[(ColumnIdentity, usize)],
109    ) -> Self {
110        let mut collations = input.index.cold.collations.clone();
111        collations.clear_columns();
112        for (position, (_, _, source, ty)) in columns.iter().enumerate() {
113            collations.column(
114                position,
115                input.inherited_column_collation(*source),
116                ty.as_ref(),
117            );
118        }
119        let output_names = columns
120            .iter()
121            .map(|(output, _, _, _)| output.clone())
122            .collect();
123        let identities = columns
124            .iter()
125            .map(|(_, identity, _, _)| identity.clone())
126            .collect();
127        let slots = columns
128            .iter()
129            .map(|(_, _, logical, _)| input.slot(*logical).unwrap_or(NULL_SLOT))
130            .collect();
131        let types = columns.iter().map(|(_, _, _, ty)| ty.clone()).collect();
132        let wildcard_hidden = columns
133            .iter()
134            .enumerate()
135            .filter_map(|(output, (_, _, logical, _))| {
136                input
137                    .index
138                    .cold
139                    .wildcard_hidden
140                    .contains(logical)
141                    .then_some(output)
142            })
143            .collect();
144        let mut lookup_aliases = input.index.aliases.clone();
145        let mut alias_types = input.index.cold.aliases.clone();
146        for (identity, logical) in aliases {
147            collations.alias(
148                identity,
149                input.inherited_column_collation(*logical),
150                input.column_type(*logical),
151            );
152            lookup_aliases.insert(identity.clone(), input.slot(*logical).unwrap_or(NULL_SLOT));
153            alias_types.insert(identity.clone(), input.column_type(*logical).cloned());
154        }
155        Self::from_typed_parts_with_aliases_and_exact_precedence(
156            output_names,
157            identities,
158            types,
159            slots,
160            input.physical_width(),
161            SchemaBuildMetadata {
162                collations,
163                record_fields: input.index.cold.record_fields.clone(),
164                aliases: lookup_aliases,
165                alias_types,
166                internal: input.index.executor_attributes.clone(),
167                internal_types: input.index.cold.executor_attribute_types.clone(),
168                score_sources: input.index.cold.score_sources.clone(),
169                wildcard_hidden,
170                binding_only: input.index.cold.binding_only.clone(),
171                row_types: input.index.cold.row_types.clone(),
172                open_qualifiers: input.index.cold.open_qualifiers.clone(),
173                ..SchemaBuildMetadata::default()
174            },
175        )
176    }
177
178    /// 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.
179    pub fn remap_typed_identities_without_input_aliases(
180        input: &Self,
181        columns: &[(String, ColumnIdentity, usize, Option<ColumnType>)],
182    ) -> Self {
183        let mut collations = input.index.cold.collations.clone();
184        collations.clear_columns();
185        for (position, (_, _, source, ty)) in columns.iter().enumerate() {
186            collations.column(
187                position,
188                input.inherited_column_collation(*source),
189                ty.as_ref(),
190            );
191        }
192        let output_names = columns
193            .iter()
194            .map(|(output, _, _, _)| output.clone())
195            .collect();
196        let identities = columns
197            .iter()
198            .map(|(_, identity, _, _)| identity.clone())
199            .collect();
200        let slots = columns
201            .iter()
202            .map(|(_, _, logical, _)| input.slot(*logical).unwrap_or(NULL_SLOT))
203            .collect();
204        let types = columns.iter().map(|(_, _, _, ty)| ty.clone()).collect();
205        let wildcard_hidden = columns
206            .iter()
207            .enumerate()
208            .filter_map(|(output, (_, _, logical, _))| {
209                input
210                    .index
211                    .cold
212                    .wildcard_hidden
213                    .contains(logical)
214                    .then_some(output)
215            })
216            .collect();
217        Self::from_typed_parts_with_aliases_and_exact_precedence(
218            output_names,
219            identities,
220            types,
221            slots,
222            input.physical_width(),
223            SchemaBuildMetadata {
224                collations,
225                record_fields: input.index.cold.record_fields.clone(),
226                aliases: SchemaMap::default(),
227                alias_types: SchemaMap::default(),
228                internal: input.index.executor_attributes.clone(),
229                internal_types: input.index.cold.executor_attribute_types.clone(),
230                score_sources: input.index.cold.score_sources.clone(),
231                wildcard_hidden,
232                binding_only: SchemaMap::default(),
233                ..SchemaBuildMetadata::default()
234            },
235        )
236    }
237}