Skip to main content

uqa_sql/plan/
input_projection.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Substitute analyzed input expressions without evaluating their values.
8
9use super::{ExpressionPlan, ScalarExpr};
10use crate::{ast::InternalColumnRef, SQLError};
11use std::collections::BTreeMap;
12use uqa_core::memory::{OwnedMap, Produced, ProductionControl};
13
14pub type OwnedInputProjections = OwnedMap<InternalColumnRef, Produced<ExpressionPlan>>;
15
16pub fn substitute_expression_inputs_owned(
17    mut plan: super::MutableExpressionPlan,
18    inputs: &OwnedInputProjections,
19    control: &ProductionControl<'_>,
20) -> Result<super::MutableExpressionPlan, SQLError> {
21    if inputs.is_empty() {
22        control.check()?;
23        return Ok(plan);
24    }
25    for index in 0..plan.queries().len() {
26        plan = plan.map_query(index, control, |query| {
27            query.transform_scalar_arenas(control, &mut |_, expression, arena| {
28                substitute_owned(expression, arena, inputs, control)
29            })
30        })?;
31    }
32    plan = plan.map_scalar(control, |expression, arena| {
33        expression.transform_nodes(control, &mut |_, expression| {
34            substitute_owned(expression, arena, inputs, control)
35        })
36    })?;
37    Ok(plan)
38}
39
40pub fn substitute_plan_inputs_owned(
41    plan: super::MutableExecutablePlan,
42    inputs: &OwnedInputProjections,
43    control: &ProductionControl<'_>,
44) -> Result<super::MutableExecutablePlan, SQLError> {
45    if inputs.is_empty() {
46        control.check()?;
47        return Ok(plan);
48    }
49    plan.transform_scalar_arenas(control, &mut |_, expression, arena| {
50        substitute_owned(expression, arena, inputs, control)
51    })
52}
53
54fn substitute_owned(
55    expression: super::OwnedScalarExpr,
56    arena: &mut super::ScalarQueryArena,
57    inputs: &OwnedInputProjections,
58    control: &ProductionControl<'_>,
59) -> Result<super::OwnedScalarExpr, SQLError> {
60    control.check()?;
61    if let ScalarExpr::InternalColumn(column) = &*expression {
62        if let Some(input) = inputs.get(column) {
63            return arena.append_expression(input.copy_for_rewrite(control)?, control);
64        }
65    }
66    Ok(expression)
67}
68
69#[cfg(test)]
70mod tests;
71
72/// Inline structurally identified inputs at their use sites. Each query keeps its own scalar-subquery arena, and inserted expressions retain their analyzed routine bindings.
73pub fn substitute_expression_inputs(
74    plan: &mut ExpressionPlan,
75    inputs: &BTreeMap<InternalColumnRef, ExpressionPlan>,
76) -> Result<(), SQLError> {
77    if inputs.is_empty() {
78        return Ok(());
79    }
80    super::subqueries::rewrite_expression_with_arena(
81        &mut plan.scalar,
82        &mut plan.subqueries,
83        &mut |node, arena| substitute_input(node, arena, inputs),
84    )
85}
86
87/// Apply the same input substitution to every native query/command arena.
88pub fn substitute_plan_inputs(
89    plan: &mut super::UnifiedPlan,
90    inputs: &BTreeMap<InternalColumnRef, ExpressionPlan>,
91) -> Result<(), SQLError> {
92    if inputs.is_empty() {
93        return Ok(());
94    }
95    super::subqueries::rewrite_with_arenas(plan, &mut |node, arena| {
96        substitute_input(node, arena, inputs)
97    })
98}
99
100fn substitute_input(
101    node: &mut ScalarExpr,
102    arena: &mut Vec<super::QueryPlan>,
103    inputs: &BTreeMap<InternalColumnRef, ExpressionPlan>,
104) -> Result<(), SQLError> {
105    let ScalarExpr::InternalColumn(column) = node else {
106        return Ok(());
107    };
108    let Some(input) = inputs.get(column) else {
109        return Ok(());
110    };
111    *node = append_expression(arena, input.clone());
112    Ok(())
113}
114
115/// Transfer an expression into another scalar arena while retaining its selected query identities.
116pub(crate) fn append_expression(
117    arena: &mut Vec<super::QueryPlan>,
118    mut input: ExpressionPlan,
119) -> ScalarExpr {
120    let offset = arena.len();
121    super::rewrite_scalar_expression(&mut input.scalar, &mut |node| match node {
122        ScalarExpr::ScalarSubquery(id)
123        | ScalarExpr::Exists { subquery: id, .. }
124        | ScalarExpr::InSubquery { subquery: id, .. } => *id += offset,
125        _ => {}
126    });
127    arena.extend(input.subqueries);
128    input.scalar
129}