elasticsearch_dsl/search/queries/term_level/
wildcard_query.rs

1use crate::search::*;
2use crate::util::*;
3use serde::Serialize;
4
5/// Returns documents that contain terms matching a wildcard pattern.
6///
7/// A wildcard operator is a placeholder that matches one or more characters. For example, the `*`
8/// wildcard operator matches zero or more characters. You can combine wildcard operators with
9/// other characters to create a wildcard pattern.
10///
11/// To create a wildcard query:
12/// ```
13/// # use elasticsearch_dsl::queries::*;
14/// # use elasticsearch_dsl::queries::params::*;
15/// # let query =
16/// Query::wildcard("test", 123);
17/// ```
18/// <https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-wildcard-query.html>
19#[derive(Debug, Clone, PartialEq, Serialize)]
20#[serde(remote = "Self")]
21pub struct WildcardQuery {
22    #[serde(skip_serializing)]
23    field: String,
24
25    value: Option<Term>,
26
27    #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
28    rewrite: Option<Rewrite>,
29
30    #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
31    case_insensitive: Option<bool>,
32
33    #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
34    boost: Option<f32>,
35
36    #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
37    _name: Option<String>,
38}
39
40impl Query {
41    /// Creates an instance of [`WildcardQuery`]
42    ///
43    /// - `field` - Field you wish to search.
44    /// - `value` - Wildcard you wish to find in the provided field.
45    ///   To return a document, the wildcard must exactly match the field value, including whitespace and capitalization.
46    pub fn wildcard<T, U>(field: T, value: U) -> WildcardQuery
47    where
48        T: ToString,
49        U: Serialize,
50    {
51        WildcardQuery {
52            field: field.to_string(),
53            value: Term::new(value),
54            rewrite: None,
55            case_insensitive: None,
56            boost: None,
57            _name: None,
58        }
59    }
60}
61
62impl WildcardQuery {
63    /// Method used to rewrite the query. For valid values and more information, see the
64    /// [rewrite](Rewrite) parameter.
65    pub fn rewrite(mut self, rewrite: Rewrite) -> Self {
66        self.rewrite = Some(rewrite);
67        self
68    }
69
70    /// Allows case insensitive matching of the pattern with the indexed field values when set to
71    /// true. Default is false which means the case sensitivity of matching depends on the
72    /// underlying field’s mapping.
73    pub fn case_insensitive(mut self, case_insensitive: bool) -> Self {
74        self.case_insensitive = Some(case_insensitive);
75        self
76    }
77
78    add_boost_and_name!();
79}
80
81impl ShouldSkip for WildcardQuery {
82    fn should_skip(&self) -> bool {
83        self.value.should_skip()
84    }
85}
86
87serialize_with_root_keyed!("wildcard": WildcardQuery);
88
89#[cfg(test)]
90mod tests {
91    use super::*;
92
93    #[test]
94    fn serialization() {
95        assert_serialize_query(
96            Query::wildcard("test", "value*"),
97            json!({
98                "wildcard": {
99                    "test": {
100                        "value": "value*"
101                    }
102                }
103            }),
104        );
105
106        assert_serialize_query(
107            Query::wildcard("test", "value*")
108                .rewrite(Rewrite::ConstantScore)
109                .case_insensitive(true)
110                .boost(2)
111                .name("test"),
112            json!({
113                "wildcard": {
114                    "test": {
115                        "value": "value*",
116                        "rewrite": "constant_score",
117                        "case_insensitive": true,
118                        "boost": 2.0,
119                        "_name": "test"
120                    }
121                }
122            }),
123        );
124
125        assert_serialize_query(
126            Query::bool().filter(Query::wildcard("test", None::<String>)),
127            json!({ "bool": {} }),
128        )
129    }
130}