elastic_query_builder/aggregation/
multi_terms_aggregation.rs

1use crate::aggregation::AggregationTrait;
2use crate::merge;
3use serde::ser::SerializeStruct;
4use serde::{Serialize, Serializer};
5use serde_json::{json, Value};
6
7#[derive(Default)]
8pub struct MultiTermsAggregation {
9    name: String,
10    // aggregation: Option<T>,
11    value: TermsValue,
12    aggregation: Value,
13}
14
15#[derive(Default, Clone)]
16struct MultiTermsOrder {
17    order_field: String,
18    order_value: String,
19}
20
21#[derive(Default)]
22struct TermsValue {
23    script: String,
24    fields: Vec<String>,
25    size: i64,
26    order: Option<MultiTermsOrder>,
27}
28
29impl MultiTermsAggregation {
30    pub fn new(name: &str) -> Self {
31        let mut term = MultiTermsAggregation {
32            name: name.to_string(),
33            ..Default::default()
34        };
35        term.value.size = 10;
36        term
37    }
38    pub fn set_fields(mut self, fields: Vec<String>) -> Self {
39        self.value.fields = fields;
40        self
41    }
42    pub fn set_size(mut self, size: i64) -> Self {
43        self.value.size = size;
44        self
45    }
46
47    pub fn set_order(mut self, order_field: &str, order_value: &str) -> Self {
48        self.value.order = Some(MultiTermsOrder {
49            order_field: order_field.to_string(),
50            order_value: order_value.to_string(),
51        });
52        self
53    }
54    pub fn set_aggregation<T>(mut self, aggregation: T) -> Self
55    where
56        T: AggregationTrait,
57    {
58        self.aggregation = aggregation.build();
59        self
60    }
61    pub fn append_aggregation<T>(mut self, query: T) -> Self
62    where
63        T: AggregationTrait,
64    {
65        let mut values = self.aggregation.clone();
66        merge(&mut values, &query.build());
67        self.aggregation = json!(values);
68        return self;
69    }
70}
71
72impl Serialize for TermsValue {
73    fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
74    where
75        S: Serializer,
76    {
77        let mut state = serializer.serialize_struct("MultiTermsBuilder", 0)?;
78
79        if self.script.is_empty() {
80            let mut values = vec![];
81            for field in &self.fields {
82                values.push(json!({"field":field}))
83            }
84            state.serialize_field("terms", &json!(values))?;
85            state.serialize_field("size", &self.size)?;
86        } else {
87            // TODO:
88        }
89
90        if self.order.is_some() {
91            let order = self.order.clone().unwrap();
92            let name = order.order_field;
93            let value = order.order_value;
94            state.serialize_field("order", &json!({name:value}))?;
95        }
96        state.end()
97    }
98}
99//
100// impl Serialize for MultiTermsOrder {
101//     fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
102//     where
103//         S: Serializer,
104//     {
105//         let mut state = serializer.serialize_struct("MultiTermsOrder", 0)?;
106//
107//         state.serialize_field("order_field", &self.order_field)?;
108//         state.serialize_field("order_value", &self.order_value)?;
109//         state.end()
110//     }
111// }
112
113impl Serialize for MultiTermsAggregation {
114    fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
115    where
116        S: Serializer,
117    {
118        let mut state = serializer.serialize_struct("MultiTerum", 0)?;
119        state.serialize_field("multi_terms", &self.value)?;
120        if !(self.aggregation.is_null() || self.aggregation.to_string().is_empty()) {
121            state.serialize_field("aggs", &self.aggregation)?;
122        }
123        // }
124        state.end()
125    }
126}
127
128// impl Serialize for MultiTermsOrder {
129//     fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
130//         where
131//             S: Serializer,
132//     {
133//         let mut state = serializer.serialize_struct("BoolQuery", 0)?;
134//         state.serialize_field(&self.order_field.to_string(), &self.order_value.to_string());
135//         state.end()
136//     }
137// }
138
139impl AggregationTrait for MultiTermsAggregation {
140    fn name(&self) -> &str {
141        self.name.as_str()
142    }
143
144    fn build(&self) -> Value {
145        let name = self.name.to_string();
146        json!({ name: self })
147    }
148
149    fn query_name(&self) -> String {
150        "terms".to_string()
151    }
152}
153
154#[cfg(test)]
155mod tests {
156    use super::*;
157    use crate::aggregation::AggregationTrait;
158
159    #[test]
160    fn test_terms_aggregation() {
161        let agg = MultiTermsAggregation::new("hoge")
162            .set_fields(vec!["field_name1".to_string(), "field_name2".to_string()])
163            .set_order("_key", "asc");
164
165        let json = agg.build();
166        println!("{}", json);
167        // assert_eq!(json["test"]["terms"]["field"], "test");
168        // assert_eq!(json["test"]["terms"]["size"], 1);
169    }
170}
elastic_query_builder/aggregation/multi_terms_aggregation.rs

elastic_query_builder/aggregation/
multi_terms_aggregation.rs
