Enum Query

pub enum Query {
    Bool(BoolQuery),
    Prefix(PrefixQuery),
    Regexp(RegexpQuery),
    Wildcard(WildcardQuery),
    TermsSet(TermsSetQuery),
    Term(TermQuery),
    Terms(TermsQuery),
    TermsLookup(TermsLookupQuery),
    Exists(ExistsQuery),
    Range(RangeQuery),
    Ids(IdsQuery),
    ConstantScore(ConstantScoreQuery),
    DistanceFeatureDate(DistanceFeatureQuery<DateTime<Utc>>),
    DistanceFeatureGeo(DistanceFeatureQuery<GeoLocation>),
    Match(MatchQuery),
    MatchBoolPrefix(MatchBoolPrefixQuery),
    MatchPhrasePrefix(MatchPhrasePrefixQuery),
    MatchAll(MatchAllQuery),
    MatchNone(MatchNoneQuery),
    MatchPhrase(MatchPhraseQuery),
    MultiMatch(MultiMatchQuery),
    Nested(NestedQuery),
    Boosting(BoostingQuery),
    DisMax(DisMaxQuery),
    Pinned(PinnedQuery),
    Percolate(PercolateQuery),
    PercolateLookup(PercolateLookupQuery),
    FunctionScore(FunctionScoreQuery),
    RankFeature(RankFeatureQuery),
    RankFeatureSaturation(RankFeatureSaturationQuery),
    RankFeatureLogarithm(RankFeatureLogarithmQuery),
    RankFeatureSigmoid(RankFeatureSigmoidQuery),
    RankFeatureLinear(RankFeatureLinearQuery),
    MoreLikeThis(MoreLikeThisQuery),
    Fuzzy(FuzzyQuery),
    GeoDistance(GeoDistanceQuery),
    GeoBoundingBox(GeoBoundingBoxQuery),
    GeoShapeLookup(GeoShapeLookupQuery),
    GeoShape(GeoShapeQuery),
    ShapeLookup(ShapeLookupQuery),
    Shape(ShapeQuery),
    Json(JsonQuery),
    Wrapper(WrapperQuery),
    Script(ScriptQuery),
    ScriptScore(ScriptScoreQuery),
    ParentId(ParentIdQuery),
    HasParent(HasParentQuery),
    HasChild(HasChildQuery),
    SimpleQueryString(SimpleQueryStringQuery),
    QueryString(QueryStringQuery),
    CombinedFields(CombinedFieldsQuery),
    SpanContaining(SpanContainingQuery),
    SpanFieldMasking(SpanFieldMaskingQuery),
    SpanFirst(SpanFirstQuery),
    SpanMulti(SpanMultiQuery),
    SpanNear(SpanNearQuery),
    SpanNot(SpanNotQuery),
    SpanOr(SpanOrQuery),
    SpanTerm(SpanTermQuery),
    SpanWithin(SpanWithinQuery),
    Knn(KnnQuery),
}

A container enum for supported Elasticsearch query types

Variants

Bool(BoolQuery)

Prefix(PrefixQuery)

Regexp(RegexpQuery)

Wildcard(WildcardQuery)

TermsSet(TermsSetQuery)

Term(TermQuery)

Terms(TermsQuery)

TermsLookup(TermsLookupQuery)

Exists(ExistsQuery)

Range(RangeQuery)

Ids(IdsQuery)

ConstantScore(ConstantScoreQuery)

DistanceFeatureDate(DistanceFeatureQuery<DateTime<Utc>>)

DistanceFeatureGeo(DistanceFeatureQuery<GeoLocation>)

Match(MatchQuery)

MatchBoolPrefix(MatchBoolPrefixQuery)

MatchPhrasePrefix(MatchPhrasePrefixQuery)

MatchAll(MatchAllQuery)

MatchNone(MatchNoneQuery)

MatchPhrase(MatchPhraseQuery)

MultiMatch(MultiMatchQuery)

Nested(NestedQuery)

Boosting(BoostingQuery)

DisMax(DisMaxQuery)

Pinned(PinnedQuery)

Percolate(PercolateQuery)

PercolateLookup(PercolateLookupQuery)

FunctionScore(FunctionScoreQuery)

RankFeature(RankFeatureQuery)

RankFeatureSaturation(RankFeatureSaturationQuery)

RankFeatureLogarithm(RankFeatureLogarithmQuery)

RankFeatureSigmoid(RankFeatureSigmoidQuery)

RankFeatureLinear(RankFeatureLinearQuery)

MoreLikeThis(MoreLikeThisQuery)

Fuzzy(FuzzyQuery)

GeoDistance(GeoDistanceQuery)

GeoBoundingBox(GeoBoundingBoxQuery)

GeoShapeLookup(GeoShapeLookupQuery)

GeoShape(GeoShapeQuery)

