Skip to main content

uqa_sql/semantics/rules/binding/actions/query/mutation/
owned.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Mutation event inputs retain independent target, source and expression owners through action attachment.
8
9use 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}