1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
//! Defines the [`Statement`] type, which represents an unprepared CQL statement.
use super::{PageSize, StatementConfig};
use crate::client::execution_profile::ExecutionProfileHandle;
use crate::frame::types::{Consistency, SerialConsistency};
use crate::observability::history::HistoryListener;
use crate::policies::load_balancing::LoadBalancingPolicy;
use crate::policies::retry::RetryPolicy;
use std::sync::Arc;
use std::time::Duration;
/// **Unprepared** CQL statement.
///
/// This represents a CQL statement that can be executed on a server.
#[derive(Clone)]
pub struct Statement {
pub(crate) config: StatementConfig,
/// The CQL statement text.
pub contents: String,
page_size: PageSize,
}
impl Statement {
/// Creates a new [`Statement`] from a CQL statement string.
pub fn new(query_text: impl Into<String>) -> Self {
Self {
contents: query_text.into(),
page_size: PageSize::default(),
config: Default::default(),
}
}
/// Returns self with page size set to the given value.
///
/// Panics if given number is nonpositive.
pub fn with_page_size(mut self, page_size: i32) -> Self {
self.set_page_size(page_size);
self
}
/// Sets the page size for this CQL statement.
///
/// Panics if given number is nonpositive.
pub fn set_page_size(&mut self, page_size: i32) {
self.page_size = page_size
.try_into()
.unwrap_or_else(|err| panic!("Query::set_page_size: {err}"));
}
/// Returns the page size for this CQL statement.
pub(crate) fn get_validated_page_size(&self) -> PageSize {
self.page_size
}
/// Returns the page size for this CQL statement.
pub fn get_page_size(&self) -> i32 {
self.page_size.inner()
}
/// Sets the consistency to be used when executing this statement.
pub fn set_consistency(&mut self, c: Consistency) {
self.config.consistency = Some(c);
}
/// Unsets the consistency overridden on this statement.
/// This means that consistency will be derived from the execution profile
/// (per-statement or, if absent, the default one).
pub fn unset_consistency(&mut self) {
self.config.consistency = None;
}
/// Gets the consistency to be used when executing this statement if it is filled.
/// If this is empty, the default_consistency of the session will be used.
pub fn get_consistency(&self) -> Option<Consistency> {
self.config.consistency
}
/// Sets the serial consistency to be used when executing this statement.
/// (Ignored unless the statement is an LWT)
pub fn set_serial_consistency(&mut self, sc: Option<SerialConsistency>) {
self.config.serial_consistency = Some(sc);
}
/// Unsets the serial consistency overridden on this statement.
/// This means that serial consistency will be derived from the execution profile
/// (per-statement or, if absent, the default one).
pub fn unset_serial_consistency(&mut self) {
self.config.serial_consistency = None;
}
/// Gets the serial consistency to be used when executing this statement.
/// (Ignored unless the statement is an LWT)
pub fn get_serial_consistency(&self) -> Option<SerialConsistency> {
self.config.serial_consistency.flatten()
}
/// Sets the idempotence of this statement
/// A statement is idempotent if it can be applied multiple times without changing the result of the initial application
/// If set to `true` we can be sure that it is idempotent
/// If set to `false` it is unknown whether it is idempotent
/// This is used in [`RetryPolicy`] to decide if retrying a statement execution is safe
pub fn set_is_idempotent(&mut self, is_idempotent: bool) {
self.config.is_idempotent = is_idempotent;
}
/// Gets the idempotence of this statement
pub fn get_is_idempotent(&self) -> bool {
self.config.is_idempotent
}
/// Enable or disable CQL Tracing for this statement
/// If enabled session.query() will return a QueryResult containing tracing_id
/// which can be used to query tracing information about the execution of this query
pub fn set_tracing(&mut self, should_trace: bool) {
self.config.tracing = should_trace;
}
/// Gets whether tracing is enabled for this statement
pub fn get_tracing(&self) -> bool {
self.config.tracing
}
/// Sets the default timestamp for this statement in microseconds.
/// If not None, it will replace the server side assigned timestamp as default timestamp
/// If a statement contains a `USING TIMESTAMP` clause, calling this method won't change
/// anything
pub fn set_timestamp(&mut self, timestamp: Option<i64>) {
self.config.timestamp = timestamp
}
/// Gets the default timestamp for this statement in microseconds.
pub fn get_timestamp(&self) -> Option<i64> {
self.config.timestamp
}
/// Sets the client-side timeout for this statement.
/// If not None, the driver will stop waiting for the request
/// to finish after `timeout` passed.
/// Otherwise, execution profile timeout will be applied.
pub fn set_request_timeout(&mut self, timeout: Option<Duration>) {
self.config.request_timeout = timeout
}
/// Gets client timeout associated with this statement.
pub fn get_request_timeout(&self) -> Option<Duration> {
self.config.request_timeout
}
/// Set the retry policy for this statement, overriding the one from execution profile if not None.
#[inline]
pub fn set_retry_policy(&mut self, retry_policy: Option<Arc<dyn RetryPolicy>>) {
self.config.retry_policy = retry_policy;
}
/// Get the retry policy set for the statement.
///
/// This method returns the retry policy that is **overridden** on this statement.
/// In other words, it returns the retry policy set using [`Statement::set_retry_policy`].
/// This does not take the retry policy from the set execution profile into account.
#[inline]
pub fn get_retry_policy(&self) -> Option<&Arc<dyn RetryPolicy>> {
self.config.retry_policy.as_ref()
}
/// Set the load balancing policy for this statement, overriding the one from execution profile if not None.
#[inline]
pub fn set_load_balancing_policy(
&mut self,
load_balancing_policy: Option<Arc<dyn LoadBalancingPolicy>>,
) {
self.config.load_balancing_policy = load_balancing_policy;
}
/// Get the load balancing policy set for the statement.
///
/// This method returns the load balancing policy that is **overridden** on this statement.
/// In other words, it returns the load balancing policy set using [`Statement::set_load_balancing_policy`].
/// This does not take the load balancing policy from the set execution profile into account.
#[inline]
pub fn get_load_balancing_policy(&self) -> Option<&Arc<dyn LoadBalancingPolicy>> {
self.config.load_balancing_policy.as_ref()
}
/// Sets the listener capable of listening what happens during statement execution.
pub fn set_history_listener(&mut self, history_listener: Arc<dyn HistoryListener>) {
self.config.history_listener = Some(history_listener);
}
/// Removes the listener set by `set_history_listener`.
pub fn remove_history_listener(&mut self) -> Option<Arc<dyn HistoryListener>> {
self.config.history_listener.take()
}
/// Associates the query with execution profile referred by the provided handle.
/// Handle may be later remapped to another profile, and query will reflect those changes.
pub fn set_execution_profile_handle(&mut self, profile_handle: Option<ExecutionProfileHandle>) {
self.config.execution_profile_handle = profile_handle;
}
/// Borrows the execution profile handle associated with this statement.
pub fn get_execution_profile_handle(&self) -> Option<&ExecutionProfileHandle> {
self.config.execution_profile_handle.as_ref()
}
}
impl From<String> for Statement {
fn from(s: String) -> Statement {
Statement::new(s)
}
}
impl<'a> From<&'a str> for Statement {
fn from(s: &'a str) -> Statement {
Statement::new(s.to_owned())
}
}