Skip to main content

uqa_execution/catalog/security/
sequence_lifecycle.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Sequence ACL publication with retained authorization and registry guards.
8
9use 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                &current_user,
164                &roles,
165                &memberships,
166                &current,
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                &current.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}