Skip to main content

uqa_sql/catalog/events/
validation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Trigger condition and rule pseudo-relation validation over SQL metadata.
8
9use 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            // PostgreSQL resolves an unknown literal against the event row's
271            // declared type when the rule target list is installed.
272            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
299/// Reject the references `PostgreSQL` reports while it analyzes a trigger WHEN condition: subqueries, unqualified columns and names that are not columns of OLD or NEW.
300pub 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
342/// Reject the OLD and NEW references a trigger cannot supply, which `PostgreSQL` checks after it has analyzed the whole WHEN condition.
343pub 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;