Struct tantivy::collector::MultiCollector

pub struct MultiCollector<'a> { /* fields omitted */ }

Multicollector makes it possible to collect on more than one collector. It should only be used for use cases where the Collector types is unknown at compile time.

If the type of the collectors is known, you can just group yours collectors in a tuple. See the Combining several collectors section of the collector documentation.

use tantivy::collector::{Count, TopDocs, MultiCollector};
use tantivy::query::QueryParser;
use tantivy::schema::{Schema, TEXT};
use tantivy::{doc, Index};

let mut schema_builder = Schema::builder();
let title = schema_builder.add_text_field("title", TEXT);
let schema = schema_builder.build();
let index = Index::create_in_ram(schema);

let mut index_writer = index.writer(3_000_000).unwrap();
index_writer.add_document(doc!(title => "The Name of the Wind"));
index_writer.add_document(doc!(title => "The Diary of Muadib"));
index_writer.add_document(doc!(title => "A Dairy Cow"));
index_writer.add_document(doc!(title => "The Diary of a Young Girl"));
assert!(index_writer.commit().is_ok());

let reader = index.reader().unwrap();
let searcher = reader.searcher();

let mut collectors = MultiCollector::new();
let top_docs_handle = collectors.add_collector(TopDocs::with_limit(2));
let count_handle = collectors.add_collector(Count);
let query_parser = QueryParser::for_index(&index, vec![title]);
let query = query_parser.parse_query("diary").unwrap();
let mut multi_fruit = searcher.search(&query, &collectors).unwrap();

let count = count_handle.extract(&mut multi_fruit);
let top_docs = top_docs_handle.extract(&mut multi_fruit);

assert_eq!(count, 2);
assert_eq!(top_docs.len(), 2);

Implementations

impl<'a> MultiCollector<'a>

pub fn new() -> Self

Create a new MultiCollector

pub fn add_collector<'b: 'a, TCollector: Collector + 'b>(
    &mut self,
    collector: TCollector
) -> FruitHandle<TCollector::Fruit>

Add a new collector to our MultiCollector.

Trait Implementations

impl<'a> Collector for MultiCollector<'a>

type Fruit = MultiFruit

Fruit is the type for the result of our collection. e.g. usize for the Count collector.

type Child = MultiCollectorChild

Type of the SegmentCollector associated to this collector.

fn for_segment(
    &self,
    segment_local_id: SegmentOrdinal,
    segment: &SegmentReader
) -> Result<MultiCollectorChild>

set_segment is called before beginning to enumerate on this segment.

fn requires_scoring(&self) -> bool

Returns true iff the collector requires to compute scores for documents.

fn merge_fruits(
    &self,
    segments_multifruits: Vec<MultiFruit>
) -> Result<MultiFruit>

Combines the fruit associated to the collection of each segments into one fruit.

fn collect_segment(
    &self,
    weight: &dyn Weight,
    segment_ord: u32,
    reader: &SegmentReader
) -> Result<<Self::Child as SegmentCollector>::Fruit>

Created a segment collector and

impl<'a> Default for MultiCollector<'a>

fn default() -> MultiCollector<'a>

Returns the “default value” for a type.