1use 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}