1use super::{
10 assignments, prepend, projection_block, BTreeMap, Expr, InternalRelationId, ProjectionPlan,
11 QueryPlan, RelationalPlan, RuleQueryInput, RuleQueryResolver, SQLError, ScalarExpr, SourcePlan,
12};
13use crate::{
14 ast::RuleEvent,
15 binding::correlation::{expression_depends_on_outer_row, CorrelationContext},
16 catalog::roles::RoleReference,
17 plan::{CtePlan, DeletePlan, ExpressionPlan, UpdatePlan},
18 semantics::{rules::analysis::RuleAnalysisContext, view_rewrite::DeferredOuterRewrite},
19 ColumnIdentity, RowSchema,
20};
21
22mod original;
23mod owned;
24pub use owned::OwnedMutationRuleInput;
25
26#[derive(Clone, Copy)]
27pub enum RuleMutation<'a> {
28 Update(&'a UpdatePlan),
29 Delete(&'a DeletePlan),
30}
31
32macro_rules! field {
33 ($self:expr, $name:ident) => {
34 match $self {
35 RuleMutation::Update(plan) => &plan.$name,
36 RuleMutation::Delete(plan) => &plan.$name,
37 }
38 };
39}
40
41impl<'a> RuleMutation<'a> {
42 pub fn table(self) -> &'a str {
43 field!(self, table)
44 }
45
46 pub fn event(self) -> RuleEvent {
47 match self {
48 Self::Update(_) => RuleEvent::Update,
49 Self::Delete(_) => RuleEvent::Delete,
50 }
51 }
52
53 pub fn target_qualifier(self) -> &'a str {
54 field!(self, target_qualifier)
55 }
56
57 pub fn source(self) -> Option<&'a SourcePlan> {
58 field!(self, source).as_deref()
59 }
60
61 pub fn predicate(self) -> Option<&'a ScalarExpr> {
62 field!(self, predicate).as_ref()
63 }
64
65 pub fn subqueries(self) -> &'a [QueryPlan] {
66 field!(self, subqueries)
67 }
68
69 pub fn ctes(self) -> &'a [CtePlan] {
70 field!(self, ctes)
71 }
72
73 pub fn returning(self) -> &'a [ProjectionPlan] {
74 field!(self, returning)
75 }
76
77 pub fn returning_aliases(self) -> &'a crate::ast::ReturningAliases {
78 field!(self, returning_aliases)
79 }
80
81 pub fn target_source(self) -> SourcePlan {
82 SourcePlan::Table {
83 name: self.table().to_owned(),
84 executable_query: None,
85 qualifier: self.target_qualifier().to_owned(),
86 alias: field!(self, target_alias).clone(),
87 column_aliases: Vec::new(),
88 bound_columns: None,
89 include_descendants: *field!(self, include_descendants),
90 }
91 }
92
93 pub fn target_source_with_control(
94 self,
95 control: &uqa_core::memory::ProductionControl<'_>,
96 ) -> Result<crate::plan::MutableSourcePlan, SQLError> {
97 crate::plan::MutableSourcePlan::table(
98 self.table(),
99 self.target_qualifier(),
100 field!(self, target_alias).as_deref(),
101 *field!(self, include_descendants),
102 control,
103 )
104 }
105
106 fn relations_bound(self) -> bool {
107 *field!(self, relations_bound)
108 }
109
110 pub fn original_condition(
112 self,
113 context: RuleAnalysisContext<'_>,
114 binding: crate::binding::stored_routines::analysis::CatalogRoutineAnalysisContext<'_>,
115 subject: &RoleReference,
116 ) -> Result<Option<ExpressionPlan>, SQLError> {
117 let control = uqa_core::memory::ProductionControl::uncontrolled();
118 self.original_condition_with_control(context, binding, subject, &control)?
119 .map(|condition| {
120 condition.finish(&control).map(|value| {
121 value
122 .into_uncontrolled()
123 .expect("ordinary original qualification")
124 })
125 })
126 .transpose()
127 }
128}
129
130pub struct MutationRuleInput {
132 pub resolver: RuleQueryResolver,
133 pub input: RuleQueryInput,
134 pub source_context: Vec<Expr>,
135 pub source_context_schema: Option<RowSchema>,
136}
137
138impl MutationRuleInput {
139 pub fn qualify_update_original(
140 context: RuleAnalysisContext<'_>,
141 statement: &mut UpdatePlan,
142 binding: crate::binding::stored_routines::analysis::CatalogRoutineAnalysisContext<'_>,
143 subject: &RoleReference,
144 ) -> Result<bool, SQLError> {
145 if crate::semantics::rules::analysis::relation_suppresses_original_query(
146 context,
147 &statement.table,
148 RuleEvent::Update,
149 )? {
150 return Ok(false);
151 }
152 let condition =
153 RuleMutation::Update(statement).original_condition(context, binding, subject)?;
154 super::add_native_condition(
155 &mut statement.predicate,
156 &mut statement.subqueries,
157 condition,
158 );
159 Ok(true)
160 }
161
162 pub fn qualify_delete_original(
163 context: RuleAnalysisContext<'_>,
164 statement: &mut DeletePlan,
165 binding: crate::binding::stored_routines::analysis::CatalogRoutineAnalysisContext<'_>,
166 subject: &RoleReference,
167 ) -> Result<bool, SQLError> {
168 if crate::semantics::rules::analysis::relation_suppresses_original_query(
169 context,
170 &statement.table,
171 RuleEvent::Delete,
172 )? {
173 return Ok(false);
174 }
175 let condition =
176 RuleMutation::Delete(statement).original_condition(context, binding, subject)?;
177 super::add_native_condition(
178 &mut statement.predicate,
179 &mut statement.subqueries,
180 condition,
181 );
182 Ok(true)
183 }
184
185 pub fn bind(
186 context: RuleAnalysisContext<'_>,
187 correlation: CorrelationContext<'_>,
188 statement: RuleMutation<'_>,
189 schemas: (&RowSchema, Option<&RowSchema>),
190 references_event: bool,
191 input_subject: &RoleReference,
192 rule_subject: &RoleReference,
193 ) -> Result<Self, SQLError> {
194 let (target_schema, source_schema) = schemas;
195 let relation = InternalRelationId::allocate();
196 let source_relation = InternalRelationId::allocate();
197 let captured = statement
198 .source()
199 .zip(source_schema)
200 .map(|(source, schema)| {
201 capture_source(statement, source, schema, source_relation, input_subject)
202 });
203 let empty_columns = BTreeMap::new();
204 let source_columns = captured
205 .as_ref()
206 .map_or(&empty_columns, |source| &source.columns);
207 let definitions =
208 crate::semantics::rules::analysis::rule_returning_columns(context, statement.table())?;
209 let target_width = definitions.len();
210 let rewrite = input_rewrite(
211 statement,
212 &definitions,
213 source_schema,
214 relation,
215 source_relation,
216 target_schema,
217 );
218 let mut resolver = resolver(context, statement, Some(relation), Some(&rewrite))?;
219 for expression in resolver.expressions.values_mut() {
220 bind_positions(expression, relation, source_relation, target_width);
221 crate::plan::input_projection::substitute_expression_inputs(
222 expression,
223 source_columns,
224 )?;
225 super::values::retain_authority(&mut expression.subqueries, Some(input_subject));
226 }
227 let mut predicate = statement.predicate().map(|scalar| ExpressionPlan {
228 scalar: scalar.clone(),
229 subqueries: statement.subqueries().to_vec(),
230 });
231 let needs_target = references_event
232 || predicate.as_ref().is_some_and(|expression| {
233 let mut found = false;
234 expression.scalar.visit(&mut |node| {
235 found |= matches!(node, ScalarExpr::Position(position) if *position < target_width);
236 });
237 found
238 })
239 || predicate
240 .as_ref()
241 .map(|expression| {
242 expression_depends_on_outer_row(
243 correlation,
244 expression,
245 statement.source(),
246 statement.ctes(),
247 )
248 })
249 .transpose()?
250 .unwrap_or(false);
251 if let Some(expression) = &mut predicate {
252 bind_positions(expression, relation, source_relation, target_width);
253 rewrite.bind_expression(expression);
254 crate::plan::input_projection::substitute_expression_inputs(
255 expression,
256 source_columns,
257 )?;
258 crate::plan::subqueries::prune_expression(expression);
259 super::values::retain_authority(&mut expression.subqueries, Some(input_subject));
260 }
261 let target = needs_target.then(|| {
262 target_source(
263 statement,
264 &definitions,
265 target_schema,
266 relation,
267 rule_subject,
268 )
269 });
270 let mut block = projection_block(Vec::new());
271 let (source, source_context, source_context_schema) = captured.map_or_else(
273 || (None, Vec::new(), None),
274 |source| (Some(source.source), source.context, Some(source.schema)),
275 );
276 block.from = prepend(target, source);
277 super::add_native_condition(&mut block.r#where, &mut block.subqueries, predicate);
278 Ok(Self {
279 resolver,
280 input: RuleQueryInput {
281 query: query(block, statement.relations_bound(), input_subject),
282 inline: true,
283 relation,
284 condition: None,
285 expressions: BTreeMap::new(),
286 },
287 source_context,
288 source_context_schema,
289 })
290 }
291
292 pub fn finish(mut self, condition: Option<ExpressionPlan>) -> RuleQueryInput {
293 self.input.condition = condition;
294 self.input.expressions = self.resolver.expressions;
295 self.input
296 }
297}
298
299struct CapturedMutationSource {
300 source: SourcePlan,
301 columns: BTreeMap<crate::ast::InternalColumnRef, ExpressionPlan>,
302 context: Vec<Expr>,
303 schema: RowSchema,
304}
305
306fn capture_source(
307 statement: RuleMutation<'_>,
308 source: &SourcePlan,
309 schema: &RowSchema,
310 relation: InternalRelationId,
311 subject: &RoleReference,
312) -> CapturedMutationSource {
313 let mut block = projection_block(
314 (0..schema.len())
315 .map(|position| ProjectionPlan {
316 expr: ScalarExpr::Position(position),
317 alias: Some(schema.columns()[position].clone()),
318 })
319 .collect(),
320 );
321 block.from = Some(source.clone());
322 block
323 .projections
324 .extend(source_whole_rows(schema).map(|qualifier| ProjectionPlan {
325 expr: ScalarExpr::Column(qualifier.into()),
326 alias: None,
327 }));
328 block.projections.extend(virtual_projections(schema));
329 let mut slots: BTreeMap<_, _> = (0..schema.len())
330 .filter_map(|position| schema.physical_slot(position).map(|slot| (slot, position)))
331 .collect();
332 for (identity, slot) in schema.lookup_aliases() {
333 if let Some(slot) = slot {
334 slots.entry(slot).or_insert_with(|| {
335 let position = block.projections.len();
336 block.projections.push(ProjectionPlan {
337 expr: identity.qualifier().map_or_else(
338 || ScalarExpr::Column(identity.column().into()),
339 |qualifier| ScalarExpr::qualified_column(qualifier, identity.column()),
340 ),
341 alias: None,
342 });
343 position
344 });
345 }
346 }
347 let mut columns = BTreeMap::new();
348 for (column, slot) in schema.internal_identities() {
349 let position = *slots.entry(slot).or_insert_with(|| {
350 let position = block.projections.len();
351 block.projections.push(ProjectionPlan {
352 expr: ScalarExpr::InternalColumn(column),
353 alias: None,
354 });
355 position
356 });
357 columns.insert(column, input_expression(relation, position));
358 }
359 block.subqueries = statement.subqueries().to_vec();
360 let (schema, context_slots) = schema.canonical_projection();
361 let context = context_slots
362 .into_iter()
363 .map(|slot| Expr::InternalColumn(relation.column(slots[&slot])))
364 .collect();
365 CapturedMutationSource {
366 source: capture(query(block, statement.relations_bound(), subject), relation),
367 columns,
368 context,
369 schema,
370 }
371}
372
373fn resolver(
374 context: RuleAnalysisContext<'_>,
375 statement: RuleMutation<'_>,
376 relation: Option<InternalRelationId>,
377 rewrite: Option<&DeferredOuterRewrite>,
378) -> Result<RuleQueryResolver, SQLError> {
379 let definitions =
380 crate::semantics::rules::analysis::rule_returning_columns(context, statement.table())?;
381 let mut resolver = RuleQueryResolver {
382 table: statement.table().to_owned(),
383 columns: Vec::new(),
384 old: BTreeMap::new(),
385 expressions: BTreeMap::new(),
386 };
387 for (position, column) in definitions.iter().enumerate() {
388 let old = relation.map_or_else(
389 || ScalarExpr::qualified_column(statement.target_qualifier(), &column.name),
390 |relation| ScalarExpr::InternalColumn(relation.column(position)),
391 );
392 let old_reference = InternalRelationId::allocate().column(0);
393 resolver
394 .old
395 .insert(column.name.clone(), Expr::InternalColumn(old_reference));
396 resolver.expressions.insert(
397 old_reference,
398 ExpressionPlan {
399 scalar: old.clone(),
400 subqueries: Vec::new(),
401 },
402 );
403 let expression = match statement {
404 RuleMutation::Update(update) => {
405 assignments::update_column_expression(context, update, column, old)
406 }
407 RuleMutation::Delete(_) => Ok(ExpressionPlan {
408 scalar: ScalarExpr::TypedLiteral {
409 value: uqa_core::Value::Null,
410 ty: column.ty.catalog_name(),
411 bound_type: Some(column.ty.clone()),
412 parameter_index: None,
413 collation_oid: column.collation_oid,
414 composite_source: None,
415 },
416 subqueries: Vec::new(),
417 }),
418 };
419 let expression = expression.map(|mut expression| {
420 let metadata = crate::semantics::rules::binding::RuleColumnMetadata {
421 ty: column.ty.clone(),
422 collation_oid: column.collation_oid,
423 };
424 expression.scalar = metadata.bind_input(expression.scalar);
425 if let Some(rewrite) = rewrite {
426 rewrite.bind_expression(&mut expression);
427 }
428 let reference = InternalRelationId::allocate().column(0);
429 resolver.expressions.insert(reference, expression);
430 Expr::InternalColumn(reference)
431 });
432 resolver.columns.push((column.name.clone(), expression));
433 }
434 Ok(resolver)
435}
436
437fn input_expression(relation: InternalRelationId, position: usize) -> ExpressionPlan {
438 ExpressionPlan {
439 scalar: ScalarExpr::InternalColumn(relation.column(position)),
440 subqueries: Vec::new(),
441 }
442}
443
444fn bind_positions(
445 expression: &mut ExpressionPlan,
446 target: InternalRelationId,
447 source: InternalRelationId,
448 target_width: usize,
449) {
450 crate::plan::rewrite_scalar_expression(&mut expression.scalar, &mut |node| {
451 if let ScalarExpr::Position(position) = node {
452 *node = ScalarExpr::InternalColumn(if *position < target_width {
453 target.column(*position)
454 } else {
455 source.column(*position - target_width)
456 });
457 }
458 });
459}
460
461fn query(
462 block: crate::plan::QueryBlockPlan,
463 relations_bound: bool,
464 subject: &RoleReference,
465) -> QueryPlan {
466 QueryPlan {
467 analyzed_output: None,
468 analyzed_source: None,
469 analyzed_grouping: None,
470 relation_privilege_subject: Some(subject.clone()),
471 relations_bound,
472 ctes: Vec::new(),
473 root: RelationalPlan::QueryBlock(Box::new(block)),
474 }
475}
476
477fn capture(query: QueryPlan, relation: InternalRelationId) -> SourcePlan {
478 SourcePlan::Subquery {
479 captured_output: Some(relation),
480 lateral: false,
481 body: Box::new(query),
482 alias: None,
483 column_aliases: Vec::new(),
484 }
485}
486
487fn input_rewrite(
488 statement: RuleMutation<'_>,
489 definitions: &[crate::ast::ColumnDef],
490 source_schema: Option<&RowSchema>,
491 relation: InternalRelationId,
492 source_relation: InternalRelationId,
493 target_schema: &RowSchema,
494) -> DeferredOuterRewrite {
495 let mut names = BTreeMap::new();
496 names.insert(
497 ColumnIdentity::unqualified(statement.target_qualifier()),
498 input_expression(relation, definitions.len()),
499 );
500 for (position, column) in definitions.iter().enumerate() {
501 let expression = input_expression(relation, position);
502 names.insert(
503 ColumnIdentity::qualified(statement.target_qualifier(), &column.name),
504 expression.clone(),
505 );
506 names.insert(ColumnIdentity::unqualified(&column.name), expression);
507 }
508 capture_virtual_names(&mut names, target_schema, relation, definitions.len() + 1);
509 if let Some(schema) = source_schema {
510 for (position, qualifier) in source_whole_rows(schema).enumerate() {
511 names
512 .entry(ColumnIdentity::unqualified(&qualifier))
513 .or_insert_with(|| input_expression(source_relation, schema.len() + position));
514 }
515 for (position, identity) in schema.identities().iter().enumerate() {
516 names.insert(
517 identity.clone(),
518 input_expression(source_relation, position),
519 );
520 if schema.unqualified_position(identity.column()) == Some(position)
521 && !definitions
522 .iter()
523 .any(|column| column.name == identity.column())
524 {
525 names.insert(
526 ColumnIdentity::unqualified(identity.column()),
527 input_expression(source_relation, position),
528 );
529 }
530 }
531 capture_virtual_names(
532 &mut names,
533 schema,
534 source_relation,
535 schema.len() + source_whole_rows(schema).count(),
536 );
537 }
538 DeferredOuterRewrite::from_inputs(names)
539}
540
541fn target_source(
542 statement: RuleMutation<'_>,
543 definitions: &[crate::ast::ColumnDef],
544 schema: &RowSchema,
545 relation: InternalRelationId,
546 rule_subject: &RoleReference,
547) -> SourcePlan {
548 let mut block = projection_block(
549 definitions
550 .iter()
551 .map(|column| ProjectionPlan {
552 expr: ScalarExpr::qualified_column(statement.target_qualifier(), &column.name),
553 alias: Some(column.name.clone()),
554 })
555 .collect(),
556 );
557 block.from = Some(statement.target_source());
558 block.projections.push(ProjectionPlan {
559 expr: ScalarExpr::Column(statement.target_qualifier().into()),
560 alias: None,
561 });
562 block.projections.extend(virtual_projections(schema));
563 capture(
564 query(block, statement.relations_bound(), rule_subject),
565 relation,
566 )
567}
568
569fn virtual_projections(schema: &RowSchema) -> impl Iterator<Item = ProjectionPlan> + '_ {
570 schema
571 .typed_virtual_identities()
572 .filter_map(|(identity, _)| {
573 identity.qualifier().map(|qualifier| ProjectionPlan {
574 expr: ScalarExpr::qualified_column(qualifier, identity.column()),
575 alias: None,
576 })
577 })
578}
579
580fn capture_virtual_names(
581 names: &mut BTreeMap<ColumnIdentity, ExpressionPlan>,
582 schema: &RowSchema,
583 relation: InternalRelationId,
584 offset: usize,
585) {
586 for (position, (identity, _)) in schema
587 .typed_virtual_identities()
588 .filter(|(identity, _)| identity.qualifier().is_some())
589 .enumerate()
590 {
591 let expression = input_expression(relation, offset + position);
592 names.insert(identity.clone(), expression.clone());
593 names
594 .entry(ColumnIdentity::unqualified(identity.column()))
595 .or_insert(expression);
596 }
597}
598
599fn source_whole_rows(schema: &RowSchema) -> impl Iterator<Item = String> {
600 schema
601 .identities()
602 .iter()
603 .filter_map(|identity| identity.qualifier().map(str::to_owned))
604 .collect::<std::collections::BTreeSet<_>>()
605 .into_iter()
606}