Skip to main content

uqa_execution/schema/namespaces/
locking.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Namespace lifetime binding and original catalog tuple replacement checks.
8
9use super::{identity::SCHEMA_CATALOG_CLASS_ID, SchemaSecurityCatalog};
10use crate::row_locks::{
11    binding::{acquire_relation, RelationLockSession},
12    session::RowLockSession,
13    shared_objects::{SharedCatalogLock, SharedObjectLockSession},
14    LockAcquire, RelationLockMode,
15};
16use uqa_core::catalog_schema::SchemaTupleIdentity;
17use uqa_sql::{
18    ast::{LockStrength, LockWait},
19    catalog::security::BoundSchemaSecurity,
20    SQLError,
21};
22
23pub struct SchemaLockContext<'a> {
24    pub objects: &'a dyn SharedObjectLockSession,
25    pub relations: &'a dyn RelationLockSession,
26    pub rows: &'a dyn RowLockSession,
27    pub catalog: &'a dyn SchemaSecurityCatalog,
28}
29
30impl SchemaLockContext<'_> {
31    /// A name lookup may bind a replacement namespace after waiting for deletion.
32    pub fn bind_lifetime(
33        &self,
34        name: &str,
35        mode: RelationLockMode,
36    ) -> Result<Option<BoundSchemaSecurity>, SQLError> {
37        bind_namespace_lifetime(self.objects, mode, || {
38            self.catalog
39                .schema_security(name)
40                .map(|security| Ok((tuple(&security)?, security)))
41                .transpose()
42        })
43    }
44
45    pub fn catalog_write(&self) -> Result<(), SQLError> {
46        acquire_relation(
47            self.relations,
48            "pg_catalog.pg_namespace",
49            RelationLockMode::RowExclusive,
50            false,
51        )?
52        .retain();
53        self.objects.refresh_shared_catalog()
54    }
55
56    /// Tuple updates retain their original target even if its name is reused while waiting.
57    pub fn replace(&self, name: &str, before: SchemaTupleIdentity) -> Result<(), SQLError> {
58        match self.rows.lock_row(
59            "pg_catalog.pg_namespace",
60            before.oid as u64,
61            LockStrength::ForNoKeyUpdate,
62            LockWait::Block,
63            name,
64        )? {
65            LockAcquire::Granted { .. } => {}
66            LockAcquire::Skipped => {
67                return Err(SQLError::Internal(
68                    "blocking schema tuple lock was skipped".into(),
69                ));
70            }
71        }
72        self.objects.refresh_shared_catalog()?;
73        let current = self
74            .catalog
75            .schema_security(name)
76            .map(|row| tuple(&row))
77            .transpose()?;
78        let Some(current) = current
79            .filter(|current| current.oid == before.oid && current.object_id == before.object_id)
80        else {
81            return Err(concurrent_tuple("deleted"));
82        };
83        if current.revision != before.revision {
84            return Err(concurrent_tuple("updated"));
85        }
86        Ok(())
87    }
88}
89
90/// Re-resolve names and authority after each wait before retaining the selected lifetime.
91pub(super) fn bind_namespace_lifetime<T>(
92    objects: &dyn SharedObjectLockSession,
93    mode: RelationLockMode,
94    mut resolve: impl FnMut() -> Result<Option<(SchemaTupleIdentity, T)>, SQLError>,
95) -> Result<Option<T>, SQLError> {
96    loop {
97        let Some((before, _)) = resolve()? else {
98            return Ok(None);
99        };
100        let guard = objects.acquire_shared_catalog(
101            SharedCatalogLock::Object {
102                class_id: SCHEMA_CATALOG_CLASS_ID,
103                oid: u32::try_from(before.oid).expect("validated schema OID"),
104            },
105            mode,
106        )?;
107        objects.refresh_shared_catalog()?;
108        let Some((current, value)) = resolve()? else {
109            return Ok(None);
110        };
111        if current.oid != before.oid || current.object_id != before.object_id {
112            continue;
113        }
114        guard.retain();
115        return Ok(Some(value));
116    }
117}
118
119pub(super) fn tuple(security: &BoundSchemaSecurity) -> Result<SchemaTupleIdentity, SQLError> {
120    security
121        .tuple
122        .filter(|tuple| tuple.is_valid())
123        .ok_or_else(|| SQLError::Internal("schema has no valid catalog tuple identity".into()))
124}
125
126pub(super) fn missing(name: &str) -> SQLError {
127    SQLError::Routine {
128        sqlstate: "3F000".into(),
129        message: format!("schema \"{name}\" does not exist"),
130    }
131}
132
133fn concurrent_tuple(action: &str) -> SQLError {
134    SQLError::Routine {
135        sqlstate: "XX000".into(),
136        message: format!("tuple concurrently {action}"),
137    }
138}
139
140#[cfg(test)]
141mod tests;