Struct tantivy::collector::Count

pub struct Count;

CountCollector collector only counts how many documents match the query.

use tantivy::collector::Count;
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();

// Here comes the important part
let query_parser = QueryParser::for_index(&index, vec![title]);
let query = query_parser.parse_query("diary").unwrap();
let count = searcher.search(&query, &Count).unwrap();

assert_eq!(count, 2);

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.

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

Created a segment collector and