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 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 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}