elastic_parser/aggregation/
mod.rs

1use crate::Hits;
2use serde::{Deserialize, Serialize};
3use serde_json::Value;
4
5#[derive(Debug, Default, Clone, Serialize, Deserialize)]
6pub struct AggregationResponseParser {
7    value: Value,
8}
9
10impl AggregationResponseParser {
11    pub fn new(value: Value) -> AggregationResponseParser {
12        AggregationResponseParser { value }
13    }
14    pub fn value(&self) -> Value {
15        self.value.clone()
16    }
17    pub fn doc_count(&self) -> Option<u64> {
18        parse_u32(self.value.get("doc_count"))
19    }
20    pub fn sum_other_doc_count(&self) -> Option<u64> {
21        parse_u32(self.value.get("sum_other_doc_count"))
22    }
23    pub fn sub_aggregation<T: Into<String>>(&self, key: T) -> Option<AggregationResponseParser> {
24        let agg = self.value.get(key.into())?.clone();
25        Some(AggregationResponseParser::new(agg))
26    }
27    pub fn buckets(&self) -> Option<Vec<AggregationResponseBucket>> {
28        let values = self.value.get("buckets")?.clone();
29        let values = values.as_array()?.clone();
30        let mut response = vec![];
31        for value in values {
32            response.push(AggregationResponseBucket::new(value))
33        }
34        Some(response)
35    }
36}
37
38#[derive(Debug, Default, Clone)]
39pub struct AggregationResponseBucket {
40    value: Value,
41}
42
43impl AggregationResponseBucket {
44    pub fn new(value: Value) -> AggregationResponseBucket {
45        AggregationResponseBucket { value }
46    }
47    pub fn value(&self) -> Value {
48        self.value.clone()
49    }
50    pub fn hits(&self) -> Option<Hits<Value>> {
51        let values = self.value.get("hits")?;
52        let hits = serde_json::from_value::<Hits<Value>>(values.clone());
53        if hits.is_err() {
54            return None;
55        }
56        return Some(hits.unwrap());
57    }
58    pub fn key(&self) -> Option<String> {
59        let key_as_string = self.value.get("key_as_string");
60        if key_as_string.is_some() {
61            let key_as_string = key_as_string.unwrap();
62            if key_as_string.is_string() {
63                return Some(key_as_string.as_str().unwrap().to_string());
64            }
65        }
66        let key = self.value.get("key");
67        if key.is_some() {
68            let key = key.unwrap();
69            if key.is_string() {
70                return Some(key.as_str().unwrap().to_string());
71            }
72            if key.is_number() {
73                return Some(key.as_str().unwrap().to_string());
74            }
75        }
76        return None;
77    }
78    pub fn keys(&self) -> Option<Vec<String>> {
79        let key = self.value.get("key");
80        if !key.is_some() {
81            return None;
82        }
83        let key = key.unwrap();
84        if key.is_string() || key.is_number() {
85            return Some(vec![key.to_string()]);
86        }
87        if key.is_array() {
88            let keys = key.as_array().unwrap();
89            let mut response = vec![];
90            for key in keys {
91                if key.is_string() || key.is_number() {
92                    response.push(key.to_string());
93                }
94            }
95            return Some(response);
96        }
97        return None;
98    }
99    pub fn doc_count(&self) -> Option<u64> {
100        parse_u32(self.value.get("doc_count"))
101    }
102
103    pub fn sub_aggregation<T: Into<String>>(&self, key: T) -> Option<AggregationResponseParser> {
104        let agg = self.value.get(key.into())?.clone();
105        Some(AggregationResponseParser::new(agg))
106    }
107}
108
109fn parse_u32(value: Option<&Value>) -> Option<u64> {
110    if value.is_none() {
111        return None;
112    }
113    let value = value.unwrap();
114    if value.is_u64() {
115        return Some(value.as_u64().unwrap());
116    }
117    return None;
118}
119
120// #[derive(Debug, Default, Clone, Deserialize, Serialize)]
121// pub struct ResponseTermAggregation<T: Default = ResponseBucket> {
122//     pub doc_count_error_upper_bound: u32,
123//     pub sum_other_doc_count: u32,
124//     pub buckets: Vec<T>,
125// }
126//
127// #[derive(Debug, Default, Clone, Deserialize, Serialize)]
128// pub struct ResponseBucket {
129//     pub key: Option<String>,
130//     pub doc_count: u32,
131// }
132//
133// #[derive(Debug, Default, Clone, Deserialize, Serialize)]
134// pub struct ResponseCustomBucket<T> {
135//     pub key: String,
136//     pub doc_count: i32,
137//     pub value: T,
138// }
139//
140// #[derive(Debug, Default, Clone, Deserialize, Serialize)]
141// pub struct ResponseMultiTermAggregation<T: Default = ResponseMultiBucket> {
142//     pub doc_count_error_upper_bound: u32,
143//     pub sum_other_doc_count: u32,
144//     pub buckets: Vec<T>,
145// }
146//
147// #[derive(Debug, Default, Clone, Deserialize, Serialize)]
148// pub struct ResponseMultiBucket {
149//     pub key_as_string: String,
150//     pub doc_count: u32,
151// }
152//
153// #[derive(Debug, Default, Clone, Deserialize, Serialize)]
154// pub struct ResponseCardinalityAggregation {
155//     pub value: u32,
156// }
157//
158// #[derive(Debug, Default, Clone, Deserialize, Serialize)]
159// pub struct ResponseStatsAggregation {
160//     pub count: i32,
161//     pub min: f64,
162//     pub max: f64,
163//     pub avg: f64,
164//     pub sum: f64,
165// }
elastic_parser/aggregation/mod.rs

elastic_parser/aggregation/
mod.rs
