uqa_sql/semantics/rules/
analysis.rs1use super::{action_binding::RuleSourceCatalog, RuleCatalog};
9use crate::semantics::returning::ReturningCatalog;
10use crate::{ast::RuleEvent, SQLError};
11use std::collections::BTreeSet;
12#[derive(Clone, Copy)]
13pub struct RuleAnalysisContext<'a> {
14 pub rules: &'a dyn RuleCatalog,
15 pub sources: &'a dyn RuleSourceCatalog,
16 pub returning: &'a dyn ReturningCatalog,
17 pub domains: &'a dyn crate::catalog::domain::DomainCatalog,
18 pub composites: Option<&'a dyn crate::expr::composites::CompositeTypeCatalog>,
19}
20pub fn rule_condition_plan_references_row(rule: &crate::catalog::events::StoredRule) -> bool {
21 rule.bound_condition_plan().is_some_and(|(plan, binding)| {
22 super::action_binding::rule_condition_plan_references_whole_row(plan)
23 || !super::action_binding::rule_condition_plan_row_columns(plan, binding).is_empty()
24 })
25}
26
27pub fn relation_suppresses_original_query(
28 context: RuleAnalysisContext<'_>,
29 table: &str,
30 event: RuleEvent,
31) -> Result<bool, SQLError> {
32 for rule in context.rules.capture_rules(table, event)?.iter() {
33 let rule = rule?;
34 if rule.definition.instead && rule.definition.condition.is_none() {
35 return Ok(true);
36 }
37 }
38 Ok(false)
39}
40
41pub fn relation_rules_reference_row(
42 context: RuleAnalysisContext<'_>,
43 table: &str,
44 event: RuleEvent,
45) -> Result<bool, SQLError> {
46 for rule in context.rules.capture_rules(table, event)?.iter() {
47 let rule = rule?;
48 let condition_references_row = if rule.bound_condition_plan().is_some() {
49 rule_condition_plan_references_row(rule)
50 } else {
51 rule.definition
52 .condition
53 .as_ref()
54 .is_some_and(super::action_binding::rule_expr_references_row)
55 };
56 if condition_references_row {
57 return Ok(true);
58 }
59 for action in &rule.definition.actions {
60 let target_columns =
61 super::action_binding::rule_action_target_columns(context.sources, action)?;
62 if super::action_binding::rule_statement_references_row(
63 context.sources,
64 action,
65 &target_columns,
66 )? {
67 return Ok(true);
68 }
69 }
70 }
71 Ok(false)
72}
73
74pub fn relation_rules_require_event_rows(
75 context: RuleAnalysisContext<'_>,
76 table: &str,
77 event: RuleEvent,
78) -> Result<bool, SQLError> {
79 for rule in context.rules.capture_rules(table, event)?.iter() {
80 let rule = rule?;
81 if rule.definition.condition.is_some() || !rule.definition.actions.is_empty() {
82 return Ok(true);
83 }
84 }
85 Ok(false)
86}
87
88pub fn surviving_view_rules_reference_row(
89 context: RuleAnalysisContext<'_>,
90 relations: &[String],
91 event: RuleEvent,
92) -> Result<bool, SQLError> {
93 let mut references_row = false;
94 for relation in relations {
95 references_row |= relation_rules_reference_row(context, relation, event)?;
96 if relation_suppresses_original_query(context, relation, event)? {
97 break;
98 }
99 }
100 Ok(references_row)
101}
102
103pub fn surviving_view_rules_require_event_rows(
104 context: RuleAnalysisContext<'_>,
105 relations: &[String],
106 event: RuleEvent,
107) -> Result<bool, SQLError> {
108 let mut requires_rows = false;
109 for relation in relations {
110 requires_rows |= relation_rules_require_event_rows(context, relation, event)?;
111 if relation_suppresses_original_query(context, relation, event)? {
112 break;
113 }
114 }
115 Ok(requires_rows)
116}
117
118pub fn relation_condition_row_columns(
119 context: RuleAnalysisContext<'_>,
120 table: &str,
121 event: RuleEvent,
122) -> Result<BTreeSet<String>, SQLError> {
123 let mut columns = BTreeSet::new();
124 for rule in context.rules.capture_rules(table, event)?.iter() {
125 let rule = rule?;
126 if let Some((plan, binding)) = rule.bound_condition_plan() {
127 columns.extend(super::action_binding::rule_condition_plan_row_columns(
128 plan, binding,
129 ));
130 continue;
131 }
132 if let Some(condition) = rule.definition.condition.as_ref() {
133 columns.extend(super::action_binding::rule_expr_row_columns(condition));
134 }
135 }
136 Ok(columns)
137}
138
139pub fn relation_rule_row_columns(
140 context: RuleAnalysisContext<'_>,
141 table: &str,
142 event: RuleEvent,
143) -> Result<Option<BTreeSet<String>>, SQLError> {
144 Ok(relation_rule_row_columns_with_control(
145 context,
146 table,
147 event,
148 &uqa_core::memory::ProductionControl::uncontrolled(),
149 )?
150 .map(|columns| {
151 columns
152 .into_uncontrolled()
153 .expect("ordinary rule row columns")
154 .into_iter()
155 .collect()
156 }))
157}
158
159pub use super::action_binding::relation_rule_row_columns_with_control;
160
161pub fn rule_returning_columns(
162 context: RuleAnalysisContext<'_>,
163 table: &str,
164) -> Result<Vec<crate::ast::ColumnDef>, SQLError> {
165 let columns = context
166 .returning
167 .try_describe_table_row_type(table)
168 .map_err(|error| SQLError::Internal(format!("read rule RETURNING row type: {error}")))?;
169 if let Some(columns) = columns {
170 return Ok(columns);
171 }
172 context.sources.rule_relation_definitions(table)
173}
174
175pub fn rule_returning_columns_with_control(
176 context: RuleAnalysisContext<'_>,
177 table: &str,
178 control: &uqa_core::memory::ProductionControl<'_>,
179) -> Result<uqa_core::memory::Produced<Vec<crate::ast::ColumnDef>>, SQLError> {
180 control.check()?;
181 let mut output = uqa_core::memory::ProductionVec::new(*control);
182 let found = context
183 .returning
184 .with_table_row_type_with_control(table, control, &mut |columns| {
185 for column in columns {
186 output.push_produced(crate::plan::copy::copy_syntax_with_control(
187 column, control,
188 )?)?;
189 }
190 Ok(())
191 })
192 .map_err(|error| match error {
193 SQLError::Internal(message) => {
194 match control.format(format_args!("read rule RETURNING row type: {message}")) {
195 Ok(message) => SQLError::Internal(message.into_parts().0),
196 Err(error) => error.into(),
197 }
198 }
199 other => other,
200 })?;
201 if found {
202 return Ok(output.finish()?);
203 }
204 context
205 .sources
206 .rule_relation_definitions_with_control(table, control)
207}