Struct elasticsearch_dsl::search::queries::compound::BoolQuery

pub struct BoolQuery { /* private fields */ }

A query that matches documents matching boolean combinations of other queries. The bool query maps to Lucene BooleanQuery. It is built using one or more boolean clauses, each clause with a typed occurrence.

The bool query takes a more-matches-is-better approach, so the score from each matching must or should clause will be added together to provide the final _score for each document.

To create bool query:

Query::bool()
   .must(Query::term("test1", 1))
   .must(Query::term("test2", 2))
   .should(Query::term("test1", 3))
   .should(Query::term("test2", 4))
   .filter(Query::term("test1", 5))
   .filter(Query::term("test2", 6))
   .must_not(Query::term("test1", 7))
   .must_not(Query::term("test2", 8))
   .minimum_should_match("2")
   .boost(1.3)
   .name("test");

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

Implementations

impl BoolQuery

pub fn must<Q>(self, queries: Q) -> Self where
    Q: Into<Queries>, 

The clause (query) must appear in matching documents and will contribute to the score.

pub fn should<Q>(self, queries: Q) -> Self where
    Q: Into<Queries>, 

The clause (query) should appear in the matching document.

pub fn filter<Q>(self, queries: Q) -> Self where
    Q: Into<Queries>, 

The clause (query) must appear in matching documents. However unlike must the score of the query will be ignored. Filter clauses are executed in filter context, meaning that scoring is ignored and clauses are considered for caching.

pub fn must_not<Q>(self, queries: Q) -> Self where
    Q: Into<Queries>, 

The clause (query) must not appear in the matching documents. Clauses are executed in filter context meaning that scoring is ignored and clauses are considered for caching. Because scoring is ignored, a score of 0 for all documents is returned.

pub fn minimum_should_match<S>(self, minimum_should_match: S) -> Self where
    S: Into<MinimumShouldMatch>, 

You can use the minimum_should_match parameter to specify the number or percentage of should clauses returned documents must match.

If the bool query includes at least one should clause and no must or filter clauses, the default value is 1. Otherwise, the default value is 0.

For other valid values, see the minimum_should_match parameter.

pub fn boost<B>(self, boost: B) -> Self where
    B: TryInto<Boost>, 

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 BoolQuery

fn clone(&self) -> BoolQuery

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BoolQuery

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

Formats the value using the given formatter.

impl Default for BoolQuery

fn default() -> BoolQuery

Returns the “default value” for a type.

impl From<BoolQuery> for Query

fn from(q: BoolQuery) -> Self

Converts to this type from the input type.

impl From<BoolQuery> for Option<Query>

fn from(q: BoolQuery) -> Self

Converts to this type from the input type.

impl From<BoolQuery> for Queries

fn from(q: BoolQuery) -> Self

Converts to this type from the input type.

impl PartialEq<BoolQuery> for BoolQuery

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

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

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

This method tests for !=.

impl PartialEq<BoolQuery> for Query

fn eq(&self, other: &BoolQuery) -> 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 !=.

impl PartialEq<Query> for BoolQuery

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 !=.

impl Serialize for BoolQuery

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 BoolQuery