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