Skip to main content

uqa_engine/capabilities/
sequence_values.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind native sequence values to actual Engine session and catalog guards.
8use crate::{
9    Engine, NontransactionalSequenceValue, SessionLastSequenceReference, SessionSequenceValue,
10    SessionStateSnapshot,
11};
12use std::collections::BTreeMap;
13use uqa_core::RelationIdentity;
14use uqa_execution::catalog::sequence::values::context::{
15    SequenceCachesWrite, SequenceSessionRead, SequenceSessionWrite, SequenceStatesWrite,
16    SequenceValueContext, SequenceValueOperation, SequenceValueRuntime, SequenceValueTransactions,
17};
18use uqa_sql::{catalog::sequence_functions::value_error::SequenceValueError, SQLError};
19use uqa_storage::{PersistentStorageSession, StorageBackendResult};
20struct SessionRead<'a>(parking_lot::RwLockReadGuard<'a, SessionStateSnapshot>);
21struct SessionWrite<'a>(crate::state::SessionStateWriteGuard<'a>);
22impl SequenceSessionRead for SessionRead<'_> {
23    fn currvals(&self) -> &BTreeMap<RelationIdentity, SessionSequenceValue> {
24        &self.0.sequence_currvals
25    }
26    fn last(&self) -> Option<&SessionLastSequenceReference> {
27        self.0.last_sequence.as_ref()
28    }
29}
30impl SequenceSessionWrite for SessionWrite<'_> {
31    fn currvals_mut(&mut self) -> &mut BTreeMap<RelationIdentity, SessionSequenceValue> {
32        &mut self.0.sequence_currvals
33    }
34    fn last_mut(&mut self) -> &mut Option<SessionLastSequenceReference> {
35        &mut self.0.last_sequence
36    }
37}
38impl SequenceValueRuntime for Engine {
39    fn cancellation(&self) -> &uqa_core::CancellationToken {
40        &self.runtime.cancellation
41    }
42    fn states_write(&self) -> SequenceStatesWrite<'_> {
43        Box::new(self.durable.sequences.write())
44    }
45    fn caches(&self) -> SequenceCachesWrite<'_> {
46        Box::new(self.session.sequence_caches.lock())
47    }
48    fn session_read(&self) -> Box<dyn SequenceSessionRead + '_> {
49        Box::new(SessionRead(self.session.state.read()))
50    }
51    fn session_write(&self) -> Box<dyn SequenceSessionWrite + '_> {
52        Box::new(SessionWrite(self.session.state.write()))
53    }
54    fn current_transaction_is_read_only(&self) -> bool {
55        Engine::current_transaction_is_read_only(self)
56    }
57    fn require_sequence_value_durability(&self) -> StorageBackendResult<()> {
58        self.storage.backend.as_ref().map_or(Ok(()), |backend| {
59            backend.require_sequence_value_durability()
60        })
61    }
62    fn open_nontransactional_sequence_session(
63        &self,
64    ) -> StorageBackendResult<Option<PersistentStorageSession>> {
65        if self.versioned_backend_transactions() {
66            return self
67                .storage
68                .backend
69                .as_ref()
70                .map(|backend| backend.open_sequence_value_session(&self.runtime.cancellation))
71                .transpose();
72        }
73        Engine::open_independent_catalog_session(self, Some(&self.runtime.cancellation))
74    }
75    fn prepare_explicit_transaction_writer(&self) -> Result<(), SQLError> {
76        self.prepare_transaction_writer().map(|_| ())
77    }
78    fn sequence_positions(&self) -> Option<&crate::row_locks::RowLockManager> {
79        self.shared_sequence_positions()
80            .map(|positions| &**positions)
81    }
82    fn record_nontransactional_sequence_value(
83        &self,
84        definition_generation: [u8; 16],
85        value: NontransactionalSequenceValue,
86        defines_lastval: bool,
87    ) {
88        Engine::record_nontransactional_sequence_value(
89            self,
90            definition_generation,
91            value,
92            defines_lastval,
93        );
94    }
95}
96
97impl SequenceValueTransactions for Engine {
98    fn with_value_transaction(
99        &self,
100        operation: SequenceValueOperation<'_>,
101    ) -> Result<i64, SequenceValueError> {
102        // SQL workers run inside the parent statement's admitted operation. Its owner receives their errors and unwinds only after execution joins them; a worker must neither reenter the statement gate nor roll back a transaction still used by its siblings. Direct value calls enter that same ownership boundary in with_sequence_value_session.
103        if self.transaction_depth() != 0 {
104            operation()
105        } else {
106            self.transaction_with_error(|_| operation(), SequenceValueError::from)
107        }
108    }
109
110    fn transaction_lock_mark(&self) -> u32 {
111        self.session
112            .transactions
113            .lock()
114            .first()
115            .map_or(0, |frame| frame.begin_lock_mark)
116    }
117}
118
119impl Engine {
120    /// The store of exact sequence positions. Independent sessions allocate the values of persistent sequences only over a versioned backend, whose durable sequence records then run ahead of the values handed out.
121    pub(crate) fn shared_sequence_positions(
122        &self,
123    ) -> Option<&std::sync::Arc<crate::row_locks::RowLockManager>> {
124        (self.versioned_backend_transactions() && self.storage.provider.is_some())
125            .then_some(&self.row_locks)
126    }
127
128    pub(crate) fn sequence_value_context(&self) -> SequenceValueContext<'_> {
129        SequenceValueContext {
130            catalog: self.catalog_execution(),
131            locks: self,
132            transactions: self,
133            snapshots: self,
134            privileges: self.sequence_privilege_inquiry(),
135            runtime: self,
136            storage: self.storage.catalog.as_deref(),
137        }
138    }
139
140    fn with_sequence_value_session(
141        &self,
142        operation: impl FnOnce(SequenceValueContext<'_>) -> Result<i64, SequenceValueError>,
143    ) -> Result<i64, String> {
144        let _statement = self.lock_statement_gate();
145        let outside_statement = self
146            .runtime
147            .sql_execution_depth
148            .load(std::sync::atomic::Ordering::Relaxed)
149            == 0
150            && self.session.row_lock_statements.lock().is_empty();
151        let run = |engine: &Self| {
152            if outside_statement {
153                engine.prepare_explicit_statement_snapshot(true)?;
154            }
155            operation(engine.sequence_value_context())
156        };
157        let result = if self.transaction_depth() != 0 {
158            self.run_existing_transaction_operation(|| run(self), SequenceValueError::from)
159        } else {
160            self.transaction_with_error(run, SequenceValueError::from)
161        };
162        result.map_err(|error| error.to_string())
163    }
164
165    pub fn nextval(&self, name: &str) -> Result<i64, String> {
166        self.with_sequence_value_session(|values| values.nextval(name))
167    }
168    pub(crate) fn nextval_sql(&self, name: &str) -> Result<i64, SQLError> {
169        self.sequence_value_context()
170            .nextval(name)
171            .map_err(SequenceValueError::into_sql_error)
172    }
173    pub fn currval(&self, name: &str) -> Result<i64, String> {
174        self.with_sequence_value_session(|values| values.currval(name))
175    }
176    pub(crate) fn currval_sql(&self, name: &str) -> Result<i64, SQLError> {
177        self.sequence_value_context()
178            .currval(name)
179            .map_err(SequenceValueError::into_sql_error)
180    }
181    pub fn lastval(&self) -> Result<i64, String> {
182        self.with_sequence_value_session(|values| values.lastval())
183    }
184    pub(crate) fn lastval_sql(&self) -> Result<i64, SQLError> {
185        self.sequence_value_context()
186            .lastval()
187            .map_err(SequenceValueError::into_sql_error)
188    }
189    pub fn setval(&self, name: &str, value: i64) -> Result<i64, String> {
190        self.setval_with_is_called(name, value, true)
191    }
192    pub fn setval_with_is_called(
193        &self,
194        name: &str,
195        value: i64,
196        is_called: bool,
197    ) -> Result<i64, String> {
198        self.with_sequence_value_session(|values| values.setval(name, value, is_called))
199    }
200    pub(crate) fn setval_sql(
201        &self,
202        name: &str,
203        value: i64,
204        is_called: bool,
205    ) -> Result<i64, SQLError> {
206        self.sequence_value_context()
207            .setval(name, value, is_called)
208            .map_err(SequenceValueError::into_sql_error)
209    }
210}