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, 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}