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