1use super::{
10 CommandQuerySlot, MutableCommandPlan, MutableExecutablePlan, MutableQueryPlan,
11 MutableSourcePlan, QueryChildSlot, SourceChildSlot,
12};
13use crate::{
14 plan::{CommandPlan, RelationalPlan, SourcePlan},
15 SQLError,
16};
17use uqa_core::memory::ProductionControl;
18
19type Visitor<'a> = dyn FnMut(MutableQueryPlan) -> Result<(MutableQueryPlan, bool), SQLError> + 'a;
20
21impl MutableExecutablePlan {
22 pub fn map_queries_while(
24 self,
25 control: &ProductionControl<'_>,
26 visit: &mut Visitor<'_>,
27 ) -> Result<Self, SQLError> {
28 control.check()?;
29 Ok(match self {
30 Self::Query(query) => Self::Query(query.map_queries_while(control, visit)?),
31 Self::Command(command) => Self::Command(command.map_queries_while(control, visit)?),
32 })
33 }
34}
35
36impl MutableQueryPlan {
37 pub fn map_queries_while(
38 self,
39 control: &ProductionControl<'_>,
40 visit: &mut Visitor<'_>,
41 ) -> Result<Self, SQLError> {
42 self.assert_owner(control);
43 control.check()?;
44 let (mut query, descend) = visit(self)?;
45 query.assert_owner(control);
46 control.check()?;
47 if !descend {
48 return Ok(query);
49 }
50 for index in 0..query.ctes.len() {
51 query = query.map_cte(index, control, |body| {
52 body.map_queries_while(control, visit)
53 })?;
54 }
55 match &query.root {
56 RelationalPlan::QueryBlock(_) => {
57 query =
58 query.map_source(control, |source| source_queries(source, control, visit))?;
59 }
60 RelationalPlan::SetOp { .. } => {
61 query = query.map_query_child(QueryChildSlot::Left, control, |query| {
62 query.map_queries_while(control, visit)
63 })?;
64 query = query.map_query_child(QueryChildSlot::Right, control, |query| {
65 query.map_queries_while(control, visit)
66 })?;
67 }
68 RelationalPlan::Values { .. } => {}
69 }
70 let count = match &query.root {
71 RelationalPlan::QueryBlock(block) => block.subqueries.len(),
72 RelationalPlan::SetOp { subqueries, .. }
73 | RelationalPlan::Values { subqueries, .. } => subqueries.len(),
74 };
75 for index in 0..count {
76 query = query.map_query_child(QueryChildSlot::Subquery(index), control, |query| {
77 query.map_queries_while(control, visit)
78 })?;
79 }
80 Ok(query)
81 }
82}
83
84impl MutableCommandPlan {
85 pub fn map_queries_while(
86 mut self,
87 control: &ProductionControl<'_>,
88 visit: &mut Visitor<'_>,
89 ) -> Result<Self, SQLError> {
90 self.assert_owner(control);
91 control.check()?;
92 match &*self {
93 CommandPlan::CreateView { .. }
94 | CommandPlan::CreateTableAs { .. }
95 | CommandPlan::CreateMaterializedView { .. }
96 | CommandPlan::DeclareCursor { .. } => {
97 return self
98 .map_query_body(control, |query| query.map_queries_while(control, visit));
99 }
100 CommandPlan::Explain { .. } | CommandPlan::Prepare { .. } => {
101 return self
102 .map_executable_body(control, |body| body.map_queries_while(control, visit));
103 }
104 CommandPlan::Call { args, .. } => {
105 let count = args.len();
106 for argument in 0..count {
107 let CommandPlan::Call { args, .. } = &*self else {
108 unreachable!()
109 };
110 for query in 0..args[argument].subqueries.len() {
111 self = self.map_query_child(
112 CommandQuerySlot::CallArgumentSubquery { argument, query },
113 control,
114 |query| query.map_queries_while(control, visit),
115 )?;
116 }
117 }
118 return Ok(self);
119 }
120 CommandPlan::Execute { params, .. } => {
121 let count = params.len();
122 for parameter in 0..count {
123 let CommandPlan::Execute { params, .. } = &*self else {
124 unreachable!()
125 };
126 for query in 0..params[parameter].subqueries.len() {
127 self = self.map_query_child(
128 CommandQuerySlot::ExecuteParameterSubquery { parameter, query },
129 control,
130 |query| query.map_queries_while(control, visit),
131 )?;
132 }
133 }
134 return Ok(self);
135 }
136 _ => {}
137 }
138 for index in 0..self.ctes().len() {
139 self = self.map_cte(index, control, |body| {
140 body.map_queries_while(control, visit)
141 })?;
142 }
143 let (insert, count) = match &*self {
144 CommandPlan::Insert(plan) => (plan.source.is_some(), plan.subqueries.len()),
145 CommandPlan::Update(plan) => (false, plan.subqueries.len()),
146 CommandPlan::Delete(plan) => (false, plan.subqueries.len()),
147 CommandPlan::Merge(plan) => (false, plan.subqueries.len()),
148 _ => (false, 0),
149 };
150 if insert {
151 self = self.map_query_child(CommandQuerySlot::InsertSource, control, |query| {
152 query.map_queries_while(control, visit)
153 })?;
154 }
155 for index in 0..count {
156 self = self.map_query_child(CommandQuerySlot::Subquery(index), control, |query| {
157 query.map_queries_while(control, visit)
158 })?;
159 }
160 self.map_source(control, |source| source_queries(source, control, visit))
161 }
162}
163
164fn source_queries(
165 mut source: MutableSourcePlan,
166 control: &ProductionControl<'_>,
167 visit: &mut Visitor<'_>,
168) -> Result<MutableSourcePlan, SQLError> {
169 match &*source {
170 SourcePlan::Subquery { .. }
171 | SourcePlan::Table {
172 executable_query: Some(_),
173 ..
174 } => source.map_query(control, |query| query.map_queries_while(control, visit)),
175 SourcePlan::Join { .. } => {
176 source = source.map_child(SourceChildSlot::Left, control, |source| {
177 source_queries(source, control, visit)
178 })?;
179 source.map_child(SourceChildSlot::Right, control, |source| {
180 source_queries(source, control, visit)
181 })
182 }
183 _ => Ok(source),
184 }
185}