1use crate::{
10 ast::{
11 ColumnType, CreateTrigger, Expr, FromClause, OnConflictAction, RuleEvent, SelectStmt,
12 Statement, TableHierarchy, TriggerEvent, TriggerTiming, TriggerTransitionRelation,
13 },
14 plpgsql::{ResolvedVariable, VariableResolver},
15 semantics::rules::action_binding::{
16 first_rule_row_reference_in_expr, first_rule_row_reference_in_select, RuleSourceCatalog,
17 },
18 SQLError,
19};
20use uqa_core::Value;
21
22pub struct TriggerConditionTypeResolver<'a> {
23 pub columns: &'a [crate::ast::ColumnDef],
24}
25
26pub struct RuleRowTypeResolver<'a> {
27 pub columns: &'a [crate::ast::ColumnDef],
28 pub event: RuleEvent,
29 condition: bool,
30 referenced_rows: (bool, bool),
31}
32
33pub struct RuleConditionNameResolver<'a> {
34 pub columns: &'a [crate::ast::ColumnDef],
35 pub event: RuleEvent,
36}
37
38impl VariableResolver for RuleConditionNameResolver<'_> {
39 fn resolve_name(&mut self, _name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
40 Ok(None)
41 }
42
43 fn resolve_qualified(
44 &mut self,
45 _qualifier: &str,
46 _column: &str,
47 ) -> Result<Option<ResolvedVariable>, SQLError> {
48 Ok(None)
49 }
50
51 fn resolve_param(&mut self, _index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
52 Ok(None)
53 }
54
55 fn rewrite_name(&mut self, name: &str) -> Result<Option<Expr>, SQLError> {
56 if !self.columns.iter().any(|column| column.name == name) {
57 if name.eq_ignore_ascii_case("old") || name.eq_ignore_ascii_case("new") {
58 return Ok(None);
59 }
60 return Err(SQLError::UnknownColumn(name.to_string()));
61 }
62 let qualifier = match self.event {
63 RuleEvent::Insert => "new",
64 RuleEvent::Delete => "old",
65 RuleEvent::Update => return Err(SQLError::AmbiguousColumn(name.to_string())),
66 RuleEvent::Select => return Ok(None),
67 };
68 Ok(Some(Expr::qualified_column(qualifier, name)))
69 }
70}
71
72pub(crate) fn unavailable_rule_row(event: RuleEvent, qualifier: &str) -> bool {
73 match qualifier {
74 "old" => matches!(event, RuleEvent::Insert | RuleEvent::Select),
75 "new" => matches!(event, RuleEvent::Delete | RuleEvent::Select),
76 _ => false,
77 }
78}
79
80impl<'a> RuleRowTypeResolver<'a> {
81 pub fn for_condition(columns: &'a [crate::ast::ColumnDef], event: RuleEvent) -> Self {
82 Self {
83 columns,
84 event,
85 condition: true,
86 referenced_rows: (false, false),
87 }
88 }
89
90 pub fn for_action(columns: &'a [crate::ast::ColumnDef], event: RuleEvent) -> Self {
91 Self {
92 condition: false,
93 ..Self::for_condition(columns, event)
94 }
95 }
96
97 pub fn validate_event_references(&self) -> Result<(), SQLError> {
98 let (old, new) = self.referenced_rows;
99 for (referenced, qualifier) in [(old, "old"), (new, "new")] {
100 if referenced && unavailable_rule_row(self.event, qualifier) {
101 return Err(SQLError::Routine {
102 sqlstate: "42P17".into(),
103 message: format!(
104 "ON {} rule cannot use {}",
105 rule_event_name(self.event),
106 qualifier.to_ascii_uppercase()
107 ),
108 });
109 }
110 }
111 Ok(())
112 }
113
114 fn validate_row_qualifier(&mut self, qualifier: &str) -> Result<bool, SQLError> {
115 if !matches!(qualifier, "old" | "new") {
116 return Ok(false);
117 }
118 if self.condition && unavailable_rule_row(self.event, qualifier) {
119 return Err(
120 crate::semantics::rules::action_binding::invalid_rule_relation_reference(qualifier),
121 );
122 }
123 self.referenced_rows.0 |= qualifier == "old";
124 self.referenced_rows.1 |= qualifier == "new";
125 Ok(true)
126 }
127
128 fn record_definition(
129 &mut self,
130 qualifier: &str,
131 column: &str,
132 ) -> Result<Option<&crate::ast::ColumnDef>, SQLError> {
133 if !self.validate_row_qualifier(qualifier)? {
134 return Ok(None);
135 }
136 let definition = self
137 .columns
138 .iter()
139 .find(|definition| definition.name == column)
140 .ok_or_else(|| SQLError::unknown_qualified_column(qualifier, column))?;
141 Ok(Some(definition))
142 }
143}
144
145impl VariableResolver for RuleRowTypeResolver<'_> {
146 fn resolve_name(&mut self, name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
147 if self.condition && unavailable_rule_row(self.event, name) {
148 return Err(SQLError::UnknownColumn(name.into()));
149 }
150 Ok(self
151 .validate_row_qualifier(name)?
152 .then(|| ResolvedVariable::untyped(Value::Record(Vec::new().into()))))
153 }
154
155 fn resolve_qualified(
156 &mut self,
157 qualifier: &str,
158 column: &str,
159 ) -> Result<Option<ResolvedVariable>, SQLError> {
160 Ok(self
161 .record_definition(qualifier, column)?
162 .map(|definition| ResolvedVariable {
163 collation_oid: definition.collation_oid,
164 value: Value::Null,
165 declared_type: Some(definition.ty.catalog_name()),
166 }))
167 }
168
169 fn resolve_param(&mut self, _index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
170 Ok(None)
171 }
172
173 fn rewrite_qualified_whole_row(&mut self, qualifier: &str) -> Result<Option<Expr>, SQLError> {
174 Ok(self
175 .validate_row_qualifier(qualifier)?
176 .then(|| Expr::Literal(Value::Record(Vec::new().into()))))
177 }
178}
179
180const fn rule_event_name(event: RuleEvent) -> &'static str {
181 match event {
182 RuleEvent::Select => "SELECT",
183 RuleEvent::Insert => "INSERT",
184 RuleEvent::Update => "UPDATE",
185 RuleEvent::Delete => "DELETE",
186 }
187}
188
189impl VariableResolver for TriggerConditionTypeResolver<'_> {
190 fn resolve_name(&mut self, _name: &str) -> Result<Option<ResolvedVariable>, SQLError> {
191 Ok(None)
192 }
193
194 fn resolve_qualified(
195 &mut self,
196 qualifier: &str,
197 column: &str,
198 ) -> Result<Option<ResolvedVariable>, SQLError> {
199 if !qualifier.eq_ignore_ascii_case("old") && !qualifier.eq_ignore_ascii_case("new") {
200 return Ok(None);
201 }
202 Ok(self
203 .columns
204 .iter()
205 .find(|definition| definition.name == column)
206 .map(|definition| ResolvedVariable {
207 collation_oid: definition.collation_oid,
208 value: Value::Null,
209 declared_type: Some(definition.ty.catalog_name()),
210 }))
211 }
212
213 fn resolve_param(&mut self, _index: usize) -> Result<Option<ResolvedVariable>, SQLError> {
214 Ok(None)
215 }
216}
217
218pub fn is_boolean_type(ty: &ColumnType) -> bool {
219 match ty {
220 ColumnType::Boolean => true,
221 ColumnType::Domain { base, .. } => is_boolean_type(base),
222 _ => false,
223 }
224}
225
226pub fn rule_action_has_returning(action: &Statement) -> bool {
227 match action {
228 Statement::Insert(statement) => !statement.returning.is_empty(),
229 Statement::Update(statement) => !statement.returning.is_empty(),
230 Statement::Delete(statement) => !statement.returning.is_empty(),
231 _ => false,
232 }
233}
234
235fn same_rule_returning_type_with_different_modifier(
236 actual: &ColumnType,
237 expected: &ColumnType,
238) -> bool {
239 match (actual, expected) {
240 (ColumnType::Varchar(_), ColumnType::Varchar(_))
241 | (ColumnType::Character(_), ColumnType::Character(_))
242 | (ColumnType::Numeric { .. }, ColumnType::Numeric { .. })
243 | (ColumnType::Vector(_), ColumnType::Vector(_))
244 | (ColumnType::Tensor(_), ColumnType::Tensor(_)) => true,
245 (ColumnType::Array(actual), ColumnType::Array(expected)) => {
246 same_rule_returning_type_with_different_modifier(actual, expected)
247 }
248 _ => false,
249 }
250}
251
252pub fn validate_rule_returning_shape(
253 schema: &crate::RowSchema,
254 columns: &[(String, ColumnType)],
255) -> Result<(), SQLError> {
256 if schema.len() < columns.len() {
257 return Err(SQLError::Routine {
258 sqlstate: "42P17".into(),
259 message: "RETURNING list has too few entries".into(),
260 });
261 }
262 if schema.len() > columns.len() {
263 return Err(SQLError::Routine {
264 sqlstate: "42P17".into(),
265 message: "RETURNING list has too many entries".into(),
266 });
267 }
268 for (position, (column, expected)) in columns.iter().enumerate() {
269 let Some(actual) = schema.column_type(position) else {
270 continue;
273 };
274 if actual == expected {
275 continue;
276 }
277 let difference = if same_rule_returning_type_with_different_modifier(actual, expected) {
278 "size"
279 } else {
280 "type"
281 };
282 return Err(SQLError::Diagnostic {
283 sqlstate: "42P17".into(),
284 message: format!(
285 "RETURNING list's entry {} has different {difference} from column \"{column}\"",
286 position + 1
287 ),
288 detail: Some(format!(
289 "RETURNING list entry has type {}, but column has type {}.",
290 actual.sql_name(),
291 expected.sql_name()
292 )),
293 hint: None,
294 });
295 }
296 Ok(())
297}
298
299pub fn validate_trigger_condition_names(
301 columns: &[crate::ast::ColumnDef],
302 condition: &Expr,
303) -> Result<(), SQLError> {
304 if condition.any_node(&|node| {
305 matches!(
306 node,
307 Expr::ScalarSubquery(_) | Expr::Exists { .. } | Expr::InSubquery { .. }
308 )
309 }) {
310 return Err(SQLError::Routine {
311 sqlstate: "0A000".into(),
312 message: "cannot use subquery in trigger WHEN condition".into(),
313 });
314 }
315 if condition.any_node(&|node| matches!(node, Expr::Column(_))) {
316 return Err(SQLError::Routine {
317 sqlstate: "42P01".into(),
318 message: "trigger WHEN condition must qualify row columns with OLD or NEW".into(),
319 });
320 }
321 let invalid_qualified_reference = std::cell::RefCell::new(None);
322 let _ = condition.any_node(&|node| {
323 let Expr::QualifiedColumn { qualifier, column } = node else {
324 return false;
325 };
326 if !qualifier.eq_ignore_ascii_case("old") && !qualifier.eq_ignore_ascii_case("new") {
327 *invalid_qualified_reference.borrow_mut() = Some(format!("{qualifier}.{column}"));
328 return true;
329 }
330 if !columns.iter().any(|definition| definition.name == *column) {
331 *invalid_qualified_reference.borrow_mut() = Some(column.clone());
332 return true;
333 }
334 false
335 });
336 if let Some(reference) = invalid_qualified_reference.into_inner() {
337 return Err(SQLError::UnknownColumn(reference));
338 }
339 Ok(())
340}
341
342pub fn validate_trigger_condition_rows(
344 definition: &CreateTrigger,
345 columns: &[crate::ast::ColumnDef],
346 condition: &Expr,
347) -> Result<(), SQLError> {
348 let references_old = condition.any_node(&|node| {
349 matches!(node, Expr::QualifiedColumn { qualifier, .. } if qualifier.eq_ignore_ascii_case("old"))
350 });
351 let references_new = condition.any_node(&|node| {
352 matches!(node, Expr::QualifiedColumn { qualifier, .. } if qualifier.eq_ignore_ascii_case("new"))
353 });
354 if !definition.row && (references_old || references_new) {
355 return Err(SQLError::Routine {
356 sqlstate: "42P17".into(),
357 message: "statement trigger's WHEN condition cannot reference column values".into(),
358 });
359 }
360 if references_old && definition.events.contains(&TriggerEvent::Insert) {
361 return Err(SQLError::Routine {
362 sqlstate: "42P17".into(),
363 message: "INSERT trigger's WHEN condition cannot reference OLD values".into(),
364 });
365 }
366 if references_new && definition.events.contains(&TriggerEvent::Delete) {
367 return Err(SQLError::Routine {
368 sqlstate: "42P17".into(),
369 message: "DELETE trigger's WHEN condition cannot reference NEW values".into(),
370 });
371 }
372 if definition.timing == TriggerTiming::Before && references_new {
373 let generated = columns
374 .iter()
375 .filter(|column| column.generated.is_some())
376 .map(|column| column.name.as_str())
377 .collect::<std::collections::BTreeSet<_>>();
378 if condition.any_node(&|node| {
379 matches!(
380 node,
381 Expr::QualifiedColumn { qualifier, column }
382 if qualifier.eq_ignore_ascii_case("new")
383 && generated.contains(column.as_str())
384 )
385 }) {
386 return Err(SQLError::Routine {
387 sqlstate: "42P17".into(),
388 message: "BEFORE trigger's WHEN condition cannot reference NEW generated columns"
389 .into(),
390 });
391 }
392 }
393 Ok(())
394}
395
396pub fn first_invalid_rule_condition_qualifier(condition: &Expr) -> Option<String> {
397 let invalid = std::cell::RefCell::new(None);
398 let _ = condition.any_node(&|node| {
399 let Expr::QualifiedColumn { qualifier, .. } = node else {
400 return false;
401 };
402 if qualifier.eq_ignore_ascii_case("old") || qualifier.eq_ignore_ascii_case("new") {
403 return false;
404 }
405 *invalid.borrow_mut() = Some(qualifier.clone());
406 true
407 });
408 invalid.into_inner()
409}
410
411fn invalid_rule_cte_reference(qualifier: &str) -> SQLError {
412 SQLError::Routine {
413 sqlstate: "0A000".into(),
414 message: format!(
415 "cannot refer to {} within WITH query",
416 qualifier.to_ascii_uppercase()
417 ),
418 }
419}
420
421fn invalid_rule_set_operation_reference() -> SQLError {
422 SQLError::Routine {
423 sqlstate: "42P10".into(),
424 message:
425 "UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"
426 .into(),
427 }
428}
429
430pub(super) use crate::semantics::rules::action_binding::invalid_rule_relation_reference;
431
432fn ambiguous_rule_pseudo_relation(qualifier: &str) -> SQLError {
433 SQLError::Routine {
434 sqlstate: "42P09".into(),
435 message: format!("table reference \"{qualifier}\" is ambiguous"),
436 }
437}
438
439fn duplicate_rule_pseudo_relation(qualifier: &str) -> SQLError {
440 SQLError::Routine {
441 sqlstate: "42712".into(),
442 message: format!("table name \"{qualifier}\" specified more than once"),
443 }
444}
445
446fn rule_pseudo_relation_name(name: &str) -> Option<String> {
447 (name.eq_ignore_ascii_case("old") || name.eq_ignore_ascii_case("new"))
448 .then(|| name.to_ascii_lowercase())
449}
450
451fn first_rule_pseudo_relation_in_from(from: &FromClause) -> Option<String> {
452 match from {
453 FromClause::Table {
454 name,
455 qualifier,
456 alias,
457 ..
458 } => alias
459 .as_deref()
460 .and_then(rule_pseudo_relation_name)
461 .or_else(|| rule_pseudo_relation_name(qualifier))
462 .or_else(|| rule_pseudo_relation_name(name))
463 .or_else(|| {
464 name.rsplit_once('.')
465 .and_then(|(_, local)| rule_pseudo_relation_name(local.trim_matches('"')))
466 }),
467 FromClause::Join {
468 left, right, alias, ..
469 } => alias
470 .as_deref()
471 .and_then(rule_pseudo_relation_name)
472 .or_else(|| first_rule_pseudo_relation_in_from(left))
473 .or_else(|| first_rule_pseudo_relation_in_from(right)),
474 FromClause::Values { alias, .. } | FromClause::Subquery { alias, .. } => {
475 alias.as_deref().and_then(rule_pseudo_relation_name)
476 }
477 FromClause::Function {
478 output_name, alias, ..
479 } => rule_pseudo_relation_name(alias.as_deref().unwrap_or(output_name)),
480 FromClause::FunctionGroup {
481 functions, alias, ..
482 } => alias
483 .as_deref()
484 .and_then(rule_pseudo_relation_name)
485 .or_else(|| {
486 functions
487 .iter()
488 .find_map(|function| rule_pseudo_relation_name(&function.output_name))
489 }),
490 }
491}
492
493fn validate_rule_action_select_namespace(select: &SelectStmt) -> Result<(), SQLError> {
494 let duplicate = select
495 .with
496 .iter()
497 .find_map(|cte| rule_pseudo_relation_name(&cte.name))
498 .or_else(|| {
499 select
500 .from
501 .as_ref()
502 .and_then(first_rule_pseudo_relation_in_from)
503 });
504 if let Some(qualifier) = duplicate {
505 return Err(duplicate_rule_pseudo_relation(&qualifier));
506 }
507 Ok(())
508}
509
510fn validate_rule_action_namespace(
511 catalog: &dyn RuleSourceCatalog,
512 action: &Statement,
513) -> Result<(), SQLError> {
514 let (ctes, source) = match action {
515 Statement::Select(select) => return validate_rule_action_select_namespace(select),
516 Statement::Insert(insert) => (insert.with.as_slice(), insert.select_source.as_deref()),
517 Statement::Update(update) => {
518 if let Some(qualifier) = update
519 .from
520 .as_ref()
521 .and_then(first_rule_pseudo_relation_in_from)
522 {
523 return Err(duplicate_rule_pseudo_relation(&qualifier));
524 }
525 if let Some(qualifier) = rule_pseudo_relation_name(&update.target_qualifier) {
526 if crate::semantics::rules::action_binding::action_target_qualifier_referenced(
527 catalog, action, &qualifier,
528 ) {
529 return Err(ambiguous_rule_pseudo_relation(&qualifier));
530 }
531 }
532 (update.with.as_slice(), None)
533 }
534 Statement::Delete(delete) => {
535 if let Some(qualifier) = delete
536 .using
537 .as_ref()
538 .and_then(first_rule_pseudo_relation_in_from)
539 {
540 return Err(duplicate_rule_pseudo_relation(&qualifier));
541 }
542 if let Some(qualifier) = rule_pseudo_relation_name(&delete.target_qualifier) {
543 if crate::semantics::rules::action_binding::action_target_qualifier_referenced(
544 catalog, action, &qualifier,
545 ) {
546 return Err(ambiguous_rule_pseudo_relation(&qualifier));
547 }
548 }
549 (delete.with.as_slice(), None)
550 }
551 _ => return Ok(()),
552 };
553 if let Some(qualifier) = ctes
554 .iter()
555 .find_map(|cte| rule_pseudo_relation_name(&cte.name))
556 {
557 return Err(duplicate_rule_pseudo_relation(&qualifier));
558 }
559 if let Some(select) = source {
560 validate_rule_action_select_namespace(select)?;
561 }
562 Ok(())
563}
564
565fn validate_rule_ctes(
566 catalog: &dyn RuleSourceCatalog,
567 ctes: &[crate::ast::CTE],
568) -> Result<(), SQLError> {
569 for cte in ctes {
570 let statement = cte.body.clone().into_statement();
571 if let Some(qualifier) =
572 crate::semantics::rules::action_binding::first_rule_row_reference_in_statement(
573 catalog, &statement,
574 )?
575 {
576 return Err(invalid_rule_cte_reference(&qualifier));
577 }
578 validate_rule_action_reference_scopes(catalog, &statement)?;
579 }
580 Ok(())
581}
582
583fn validate_rule_select_scopes(
584 catalog: &dyn RuleSourceCatalog,
585 select: &SelectStmt,
586) -> Result<(), SQLError> {
587 validate_rule_ctes(catalog, &select.with)?;
588 if let Some(set_op) = &select.set_op {
589 let member_references_rule_row = set_op
590 .left
591 .as_deref()
592 .and_then(|left| first_rule_row_reference_in_select(catalog, left))
593 .or_else(|| first_rule_row_reference_in_select(catalog, &set_op.right));
594 if member_references_rule_row.is_some() {
595 return Err(invalid_rule_set_operation_reference());
596 }
597 if let Some(left) = set_op.left.as_deref() {
598 validate_rule_select_scopes(catalog, left)?;
599 }
600 validate_rule_select_scopes(catalog, &set_op.right)?;
601 for order in &set_op.combined_order_by {
602 validate_rule_expr_scopes(catalog, &order.expr)?;
603 }
604 if let Some(limit) = &set_op.combined_limit {
605 validate_rule_expr_scopes(catalog, limit)?;
606 }
607 if let Some(offset) = &set_op.combined_offset {
608 validate_rule_expr_scopes(catalog, offset)?;
609 }
610 }
611 for projection in &select.projections {
612 validate_rule_expr_scopes(catalog, &projection.expr)?;
613 }
614 for expr in select.values.iter().flatten() {
615 validate_rule_expr_scopes(catalog, expr)?;
616 }
617 if let Some(from) = &select.from {
618 validate_rule_from_scopes(catalog, from)?;
619 }
620 for expr in select
621 .r#where
622 .iter()
623 .chain(select.group_by.iter())
624 .chain(select.grouping_sets.iter().flatten())
625 .chain(select.having.iter())
626 .chain(select.order_by.iter().map(|order| &order.expr))
627 .chain(select.limit.iter())
628 .chain(select.offset.iter())
629 .chain(select.distinct_on.iter())
630 {
631 validate_rule_expr_scopes(catalog, expr)?;
632 }
633 Ok(())
634}
635
636fn validate_rule_from_scopes(
637 catalog: &dyn RuleSourceCatalog,
638 from: &FromClause,
639) -> Result<(), SQLError> {
640 match from {
641 FromClause::Table { .. } => {}
642 FromClause::Join {
643 left, right, on, ..
644 } => {
645 validate_rule_from_scopes(catalog, left)?;
646 validate_rule_from_scopes(catalog, right)?;
647 if let Some(on) = on {
648 validate_rule_expr_scopes(catalog, on)?;
649 }
650 }
651 FromClause::Values { rows, .. } => {
652 for expr in rows.iter().flatten() {
653 validate_rule_expr_scopes(catalog, expr)?;
654 }
655 }
656 FromClause::Function { args, .. } => {
657 for expr in args {
658 validate_rule_expr_scopes(catalog, expr)?;
659 }
660 }
661 FromClause::FunctionGroup { functions, .. } => {
662 for expr in functions.iter().flat_map(|function| &function.args) {
663 validate_rule_expr_scopes(catalog, expr)?;
664 }
665 }
666 FromClause::Subquery { body, .. } => validate_rule_select_scopes(catalog, body)?,
667 }
668 Ok(())
669}
670
671fn validate_rule_expr_scopes(catalog: &dyn RuleSourceCatalog, expr: &Expr) -> Result<(), SQLError> {
672 match expr {
673 Expr::Func {
674 args,
675 order_by,
676 filter,
677 ..
678 } => {
679 for expr in args {
680 validate_rule_expr_scopes(catalog, expr)?;
681 }
682 for order in order_by {
683 validate_rule_expr_scopes(catalog, &order.expr)?;
684 }
685 if let Some(filter) = filter {
686 validate_rule_expr_scopes(catalog, filter)?;
687 }
688 }
689 Expr::Array(items)
690 | Expr::Row(items)
691 | Expr::CompositeRow { items, .. }
692 | Expr::And(items)
693 | Expr::Or(items) => {
694 for expr in items {
695 validate_rule_expr_scopes(catalog, expr)?;
696 }
697 }
698 Expr::Binary { lhs, rhs, .. } => {
699 validate_rule_expr_scopes(catalog, lhs)?;
700 validate_rule_expr_scopes(catalog, rhs)?;
701 }
702 Expr::UnaryMinus(expr)
703 | Expr::Not(expr)
704 | Expr::IsNull { expr, .. }
705 | Expr::Cast { expr, .. } => validate_rule_expr_scopes(catalog, expr)?,
706 Expr::Between { expr, low, high } => {
707 validate_rule_expr_scopes(catalog, expr)?;
708 validate_rule_expr_scopes(catalog, low)?;
709 validate_rule_expr_scopes(catalog, high)?;
710 }
711 Expr::InList { expr, list, .. } => {
712 validate_rule_expr_scopes(catalog, expr)?;
713 for item in list {
714 validate_rule_expr_scopes(catalog, item)?;
715 }
716 }
717 Expr::WindowCall {
718 args, spec, filter, ..
719 } => {
720 for expr in args
721 .iter()
722 .chain(filter.iter().map(AsRef::as_ref))
723 .chain(spec.partition_by.iter())
724 {
725 validate_rule_expr_scopes(catalog, expr)?;
726 }
727 for order in &spec.order_by {
728 validate_rule_expr_scopes(catalog, &order.expr)?;
729 }
730 }
731 Expr::Case {
732 base,
733 when,
734 else_branch,
735 } => {
736 if let Some(base) = base {
737 validate_rule_expr_scopes(catalog, base)?;
738 }
739 for (condition, result) in when {
740 validate_rule_expr_scopes(catalog, condition)?;
741 validate_rule_expr_scopes(catalog, result)?;
742 }
743 if let Some(else_branch) = else_branch {
744 validate_rule_expr_scopes(catalog, else_branch)?;
745 }
746 }
747 Expr::ScalarSubquery(body) | Expr::Exists { body, .. } => {
748 validate_rule_select_scopes(catalog, body)?;
749 }
750 Expr::InSubquery { expr, body, .. } => {
751 validate_rule_expr_scopes(catalog, expr)?;
752 validate_rule_select_scopes(catalog, body)?;
753 }
754 Expr::Default
755 | Expr::Literal(_)
756 | Expr::TypedLiteral { .. }
757 | Expr::Star
758 | Expr::QualifiedStar(_)
759 | Expr::Column(_)
760 | Expr::QualifiedColumn { .. }
761 | Expr::InternalColumn(_)
762 | Expr::Param(_) => {}
763 }
764 Ok(())
765}
766
767pub fn validate_rule_action_reference_scopes(
768 catalog: &dyn RuleSourceCatalog,
769 action: &Statement,
770) -> Result<(), SQLError> {
771 validate_rule_action_namespace(catalog, action)?;
772 match action {
773 Statement::Select(select) => validate_rule_select_scopes(catalog, select),
774 Statement::Insert(insert) => {
775 validate_rule_ctes(catalog, &insert.with)?;
776 for expr in insert
777 .columns
778 .iter()
779 .flat_map(crate::ast::AssignmentTarget::expressions)
780 .chain(insert.rows.iter().flatten())
781 {
782 validate_rule_expr_scopes(catalog, expr)?;
783 }
784 if let Some(select) = &insert.select_source {
785 validate_rule_select_scopes(catalog, select)?;
786 }
787 if let Some(conflict) = &insert.on_conflict {
788 for expression in &conflict.expressions {
789 validate_rule_expr_scopes(catalog, expression)?;
790 }
791 if let Some(predicate) = conflict.predicate.as_deref() {
792 validate_rule_expr_scopes(catalog, predicate)?;
793 }
794 if let OnConflictAction::Update {
795 assignments,
796 r#where,
797 } = &conflict.action
798 {
799 let reference = assignments
800 .iter()
801 .flat_map(|(target, value)| {
802 target.expressions().chain(std::iter::once(value))
803 })
804 .find_map(|expr| {
805 let mut shadowed = std::collections::BTreeSet::new();
806 shadowed.insert(insert.target_qualifier.to_ascii_lowercase());
807 first_rule_row_reference_in_expr(expr, &shadowed)
808 })
809 .or_else(|| {
810 r#where.as_ref().and_then(|expr| {
811 let mut shadowed = std::collections::BTreeSet::new();
812 shadowed.insert(insert.target_qualifier.to_ascii_lowercase());
813 first_rule_row_reference_in_expr(expr, &shadowed)
814 })
815 });
816 if let Some(qualifier) = reference {
817 return Err(invalid_rule_relation_reference(&qualifier));
818 }
819 for expr in assignments.iter().flat_map(|(target, value)| {
820 target.expressions().chain(std::iter::once(value))
821 }) {
822 validate_rule_expr_scopes(catalog, expr)?;
823 }
824 if let Some(r#where) = r#where {
825 validate_rule_expr_scopes(catalog, r#where)?;
826 }
827 }
828 }
829 for projection in &insert.returning {
830 validate_rule_expr_scopes(catalog, &projection.expr)?;
831 }
832 Ok(())
833 }
834 Statement::Update(update) => {
835 validate_rule_ctes(catalog, &update.with)?;
836 if let Some(from) = &update.from {
837 validate_rule_from_scopes(catalog, from)?;
838 }
839 for expr in update
840 .assignments
841 .iter()
842 .flat_map(|(target, value)| target.expressions().chain(std::iter::once(value)))
843 .chain(update.r#where.iter())
844 .chain(update.returning.iter().map(|projection| &projection.expr))
845 {
846 validate_rule_expr_scopes(catalog, expr)?;
847 }
848 Ok(())
849 }
850 Statement::Delete(delete) => {
851 validate_rule_ctes(catalog, &delete.with)?;
852 if let Some(using) = &delete.using {
853 validate_rule_from_scopes(catalog, using)?;
854 }
855 for expr in delete
856 .r#where
857 .iter()
858 .chain(delete.returning.iter().map(|projection| &projection.expr))
859 {
860 validate_rule_expr_scopes(catalog, expr)?;
861 }
862 Ok(())
863 }
864 _ => Ok(()),
865 }
866}
867
868pub fn validate_trigger_transition_relation(
869 definition: &CreateTrigger,
870 hierarchy: &TableHierarchy,
871 transition: &TriggerTransitionRelation,
872) -> Result<(), SQLError> {
873 if !transition.is_table {
874 return Err(SQLError::Routine {
875 sqlstate: "0A000".into(),
876 message: "ROW variable naming in the REFERENCING clause is not supported".into(),
877 });
878 }
879 if definition.row && !hierarchy.parents.is_empty() {
880 return Err(SQLError::Routine {
881 sqlstate: "0A000".into(),
882 message: if hierarchy.partition_bound.is_some() {
883 "ROW triggers with transition tables are not supported on partitions".into()
884 } else {
885 "ROW triggers with transition tables are not supported on inheritance children"
886 .into()
887 },
888 });
889 }
890 if definition.timing != TriggerTiming::After {
891 return Err(SQLError::Routine {
892 sqlstate: "42P17".into(),
893 message: "transition table name can only be specified for an AFTER trigger".into(),
894 });
895 }
896 if definition.events.contains(&TriggerEvent::Truncate) {
897 return Err(SQLError::Routine {
898 sqlstate: "0A000".into(),
899 message: "TRUNCATE triggers with transition tables are not supported".into(),
900 });
901 }
902 let mutation_events = definition
903 .events
904 .iter()
905 .filter(|event| {
906 matches!(
907 event,
908 TriggerEvent::Insert | TriggerEvent::Update | TriggerEvent::Delete
909 )
910 })
911 .count();
912 if mutation_events != 1 {
913 return Err(SQLError::Routine {
914 sqlstate: "0A000".into(),
915 message: "transition tables cannot be specified for triggers with more than one event"
916 .into(),
917 });
918 }
919 if !definition.update_columns.is_empty() {
920 return Err(SQLError::Routine {
921 sqlstate: "0A000".into(),
922 message: "transition tables cannot be specified for triggers with column lists".into(),
923 });
924 }
925 let valid_event = definition.events.iter().any(|event| {
926 if transition.is_new {
927 matches!(event, TriggerEvent::Insert | TriggerEvent::Update)
928 } else {
929 matches!(event, TriggerEvent::Delete | TriggerEvent::Update)
930 }
931 });
932 if !valid_event {
933 return Err(SQLError::Routine {
934 sqlstate: "42P17".into(),
935 message: format!(
936 "{} TABLE can only be specified for {} trigger",
937 if transition.is_new { "NEW" } else { "OLD" },
938 if transition.is_new {
939 "an INSERT or UPDATE"
940 } else {
941 "a DELETE or UPDATE"
942 }
943 ),
944 });
945 }
946 Ok(())
947}
948
949#[cfg(test)]
950mod tests;