Skip to main content

uqa_sql/semantics/rules/
input_contract.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Validate INSERT rule query shapes before source expressions, CTEs or triggers execute.
8
9use super::{RuleCatalog, RuleEvent, SQLError, Statement};
10use crate::plan::{InsertPlan, RelationalPlan};
11
12enum Pending {
13    Relation(String, bool, bool),
14    Leave,
15}
16
17pub fn validate_insert_rule_query_contract(
18    catalog: &dyn RuleCatalog,
19    table: &str,
20    insert: &InsertPlan,
21    mut original_target: impl FnMut(&str, RuleEvent) -> Result<Option<String>, SQLError>,
22) -> Result<(), SQLError> {
23    let mut pending = vec![Pending::Relation(
24        table.into(),
25        true,
26        conditional_input(insert),
27    )];
28    let mut active = Vec::new();
29    while let Some(next) = pending.pop() {
30        crate::expr::check_statement_cancellation()?;
31        let Pending::Relation(table, bound, conditional) = next else {
32            active.pop();
33            continue;
34        };
35        let table = catalog.resolve_mutation_target(&table, bound)?;
36        let relation = catalog.resolve_rule_relation(&table)?;
37        let table = relation.qualified_name();
38        if active.contains(&table) {
39            return Err(SQLError::Routine {
40                sqlstate: "42P17".into(),
41                message: format!(
42                    "infinite recursion detected in rules for relation \"{}\"",
43                    relation.name
44                ),
45            });
46        }
47        let rules = catalog.rules_for(&table, RuleEvent::Insert)?;
48        active.push(table.clone());
49        pending.push(Pending::Leave);
50        let survives = !rules
51            .iter()
52            .any(|rule| rule.definition.instead && rule.definition.condition.is_none());
53        if survives {
54            if let Some(target) = original_target(&table, RuleEvent::Insert)? {
55                pending.push(Pending::Relation(
56                    target,
57                    true,
58                    conditional || rules.iter().any(|rule| rule.definition.instead),
59                ));
60            }
61        }
62        for rule in rules.into_iter().rev() {
63            let conditional = conditional || rule.definition.condition.is_some();
64            for action in rule.definition.actions.into_iter().rev() {
65                if conditional && super::action_binding::rule_action_has_set_operation(&action) {
66                    return Err(SQLError::Routine {
67                        sqlstate: "0A000".into(),
68                        message:
69                            "conditional UNION/INTERSECT/EXCEPT statements are not implemented"
70                                .into(),
71                    });
72                }
73                if let Statement::Insert(action) = action {
74                    pending.push(Pending::Relation(
75                        action.table,
76                        action.target_relation_bound,
77                        conditional || action.select_source.is_some() || action.rows.len() > 1,
78                    ));
79                }
80            }
81        }
82    }
83    Ok(())
84}
85
86fn conditional_input(insert: &InsertPlan) -> bool {
87    let Some(source) = &insert.source else {
88        return insert.rows.len() > 1;
89    };
90    if !insert
91        .rule_values_input
92        .as_ref()
93        .is_some_and(crate::plan::RuleValuesInput::is_inline)
94    {
95        return true;
96    }
97    match &source.root {
98        RelationalPlan::QueryBlock(block) => {
99            !source.ctes.is_empty() || block.from.is_some() || block.r#where.is_some()
100        }
101        _ => true,
102    }
103}