uqa_sql/plan/
subqueries.rs1use 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
30pub 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
46pub 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
52pub 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 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}