cdrs_async/query/
query_params.rs

1use cassandra_proto::{
2  consistency::Consistency,
3  frame::{AsByte, IntoBytes},
4  types::{to_bigint, to_int, to_short, CBytes},
5};
6
7use crate::query::query_flags::QueryFlags;
8use crate::query::query_values::QueryValues;
9
10/// Parameters of Query for query operation.
11#[derive(Debug, Default)]
12pub struct QueryParams {
13  /// Cassandra consistency level.
14  pub consistency: Consistency,
15  /// Array of query flags.
16  pub flags: Vec<QueryFlags>,
17  /// Were values provided with names
18  pub with_names: Option<bool>,
19  /// Array of values.
20  pub values: Option<QueryValues>,
21  /// Page size.
22  pub page_size: Option<i32>,
23  /// Array of bytes which represents paging state.
24  pub paging_state: Option<CBytes>,
25  /// Serial `Consistency`.
26  pub serial_consistency: Option<Consistency>,
27  /// Timestamp.
28  pub timestamp: Option<i64>,
29}
30
31impl QueryParams {
32  /// Sets values of Query request params.
33  pub fn set_values(&mut self, values: QueryValues) {
34    self.flags.push(QueryFlags::Value);
35    self.values = Some(values);
36  }
37
38  fn flags_as_byte(&self) -> u8 {
39    self.flags.iter().fold(0, |acc, flag| acc | flag.as_byte())
40  }
41
42  #[allow(dead_code)]
43  fn parse_query_flags(byte: u8) -> Vec<QueryFlags> {
44    let mut flags: Vec<QueryFlags> = vec![];
45
46    if QueryFlags::has_value(byte) {
47      flags.push(QueryFlags::Value);
48    }
49    if QueryFlags::has_skip_metadata(byte) {
50      flags.push(QueryFlags::SkipMetadata);
51    }
52    if QueryFlags::has_page_size(byte) {
53      flags.push(QueryFlags::PageSize);
54    }
55    if QueryFlags::has_with_paging_state(byte) {
56      flags.push(QueryFlags::WithPagingState);
57    }
58    if QueryFlags::has_with_serial_consistency(byte) {
59      flags.push(QueryFlags::WithSerialConsistency);
60    }
61    if QueryFlags::has_with_default_timestamp(byte) {
62      flags.push(QueryFlags::WithDefaultTimestamp);
63    }
64    if QueryFlags::has_with_names_for_values(byte) {
65      flags.push(QueryFlags::WithNamesForValues);
66    }
67
68    flags
69  }
70}
71
72impl IntoBytes for QueryParams {
73  fn into_cbytes(&self) -> Vec<u8> {
74    let mut v: Vec<u8> = vec![];
75
76    v.extend_from_slice(self.consistency.into_cbytes().as_slice());
77    v.push(self.flags_as_byte());
78    if QueryFlags::has_value(self.flags_as_byte()) {
79      if let Some(ref values) = self.values {
80        v.extend_from_slice(to_short(values.len() as i16).as_slice());
81        v.extend_from_slice(values.into_cbytes().as_slice());
82      }
83    }
84    if QueryFlags::has_page_size(self.flags_as_byte()) && self.page_size.is_some() {
85      // XXX clone
86      v.extend_from_slice(
87        to_int(
88          self
89            .page_size
90            .clone()
91            // unwrap is safe as we've checked that
92            // self.page_size.is_some()
93            .unwrap(),
94        )
95        .as_slice(),
96      );
97    }
98    if QueryFlags::has_with_paging_state(self.flags_as_byte()) && self.paging_state.is_some() {
99      // XXX clone
100      v.extend_from_slice(
101        self
102          .paging_state
103          .clone()
104          // unwrap is safe as we've checked that
105          // self.paging_state.is_some()
106          .unwrap()
107          .into_cbytes()
108          .as_slice(),
109      );
110    }
111    if QueryFlags::has_with_serial_consistency(self.flags_as_byte())
112      && self.serial_consistency.is_some()
113    {
114      // XXX clone
115      v.extend_from_slice(
116        self
117          .serial_consistency
118          .clone()
119          // unwrap is safe as we've checked that
120          // self.serial_consistency.is_some()
121          .unwrap()
122          .into_cbytes()
123          .as_slice(),
124      );
125    }
126    if QueryFlags::has_with_default_timestamp(self.flags_as_byte()) && self.timestamp.is_some() {
127      // unwrap is safe as we've checked that self.timestamp.is_some()
128      v.extend_from_slice(to_bigint(self.timestamp.unwrap()).as_slice());
129    }
130
131    v
132  }
133}