Struct tantivy::collector::Count

pub struct Count;

CountCollector collector only counts how many documents match the query.

#[macro_use]
extern crate tantivy;
use tantivy::schema::{Schema, TEXT};
use tantivy::{Index, Result};
use tantivy::collector::Count;
use tantivy::query::QueryParser;

fn example() -> Result<()> {
    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)?;
        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",
        ));
        index_writer.commit().unwrap();
    }

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

    {
        let query_parser = QueryParser::for_index(&index, vec![title]);
        let query = query_parser.parse_query("diary")?;
        let count = searcher.search(&query, &Count).unwrap();

        assert_eq!(count, 2);
    }

    Ok(())
}

Trait Implementations

impl Collector for Count

type Fruit = usize

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

type Child = SegmentCountCollector

Type of the SegmentCollector associated to this collector.

fn for_segment(
    &self,
    _: SegmentLocalId,
    _: &SegmentReader
) -> Result<SegmentCountCollector>

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, segment_counts: Vec<usize>) -> Result<usize>

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