uqa_sql/plan/
query_visit.rs1use super::{
10 CommandPlan, CtePlan, CtePlanBody, QueryPlan, RelationalPlan, SourcePlan, UnifiedPlan,
11};
12
13impl UnifiedPlan {
14 pub fn visit_queries_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan)) {
15 self.try_visit_queries_mut(&mut |query| {
16 visit(query);
17 Ok::<_, std::convert::Infallible>(())
18 })
19 .unwrap_or_else(|never| match never {});
20 }
21
22 pub fn visit_query_roots_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan)) {
24 self.visit_queries_while_mut(&mut |query| {
25 visit(query);
26 Ok::<_, std::convert::Infallible>(false)
27 })
28 .unwrap_or_else(|never| match never {});
29 }
30
31 pub fn try_visit_queries_mut<E>(
33 &mut self,
34 visit: &mut dyn FnMut(&mut QueryPlan) -> Result<(), E>,
35 ) -> Result<(), E> {
36 self.visit_queries_while_mut(&mut |query| visit(query).map(|()| true))
37 }
38
39 fn visit_queries_while_mut<E>(
40 &mut self,
41 visit: &mut dyn FnMut(&mut QueryPlan) -> Result<bool, E>,
42 ) -> Result<(), E> {
43 match self {
44 Self::Query(query) => query.visit_queries_while_mut(visit),
45 Self::Command(command) => visit_command(command, visit),
46 }
47 }
48}
49
50fn visit_ctes<E>(
51 ctes: &mut [CtePlan],
52 visit: &mut dyn FnMut(&mut QueryPlan) -> Result<bool, E>,
53) -> Result<(), E> {
54 for cte in ctes {
55 match &mut cte.body {
56 CtePlanBody::Query(query) => query.visit_queries_while_mut(visit)?,
57 CtePlanBody::Command(command) => visit_command(command, visit)?,
58 }
59 }
60 Ok(())
61}
62
63fn visit_command<E>(
64 command: &mut CommandPlan,
65 visit: &mut dyn FnMut(&mut QueryPlan) -> Result<bool, E>,
66) -> Result<(), E> {
67 match command {
68 CommandPlan::CreateView { query, .. }
69 | CommandPlan::CreateTableAs { query, .. }
70 | CommandPlan::CreateMaterializedView { query, .. }
71 | CommandPlan::DeclareCursor { query, .. } => {
72 return query.visit_queries_while_mut(visit);
73 }
74 CommandPlan::Explain { body, .. } | CommandPlan::Prepare { body, .. } => {
75 return body.visit_queries_while_mut(visit);
76 }
77 CommandPlan::Execute { params, .. } | CommandPlan::Call { args: params, .. } => {
78 for expression in params {
79 for query in &mut expression.subqueries {
80 query.visit_queries_while_mut(visit)?;
81 }
82 }
83 return Ok(());
84 }
85 _ => {}
86 }
87 if let Some(ctes) = command.ctes_mut() {
88 visit_ctes(ctes, visit)?;
89 }
90 for query in command.query_inputs_mut() {
91 query.visit_queries_while_mut(visit)?;
92 }
93 if let Some(source) = command.source_input_mut() {
94 visit_source(source, visit)?;
95 }
96 Ok(())
97}
98
99impl QueryPlan {
100 pub fn visit_queries_mut(&mut self, visit: &mut dyn FnMut(&mut Self)) {
101 self.try_visit_queries_mut(&mut |query| {
102 visit(query);
103 Ok::<_, std::convert::Infallible>(())
104 })
105 .unwrap_or_else(|never| match never {});
106 }
107
108 pub fn try_visit_queries_mut<E>(
110 &mut self,
111 visit: &mut dyn FnMut(&mut Self) -> Result<(), E>,
112 ) -> Result<(), E> {
113 self.visit_queries_while_mut(&mut |query| visit(query).map(|()| true))
114 }
115
116 fn visit_queries_while_mut<E>(
117 &mut self,
118 visit: &mut dyn FnMut(&mut Self) -> Result<bool, E>,
119 ) -> Result<(), E> {
120 if !visit(self)? {
121 return Ok(());
122 }
123 visit_ctes(&mut self.ctes, visit)?;
124 let subqueries = match &mut self.root {
125 RelationalPlan::QueryBlock(block) => {
126 if let Some(source) = &mut block.from {
127 visit_source(source, visit)?;
128 }
129 &mut block.subqueries
130 }
131 RelationalPlan::SetOp {
132 left,
133 right,
134 subqueries,
135 ..
136 } => {
137 left.visit_queries_while_mut(visit)?;
138 right.visit_queries_while_mut(visit)?;
139 subqueries
140 }
141 RelationalPlan::Values { subqueries, .. } => subqueries,
142 };
143 for query in subqueries {
144 query.visit_queries_while_mut(visit)?;
145 }
146 Ok(())
147 }
148}
149
150fn visit_source<E>(
151 source: &mut SourcePlan,
152 visit: &mut dyn FnMut(&mut QueryPlan) -> Result<bool, E>,
153) -> Result<(), E> {
154 match source {
155 SourcePlan::Subquery { body, .. } => body.visit_queries_while_mut(visit)?,
156 SourcePlan::Table {
157 executable_query: Some(body),
158 ..
159 } => body.visit_queries_while_mut(visit)?,
160 SourcePlan::Join { left, right, .. } => {
161 visit_source(left, visit)?;
162 visit_source(right, visit)?;
163 }
164 _ => {}
165 }
166 Ok(())
167}
168
169impl CommandPlan {
170 pub fn visit_query_roots_mut(&mut self, visit: &mut dyn FnMut(&mut QueryPlan)) {
171 visit_command(self, &mut |query| {
172 visit(query);
173 Ok::<_, std::convert::Infallible>(false)
174 })
175 .unwrap_or_else(|never| match never {});
176 }
177}