1use super::{
10 AssignmentPlan, CommandPlan, ConflictActionPlan, ConflictPlan, DeletePlan, InsertPlan,
11 MergePlan, MergeWhenPlan, ScalarExpr, UpdatePlan,
12};
13use crate::ast::AssignmentTarget;
14
15impl CommandPlan {
16 pub fn expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
18 let (insert, update, delete, merge) = match self {
19 Self::Insert(plan) => (Some(&**plan), None, None, None),
20 Self::Update(plan) => (None, Some(&**plan), None, None),
21 Self::Delete(plan) => (None, None, Some(&**plan), None),
22 Self::Merge(plan) => (None, None, None, Some(&**plan)),
23 _ => (None, None, None, None),
24 };
25 insert
26 .into_iter()
27 .flat_map(InsertPlan::expressions)
28 .chain(update.into_iter().flat_map(UpdatePlan::expressions))
29 .chain(delete.into_iter().flat_map(DeletePlan::expressions))
30 .chain(merge.into_iter().flat_map(MergePlan::expressions))
31 }
32
33 pub fn expressions_mut(&mut self) -> impl Iterator<Item = &mut ScalarExpr> {
35 let (insert, update, delete, merge) = match self {
36 Self::Insert(plan) => (Some(&mut **plan), None, None, None),
37 Self::Update(plan) => (None, Some(&mut **plan), None, None),
38 Self::Delete(plan) => (None, None, Some(&mut **plan), None),
39 Self::Merge(plan) => (None, None, None, Some(&mut **plan)),
40 _ => (None, None, None, None),
41 };
42 insert
43 .into_iter()
44 .flat_map(InsertPlan::expressions_mut)
45 .chain(update.into_iter().flat_map(UpdatePlan::expressions_mut))
46 .chain(delete.into_iter().flat_map(DeletePlan::expressions_mut))
47 .chain(merge.into_iter().flat_map(MergePlan::expressions_mut))
48 }
49}
50
51impl InsertPlan {
52 pub fn expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
53 self.columns
54 .iter()
55 .flat_map(AssignmentTarget::expressions)
56 .chain(self.rows.iter().flatten())
57 .chain(self.on_conflict.iter().flat_map(ConflictPlan::expressions))
58 .chain(self.returning.iter().map(|projection| &projection.expr))
59 .chain(self.view_checks.iter().map(|check| &check.predicate))
60 }
61
62 fn expressions_mut(&mut self) -> impl Iterator<Item = &mut ScalarExpr> {
63 self.columns
64 .iter_mut()
65 .flat_map(AssignmentTarget::expressions_mut)
66 .chain(self.rows.iter_mut().flatten())
67 .chain(
68 self.on_conflict
69 .iter_mut()
70 .flat_map(ConflictPlan::expressions_mut),
71 )
72 .chain(
73 self.returning
74 .iter_mut()
75 .map(|projection| &mut projection.expr),
76 )
77 .chain(
78 self.view_checks
79 .iter_mut()
80 .map(|check| &mut check.predicate),
81 )
82 }
83
84 pub fn conflict_update_expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
86 self.on_conflict
87 .iter()
88 .flat_map(|conflict| conflict.action.expressions())
89 }
90}
91
92impl ConflictPlan {
93 fn expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
94 self.expressions
95 .iter()
96 .chain(self.predicate.as_deref())
97 .chain(self.action.expressions())
98 }
99
100 fn expressions_mut(&mut self) -> impl Iterator<Item = &mut ScalarExpr> {
101 self.expressions
102 .iter_mut()
103 .chain(self.predicate.as_deref_mut())
104 .chain(self.action.expressions_mut())
105 }
106}
107
108impl ConflictActionPlan {
109 fn expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
110 let (assignments, predicate): (&[AssignmentPlan], _) = match self {
111 Self::Nothing => (&[], None),
112 Self::Update {
113 assignments,
114 predicate,
115 } => (assignments, predicate.as_deref()),
116 };
117 assignments
118 .iter()
119 .flat_map(AssignmentPlan::expressions)
120 .chain(predicate)
121 }
122
123 fn expressions_mut(&mut self) -> impl Iterator<Item = &mut ScalarExpr> {
124 let (assignments, predicate): (&mut [AssignmentPlan], _) = match self {
125 Self::Nothing => (&mut [], None),
126 Self::Update {
127 assignments,
128 predicate,
129 } => (assignments, predicate.as_deref_mut()),
130 };
131 assignments
132 .iter_mut()
133 .flat_map(AssignmentPlan::expressions_mut)
134 .chain(predicate)
135 }
136}
137
138impl UpdatePlan {
139 pub fn expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
140 self.assignments
141 .iter()
142 .flat_map(AssignmentPlan::expressions)
143 .chain(self.predicate.as_ref())
144 .chain(self.returning.iter().map(|projection| &projection.expr))
145 .chain(self.view_checks.iter().map(|check| &check.predicate))
146 }
147
148 fn expressions_mut(&mut self) -> impl Iterator<Item = &mut ScalarExpr> {
149 self.assignments
150 .iter_mut()
151 .flat_map(AssignmentPlan::expressions_mut)
152 .chain(self.predicate.as_mut())
153 .chain(
154 self.returning
155 .iter_mut()
156 .map(|projection| &mut projection.expr),
157 )
158 .chain(
159 self.view_checks
160 .iter_mut()
161 .map(|check| &mut check.predicate),
162 )
163 }
164}
165
166impl DeletePlan {
167 pub fn expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
168 self.predicate
169 .iter()
170 .chain(self.returning.iter().map(|projection| &projection.expr))
171 }
172
173 fn expressions_mut(&mut self) -> impl Iterator<Item = &mut ScalarExpr> {
174 self.predicate.iter_mut().chain(
175 self.returning
176 .iter_mut()
177 .map(|projection| &mut projection.expr),
178 )
179 }
180}
181
182impl MergePlan {
183 pub fn expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
184 self.target_predicate
185 .iter()
186 .chain(std::iter::once(&self.join_condition))
187 .chain(
188 self.when_clauses
189 .iter()
190 .flat_map(MergeWhenPlan::expressions),
191 )
192 .chain(self.returning.iter().map(|projection| &projection.expr))
193 .chain(self.view_checks.iter().map(|check| &check.predicate))
194 }
195
196 fn expressions_mut(&mut self) -> impl Iterator<Item = &mut ScalarExpr> {
197 self.target_predicate
198 .iter_mut()
199 .chain(std::iter::once(&mut self.join_condition))
200 .chain(
201 self.when_clauses
202 .iter_mut()
203 .flat_map(MergeWhenPlan::expressions_mut),
204 )
205 .chain(
206 self.returning
207 .iter_mut()
208 .map(|projection| &mut projection.expr),
209 )
210 .chain(
211 self.view_checks
212 .iter_mut()
213 .map(|check| &mut check.predicate),
214 )
215 }
216}
217
218impl MergeWhenPlan {
219 fn expressions(&self) -> impl Iterator<Item = &ScalarExpr> {
220 let (condition, assignments, columns, values): (
221 _,
222 &[AssignmentPlan],
223 &[AssignmentTarget<ScalarExpr>],
224 &[ScalarExpr],
225 ) = match self {
226 Self::UpdateMatched {
227 condition,
228 assignments,
229 }
230 | Self::UpdateNotMatchedBySource {
231 condition,
232 assignments,
233 } => (condition.as_ref(), assignments, &[], &[]),
234 Self::InsertNotMatched {
235 condition,
236 columns,
237 values,
238 ..
239 } => (condition.as_ref(), &[], columns, values),
240 Self::DeleteMatched { condition }
241 | Self::DeleteNotMatchedBySource { condition }
242 | Self::NothingMatched { condition }
243 | Self::NothingNotMatched { condition }
244 | Self::NothingNotMatchedBySource { condition } => (condition.as_ref(), &[], &[], &[]),
245 };
246 condition
247 .into_iter()
248 .chain(assignments.iter().flat_map(AssignmentPlan::expressions))
249 .chain(columns.iter().flat_map(AssignmentTarget::expressions))
250 .chain(values)
251 }
252
253 fn expressions_mut(&mut self) -> impl Iterator<Item = &mut ScalarExpr> {
254 let (condition, assignments, columns, values): (
255 _,
256 &mut [AssignmentPlan],
257 &mut [AssignmentTarget<ScalarExpr>],
258 &mut [ScalarExpr],
259 ) = match self {
260 Self::UpdateMatched {
261 condition,
262 assignments,
263 }
264 | Self::UpdateNotMatchedBySource {
265 condition,
266 assignments,
267 } => (condition.as_mut(), assignments, &mut [], &mut []),
268 Self::InsertNotMatched {
269 condition,
270 columns,
271 values,
272 ..
273 } => (condition.as_mut(), &mut [], columns, values),
274 Self::DeleteMatched { condition }
275 | Self::DeleteNotMatchedBySource { condition }
276 | Self::NothingMatched { condition }
277 | Self::NothingNotMatched { condition }
278 | Self::NothingNotMatchedBySource { condition } => {
279 (condition.as_mut(), &mut [], &mut [], &mut [])
280 }
281 };
282 condition
283 .into_iter()
284 .chain(
285 assignments
286 .iter_mut()
287 .flat_map(AssignmentPlan::expressions_mut),
288 )
289 .chain(
290 columns
291 .iter_mut()
292 .flat_map(AssignmentTarget::expressions_mut),
293 )
294 .chain(values)
295 }
296}