cdrs 2.2.0

Cassandra DB driver written in Rust
Documentation 
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

use super::{QueryFlags, QueryParams, QueryValues};
use crate::consistency::Consistency;
use crate::types::CBytes;

#[derive(Debug, Default)]
pub struct QueryParamsBuilder {
  consistency: Consistency,
  flags: Option<Vec<QueryFlags>>,
  values: Option<QueryValues>,
  with_names: Option<bool>,
  page_size: Option<i32>,
  paging_state: Option<CBytes>,
  serial_consistency: Option<Consistency>,
  timestamp: Option<i64>,
}

impl QueryParamsBuilder {
  /// Factory function that returns new `QueryBuilder`.
  /// Default consistency level is `One`
  pub fn new() -> QueryParamsBuilder {
    Default::default()
  }

  /// Sets new query consistency
  pub fn consistency(mut self, consistency: Consistency) -> Self {
    self.consistency = consistency;

    self
  }

  /// Sets new flags.
  builder_opt_field!(flags, Vec<QueryFlags>);

  /// Sets new values.
  /// Sets new query consistency
  pub fn values(mut self, values: QueryValues) -> Self {
    let with_names = values.with_names();
    self.with_names = Some(with_names);
    self.values = Some(values);
    self.flags = self.flags.or(Some(vec![])).map(|mut flags| {
      flags.push(QueryFlags::Value);
      if with_names {
        flags.push(QueryFlags::WithNamesForValues);
      }
      flags
    });

    self
  }

  /// Sets new with_names parameter value.
  builder_opt_field!(with_names, bool);

  /// Sets new values.
  /// Sets new query consistency
  pub fn page_size(mut self, size: i32) -> Self {
    self.page_size = Some(size);
    self.flags = self.flags.or(Some(vec![])).map(|mut flags| {
      flags.push(QueryFlags::PageSize);
      flags
    });

    self
  }

  /// Sets new values.
  /// Sets new query consistency
  pub fn paging_state(mut self, state: CBytes) -> Self {
    self.paging_state = Some(state);
    self.flags = self.flags.or(Some(vec![])).map(|mut flags| {
      flags.push(QueryFlags::WithPagingState);
      flags
    });

    self
  }

  /// Sets new serial_consistency value.
  builder_opt_field!(serial_consistency, Consistency);

  /// Sets new timestamp value.
  builder_opt_field!(timestamp, i64);

  /// Finalizes query building process and returns query itself
  pub fn finalize(self) -> QueryParams {
    QueryParams {
      consistency: self.consistency,
      flags: self.flags.unwrap_or(vec![]),
      values: self.values,
      with_names: self.with_names,
      page_size: self.page_size,
      paging_state: self.paging_state,
      serial_consistency: self.serial_consistency,
      timestamp: self.timestamp,
    }
  }
}