uqa_sql/plan/
input_projection.rs1use 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
72pub 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
87pub 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
115pub(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}