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