Skip to main content

uqa_engine/capabilities/
table_locks.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind explicit relation locking to live catalogs and transaction-owned lock marks.
8
9use crate::Engine;
10use uqa_execution::{
11    row_locks::{
12        binding::{RelationDefinitionSession, RelationLockCatalog, RelationLockSession},
13        shared_objects::{SharedCatalogLock, SharedObjectLockSession},
14        RelationLockMode, ScopedRelationLock,
15    },
16    statement::table_locks::{
17        TableLockCatalog, TableLockContext, TableLockMetadata, TableLockSession,
18    },
19};
20use uqa_sql::catalog::roles::RoleReference;
21use uqa_sql::{
22    catalog::{resolution::RelationResolution, stored_view::StoredView},
23    SQLError,
24};
25
26impl Engine {
27    pub(crate) fn table_lock_context(&self) -> TableLockContext<'_> {
28        TableLockContext {
29            catalog: self,
30            roles: self,
31            session: self,
32        }
33    }
34}
35
36impl TableLockCatalog for Engine {
37    fn resolve(&self, name: &str, bound: bool) -> Result<RelationResolution, SQLError> {
38        if bound {
39            self.resolve_bound_relation_kind(name)
40        } else {
41            self.resolve_visible_relation_kind(name)
42        }
43    }
44
45    fn table(
46        &self,
47        name: &str,
48        _roles: &std::collections::BTreeMap<String, uqa_sql::catalog::roles::RoleDefinition>,
49    ) -> Result<Option<TableLockMetadata>, SQLError> {
50        let relation =
51            uqa_core::RelationIdentity::from_legacy_name(name).map_err(SQLError::Internal)?;
52        self.storage
53            .tables
54            .read()
55            .get(&relation)
56            .map(|table| {
57                Ok(TableLockMetadata {
58                    object_id: table.object_id(),
59                    security: table.security(),
60                })
61            })
62            .transpose()
63    }
64
65    fn view(&self, name: &str) -> Result<Option<StoredView>, SQLError> {
66        let relation =
67            uqa_core::RelationIdentity::from_legacy_name(name).map_err(SQLError::Internal)?;
68        Ok(self.durable.views.read().get(&relation).cloned())
69    }
70
71    fn descendants(&self, name: &str) -> Result<Vec<String>, SQLError> {
72        self.hierarchy_scan_tables(name, true)
73    }
74}
75
76impl TableLockSession for Engine {
77    fn in_transaction_block(&self) -> bool {
78        Engine::in_transaction_block(self)
79    }
80    fn current_role(&self) -> RoleReference {
81        self.current_role()
82    }
83}
84
85impl RelationLockSession for Engine {
86    fn acquire(
87        &self,
88        name: &str,
89        mode: RelationLockMode,
90        nowait: bool,
91    ) -> Result<Option<ScopedRelationLock<'_>>, SQLError> {
92        self.prepare_transaction_lock_wait()?;
93        let relation =
94            uqa_core::RelationIdentity::from_legacy_name(name).map_err(SQLError::Internal)?;
95        let identity = self
96            .durable
97            .catalog_indexes
98            .read()
99            .get(&relation)
100            .map(crate::catalog_indexes::index_definition)
101            .transpose()
102            .map_err(|error| {
103                uqa_sql::catalog::errors::storage_error("index lock identity", &error)
104            })?
105            .and_then(|definition| definition.catalog.map(|catalog| catalog.identity.object_id));
106        let table = identity.map_or_else(
107            || self.row_locks.table_key(name),
108            |identity| self.row_locks.index_key(identity),
109        );
110        let marks = self.temporary_relation_lock_marks()?;
111        if nowait {
112            self.row_locks.try_acquire_scoped_relation(
113                self.session_id,
114                table,
115                mode,
116                marks,
117                &self.runtime.cancellation,
118            )
119        } else {
120            self.row_locks
121                .acquire_scoped_relation(
122                    self.session_id,
123                    table,
124                    mode,
125                    marks,
126                    &self.runtime.cancellation,
127                )
128                .map(Some)
129        }
130    }
131    fn refresh_after_wait(&self) -> Result<(), SQLError> {
132        self.refresh_explicit_statement_snapshot()
133    }
134}
135
136impl RelationDefinitionSession for Engine {
137    fn prepare_definition_write(&self) -> Result<(), SQLError> {
138        self.prepare_explicit_transaction_writer().map(|_| ())
139    }
140}
141
142impl SharedObjectLockSession for Engine {
143    fn acquire_shared_catalog(
144        &self,
145        target: SharedCatalogLock<'_>,
146        mode: RelationLockMode,
147    ) -> Result<ScopedRelationLock<'_>, SQLError> {
148        self.prepare_transaction_lock_wait()?;
149        let key = self.row_locks.shared_catalog_key(target);
150        let marks = self.temporary_relation_lock_marks()?;
151        self.row_locks.acquire_scoped_relation(
152            self.session_id,
153            key,
154            mode,
155            marks,
156            &self.runtime.cancellation,
157        )
158    }
159
160    fn refresh_shared_catalog(&self) -> Result<(), SQLError> {
161        self.refresh_explicit_statement_snapshot()
162    }
163
164    fn next_catalog_oid(&self) -> Result<u32, SQLError> {
165        let durable = self
166            .storage
167            .backend
168            .as_ref()
169            .and_then(|backend| backend.identifier_allocator());
170        self.row_locks.catalog_oids().next_oid(durable, || {
171            let catalog = self.catalog_execution();
172            uqa_execution::catalog::projection::largest_catalog_oid(
173                &catalog.catalog_read_view(),
174                &catalog.session.relation_name_resolution(),
175            )
176        })
177    }
178}
179
180impl RelationLockCatalog for Engine {
181    fn relation_object_id(&self, name: &str) -> Result<Option<[u8; 16]>, SQLError> {
182        let relation =
183            uqa_core::RelationIdentity::from_legacy_name(name).map_err(SQLError::Internal)?;
184        if let Some(system) = uqa_sql::catalog::SystemRelation::at(&relation.schema, &relation.name)
185        {
186            return Ok(Some(system.object_id()));
187        }
188        if let Some(table) = self.storage.tables.read().get(&relation) {
189            return Ok(Some(table.object_id()));
190        }
191        if let Some(view) = self.durable.views.read().get(&relation) {
192            return Ok(Some(view.object_id));
193        }
194        if let Some(object_id) = self.durable.sequence_object_ids.read().get(&relation) {
195            return Ok(Some(*object_id));
196        }
197        if let Some(index) = self.durable.catalog_indexes.read().get(&relation) {
198            return crate::catalog_indexes::index_definition(index)
199                .map(|definition| definition.catalog.map(|catalog| catalog.identity.object_id))
200                .map_err(|error| {
201                    uqa_sql::catalog::errors::storage_error("index lock identity", &error)
202                });
203        }
204        Ok(self
205            .durable
206            .foreign_tables
207            .read()
208            .get(&relation)
209            .map(|table| table.object_id))
210    }
211    fn relation_catalog_oid(&self, name: &str) -> Result<Option<u32>, SQLError> {
212        let relation =
213            uqa_core::RelationIdentity::from_legacy_name(name).map_err(SQLError::Internal)?;
214        if let Some(table) = self.storage.tables.read().get(&relation) {
215            return Ok(Some(table.relation_oids().relation));
216        }
217        if let Some(view) = self.durable.views.read().get(&relation) {
218            return Ok(Some(view.relation_oids().relation));
219        }
220        Ok(self
221            .durable
222            .foreign_tables
223            .read()
224            .get(&relation)
225            .map(|table| table.relation_oids().relation))
226    }
227    fn table_name(&self, object_id: [u8; 16]) -> Option<String> {
228        self.storage.tables.read().iter().find_map(|(name, table)| {
229            (table.object_id() == object_id).then(|| name.qualified_name())
230        })
231    }
232    fn relation_name(&self, object_id: [u8; 16]) -> Option<String> {
233        self.table_name(object_id)
234            .or_else(|| {
235                self.durable.views.read().iter().find_map(|(name, view)| {
236                    (view.object_id == object_id).then(|| name.qualified_name())
237                })
238            })
239            .or_else(|| {
240                self.durable
241                    .sequence_object_ids
242                    .read()
243                    .iter()
244                    .find_map(|(name, id)| (*id == object_id).then(|| name.qualified_name()))
245            })
246            .or_else(|| {
247                self.durable
248                    .foreign_tables
249                    .read()
250                    .iter()
251                    .find_map(|(name, table)| {
252                        (table.object_id == object_id).then(|| name.qualified_name())
253                    })
254            })
255    }
256}