Issue/range query (#242)

BitSet and RangeQuery

src/query/boolean_query/boolean_query.rs

@@ -8,7 +8,6 @@ use schema::Term;
 use query::TermQuery;
 use schema::IndexRecordOption;
 use query::Occur;
-use query::OccurFilter;
 
 /// The boolean query combines a set of queries
 ///
@@ -39,14 +38,9 @@ impl Query for BooleanQuery {
     fn weight(&self, searcher: &Searcher) -> Result<Box<Weight>> {
         let sub_weights = self.subqueries
             .iter()
-            .map(|&(ref _occur, ref subquery)| subquery.weight(searcher))
+            .map(|&(ref occur, ref subquery)| Ok((*occur, subquery.weight(searcher)?)))
             .collect::<Result<_>>()?;
-        let occurs: Vec<Occur> = self.subqueries
-            .iter()
-            .map(|&(ref occur, ref _subquery)| *occur)
-            .collect();
-        let filter = OccurFilter::new(&occurs);
-        Ok(box BooleanWeight::new(sub_weights, filter))
+        Ok(box BooleanWeight::new(sub_weights))
     }
 }
 

src/query/boolean_query/boolean_scorer.rs

@@ -90,7 +90,7 @@ impl<TScorer: Scorer> BooleanScorer<TScorer> {
 }
 
 impl<TScorer: Scorer> DocSet for BooleanScorer<TScorer> {
-    fn size_hint(&self) -> usize {
+    fn size_hint(&self) -> u32 {
         // TODO fix this. it should be the min
         // of the MUST scorer
         // and the max of the SHOULD scorers.

src/query/boolean_query/boolean_weight.rs

@@ -1,31 +1,43 @@
 use query::Weight;
 use core::SegmentReader;
+use query::EmptyScorer;
 use query::Scorer;
 use super::BooleanScorer;
 use query::OccurFilter;
+use query::Occur;
 use Result;
 
 pub struct BooleanWeight {
-    weights: Vec<Box<Weight>>,
-    occur_filter: OccurFilter,
+    weights: Vec<(Occur, Box<Weight>)>,
 }
 
 impl BooleanWeight {
-    pub fn new(weights: Vec<Box<Weight>>, occur_filter: OccurFilter) -> BooleanWeight {
-        BooleanWeight {
-            weights,
-            occur_filter,
-        }
+    pub fn new(weights: Vec<(Occur, Box<Weight>)>) -> BooleanWeight {
+        BooleanWeight { weights }
     }
 }
 
 impl Weight for BooleanWeight {
     fn scorer<'a>(&'a self, reader: &'a SegmentReader) -> Result<Box<Scorer + 'a>> {
-        let sub_scorers: Vec<Box<Scorer + 'a>> = self.weights
-            .iter()
-            .map(|weight| weight.scorer(reader))
-            .collect::<Result<_>>()?;
-        let boolean_scorer = BooleanScorer::new(sub_scorers, self.occur_filter);
-        Ok(box boolean_scorer)
+        if self.weights.is_empty() {
+            Ok(box EmptyScorer)
+        } else if self.weights.len() == 1 {
+            let &(occur, ref weight) = &self.weights[0];
+            if occur == Occur::MustNot {
+                Ok(box EmptyScorer)
+            } else {
+                weight.scorer(reader)
+            }
+        } else {
+            let sub_scorers: Vec<Box<Scorer + 'a>> = self.weights
+                .iter()
+                .map(|&(_, ref weight)| weight)
+                .map(|weight| weight.scorer(reader))
+                .collect::<Result<_>>()?;
+            let occurs: Vec<Occur> = self.weights.iter().map(|&(ref occur, _)| *occur).collect();
+            let occur_filter = OccurFilter::new(&occurs);
+            let boolean_scorer = BooleanScorer::new(sub_scorers, occur_filter);
+            Ok(box boolean_scorer)
+        }
     }
 }