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