uqa_execution/catalog/security/
sequence_lifecycle.rs1use super::roles::{
10 dependencies::{prepare_role_dependencies, RoleDependencyCandidate},
11 locking::RoleLockContext,
12};
13use crate::catalog::{
14 context::CatalogContext, projection::resolve_regclass_kind_by_oid, sequence::sequence_row,
15 sequence_introspection::SequenceIntrospectionCatalog,
16};
17use crate::row_locks::shared_objects::SharedObjectLockSession;
18use std::{
19 collections::{BTreeMap, BTreeSet},
20 ops::DerefMut,
21};
22use uqa_core::RelationIdentity;
23use uqa_sql::catalog::security::acl_command::{AclCommandRoles, ResolvedAclRoles};
24use uqa_sql::{
25 ast::{GrantSequenceStmt, GrantSequenceTarget},
26 catalog::security::{
27 acl_warning::acl_warning,
28 dependencies::added_acl_roles,
29 sequence::requested_acl_privileges,
30 sequence_grants::{
31 apply_sequence_acl, bind_named_sequence_grants, bind_sequence_grant_schemas,
32 sequence_grants_in_schemas, validate_sequence_acl_roles,
33 validate_sequence_grant_target_kinds, ResolvedSequenceGrantTarget,
34 SequenceGrantNamespace,
35 },
36 sequence_inquiry::SequencePrivilegeInquiry,
37 BoundSequenceSecurity,
38 },
39 SQLError,
40};
41use uqa_storage::{CatalogFacade, StorageBackendResult};
42
43pub type SequenceSecurityWrite<'a> =
44 Box<dyn DerefMut<Target = BTreeMap<RelationIdentity, BoundSequenceSecurity>> + 'a>;
45pub trait SequencePrivilegePublication {
46 fn prepare_writer(&self) -> Result<(), SQLError>;
47 fn refresh_catalog(&self) -> StorageBackendResult<()>;
48 fn security_write(&self) -> SequenceSecurityWrite<'_>;
49 fn catalog_changed(&self);
50 fn prepared_relation_changed(&self, _relation: &RelationIdentity) {}
51 fn notice(&self, notice: uqa_sql::SQLNotice);
52}
53pub struct SequencePrivilegeContext<'a> {
54 pub inquiry: SequencePrivilegeInquiry<'a>,
55 pub locks: &'a dyn SharedObjectLockSession,
56 pub sequences: &'a dyn SequenceIntrospectionCatalog,
57 pub namespaces: &'a dyn SequenceGrantNamespace,
58 pub publication: &'a dyn SequencePrivilegePublication,
59 pub catalog: CatalogContext<'a>,
60 pub storage: Option<&'a dyn CatalogFacade>,
61}
62
63struct SequencePrivilegeCandidate<'a> {
64 registry: SequenceSecurityWrite<'a>,
65 updates: Vec<(String, RelationIdentity, BoundSequenceSecurity)>,
66 notices: Vec<uqa_sql::SQLNotice>,
67}
68
69impl SequencePrivilegeContext<'_> {
70 pub fn grant_sequence_privileges(&self, statement: &GrantSequenceStmt) -> Result<(), SQLError> {
71 self.grant_sequence_privileges_with_roles(statement, &mut AclCommandRoles::default())
72 }
73
74 pub(crate) fn grant_sequence_privileges_with_roles(
75 &self,
76 statement: &GrantSequenceStmt,
77 command_roles: &mut AclCommandRoles,
78 ) -> Result<(), SQLError> {
79 let targets = self.resolve_sequence_grant_targets(&statement.target)?;
80 let RoleDependencyCandidate {
81 roles,
82 memberships,
83 value:
84 SequencePrivilegeCandidate {
85 mut registry,
86 updates,
87 notices,
88 },
89 ..
90 } = prepare_role_dependencies(
91 &RoleLockContext {
92 roles: self.inquiry.roles,
93 session: self.locks,
94 },
95 || self.publication.prepare_writer(),
96 || self.prepare_privileges(statement, &targets, command_roles),
97 )?;
98 for (name, relation, security) in &updates {
99 self.persist_sequence_security(name, relation, security)?;
100 }
101 let changed = !updates.is_empty();
102 for (_, relation, security) in updates {
103 self.publication.prepared_relation_changed(&relation);
104 registry.insert(relation, security);
105 }
106 drop(registry);
107 drop(memberships);
108 drop(roles);
109 for notice in notices {
110 self.publication.notice(notice);
111 }
112 if changed {
113 self.publication.catalog_changed();
114 }
115 Ok(())
116 }
117
118 fn prepare_privileges<'a>(
119 &'a self,
120 statement: &GrantSequenceStmt,
121 targets: &[ResolvedSequenceGrantTarget],
122 command_roles: &mut AclCommandRoles,
123 ) -> Result<RoleDependencyCandidate<'a, SequencePrivilegeCandidate<'a>>, SQLError> {
124 let roles = self.inquiry.roles.role_definitions();
125 let ResolvedAclRoles {
126 grantees,
127 current_user,
128 ..
129 } = command_roles.resolve_validated(
130 self.inquiry.names,
131 &roles,
132 &statement.grantees,
133 statement.grantor.as_ref(),
134 |resolved| {
135 validate_sequence_acl_roles(
136 statement,
137 &resolved.grantees,
138 resolved.requested_grantor.as_deref(),
139 &resolved.current_user,
140 &roles,
141 )
142 },
143 )?;
144 validate_sequence_grant_target_kinds(targets)?;
145 let privileges = requested_acl_privileges(&statement.privileges)?;
146 let memberships = self.inquiry.roles.role_memberships();
147 let registry = self.publication.security_write();
148 let mut updates = Vec::new();
149 let mut notices = Vec::new();
150 let mut dependencies = BTreeSet::new();
151 for target in targets {
152 let current = registry.get(&target.relation).cloned().ok_or_else(|| {
153 SQLError::Internal(format!(
154 "sequence `{}` has no security metadata",
155 target.name
156 ))
157 })?;
158 let current = current.resolve(&roles).map_err(SQLError::Internal)?;
159 let (next, grantable) = apply_sequence_acl(
160 statement,
161 &grantees,
162 &privileges,
163 ¤t_user,
164 &roles,
165 &memberships,
166 ¤t,
167 )?;
168 if grantable != privileges.len() {
169 notices.push(acl_warning(
170 statement.is_grant,
171 grantable != 0,
172 &target.relation.name,
173 ));
174 }
175 added_acl_roles(
176 current.acl.as_deref().unwrap_or_default(),
177 ¤t.role_owner,
178 next.acl.as_deref().unwrap_or_default(),
179 &next.role_owner,
180 &mut dependencies,
181 );
182 if next != current {
183 let next =
184 BoundSequenceSecurity::bind(&next, &roles).map_err(SQLError::Internal)?;
185 next.validate(&roles).map_err(SQLError::Internal)?;
186 updates.push((target.name.clone(), target.relation.clone(), next));
187 }
188 }
189 Ok(RoleDependencyCandidate {
190 value: SequencePrivilegeCandidate {
191 registry,
192 updates,
193 notices,
194 },
195 memberships,
196 roles,
197 dependencies,
198 })
199 }
200
201 fn resolve_sequence_grant_targets(
202 &self,
203 target: &GrantSequenceTarget,
204 ) -> Result<Vec<ResolvedSequenceGrantTarget>, SQLError> {
205 match target {
206 GrantSequenceTarget::Sequences { names } => {
207 bind_named_sequence_grants(self.inquiry.resolution, names)
208 }
209 GrantSequenceTarget::AllSequencesInSchemas { schemas } => {
210 self.resolve_all_sequences_in_schemas(schemas)
211 }
212 }
213 }
214
215 fn resolve_all_sequences_in_schemas(
216 &self,
217 schemas: &[String],
218 ) -> Result<Vec<ResolvedSequenceGrantTarget>, SQLError> {
219 self.publication.refresh_catalog().map_err(|error| {
220 SQLError::Internal(format!("load schemas for sequence privileges: {error}"))
221 })?;
222 self.sequences.refresh_sequences().map_err(|error| {
223 SQLError::Internal(format!("load sequences for privileges: {error}"))
224 })?;
225 let schemas = bind_sequence_grant_schemas(self.namespaces, schemas)?;
226 let sequences = self.sequences.states();
227 let targets = sequence_grants_in_schemas(&schemas, sequences.keys());
228 Ok(targets)
229 }
230
231 pub fn persist_sequence_security(
232 &self,
233 name: &str,
234 relation: &RelationIdentity,
235 security: &BoundSequenceSecurity,
236 ) -> Result<(), SQLError> {
237 let state = self
238 .sequences
239 .sequence_state(relation)
240 .ok_or_else(|| SQLError::Internal(format!("sequence `{name}` disappeared")))?;
241 let object_id = self
242 .sequences
243 .object_ids()
244 .get(relation)
245 .copied()
246 .ok_or_else(|| {
247 SQLError::Internal(format!("sequence `{name}` has no object identity"))
248 })?;
249 let persistence = self
250 .sequences
251 .sequence_persistence(relation)
252 .ok_or_else(|| {
253 SQLError::Internal(format!("sequence `{name}` has no persistence metadata"))
254 })?;
255 if persistence == uqa_sql::ast::RelationPersistence::Temporary {
256 return Ok(());
257 }
258 let Some(catalog) = self.storage else {
259 return Ok(());
260 };
261 let row = sequence_row(name, object_id, state, persistence, security)
262 .map_err(|error| SQLError::Internal(format!("build sequence catalog row: {error}")))?;
263 if !catalog
264 .replace_sequence_row(&row)
265 .map_err(|error| SQLError::Internal(format!("persist sequence privileges: {error}")))?
266 {
267 return Err(SQLError::Internal(format!(
268 "sequence `{name}` disappeared during privilege change"
269 )));
270 }
271 Ok(())
272 }
273
274 pub fn resolve_sequence_privilege_oid(
275 &self,
276 oid: i64,
277 ) -> Result<Option<(String, RelationIdentity)>, SQLError> {
278 self.sequences.refresh_sequences().map_err(|error| {
279 SQLError::Internal(format!("load sequences for privilege inquiry: {error}"))
280 })?;
281 let catalog = self.catalog.catalog_read_view();
282 if let Some((relation, _)) = self
283 .sequences
284 .object_ids()
285 .iter()
286 .find(|(_, object_id)| catalog.sequence_catalog_oid(object_id) == oid)
287 {
288 return Ok(Some((relation.qualified_name(), relation.clone())));
289 }
290 if let Some((name, _kind)) = resolve_regclass_kind_by_oid(&self.catalog, oid)? {
291 return Err(SQLError::Routine {
292 sqlstate: "42809".into(),
293 message: format!("\"{name}\" is not a sequence"),
294 });
295 }
296 Ok(None)
297 }
298}