Struct RegexpQuery

pub struct RegexpQuery { /* private fields */ }

Returns documents that contain terms matching a regular expression.

A regular expression is a way to match patterns in data using placeholder characters, called operators. For a list of operators supported by the regexp query, see Regular expression syntax.

To create a regexp query:

Query::regexp("test", "username");

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

Implementations

impl RegexpQuery

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

where __S: Serializer,

impl RegexpQuery

pub fn flags<I>(self, flags: I) -> Self

where I: IntoIterator<Item = RegexpFlag>,

Enables optional operators for the regular expression. For valid values and more information, see Regular expression syntax.

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

Allows case insensitive matching of the regular expression value with the indexed field values when set to true. Default is false which means the case sensitivity of matching depends on the underlying field’s mapping.

pub fn max_determinized_states(self, max_determinized_states: u64) -> 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 rewrite(self, rewrite: Rewrite) -> Self

Method used to rewrite the query. For valid values and more information, see the rewrite 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 RegexpQuery

fn clone(&self) -> RegexpQuery

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RegexpQuery

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

Formats the value using the given formatter.

impl From<RegexpQuery> for MultiTermQuery

fn from(q: RegexpQuery) -> Self

Converts to this type from the input type.

impl From<RegexpQuery> for Option<MultiTermQuery>

fn from(q: RegexpQuery) -> Self

Converts to this type from the input type.

impl From<RegexpQuery> for Option<Query>

fn from(q: RegexpQuery) -> 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 IntoIterator for RegexpQuery

type Item = RegexpQuery

The type of the elements being iterated over.

type IntoIter = IntoIter<<RegexpQuery 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<MultiTermQuery> for RegexpQuery

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

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

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

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 RegexpQuery