1use crate::{state::BoundSequenceSecurity, Engine, SequenceState};
9use uqa_core::RelationIdentity;
10use uqa_execution::schema::sequences::{
11 creation::{SequenceCreationContext, SequenceCreationNamespace, SequenceCreationPublication},
12 implicit::{ImplicitSequenceContext, ImplicitSequencePublication},
13};
14use uqa_sql::schema::sequences::ownership::{SequenceOwnerCatalog, SequenceOwnerColumns};
15use uqa_sql::{ast::RelationPersistence, SQLError};
16use uqa_storage::StorageBackendResult;
17
18impl Engine {
19 pub(crate) fn sequence_creation_context(&self) -> SequenceCreationContext<'_> {
20 SequenceCreationContext {
21 identities: self.catalog_identity_reservation_context(),
22 creation: self.relation_creation_context(),
23 namespace: self,
24 owners: self,
25 publication: self,
26 }
27 }
28 pub(crate) fn implicit_sequence_context(&self) -> ImplicitSequenceContext<'_> {
29 ImplicitSequenceContext {
30 namespace: self,
31 owners: self,
32 publication: self,
33 }
34 }
35}
36
37impl SequenceCreationNamespace for Engine {
38 fn refresh_sequences(&self) -> StorageBackendResult<()> {
39 self.refresh_sequences_from_catalog()
40 }
41 fn relation_exists(&self, name: &str) -> StorageBackendResult<bool> {
42 self.relation_kind_at(name).map(|kind| kind.is_some())
43 }
44}
45impl ImplicitSequencePublication for Engine {
46 fn create_implicit_sequence(
47 &self,
48 name: &str,
49 state: SequenceState,
50 persistence: RelationPersistence,
51 ) -> Result<(), SQLError> {
52 self.create_implicit_sequence_with_persistence(name, state, persistence)
53 }
54}
55impl SequenceOwnerCatalog for Engine {
56 fn resolve_owner_relation(
57 &self,
58 name: &str,
59 ) -> Result<Option<(String, &'static str)>, SQLError> {
60 self.try_resolve_visible_relation_kind(name)
61 }
62 fn owner_table_columns(
63 &self,
64 canonical: &str,
65 ) -> Result<Option<SequenceOwnerColumns>, SQLError> {
66 self.try_table(canonical)
67 .map_err(|error| SQLError::Internal(format!("load table `{canonical}`: {error}")))
68 .map(|table| table.map(|table| (table.object_id(), table.columns.read().clone())))
69 }
70 fn owner_foreign_columns(&self, relation: &RelationIdentity) -> Option<SequenceOwnerColumns> {
71 self.durable
72 .foreign_tables
73 .read()
74 .get(relation)
75 .map(|table| (table.object_id, table.columns.clone()))
76 }
77}
78impl SequenceCreationPublication for Engine {
79 fn insert_sequence(
80 &self,
81 name: &str,
82 relation: &RelationIdentity,
83 mut state: SequenceState,
84 persistence: RelationPersistence,
85 role_owner: uqa_core::catalog_role::RoleIdentity,
86 catalog_oid: u32,
87 ) -> Result<bool, SQLError> {
88 let security = BoundSequenceSecurity::owner(role_owner);
89 let object_id = crate::new_sequence_object_id().map_err(|error| {
90 SQLError::Internal(format!("allocate sequence `{name}` identity: {error}"))
91 })?;
92 state.definition_generation = object_id;
93 if persistence == RelationPersistence::Temporary {
94 let seqs = self.durable.sequences.read();
95 if seqs.contains_key(relation) {
96 return Ok(false);
97 }
98 } else if let Some(catalog) = self.storage.catalog.as_ref() {
99 let created = catalog
100 .create_sequence_row(
101 &Self::sequence_row(name, object_id, state, persistence, &security).map_err(
102 |error| SQLError::Internal(format!("build sequence catalog row: {error}")),
103 )?,
104 )
105 .map_err(|error| {
106 SQLError::Internal(format!("persist sequence catalog: {error}"))
107 })?;
108 if !created {
109 return Ok(false);
110 }
111 uqa_execution::catalog::sequence::catalog_oids::record(
112 catalog.as_ref(),
113 &object_id,
114 catalog_oid,
115 )
116 .map_err(|error| {
117 SQLError::Internal(format!("persist sequence catalog OID: {error}"))
118 })?;
119 } else {
120 let seqs = self.durable.sequences.read();
121 if seqs.contains_key(relation) {
122 return Ok(false);
123 }
124 }
125 self.durable
126 .sequences
127 .write()
128 .insert(relation.clone(), state);
129 self.durable
130 .sequence_object_ids
131 .write()
132 .insert(relation.clone(), object_id);
133 self.durable
134 .sequence_catalog_oids
135 .write()
136 .insert(object_id, catalog_oid);
137 self.durable
138 .sequence_persistence
139 .write()
140 .insert(relation.clone(), persistence);
141 self.durable
142 .sequence_security
143 .write()
144 .insert(relation.clone(), security);
145 self.note_catalog_registry_changed();
146 self.note_prepared_catalog_change(
147 uqa_execution::statement::prepared::invalidation::PreparedCatalogChange::Relation(
148 catalog_oid,
149 ),
150 );
151 Ok(true)
152 }
153}
154
155impl Engine {
156 pub(crate) fn implicit_ownership_context(
157 &self,
158 ) -> uqa_execution::schema::sequences::ownership::ImplicitOwnershipContext<'_> {
159 uqa_execution::schema::sequences::ownership::ImplicitOwnershipContext {
160 owners: self,
161 names: self,
162 tables: self,
163 publication: self,
164 }
165 }
166}
167impl uqa_sql::schema::sequences::implicit_ownership::StoredSequenceNames for Engine {
168 fn stored_sequence_name(&self, reference: &str) -> Result<String, String> {
169 self.resolve_stored_sequence_reference_from_loaded_registry(reference)
170 .map_err(|error| error.to_string())
171 }
172}
173impl uqa_execution::schema::sequences::ownership::ImplicitOwnerTables for Engine {
174 fn table_owner_columns(
175 &self,
176 table: &str,
177 ) -> StorageBackendResult<Option<([u8; 16], Vec<uqa_sql::ast::ColumnDef>)>> {
178 self.try_table(table)
179 .map(|table| table.map(|table| (table.object_id(), table.columns.read().clone())))
180 }
181}
182impl uqa_execution::schema::sequences::ownership::ImplicitOwnerPublication for Engine {
183 fn attach_owner(
184 &self,
185 sequence: &str,
186 owner: uqa_storage::SequenceOwner,
187 ) -> Result<(), SQLError> {
188 self.attach_sequence_owner_identity(sequence, owner)
189 }
190}
191
192impl uqa_sql::schema::sequences::lifecycle::SequenceLifecycleCatalog for Engine {
193 fn temporary_schema_name(&self) -> String {
194 Engine::temporary_schema_name(self)
195 }
196 fn sequence_is_owned(&self, relation: &RelationIdentity) -> bool {
197 self.durable
198 .sequences
199 .read()
200 .get(relation)
201 .is_some_and(|state| state.owner.is_some())
202 }
203 fn relation_kind_at(&self, name: &str) -> Result<Option<&'static str>, String> {
204 Engine::relation_kind_at(self, name).map_err(|error| error.to_string())
205 }
206}
207impl uqa_sql::schema::sequences::names::StoredSequenceRegistry for Engine {
208 fn contains_sequence(&self, relation: &RelationIdentity) -> bool {
209 self.durable.sequences.read().contains_key(relation)
210 }
211 fn sequence_names(&self) -> Vec<RelationIdentity> {
212 self.durable.sequences.read().keys().cloned().collect()
213 }
214}
215
216impl Engine {
217 pub(crate) fn sequence_definition_context(
218 &self,
219 ) -> uqa_execution::schema::sequences::alteration::SequenceDefinitionContext<'_> {
220 uqa_execution::schema::sequences::alteration::SequenceDefinitionContext {
221 catalog: self,
222 owners: self,
223 publication: self,
224 markers: self.schema_dependency_publication_context(),
225 new_generation: crate::new_sequence_definition_generation,
226 }
227 }
228}
229impl uqa_execution::schema::sequences::alteration::SequenceDefinitionCatalog for Engine {
230 fn object_id(&self, relation: &RelationIdentity) -> Option<[u8; 16]> {
231 self.durable
232 .sequence_object_ids
233 .read()
234 .get(relation)
235 .copied()
236 }
237 fn state(&self, relation: &RelationIdentity) -> Result<Option<SequenceState>, SQLError> {
238 let Some(state) = self.durable.sequences.read().get(relation).copied() else {
239 return Ok(None);
240 };
241 let object_id = self
242 .durable
243 .sequence_object_ids
244 .read()
245 .get(relation)
246 .copied();
247 let (Some(positions), Some(object_id)) = (self.shared_sequence_positions(), object_id)
248 else {
249 return Ok(Some(state));
250 };
251 Ok(Some(state.at_position(
252 positions.sequence_position(state.position_key(object_id))?,
253 )))
254 }
255 fn owner_target(&self, owner: uqa_storage::SequenceOwner) -> Option<(String, String, bool)> {
256 self.sequence_owner_target(owner)
257 }
258}
259impl uqa_execution::schema::sequences::alteration::SequenceDefinitionPublication for Engine {
260 fn replace_sequence(
261 &self,
262 name: &str,
263 relation: &RelationIdentity,
264 object_id: [u8; 16],
265 persistence: RelationPersistence,
266 state: SequenceState,
267 invalidate_current_cache: bool,
268 ) -> Result<(), SQLError> {
269 self.persist_sequence_state_replacement(
270 name,
271 relation,
272 object_id,
273 persistence,
274 state,
275 invalidate_current_cache,
276 )
277 }
278}
279
280impl Engine {
281 pub(crate) fn sequence_role_ownership_context(
282 &self,
283 ) -> uqa_execution::schema::sequences::role_ownership::SequenceRoleOwnershipContext<'_> {
284 uqa_execution::schema::sequences::role_ownership::SequenceRoleOwnershipContext {
285 locks: self,
286 writer: self,
287 roles: self,
288 session: self,
289 schemas: self,
290 metadata: self,
291 security: self,
292 changes: self,
293 }
294 }
295}
296impl uqa_execution::schema::sequences::role_ownership::SequenceSecurityPublication for Engine {
297 fn security(&self, relation: &RelationIdentity) -> Option<BoundSequenceSecurity> {
298 self.durable.sequence_security.read().get(relation).cloned()
299 }
300 fn persist_security(
301 &self,
302 name: &str,
303 relation: &RelationIdentity,
304 security: &BoundSequenceSecurity,
305 ) -> Result<(), SQLError> {
306 self.persist_sequence_security(name, relation, security)
307 }
308 fn publish_security(&self, relation: &RelationIdentity, security: BoundSequenceSecurity) {
309 self.durable
310 .sequence_security
311 .write()
312 .insert(relation.clone(), security);
313 self.note_prepared_relation_change(relation);
314 }
315}
316
317impl Engine {
318 pub(crate) fn sequence_lifecycle_context(
319 &self,
320 ) -> uqa_execution::schema::sequences::lifecycle::SequenceLifecycleContext<'_> {
321 uqa_execution::schema::sequences::lifecycle::SequenceLifecycleContext {
322 analysis: self,
323 creation: self.relation_creation_context(),
324 schemas: self.schema_dependency_publication_context(),
325 views: self.view_sequence_rewrite_context(),
326 state: self,
327 catalog: self,
328 events: self.event_catalog_context(),
329 changes: self,
330 }
331 }
332 pub(crate) fn sequence_alter_context(
333 &self,
334 ) -> uqa_execution::schema::sequences::dispatch::SequenceAlterContext<'_> {
335 uqa_execution::schema::sequences::dispatch::SequenceAlterContext {
336 catalog: self,
337 authority: self.table_privilege_context(),
338 definition: self.sequence_definition_context(),
339 roles: self.sequence_role_ownership_context(),
340 lifecycle: self.sequence_lifecycle_context(),
341 }
342 }
343}
344impl uqa_execution::schema::sequences::entry::SequenceCreationTransactions for Engine {
345 fn with_sequence_creation(
346 &self,
347 write: uqa_execution::schema::sequences::entry::SequenceCreationWrite<'_>,
348 ) -> Result<bool, SQLError> {
349 self.with_implicit_transaction(|engine| write(&engine.sequence_creation_context()))
350 }
351}
352impl uqa_execution::schema::sequences::entry::SequenceAlterTransactions for Engine {
353 fn with_sequence_write(
354 &self,
355 write: uqa_execution::schema::sequences::entry::SequenceAlterWrite<'_>,
356 ) -> Result<bool, SQLError> {
357 self.with_implicit_transaction(|engine| write(&engine.sequence_alter_context()))
358 }
359}
360impl uqa_execution::schema::sequences::lifecycle::SequenceStateRename for Engine {
361 fn move_state(
362 &self,
363 source: &RelationIdentity,
364 target: &RelationIdentity,
365 ) -> Result<(), SQLError> {
366 self.move_sequence_state(source, target)?;
367 self.note_prepared_relation_change(target);
368 Ok(())
369 }
370}
371impl uqa_execution::schema::sequences::lifecycle::SequenceRenameCatalog for Engine {
372 fn has_catalog(&self) -> bool {
373 self.storage.catalog.is_some()
374 }
375 fn rename_sequence_row(&self, source: &str, target: &str) -> StorageBackendResult<bool> {
376 let renamed = self.storage.catalog.as_ref().map_or(Ok(false), |catalog| {
377 catalog.rename_sequence_row(source, target)
378 })?;
379 if renamed {
380 let relation = RelationIdentity::from_legacy_name(source)
381 .map_err(uqa_storage::StorageBackendError::Other)?;
382 self.note_prepared_relation_change(&relation);
383 }
384 Ok(renamed)
385 }
386}
387impl uqa_execution::schema::sequences::dispatch::SequenceCommandCatalog for Engine {
388 fn resolve_visible_relation(
389 &self,
390 name: &str,
391 ) -> Result<uqa_sql::catalog::resolution::RelationResolution, SQLError> {
392 self.resolve_visible_relation_kind(name)
393 }
394 fn sequence_persistence(&self, relation: &RelationIdentity) -> RelationPersistence {
395 self.durable
396 .sequence_persistence
397 .read()
398 .get(relation)
399 .copied()
400 .unwrap_or_default()
401 }
402}