ShapeLookup(ShapeLookupQuery)

Shape(ShapeQuery)

Json(JsonQuery)

Wrapper(WrapperQuery)

Script(ScriptQuery)

ScriptScore(ScriptScoreQuery)

ParentId(ParentIdQuery)

HasParent(HasParentQuery)

HasChild(HasChildQuery)

SimpleQueryString(SimpleQueryStringQuery)

QueryString(QueryStringQuery)

CombinedFields(CombinedFieldsQuery)

SpanContaining(SpanContainingQuery)

SpanFieldMasking(SpanFieldMaskingQuery)

SpanFirst(SpanFirstQuery)

SpanMulti(SpanMultiQuery)

SpanNear(SpanNearQuery)

SpanNot(SpanNotQuery)

SpanOr(SpanOrQuery)

SpanTerm(SpanTermQuery)

SpanWithin(SpanWithinQuery)

Knn(KnnQuery)

Implementations

impl Query

pub fn bool() -> BoolQuery

Creates an instance of BoolQuery

impl Query

pub fn boosting<Q, B>( positive: Q, negative: Q, negative_boost: B, ) -> BoostingQuery

where Q: Into<Query>, B: Into<NegativeBoost>,

Creates an instance of BoostingQuery

• positive - Query you wish to run. Any returned documents must match this query.
• negative - Query used to decrease the relevance score of matching documents.
  If a returned document matches the positive query and this query, the boosting query calculates the final relevance score for the document as follows:
  1. Take the original relevance score from the positive query.
  2. Multiply the score by the negative_boost value.
• negative_boost - Floating point number between 0 and 1.0 used to decrease the relevance scores of documents matching the negative query.

impl Query

pub fn constant_score<T>(filter: T) -> ConstantScoreQuery

where T: Into<Query>,

Creates an instance of ConstantScoreQuery

• filter - Filter query you wish to run. Any returned documents must match this query.
  Filter queries do not calculate relevance scores. To speed up performance, Elasticsearch automatically caches frequently used filter queries.

impl Query

pub fn dis_max() -> DisMaxQuery

Creates an instance of DisMaxQuery

impl Query

pub fn function_score() -> FunctionScoreQuery

Creates an instance of FunctionScoreQuery

impl Query

pub fn json(query: Value) -> JsonQuery

Creates an instance of JsonQuery

• query - raw JSON query

impl Query

pub fn combined_fields<F, S>(fields: F, query: S) -> CombinedFieldsQuery

where F: IntoIterator, F::Item: ToString, S: Into<Text>,

Creates an instance of CombinedFieldsQuery

• fields - List of fields to search. Field wildcard patterns are allowed. Only text fields are supported, and they must all have the same search analyzer.
• query - Text to search for in the provided <fields>. The combined_fields query analyzes the provided text before performing a search.

impl Query

pub fn match_bool_prefix<T, U>(field: T, query: U) -> MatchBoolPrefixQuery

where T: ToString, U: Into<Text>,

Creates an instance of MatchBoolPrefixQuery

• field - Field you wish to search.
• query - Text, number, boolean value or date you wish to find in the provided <field>

impl Query

pub fn match_phrase_prefix<T, U>(field: T, query: U) -> MatchPhrasePrefixQuery

where T: ToString, U: Into<Text>,

Creates an instance of MatchPhrasePrefixQuery

• field - Field you wish to search.
• query - Text you wish to find in the provided <field>.
  The match_phrase_prefix query analyzes any provided text into tokens before performing a search. The last term of this text is treated as a prefix, matching any words that begin with that term.

impl Query

pub fn match_phrase<T, U>(field: T, query: U) -> MatchPhraseQuery

where T: ToString, U: Into<Text>,

Creates an instance of MatchPhraseQuery

• field - Field you wish to search.
• query - Text, number, boolean value or date you wish to find in the provided <field>.
  The match_phrase query analyzes any provided text before performing a search. This means the match_phrase query can search text fields for analyzed tokens rather than an exact term.

impl Query

pub fn match<T, U>(field: T, query: U) -> MatchQuery

where T: ToString, U: Into<Text>,

Creates an instance of MatchQuery

• field - Field you wish to search.
• query - Text, number, boolean value or date you wish to find in the provided <field>.
  The match query analyzes any provided text before performing a search. This means the match query can search text fields for analyzed tokens rather than an exact term.

impl Query

pub fn multi_match<F, S>(fields: F, query: S) -> MultiMatchQuery

where F: IntoIterator, F::Item: ToString, S: Into<Text>,

Creates an instance of MultiMatchQuery

• fields - Fields you wish to search.
• query - Text, number, boolean value or date you wish to find in the provided <field>. The match query analyzes any provided text before performing a search. This means the match query can search text fields for analyzed tokens rather than an exact term.

impl Query

