Skip to main content

uqa_execution/catalog/read/
privileges.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Role-aware visibility and table-shaped relation privilege projections.
8
9use super::super::{CatalogReadView, CatalogTableSnapshot};
10use uqa_sql::catalog::roles::identity::RoleSubject;
11
12impl CatalogReadView {
13    pub fn role_is_enabled_for(
14        &self,
15        member: &(impl RoleSubject + ?Sized),
16        role: &(impl RoleSubject + ?Sized),
17    ) -> bool {
18        uqa_sql::catalog::roles::role_inherits(
19            &self.snapshot.definitions.roles,
20            &self.snapshot.definitions.role_memberships,
21            member,
22            role,
23        )
24    }
25
26    pub fn table_is_visible_to(
27        &self,
28        table: &CatalogTableSnapshot,
29        role: &(impl RoleSubject + ?Sized),
30    ) -> bool {
31        let Ok(security) = self.relation_security_names(&table.security) else {
32            return false;
33        };
34        crate::catalog::security::table::role_can_view_table(
35            &security,
36            role,
37            &self.snapshot.definitions.roles,
38            &self.snapshot.definitions.role_memberships,
39        )
40    }
41
42    pub fn table_has_privilege_to(
43        &self,
44        table: &CatalogTableSnapshot,
45        role: &(impl RoleSubject + ?Sized),
46        privilege: crate::catalog::security::table::TableAclPrivilege,
47    ) -> bool {
48        let Ok(security) = self.relation_security_names(&table.security) else {
49            return false;
50        };
51        crate::catalog::security::table::role_has_table_privilege(
52            &security,
53            role,
54            privilege,
55            &self.snapshot.definitions.roles,
56            &self.snapshot.definitions.role_memberships,
57        )
58    }
59
60    pub fn table_column_has_privilege_to(
61        &self,
62        table: &CatalogTableSnapshot,
63        column: &str,
64        role: &(impl RoleSubject + ?Sized),
65        privilege: crate::catalog::security::table::TableAclPrivilege,
66    ) -> bool {
67        let Ok(security) = self.relation_security_names(&table.security) else {
68            return false;
69        };
70        crate::catalog::security::table::role_has_column_privilege(
71            &security,
72            column,
73            role,
74            privilege,
75            &self.snapshot.definitions.roles,
76            &self.snapshot.definitions.role_memberships,
77        )
78    }
79
80    pub fn table_column_is_visible_to(
81        &self,
82        table: &CatalogTableSnapshot,
83        column: &str,
84        role: &(impl RoleSubject + ?Sized),
85    ) -> bool {
86        crate::catalog::security::table::TableAclPrivilege::COLUMN_ALL
87            .into_iter()
88            .any(|privilege| self.table_column_has_privilege_to(table, column, role, privilege))
89    }
90
91    pub fn view_is_visible_to(
92        &self,
93        view: &crate::catalog::view::StoredView,
94        role: &(impl RoleSubject + ?Sized),
95    ) -> bool {
96        let Ok(security) = self.relation_security_names(&view.security) else {
97            return false;
98        };
99        crate::catalog::security::table::role_can_view_table(
100            &security,
101            role,
102            &self.snapshot.definitions.roles,
103            &self.snapshot.definitions.role_memberships,
104        )
105    }
106
107    pub fn view_has_privilege_to(
108        &self,
109        view: &crate::catalog::view::StoredView,
110        role: &(impl RoleSubject + ?Sized),
111        privilege: crate::catalog::security::table::TableAclPrivilege,
112    ) -> bool {
113        let Ok(security) = self.relation_security_names(&view.security) else {
114            return false;
115        };
116        crate::catalog::security::table::role_has_table_privilege(
117            &security,
118            role,
119            privilege,
120            &self.snapshot.definitions.roles,
121            &self.snapshot.definitions.role_memberships,
122        )
123    }
124
125    pub fn view_column_has_privilege_to(
126        &self,
127        view: &crate::catalog::view::StoredView,
128        column: &str,
129        role: &(impl RoleSubject + ?Sized),
130        privilege: crate::catalog::security::table::TableAclPrivilege,
131    ) -> bool {
132        let Ok(security) = self.relation_security_names(&view.security) else {
133            return false;
134        };
135        crate::catalog::security::table::role_has_column_privilege(
136            &security,
137            column,
138            role,
139            privilege,
140            &self.snapshot.definitions.roles,
141            &self.snapshot.definitions.role_memberships,
142        )
143    }
144
145    pub fn view_column_is_visible_to(
146        &self,
147        view: &crate::catalog::view::StoredView,
148        column: &str,
149        role: &(impl RoleSubject + ?Sized),
150    ) -> bool {
151        crate::catalog::security::table::TableAclPrivilege::COLUMN_ALL
152            .into_iter()
153            .any(|privilege| self.view_column_has_privilege_to(view, column, role, privilege))
154    }
155
156    pub fn foreign_table_is_visible_to(
157        &self,
158        name: &str,
159        role: &(impl RoleSubject + ?Sized),
160    ) -> Result<bool, uqa_sql::SQLError> {
161        Ok(crate::catalog::security::table::role_can_view_table(
162            &self.foreign_table_security(name)?,
163            role,
164            &self.snapshot.definitions.roles,
165            &self.snapshot.definitions.role_memberships,
166        ))
167    }
168
169    pub fn foreign_table_has_privilege_to(
170        &self,
171        name: &str,
172        role: &(impl RoleSubject + ?Sized),
173        privilege: crate::catalog::security::table::TableAclPrivilege,
174    ) -> Result<bool, uqa_sql::SQLError> {
175        Ok(crate::catalog::security::table::role_has_table_privilege(
176            &self.foreign_table_security(name)?,
177            role,
178            privilege,
179            &self.snapshot.definitions.roles,
180            &self.snapshot.definitions.role_memberships,
181        ))
182    }
183
184    pub fn foreign_table_column_has_privilege_to(
185        &self,
186        name: &str,
187        column: &str,
188        role: &(impl RoleSubject + ?Sized),
189        privilege: crate::catalog::security::table::TableAclPrivilege,
190    ) -> Result<bool, uqa_sql::SQLError> {
191        Ok(crate::catalog::security::table::role_has_column_privilege(
192            &self.foreign_table_security(name)?,
193            column,
194            role,
195            privilege,
196            &self.snapshot.definitions.roles,
197            &self.snapshot.definitions.role_memberships,
198        ))
199    }
200
201    pub fn foreign_table_column_is_visible_to(
202        &self,
203        name: &str,
204        column: &str,
205        role: &(impl RoleSubject + ?Sized),
206    ) -> Result<bool, uqa_sql::SQLError> {
207        for privilege in crate::catalog::security::table::TableAclPrivilege::COLUMN_ALL {
208            if self.foreign_table_column_has_privilege_to(name, column, role, privilege)? {
209                return Ok(true);
210            }
211        }
212        Ok(false)
213    }
214}
215
216impl uqa_sql::catalog::security::system_relations::SystemRelationSecurityCatalog
217    for CatalogReadView
218{
219    fn system_relation_securities(
220        &self,
221    ) -> uqa_sql::catalog::security::system_relations::SystemRelationSecurityRead<'_> {
222        Box::new(self.snapshot.definitions.system_relation_security.as_ref())
223    }
224}
225
226impl uqa_sql::catalog::security::builtin_routines::BuiltinRoutineSecurityCatalog
227    for CatalogReadView
228{
229    fn builtin_routine_securities(
230        &self,
231    ) -> uqa_sql::catalog::security::builtin_routines::BuiltinRoutineSecurityRead<'_> {
232        Box::new(self.snapshot.definitions.builtin_routine_security.as_ref())
233    }
234}