No score calls if score is not requested

Author: PSeitz

src/collector/mod.rs

@@ -173,13 +173,13 @@ pub trait Collector: Sync + Send {
         let mut segment_collector = self.for_segment(segment_ord as u32, reader)?;
 
         if let Some(alive_bitset) = reader.alive_bitset() {
-            weight.for_each(reader, &mut |doc, score| {
+            weight.for_each(reader, self.requires_scoring(), &mut |doc, score| {
                 if alive_bitset.is_alive(doc) {
                     segment_collector.collect(doc, score);
                 }
             })?;
         } else {
-            weight.for_each(reader, &mut |doc, score| {
+            weight.for_each(reader, self.requires_scoring(), &mut |doc, score| {
                 segment_collector.collect(doc, score);
             })?;
         }

src/indexer/index_writer.rs

@@ -93,14 +93,16 @@ fn compute_deleted_bitset(
 
         // A delete operation should only affect
         // document that were inserted before it.
-        delete_op
-            .target
-            .for_each(segment_reader, &mut |doc_matching_delete_query, _| {
+        delete_op.target.for_each(
+            segment_reader,
+            false, // requires_scoring
+            &mut |doc_matching_delete_query, _| {
                 if doc_opstamps.is_deleted(doc_matching_delete_query, delete_op.opstamp) {
                     alive_bitset.remove(doc_matching_delete_query);
                     might_have_changed = true;
                 }
-            })?;
+            },
+        )?;
         delete_cursor.advance();
     }
     Ok(might_have_changed)

src/query/boolean_query/boolean_weight.rs

@@ -204,16 +204,17 @@ impl<TScoreCombiner: ScoreCombiner + Sync> Weight for BooleanWeight<TScoreCombin
     fn for_each(
         &self,
         reader: &SegmentReader,
+        requires_scoring: bool,
         callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
         let scorer = self.complex_scorer(reader, 1.0, &self.score_combiner_fn)?;
         match scorer {
             SpecializedScorer::TermUnion(term_scorers) => {
                 let mut union_scorer = Union::build(term_scorers, &self.score_combiner_fn);
-                for_each_scorer(&mut union_scorer, callback);
+                for_each_scorer(&mut union_scorer, requires_scoring, callback);
             }
             SpecializedScorer::Other(mut scorer) => {
-                for_each_scorer(scorer.as_mut(), callback);
+                for_each_scorer(scorer.as_mut(), requires_scoring, callback);
             }
         }
         Ok(())

src/query/term_query/term_weight.rs

@@ -49,10 +49,11 @@ impl Weight for TermWeight {
     fn for_each(
         &self,
         reader: &SegmentReader,
+        requires_scoring: bool,
         callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
         let mut scorer = self.specialized_scorer(reader, 1.0)?;
-        for_each_scorer(&mut scorer, callback);
+        for_each_scorer(&mut scorer, requires_scoring, callback);
         Ok(())
     }
 

src/query/weight.rs

@@ -7,12 +7,21 @@ use crate::{DocId, Score, TERMINATED};
 /// `DocSet` and push the scored documents to the collector.
 pub(crate) fn for_each_scorer<TScorer: Scorer + ?Sized>(
     scorer: &mut TScorer,
+    requires_scoring: bool,
     callback: &mut dyn FnMut(DocId, Score),
 ) {
     let mut doc = scorer.doc();
-    while doc != TERMINATED {
-        callback(doc, scorer.score());
-        doc = scorer.advance();
+
+    if requires_scoring {
+        while doc != TERMINATED {
+            callback(doc, scorer.score());
+            doc = scorer.advance();
+        }
+    } else {
+        while doc != TERMINATED {
+            callback(doc, 0.0);
+            doc = scorer.advance();
+        }
     }
 }
 
@@ -71,10 +80,11 @@ pub trait Weight: Send + Sync + 'static {
     fn for_each(
         &self,
         reader: &SegmentReader,
+        requires_scoring: bool,
         callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
         let mut scorer = self.scorer(reader, 1.0)?;
-        for_each_scorer(scorer.as_mut(), callback);
+        for_each_scorer(scorer.as_mut(), requires_scoring, callback);
         Ok(())
     }