Struct elasticsearch_dsl::search::queries::full_text::QueryStringQuery

pub struct QueryStringQuery { /* private fields */ }

Returns documents that match a provided text, number, date or boolean value. The provided text is analyzed before matching.

The match query is the standard query for performing a full-text search, including options for fuzzy matching.

To create a Match query with numeric values:

Query::query_string("(new york city) OR (big apple)")
    .boost(2)
    .name("test");

https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html

Implementations

impl QueryStringQuery

pub fn default_field<S>(self, default_field: S) -> Selfwhere
    S: ToString,

Default field you wish to search if no field is provided in the query string.

Defaults to the index.query.default_field index setting, which has a default value of *. The * value extracts all fields that are eligible for term queries and filters the metadata fields. All extracted fields are then combined to build a query if no prefix is specified.

Searching across all eligible fields does not include nested documents. Use a nested query to search those documents.

For mappings with a large number of fields, searching across all eligible fields could be expensive.

There is a limit on the number of fields that can be queried at once. It is defined by the indices.query.bool.max_clause_count search setting, which defaults to 1024.

pub fn allow_leading_wildcard(self, allow_leading_wildcard: bool) -> Self

If true, the wildcard characters * and ? are allowed as the first character of the query string.

Defaults to true.

pub fn analyze_wildcard(self, analyze_wildcard: bool) -> Self

If true, the query attempts to analyze wildcard terms in the query string.

Defaults to false.

pub fn analyzer<T>(self, analyzer: T) -> Selfwhere
    T: ToString,

Analyzer used to convert text in the query string into tokens. Defaults to the index-time analyzer mapped for the default_field. If no analyzer is mapped, the index’s default analyzer is used.

pub fn auto_generate_synonyms_phrase_query(
    self,
    auto_generate_synonyms_phrase_query: bool
) -> Self

If true, the parser creates a match_phrase query for each multi-position token.

Defaults to true. For examples, see Multi-position tokens.

pub fn default_operator(self, default_operator: Operator) -> Self

Default boolean logic used to interpret text in the query string if no operators are specified.

pub fn enable_position_increments(self, enable_position_increments: bool) -> Self

If true, enable position increments in queries constructed from a query_string search.

Defaults to true.

pub fn fields<I>(self, fields: I) -> Selfwhere
    I: IntoIterator,
    I::Item: ToString,

Array of fields you wish to search.

You can use this parameter query to search across multiple fields. See Search multiple fields.

pub fn fuzziness<T>(self, fuzziness: T) -> Selfwhere
    T: Into<Fuzziness>,

Maximum edit distance allowed for fuzzy matching. For fuzzy syntax, see Fuzziness.

pub fn fuzzy_max_expansions(self, fuzzy_max_expansions: u32) -> Self

Maximum number of terms to which the query expands for fuzzy matching.

Defaults to 50.

pub fn fuzzy_prefix_length(self, fuzzy_prefix_length: u32) -> Self

Number of beginning characters left unchanged for fuzzy matching.

Defaults to 0.

pub fn fuzzy_transpositions(self, fuzzy_transpositions: bool) -> Self

If true, edits for fuzzy matching include transpositions of two adjacent characters (ab → ba).

Defaults to true.

pub fn lenient(self, lenient: bool) -> Self

If true, format-based errors, such as providing a text query value for a numeric field, are ignored.

Defaults to false.

pub fn max_determinized_states(self, max_determinized_states: u32) -> Self

Maximum number of automaton states required for the query.

Default is 10000.

Elasticsearch uses Apache Lucene internally to parse regular expressions. Lucene converts each regular expression to a finite automaton containing a number of determinized states.

You can use this parameter to prevent that conversion from unintentionally consuming too many resources. You may need to increase this limit to run complex regular expressions.

pub fn minimum_should_match<T>(self, minimum_should_match: T) -> Selfwhere
    T: ToString,

Minimum number of clauses that must match for a document to be returned. See the minimum_should_match parameter for valid values and more information.

pub fn quote_analyzer<S>(self, quote_analyzer: S) -> Selfwhere
    S: ToString,

Analyzer used to convert quoted text in the query string into tokens.

Defaults to the search_quote_analyzer mapped for the default_field.

For quoted text, this parameter overrides the analyzer specified in the analyzer parameter.

pub fn phrase_slop(self, phrase_slop: u32) -> Self

Maximum number of positions allowed between matching tokens for phrases.

Defaults to 0. If 0, exact phrase matches are required. Transposed terms have a slop of 2.

pub fn quote_field_suffix<S>(self, quote_field_suffix: S) -> Selfwhere
    S: ToString,

Suffix appended to quoted text in the query string.

You can use this suffix to use a different analysis method for exact matches. See Mixing exact search with stemming.

pub fn rewrite(self, rewrite: Rewrite) -> Self

Method used to rewrite the query. For valid values and more information, see the rewrite parameter.

pub fn time_zone<S>(self, time_zone: S) -> Selfwhere
    S: ToString,

Coordinated Universal Time (UTC) offset or IANA time zone used to convert date values in the query string to UTC.

Valid values are ISO 8601 UTC offsets, such as +01:00 or -08:00, and IANA time zone IDs, such as America/Los_Angeles.

pub fn boost<T>(self, boost: T) -> Selfwhere
    T: AsPrimitive<f32>,

Floating point number used to decrease or increase the relevance scores of a query. Defaults to 1.0.

You can use the boost parameter to adjust relevance scores for searches containing two or more queries.

Boost values are relative to the default value of 1.0. A boost value between 0 and 1.0 decreases the relevance score. A value greater than 1.0 increases the relevance score.

pub fn name<S>(self, name: S) -> Selfwhere
    S: ToString,

You can use named queries to track which queries matched returned documents. If named queries are used, the response includes a matched_queries property for each hit.

https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html#named-queries

Trait Implementations

impl Clone for QueryStringQuery

fn clone(&self) -> QueryStringQuery

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QueryStringQuery

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<QueryStringQuery> for Option<Query>

fn from(q: QueryStringQuery) -> Self

Converts to this type from the input type.

impl From<QueryStringQuery> for Query

fn from(q: QueryStringQuery) -> Self

Converts to this type from the input type.

impl IntoIterator for QueryStringQuery

type Item = QueryStringQuery

The type of the elements being iterated over.

type IntoIter = IntoIter<<QueryStringQuery as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq<Query> for QueryStringQuery

fn eq(&self, other: &Query) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<QueryStringQuery> for Query

fn eq(&self, other: &QueryStringQuery) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<QueryStringQuery> for QueryStringQuery

fn eq(&self, other: &QueryStringQuery) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for QueryStringQuery

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for QueryStringQuery