uqa_sql/semantics/rules/
input_contract.rs1use 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}