uqa_engine/capabilities/
sequence_values.rs1use 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 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 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}