Struct 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 serialize<__S>( __self: &BoolQuery, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

impl BoolQuery

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

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

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

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

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

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

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

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

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<T>(self, query: T) -> Self

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

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<T>(self, minimum_should_match: T) -> Self

where T: ToString,

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<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 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 Option<Query>

fn from(q: BoolQuery) -> Self

Converts to this type from the input type.

impl From<BoolQuery> for Query

fn from(q: BoolQuery) -> Self

Converts to this type from the input type.

impl IntoIterator for BoolQuery

type Item = BoolQuery

The type of the elements being iterated over.

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

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

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 BoolQuery

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