Skip to main content

uqa_engine/capabilities/
sequence_removal.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind native sequence removal to the transaction and concrete registry/cache publication boundary.
8use crate::Engine;
9use uqa_execution::schema::sequences::removal::{
10    SequenceRemovalContext, SequenceRemovalInputs, SequenceRemovalPublication,
11};
12impl SequenceRemovalInputs for Engine {
13    fn sequence_removal_context(&self) -> SequenceRemovalContext<'_> {
14        Engine::sequence_removal_context(self)
15    }
16}
17impl Engine {
18    pub(crate) fn sequence_removal_context(&self) -> SequenceRemovalContext<'_> {
19        SequenceRemovalContext {
20            publication: self,
21            privileges: self.sequence_privilege_inquiry(),
22            dependencies: self.sequence_dependency_context(),
23        }
24    }
25    pub fn drop_sequence(&self, name: &str) -> Result<bool, String> {
26        self.with_implicit_definition_transaction(|engine| {
27            uqa_execution::schema::removal::direct::drop_sequence(
28                &engine.relation_removal_context(),
29                name,
30            )
31        })
32        .map_err(|error| error.to_string())
33    }
34}
35impl SequenceRemovalPublication for Engine {
36    fn remove_state(&self, name: &str) -> Result<bool, String> {
37        let relation = Self::resolved_relation_identity(name)
38            .map_err(|err| format!("resolve sequence `{name}`: {err}"))?;
39        let object_id = self
40            .durable
41            .sequence_object_ids
42            .read()
43            .get(&relation)
44            .copied()
45            .ok_or_else(|| format!("Sequence `{name}` has no object identity"))?;
46        let temporary = self
47            .durable
48            .sequence_persistence
49            .read()
50            .get(&relation)
51            .is_some_and(|persistence| {
52                *persistence == uqa_sql::ast::RelationPersistence::Temporary
53            });
54        let removed = if temporary {
55            self.durable.sequences.read().contains_key(&relation)
56        } else if let Some(catalog) = self.storage.catalog.as_ref() {
57            let removed = catalog
58                .drop_sequence_row(name)
59                .map_err(|err| format!("persist sequence catalog: {err}"))?;
60            if removed {
61                uqa_execution::catalog::sequence::catalog_oids::forget(
62                    catalog.as_ref(),
63                    &object_id,
64                )
65                .map_err(|err| format!("persist sequence catalog OID: {err}"))?;
66            }
67            removed
68        } else {
69            self.durable.sequences.read().contains_key(&relation)
70        };
71        if removed {
72            self.note_prepared_relation_change(&relation);
73            self.durable.sequences.write().remove(&relation);
74            self.durable.sequence_object_ids.write().remove(&relation);
75            self.durable
76                .sequence_catalog_oids
77                .write()
78                .remove(&object_id);
79            self.durable.sequence_persistence.write().remove(&relation);
80            self.durable.sequence_security.write().remove(&relation);
81            let mut session = self.session.state.write();
82            session
83                .sequence_currvals
84                .retain(|_, current| current.object_id != object_id);
85            if session
86                .last_sequence
87                .as_ref()
88                .is_some_and(|last| last.object_id == object_id)
89            {
90                session.last_sequence = None;
91            }
92            drop(session);
93            self.session
94                .sequence_caches
95                .lock()
96                .retain(|_, cache| cache.object_id != object_id);
97            self.note_catalog_registry_changed();
98        }
99        Ok(removed)
100    }
101}