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