Skip to main content

uqa_sql/plan/
command_expressions.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Borrow the direct scalar roots of mutations without collecting reference arrays.
8
9use super::{
10    AssignmentPlan, CommandPlan, ConflictActionPlan, ConflictPlan, DeletePlan, InsertPlan,
11    MergePlan, MergeWhenPlan, ScalarExpr, UpdatePlan,
12};
13use crate::ast::AssignmentTarget;
14
15impl CommandPlan {
16    /// Scalar roots owned by this mutation, excluding its relational children.
17    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    /// Mutable scalar roots in the same ownership order as `expressions`.
34    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    /// Expressions that see the additional EXCLUDED relation in ON CONFLICT DO UPDATE.
85    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}