uqa_execution/schema/events/
dependents.rs1use 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}