Struct ReservoirSampling 

pub struct ReservoirSampling { /* private fields */ }

ReservoirSampling collector collects k random documents using O(k) memory

use summa_core::collectors::ReservoirSampling;
use summa_core::configs::core::QueryParserConfig;
use summa_core::components::{MorphologyManager, QueryParser};
use tantivy::collector::Count;
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(15_000_000).unwrap();
index_writer.add_document(doc!(title => "The Name of the Wind")).unwrap();
index_writer.add_document(doc!(title => "The Diary of Muadib")).unwrap();
index_writer.add_document(doc!(title => "A Dairy Cow")).unwrap();
index_writer.add_document(doc!(title => "The Diary of a Young Girl")).unwrap();
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, QueryParserConfig::from_default_fields(vec!["title".to_string()]), &MorphologyManager::default()).unwrap();
let query = query_parser.parse_query("diary").unwrap();
let documents = searcher.search(&query, &ReservoirSampling::with_limit(2)).unwrap();

assert_eq!(documents.len(), 2);

Implementations

impl ReservoirSampling

Implements Algorithm R for weighted sampling from the downstream Fruit. It uses O(k) memory and has O(n) time complexity.

pub fn with_limit(limit: usize) -> ReservoirSampling

Trait Implementations

impl Collector for ReservoirSampling

type Fruit = Vec<DocAddress>

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

type Child = SegmentReservoirSamplingCollector

Type of the SegmentCollector associated with this collector.

fn for_segment( &self, segment_ord: SegmentOrdinal, _: &SegmentReader, ) -> Result<SegmentReservoirSamplingCollector>

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_docs_vec: Vec<(Vec<DocAddress>, usize)>, ) -> Result<Vec<DocAddress>>

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

fn for_segment_async<'life0, 'life1, 'async_trait>( &'life0 self, segment_local_id: u32, segment: &'life1 SegmentReader, ) -> Pin<Box<dyn Future<Output = Result<Self::Child, TantivyError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

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

Created a segment collector and

fn collect_segment_async<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, weight: &'life1 (dyn Weight + 'static), segment_ord: u32, reader: &'life2 SegmentReader, ) -> Pin<Box<dyn Future<Output = Result<<Self::Child as SegmentCollector>::Fruit, TantivyError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Created a segment collector in async way