pub fn query_string<S>(query: S) -> QueryStringQuery

where S: Into<Text>,

Creates an instance of QueryStringQuery

• query - Query string you wish to parse and use for search. See Simple query string syntax.

impl Query

pub fn simple_query_string<S>(query: S) -> SimpleQueryStringQuery

where S: Into<Text>,

Creates an instance of SimpleQueryStringQuery

• query - Query string you wish to parse and use for search. See Simple query string syntax.

impl Query

pub fn geo_bounding_box<T, U>(field: T, bounding_box: U) -> GeoBoundingBoxQuery

where T: ToString, U: Into<GeoBoundingBox>,

Creates an instance of GeoBoundingBoxQuery

• field - Field you wish to search.
• bounding_box - A series of vertex coordinates of a geo bounding box

impl Query

pub fn geo_distance<T, U, V>( field: T, origin: U, distance: V, ) -> GeoDistanceQuery

where T: ToString, U: Into<GeoLocation>, V: Into<Distance>,

Creates an instance of GeoDistanceQuery

• field - Field you wish to search
• origin - GeoPoint to measure distance to
• distance - Distance threshold

impl Query

pub fn geo_shape_lookup<S, T>(field: S, id: T) -> GeoShapeLookupQuery

where S: ToString, T: ToString,

Creates an instance of GeoShapeLookupQuery

• field - Field you wish to search
• id - The ID of the document that containing the pre-indexed shape

impl Query

pub fn geo_shape<S, T>(field: S, shape: T) -> GeoShapeQuery

where S: ToString, T: Into<GeoShape>,

Creates an instance of GeoShapeQuery

• field - Field you wish to search
• shape - Shape you with to search

impl Query

pub fn has_child<T, U>(type: T, query: U) -> HasChildQuery

where T: ToString, U: Into<Query>,

Creates an instance of HasChildQuery

• type - Name of the child relationship mapped for the join field.
• query - Query you wish to run on child documents of the type field. If a child document matches the search, the query returns the parent document.

impl Query

pub fn has_parent<T, U>(parent_type: T, query: U) -> HasParentQuery

where T: ToString, U: Into<Query>,

Creates an instance of HasParentQuery

• parent-type - Name of the parent relationship mapped for the join field.
• query - Query you wish to run on parent documents of the parent_type field. If a parent document matches the search, the query returns its child documents.

impl Query

pub fn nested<T, U>(path: T, query: U) -> NestedQuery

where T: ToString, U: Into<Query>,

Creates an instance of NestedQuery

• path - Path to the nested object you wish to search.
• query - Query you wish to run on nested objects in the path. If an object matches the search, the nested query returns the root parent document.
  You can search nested fields using dot notation that includes the complete path, such as obj1.name.
  Multi-level nesting is automatically supported, and detected, resulting in an inner nested query to automatically match the relevant nesting level, rather than root, if it exists within another nested query.
  Multi-level nested queries are also supported.

impl Query

pub fn parent_id<T, U>(type: T, id: U) -> ParentIdQuery

where T: ToString, U: ToString,

Creates an instance of ParentIdQuery

• type - Name of the child relationship mapped for the join field
• id - ID of the parent document. The query will return child documents of this parent document.

impl Query

pub fn shape_lookup<S, T>(field: S, id: T) -> ShapeLookupQuery

where S: ToString, T: ToString,

Creates an instance of ShapeLookupQuery

• field - Field you wish to search
• id - The ID of the document that containing the pre-indexed shape

impl Query

pub fn shape<S, T>(field: S, shape: T) -> ShapeQuery

where S: ToString, T: Into<Shape>,

Creates an instance of ShapeQuery

• field - Field you wish to search
• shape - Shape you with to search

impl Query

pub fn span_containing<T, U>(little: T, big: U) -> SpanContainingQuery

where T: Into<SpanQuery>, U: Into<SpanQuery>,

Creates an instance of SpanContainingQuery

impl Query

pub fn span_field_masking<Q, F>(query: Q, field: F) -> SpanFieldMaskingQuery

where Q: Into<SpanQuery>, F: ToString,

Creates an instance of SpanFieldMaskingQuery

impl Query

pub fn span_first<T>(match: T, end: u32) -> SpanFirstQuery

where T: Into<SpanQuery>,

Creates an instance of SpanFirstQuery

impl Query

pub fn span_multi<Q>(match: Q) -> SpanMultiQuery

where Q: Into<MultiTermQuery>,

Creates an instance of SpanMultiQuery

impl Query

pub fn span_near<T>(clauses: T) -> SpanNearQuery

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

Creates an instance of SpanNearQuery

impl Query

pub fn span_not<T, U>(exclude: T, include: U) -> SpanNotQuery

where T: IntoIterator, T::Item: Into<SpanQuery>, U: IntoIterator, U::Item: Into<SpanQuery>,

