1use super::context::EventLifecycleContext;
9use std::collections::BTreeMap;
10use uqa_sql::{
11 ast::{CreateRule, CreateTrigger, DropRule, DropTrigger, EventEnableMode},
12 catalog::{
13 events::{
14 definition::{duplicate_object, undefined_object, undefined_rule},
15 StoredRule, StoredTrigger,
16 },
17 resolution::{RelationLookupMode, RelationResolution},
18 },
19 schema::constraint_metadata::CatalogOidClass,
20 SQLError,
21};
22
23impl EventLifecycleContext<'_> {
24 fn visible_event_drop_resolution(
25 &self,
26 requested: &str,
27 if_exists: bool,
28 ) -> Result<Option<RelationResolution>, SQLError> {
29 let resolution = self
30 .lookup
31 .analysis
32 .relations
33 .resolve_visible_relation_kind(requested)?;
34 match resolution {
35 RelationResolution::MissingSchema(schema) if if_exists => {
36 self.notice(uqa_sql::SQLNotice::notice(format!(
37 "schema \"{schema}\" does not exist, skipping"
38 )));
39 Ok(None)
40 }
41 RelationResolution::MissingRelation if if_exists => {
42 self.notice(uqa_sql::SQLNotice::notice(format!(
43 "relation \"{requested}\" does not exist, skipping"
44 )));
45 Ok(None)
46 }
47 resolution => Ok(Some(resolution)),
48 }
49 }
50
51 pub fn register_rule(&self, mut definition: CreateRule) -> Result<(), SQLError> {
52 let (relation, condition_plan, condition_binding, dependencies) = self
53 .lookup
54 .analysis
55 .validate_rule_definition(&mut definition, RelationLookupMode::Dynamic, None, None)?;
56 if definition.event == uqa_sql::ast::RuleEvent::Select {
57 if !definition.or_replace {
58 return Err(duplicate_object(
59 "rule",
60 &definition.name,
61 &definition.table,
62 ));
63 }
64 let existing = self
65 .lookup
66 .analysis
67 .privileges
68 .view_definition(&definition.table)?
69 .ok_or_else(|| SQLError::UnknownTable(definition.table.clone()))?;
70 let action = definition.actions.into_iter().next().ok_or_else(|| {
71 SQLError::Internal("validated ON SELECT rule lost its action".into())
72 })?;
73 let plan = uqa_sql::plan::UnifiedPlan::lower_with(action, &|name: &str| {
74 self.lookup
75 .analysis
76 .routines
77 .has_registered_aggregate_function(name)
78 });
79 let uqa_sql::plan::UnifiedPlan::Query(plan) = plan else {
80 return Err(SQLError::Internal(
81 "ON SELECT rule action lowered to a command".into(),
82 ));
83 };
84 let output_columns = existing.output_columns.as_deref().unwrap_or_default();
85 crate::schema::view_creation::register_view_plan(
86 self.views,
87 crate::schema::view_creation::ViewRegistration {
88 name: &definition.table,
89 column_names: output_columns,
90 plan: *plan,
91 or_replace: true,
92 persistence: existing.persistence,
93 options: &existing.options,
94 params: &[],
95 },
96 )?;
97 return Ok(());
98 }
99 self.writer.prepare_writer()?;
100 let reserved = self.reserve_rule_oid(&relation, &definition.name)?;
101 let mut rules = self.catalog.registry.rules();
102 let mut next = rules.clone();
103 let relation_rules = std::sync::Arc::make_mut(next.entry(relation).or_default());
104 if relation_rules.contains_key(&definition.name) && !definition.or_replace {
105 return Err(duplicate_object(
106 "rule",
107 &definition.name,
108 &definition.table,
109 ));
110 }
111 let enabled = relation_rules
112 .get(&definition.name)
113 .map_or(EventEnableMode::Origin, |rule| rule.enabled);
114 let catalog_oid = match relation_rules.get(&definition.name) {
115 Some(existing) => crate::catalog::projection::rule_catalog_oid(existing),
116 None => reserved.ok_or_else(|| {
117 SQLError::Internal(format!(
118 "rule `{}` was removed while the definition writer was held",
119 definition.name
120 ))
121 })?,
122 };
123 relation_rules.insert(
124 definition.name.clone(),
125 StoredRule {
126 definition,
127 enabled,
128 condition_plan,
129 condition_binding,
130 dependencies: Some(dependencies),
131 catalog_oid: Some(catalog_oid),
132 },
133 );
134 self.catalog.publication.persist_rules(&next)?;
135 **rules = next;
136 drop(rules);
137 self.catalog.changes.catalog_registry_changed();
138 self.catalog.publication.finish_publication()?;
139 Ok(())
140 }
141
142 pub fn drop_rule_sql(&self, statement: &DropRule) -> Result<(), SQLError> {
143 let Some(resolution) =
144 self.visible_event_drop_resolution(&statement.table, statement.if_exists)?
145 else {
146 return Ok(());
147 };
148 let (relation, _) = uqa_sql::catalog::events::definition::EventAnalysisContext::event_relation_from_resolution(&statement.table, resolution)?;
149 let mut bound = statement.clone();
150 bound.table = relation.qualified_name();
151 let rule_exists = self
152 .lookup
153 .registry
154 .read_rules()
155 .get(&relation)
156 .is_some_and(|rules| rules.contains_key(&bound.name));
157 if rule_exists {
158 self.lookup
159 .analysis
160 .ensure_event_relation_owner(&relation, Some("relation"))?;
161 }
162 self.drop_rule(&bound)
163 }
164
165 pub fn drop_rule(&self, statement: &DropRule) -> Result<(), SQLError> {
166 let relation = self
167 .lookup
168 .analysis
169 .resolve_rule_relation(&statement.table)?;
170 let table = relation.qualified_name();
171 if statement.name == "_RETURN"
172 && self
173 .lookup
174 .analysis
175 .privileges
176 .view_definition(&table)?
177 .is_some()
178 {
179 return Err(SQLError::Diagnostic {
180 sqlstate: "2BP01".into(),
181 message: format!(
182 "cannot drop rule _RETURN on view {} because view {} requires it",
183 relation.name, relation.name
184 ),
185 detail: None,
186 hint: Some(format!("You can drop view {} instead.", relation.name)),
187 });
188 }
189 self.writer.prepare_writer()?;
190 let mut rules = self.catalog.registry.rules();
191 let mut next = rules.clone();
192 let removed = next
193 .get_mut(&relation)
194 .and_then(|entries| std::sync::Arc::make_mut(entries).remove(&statement.name));
195 if removed.is_none() {
196 if statement.if_exists {
197 self.notice(uqa_sql::SQLNotice::notice(format!(
198 "rule \"{}\" for relation \"{}\" does not exist, skipping",
199 statement.name, table
200 )));
201 return Ok(());
202 }
203 return Err(undefined_rule(&statement.name, &table));
204 }
205 if next
206 .get(&relation)
207 .is_some_and(|entries| entries.is_empty())
208 {
209 next.remove(&relation);
210 }
211 self.catalog.publication.persist_rules(&next)?;
212 **rules = next;
213 drop(rules);
214 self.catalog.changes.catalog_registry_changed();
215 self.catalog.publication.finish_publication()?;
216 Ok(())
217 }
218
219 pub fn rename_rule(&self, table: &str, from: &str, to: &str) -> Result<(), SQLError> {
220 let relation = self.lookup.analysis.resolve_rule_relation(table)?;
221 self.lookup
222 .analysis
223 .ensure_event_relation_owner(&relation, None)?;
224 let is_view = self
225 .lookup
226 .analysis
227 .privileges
228 .view_definition(&relation.qualified_name())?
229 .is_some();
230 if is_view && from == "_RETURN" {
231 return Err(SQLError::Routine {
232 sqlstate: "42P17".into(),
233 message: "renaming an ON SELECT rule is not allowed".into(),
234 });
235 }
236 if is_view && to == "_RETURN" {
237 return Err(duplicate_object("rule", to, &relation.qualified_name()));
238 }
239 self.writer.prepare_writer()?;
240 let mut rules = self.catalog.registry.rules();
241 let mut next = rules.clone();
242 let entries = std::sync::Arc::make_mut(next.entry(relation).or_default());
243 if entries.contains_key(to) {
244 return Err(duplicate_object("rule", to, table));
245 }
246 let mut rule = entries
247 .remove(from)
248 .ok_or_else(|| undefined_rule(from, table))?;
249 rule.definition.name = to.to_string();
250 entries.insert(to.to_string(), rule);
251 self.catalog.publication.persist_rules(&next)?;
252 **rules = next;
253 self.catalog.changes.catalog_registry_changed();
254 self.catalog.publication.finish_publication()?;
255 Ok(())
256 }
257
258 pub fn set_rule_enable_mode(
259 &self,
260 table: &str,
261 name: &str,
262 mode: EventEnableMode,
263 ) -> Result<(), SQLError> {
264 let relation = self.lookup.analysis.resolve_rule_relation(table)?;
265 self.lookup
266 .analysis
267 .ensure_event_relation_owner(&relation, None)?;
268 self.writer.prepare_writer()?;
269 let mut rules = self.catalog.registry.rules();
270 let mut next = rules.clone();
271 std::sync::Arc::make_mut(next.entry(relation).or_default())
272 .get_mut(name)
273 .ok_or_else(|| undefined_rule(name, table))?
274 .enabled = mode;
275 self.catalog.publication.persist_rules(&next)?;
276 **rules = next;
277 self.catalog.changes.catalog_registry_changed();
278 self.catalog.publication.finish_publication()?;
279 Ok(())
280 }
281
282 pub fn register_trigger(&self, mut definition: CreateTrigger) -> Result<(), SQLError> {
283 let (relation, _) = self
284 .lookup
285 .analysis
286 .validate_trigger_definition(&mut definition, RelationLookupMode::Dynamic)?;
287 let function_object_id = self
288 .lookup
289 .analysis
290 .resolve_trigger_function(&definition.function, RelationLookupMode::Bound)?
291 .def
292 .object_id
293 .ok_or_else(|| {
294 SQLError::Internal(format!(
295 "trigger function `{}` has no catalog object identity",
296 definition.function
297 ))
298 })?;
299 self.lookup.ensure_partition_trigger_name_available(
300 &relation,
301 &definition.name,
302 definition.or_replace,
303 )?;
304 if definition.constraint {
305 self.constraint_names.reserve(
306 self.constraint_names.bind(&relation.qualified_name())?,
307 &definition.name,
308 )?;
309 }
310 self.writer.prepare_writer()?;
311 let reserved =
312 self.reserve_trigger_oids(&relation, &definition.name, definition.constraint)?;
313 let mut triggers = self.catalog.registry.triggers();
314 let mut next = triggers.clone();
315 let table_triggers = next.entry(relation).or_default();
316 if definition.or_replace
317 && table_triggers
318 .get(&definition.name)
319 .is_some_and(|trigger| trigger.definition.constraint)
320 {
321 return Err(SQLError::Routine {
322 sqlstate: "0A000".into(),
323 message: "CREATE OR REPLACE CONSTRAINT TRIGGER is not supported".into(),
324 });
325 }
326 if table_triggers.contains_key(&definition.name) && !definition.or_replace {
327 return Err(duplicate_object(
328 "trigger",
329 &definition.name,
330 &definition.table,
331 ));
332 }
333 let object_id = match table_triggers.get(&definition.name) {
334 Some(trigger) => trigger.object_id,
335 None => Some(new_trigger_object_id()?),
336 };
337 let constraint_name = definition.constraint.then(|| definition.name.clone());
338 let (catalog_oid, constraint_catalog_oid) = match table_triggers.get(&definition.name) {
339 Some(existing) => (existing.catalog_oid, existing.constraint_catalog_oid),
340 None => reserved.ok_or_else(|| {
341 SQLError::Internal(format!(
342 "trigger `{}` was removed while the definition writer was held",
343 definition.name
344 ))
345 })?,
346 };
347 table_triggers.insert(
348 definition.name.clone(),
349 StoredTrigger {
350 definition,
351 function_object_id: Some(function_object_id),
352 enabled: EventEnableMode::Origin,
353 object_id,
354 constraint_name,
355 catalog_oid,
356 constraint_catalog_oid,
357 },
358 );
359 self.catalog.publication.persist_triggers(&next)?;
360 **triggers = next;
361 drop(triggers);
362 self.catalog.changes.catalog_registry_changed();
363 self.catalog.publication.finish_publication()?;
364 Ok(())
365 }
366
367 pub fn drop_trigger_sql(&self, statement: &DropTrigger) -> Result<(), SQLError> {
368 let Some(resolution) =
369 self.visible_event_drop_resolution(&statement.table, statement.if_exists)?
370 else {
371 return Ok(());
372 };
373 let (relation, _) = uqa_sql::catalog::events::definition::EventAnalysisContext::trigger_relation_from_resolution(&statement.table, resolution)?;
374 let mut bound = statement.clone();
375 bound.table = relation.qualified_name();
376 let trigger_exists = {
377 let triggers = self.lookup.registry.read_triggers();
378 triggers
379 .get(&relation)
380 .is_some_and(|triggers| triggers.contains_key(&bound.name))
381 };
382 if trigger_exists {
383 self.lookup
384 .analysis
385 .ensure_event_relation_owner(&relation, Some("relation"))?;
386 }
387 self.drop_trigger(&bound)
388 }
389
390 pub fn drop_trigger(&self, statement: &DropTrigger) -> Result<(), SQLError> {
391 let relation = self
392 .lookup
393 .analysis
394 .resolve_trigger_table(&statement.table)?;
395 let table = relation.qualified_name();
396 self.writer.prepare_writer()?;
397 let mut triggers = self.catalog.registry.triggers();
398 let mut next = triggers.clone();
399 let removed = next
400 .get_mut(&relation)
401 .and_then(|entries| entries.remove(&statement.name));
402 let Some(removed) = removed else {
403 if statement.if_exists {
404 self.notice(uqa_sql::SQLNotice::notice(format!(
405 "trigger \"{}\" for relation \"{}\" does not exist, skipping",
406 statement.name, table
407 )));
408 return Ok(());
409 }
410 return Err(undefined_object("trigger", &statement.name, &relation.name));
411 };
412 if next.get(&relation).is_some_and(BTreeMap::is_empty) {
413 next.remove(&relation);
414 }
415 self.catalog.publication.persist_triggers(&next)?;
416 **triggers = next;
417 drop(triggers);
418 if removed.definition.constraint {
419 self.pending.forget(&removed.constraint_identity()?);
420 }
421 self.catalog.changes.catalog_registry_changed();
422 self.catalog.publication.finish_publication()?;
423 Ok(())
424 }
425
426 pub fn rename_trigger(&self, table: &str, from: &str, to: &str) -> Result<(), SQLError> {
427 let relation = self.lookup.analysis.resolve_trigger_table(table)?;
428 self.lookup
429 .analysis
430 .ensure_event_relation_owner(&relation, None)?;
431 self.writer.prepare_writer()?;
432 let mut triggers = self.catalog.registry.triggers();
433 let mut next = triggers.clone();
434 let entries = next.entry(relation).or_default();
435 if entries.contains_key(to) {
436 return Err(duplicate_object("trigger", to, table));
437 }
438 let mut trigger = entries
439 .remove(from)
440 .ok_or_else(|| undefined_object("trigger", from, table))?;
441 let constraint_identity = trigger
442 .definition
443 .constraint
444 .then(|| trigger.constraint_identity())
445 .transpose()?;
446 trigger.definition.name = to.to_string();
447 entries.insert(to.to_string(), trigger);
448 self.catalog.publication.persist_triggers(&next)?;
449 **triggers = next;
450 drop(triggers);
451 if let Some(identity) = constraint_identity.as_ref() {
452 self.pending.rename_trigger(identity, to);
453 }
454 self.catalog.changes.catalog_registry_changed();
455 self.catalog.publication.finish_publication()?;
456 Ok(())
457 }
458
459 pub fn rename_trigger_constraint(
460 &self,
461 table: &str,
462 from: &str,
463 to: &str,
464 ) -> Result<(), SQLError> {
465 let relation = self.lookup.analysis.resolve_trigger_table(table)?;
466 let missing = || SQLError::Routine {
467 sqlstate: "42704".into(),
468 message: format!(
469 "constraint \"{from}\" of relation \"{}\" does not exist",
470 relation.name
471 ),
472 };
473 let selected = self
474 .lookup
475 .constraint_trigger_by_constraint_name(table, from)?
476 .ok_or_else(missing)?;
477 self.constraint_names
478 .ensure_available(&relation.qualified_name(), Some(to))?;
479 self.constraint_names
480 .reserve(self.constraint_names.bind(&relation.qualified_name())?, to)?;
481 self.writer.prepare_writer()?;
482 let mut triggers = self.catalog.registry.triggers();
483 let mut next = triggers.clone();
484 let entries = next.entry(relation.clone()).or_default();
485 let trigger = entries
486 .values_mut()
487 .find(|trigger| {
488 trigger.definition.constraint
489 && trigger.object_id == selected.object_id
490 && trigger.definition.name == selected.definition.name
491 })
492 .ok_or_else(missing)?;
493 let old_identity = trigger.constraint_identity()?;
494 trigger.constraint_name = Some(to.to_string());
495 self.catalog.publication.persist_triggers(&next)?;
496 **triggers = next;
497 drop(triggers);
498 self.pending.rename_constraint(&old_identity, to);
499 self.catalog.changes.catalog_registry_changed();
500 self.catalog.publication.finish_publication()?;
501 Ok(())
502 }
503
504 pub fn set_trigger_enable_mode(
505 &self,
506 table: &str,
507 name: Option<&str>,
508 mode: EventEnableMode,
509 ) -> Result<(), SQLError> {
510 let relation = self.lookup.analysis.resolve_trigger_table(table)?;
511 self.writer.prepare_writer()?;
512 let mut triggers = self.catalog.registry.triggers();
513 let mut next = triggers.clone();
514 let entries = next.entry(relation).or_default();
515 if let Some(name) = name {
516 entries
517 .get_mut(name)
518 .ok_or_else(|| undefined_object("trigger", name, table))?
519 .enabled = mode;
520 } else {
521 for trigger in entries.values_mut() {
522 trigger.enabled = mode;
523 }
524 }
525 self.catalog.publication.persist_triggers(&next)?;
526 **triggers = next;
527 self.catalog.changes.catalog_registry_changed();
528 self.catalog.publication.finish_publication()?;
529 Ok(())
530 }
531}
532
533type TriggerCatalogOids = (Option<i64>, Option<i64>);
535
536fn new_trigger_object_id() -> Result<[u8; 16], SQLError> {
537 let mut object_id = [0_u8; 16];
538 getrandom::fill(&mut object_id).map_err(|error| {
539 SQLError::Internal(format!(
540 "allocate constraint-trigger object identity: {error}"
541 ))
542 })?;
543 if object_id == [0; 16] {
544 object_id[15] = 1;
545 }
546 Ok(object_id)
547}
548
549impl EventLifecycleContext<'_> {
550 pub(super) fn notice(&self, notice: uqa_sql::SQLNotice) {
551 self.notices.push(notice);
552 }
553
554 fn reserve_rule_oid(
556 &self,
557 relation: &uqa_core::RelationIdentity,
558 name: &str,
559 ) -> Result<Option<i64>, SQLError> {
560 if self
561 .catalog
562 .registry
563 .rules()
564 .get(relation)
565 .is_some_and(|rules| rules.contains_key(name))
566 {
567 return Ok(None);
568 }
569 self.identities
570 .allocator(crate::catalog::identity::allocate_catalog_object_id)
571 .allocate_catalog_oid_matching(CatalogOidClass::Rewrite, |_| true)
572 .map(Some)
573 }
574
575 fn reserve_trigger_oids(
577 &self,
578 relation: &uqa_core::RelationIdentity,
579 name: &str,
580 constraint: bool,
581 ) -> Result<Option<TriggerCatalogOids>, SQLError> {
582 if self
583 .catalog
584 .registry
585 .triggers()
586 .get(relation)
587 .is_some_and(|triggers| triggers.contains_key(name))
588 {
589 return Ok(None);
590 }
591 let mut allocator = self
592 .identities
593 .allocator(crate::catalog::identity::allocate_catalog_object_id);
594 let trigger =
595 allocator.allocate_catalog_oid_matching(CatalogOidClass::Trigger, |_| true)?;
596 let constraint = constraint
597 .then(|| allocator.allocate_catalog_oid_matching(CatalogOidClass::Constraint, |_| true))
598 .transpose()?;
599 Ok(Some((Some(trigger), constraint)))
600 }
601}