cdrs 2.3.3

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