1use super::{
10 production::{visit_column_order, OutputColumn},
11 ColumnIdentity, JoinKind, JoinOutputSource, JoinUsingLayout, ProductionControl,
12 ResolvedJoinColumn, ResolvedJoinUsing, RowSchema, SQLError,
13};
14use uqa_core::memory::{Produced, ProductionVec};
15
16pub fn join_using_output_schema_with_control(
17 kind: JoinKind,
18 left: &RowSchema,
19 right: &RowSchema,
20 using: &ResolvedJoinUsing,
21 control: &ProductionControl<'_>,
22) -> Result<RowSchema, SQLError> {
23 let input = RowSchema::join_with_control(left, right, std::iter::empty::<String>(), control)?;
24 let layout = join_using_layout_with_control(kind, left, right, using, control)?;
25 crate::schema::join_output::compile_layout_with_control(&input, &layout.0, &layout.1, control)
26 .map(|(schema, _)| schema)
27}
28
29pub fn join_using_layout_with_control(
30 kind: JoinKind,
31 left: &RowSchema,
32 right: &RowSchema,
33 using: &ResolvedJoinUsing,
34 control: &ProductionControl<'_>,
35) -> Result<Produced<JoinUsingLayout>, SQLError> {
36 let mut columns = ProductionVec::new(*control);
37 visit_column_order(kind, left.len(), right.len(), using, control, |column| {
38 let (name, identity, source) = match column {
39 OutputColumn::Merged(column) => (
40 column.name.as_str(),
41 ColumnIdentity::from_parts_with_control(None, &column.name, control)?,
42 merged_source(kind, column, left, right, control)?,
43 ),
44 OutputColumn::Left(position) => (
45 left.public_name(position)
46 .unwrap_or(&left.columns()[position]),
47 left.identities()[position].clone_with_control(control)?,
48 control.finish(
49 JoinOutputSource::Input(position),
50 control.empty_reservation(),
51 )?,
52 ),
53 OutputColumn::Right(position) => (
54 right
55 .public_name(position)
56 .unwrap_or(&right.columns()[position]),
57 right.identities()[position].clone_with_control(control)?,
58 control.finish(
59 JoinOutputSource::Input(left.len() + position),
60 control.empty_reservation(),
61 )?,
62 ),
63 };
64 let (name, names) = control.copy_text(name)?.into_parts();
65 let (identity, identities) = identity.into_parts();
66 let (source, sources) = source.into_parts();
67 columns.push_produced(control.finish(
68 (name, identity, source),
69 control.combine(names, control.combine(identities, sources)),
70 )?)?;
71 Ok(())
72 })?;
73 let mut aliases = ProductionVec::new(*control);
74 for (input, offset) in [(left, 0), (right, left.len())] {
75 for (position, identity) in input.identities().iter().enumerate() {
76 control.check()?;
77 if identity.qualifier().is_some() {
78 let (identity, memory) = identity.clone_with_control(control)?.into_parts();
79 aliases.push_produced(control.finish(
80 (identity, JoinOutputSource::Input(offset + position)),
81 memory,
82 )?)?;
83 }
84 }
85 }
86 if let Some(alias) = &using.alias {
87 for (name, _, source) in columns.iter().take(using.columns.len()) {
88 let (identity, names) =
89 ColumnIdentity::from_parts_with_control(Some(alias), name, control)?.into_parts();
90 let (source, sources) = source.clone_with_control(control)?.into_parts();
91 aliases.push_produced(
92 control.finish((identity, source), control.combine(names, sources))?,
93 )?;
94 }
95 }
96 let (columns, column_memory) = columns.finish()?.into_parts();
97 let (aliases, alias_memory) = aliases.finish()?.into_parts();
98 Ok(control.finish(
99 (columns, aliases),
100 control.combine(column_memory, alias_memory),
101 )?)
102}
103
104fn merged_source(
105 kind: JoinKind,
106 column: &ResolvedJoinColumn,
107 left: &RowSchema,
108 right: &RowSchema,
109 control: &ProductionControl<'_>,
110) -> Result<Produced<JoinOutputSource>, SQLError> {
111 if kind == JoinKind::Full {
112 return match &column.output_type {
113 Some(ty) => {
114 let (ty, memory) = ty.clone_with_control(control)?.into_parts();
115 Ok(control.finish(
116 JoinOutputSource::Coalesce {
117 left: column.left,
118 right: left.len() + column.right,
119 ty,
120 },
121 memory,
122 )?)
123 }
124 None => Ok(control.finish(
125 JoinOutputSource::Input(column.left),
126 control.empty_reservation(),
127 )?),
128 };
129 }
130 let (position, source) = match kind {
131 JoinKind::Inner | JoinKind::Left => (column.left, left.column_type(column.left)),
132 JoinKind::Right => (left.len() + column.right, right.column_type(column.right)),
133 JoinKind::Full | JoinKind::Cross => {
134 unreachable!("qualified cross join rejected by column selection")
135 }
136 };
137 if let (Some(source), Some(target)) = (source, column.output_type.as_ref()) {
138 if source != target {
139 let (ty, memory) = target.clone_with_control(control)?.into_parts();
140 return Ok(control.finish(
141 JoinOutputSource::Cast {
142 input: position,
143 ty,
144 },
145 memory,
146 )?);
147 }
148 }
149 Ok(control.finish(
150 JoinOutputSource::Input(position),
151 control.empty_reservation(),
152 )?)
153}
154
155#[cfg(test)]
156mod tests {
157 use super::*;
158 use crate::{ast::JoinUsing, semantics::resolve_join_using, ColumnType};
159 use uqa_core::{memory::MemoryBudget, CancellationToken};
160
161 #[test]
162 fn using_output_payloads_retain_exact_allocated_storage_and_retire_scratch() {
163 let left = RowSchema::with_qualified_types(
164 "l",
165 vec!["id".into(), "payload".into()],
166 vec![Some(ColumnType::Integer), Some(ColumnType::Text)],
167 );
168 let right = RowSchema::with_qualified_types(
169 "r",
170 vec!["id".into(), "payload".into()],
171 vec![Some(ColumnType::BigInteger), Some(ColumnType::Text)],
172 );
173 let clause = JoinUsing {
174 columns: vec!["id".into()],
175 alias: Some("merged".into()),
176 };
177 let using = resolve_join_using(Some(&clause), false, &left, &right)
178 .unwrap()
179 .unwrap();
180 for kind in [
181 JoinKind::Inner,
182 JoinKind::Left,
183 JoinKind::Right,
184 JoinKind::Full,
185 ] {
186 let memory = MemoryBudget::new(1 << 20);
187 let original = CancellationToken::new();
188 let invoking = CancellationToken::new();
189 let control = ProductionControl::new(&memory, &original, &invoking);
190 let mut result = None;
191 let measured = allocation_counter::measure(|| {
192 result = Some(
193 join_using_layout_with_control(kind, &left, &right, &using, &control).unwrap(),
194 );
195 });
196 let result = result.unwrap();
197 assert_eq!(result.0.len(), 3);
198 assert_eq!(result.1.len(), 5);
199 assert_eq!(measured.bytes_current, result.reserved_bytes() as i64);
200 assert_eq!(memory.used(), result.reserved_bytes());
201 drop(result);
202 assert_eq!(memory.used(), 0);
203 for token in [&original, &invoking] {
204 token.cancel();
205 assert_eq!(
206 join_using_layout_with_control(kind, &left, &right, &using, &control)
207 .unwrap_err()
208 .sqlstate(),
209 Some("57014")
210 );
211 assert_eq!(memory.used(), 0);
212 token.reset();
213 }
214 }
215 }
216}