Struct Searcher 

pub struct Searcher<D: Directory + 'static> { /* private fields */ }

Searcher - provides search over loaded segments

For wasm/read-only use, create via Searcher::open(). For native use with Index, this is created via IndexReader.

Implementations

impl<D: Directory + 'static> Searcher<D>

pub async fn open( directory: Arc<D>, schema: Arc<Schema>, segment_ids: &[String], term_cache_blocks: usize, ) -> Result<Self>

Create a Searcher directly from segment IDs

This is a simpler initialization path that doesn’t require SegmentManager. Use this for read-only access to pre-built indexes.

pub fn schema(&self) -> &Schema

Get the schema

pub fn segment_readers(&self) -> &[Arc<SegmentReader>]

Get segment readers

pub fn default_fields(&self) -> &[Field]

Get default fields for search

pub fn tokenizers(&self) -> &TokenizerRegistry

Get tokenizer registry

pub fn trained_centroids(&self) -> &FxHashMap<u32, Arc<CoarseCentroids>>

Get trained centroids

pub fn global_stats(&self) -> &Arc<LazyGlobalStats>

Get lazy global statistics for cross-segment IDF computation

pub fn num_docs(&self) -> u32

Get total document count across all segments

pub fn segment_map(&self) -> &FxHashMap<u128, usize>

Get O(1) segment_id → index map (used by reranker)

pub fn num_segments(&self) -> usize

Get number of segments

pub async fn doc(&self, doc_id: u32) -> Result<Option<Document>>

Get a document by global doc_id (binary search on cumulative offsets)

pub async fn search( &self, query: &dyn Query, limit: usize, ) -> Result<Vec<SearchResult>>

Search across all segments and return aggregated results

pub async fn search_with_count( &self, query: &dyn Query, limit: usize, ) -> Result<(Vec<SearchResult>, u32)>

Search across all segments and return (results, total_seen) total_seen is the number of documents that were scored across all segments

pub async fn search_with_offset( &self, query: &dyn Query, limit: usize, offset: usize, ) -> Result<Vec<SearchResult>>

Search with offset for pagination

pub async fn search_with_offset_and_count( &self, query: &dyn Query, limit: usize, offset: usize, ) -> Result<(Vec<SearchResult>, u32)>

Search with offset and return (results, total_seen)

pub async fn search_with_positions( &self, query: &dyn Query, limit: usize, ) -> Result<(Vec<SearchResult>, u32)>

Search with positions (ordinal tracking) and return (results, total_seen)

Use this when you need per-ordinal scores for multi-valued fields.

pub async fn search_and_rerank( &self, query: &dyn Query, l1_limit: usize, final_limit: usize, config: &RerankerConfig, ) -> Result<(Vec<SearchResult>, u32)>

Two-stage search: L1 retrieval + L2 dense vector reranking

Runs the query to get l1_limit candidates, then reranks by exact dense vector distance and returns the top final_limit results.

pub async fn query( &self, query_str: &str, limit: usize, ) -> Result<SearchResponse>

Parse query string and search (convenience method)

pub async fn query_offset( &self, query_str: &str, limit: usize, offset: usize, ) -> Result<SearchResponse>

Parse query string and search with offset (convenience method)

pub fn query_parser(&self) -> QueryLanguageParser

Get query parser for this searcher

pub async fn get_document( &self, address: &DocAddress, ) -> Result<Option<Document>>

Get a document by address (segment_id + global doc_id)

The doc_id in the address is a global doc_id (with doc_id_offset applied). This method converts it back to a segment-local doc_id for the store lookup.

pub async fn get_document_with_fields( &self, address: &DocAddress, fields: Option<&FxHashSet<u32>>, ) -> Result<Option<Document>>

Get a document by address, hydrating only the specified field IDs.

If fields is None, all fields are hydrated (including dense vectors). If fields is Some(set), only dense vector fields in the set are read from flat storage — skipping expensive mmap reads for unrequested vectors.