Skip to main content

uqa_sql/semantics/join_using/
output.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Qualified JOIN output selection admits each copied identity and coercion before construction.
8
9use 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}