Struct Index 

pub struct Index<D: Directory> { /* private fields */ }

Multi-segment async Index

The main entry point for searching. Manages multiple segments and provides unified search across all of them.

Implementations

impl<D: Directory> Index<D>

pub async fn open(directory: D, config: IndexConfig) -> Result<Self>

Open an existing index from a directory

pub fn schema(&self) -> &Schema

Get the schema

pub fn directory(&self) -> &D

Get a reference to the underlying directory

pub fn num_docs(&self) -> u32

Total number of documents across all segments

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

Get a document by global doc_id (async)

pub async fn get_postings( &self, field: Field, term: &[u8], ) -> Result<Vec<(Arc<SegmentReader>, BlockPostingList)>>

Get posting lists for a term across all segments (async)

pub async fn spawn_blocking<F, R>(&self, f: F) -> R

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Execute CPU-intensive work on thread pool (native only)

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

Get segment readers for query execution

pub async fn reload(&self) -> Result<()>

Reload segments from directory (after new segments added)

pub fn global_stats(&self) -> Option<Arc<GlobalStats>>

Get global statistics for cross-segment IDF computation (sync, basic stats only)

Returns cached stats if available. For full stats including term frequencies, call build_global_stats().await first.

This sync version only includes:

• Total docs
• Sparse vector dimension document frequencies
• Average field lengths

pub async fn build_global_stats(&self) -> Result<Arc<GlobalStats>>

Build and cache global statistics (async, includes term frequencies)

This iterates term dictionaries across all segments to compute accurate cross-segment IDF values for full-text queries.

Call this once after opening the index or after reload().

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

Search and return results with document addresses (no document content)

This is the primary search method. Use get_document to fetch document content.

pub async fn search_offset( &self, query: &dyn Query, limit: usize, offset: usize, ) -> Result<SearchResponse>

Search with offset for pagination

pub async fn search_with_matched_fields( &self, query: &dyn Query, limit: usize, ) -> Result<SearchResponse>

Search with matched field ordinals (for multi-valued fields with position tracking)

Returns which array elements matched for each field with position tracking enabled.

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

Get a document by its unique address (segment_id + local doc_id)

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

Get the default fields for this index

pub fn set_default_fields(&mut self, fields: Vec<Field>)

Set the default fields for query parsing

pub fn tokenizers(&self) -> &Arc<TokenizerRegistry>

Get the tokenizer registry

pub fn query_parser(&self) -> QueryLanguageParser

Create a query parser for this index

If the schema contains query router rules, they will be used to route queries to specific fields based on regex patterns.

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

Parse and search using a query string

Accepts both query language syntax (field:term, AND, OR, NOT, grouping) and simple text (tokenized and searched across default fields). Returns document addresses (segment_id + doc_id) without document content.

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

Query with offset for pagination

impl<D: Directory> Index<SliceCachingDirectory<D>>

Methods for opening index with slice caching

pub async fn open_with_cache( directory: D, config: IndexConfig, cache_max_bytes: usize, ) -> Result<Self>

Open an index with slice caching, automatically loading the cache file if present

This wraps the directory in a SliceCachingDirectory and attempts to load any existing slice cache file to prefill the cache with hot data.

pub async fn save_slice_cache(&self) -> Result<()>

where D: DirectoryWriter,

Serialize the current slice cache to the index directory

This saves all cached slices to a single file that can be loaded on subsequent index opens for faster startup.

pub fn slice_cache_stats(&self) -> SliceCacheStats

Get slice cache statistics

Trait Implementations

impl<D: Directory> Clone for Index<D>

Available on crate feature native only.

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.