Struct BooleanQuery 

pub struct BooleanQuery {
    pub must: Vec<Arc<dyn Query>>,
    pub should: Vec<Arc<dyn Query>>,
    pub must_not: Vec<Arc<dyn Query>>,
    /* private fields */
}

Boolean query with MUST, SHOULD, and MUST_NOT clauses

When all clauses are SHOULD term queries on the same field, automatically uses MaxScore optimization for efficient top-k retrieval.

Fields

must: Vec<Arc<dyn Query>>

should: Vec<Arc<dyn Query>>

must_not: Vec<Arc<dyn Query>>

Implementations

impl BooleanQuery

pub fn new() -> Self

pub fn must(self, query: impl Query + 'static) -> Self

pub fn should(self, query: impl Query + 'static) -> Self

pub fn must_not(self, query: impl Query + 'static) -> Self

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

Set global statistics for cross-segment IDF

pub fn with_proximity(self, config: ProximityConfig) -> Self

Rescore the text MaxScore top candidates with term proximity (docs: query::proximity). Applies when the SHOULD clauses are text terms of one field, in query order.

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

Approximate text MaxScore (threshold / heap_factor), like sparse. 1 is exact; [0, 1) prunes more aggressively, with an effective 0.01 floor. Non-finite values and values outside [0, 1] fail construction of the scorer. RPC zero/unset is normalized to 1 by the adapter.

pub fn with_max_terms(self, max_terms: usize) -> Self

Cap the text terms scored per field group to the max_terms rarest (highest idf) ones; 0 = no cap.

Trait Implementations

impl Clone for BooleanQuery

fn clone(&self) -> BooleanQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BooleanQuery

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

Formats the value using the given formatter.

impl Default for BooleanQuery

fn default() -> Self

Returns the “default value” for a type.

impl Display for BooleanQuery

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

Formats the value using the given formatter.

impl Query for BooleanQuery

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

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

Estimated number of matching documents in a segment (async)

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