rqlite_client 0.1.0

rqlite database client with optional extra convenience
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! `associative`

use std::collections::HashMap;

use crate::{response::mapping, DataType, Value};

use super::timed::Timed;

/// `Associative` result
///
/// ```json
/// {
///     "results": [
///         {
///             "types": {"id": "integer", "age": "integer", "name": "text"},
///             "rows": [
///                 { "id": 1, "age": 20, "name": "fiona"},
///                 { "id": 2, "age": 25, "name": "declan"}
///             ],
///             "time": 0.000173061
///         }
///     ],
///     "time": 0.000185964
/// }
/// ```
///
/// See <https://rqlite.io/docs/api/api/#associative-response-form>
///
#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct Associative {
    /// rows in key:value hashmap
    pub rows: Vec<HashMap<String, Value>>,
    /// optional timing info
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time: Option<f64>,
    /// description of column `DataType`
    pub types: HashMap<String, DataType>,
}

impl Timed for Associative {
    fn time(&self) -> Option<f64> {
        self.time
    }
}

impl From<mapping::Standard> for Associative {
    fn from(standard: mapping::Standard) -> Self {
        let columns = standard.columns;
        let mut v = Vec::new();
        let mut hm_typ = HashMap::new();

        if let Some(rows) = standard.values {
            for row in rows {
                let mut hm = HashMap::new();

                for (idx, column) in columns.iter().enumerate() {
                    if let Some(value) = row.get(idx) {
                        let _ = hm.insert(column.to_string(), value.clone());
                    }
                }
                v.push(hm);
            }

            for (idx, column) in columns.iter().enumerate() {
                if let Some(t) = standard.types.get(idx) {
                    let _ = hm_typ.insert(column.to_string(), *t);
                }
            }
        }

        Associative {
            rows: v,
            time: standard.time,
            types: hm_typ,
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{response::mapping, DataType};

    use super::Associative;

    #[test]
    fn standard_to_associativ_test() {
        let standard = mapping::Standard {
            columns: vec!["id".to_string(), "val".to_string()],
            time: None,
            types: vec![DataType::Text, DataType::Text],
            values: Some(vec![
                vec!["123456".into(), "value".into()],
                vec!["123456".into(), "value".into()],
                vec!["123456".into(), "value".into()],
            ]),
        };

        let associative = Associative::from(standard.clone());

        assert_eq!(associative.time, standard.time);
        assert_eq!(associative.rows.len(), standard.values.unwrap().len());
        let mut keys = associative.rows[0]
            .keys()
            .map(String::from)
            .collect::<Vec<String>>();
        keys.sort_unstable();
        let mut columns = standard.columns;
        columns.sort_unstable();
        assert_eq!(keys, columns);
    }
}