Struct DenseVectorQuery 

pub struct DenseVectorQuery {
    pub field: Field,
    pub vector: Vec<f32>,
    pub nprobe: usize,
    pub rerank_factor: f32,
    pub combiner: MultiValueCombiner,
    /* private fields */
}

Dense vector query for similarity search

Fields

field: Field

Field containing the dense vectors

vector: Vec<f32>

Query vector

nprobe: usize

Number of clusters to probe (for IVF indexes)

rerank_factor: f32

Re-ranking factor multiplied by k for candidate selection (1x to 2x)

combiner: MultiValueCombiner

How to combine scores for multi-valued documents

Implementations

impl DenseVectorQuery

pub fn new(field: Field, vector: Vec<f32>) -> Self

Create a new dense vector query

pub fn with_nprobe(self, nprobe: usize) -> Self

Set the number of clusters to probe (for IVF indexes)

Values are validated when the query is executed. See MAX_DENSE_NPROBE.

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

Set the re-ranking factor (e.g. 2.0 = fetch 2x candidates for reranking)

Values are validated when the query is executed. See MAX_DENSE_RERANK_FACTOR.

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

Set the multi-value score combiner

Trait Implementations

impl Clone for DenseVectorQuery

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 DenseVectorQuery

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

Formats the value using the given formatter.

impl Display for DenseVectorQuery

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

Formats the value using the given formatter.

impl Query for DenseVectorQuery

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 scorer<'a>( &self, reader: &'a SegmentReader, limit: usize, ) -> ScorerFuture<'a>

Create a scorer for this query against a single 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 count_estimate<'a>(&self, _reader: &'a SegmentReader) -> CountFuture<'a>

Estimated number of matching documents in a 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_with_options<'a>( &self, reader: &'a SegmentReader, limit: usize, options: ScorerOptions, ) -> Result<Box<dyn Scorer + 'a>>

Synchronous counterpart to Query::scorer_with_options.

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