Struct DisMaxQuery

pub struct DisMaxQuery { /* private fields */ }

Returns documents matching one or more wrapped queries, called query clauses or clauses.

If a returned document matches multiple query clauses, the dis_max query assigns the document the highest relevance score from any matching clause, plus a tie breaking increment for any additional matching subqueries.

You can use the dis_max to search for a term in fields mapped with different boost factors.

To create disjunction max query:

Query::dis_max()
    .query(Query::r#match("t1", "text"))
    .query(Query::r#match("t2", "text"))
    .tie_breaker(0.5)
    .boost(3)
    .name("test");

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

Implementations

impl DisMaxQuery

pub fn serialize<__S>( __self: &DisMaxQuery, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

impl DisMaxQuery

pub fn query<T>(self, query: T) -> Self

where T: IntoIterator, T::Item: Into<Query>,

Contains one or more query clauses. Returned documents must match one or more of these queries. If a document matches multiple queries, Elasticsearch uses the highest relevance score

pub fn tie_breaker(self, tie_breaker: f32) -> Self

Floating point number between 0 and 1.0 used to increase the relevance scores of documents matching multiple query clauses. Defaults to 0.0.

You can use the tie_breaker value to assign higher relevance scores to documents that contain the same term in multiple fields than documents that contain this term in only the best of those multiple fields, without confusing this with the better case of two different terms in the multiple fields.

If a document matches multiple clauses, the dis_max query calculates the relevance score for the document as follows:

1. Take the relevance score from a matching clause with the highest score.
2. Multiply the score from any other matching clauses by the tie_breaker value.
3. Add the highest score to the multiplied scores.

If the tie_breaker value is greater than 0.0, all matching clauses count, but the clause with the highest score counts most.

pub fn boost<T>(self, boost: T) -> Self

where 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) -> Self

where 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 DisMaxQuery

fn clone(&self) -> DisMaxQuery

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DisMaxQuery

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

Formats the value using the given formatter.

impl Default for DisMaxQuery

fn default() -> DisMaxQuery

Returns the “default value” for a type.

impl From<DisMaxQuery> for Option<Query>

fn from(q: DisMaxQuery) -> Self

Converts to this type from the input type.

impl From<DisMaxQuery> for Query

fn from(q: DisMaxQuery) -> Self

Converts to this type from the input type.

impl IntoIterator for DisMaxQuery

type Item = DisMaxQuery

The type of the elements being iterated over.

type IntoIter = IntoIter<<DisMaxQuery 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<DisMaxQuery> for Query

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Query> for DisMaxQuery

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for DisMaxQuery

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for DisMaxQuery

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 DisMaxQuery