1use super::RuleMutation;
10use crate::{
11 ast::{Expr, InternalRelationId},
12 binding::correlation::{expression_depends_on_outer_row_with_control, CorrelationContext},
13 catalog::roles::RoleReference,
14 plan::{
15 input_projection::{substitute_expression_inputs_owned, OwnedInputProjections},
16 ExpressionPlan, MutableExpressionPlan, MutableQueryPlan, MutableSourcePlan,
17 },
18 semantics::rules::{
19 analysis::{rule_returning_columns_with_control, RuleAnalysisContext},
20 binding::{OwnedRuleQueryInput, OwnedRuleQueryResolver},
21 },
22 RowSchema, SQLError, ScalarExpr,
23};
24use uqa_core::memory::{OwnedMap, Produced, ProductionControl};
25
26mod capture;
27mod namespaces;
28
29pub struct OwnedMutationRuleInput {
30 pub resolver: OwnedRuleQueryResolver,
31 query: MutableQueryPlan,
32 relation: InternalRelationId,
33 pub source_context: Produced<Vec<Expr>>,
34 pub source_context_schema: Option<RowSchema>,
35}
36
37impl OwnedMutationRuleInput {
38 #[expect(
39 clippy::too_many_arguments,
40 reason = "keeps mutation syntax, physical schemas, authority and request ownership distinct"
41 )]
42 pub fn bind(
43 context: RuleAnalysisContext<'_>,
44 correlation: CorrelationContext<'_>,
45 statement: RuleMutation<'_>,
46 schemas: (&RowSchema, Option<&RowSchema>),
47 references_event: bool,
48 input_subject: &RoleReference,
49 rule_subject: &RoleReference,
50 control: &ProductionControl<'_>,
51 ) -> Result<Self, SQLError> {
52 control.check()?;
53 let (target_schema, source_schema) = schemas;
54 let relation = InternalRelationId::allocate();
55 let source_relation = InternalRelationId::allocate();
56 let captured = statement
57 .source()
58 .zip(source_schema)
59 .map(|(source, schema)| {
60 capture::source(
61 statement,
62 source,
63 schema,
64 source_relation,
65 input_subject,
66 control,
67 )
68 })
69 .transpose()?;
70 let empty_columns = OwnedMap::new();
71 let source_columns = captured
72 .as_ref()
73 .map_or(&empty_columns, |source| &source.columns);
74 let definitions = rule_returning_columns_with_control(context, statement.table(), control)?;
75 let target_width = definitions.len();
76 let rewrite = namespaces::input_rewrite(
77 statement,
78 &definitions,
79 source_schema,
80 relation,
81 source_relation,
82 target_schema,
83 control,
84 )?;
85 let inputs = MutationExpressions {
86 target: relation,
87 source: source_relation,
88 target_width,
89 source_columns,
90 rewrite: &rewrite,
91 subject: input_subject,
92 };
93 let resolver = OwnedRuleQueryResolver::from_mutation_with_control(
94 context,
95 statement,
96 &definitions,
97 Some(relation),
98 Some(&rewrite),
99 control,
100 |expression| inputs.bind(expression, control),
101 )?;
102 let needs_target = needs_target(
103 correlation,
104 statement,
105 references_event,
106 target_width,
107 control,
108 )?;
109 let predicate = inputs.predicate(statement, control)?;
110 let target = needs_target
111 .then(|| {
112 capture::target(
113 statement,
114 &definitions,
115 target_schema,
116 relation,
117 rule_subject,
118 control,
119 )
120 })
121 .transpose()?;
122 let (source, source_context, source_context_schema) = match captured {
123 Some(source) => (Some(source.source), source.context, Some(source.schema)),
124 None => (
125 None,
126 control.finish(Vec::new(), control.empty_reservation())?,
127 None,
128 ),
129 };
130 let query =
131 capture::action_query(statement, target, source, predicate, input_subject, control)?;
132 Ok(Self {
133 resolver,
134 query,
135 relation,
136 source_context,
137 source_context_schema,
138 })
139 }
140
141 pub fn finish(
142 self,
143 condition: Option<MutableExpressionPlan>,
144 control: &ProductionControl<'_>,
145 ) -> Result<OwnedRuleQueryInput, SQLError> {
146 Ok(OwnedRuleQueryInput {
147 query: self.query,
148 inline: true,
149 relation: self.relation,
150 condition,
151 expressions: control.finish(self.resolver.expressions, control.empty_reservation())?,
152 })
153 }
154}
155
156struct MutationExpressions<'a> {
157 target: InternalRelationId,
158 source: InternalRelationId,
159 target_width: usize,
160 source_columns: &'a OwnedInputProjections,
161 rewrite: &'a crate::semantics::view_rewrite::DeferredOuterRewrite,
162 subject: &'a RoleReference,
163}
164
165impl MutationExpressions<'_> {
166 fn bind(
167 &self,
168 expression: MutableExpressionPlan,
169 control: &ProductionControl<'_>,
170 ) -> Result<MutableExpressionPlan, SQLError> {
171 let expression = bind_positions(
172 expression,
173 self.target,
174 self.source,
175 self.target_width,
176 control,
177 )?;
178 self.substitute(expression, control)
179 }
180
181 fn substitute(
182 &self,
183 expression: MutableExpressionPlan,
184 control: &ProductionControl<'_>,
185 ) -> Result<MutableExpressionPlan, SQLError> {
186 let expression =
187 substitute_expression_inputs_owned(expression, self.source_columns, control)?;
188 super::super::resolver::retain_authority(expression, Some(self.subject), control)
189 }
190
191 fn predicate(
192 &self,
193 statement: RuleMutation<'_>,
194 control: &ProductionControl<'_>,
195 ) -> Result<Option<MutableExpressionPlan>, SQLError> {
196 statement
197 .predicate()
198 .map(|scalar| {
199 let expression =
200 MutableExpressionPlan::copy_from(scalar, statement.subqueries(), control)?;
201 let expression = bind_positions(
202 expression,
203 self.target,
204 self.source,
205 self.target_width,
206 control,
207 )?;
208 let expression = self.rewrite.bind_expression_owned(expression, control)?;
209 self.substitute(expression, control)?
210 .prune_subqueries(control)
211 })
212 .transpose()
213 }
214}
215
216fn needs_target(
217 correlation: CorrelationContext<'_>,
218 statement: RuleMutation<'_>,
219 references_event: bool,
220 width: usize,
221 control: &ProductionControl<'_>,
222) -> Result<bool, SQLError> {
223 Ok(references_event
224 || references_target_position(statement.predicate(), width, control)?
225 || statement
226 .predicate()
227 .map(|scalar| {
228 expression_depends_on_outer_row_with_control(
229 correlation,
230 scalar,
231 statement.subqueries(),
232 statement.source(),
233 statement.ctes(),
234 control,
235 )
236 })
237 .transpose()?
238 .unwrap_or(false))
239}
240
241fn references_target_position(
242 predicate: Option<&ScalarExpr>,
243 width: usize,
244 control: &ProductionControl<'_>,
245) -> Result<bool, SQLError> {
246 let mut found = false;
247 if let Some(predicate) = predicate {
248 predicate.try_visit(&mut |node| {
249 control.check()?;
250 found |= matches!(node, ScalarExpr::Position(position) if *position < width);
251 Ok::<_, SQLError>(!found)
252 })?;
253 }
254 Ok(found)
255}
256
257fn bind_positions(
258 expression: MutableExpressionPlan,
259 target: InternalRelationId,
260 source: InternalRelationId,
261 width: usize,
262 control: &ProductionControl<'_>,
263) -> Result<MutableExpressionPlan, SQLError> {
264 expression.map_scalar(control, |scalar, _| {
265 scalar.transform_nodes(control, &mut |_, node| {
266 if let ScalarExpr::Position(position) = &*node {
267 let column = if *position < width {
268 target.column(*position)
269 } else {
270 source.column(*position - width)
271 };
272 Ok(ScalarExpr::InternalColumn(column).copy_for_rewrite(control)?)
273 } else {
274 Ok(node)
275 }
276 })
277 })
278}
279
280fn input_expression(
281 relation: InternalRelationId,
282 position: usize,
283 control: &ProductionControl<'_>,
284) -> Result<Produced<ExpressionPlan>, SQLError> {
285 MutableExpressionPlan::copy_from(
286 &ScalarExpr::InternalColumn(relation.column(position)),
287 &[],
288 control,
289 )?
290 .finish(control)
291}
292
293struct CapturedSource {
294 source: MutableSourcePlan,
295 columns: OwnedInputProjections,
296 context: Produced<Vec<Expr>>,
297 schema: RowSchema,
298}