Skip to main content

uqa_sql/plan/
subqueries.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Compact scalar-subquery arenas after expression rewrites discard inputs.
8
9use crate::ScalarExpr;
10
11use super::{CommandPlan, QueryPlan, RelationalPlan, SourcePlan};
12
13mod compaction;
14pub use compaction::{
15    prune_command_with_control, prune_expression_with_control, prune_query_with_control,
16};
17pub(crate) use compaction::{
18    prune_command_with_retention, prune_expression_with_retention, prune_query_with_retention,
19};
20
21mod transfer;
22pub use transfer::transfer_expression;
23
24mod transform;
25pub(crate) use transform::{
26    copy_occurrences, rewrite_expression_with_arena, rewrite_expression_with_arena_and_metadata,
27    rewrite_query_with_arenas, rewrite_with_arenas, rewrite_with_arenas_and_metadata,
28};
29
30/// Drop unreferenced query children and remap local command expressions without evaluating them.
31pub fn prune_command(command: &mut CommandPlan) {
32    prune_command_with_control(command, uqa_core::memory::ProductionControl::uncontrolled())
33        .expect("uncontrolled scalar-subquery compaction");
34}
35
36fn command_arena(command: &mut CommandPlan) -> Option<&mut Vec<QueryPlan>> {
37    match command {
38        CommandPlan::Insert(plan) => Some(&mut plan.subqueries),
39        CommandPlan::Update(plan) => Some(&mut plan.subqueries),
40        CommandPlan::Delete(plan) => Some(&mut plan.subqueries),
41        CommandPlan::Merge(plan) => Some(&mut plan.subqueries),
42        _ => None,
43    }
44}
45
46/// Drop unreferenced query children and remap local query expressions, including canonical window definitions.
47pub fn prune_query(query: &mut QueryPlan) {
48    prune_query_with_control(query, uqa_core::memory::ProductionControl::uncontrolled())
49        .expect("uncontrolled scalar-subquery compaction");
50}
51
52/// Retain only query children actually referenced by one scalar expression.
53pub fn prune_expression(plan: &mut super::ExpressionPlan) {
54    prune_expression_with_control(plan, uqa_core::memory::ProductionControl::uncontrolled())
55        .expect("uncontrolled scalar-subquery compaction");
56}
57
58fn query_arena(root: &mut RelationalPlan) -> &mut Vec<QueryPlan> {
59    match root {
60        RelationalPlan::QueryBlock(block) => &mut block.subqueries,
61        RelationalPlan::Values { subqueries, .. } | RelationalPlan::SetOp { subqueries, .. } => {
62            subqueries
63        }
64    }
65}
66
67fn subquery_id(expression: &mut ScalarExpr) -> Option<&mut usize> {
68    match expression {
69        ScalarExpr::ScalarSubquery(id)
70        | ScalarExpr::Exists { subquery: id, .. }
71        | ScalarExpr::InSubquery { subquery: id, .. } => Some(id),
72        _ => None,
73    }
74}
75
76pub(crate) fn visit_root(root: &mut RelationalPlan, visitor: &mut dyn FnMut(&mut ScalarExpr)) {
77    match root {
78        RelationalPlan::QueryBlock(block) => visit_block(block, visitor),
79        RelationalPlan::Values { rows, .. } => {
80            for expression in rows.iter_mut().flatten() {
81                super::rewrite_scalar_expression(expression, visitor);
82            }
83        }
84        RelationalPlan::SetOp {
85            order_by,
86            limit,
87            offset,
88            ..
89        } => {
90            for expression in order_by
91                .iter_mut()
92                .map(|order| &mut order.expr)
93                .chain(limit.as_deref_mut())
94                .chain(offset.as_deref_mut())
95            {
96                super::rewrite_scalar_expression(expression, visitor);
97            }
98        }
99    }
100}
101
102fn visit_source(source: &mut SourcePlan, visitor: &mut dyn FnMut(&mut ScalarExpr)) {
103    match source {
104        crate::plan::SourcePlan::RetainedRows(_) => {}
105        SourcePlan::Join {
106            left, right, on, ..
107        } => {
108            visit_source(left, visitor);
109            visit_source(right, visitor);
110            if let Some(on) = on {
111                super::rewrite_scalar_expression(on, visitor);
112            }
113        }
114        SourcePlan::Values { rows, .. } => {
115            for expression in rows.iter_mut().flatten() {
116                super::rewrite_scalar_expression(expression, visitor);
117            }
118        }
119        SourcePlan::Function { args, .. } => {
120            for argument in args {
121                super::rewrite_scalar_expression(argument, visitor);
122            }
123        }
124        SourcePlan::FunctionGroup { functions, .. } => {
125            for argument in functions.iter_mut().flat_map(|function| &mut function.args) {
126                super::rewrite_scalar_expression(argument, visitor);
127            }
128        }
129        // A derived query owns its own scalar-subquery arena.
130        SourcePlan::Subquery { .. } | SourcePlan::Table { .. } => {}
131    }
132}
133
134fn visit_block(block: &mut super::QueryBlockPlan, visitor: &mut dyn FnMut(&mut ScalarExpr)) {
135    if let Some(source) = &mut block.from {
136        visit_source(source, visitor);
137    }
138    for expression in block
139        .projections
140        .iter_mut()
141        .map(|projection| &mut projection.expr)
142        .chain(block.r#where.iter_mut())
143        .chain(block.group_by.iter_mut())
144        .chain(block.grouping_sets.iter_mut().flatten())
145        .chain(block.having.iter_mut())
146        .chain(block.order_by.iter_mut().map(|order| &mut order.expr))
147        .chain(block.limit.iter_mut())
148        .chain(block.offset.iter_mut())
149        .chain(block.distinct_on.iter_mut())
150        .chain(
151            block
152                .windows
153                .iter_mut()
154                .flat_map(|window| window.spec.expressions_mut()),
155        )
156    {
157        super::rewrite_scalar_expression(expression, visitor);
158    }
159}