Skip to main content

uqa_execution/schema/events/
lifecycle.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Native rule and trigger registration, removal, rename, and enable-mode publication.
8use 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
533/// The `pg_trigger` OID of a trigger, and the `pg_constraint` OID of a constraint trigger's constraint.
534type 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    /// The OID of the rule `InsertRule` creates, or `None` when it replaces a rule, whose OID it keeps. Reserving reads a catalog snapshot, which includes the rule registry, so it precedes the registry's write guard.
555    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    /// The OIDs of the trigger `CreateTrigger` creates and of a constraint trigger's constraint, which it allocates after the trigger's, or `None` when it replaces a trigger, whose OIDs it keeps. Reserving reads a catalog snapshot, which includes the trigger registry, so it precedes the registry's write guard.
576    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}