Skip to main content

uqa_execution/catalog/read/
lineage.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7use 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}