Skip to main content

uqa_engine/capabilities/
sequences.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind sequence catalog consumers to session namespaces and durable registry state.
8use 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}