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        // Query workers already belong to the caller's transaction and must not reenter its thread-owned statement gate.
103        if self.transaction_depth() != 0 {
104            self.ensure_transaction_usable()?;
105            operation()
106        } else {
107            self.transaction_with_error(|_| operation(), SequenceValueError::from)
108        }
109    }
110
111    fn transaction_lock_mark(&self) -> u32 {
112        self.session
113            .transactions
114            .lock()
115            .first()
116            .map_or(0, |frame| frame.begin_lock_mark)
117    }
118}
119
120impl Engine {
121    /// 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.
122    pub(crate) fn shared_sequence_positions(
123        &self,
124    ) -> Option<&std::sync::Arc<crate::row_locks::RowLockManager>> {
125        (self.versioned_backend_transactions() && self.storage.provider.is_some())
126            .then_some(&self.row_locks)
127    }
128
129    pub(crate) fn sequence_value_context(&self) -> SequenceValueContext<'_> {
130        SequenceValueContext {
131            catalog: self.catalog_execution(),
132            locks: self,
133            transactions: self,
134            snapshots: self,
135            privileges: self.sequence_privilege_inquiry(),
136            runtime: self,
137            storage: self.storage.catalog.as_deref(),
138        }
139    }
140
141    fn with_sequence_value_session(
142        &self,
143        operation: impl FnOnce(SequenceValueContext<'_>) -> Result<i64, SequenceValueError>,
144    ) -> Result<i64, String> {
145        let _statement = self.lock_statement_gate();
146        let outside_statement = self
147            .runtime
148            .sql_execution_depth
149            .load(std::sync::atomic::Ordering::Relaxed)
150            == 0
151            && self.session.row_lock_statements.lock().is_empty();
152        if outside_statement && self.transaction_depth() != 0 {
153            self.ensure_transaction_usable()
154                .map_err(|error| error.to_string())?;
155            self.prepare_explicit_statement_snapshot(true)
156                .map_err(|error| error.to_string())?;
157        }
158        operation(self.sequence_value_context()).map_err(|error| error.to_string())
159    }
160
161    pub fn nextval(&self, name: &str) -> Result<i64, String> {
162        self.with_sequence_value_session(|values| values.nextval(name))
163    }
164    pub(crate) fn nextval_sql(&self, name: &str) -> Result<i64, SQLError> {
165        self.sequence_value_context()
166            .nextval(name)
167            .map_err(SequenceValueError::into_sql_error)
168    }
169    pub fn currval(&self, name: &str) -> Result<i64, String> {
170        self.with_sequence_value_session(|values| values.currval(name))
171    }
172    pub(crate) fn currval_sql(&self, name: &str) -> Result<i64, SQLError> {
173        self.sequence_value_context()
174            .currval(name)
175            .map_err(SequenceValueError::into_sql_error)
176    }
177    pub fn lastval(&self) -> Result<i64, String> {
178        self.with_sequence_value_session(|values| values.lastval())
179    }
180    pub(crate) fn lastval_sql(&self) -> Result<i64, SQLError> {
181        self.sequence_value_context()
182            .lastval()
183            .map_err(SequenceValueError::into_sql_error)
184    }
185    pub fn setval(&self, name: &str, value: i64) -> Result<i64, String> {
186        self.setval_with_is_called(name, value, true)
187    }
188    pub fn setval_with_is_called(
189        &self,
190        name: &str,
191        value: i64,
192        is_called: bool,
193    ) -> Result<i64, String> {
194        self.with_sequence_value_session(|values| values.setval(name, value, is_called))
195    }
196    pub(crate) fn setval_sql(
197        &self,
198        name: &str,
199        value: i64,
200        is_called: bool,
201    ) -> Result<i64, SQLError> {
202        self.sequence_value_context()
203            .setval(name, value, is_called)
204            .map_err(SequenceValueError::into_sql_error)
205    }
206}