Skip to main content

uqa_sql/semantics/rules/
analysis.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Stored-rule lineage, column requirements, and event row types.
8use 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}