elastic_query_builder/query/
multi_match_query.rs

1use crate::query::QueryTrait;
2use crate::util::UtilMap;
3use serde::ser::SerializeStruct;
4use serde::{Serialize, Serializer};
5use serde_json::Value;
6
7#[derive(Default)]
8pub struct MultiMatchQuery {
9    fields: Vec<String>,
10    query: String,
11    search_type: String,
12    fuzziness: String,
13    boost: Option<f64>,
14}
15
16impl MultiMatchQuery {
17    pub fn new(fields: Vec<String>, query: &str) -> MultiMatchQuery {
18        let mut value = MultiMatchQuery::default();
19        value.fields = fields;
20        value.query = query.to_string();
21        return value;
22    }
23    pub fn set_fields(&mut self, fields: Vec<String>) {
24        self.fields = fields;
25    }
26    pub fn set_query(&mut self, query: &str) {
27        self.query = query.to_string();
28    }
29    pub fn set_fuzziness(&mut self, fuzziness: &str) {
30        self.fuzziness = fuzziness.to_string();
31    }
32    pub fn set_type(&mut self, search_type: &str) {
33        self.search_type = search_type.to_string();
34    }
35    pub fn set_boost(mut self, boost: f64) -> MultiMatchQuery {
36        self.boost = Some(boost);
37        self
38    }
39}
40
41impl Serialize for MultiMatchQuery {
42    fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
43    where
44        S: Serializer,
45    {
46        let mut state = serializer.serialize_struct("MultiMatchQuery", 0)?;
47        let _ = state.serialize_field("query", &self.query);
48        let _ = state.serialize_field("fields", &self.fields);
49        if !self.search_type.is_empty() {
50            let _ = state.serialize_field("type", &self.search_type);
51        }
52        if !self.fuzziness.is_empty() {
53            let _ = state.serialize_field("fuzziness", &self.fuzziness);
54        }
55        state.end()
56    }
57}
58
59impl QueryTrait for MultiMatchQuery {
60    fn build(&self) -> Value {
61        let mut root = UtilMap::new();
62        root.append_string("query", self.query.to_string());
63        root.append_vec_string("fields", self.fields.clone());
64        root.append_boost(self.boost);
65        if !self.search_type.is_empty() {
66            root.append_string("type", self.search_type.clone());
67        }
68        if !self.fuzziness.is_empty() {
69            root.append_string("fuzziness", self.fuzziness.clone());
70        }
71        root.build_object(self.query_name())
72    }
73    fn query_name(&self) -> String {
74        return "multi_match".to_string();
75    }
76}
77#[test]
78fn test() {
79    let build = MultiMatchQuery::new(
80        vec!["title".to_string(), "description".to_string()],
81        "elastic",
82    )
83    .set_boost(100.0);
84    assert_eq!("{\"multi_match\":{\"boost\":100.0,\"fields\":[\"title\",\"description\"],\"query\":\"elastic\"}}", build.build().to_string());
85}