1use super::{action_binding::RuleSourceCatalog, binding::RuleColumnMetadata, RuleCatalog};
9use crate::semantics::returning::ReturningCatalog;
10use crate::{ast::RuleEvent, SQLError};
11use std::collections::{BTreeMap, 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 Ok(context
33 .rules
34 .rules_for(table, event)?
35 .iter()
36 .any(|rule| rule.definition.instead && rule.definition.condition.is_none()))
37}
38
39pub fn relation_rules_reference_row(
40 context: RuleAnalysisContext<'_>,
41 table: &str,
42 event: RuleEvent,
43) -> Result<bool, SQLError> {
44 for rule in context.rules.rules_for(table, event)? {
45 let condition_references_row = if rule.bound_condition_plan().is_some() {
46 rule_condition_plan_references_row(&rule)
47 } else {
48 rule.definition
49 .condition
50 .as_ref()
51 .is_some_and(super::action_binding::rule_expr_references_row)
52 };
53 if condition_references_row {
54 return Ok(true);
55 }
56 for action in &rule.definition.actions {
57 let target_columns =
58 super::action_binding::rule_action_target_columns(context.sources, action)?;
59 if super::action_binding::rule_statement_references_row(
60 context.sources,
61 action,
62 &target_columns,
63 )? {
64 return Ok(true);
65 }
66 }
67 }
68 Ok(false)
69}
70
71pub fn relation_rules_require_event_rows(
72 context: RuleAnalysisContext<'_>,
73 table: &str,
74 event: RuleEvent,
75) -> Result<bool, SQLError> {
76 Ok(context
77 .rules
78 .rules_for(table, event)?
79 .iter()
80 .any(|rule| rule.definition.condition.is_some() || !rule.definition.actions.is_empty()))
81}
82
83pub fn surviving_view_rules_reference_row(
84 context: RuleAnalysisContext<'_>,
85 relations: &[String],
86 event: RuleEvent,
87) -> Result<bool, SQLError> {
88 let mut references_row = false;
89 for relation in relations {
90 references_row |= relation_rules_reference_row(context, relation, event)?;
91 if relation_suppresses_original_query(context, relation, event)? {
92 break;
93 }
94 }
95 Ok(references_row)
96}
97
98pub fn surviving_view_rules_require_event_rows(
99 context: RuleAnalysisContext<'_>,
100 relations: &[String],
101 event: RuleEvent,
102) -> Result<bool, SQLError> {
103 let mut requires_rows = false;
104 for relation in relations {
105 requires_rows |= relation_rules_require_event_rows(context, relation, event)?;
106 if relation_suppresses_original_query(context, relation, event)? {
107 break;
108 }
109 }
110 Ok(requires_rows)
111}
112
113pub fn relation_condition_row_columns(
114 context: RuleAnalysisContext<'_>,
115 table: &str,
116 event: RuleEvent,
117) -> Result<BTreeSet<String>, SQLError> {
118 let mut columns = BTreeSet::new();
119 for rule in context.rules.rules_for(table, event)? {
120 if let Some((plan, binding)) = rule.bound_condition_plan() {
121 columns.extend(super::action_binding::rule_condition_plan_row_columns(
122 plan, binding,
123 ));
124 continue;
125 }
126 if let Some(condition) = rule.definition.condition.as_ref() {
127 columns.extend(super::action_binding::rule_expr_row_columns(condition));
128 }
129 }
130 Ok(columns)
131}
132
133pub fn relation_rule_row_columns(
134 context: RuleAnalysisContext<'_>,
135 table: &str,
136 event: RuleEvent,
137) -> Result<Option<BTreeSet<String>>, SQLError> {
138 let mut columns = BTreeSet::new();
139 let mut references_row = false;
140 let mut references_whole_row = false;
141 for rule in context.rules.rules_for(table, event)? {
142 if let Some((plan, binding)) = rule.bound_condition_plan() {
143 let plan_references_row = rule_condition_plan_references_row(&rule);
144 references_row |= plan_references_row;
145 references_whole_row |=
146 super::action_binding::rule_condition_plan_references_whole_row(plan);
147 columns.extend(super::action_binding::rule_condition_plan_row_columns(
148 plan, binding,
149 ));
150 } else if let Some(condition) = rule.definition.condition.as_ref() {
151 references_row |= super::action_binding::rule_expr_references_row(condition);
152 references_whole_row |=
153 super::action_binding::rule_expr_references_whole_row(condition);
154 columns.extend(super::action_binding::rule_expr_row_columns(condition));
155 }
156 for action in &rule.definition.actions {
157 let action_columns =
158 super::action_binding::rule_action_target_columns(context.sources, action)?;
159 references_row |= super::action_binding::rule_statement_references_row(
160 context.sources,
161 action,
162 &action_columns,
163 )?;
164 references_whole_row |= super::action_binding::rule_statement_references_whole_row(
165 context.sources,
166 action,
167 &action_columns,
168 )?;
169 columns.extend(super::action_binding::rule_statement_row_columns(
170 context.sources,
171 action,
172 &action_columns,
173 )?);
174 }
175 }
176 if references_whole_row || references_row && columns.is_empty() {
177 Ok(None)
178 } else {
179 Ok(Some(columns))
180 }
181}
182
183pub fn rule_columns(
184 context: RuleAnalysisContext<'_>,
185 table: &str,
186) -> Result<BTreeMap<String, RuleColumnMetadata>, SQLError> {
187 let columns = context
188 .returning
189 .try_describe_table_row_type(table)
190 .map_err(|error| SQLError::Internal(format!("read rule row type: {error}")))?;
191 if let Some(columns) = columns {
192 return Ok(columns
193 .into_iter()
194 .enumerate()
195 .map(|(position, column)| {
196 let uses_document_id = column.primary_key && column.ty.is_integer();
197 (
198 column.name,
199 RuleColumnMetadata {
200 ty: column.ty,
201 collation_oid: column.collation_oid,
202 uses_document_id,
203 position,
204 },
205 )
206 })
207 .collect());
208 }
209 Ok(context
210 .sources
211 .rule_relation_definitions(table)?
212 .into_iter()
213 .enumerate()
214 .map(|(position, column)| {
215 (
216 column.name,
217 RuleColumnMetadata {
218 ty: column.ty,
219 collation_oid: column.collation_oid,
220 uses_document_id: false,
221 position,
222 },
223 )
224 })
225 .collect())
226}
227
228pub fn rule_returning_columns(
229 context: RuleAnalysisContext<'_>,
230 table: &str,
231) -> Result<Vec<crate::ast::ColumnDef>, SQLError> {
232 let columns = context
233 .returning
234 .try_describe_table_row_type(table)
235 .map_err(|error| SQLError::Internal(format!("read rule RETURNING row type: {error}")))?;
236 if let Some(columns) = columns {
237 return Ok(columns);
238 }
239 context.sources.rule_relation_definitions(table)
240}