Skip to main content

uqa_execution/catalog/security/
database_lifecycle.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Database ACL publication and restoration with retained authorization guards.
8
9use super::roles::{
10    dependencies::{prepare_role_dependencies, RoleDependencyCandidate},
11    locking::RoleLockContext,
12};
13use crate::row_locks::shared_objects::SharedObjectLockSession;
14use std::{collections::BTreeSet, ops::DerefMut};
15use uqa_sql::catalog::security::acl_command::{AclCommandRoles, ResolvedAclRoles};
16use uqa_sql::{
17    ast::GrantDatabaseStmt,
18    catalog::{
19        roles::{guards::RoleCatalogGuards, RoleReferenceNames},
20        security::{
21            acl_warning::acl_warning,
22            database::{
23                apply_database_acl, requested_acl_privileges, resolve_database_grant_targets,
24                validate_database_acl_roles, BoundDatabaseSecurity,
25            },
26            database_inquiry::DatabaseSecurityRead,
27            dependencies::added_acl_roles,
28        },
29        DATABASE_NAME,
30    },
31    SQLError,
32};
33use uqa_storage::{CatalogFacade, StorageBackendResult};
34
35pub const DATABASE_SECURITY_METADATA_KEY: &str = "sql_database_security_json";
36mod persistence;
37pub type DatabaseSecurityWrite<'a> = Box<dyn DerefMut<Target = BoundDatabaseSecurity> + 'a>;
38
39pub trait DatabaseSecurityRegistry {
40    fn security_read(&self) -> DatabaseSecurityRead<'_>;
41    fn security_write(&self) -> DatabaseSecurityWrite<'_>;
42}
43pub trait DatabasePrivilegePublication {
44    fn prepare_writer(&self) -> Result<(), SQLError>;
45    fn refresh_catalog(&self) -> StorageBackendResult<()>;
46    fn persist_security(&self, json: &str) -> Result<(), SQLError>;
47    fn catalog_changed(&self);
48    fn notice(&self, notice: uqa_sql::SQLNotice);
49}
50pub struct DatabasePrivilegeContext<'a> {
51    pub names: &'a dyn RoleReferenceNames,
52    pub locks: &'a dyn SharedObjectLockSession,
53    pub roles: &'a dyn RoleCatalogGuards,
54    pub registry: &'a dyn DatabaseSecurityRegistry,
55    pub publication: &'a dyn DatabasePrivilegePublication,
56}
57
58pub fn grant_database_privileges(
59    context: &DatabasePrivilegeContext<'_>,
60    statement: &GrantDatabaseStmt,
61) -> Result<(), SQLError> {
62    context
63        .publication
64        .refresh_catalog()
65        .map_err(|error| SQLError::Internal(format!("load database privileges: {error}")))?;
66    let mut command_roles = AclCommandRoles::default();
67    let RoleDependencyCandidate {
68        roles,
69        memberships,
70        value:
71            DatabasePrivilegeCandidate {
72                current,
73                next,
74                notice,
75            },
76        ..
77    } = prepare_role_dependencies(
78        &RoleLockContext {
79            roles: context.roles,
80            session: context.locks,
81        },
82        || context.publication.prepare_writer(),
83        || prepare_privileges(context, statement, &mut command_roles),
84    )?;
85    if next != current {
86        let json = persistence::encode(&next, &roles).map_err(|error| {
87            SQLError::Internal(format!("serialize database privileges: {error}"))
88        })?;
89        context.publication.persist_security(&json)?;
90        **context.registry.security_write() = next;
91        context.publication.catalog_changed();
92    }
93    drop(memberships);
94    drop(roles);
95    if let Some(notice) = notice {
96        context.publication.notice(notice);
97    }
98    Ok(())
99}
100
101struct DatabasePrivilegeCandidate {
102    current: BoundDatabaseSecurity,
103    next: BoundDatabaseSecurity,
104    notice: Option<uqa_sql::SQLNotice>,
105}
106
107fn prepare_privileges<'a>(
108    context: &'a DatabasePrivilegeContext<'_>,
109    statement: &GrantDatabaseStmt,
110    command_roles: &mut AclCommandRoles,
111) -> Result<RoleDependencyCandidate<'a, DatabasePrivilegeCandidate>, SQLError> {
112    resolve_database_grant_targets(&statement.databases)?;
113    let roles = context.roles.role_definitions();
114    let ResolvedAclRoles {
115        grantees,
116        current_user,
117        ..
118    } = command_roles.resolve_validated(
119        context.names,
120        &roles,
121        &statement.grantees,
122        statement.grantor.as_ref(),
123        |resolved| {
124            validate_database_acl_roles(
125                statement,
126                &resolved.grantees,
127                resolved.requested_grantor.as_deref(),
128                &resolved.current_user,
129                &roles,
130            )
131        },
132    )?;
133    let privileges = requested_acl_privileges(&statement.privileges)?;
134    let memberships = context.roles.role_memberships();
135    let current = context.registry.security_read().clone();
136    let resolved = current.resolve(&roles).map_err(SQLError::Internal)?;
137    let (next, grantable) = apply_database_acl(
138        statement,
139        &grantees,
140        &privileges,
141        &current_user,
142        &roles,
143        &memberships,
144        &resolved,
145    )?;
146    let notice = (grantable != privileges.len())
147        .then(|| acl_warning(statement.is_grant, grantable != 0, DATABASE_NAME));
148    let mut dependencies = BTreeSet::new();
149    added_acl_roles(
150        resolved.acl.as_deref().unwrap_or_default(),
151        &resolved.role_owner,
152        next.acl.as_deref().unwrap_or_default(),
153        &next.role_owner,
154        &mut dependencies,
155    );
156    let next = BoundDatabaseSecurity::bind(&next, &roles).map_err(SQLError::Internal)?;
157    Ok(RoleDependencyCandidate {
158        value: DatabasePrivilegeCandidate {
159            current,
160            next,
161            notice,
162        },
163        memberships,
164        roles,
165        dependencies,
166    })
167}
168
169pub fn restore_database_security_from_metadata(
170    context: &DatabasePrivilegeContext<'_>,
171    catalog: &dyn CatalogFacade,
172    allow_migration: bool,
173) -> StorageBackendResult<()> {
174    let roles = context.roles.role_definitions();
175    let security = persistence::restore(catalog, &roles, allow_migration)?;
176    drop(roles);
177    **context.registry.security_write() = security;
178    Ok(())
179}
180
181#[cfg(test)]
182mod tests;