Skip to main content

uqa_engine/capabilities/
event_definitions.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Live event metadata, retained catalog scopes, and declaration-analysis inputs.
8
9use crate::Engine;
10use uqa_core::RelationIdentity;
11use uqa_sql::{
12    ast::{ColumnDef, TableHierarchy},
13    catalog::{
14        events::definition::{EventAnalysisContext, EventForeignPrivileges, EventRelationCatalog},
15        security::table::TableAclPrivilege,
16        stored_view::StoredView,
17        view::StoredViewKind,
18    },
19    RowSchema, SQLError,
20};
21
22impl Engine {
23    pub(crate) fn event_analysis_context(&self) -> EventAnalysisContext<'_> {
24        EventAnalysisContext {
25            catalog: self,
26            relations: self,
27            sources: self,
28            routines: self,
29            authority: self,
30            privileges: self,
31            foreign_privileges: self,
32            columns: self.stored_column_binding_context(),
33            returning: self.returning_analysis_context(),
34            stored_routines: self.catalog_routine_analysis_context(),
35            namespaces: self,
36            sequences: self,
37            regroles: self,
38        }
39    }
40}
41impl EventRelationCatalog for Engine {
42    fn event_relation_owner(
43        &self,
44        relation: &RelationIdentity,
45    ) -> Result<(uqa_sql::catalog::roles::RoleIdentity, &'static str), SQLError> {
46        if let Some(table) = self.storage.tables.read().get(relation) {
47            return Ok((table.role_owner(), "table"));
48        }
49        if let Some(view) = self.durable.views.read().get(relation) {
50            return Ok((
51                view.security.role_owner,
52                match view.kind {
53                    StoredViewKind::View => "view",
54                    StoredViewKind::Materialized => "materialized view",
55                },
56            ));
57        }
58        if self.durable.foreign_tables.read().contains_key(relation) {
59            let owner = self
60                .durable
61                .foreign_table_security
62                .read()
63                .get(relation)
64                .map(|security| security.role_owner)
65                .ok_or_else(|| {
66                    SQLError::Internal(format!(
67                        "foreign trigger relation `{}` has no security metadata",
68                        relation.qualified_name()
69                    ))
70                })?;
71            return Ok((owner, "foreign table"));
72        }
73        Err(SQLError::Internal(format!(
74            "event relation `{}` disappeared after resolution",
75            relation.qualified_name()
76        )))
77    }
78    fn view_kind(&self, relation: &RelationIdentity) -> Option<StoredViewKind> {
79        self.durable
80            .views
81            .read()
82            .get(relation)
83            .map(|view| view.kind)
84    }
85    fn view(&self, relation: &RelationIdentity) -> Option<StoredView> {
86        self.durable.views.read().get(relation).cloned()
87    }
88    fn with_view_with_control(
89        &self,
90        relation: &RelationIdentity,
91        control: &uqa_core::memory::ProductionControl<'_>,
92        read: &mut dyn FnMut(&StoredView) -> Result<(), SQLError>,
93    ) -> Result<bool, SQLError> {
94        control.check()?;
95        let views = self.durable.views.snapshot();
96        let Some(view) = views.get(relation) else {
97            return Ok(false);
98        };
99        read(view)?;
100        Ok(true)
101    }
102    fn foreign_columns(&self, relation: &RelationIdentity) -> Option<Vec<ColumnDef>> {
103        self.durable
104            .foreign_tables
105            .read()
106            .get(relation)
107            .cloned()
108            .map(|table| table.columns)
109    }
110    fn restored_catalog_view_definition(&self, name: &str) -> Result<Option<StoredView>, SQLError> {
111        Engine::restored_catalog_view_definition(self, name)
112    }
113    fn stored_view_schema(&self, view: &StoredView) -> Result<RowSchema, SQLError> {
114        Engine::stored_view_schema(self, view)
115    }
116    fn stored_view_schema_with_control(
117        &self,
118        view: &StoredView,
119        control: &uqa_core::memory::ProductionControl<'_>,
120    ) -> Result<RowSchema, SQLError> {
121        self.catalog_execution()
122            .stored_view_schema_with_catalog_with_control(
123                view,
124                self.restored_catalog_read_view_with_control(control)?,
125                control,
126            )
127    }
128    fn loaded_table_hierarchy(&self, relation: &RelationIdentity) -> Option<TableHierarchy> {
129        Engine::loaded_table_hierarchy(self, relation)
130    }
131}
132impl EventForeignPrivileges for Engine {
133    fn ensure_foreign_table_privilege(
134        &self,
135        name: &str,
136        privilege: TableAclPrivilege,
137    ) -> Result<(), SQLError> {
138        Engine::ensure_foreign_table_privilege(self, name, privilege)
139    }
140}