Skip to main content

uqa_sql/schema/production/
physical_attributes.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Physical scan metadata owns its executor attributes and hidden SQL aliases.
8
9use super::{copy, optional_type};
10use crate::{
11    ast::InternalColumnRef,
12    schema::{ColumnIdentity, RowSchema, SchemaMap},
13    ColumnType, SQLError,
14};
15use uqa_core::memory::{ProductionControl, ProductionMap};
16
17impl RowSchema {
18    pub fn with_physical_identity_aliases_with_control<'a>(
19        input: &'a Self,
20        aliases: impl IntoIterator<Item = (Option<&'a str>, &'a str, usize, Option<&'a ColumnType>)>,
21        control: &ProductionControl<'_>,
22    ) -> Result<Self, SQLError> {
23        let mut selected = ProductionMap::new(*control);
24        let mut collations = crate::schema::collations::composition::Selection::new(
25            &input.index.cold.collations,
26            control,
27        )?;
28        for (qualifier, column, slot, ty) in aliases {
29            assert!(
30                slot < input.physical_width(),
31                "physical identity alias is outside row width"
32            );
33            selected.insert_copy((qualifier, column), (slot, ty))?;
34            collations.alias(
35                (qualifier, column),
36                input.inherited_physical_collation(slot),
37                ty,
38            )?;
39        }
40        let aliases = SchemaMap::from_produced(
41            input
42                .index
43                .aliases
44                .iter()
45                .map(|(identity, slot)| {
46                    Ok((
47                        identity.clone_with_control(control)?,
48                        control.finish(*slot, control.empty_reservation())?,
49                    ))
50                })
51                .chain(selected.iter().map(|((qualifier, column), (slot, _))| {
52                    Ok((
53                        ColumnIdentity::from_parts_with_control(*qualifier, column, control)?,
54                        control.finish(*slot, control.empty_reservation())?,
55                    ))
56                })),
57            control,
58        )?;
59        let types = SchemaMap::from_produced(
60            input
61                .index
62                .cold
63                .aliases
64                .iter()
65                .map(|(identity, ty)| {
66                    Ok((
67                        identity.clone_with_control(control)?,
68                        optional_type(ty.as_ref(), control)?,
69                    ))
70                })
71                .chain(selected.iter().map(|((qualifier, column), (_, ty))| {
72                    Ok((
73                        ColumnIdentity::from_parts_with_control(*qualifier, column, control)?,
74                        optional_type(*ty, control)?,
75                    ))
76                })),
77            control,
78        )?;
79        let mut metadata = copy::metadata_with_identity_maps(
80            input,
81            collations.finish(control)?,
82            aliases,
83            types,
84            control,
85        )?;
86        metadata.local_width = None;
87        copy::with_metadata(input, metadata, control)
88    }
89
90    pub fn append_internal_typed_with_control<'a>(
91        input: &'a Self,
92        columns: impl IntoIterator<Item = (InternalColumnRef, Option<&'a ColumnType>)>,
93        control: &ProductionControl<'_>,
94    ) -> Result<Self, SQLError> {
95        let mut selected = ProductionMap::new(*control);
96        let mut collations = crate::schema::collations::composition::Selection::new(
97            &input.index.cold.collations,
98            control,
99        )?;
100        let base = input.physical_width();
101        let mut width = base;
102        for (column, ty) in columns {
103            collations.internal(column, None, ty)?;
104            selected.insert_copy(column, (width, ty))?;
105            width += 1;
106        }
107        let mut metadata = copy::metadata(input, control)?;
108        metadata.collations = collations.finish(control)?;
109        metadata.internal = SchemaMap::from_produced(
110            input
111                .index
112                .executor_attributes
113                .iter()
114                .map(|(column, slot)| {
115                    Ok((
116                        control.finish(*column, control.empty_reservation())?,
117                        control.finish(*slot, control.empty_reservation())?,
118                    ))
119                })
120                .chain(selected.iter().map(|(column, (slot, _))| {
121                    Ok((
122                        control.finish(*column, control.empty_reservation())?,
123                        control.finish(*slot, control.empty_reservation())?,
124                    ))
125                })),
126            control,
127        )?;
128        metadata.internal_types = SchemaMap::from_produced(
129            input
130                .index
131                .cold
132                .executor_attribute_types
133                .iter()
134                .map(|(column, ty)| {
135                    Ok((
136                        control.finish(*column, control.empty_reservation())?,
137                        optional_type(ty.as_ref(), control)?,
138                    ))
139                })
140                .chain(selected.iter().map(|(column, (_, ty))| {
141                    Ok((
142                        control.finish(*column, control.empty_reservation())?,
143                        optional_type(*ty, control)?,
144                    ))
145                })),
146            control,
147        )?;
148        metadata.local_width = None;
149        copy::with_metadata_width(input, metadata, width, control)
150    }
151}
152
153#[cfg(test)]
154mod tests {
155    use super::*;
156    use uqa_core::{memory::MemoryBudget, CancellationToken};
157
158    #[test]
159    fn physical_scan_attributes_keep_slots_types_collations_and_alias_precedence() {
160        let input = RowSchema::with_column_metadata(
161            Some("q"),
162            [
163                ("x".into(), Some(ColumnType::Text), Some(950)),
164                ("n".into(), Some(ColumnType::Integer), None),
165            ],
166        );
167        let relation = crate::ast::InternalRelationId::allocate();
168        let memory = MemoryBudget::new(1 << 20);
169        let token = CancellationToken::new();
170        let control = ProductionControl::new(&memory, &token, &token);
171        let extended = RowSchema::append_internal_typed_with_control(
172            &input,
173            [
174                (relation.column(0), Some(&ColumnType::BigInteger)),
175                (relation.column(1), Some(&ColumnType::DoublePrecision)),
176            ],
177            &control,
178        )
179        .unwrap();
180        assert_eq!(extended.columns(), input.columns());
181        assert_eq!(extended.physical_width(), 4);
182        assert_eq!(extended.internal_slot(relation.column(0)), Some(2));
183        assert_eq!(extended.internal_slot(relation.column(1)), Some(3));
184        assert_eq!(extended.column_collation(0), Some(950));
185        let aliases = RowSchema::with_physical_identity_aliases_with_control(
186            &extended,
187            [
188                (Some("q"), "hidden", 0, Some(&ColumnType::Text)),
189                (Some("q"), "hidden", 3, Some(&ColumnType::DoublePrecision)),
190                (Some("q"), "x", 2, Some(&ColumnType::BigInteger)),
191                (Some("q"), "text_alias", 0, Some(&ColumnType::Text)),
192            ],
193            &control,
194        )
195        .unwrap();
196        assert_eq!(aliases.qualified_slot("q", "hidden"), Some(3));
197        assert_eq!(aliases.qualified_slot("q", "x"), Some(0));
198        assert_eq!(
199            aliases.qualified_type("q", "hidden"),
200            Some(&ColumnType::DoublePrecision)
201        );
202        assert_eq!(
203            aliases.qualified_type("q", "text_alias"),
204            Some(&ColumnType::Text)
205        );
206        assert_eq!(aliases.internal_slot(relation.column(1)), Some(3));
207        assert_eq!(aliases.columns(), input.columns());
208        assert_eq!(input.physical_width(), 2);
209        let retained = aliases.clone();
210        drop(extended);
211        let held = memory.used();
212        drop(aliases);
213        assert_eq!(memory.used(), held);
214        drop(retained);
215        assert_eq!(memory.used(), 0);
216    }
217
218    #[test]
219    fn physical_scan_aliases_admit_large_names_before_copying_and_release_failures() {
220        let input = RowSchema::new(vec!["x".into()]);
221        let name = "x".repeat(4 << 20);
222        let memory = MemoryBudget::new(64 << 20);
223        let original = CancellationToken::new();
224        let invoking = CancellationToken::new();
225        let control = ProductionControl::new(&memory, &original, &invoking);
226        let build = || {
227            RowSchema::with_physical_identity_aliases_with_control(
228                &input,
229                [(Some("q"), name.as_str(), 0, Some(&ColumnType::Integer))],
230                &control,
231            )
232        };
233        let occupied = memory.reserve(memory.available() - (64 << 10)).unwrap();
234        let mut failed = None;
235        let allocation = allocation_counter::measure(|| failed = Some(build()));
236        assert_eq!(failed.unwrap().unwrap_err().sqlstate(), Some("53200"));
237        assert!(allocation.bytes_total < 256 << 10, "{allocation:?}");
238        assert_eq!(memory.used(), occupied.bytes());
239        drop(occupied);
240        for token in [&original, &invoking] {
241            token.cancel();
242            assert_eq!(build().unwrap_err().sqlstate(), Some("57014"));
243            assert_eq!(memory.used(), 0);
244            token.reset();
245        }
246        let schema = build().unwrap();
247        assert_eq!(schema.qualified_slot("q", &name), Some(0));
248        assert!(memory.used() >= name.len());
249        drop(schema);
250        assert_eq!(memory.used(), 0);
251    }
252}