rust/tantivy
1
0
Fork 0
mirror of https://github.com/quickwit-oss/tantivy.git synced 2026-06-05 01:50:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Generic on Postings rather than deletes in TermScorer

Browse Source
This commit is contained in:
Paul Masurel
2018-02-22 08:26:45 +09:00
parent e423784fd0
commit 4ee2db25a0
10 changed files with 38 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/postings/delete_set.rs
View File

@@ -11,7 +11,7 @@ pub trait DeleteSet: 'static + From<Option<DeleteBitSet>> {
pub struct NoDelete;
impl DeleteSet for NoDelete {
#[inline(always)]
fn is_deleted(&self, doc: DocId) -> bool {
fn is_deleted(&self, _doc: DocId) -> bool {
false
}
fn empty() -> Self {

3
src/postings/mod.rs
View File

@@ -44,7 +44,7 @@ pub mod tests {
use DocId;
use Score;
use query::Intersection;
use query::{Weight, Scorer};
use query::Scorer;
use schema::{Document, SchemaBuilder, Term, INT_INDEXED, STRING, TEXT};
use core::SegmentComponent;
use indexer::SegmentWriter;
@@ -53,7 +53,6 @@ pub mod tests {
use schema::IndexRecordOption;
use std::iter;
use datastruct::stacker::Heap;
use query::TermQuery;
use schema::Field;
use test::{self, Bencher};
use indexer::operation::AddOperation;

2
src/postings/postings.rs
View File

@@ -10,7 +10,7 @@ use docset::DocSet;
/// Its main implementation is `SegmentPostings`,
/// but other implementations mocking `SegmentPostings` exist,
/// for merging segments or for testing.
pub trait Postings: DocSet {
pub trait Postings: DocSet + 'static {
/// Returns the term frequency
fn term_freq(&self) -> u32;
/// Returns the list of positions of the term, expressed as a list of

1
src/postings/segment_postings.rs
View File

@@ -9,7 +9,6 @@ use std::cmp;
use fst::Streamer;
use compression::compressed_block_size;
use postings::{NoDelete, DeleteSet};
use fastfield::DeleteBitSet;
use std::cell::UnsafeCell;
use directory::{ReadOnlySource, SourceRead};
use postings::FreqReadingOption;

33
src/query/boolean_query/boolean_weight.rs
View File

@@ -5,16 +5,15 @@ use std::collections::HashMap;
use query::EmptyScorer;
use query::Scorer;
use downcast::Downcast;
use query::term_query::TermScorer;
use std::borrow::Borrow;
use query::Exclude;
use query::Occur;
use query::RequiredOptionalScorer;
use query::IntersectionTwoTerms;
use fastfield::DeleteBitSet;
use postings::NoDelete;
use query::score_combiner::{DoNothingCombiner, ScoreCombiner, SumWithCoordsCombiner};
use Result;
use query::term_query::{TermScorerWithDeletes, TermScorerNoDeletes};
fn scorer_union<TScoreCombiner>(scorers: Vec<Box<Scorer>>) -> Box<Scorer>
where
@@ -28,14 +27,14 @@ where
{
let is_all_term_queries = scorers.iter().all(|scorer| {
let scorer_ref: &Scorer = scorer.borrow();
Downcast::<TermScorer<DeleteBitSet>>::is_type(scorer_ref)
Downcast::<TermScorerWithDeletes>::is_type(scorer_ref)
});
if is_all_term_queries {
let scorers: Vec<TermScorer<DeleteBitSet>> = scorers
let scorers: Vec<TermScorerWithDeletes> = scorers
.into_iter()
.map(|scorer| *Downcast::<TermScorer<DeleteBitSet>>::downcast(scorer).unwrap())
.map(|scorer| *Downcast::<TermScorerWithDeletes>::downcast(scorer).unwrap())
.collect();
let scorer: Box<Scorer> = box Union::<TermScorer<DeleteBitSet>, TScoreCombiner>::from(scorers);
let scorer: Box<Scorer> = box Union::<TermScorerWithDeletes, TScoreCombiner>::from(scorers);
return scorer;
}
}
@@ -43,14 +42,14 @@ where
{
let is_all_term_queries = scorers.iter().all(|scorer| {
let scorer_ref: &Scorer = scorer.borrow();
Downcast::<TermScorer<NoDelete>>::is_type(scorer_ref)
Downcast::<TermScorerNoDeletes>::is_type(scorer_ref)
});
if is_all_term_queries {
let scorers: Vec<TermScorer<NoDelete>> = scorers
let scorers: Vec<TermScorerNoDeletes> = scorers
.into_iter()
.map(|scorer| *Downcast::<TermScorer<NoDelete>>::downcast(scorer).unwrap())
.map(|scorer| *Downcast::<TermScorerNoDeletes>::downcast(scorer).unwrap())
.collect();
let scorer: Box<Scorer> = box Union::<TermScorer<NoDelete>, TScoreCombiner>::from(scorers);
let scorer: Box<Scorer> = box Union::<TermScorerNoDeletes, TScoreCombiner>::from(scorers);
return scorer;
}
}
@@ -102,7 +101,7 @@ impl BooleanWeight {
{
let is_all_term_queries = scorers.iter().all(|scorer| {
let scorer_ref: &Scorer = scorer.borrow();
Downcast::<TermScorer<DeleteBitSet>>::is_type(scorer_ref)
Downcast::<TermScorerWithDeletes>::is_type(scorer_ref)
});
if is_all_term_queries {
if scorers.len() == 2 {
@@ -110,9 +109,9 @@ impl BooleanWeight {
let left = scorers.pop().unwrap();
return box IntersectionTwoTerms::new(left, right);
} else {
let mut scorers: Vec<TermScorer<DeleteBitSet>> = scorers
let scorers: Vec<TermScorerWithDeletes> = scorers
.into_iter()
.map(|scorer| *Downcast::<TermScorer<DeleteBitSet>>::downcast(scorer).unwrap())
.map(|scorer| *Downcast::<TermScorerWithDeletes>::downcast(scorer).unwrap())
.collect();
let scorer: Box<Scorer> = box Intersection::from(scorers);
return scorer;
@@ -122,7 +121,7 @@ impl BooleanWeight {
{
let is_all_term_queries = scorers.iter().all(|scorer| {
let scorer_ref: &Scorer = scorer.borrow();
Downcast::<TermScorer<NoDelete>>::is_type(scorer_ref)
Downcast::<TermScorerNoDeletes>::is_type(scorer_ref)
});
if is_all_term_queries {
if scorers.len() == 2 {
@@ -130,9 +129,9 @@ impl BooleanWeight {
let left = scorers.pop().unwrap();
return box IntersectionTwoTerms::new(left, right);
} else {
let mut scorers: Vec<TermScorer<NoDelete>> = scorers
let scorers: Vec<TermScorerNoDeletes> = scorers
.into_iter()
.map(|scorer| *Downcast::<TermScorer<NoDelete>>::downcast(scorer).unwrap())
.map(|scorer| *Downcast::<TermScorerNoDeletes>::downcast(scorer).unwrap())
.collect();
let scorer: Box<Scorer> = box Intersection::from(scorers);
return scorer;

13
src/query/boolean_query/mod.rs
View File

@@ -12,7 +12,6 @@ mod tests {
use query::TermQuery;
use query::Intersection;
use query::Scorer;
use query::term_query::TermScorer;
use collector::tests::TestCollector;
use Index;
use downcast::Downcast;
@@ -20,8 +19,7 @@ mod tests {
use query::QueryParser;
use query::RequiredOptionalScorer;
use query::score_combiner::SumWithCoordsCombiner;
use query::term_query::TermScorerNoDeletes;
fn aux_test_helper() -> (Index, Field) {
let mut schema_builder = SchemaBuilder::default();
@@ -73,7 +71,7 @@ mod tests {
let searcher = index.searcher();
let weight = query.weight(&*searcher, true).unwrap();
let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
assert!(Downcast::<TermScorer>::is_type(&*scorer));
assert!(Downcast::<TermScorerNoDeletes>::is_type(&*scorer));
}
#[test]
@@ -85,7 +83,7 @@ mod tests {
let query = query_parser.parse_query("+a +b +c").unwrap();
let weight = query.weight(&*searcher, true).unwrap();
let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
assert!(Downcast::<Intersection<TermScorer<NoDelete>>>::is_type(&*scorer));
assert!(Downcast::<Intersection<TermScorerNoDeletes>>::is_type(&*scorer));
}
{
let query = query_parser.parse_query("+a +(b c)").unwrap();
@@ -95,8 +93,6 @@ mod tests {
}
}
use postings::NoDelete;
#[test]
pub fn test_boolean_reqopt() {
let (index, text_field) = aux_test_helper();
@@ -112,7 +108,8 @@ mod tests {
let query = query_parser.parse_query("+a b").unwrap();
let weight = query.weight(&*searcher, false).unwrap();
let scorer = weight.scorer(searcher.segment_reader(0u32)).unwrap();
assert!(Downcast::<TermScorer<NoDelete>>::is_type(&*scorer));
println!("{:?}", scorer.type_name());
assert!(Downcast::<TermScorerNoDeletes>::is_type(&*scorer));
}
}

5
src/query/intersection_two.rs
View File

@@ -2,9 +2,6 @@ use docset::DocSet;
use query::Scorer;
use DocId;
use Score;
use std::mem;
use query::term_query::TermScorer;
use postings::DeleteSet;
use SkipResult;
@@ -15,7 +12,7 @@ pub struct IntersectionTwoTerms<TDocSet> {
}
impl<TDocSet: DocSet> IntersectionTwoTerms<TDocSet> {
pub fn new(left: TDocSet, mut right: TDocSet) -> IntersectionTwoTerms<TDocSet> {
pub fn new(left: TDocSet, right: TDocSet) -> IntersectionTwoTerms<TDocSet> {
IntersectionTwoTerms {
left,
right

7
src/query/term_query/mod.rs
View File

@@ -6,6 +6,13 @@ pub use self::term_query::TermQuery;
pub use self::term_weight::TermWeight;
pub use self::term_scorer::TermScorer;
use postings::SegmentPostings;
use postings::NoDelete;
use fastfield::DeleteBitSet;
pub(crate) type TermScorerWithDeletes = TermScorer<SegmentPostings<DeleteBitSet>>;
pub(crate) type TermScorerNoDeletes = TermScorer<SegmentPostings<NoDelete>>;
#[cfg(test)]
mod tests {

18
src/query/term_query/term_scorer.rs
View File

@@ -1,25 +1,17 @@
use Score;
use DocId;
use docset::{DocSet, SkipResult};
use postings::SegmentPostings;
use query::Scorer;
use postings::Postings;
use fastfield::FastFieldReader;
use postings::{NoDelete, DeleteSet};
use postings::Postings;
pub struct TermScorer<TDeleteSet: DeleteSet=NoDelete> {
pub struct TermScorer<TPostings: Postings> {
pub idf: Score,
pub fieldnorm_reader_opt: Option<FastFieldReader<u64>>,
pub postings: SegmentPostings<TDeleteSet>,
pub postings: TPostings,
}
impl<TDeleteSet: DeleteSet> TermScorer<TDeleteSet> {
pub fn postings(&self) -> &SegmentPostings<TDeleteSet> {
&self.postings
}
}
impl<TDeleteSet: DeleteSet> DocSet for TermScorer<TDeleteSet> {
impl<TPostings: Postings> DocSet for TermScorer<TPostings> {
fn advance(&mut self) -> bool {
self.postings.advance()
}
@@ -37,7 +29,7 @@ impl<TDeleteSet: DeleteSet> DocSet for TermScorer<TDeleteSet> {
}
}
impl<TDeleteSet: DeleteSet> Scorer for TermScorer<TDeleteSet> {
impl<TPostings: Postings> Scorer for TermScorer<TPostings> {
fn score(&mut self) -> Score {
let doc = self.postings.doc();
let tf = match self.fieldnorm_reader_opt {

2
src/query/term_query/term_weight.rs
View File

@@ -7,7 +7,7 @@ use postings::SegmentPostings;
use schema::IndexRecordOption;
use super::term_scorer::TermScorer;
use fastfield::DeleteBitSet;
use postings::{DeleteSet, NoDelete};
use postings::NoDelete;
use Result;
pub struct TermWeight {