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 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}