Creates an instance of SpanNotQuery

impl Query

pub fn span_or<T>(clauses: T) -> SpanOrQuery

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

Creates an instance of SpanOrQuery

impl Query

pub fn span_term<T, U>(field: T, value: U) -> SpanTermQuery

where T: ToString, U: Serialize,

Creates an instance of SpanTermQuery

• field - Field you wish to search.
• value - Term you wish to find in the provided field. To return a document, the term must exactly match the field value, including whitespace and capitalization.

impl Query

pub fn span_within<T, U>(little: T, big: U) -> SpanWithinQuery

where T: Into<SpanQuery>, U: Into<SpanQuery>,

Creates an instance of SpanWithinQuery

impl Query

pub fn distance_feature<T, O>( field: T, origin: O, pivot: <O as Origin>::Pivot, ) -> DistanceFeatureQuery<O>

where T: ToString, O: Origin,

Creates an instance of DistanceFeatureQuery

• field - Name of the field used to calculate distances. This field must meet the following criteria:
  
  • Be a date, date_nanos or geo_point field
  • Have an index mapping parameter value of true, which is the default
  • Have an doc_values mapping parameter value of true, which is the default
• origin - Date or point of origin used to calculate distances.
  If the field value is a date or date_nanos field, the origin value must be a date. Date Math, such as now-1h, is supported.
  If the field value is a geo_point field, the origin value must be a geopoint.
• pivot - Distance from the origin at which relevance scores receive half of the boost value.
  If the field value is a date or date_nanos field, the pivot value must be a time unit , such as 1h or 10d.
  If the field value is a geo_point field, the pivot value must be a distance unit , such as 1km or 12m.

impl Query

pub fn knn<T>(field: T, query_vector: Vec<f32>) -> KnnQuery

where T: ToString,

Creates an instance of KnnQuery

• field - The name of the vector field to search against. Must be a dense_vector field with indexing enabled.
• query_vector - Query vector. Must have the same number of dimensions as the vector field you are searching against.

impl Query

pub fn more_like_this<I>(like: I) -> MoreLikeThisQuery

where I: IntoIterator, I::Item: Into<Like>,

Creates an instance of MoreLikeThisQuery

• like - free form text and/or a single or multiple documents.

impl Query

pub fn percolate_lookup<S, T, U>( field: S, index: T, id: U, ) -> PercolateLookupQuery

where S: ToString, T: ToString, U: ToString,

Creates an instance of PercolateLookupQuery

• field - The field of type percolator that holds the indexed queries
• index - The index the document resides in
• id - The id of the document to fetch

impl Query

pub fn percolate<S, T>(field: S, source: T) -> PercolateQuery

where S: ToString, T: Serialize,

Creates an instance of PercolateQuery

• field - The field of type percolator that holds the indexed queries
• source - Source to percolate

impl Query

pub fn pinned<Q>(values: PinnedQueryValues, organic: Q) -> PinnedQuery

where Q: Into<Query>,

Creates an instance of PinnedQuery

impl Query

pub fn rank_feature<T>(field: T) -> RankFeatureQuery

where T: ToString,

Creates an instance of RankFeatureQuery

• field - rank_feature or rank_features field used to boost relevance scores

impl Query

pub fn script(script: Script) -> ScriptQuery

Creates an instance of ScriptQuery

• script - Contains a script to run as a query. This script must return a boolean value, true or false

impl Query

pub fn script_score<Q>(query: Q, script: Script) -> ScriptScoreQuery

where Q: Into<Query>,

Creates an instance of ScriptScoreQuery

• query - Query used to return documents
• script - Script used to compute the score of documents returned by the query

impl Query

pub fn wrapper<S>(query: S) -> WrapperQuery

where S: ToString,

Creates an instance of WrapperQuery

impl Query

pub fn exists<T>(field: T) -> ExistsQuery

where T: ToString,

Creates an instance of ExistsQuery

• field - Name of the field you wish to search. While a field is deemed non-existent if the JSON value is null or [], these values will indicate the field does exist:
  • Empty strings, such as "" or "-"
  • Arrays containing null and another value, such as [null, "foo"]
  • A custom null-value, defined in field mapping

impl Query

pub fn fuzzy<T, U>(field: T, value: U) -> FuzzyQuery

where T: ToString, U: Serialize,

Creates an instance of FuzzyQuery

• field - Field you wish to search.
• value - Fuzzy you wish to find in the provided field.

impl Query

pub fn ids<I>(values: I) -> IdsQuery

where I: IntoIterator, I::Item: ToString,

Creates an instance of IdsQuery

• values - An array of document IDs.

impl Query

pub fn prefix<T, U>(field: T, value: U) -> PrefixQuery

where T: ToString, U: Serialize,

Creates an instance of PrefixQuery

