uqa_execution/catalog/read/
lineage.rs1use super::super::CatalogReadView;
8use crate::catalog::{security::table::TableAclPrivilege, view::StoredViewKind};
9use uqa_sql::catalog::roles::RoleReference;
10use uqa_sql::{
11 catalog::resolution::RelationNameResolution,
12 semantics::privileges::context::{PrivilegeCatalog, PrivilegeRelation, PrivilegeRelationKind},
13 SQLError,
14};
15mod production;
16
17impl PrivilegeCatalog for CatalogReadView {
18 fn relation_with_control(
19 &self,
20 resolution: &RelationNameResolution,
21 name: &str,
22 control: &uqa_core::memory::ProductionControl<'_>,
23 ) -> Result<Option<uqa_core::memory::Produced<PrivilegeRelation>>, SQLError> {
24 production::relation(self, resolution, name, control)
25 }
26 fn has_select_privilege_with_control(
27 &self,
28 resolution: &RelationNameResolution,
29 relation: &PrivilegeRelation,
30 column: Option<&str>,
31 subject: &RoleReference,
32 control: &uqa_core::memory::ProductionControl<'_>,
33 ) -> Result<bool, SQLError> {
34 production::select(self, resolution, relation, column, subject, control)
35 }
36
37 fn relation(
38 &self,
39 resolution: &RelationNameResolution,
40 name: &str,
41 ) -> Result<Option<PrivilegeRelation>, SQLError> {
42 if let Some(canonical) = self.table_name_resolved(resolution, name)? {
43 let table = self
44 .table_resolved(resolution, &canonical)?
45 .ok_or_else(|| SQLError::UnknownTable(canonical.clone()))?;
46 return Ok(Some(PrivilegeRelation {
47 columns: table
48 .columns
49 .iter()
50 .map(|column| column.name.clone())
51 .collect(),
52 canonical,
53 kind: PrivilegeRelationKind::Table,
54 }));
55 }
56 if let Some(canonical) = self.view_name_resolved(resolution, name)? {
57 let view = self
58 .view_resolved(resolution, &canonical)?
59 .ok_or_else(|| SQLError::UnknownTable(canonical.clone()))?;
60 let columns = view.output_columns.clone().ok_or_else(|| {
61 SQLError::Internal(format!(
62 "loaded view `{canonical}` has no durable public column metadata"
63 ))
64 })?;
65 let kind = match view.kind {
66 StoredViewKind::View => PrivilegeRelationKind::View,
67 StoredViewKind::Materialized => PrivilegeRelationKind::MaterializedView,
68 };
69 return Ok(Some(PrivilegeRelation {
70 columns,
71 canonical,
72 kind,
73 }));
74 }
75 if let Some((canonical, table)) = self.foreign_table_entry_resolved(resolution, name)? {
76 return Ok(Some(PrivilegeRelation {
77 columns: table
78 .columns
79 .iter()
80 .map(|column| column.name.clone())
81 .collect(),
82 canonical,
83 kind: PrivilegeRelationKind::ForeignTable,
84 }));
85 }
86 if let Some((canonical, _)) = self
87 .relation_kind_resolution(resolution, name)?
88 .into_found()
89 {
90 if let Some(relation) =
91 uqa_sql::catalog::SystemRelation::from_qualified_name(&canonical)
92 {
93 return Ok(Some(PrivilegeRelation {
94 canonical,
95 columns: relation.column_names(),
96 kind: PrivilegeRelationKind::System(relation),
97 }));
98 }
99 }
100 Ok(None)
101 }
102 fn has_select_privilege(
103 &self,
104 resolution: &RelationNameResolution,
105 relation: &PrivilegeRelation,
106 column: Option<&str>,
107 subject: &RoleReference,
108 ) -> Result<bool, SQLError> {
109 let privilege = TableAclPrivilege::Select;
110 match relation.kind {
111 PrivilegeRelationKind::System(system) => {
112 use uqa_sql::catalog::security::{
113 system_relations::{self, SystemRelationSecurityCatalog},
114 table::TablePrivilegeCheck,
115 };
116 let security = self
117 .system_relation_security(system)
118 .resolve(&self.snapshot.definitions.roles)
119 .map_err(SQLError::Internal)?;
120 let check = TablePrivilegeCheck {
121 privilege,
122 grant_option: false,
123 };
124 let definitions = &self.snapshot.definitions;
125 Ok(column.map_or_else(
126 || {
127 system_relations::has_table_privilege(
128 system,
129 &security,
130 subject,
131 check,
132 &definitions.roles,
133 &definitions.role_memberships,
134 )
135 },
136 |column| {
137 system_relations::has_column_privilege(
138 system,
139 &security,
140 column,
141 subject,
142 check,
143 &definitions.roles,
144 &definitions.role_memberships,
145 )
146 },
147 ))
148 }
149 PrivilegeRelationKind::Table => {
150 let table = self
151 .table_resolved(resolution, &relation.canonical)?
152 .ok_or_else(|| SQLError::UnknownTable(relation.canonical.clone()))?;
153 Ok(column.map_or_else(
154 || self.table_has_privilege_to(table, subject, privilege),
155 |column| self.table_column_has_privilege_to(table, column, subject, privilege),
156 ))
157 }
158 PrivilegeRelationKind::View | PrivilegeRelationKind::MaterializedView => {
159 let view = self
160 .view_resolved(resolution, &relation.canonical)?
161 .ok_or_else(|| SQLError::UnknownTable(relation.canonical.clone()))?;
162 Ok(column.map_or_else(
163 || self.view_has_privilege_to(view, subject, privilege),
164 |column| self.view_column_has_privilege_to(view, column, subject, privilege),
165 ))
166 }
167 PrivilegeRelationKind::ForeignTable => column.map_or_else(
168 || self.foreign_table_has_privilege_to(&relation.canonical, subject, privilege),
169 |column| {
170 self.foreign_table_column_has_privilege_to(
171 &relation.canonical,
172 column,
173 subject,
174 privilege,
175 )
176 },
177 ),
178 }
179 }
180}