uqa_engine/capabilities/
table_locks.rs1use 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}