• field - Field you wish to search.
• value - Term you wish to find in the provided field. To return a document, the term must exactly match the field value, including whitespace and capitalization.

impl Query

pub fn range<T>(field: T) -> RangeQuery

where T: ToString,

Creates an instance of RangeQuery

• field - Field you wish to search.

impl Query

pub fn regexp<S>(field: S, value: S) -> RegexpQuery

where S: ToString,

Creates an instance of RegexpQuery

• field - Field you wish to search.
• value - Regular expression for terms you wish to find in the provided field. For a list of supported operators, see Regular expression syntax.
  

By default, regular expressions are limited to 1,000 characters. You can change this limit using the index.max_regex_length setting.

impl Query

pub fn term<T, U>(field: T, value: U) -> TermQuery

where T: ToString, U: Serialize,

Creates an instance of TermQuery

• field - Field you wish to search.
• value - Term you wish to find in the provided field. To return a document, the term must exactly match the field value, including whitespace and capitalization.

impl Query

pub fn terms_lookup<S, T, U, V>( field: S, index: T, id: U, path: V, ) -> TermsLookupQuery

where S: ToString, T: ToString, U: ToString, V: ToString,

Creates an instance of TermsLookupQuery

• field - Field you wish to search.
• index - Name of the index from which to fetch field values.
• id - ID of the document from which to fetch field values.
• path - Name of the field from which to fetch field values. Elasticsearch uses these values as search terms for the query. If the field values include an array of nested inner objects, you can access those objects using dot notation syntax.

impl Query

pub fn terms<S, I>(field: S, terms: I) -> TermsQuery

where S: ToString, I: Into<Terms>,

Creates an instance of TermsQuery

• field - Field you wish to search.
• values - An array of terms you wish to find in the provided field. To return a document, one or more terms must exactly match a field value, including whitespace and capitalization.
  By default, Elasticsearch limits the terms query to a maximum of 65,536 terms. You can change this limit using the index.max_terms_count setting.
  

To use the field values of an existing document as search terms, use the terms lookup parameters.

impl Query

pub fn terms_set<S, T, U>( field: S, terms: T, minimum_should_match: U, ) -> TermsSetQuery

where S: ToString, T: Into<Terms>, U: Into<TermsSetMinimumShouldMatch>,

Creates an instance of TermsSetQuery

• field - Field you wish to search.
• value - TermsSet you wish to find in the provided field. To return a document, the terms_set must exactly match the field value, including whitespace and capitalization.

impl Query

pub fn wildcard<T, U>(field: T, value: U) -> WildcardQuery

where T: ToString, U: Serialize,

Creates an instance of WildcardQuery

• field - Field you wish to search.
• value - Wildcard you wish to find in the provided field. To return a document, the wildcard must exactly match the field value, including whitespace and capitalization.

impl Query

pub fn match_all() -> MatchAllQuery

Creates an instance of MatchAllQuery

impl Query

pub fn match_none() -> MatchNoneQuery

Creates an instance of MatchNoneQuery

Trait Implementations

impl Clone for Query

fn clone(&self) -> Query

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Query

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

Formats the value using the given formatter.

impl From<BoolQuery> for Query

fn from(q: BoolQuery) -> Self

Converts to this type from the input type.

impl From<BoostingQuery> for Query

fn from(q: BoostingQuery) -> Self

Converts to this type from the input type.

impl From<CombinedFieldsQuery> for Query

fn from(q: CombinedFieldsQuery) -> Self

Converts to this type from the input type.

impl From<ConstantScoreQuery> for Query

fn from(q: ConstantScoreQuery) -> 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 From<DistanceFeatureQuery<DateTime<Utc>>> for Query

fn from(q: DistanceFeatureQuery<DateTime<Utc>>) -> Self

Converts to this type from the input type.

impl From<DistanceFeatureQuery<GeoLocation>> for Query

fn from(q: DistanceFeatureQuery<GeoLocation>) -> Self

Converts to this type from the input type.

impl From<ExistsQuery> for Query

fn from(q: ExistsQuery) -> Self

Converts to this type from the input type.

impl From<FunctionScoreQuery> for Query

fn from(q: FunctionScoreQuery) -> Self

Converts to this type from the input type.

impl From<FuzzyQuery> for Query

fn from(q: FuzzyQuery) -> Self

Converts to this type from the input type.

impl From<GeoBoundingBoxQuery> for Query

fn from(q: GeoBoundingBoxQuery) -> Self

Converts to this type from the input type.

impl From<GeoDistanceQuery> for Query

fn from(q: GeoDistanceQuery) -> Self

Converts to this type from the input type.

impl From<GeoShapeLookupQuery> for Query

fn from(q: GeoShapeLookupQuery) -> Self

Converts to this type from the input type.

impl From<GeoShapeQuery> for Query

fn from(q: GeoShapeQuery) -> Self

