Skip to main content

uqa_engine/capabilities/
roles.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind role lifecycle consumers to live catalog guards, provider writes and session state.
8
9use crate::{Engine, TableState};
10use std::{collections::BTreeMap, sync::Arc};
11use uqa_core::RelationIdentity;
12use uqa_execution::catalog::security::role_lifecycle::context::{
13    RoleDefinitionWrite, RoleExecutionContext, RoleMembershipWrite, RolePublication, RoleRegistry,
14};
15use uqa_sql::catalog::roles::identity::RoleBinding;
16use uqa_sql::catalog::roles::RoleReference;
17use uqa_sql::{
18    catalog::{
19        roles::{
20            definition::{RoleNotices, RoleValidationContext},
21            dependencies::context::{
22                RoleDependencyCatalog, RoleDependencyRead, RoleForeignPersistenceRead,
23                RoleTableSecurity, RoleTablesRead,
24            },
25            RoleDefinition, RoleMembership, RoleMembershipKey,
26        },
27        security::{
28            database::BoundDatabaseSecurity, BoundSchemaSecurity, BoundSequenceSecurity,
29            BoundTableSecurity,
30        },
31        stored_view::StoredView,
32    },
33    routines::SQLUserFunction,
34    SQLError,
35};
36impl uqa_execution::catalog::security::roles::RoleCatalogGuards for Engine {
37    fn role_definitions(&self) -> uqa_execution::catalog::security::roles::RoleDefinitionRead<'_> {
38        Box::new(self.durable.roles.read())
39    }
40    fn role_memberships(&self) -> uqa_execution::catalog::security::roles::RoleMembershipRead<'_> {
41        Box::new(self.durable.role_memberships.read())
42    }
43    fn inquiry_role_definitions(
44        &self,
45    ) -> Result<uqa_execution::catalog::security::roles::RoleDefinitionRead<'_>, SQLError> {
46        use uqa_execution::catalog::security::roles::{
47            persistence::RoleCatalogSnapshot, snapshot::read_role_snapshot,
48        };
49        let session = self
50            .open_independent_catalog_session(None)
51            .map_err(|error| SQLError::Internal(format!("open role inquiry snapshot: {error}")))?;
52        let snapshot = read_role_snapshot(
53            RoleCatalogSnapshot {
54                roles: self.durable.roles.snapshot(),
55                memberships: self.durable.role_memberships.snapshot(),
56            },
57            self.storage.catalog.as_deref(),
58            session.as_ref(),
59            self.versioned_backend_transactions(),
60        )
61        .map_err(|error| SQLError::Internal(format!("load role inquiry snapshot: {error}")))?;
62        Ok(Box::new(snapshot.roles))
63    }
64}
65impl uqa_sql::catalog::roles::RoleReferenceNames for Engine {
66    fn outer_role(&self) -> RoleReference {
67        RoleReference::Bound(self.session.state.read().authorization.outer().clone())
68    }
69    fn current_role(&self) -> RoleReference {
70        Engine::current_role(self)
71    }
72    fn session_role(&self) -> RoleReference {
73        Engine::session_role(self)
74    }
75    fn authenticated_role(&self) -> RoleReference {
76        RoleReference::Bound(
77            self.session
78                .state
79                .read()
80                .authorization
81                .authenticated()
82                .clone(),
83        )
84    }
85}
86
87impl Engine {
88    pub(crate) fn role_execution_context(&self) -> RoleExecutionContext<'_> {
89        RoleExecutionContext {
90            analysis: RoleValidationContext {
91                names: self,
92                roles: self,
93                notices: self,
94            },
95            registry: self,
96            publication: self,
97            dependencies: self,
98            locks: self,
99            temporary_roles: self,
100        }
101    }
102}
103impl RoleRegistry for Engine {
104    fn write_roles(&self) -> RoleDefinitionWrite<'_> {
105        Box::new(self.durable.roles.write())
106    }
107    fn write_memberships(&self) -> RoleMembershipWrite<'_> {
108        Box::new(self.durable.role_memberships.write())
109    }
110}
111impl RolePublication for Engine {
112    fn prepare_writer(&self) -> Result<(), SQLError> {
113        self.prepare_explicit_transaction_writer().map(|_| ())
114    }
115    fn persist_roles(
116        &self,
117        before: &BTreeMap<String, RoleDefinition>,
118        roles: &BTreeMap<String, RoleDefinition>,
119    ) -> Result<(), SQLError> {
120        self.persist_roles_snapshot(before, roles)
121    }
122    fn persist_memberships(
123        &self,
124        before: &BTreeMap<RoleMembershipKey, RoleMembership>,
125        memberships: &BTreeMap<RoleMembershipKey, RoleMembership>,
126    ) -> Result<(), SQLError> {
127        self.persist_role_memberships_snapshot(before, memberships)
128    }
129    fn catalog_changed(&self) {
130        self.note_catalog_registry_changed();
131    }
132    fn set_current_role(&self, target: Option<RoleBinding>) {
133        let mut state = self.session.state.write();
134        state.authorization.set_role(target.map(Arc::new));
135        state.sql_statement_cache.clear();
136    }
137    fn set_session_authorization(&self, target: RoleBinding) {
138        let mut state = self.session.state.write();
139        state.authorization.set_session(Arc::new(target));
140        state.sql_statement_cache.clear();
141    }
142}
143impl RoleNotices for Engine {
144    fn notice(&self, notice: uqa_sql::SQLNotice) {
145        self.push_sql_notice(notice);
146    }
147}
148struct RoleTableRegistryRead<'a>(
149    parking_lot::RwLockReadGuard<'a, BTreeMap<RelationIdentity, Arc<TableState>>>,
150);
151impl RoleTableSecurity for TableState {
152    fn persistence(&self) -> uqa_sql::ast::RelationPersistence {
153        self.persistence
154    }
155    fn security(&self) -> BoundTableSecurity {
156        TableState::security(self)
157    }
158}
159impl RoleTablesRead for RoleTableRegistryRead<'_> {
160    fn iter(&self) -> Box<dyn Iterator<Item = (&RelationIdentity, &dyn RoleTableSecurity)> + '_> {
161        Box::new(
162            self.0
163                .iter()
164                .map(|(relation, table)| (relation, table.as_ref() as &dyn RoleTableSecurity)),
165        )
166    }
167}
168impl uqa_execution::catalog::security::role_lifecycle::context::RoleSharedDependencies for Engine {
169    fn role_dependency_detail(
170        &self,
171        role: uqa_sql::catalog::roles::RoleIdentity,
172    ) -> Result<Option<String>, SQLError> {
173        uqa_execution::catalog::projection::role_dependency_detail(&self.catalog_execution(), role)
174    }
175}
176impl RoleDependencyCatalog for Engine {
177    fn database(&self) -> RoleDependencyRead<'_, BoundDatabaseSecurity> {
178        Box::new(self.durable.database_security.read())
179    }
180    fn schemas(&self) -> RoleDependencyRead<'_, BTreeMap<String, BoundSchemaSecurity>> {
181        Box::new(self.durable.schemas.read())
182    }
183    fn tables(&self) -> Box<dyn RoleTablesRead + '_> {
184        Box::new(RoleTableRegistryRead(self.storage.tables.read()))
185    }
186    fn views(&self) -> RoleDependencyRead<'_, BTreeMap<RelationIdentity, StoredView>> {
187        Box::new(self.durable.views.read())
188    }
189    fn foreign_tables(
190        &self,
191    ) -> RoleDependencyRead<'_, BTreeMap<RelationIdentity, BoundTableSecurity>> {
192        Box::new(self.durable.foreign_table_security.read())
193    }
194    fn sequences(
195        &self,
196    ) -> RoleDependencyRead<'_, BTreeMap<RelationIdentity, BoundSequenceSecurity>> {
197        Box::new(self.durable.sequence_security.read())
198    }
199    fn routines(&self) -> RoleDependencyRead<'_, BTreeMap<String, Vec<Arc<SQLUserFunction>>>> {
200        Box::new(self.durable.sql_user_functions.read())
201    }
202    fn domains(
203        &self,
204    ) -> RoleDependencyRead<'_, BTreeMap<String, uqa_sql::catalog::domain::StoredDomain>> {
205        Box::new(self.durable.domains.read())
206    }
207}
208
209struct ForeignRolePersistenceRead<'a>(
210    parking_lot::MappedRwLockReadGuard<
211        'a,
212        BTreeMap<RelationIdentity, crate::fdw::StoredForeignTable>,
213    >,
214);
215impl RoleForeignPersistenceRead for ForeignRolePersistenceRead<'_> {
216    fn iter(
217        &self,
218    ) -> Box<dyn Iterator<Item = (&RelationIdentity, uqa_sql::ast::RelationPersistence)> + '_> {
219        Box::new(
220            self.0
221                .iter()
222                .map(|(relation, table)| (relation, table.persistence)),
223        )
224    }
225}
226impl uqa_sql::catalog::roles::dependencies::context::TemporaryRoleDependencyCatalog for Engine {
227    fn foreign_table_persistence(&self) -> Box<dyn RoleForeignPersistenceRead + '_> {
228        Box::new(ForeignRolePersistenceRead(
229            self.durable.foreign_tables.read(),
230        ))
231    }
232    fn temporary_namespace_allocated(&self) -> bool {
233        self.session.state.read().temporary_namespace.is_some()
234    }
235    fn sequence_persistence(
236        &self,
237    ) -> RoleDependencyRead<'_, BTreeMap<RelationIdentity, uqa_sql::ast::RelationPersistence>> {
238        Box::new(self.durable.sequence_persistence.read())
239    }
240}
241
242impl uqa_execution::catalog::security::roles::temporary::TemporaryRoleDependencyReads for Engine {
243    fn peer_temporary_role_reference(&self, oid: u32) -> Result<bool, SQLError> {
244        self.row_locks.peer_temporary_role_reference(
245            self.session_id,
246            oid,
247            &self.runtime.cancellation,
248        )
249    }
250}
251
252impl Engine {
253    pub(crate) fn prepare_temporary_role_publication(
254        &self,
255    ) -> Result<
256        Option<uqa_execution::row_locks::temporary_roles::TemporaryRolePublication<'_>>,
257        SQLError,
258    > {
259        uqa_execution::catalog::security::roles::temporary::prepare_temporary_roles(
260            uqa_execution::catalog::security::roles::temporary::TemporaryRoleContext {
261                catalog: self,
262                roles: self,
263                manager: &self.row_locks,
264                session: self.session_id,
265                cancellation: &self.runtime.cancellation,
266            },
267        )
268    }
269}