Struct tantivy::Searcher

pub struct Searcher { /* private fields */ }

Holds a list of SegmentReaders ready for search.

It guarantees that the Segment will not be removed before the destruction of the Searcher.

Implementations

impl Searcher

pub fn index(&self) -> &Index

Returns the Index associated with the Searcher

pub fn generation(&self) -> &SearcherGeneration

SearcherGeneration which identifies the version of the snapshot held by this Searcher.

pub fn doc<D: DocumentDeserialize>(&self, doc_address: DocAddress) -> Result<D>

Fetches a document from tantivy’s store given a DocAddress.

The searcher uses the segment ordinal to route the request to the right Segment.

pub fn doc_store_cache_stats(&self) -> CacheStats

The cache stats for the underlying store reader.

Aggregates the sum for each segment store reader.

pub fn schema(&self) -> &Schema

Access the schema associated with the index of this searcher.

pub fn num_docs(&self) -> u64

Returns the overall number of documents in the index.

pub fn doc_freq(&self, term: &Term) -> Result<u64>

Return the overall number of documents containing the given term.

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

Return the list of segment readers

pub fn segment_reader(&self, segment_ord: u32) -> &SegmentReader

Returns the segment_reader associated with the given segment_ord

pub fn search<C: Collector>( &self, query: &dyn Query, collector: &C ) -> Result<C::Fruit>

Runs a query on the segment readers wrapped by the searcher.

Search works as follows :

First the weight object associated with the query is created.

Then, the query loops over the segments and for each segment :

• setup the collector and informs it that the segment being processed has changed.
• creates a SegmentCollector for collecting documents associated with the segment
• creates a Scorer object associated for this segment
• iterate through the matched documents and push them to the segment collector.

Finally, the Collector merges each of the child collectors into itself for result usability by the caller.

pub fn search_with_statistics_provider<C: Collector>( &self, query: &dyn Query, collector: &C, statistics_provider: &dyn Bm25StatisticsProvider ) -> Result<C::Fruit>

Same as search(...) but allows specifying a Bm25StatisticsProvider.

This can be used to adjust the statistics used in computing BM25 scores.

pub fn search_with_executor<C: Collector>( &self, query: &dyn Query, collector: &C, executor: &Executor, enabled_scoring: EnableScoring<'_> ) -> Result<C::Fruit>

Same as search(...) but multithreaded.

The current implementation is rather naive : multithreading is by splitting search into as many task as there are segments.

It is powerless at making search faster if your index consists in one large segment.

Also, keep in my multithreading a single query on several threads will not improve your throughput. It can actually hurt it. It will however, decrease the average response time.

pub fn space_usage(&self) -> Result<SearcherSpaceUsage>

Summarize total space usage of this searcher.

Trait Implementations

impl Bm25StatisticsProvider for Searcher

fn total_num_tokens(&self, field: Field) -> Result<u64>

The total number of tokens in a given field across all documents in the index.

fn total_num_docs(&self) -> Result<u64>

The total number of documents in the index.

fn doc_freq(&self, term: &Term) -> Result<u64>

The number of documents containing the given term.

impl Clone for Searcher

fn clone(&self) -> Searcher

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Searcher

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

Formats the value using the given formatter.

impl From<Arc<SearcherInner>> for Searcher

fn from(inner: Arc<SearcherInner>) -> Self

Converts to this type from the input type.