Converts to this type from the input type.

impl From<HasChildQuery> for Query

fn from(q: HasChildQuery) -> Self

Converts to this type from the input type.

impl From<HasParentQuery> for Query

fn from(q: HasParentQuery) -> Self

Converts to this type from the input type.

impl From<IdsQuery> for Query

fn from(q: IdsQuery) -> Self

Converts to this type from the input type.

impl From<JsonQuery> for Query

fn from(q: JsonQuery) -> Self

Converts to this type from the input type.

impl From<KnnQuery> for Query

fn from(q: KnnQuery) -> Self

Converts to this type from the input type.

impl From<MatchAllQuery> for Query

fn from(q: MatchAllQuery) -> Self

Converts to this type from the input type.

impl From<MatchBoolPrefixQuery> for Query

fn from(q: MatchBoolPrefixQuery) -> Self

Converts to this type from the input type.

impl From<MatchNoneQuery> for Query

fn from(q: MatchNoneQuery) -> Self

Converts to this type from the input type.

impl From<MatchPhrasePrefixQuery> for Query

fn from(q: MatchPhrasePrefixQuery) -> Self

Converts to this type from the input type.

impl From<MatchPhraseQuery> for Query

fn from(q: MatchPhraseQuery) -> Self

Converts to this type from the input type.

impl From<MatchQuery> for Query

fn from(q: MatchQuery) -> Self

Converts to this type from the input type.

impl From<MoreLikeThisQuery> for Query

fn from(q: MoreLikeThisQuery) -> Self

Converts to this type from the input type.

impl From<MultiMatchQuery> for Query

fn from(q: MultiMatchQuery) -> Self

Converts to this type from the input type.

impl From<NestedQuery> for Query

fn from(q: NestedQuery) -> Self

Converts to this type from the input type.

impl From<ParentIdQuery> for Query

fn from(q: ParentIdQuery) -> Self

Converts to this type from the input type.

impl From<PercolateLookupQuery> for Query

fn from(q: PercolateLookupQuery) -> Self

Converts to this type from the input type.

impl From<PercolateQuery> for Query

fn from(q: PercolateQuery) -> Self

Converts to this type from the input type.

impl From<PinnedQuery> for Query

fn from(q: PinnedQuery) -> Self

Converts to this type from the input type.

impl From<PrefixQuery> for Query

fn from(q: PrefixQuery) -> 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 From<RangeQuery> for Query

fn from(q: RangeQuery) -> Self

Converts to this type from the input type.

impl From<RankFeatureLinearQuery> for Query

fn from(q: RankFeatureLinearQuery) -> Self

Converts to this type from the input type.

impl From<RankFeatureLogarithmQuery> for Query

fn from(q: RankFeatureLogarithmQuery) -> Self

Converts to this type from the input type.

impl From<RankFeatureQuery> for Query

fn from(q: RankFeatureQuery) -> Self

Converts to this type from the input type.

impl From<RankFeatureSaturationQuery> for Query

fn from(q: RankFeatureSaturationQuery) -> Self

Converts to this type from the input type.

impl From<RankFeatureSigmoidQuery> for Query

fn from(q: RankFeatureSigmoidQuery) -> Self

Converts to this type from the input type.

impl From<RegexpQuery> for Query

fn from(q: RegexpQuery) -> Self

Converts to this type from the input type.

impl From<ScriptQuery> for Query

fn from(q: ScriptQuery) -> Self

Converts to this type from the input type.

impl From<ScriptScoreQuery> for Query

fn from(q: ScriptScoreQuery) -> Self

Converts to this type from the input type.

impl From<ShapeLookupQuery> for Query

fn from(q: ShapeLookupQuery) -> Self

Converts to this type from the input type.

impl From<ShapeQuery> for Query

fn from(q: ShapeQuery) -> Self

Converts to this type from the input type.

impl From<SimpleQueryStringQuery> for Query

fn from(q: SimpleQueryStringQuery) -> Self

Converts to this type from the input type.

impl From<SpanContainingQuery> for Query

fn from(q: SpanContainingQuery) -> Self

Converts to this type from the input type.

impl From<SpanFieldMaskingQuery> for Query

fn from(q: SpanFieldMaskingQuery) -> Self

Converts to this type from the input type.

impl From<SpanFirstQuery> for Query

fn from(q: SpanFirstQuery) -> Self

Converts to this type from the input type.

impl From<SpanMultiQuery> for Query

fn from(q: SpanMultiQuery) -> Self

Converts to this type from the input type.

impl From<SpanNearQuery> for Query

fn from(q: SpanNearQuery) -> Self

Converts to this type from the input type.

impl From<SpanNotQuery> for Query

fn from(q: SpanNotQuery) -> Self

Converts to this type from the input type.

impl From<SpanOrQuery> for Query

