Struct TermQuery 

pub struct TermQuery {
    pub field: Field,
    pub term: Vec<u8>,
    /* private fields */
}

Term query - matches documents containing a specific term

Fields

field: Field

term: Vec<u8>

Implementations

impl TermQuery

pub fn new(field: Field, term: impl Into<Vec<u8>>) -> Self

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

pub fn with_global_stats( field: Field, text: &str, stats: Arc<GlobalStats>, ) -> Self

Create with global statistics for cross-segment IDF

pub fn set_global_stats(&mut self, stats: Arc<GlobalStats>)

Set global statistics for cross-segment IDF

Trait Implementations

impl Clone for TermQuery

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TermQuery

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

Formats the value using the given formatter.

impl Display for TermQuery

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

Formats the value using the given formatter.

impl Query for TermQuery

fn physical_text_field( &self, reader: &SegmentReader, complete: bool, ) -> Option<Field>

Opt into one field-local physical address space for collection. Every child must honor the internal scorer scope. Unknown/custom queries retain logical IDs. Ranked term/union executors may keep their existing mapping by opting in only for complete streams.

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 count_estimate<'a>(&self, reader: &'a SegmentReader) -> CountFuture<'a>

Estimated number of matching documents in a segment (async)

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 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).

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

Cheap estimate of how many docs this filter clause matches in the segment. Used by the boolean planner to order MUST/MUST_NOT evaluation: the narrowest clause is materialized first and wider clauses refine it with per-doc probes instead of being fully materialized. None = unknown (treated as matching everything).

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

Build a compact bitset of matching doc_ids for this query.

fn as_doc_bitset_with_options( &self, reader: &SegmentReader, options: &ScorerOptions, ) -> Option<DocBitset>

Budget-aware materialization. None means unsupported or cancelled; cancellation must flag the shared budget, and a partial bitset must never escape as a complete filter.

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 decompose(&self) -> QueryDecomposition

Decompose this query for MaxScore optimization.

fn sparse_decomposition(&self) -> QueryDecomposition

Sparse terms for query-global BMP superblock planning only. Unlike scoring decomposition, this never replaces a query’s scorer. A filter wrapper may expose its inner sparse query here while remaining opaque to Boolean scoring optimizations.

fn candidate_query(&self) -> Result<CandidateQuery>

Exact scoring plan for a named L1 branch. Unsupported queries reject explicitly rather than returning truncated retrieval scores.

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 count_equivalent_term(&self) -> Option<TermQueryInfo>

A term with identical membership for count-only collection. This does not change scoring decomposition. The collector must still account for deleted rows, chunks and missing metadata.

fn ranked_count_equivalent_term(&self) -> Option<TermQueryInfo>

A term-equivalent cardinality alongside an exact score-only text rank plan. Unlike the count-only hint, opaque/custom plans do not opt in automatically. The collector still validates the indexed document space, deletions, mappings and cardinality gate.

fn supports_ranked_conjunction_count(&self) -> bool

Opt into top-level bounded conjunction results with an exact count. Wrappers must not inherit this automatically: they may consume or hide a child’s cardinality. Defaults to streaming.

fn should_children(&self) -> Option<&[Arc<dyn Query>]>

For a query that is a pure disjunction of sub-queries (a Boolean query with only SHOULD clauses and no boost), the clauses.