Struct PhraseQuery 

pub struct PhraseQuery {
    pub field: Field,
    pub terms: Vec<Vec<u8>>,
    pub offsets: Vec<u32>,
    pub slop: u32,
    /* private fields */
}

Phrase query - matches documents containing terms in consecutive positions

Example: “quick brown fox” matches only if all three terms appear consecutively in the document.

Fields

field: Field

terms: Vec<Vec<u8>>

Terms in the phrase, in order

offsets: Vec<u32>

Token offset of each term inside the phrase, ascending, one per term. offsets[i + 1] - offsets[i] is the required distance between two consecutive terms: 1 for adjacent words, more when index-time stop words were dropped between them (quantum@0 art@3). PhraseQuery::new makes every term adjacent.

slop: u32

Optional slop (max distance between terms, 0 = exact phrase)

Implementations

impl PhraseQuery

pub fn new(field: Field, terms: Vec<Vec<u8>>) -> Self

Create a new exact phrase query of adjacent terms.

pub fn with_offsets(field: Field, terms: Vec<(u32, Vec<u8>)>) -> Self

Create a phrase whose terms carry their token offsets, as produced by a tokenizer that drops stop words without renumbering ((0, quantum), (3, art) for “quantum of the art”). Offsets must be ascending.

pub fn text(field: Field, phrase: &str) -> Self

Create from text using the simple tokenizer (whitespace split, punctuation stripped, lowercased). Fields with a stemming tokenizer should tokenize the phrase themselves and call PhraseQuery::with_offsets so the query terms match the indexed stems and keep the gaps of dropped stop words.

pub fn with_slop(self, slop: u32) -> Self

Set slop (max distance between terms)

pub fn with_global_stats(self, stats: Arc<GlobalStats>) -> Self

Set global statistics for cross-segment IDF

Trait Implementations

impl Clone for PhraseQuery

fn clone(&self) -> PhraseQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PhraseQuery

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

Formats the value using the given formatter.

impl Display for PhraseQuery

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

Formats the value using the given formatter.

impl Query for PhraseQuery

fn as_doc_bitset(&self, reader: &SegmentReader) -> Option<DocBitset>

Every document containing the phrase, as a bitset (documents, also for chunked fields). Lets the planner push a quoted span into the MaxScore executors as an O(1) predicate instead of a verifier.

fn bitset_cardinality_estimate(&self, reader: &SegmentReader) -> Option<u64>

Matches are at most the rarest term’s postings; the planner only needs the order of magnitude to pick which clause to materialize.

fn text_terms(&self, out: &mut Vec<(Field, Vec<u8>)>)

Append every (field, term) this query scores with BM25 to out. The searcher aggregates their document frequencies across segments before scoring (see ScorerOptions::global_stats).

fn scorer<'a>( &self, reader: &'a SegmentReader, limit: usize, ) -> ScorerFuture<'a>

Create a scorer for this query against a single segment (async)

fn scorer_with_options<'a>( &self, reader: &'a SegmentReader, limit: usize, options: ScorerOptions, ) -> ScorerFuture<'a>

Create a scorer with collector-specific construction options. Query implementations that can avoid optional position data should override this; the default preserves existing behavior.

fn scorer_sync<'a>( &self, reader: &'a SegmentReader, limit: usize, ) -> Result<Box<dyn Scorer + 'a>>

Create a scorer synchronously (mmap/RAM only).

fn scorer_sync_with_options<'a>( &self, reader: &'a SegmentReader, limit: usize, options: ScorerOptions, ) -> Result<Box<dyn Scorer + 'a>>

Synchronous counterpart to Query::scorer_with_options.

fn count_estimate<'a>(&self, reader: &'a SegmentReader) -> CountFuture<'a>

Estimated number of matching documents in a segment (async)

fn decompose(&self) -> QueryDecomposition

Decompose this query for MaxScore optimization.

fn is_filter(&self) -> bool

True if this query is a pure filter (always scores 1.0, no positions). Used by the planner to convert non-selective MUST filters into predicates.

fn as_doc_predicate<'a>( &self, _reader: &'a SegmentReader, ) -> Option<DocPredicate<'a>>

For filter queries: return a cheap per-doc predicate against a segment. The predicate does O(1) work per doc (e.g., fast-field lookup).