fn from(q: SpanOrQuery) -> Self

Converts to this type from the input type.

impl From<SpanTermQuery> for Query

fn from(q: SpanTermQuery) -> Self

Converts to this type from the input type.

impl From<SpanWithinQuery> for Query

fn from(q: SpanWithinQuery) -> Self

Converts to this type from the input type.

impl From<TermQuery> for Query

fn from(q: TermQuery) -> Self

Converts to this type from the input type.

impl From<TermsLookupQuery> for Query

fn from(q: TermsLookupQuery) -> Self

Converts to this type from the input type.

impl From<TermsQuery> for Query

fn from(q: TermsQuery) -> Self

Converts to this type from the input type.

impl From<TermsSetQuery> for Query

fn from(q: TermsSetQuery) -> Self

Converts to this type from the input type.

impl From<Value> for Query

fn from(value: Value) -> Self

Converts to this type from the input type.

impl From<WildcardQuery> for Query

fn from(q: WildcardQuery) -> Self

Converts to this type from the input type.

impl From<WrapperQuery> for Query

fn from(q: WrapperQuery) -> Self

Converts to this type from the input type.

impl IntoIterator for Query

type Item = Query

The type of the elements being iterated over.

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

fn eq(&self, other: &BoostingQuery) -> 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<CombinedFieldsQuery> for Query

fn eq(&self, other: &CombinedFieldsQuery) -> 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<ConstantScoreQuery> for Query

fn eq(&self, other: &ConstantScoreQuery) -> 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<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<DistanceFeatureQuery<DateTime<Utc>>> for Query

fn eq(&self, other: &DistanceFeatureQuery<DateTime<Utc>>) -> 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<DistanceFeatureQuery<GeoLocation>> for Query

fn eq(&self, other: &DistanceFeatureQuery<GeoLocation>) -> 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<ExistsQuery> for Query

fn eq(&self, other: &ExistsQuery) -> 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<FunctionScoreQuery> for Query

fn eq(&self, other: &FunctionScoreQuery) -> 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<FuzzyQuery> for Query

fn eq(&self, other: &FuzzyQuery) -> 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<GeoBoundingBoxQuery> for Query

fn eq(&self, other: &GeoBoundingBoxQuery) -> 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<GeoDistanceQuery> for Query

fn eq(&self, other: &GeoDistanceQuery) -> 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<GeoShapeLookupQuery> for Query

fn eq(&self, other: &GeoShapeLookupQuery) -> 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<GeoShapeQuery> for Query

fn eq(&self, other: &GeoShapeQuery) -> 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<HasChildQuery> for Query

fn eq(&self, other: &HasChildQuery) -> 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<HasParentQuery> for Query

fn eq(&self, other: &HasParentQuery) -> 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<IdsQuery> for Query

fn eq(&self, other: &IdsQuery) -> 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<JsonQuery> for Query

fn eq(&self, other: &JsonQuery) -> 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<KnnQuery> for Query

fn eq(&self, other: &KnnQuery) -> 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<MatchAllQuery> for Query

fn eq(&self, other: &MatchAllQuery) -> 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<MatchBoolPrefixQuery> for Query

fn eq(&self, other: &MatchBoolPrefixQuery) -> 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<MatchNoneQuery> for Query

fn eq(&self, other: &MatchNoneQuery) -> 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<MatchPhrasePrefixQuery> for Query

fn eq(&self, other: &MatchPhrasePrefixQuery) -> 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<MatchPhraseQuery> for Query

fn eq(&self, other: &MatchPhraseQuery) -> 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<MatchQuery> for Query

fn eq(&self, other: &MatchQuery) -> 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<MoreLikeThisQuery> for Query

fn eq(&self, other: &MoreLikeThisQuery) -> 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<MultiMatchQuery> for Query

fn eq(&self, other: &MultiMatchQuery) -> 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<NestedQuery> for Query

fn eq(&self, other: &NestedQuery) -> 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<ParentIdQuery> for Query

fn eq(&self, other: &ParentIdQuery) -> 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<PercolateLookupQuery> for Query

fn eq(&self, other: &PercolateLookupQuery) -> 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<PercolateQuery> for Query

fn eq(&self, other: &PercolateQuery) -> 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<PinnedQuery> for Query

fn eq(&self, other: &PinnedQuery) -> 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<PrefixQuery> for Query

