Skip to main content

uqa_execution/schema/events/
dependents.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Event dependency publication through retained registry guards and pending transaction state.
8use super::context::EventLifecycleContext;
9use uqa_core::RelationIdentity;
10use uqa_sql::{
11    ast::{DropRule, DropTrigger},
12    catalog::events::PreparedRuleColumnDrop,
13    SQLError,
14};
15use uqa_storage::{StorageBackendError, StorageBackendResult};
16impl EventLifecycleContext<'_> {
17    pub fn rewrite_event_routine_identity(
18        &self,
19        target: &uqa_sql::ast::FunctionBinding,
20        new_name: &str,
21    ) -> Result<(), SQLError> {
22        let mut next_triggers = self.lookup.registry.read_triggers().clone();
23        let triggers_changed =
24            uqa_sql::catalog::events::definition::rewrites::rewrite_trigger_routine_references(
25                &mut next_triggers,
26                target,
27                new_name,
28            )?;
29        if triggers_changed {
30            self.catalog.publication.persist_triggers(&next_triggers)?;
31            **self.catalog.registry.triggers() = next_triggers;
32        }
33
34        let mut next_rules = self.lookup.registry.read_rules().clone();
35        let rules_changed = self.lookup.analysis.rewrite_rule_routine_references(
36            &mut next_rules,
37            target,
38            new_name,
39        )?;
40        if rules_changed {
41            self.catalog.publication.persist_rules(&next_rules)?;
42            **self.catalog.registry.rules() = next_rules;
43        }
44        if triggers_changed || rules_changed {
45            self.catalog.changes.catalog_registry_changed();
46        }
47        Ok(())
48    }
49
50    pub fn drop_relation_events_inner(
51        &self,
52        relation: &RelationIdentity,
53    ) -> StorageBackendResult<()> {
54        let mut triggers = self.catalog.registry.triggers();
55        let mut rules = self.catalog.registry.rules();
56        let Some(uqa_sql::catalog::events::removal::RemovedRelationEvents {
57            triggers: next_triggers,
58            rules: next_rules,
59            constraints: removed_constraint_identities,
60        }) =
61            uqa_sql::catalog::events::removal::removed_relation_events(&triggers, &rules, relation)
62                .map_err(StorageBackendError::Other)?
63        else {
64            return Ok(());
65        };
66        self.catalog
67            .publication
68            .persist_triggers(&next_triggers)
69            .map_err(|error| StorageBackendError::Other(error.to_string()))?;
70        self.catalog
71            .publication
72            .persist_rules(&next_rules)
73            .map_err(|error| StorageBackendError::Other(error.to_string()))?;
74        **triggers = next_triggers;
75        **rules = next_rules;
76        drop(rules);
77        drop(triggers);
78        for identity in &removed_constraint_identities {
79            self.pending.forget(identity);
80        }
81        self.catalog.changes.catalog_registry_changed();
82        Ok(())
83    }
84
85    pub fn rename_event_column_inner(
86        &self,
87        table: &str,
88        from: &str,
89        to: &str,
90    ) -> StorageBackendResult<()> {
91        let relation =
92            RelationIdentity::from_legacy_name(table).map_err(StorageBackendError::Other)?;
93        let triggers = self.lookup.registry.read_triggers().clone();
94        let rules = self.lookup.registry.read_rules().clone();
95        let Some((next_triggers, next_rules)) = self
96            .lookup
97            .analysis
98            .renamed_event_column(&triggers, &rules, &relation, from, to)
99            .map_err(StorageBackendError::Other)?
100        else {
101            return Ok(());
102        };
103        self.catalog
104            .publication
105            .persist_triggers(&next_triggers)
106            .map_err(|error| StorageBackendError::Other(error.to_string()))?;
107        self.catalog
108            .publication
109            .persist_rules(&next_rules)
110            .map_err(|error| StorageBackendError::Other(error.to_string()))?;
111        **self.catalog.registry.triggers() = next_triggers;
112        **self.catalog.registry.rules() = next_rules;
113        self.catalog.changes.catalog_registry_changed();
114        Ok(())
115    }
116
117    pub fn finish_rule_column_drop(
118        &self,
119        mut prepared: PreparedRuleColumnDrop,
120    ) -> StorageBackendResult<()> {
121        if prepared.rebind.is_empty() {
122            return Ok(());
123        }
124        self.lookup
125            .analysis
126            .rebind_rule_column_drop(&mut prepared)
127            .map_err(StorageBackendError::Other)?;
128        self.catalog
129            .publication
130            .persist_rules(&prepared.rules)
131            .map_err(|error| StorageBackendError::Other(error.to_string()))?;
132        **self.catalog.registry.rules() = prepared.rules;
133        self.catalog.changes.catalog_registry_changed();
134        Ok(())
135    }
136
137    pub fn handle_drop_column_event_dependencies(
138        &self,
139        table: &str,
140        column: &str,
141        cascade: bool,
142    ) -> Result<(), SQLError> {
143        let uqa_sql::catalog::events::definition::dependents::EventColumnDependencies {
144            triggers: dependent_triggers,
145            rules: dependent_rules,
146        } = self.lookup.column_event_dependencies(table, column)?;
147        if dependent_triggers.is_empty() && dependent_rules.is_empty() {
148            return Ok(());
149        }
150        if !cascade {
151            let mut objects = dependent_triggers
152                .iter()
153                .map(|name| format!("trigger {name}"))
154                .collect::<Vec<_>>();
155            objects.extend(
156                dependent_rules
157                    .iter()
158                    .map(|(_, name)| format!("rule {name}")),
159            );
160            return Err(SQLError::Routine {
161                sqlstate: "2BP01".into(),
162                message: format!(
163                    "cannot drop column {column} of table {table} because {} depends on it",
164                    objects.join(", ")
165                ),
166            });
167        }
168        for name in dependent_triggers {
169            self.drop_trigger(&DropTrigger {
170                name: name.clone(),
171                table: table.to_string(),
172                if_exists: false,
173                cascade: true,
174            })?;
175            self.notice(uqa_sql::SQLNotice::notice(format!(
176                "drop cascades to trigger {name} on table {table}"
177            )));
178        }
179        for (event_relation, name) in dependent_rules {
180            let event_table = event_relation.qualified_name();
181            self.drop_rule(&DropRule {
182                name: name.clone(),
183                table: event_table.clone(),
184                if_exists: false,
185                cascade: true,
186            })?;
187            self.notice(uqa_sql::SQLNotice::notice(format!(
188                "drop cascades to rule {name} on table {event_table}"
189            )));
190        }
191        Ok(())
192    }
193}