1use 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}