uqa_engine/capabilities/
event_definitions.rs1use 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 foreign_columns(&self, relation: &RelationIdentity) -> Option<Vec<ColumnDef>> {
89 self.durable
90 .foreign_tables
91 .read()
92 .get(relation)
93 .cloned()
94 .map(|table| table.columns)
95 }
96 fn restored_catalog_view_definition(&self, name: &str) -> Result<Option<StoredView>, SQLError> {
97 Engine::restored_catalog_view_definition(self, name)
98 }
99 fn stored_view_schema(&self, view: &StoredView) -> Result<RowSchema, SQLError> {
100 Engine::stored_view_schema(self, view)
101 }
102 fn loaded_table_hierarchy(&self, relation: &RelationIdentity) -> Option<TableHierarchy> {
103 Engine::loaded_table_hierarchy(self, relation)
104 }
105}
106impl EventForeignPrivileges for Engine {
107 fn ensure_foreign_table_privilege(
108 &self,
109 name: &str,
110 privilege: TableAclPrivilege,
111 ) -> Result<(), SQLError> {
112 Engine::ensure_foreign_table_privilege(self, name, privilege)
113 }
114}