Struct SparseTermQuery 

pub struct SparseTermQuery {
    pub field: Field,
    pub dim_id: u32,
    pub weight: f32,
    pub combiner: MultiValueCombiner,
    pub heap_factor: f32,
    pub over_fetch_factor: f32,
    pub lsp_gamma: Option<usize>,
    pub seismic_cut: usize,
    pub seismic_factor: f32,
    pub exhaustive: bool,
}

Query for a single sparse vector dimension.

Analogous to TermQuery for text: searches one dimension’s posting list with a given weight. Multiple SparseTermQuery instances are combined as BooleanQuery SHOULD clauses to form a full sparse vector search.

Fields

field: Field

dim_id: u32

weight: f32

combiner: MultiValueCombiner

Multi-value combiner for ordinal deduplication

heap_factor: f32

over_fetch_factor: f32

lsp_gamma: Option<usize>

seismic_cut: usize

seismic_factor: f32

exhaustive: bool

Implementations

impl SparseTermQuery

pub fn new(field: Field, dim_id: u32, weight: f32) -> Self

pub fn with_heap_factor(self, heap_factor: f32) -> Self

pub fn with_over_fetch_factor(self, factor: f32) -> Self

pub fn with_lsp_gamma(self, gamma: usize) -> Self

pub fn with_seismic_cut(self, cut: usize) -> Self

pub fn with_seismic_factor(self, factor: f32) -> Self

pub fn with_exhaustive(self, exhaustive: bool) -> Self

pub fn with_combiner(self, combiner: MultiValueCombiner) -> Self

Trait Implementations

impl Clone for SparseTermQuery

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 SparseTermQuery

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

Formats the value using the given formatter.

impl Display for SparseTermQuery

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

Formats the value using the given formatter.

impl Query for SparseTermQuery

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

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

Build a compact bitset of matching doc_ids for this query.

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