uqa_execution/schema/namespaces/
locking.rs1use 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 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 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
90pub(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;