fn eq(&self, other: &PrefixQuery) -> 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<Query> for BoostingQuery

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<Query> for CombinedFieldsQuery

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<Query> for ConstantScoreQuery

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<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<Query> for DistanceFeatureQuery<DateTime<Utc>>

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<Query> for DistanceFeatureQuery<GeoLocation>

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<Query> for ExistsQuery

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<Query> for FunctionScoreQuery

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<Query> for FuzzyQuery

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<Query> for GeoBoundingBoxQuery

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<Query> for GeoDistanceQuery

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<Query> for GeoShapeLookupQuery

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<Query> for GeoShapeQuery

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<Query> for HasChildQuery

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<Query> for HasParentQuery

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<Query> for IdsQuery

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<Query> for JsonQuery

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<Query> for KnnQuery

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<Query> for MatchAllQuery

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<Query> for MatchBoolPrefixQuery

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<Query> for MatchNoneQuery

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<Query> for MatchPhrasePrefixQuery

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<Query> for MatchPhraseQuery

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<Query> for MatchQuery

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<Query> for MoreLikeThisQuery

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<Query> for MultiMatchQuery

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<Query> for NestedQuery

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<Query> for ParentIdQuery

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<Query> for PercolateLookupQuery

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<Query> for PercolateQuery

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<Query> for PinnedQuery

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<Query> for PrefixQuery

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<Query> for QueryStringQuery

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<Query> for RangeQuery

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<Query> for RankFeatureLinearQuery

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<Query> for RankFeatureLogarithmQuery

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<Query> for RankFeatureQuery

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<Query> for RankFeatureSaturationQuery

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<Query> for RankFeatureSigmoidQuery

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<Query> for RegexpQuery

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<Query> for ScriptQuery

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<Query> for ScriptScoreQuery

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<Query> for ShapeLookupQuery

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<Query> for ShapeQuery

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<Query> for SimpleQueryStringQuery

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<Query> for SpanContainingQuery

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<Query> for SpanFieldMaskingQuery

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<Query> for SpanFirstQuery

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<Query> for SpanMultiQuery

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<Query> for SpanNearQuery

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<Query> for SpanNotQuery

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<Query> for SpanOrQuery

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<Query> for SpanTermQuery

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<Query> for SpanWithinQuery

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<Query> for TermQuery

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<Query> for TermsLookupQuery

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<Query> for TermsQuery

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<Query> for TermsSetQuery

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<Query> for WildcardQuery

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<Query> for WrapperQuery

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<QueryStringQuery> for Query

fn eq(&self, other: &QueryStringQuery) -> 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<RangeQuery> for Query

fn eq(&self, other: &RangeQuery) -> 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<RankFeatureLinearQuery> for Query

fn eq(&self, other: &RankFeatureLinearQuery) -> 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<RankFeatureLogarithmQuery> for Query

fn eq(&self, other: &RankFeatureLogarithmQuery) -> 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<RankFeatureQuery> for Query

fn eq(&self, other: &RankFeatureQuery) -> 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<RankFeatureSaturationQuery> for Query

fn eq(&self, other: &RankFeatureSaturationQuery) -> 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<RankFeatureSigmoidQuery> for Query

fn eq(&self, other: &RankFeatureSigmoidQuery) -> 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<RegexpQuery> for Query

fn eq(&self, other: &RegexpQuery) -> 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<ScriptQuery> for Query

fn eq(&self, other: &ScriptQuery) -> 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<ScriptScoreQuery> for Query

fn eq(&self, other: &ScriptScoreQuery) -> 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<ShapeLookupQuery> for Query

fn eq(&self, other: &ShapeLookupQuery) -> 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<ShapeQuery> for Query

fn eq(&self, other: &ShapeQuery) -> 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<SimpleQueryStringQuery> for Query

fn eq(&self, other: &SimpleQueryStringQuery) -> 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<SpanContainingQuery> for Query

fn eq(&self, other: &SpanContainingQuery) -> 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<SpanFieldMaskingQuery> for Query

fn eq(&self, other: &SpanFieldMaskingQuery) -> 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<SpanFirstQuery> for Query

fn eq(&self, other: &SpanFirstQuery) -> 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<SpanMultiQuery> for Query

fn eq(&self, other: &SpanMultiQuery) -> 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<SpanNearQuery> for Query

fn eq(&self, other: &SpanNearQuery) -> 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<SpanNotQuery> for Query

fn eq(&self, other: &SpanNotQuery) -> 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<SpanOrQuery> for Query

fn eq(&self, other: &SpanOrQuery) -> 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<SpanTermQuery> for Query

fn eq(&self, other: &SpanTermQuery) -> 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<SpanWithinQuery> for Query

fn eq(&self, other: &SpanWithinQuery) -> 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<TermQuery> for Query

fn eq(&self, other: &TermQuery) -> 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<TermsLookupQuery> for Query

fn eq(&self, other: &TermsLookupQuery) -> 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<TermsQuery> for Query

fn eq(&self, other: &TermsQuery) -> 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<TermsSetQuery> for Query

fn eq(&self, other: &TermsSetQuery) -> 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<WildcardQuery> for Query

fn eq(&self, other: &WildcardQuery) -> 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<WrapperQuery> for Query

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

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 Serialize for Query

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 Query