elasticsearch_dsl/search/queries/term_level/
prefix_query.rs

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