Apache Lucene open-source search software
Remove Scorable#docID. (#12407)
Adrien Grandf527eb3b12df
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex f45ed636d40..74d81c5f2de 100644--- a/lucene/CHANGES.txt+++ b/lucene/CHANGES.txt@@ -55,6 +55,8 @@ API Changes* GITHUB#12321: Reduced visibility of StringsToAutomaton. Please use Automata#makeStringUnion instead. (Greg Miller)+* GITHUB#12407: Removed Scorable#docID. (Adrien Grand)+New Features---------------------diff --git a/lucene/MIGRATE.md b/lucene/MIGRATE.mdindex 15f813fde8b..09688b87dc5 100644--- a/lucene/MIGRATE.md+++ b/lucene/MIGRATE.md@@ -143,6 +143,18 @@ Lucene 9.2 or stay with 9.0.See LUCENE-10558 for more details and workarounds.+### Removed Scorable#docID() (GITHUB#12407)++This method has been removed in order to enable more search-time optimizations.+Use the doc ID passed to `LeafCollector#collect` to know which doc ID is being+collected.++### ScoreCachingWrappingScorer now wraps a LeafCollector instead of a Scorable (GITHUB#12407)++In order to adapt to the removal of `Scorable#docID()`,+`ScoreCachingWrappingScorer` now wraps a `LeafCollector` rather than a+`Scorable`.+## Migration from Lucene 8.x to Lucene 9.0### Rename of binary artifacts from '**-analyzers-**' to '**-analysis-**' (LUCENE-9562)diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java b/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.javaindex 51ff46c912b..5bc9c979375 100644--- a/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java@@ -116,7 +116,7 @@ final class BooleanScorer extends BulkScorer {final BulkScorerAndDoc[] leads;final HeadPriorityQueue head;final TailPriorityQueue tail;- final ScoreAndDoc scoreAndDoc = new ScoreAndDoc();+ final Score score = new Score();final int minShouldMatch;final long cost;@@ -181,12 +181,11 @@ final class BooleanScorer extends BulkScorer {}private void scoreDocument(LeafCollector collector, int base, int i) throws IOException {- final ScoreAndDoc scoreAndDoc = this.scoreAndDoc;+ final Score score = this.score;final Bucket bucket = buckets[i];if (bucket.freq >= minShouldMatch) {- scoreAndDoc.score = (float) bucket.score;+ score.score = (float) bucket.score;final int doc = base | i;- scoreAndDoc.doc = doc;collector.collect(doc);}bucket.freq = 0;@@ -300,7 +299,7 @@ final class BooleanScorer extends BulkScorer {bulkScorer.score(collector, acceptDocs, windowMin, end);// reset the scorer that should be used for the general case- collector.setScorer(scoreAndDoc);+ collector.setScorer(score);}private BulkScorerAndDoc scoreWindow(@@ -332,8 +331,7 @@ final class BooleanScorer extends BulkScorer {@Overridepublic int score(LeafCollector collector, Bits acceptDocs, int min, int max) throws IOException {- scoreAndDoc.doc = -1;- collector.setScorer(scoreAndDoc);+ collector.setScorer(score);BulkScorerAndDoc top = advance(min);while (top.next < max) {diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java b/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.javaindex f11363693a5..28d1f0343dc 100644--- a/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java@@ -164,7 +164,7 @@ final class BooleanWeight extends Weight {throws IOException {final LeafCollector noScoreCollector =new LeafCollector() {- ScoreAndDoc fake = new ScoreAndDoc();+ Score fake = new Score();@Overridepublic void setScorer(Scorable scorer) throws IOException {@@ -173,7 +173,6 @@ final class BooleanWeight extends Weight {@Overridepublic void collect(int doc) throws IOException {- fake.doc = doc;collector.collect(doc);}};diff --git a/lucene/core/src/java/org/apache/lucene/search/CachingCollector.java b/lucene/core/src/java/org/apache/lucene/search/CachingCollector.javaindex fd45666d33a..4cedde982dd 100644--- a/lucene/core/src/java/org/apache/lucene/search/CachingCollector.java+++ b/lucene/core/src/java/org/apache/lucene/search/CachingCollector.java@@ -47,18 +47,12 @@ public abstract class CachingCollector extends FilterCollector {// the outer class does not incur access check by the JVM. The same// situation would be if they were defined in the outer class as private// members.- int doc;float score;@Overridepublic final float score() {return score;}-- @Override- public int docID() {- return doc;- }}private static class NoScoreCachingCollector extends CachingCollector {@@ -155,9 +149,8 @@ public abstract class CachingCollector extends FilterCollector {final CachedScorable scorer = new CachedScorable();collector.setScorer(scorer);for (int j = 0; j < docs.length; ++j) {- scorer.doc = docs[j];scorer.score = scores[j];- collector.collect(scorer.doc);+ collector.collect(docs[j]);}}}diff --git a/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java b/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.javaindex f27b791dd95..4624fb9d80e 100644--- a/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java+++ b/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java@@ -328,8 +328,9 @@ public abstract class DoubleValuesSource implements SegmentCacheable {* Returns a DoubleValues instance that wraps scores returned by a Scorer.** <p>Note: If you intend to call {@link Scorable#score()} on the provided {@code scorer}- * separately, you may want to consider wrapping it with {@link- * ScoreCachingWrappingScorer#wrap(Scorable)} to avoid computing the actual score multiple times.+ * separately, you may want to consider wrapping the collector with {@link+ * ScoreCachingWrappingScorer#wrap(LeafCollector)} to avoid computing the actual score multiple+ * times.*/public static DoubleValues fromScorer(Scorable scorer) {return new DoubleValues() {@@ -340,7 +341,6 @@ public abstract class DoubleValuesSource implements SegmentCacheable {@Overridepublic boolean advanceExact(int doc) throws IOException {- assert scorer.docID() == doc;return true;}};diff --git a/lucene/core/src/java/org/apache/lucene/search/FieldComparator.java b/lucene/core/src/java/org/apache/lucene/search/FieldComparator.javaindex 99c5a480ed1..2a810e674e9 100644--- a/lucene/core/src/java/org/apache/lucene/search/FieldComparator.java+++ b/lucene/core/src/java/org/apache/lucene/search/FieldComparator.java@@ -183,10 +183,7 @@ public abstract class FieldComparator<T> {@Overridepublic void setScorer(Scorable scorer) {- // wrap with a ScoreCachingWrappingScorer so that successive calls to- // score() will not incur score computation over and- // over again.- this.scorer = ScoreCachingWrappingScorer.wrap(scorer);+ this.scorer = scorer;}@Overridediff --git a/lucene/core/src/java/org/apache/lucene/search/FilterScorable.java b/lucene/core/src/java/org/apache/lucene/search/FilterScorable.javaindex d9e0e29f508..890a3f3c2d5 100644--- a/lucene/core/src/java/org/apache/lucene/search/FilterScorable.java+++ b/lucene/core/src/java/org/apache/lucene/search/FilterScorable.java@@ -45,11 +45,6 @@ public class FilterScorable extends Scorable {return in.score();}- @Override- public int docID() {- return in.docID();- }-@Overridepublic Collection<ChildScorable> getChildren() throws IOException {return Collections.singletonList(new ChildScorable(in, "FILTER"));diff --git a/lucene/core/src/java/org/apache/lucene/search/MatchAllDocsQuery.java b/lucene/core/src/java/org/apache/lucene/search/MatchAllDocsQuery.javaindex e13521cc8d4..68df90cfd02 100644--- a/lucene/core/src/java/org/apache/lucene/search/MatchAllDocsQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/MatchAllDocsQuery.java@@ -54,11 +54,10 @@ public final class MatchAllDocsQuery extends Query {public int score(LeafCollector collector, Bits acceptDocs, int min, int max)throws IOException {max = Math.min(max, maxDoc);- ScoreAndDoc scorer = new ScoreAndDoc();+ Score scorer = new Score();scorer.score = score;collector.setScorer(scorer);for (int doc = min; doc < max; ++doc) {- scorer.doc = doc;if (acceptDocs == null || acceptDocs.get(doc)) {collector.collect(doc);}diff --git a/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java b/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.javaindex 5a89ef267d2..ad7c08b9abc 100644--- a/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java@@ -37,7 +37,7 @@ final class MaxScoreBulkScorer extends BulkScorer {private final long cost;private float minCompetitiveScore;private boolean minCompetitiveScoreUpdated;- private ScoreAndDoc scorable = new ScoreAndDoc();+ private Score scorable = new Score();private final double[] maxScoreSums;MaxScoreBulkScorer(int maxDoc, List<Scorer> scorers) throws IOException {@@ -103,7 +103,6 @@ final class MaxScoreBulkScorer extends BulkScorer {}if (possibleMatch) {- scorable.doc = top.doc;scorable.score = (float) score;collector.collect(top.doc);}@@ -203,15 +202,9 @@ final class MaxScoreBulkScorer extends BulkScorer {return cost;}- private class ScoreAndDoc extends Scorable {+ private class Score extends Scorable {float score;- int doc = -1;-- @Override- public int docID() {- return doc;- }@Overridepublic float score() {diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiCollector.java b/lucene/core/src/java/org/apache/lucene/search/MultiCollector.javaindex ff6a6a97ba5..72418594b6c 100644--- a/lucene/core/src/java/org/apache/lucene/search/MultiCollector.java+++ b/lucene/core/src/java/org/apache/lucene/search/MultiCollector.java@@ -150,8 +150,12 @@ public class MultiCollector implements Collector {&& (scoreMode() == ScoreMode.TOP_SCORES || leafScoreMode != ScoreMode.TOP_SCORES)) {return leafCollectors.get(0);}- return new MultiLeafCollector(- leafCollectors, cacheScores, scoreMode() == ScoreMode.TOP_SCORES);+ LeafCollector collector =+ new MultiLeafCollector(leafCollectors, scoreMode() == ScoreMode.TOP_SCORES);+ if (cacheScores) {+ collector = ScoreCachingWrappingScorer.wrap(collector);+ }+ return collector;}}@@ -169,24 +173,18 @@ public class MultiCollector implements Collector {private static class MultiLeafCollector implements LeafCollector {- private final boolean cacheScores;private final LeafCollector[] collectors;private final float[] minScores;private final boolean skipNonCompetitiveScores;- private MultiLeafCollector(- List<LeafCollector> collectors, boolean cacheScores, boolean skipNonCompetitive) {+ private MultiLeafCollector(List<LeafCollector> collectors, boolean skipNonCompetitive) {this.collectors = collectors.toArray(new LeafCollector[collectors.size()]);- this.cacheScores = cacheScores;this.skipNonCompetitiveScores = skipNonCompetitive;this.minScores = this.skipNonCompetitiveScores ? new float[this.collectors.length] : null;}@Overridepublic void setScorer(Scorable scorer) throws IOException {- if (cacheScores) {- scorer = ScoreCachingWrappingScorer.wrap(scorer);- }if (skipNonCompetitiveScores) {for (int i = 0; i < collectors.length; ++i) {final LeafCollector c = collectors[i];diff --git a/lucene/core/src/java/org/apache/lucene/search/PositiveScoresOnlyCollector.java b/lucene/core/src/java/org/apache/lucene/search/PositiveScoresOnlyCollector.javaindex 7dd0b45216a..eaa787ddee8 100644--- a/lucene/core/src/java/org/apache/lucene/search/PositiveScoresOnlyCollector.java+++ b/lucene/core/src/java/org/apache/lucene/search/PositiveScoresOnlyCollector.java@@ -31,22 +31,23 @@ public class PositiveScoresOnlyCollector extends FilterCollector {@Overridepublic LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {- return new FilterLeafCollector(super.getLeafCollector(context)) {+ return ScoreCachingWrappingScorer.wrap(+ new FilterLeafCollector(super.getLeafCollector(context)) {- private Scorable scorer;+ private Scorable scorer;- @Override- public void setScorer(Scorable scorer) throws IOException {- this.scorer = ScoreCachingWrappingScorer.wrap(scorer);- in.setScorer(this.scorer);- }+ @Override+ public void setScorer(Scorable scorer) throws IOException {+ this.scorer = scorer;+ in.setScorer(scorer);+ }- @Override- public void collect(int doc) throws IOException {- if (scorer.score() > 0) {- in.collect(doc);- }- }- };+ @Override+ public void collect(int doc) throws IOException {+ if (scorer.score() > 0) {+ in.collect(doc);+ }+ }+ });}}diff --git a/lucene/core/src/java/org/apache/lucene/search/Scorable.java b/lucene/core/src/java/org/apache/lucene/search/Scorable.javaindex 075d8be079c..db53eb97e7b 100644--- a/lucene/core/src/java/org/apache/lucene/search/Scorable.java+++ b/lucene/core/src/java/org/apache/lucene/search/Scorable.java@@ -42,9 +42,6 @@ public abstract class Scorable {return 0f;}- /** Returns the doc ID that is currently being scored. */- public abstract int docID();-/*** Optional method: Tell the scorer that its iterator may safely ignore all documents whose score* is less than the given {@code minScore}. This is a no-op by default.diff --git a/lucene/core/src/java/org/apache/lucene/search/ScoreAndDoc.java b/lucene/core/src/java/org/apache/lucene/search/Score.javasimilarity index 89%rename from lucene/core/src/java/org/apache/lucene/search/ScoreAndDoc.javarename to lucene/core/src/java/org/apache/lucene/search/Score.javaindex b1ccd044948..fdda8e2d76e 100644--- a/lucene/core/src/java/org/apache/lucene/search/ScoreAndDoc.java+++ b/lucene/core/src/java/org/apache/lucene/search/Score.java@@ -20,14 +20,8 @@ package org.apache.lucene.search;* Used by {@link BulkScorer}s that need to pass a {@link Scorable} to {@link* LeafCollector#setScorer}.*/-final class ScoreAndDoc extends Scorable {+final class Score extends Scorable {float score;- int doc = -1;-- @Override- public int docID() {- return doc;- }@Overridepublic float score() {diff --git a/lucene/core/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java b/lucene/core/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.javaindex ebdc8262b7b..e9a23921ece 100644--- a/lucene/core/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/ScoreCachingWrappingScorer.java@@ -31,22 +31,48 @@ import java.util.Collections;*/public final class ScoreCachingWrappingScorer extends Scorable {+ private int lastDoc = -1;private int curDoc = -1;private float curScore;private final Scorable in;/**- * Wraps the provided {@link Scorable} unless it's already an instance of {@code- * ScoreCachingWrappingScorer}, in which case it will just return the provided instance.- *- * @param scorer Underlying {@code Scorable} to wrap- * @return Instance of {@code ScoreCachingWrappingScorer} wrapping the underlying {@code scorer}+ * Wrap the provided {@link LeafCollector} so that scores are computed lazily and cached if+ * accessed multiple times.*/- public static Scorable wrap(Scorable scorer) {- if (scorer instanceof ScoreCachingWrappingScorer) {- return scorer;+ public static LeafCollector wrap(LeafCollector collector) {+ if (collector instanceof ScoreCachingWrappingLeafCollector) {+ return collector;+ }+ return new ScoreCachingWrappingLeafCollector(collector);+ }++ private static class ScoreCachingWrappingLeafCollector extends FilterLeafCollector {++ ScoreCachingWrappingLeafCollector(LeafCollector in) {+ super(in);+ }++ private ScoreCachingWrappingScorer scorer;++ @Override+ public void setScorer(Scorable scorer) throws IOException {+ this.scorer = new ScoreCachingWrappingScorer(scorer);+ super.setScorer(this.scorer);+ }++ @Override+ public void collect(int doc) throws IOException {+ if (scorer != null) {+ scorer.curDoc = doc;+ }+ super.collect(doc);+ }++ @Override+ public DocIdSetIterator competitiveIterator() throws IOException {+ return in.competitiveIterator();}- return new ScoreCachingWrappingScorer(scorer);}/** Creates a new instance by wrapping the given scorer. */@@ -56,10 +82,9 @@ public final class ScoreCachingWrappingScorer extends Scorable {@Overridepublic float score() throws IOException {- int doc = in.docID();- if (doc != curDoc) {+ if (lastDoc != curDoc) {curScore = in.score();- curDoc = doc;+ curDoc = lastDoc;}return curScore;@@ -70,11 +95,6 @@ public final class ScoreCachingWrappingScorer extends Scorable {in.setMinCompetitiveScore(minScore);}- @Override- public int docID() {- return in.docID();- }-@Overridepublic Collection<ChildScorable> getChildren() {return Collections.singleton(new ChildScorable(in, "CACHED"));diff --git a/lucene/core/src/java/org/apache/lucene/search/Scorer.java b/lucene/core/src/java/org/apache/lucene/search/Scorer.javaindex eeaa9158e72..8a84620581e 100644--- a/lucene/core/src/java/org/apache/lucene/search/Scorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/Scorer.java@@ -54,6 +54,9 @@ public abstract class Scorer extends Scorable {return weight;}+ /** Returns the doc ID that is currently being scored. */+ public abstract int docID();+/*** Return a {@link DocIdSetIterator} over matching documents.*diff --git a/lucene/core/src/java/org/apache/lucene/search/SortRescorer.java b/lucene/core/src/java/org/apache/lucene/search/SortRescorer.javaindex 5b334c2f4d6..fce33a030d5 100644--- a/lucene/core/src/java/org/apache/lucene/search/SortRescorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/SortRescorer.java@@ -54,7 +54,7 @@ public class SortRescorer extends Rescorer {int docBase = 0;LeafCollector leafCollector = null;- ScoreAndDoc scoreAndDoc = new ScoreAndDoc();+ Score score = new Score();while (hitUpto < hits.length) {ScoreDoc hit = hits[hitUpto];@@ -69,14 +69,13 @@ public class SortRescorer extends Rescorer {if (readerContext != null) {// We advanced to another segment:leafCollector = collector.getLeafCollector(readerContext);- leafCollector.setScorer(scoreAndDoc);+ leafCollector.setScorer(score);docBase = readerContext.docBase;}- scoreAndDoc.score = hit.score;- scoreAndDoc.doc = docID - docBase;+ score.score = hit.score;- leafCollector.collect(scoreAndDoc.doc);+ leafCollector.collect(docID - docBase);hitUpto++;}diff --git a/lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java b/lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.javaindex 02e5bae87ce..d9e32ff0858 100644--- a/lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java+++ b/lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java@@ -195,21 +195,30 @@ public abstract class TopFieldCollector extends TopDocsCollector<Entry> {minCompetitiveScore = 0f;docBase = context.docBase;- return new TopFieldLeafCollector(queue, sort, context) {-- @Override- public void collect(int doc) throws IOException {- countHit(doc);- if (queueFull) {- if (thresholdCheck(doc)) {- return;+ LeafCollector collector =+ new TopFieldLeafCollector(queue, sort, context) {++ @Override+ public void collect(int doc) throws IOException {+ countHit(doc);+ if (queueFull) {+ if (thresholdCheck(doc)) {+ return;+ }+ collectCompetitiveHit(doc);+ } else {+ collectAnyHit(doc, totalHits);+ }}- collectCompetitiveHit(doc);- } else {- collectAnyHit(doc, totalHits);- }- }- };+ };++ if (needsScores) {+ // score-based comparators may need to call score() multiple times, e.g. once for the+ // comparison, and once to copy the score into the priority queue+ collector = ScoreCachingWrappingScorer.wrap(collector);+ }++ return collector;}}@@ -251,34 +260,43 @@ public abstract class TopFieldCollector extends TopDocsCollector<Entry> {docBase = context.docBase;final int afterDoc = after.doc - docBase;- return new TopFieldLeafCollector(queue, sort, context) {-- @Override- public void collect(int doc) throws IOException {- countHit(doc);- if (queueFull) {- if (thresholdCheck(doc)) {- return;- }- }- final int topCmp = reverseMul * comparator.compareTop(doc);- if (topCmp > 0 || (topCmp == 0 && doc <= afterDoc)) {- // Already collected on a previous page- if (totalHitsRelation == TotalHits.Relation.EQUAL_TO) {- // check if totalHitsThreshold is reached and we can update competitive score- // necessary to account for possible update to global min competitive score- updateMinCompetitiveScore(scorer);+ LeafCollector collector =+ new TopFieldLeafCollector(queue, sort, context) {++ @Override+ public void collect(int doc) throws IOException {+ countHit(doc);+ if (queueFull) {+ if (thresholdCheck(doc)) {+ return;+ }+ }+ final int topCmp = reverseMul * comparator.compareTop(doc);+ if (topCmp > 0 || (topCmp == 0 && doc <= afterDoc)) {+ // Already collected on a previous page+ if (totalHitsRelation == TotalHits.Relation.EQUAL_TO) {+ // check if totalHitsThreshold is reached and we can update competitive score+ // necessary to account for possible update to global min competitive score+ updateMinCompetitiveScore(scorer);+ }+ return;+ }+ if (queueFull) {+ collectCompetitiveHit(doc);+ } else {+ collectedHits++;+ collectAnyHit(doc, collectedHits);+ }}- return;- }- if (queueFull) {- collectCompetitiveHit(doc);- } else {- collectedHits++;- collectAnyHit(doc, collectedHits);- }- }- };+ };++ if (needsScores) {+ // score-based comparators may need to call score() multiple times, e.g. once for the+ // comparison, and once to copy the score into the priority queue+ collector = ScoreCachingWrappingScorer.wrap(collector);+ }++ return collector;}}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.javaindex b464a5d225b..d895b269b75 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java@@ -207,7 +207,7 @@ public class TestBooleanOr extends LuceneTestCase {private static BulkScorer scorer(int... matches) {return new BulkScorer() {- final ScoreAndDoc scorer = new ScoreAndDoc();+ final Score scorer = new Score();int i = 0;@Override@@ -218,9 +218,9 @@ public class TestBooleanOr extends LuceneTestCase {i += 1;}while (i < matches.length && matches[i] < max) {- scorer.doc = matches[i];- if (acceptDocs == null || acceptDocs.get(scorer.doc)) {- collector.collect(scorer.doc);+ int doc = matches[i];+ if (acceptDocs == null || acceptDocs.get(doc)) {+ collector.collect(doc);}i += 1;}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.javaindex 907bb397bf3..119ebaf880e 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java@@ -99,7 +99,7 @@ public class TestBooleanScorer extends LuceneTestCase {public int score(LeafCollector collector, Bits acceptDocs, int min, int max)throws IOException {assert min == 0;- collector.setScorer(new ScoreAndDoc());+ collector.setScorer(new Score());collector.collect(0);return DocIdSetIterator.NO_MORE_DOCS;}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestCachingCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestCachingCollector.javaindex 425c33a34e7..20b006e0bda 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestCachingCollector.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestCachingCollector.java@@ -29,11 +29,6 @@ public class TestCachingCollector extends LuceneTestCase {public float score() {return 0;}-- @Override- public int docID() {- return 0;- }}private static class NoOpCollector extends SimpleCollector {diff --git a/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.javaindex b553debc0f9..adef5e004f8 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java@@ -157,7 +157,7 @@ public class TestConstantScoreQuery extends LuceneTestCase {// for the combined BQ, the scorer should always be BooleanScorer's BucketScorer, because our// scorer supports out-of order collection!- final Class<ScoreAndDoc> bucketScorerClass = ScoreAndDoc.class;+ final Class<Score> bucketScorerClass = Score.class;checkHits(searcher, csqbq, csqbq.getBoost(), bucketScorerClass);} finally {IOUtils.close(reader, directory);diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.javaindex 5e9a910f126..d27d026f9a6 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java@@ -147,7 +147,7 @@ public class TestMultiCollector extends LuceneTestCase {collector1 = new TerminateAfterCollector(collector1, 1);collector2 = new TerminateAfterCollector(collector2, 2);- Scorable scorer = new ScoreAndDoc();+ Scorable scorer = new Score();List<Collector> collectors = Arrays.asList(collector1, collector2);Collections.shuffle(collectors, random());@@ -189,10 +189,6 @@ public class TestMultiCollector extends LuceneTestCase {Scorable scorer =new Scorable() {- @Override- public int docID() {- throw new UnsupportedOperationException();- }@Overridepublic float score() {@@ -244,10 +240,6 @@ public class TestMultiCollector extends LuceneTestCase {Scorable scorer =new Scorable() {- @Override- public int docID() {- throw new UnsupportedOperationException();- }@Overridepublic float score() {@@ -341,7 +333,7 @@ public class TestMultiCollector extends LuceneTestCase {final LeafCollector ac = c.getLeafCollector(null);ac.collect(1);c.getLeafCollector(null);- c.getLeafCollector(null).setScorer(new ScoreAndDoc());+ c.getLeafCollector(null).setScorer(new Score());}@Test@@ -363,7 +355,7 @@ public class TestMultiCollector extends LuceneTestCase {LeafCollector ac = c.getLeafCollector(null);ac.collect(1);ac = c.getLeafCollector(null);- ac.setScorer(new ScoreAndDoc());+ ac.setScorer(new Score());for (DummyCollector dc : dcs) {assertTrue(dc.collectCalled);@@ -415,23 +407,23 @@ public class TestMultiCollector extends LuceneTestCase {() -> {collector(ScoreMode.COMPLETE_NO_SCORES, ScoreCachingWrappingScorer.class).getLeafCollector(ctx)- .setScorer(new ScoreAndDoc());+ .setScorer(new Score());});// no collector needs scores => no caching- Collector c1 = collector(ScoreMode.COMPLETE_NO_SCORES, ScoreAndDoc.class);- Collector c2 = collector(ScoreMode.COMPLETE_NO_SCORES, ScoreAndDoc.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new ScoreAndDoc());+ Collector c1 = collector(ScoreMode.COMPLETE_NO_SCORES, Score.class);+ Collector c2 = collector(ScoreMode.COMPLETE_NO_SCORES, Score.class);+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());// only one collector needs scores => no caching- c1 = collector(ScoreMode.COMPLETE, ScoreAndDoc.class);- c2 = collector(ScoreMode.COMPLETE_NO_SCORES, ScoreAndDoc.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new ScoreAndDoc());+ c1 = collector(ScoreMode.COMPLETE, Score.class);+ c2 = collector(ScoreMode.COMPLETE_NO_SCORES, Score.class);+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());// several collectors need scores => cachingc1 = collector(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);c2 = collector(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new ScoreAndDoc());+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());reader.close();dir.close();@@ -448,11 +440,11 @@ public class TestMultiCollector extends LuceneTestCase {collector(ScoreMode.TOP_SCORES, MultiCollector.MinCompetitiveScoreAwareScorable.class);Collector c2 =collector(ScoreMode.TOP_SCORES, MultiCollector.MinCompetitiveScoreAwareScorable.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new ScoreAndDoc());+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());c1 = collector(ScoreMode.TOP_SCORES, ScoreCachingWrappingScorer.class);c2 = collector(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new ScoreAndDoc());+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());reader.close();dir.close();@@ -469,11 +461,6 @@ public class TestMultiCollector extends LuceneTestCase {return 0;}- @Override- public int docID() {- return 0;- }-@Overridepublic void setMinCompetitiveScore(float minScore) throws IOException {minCompetitiveScore[0] = minScore;@@ -511,7 +498,7 @@ public class TestMultiCollector extends LuceneTestCase {Collector mc = MultiCollector.wrap(c1, c2);LeafCollector lc = mc.getLeafCollector(ctx);- lc.setScorer(new ScoreAndDoc());+ lc.setScorer(new Score());lc.collect(0); // OKassertTrue("c1's collect should be called", c1.collectCalled);assertTrue("c2's collect should be called", c2.collectCalled);@@ -562,21 +549,21 @@ public class TestMultiCollector extends LuceneTestCase {LeafCollector lc = mc.getLeafCollector(ctx);assertFalse(c1.setScorerCalled);assertFalse(c2.setScorerCalled);- lc.setScorer(new ScoreAndDoc());+ lc.setScorer(new Score());assertTrue(c1.setScorerCalled);assertTrue(c2.setScorerCalled);c1.setScorerCalled = false;c2.setScorerCalled = false;lc.collect(0); // OK- lc.setScorer(new ScoreAndDoc());+ lc.setScorer(new Score());assertTrue(c1.setScorerCalled);assertTrue(c2.setScorerCalled);c1.setScorerCalled = false;c2.setScorerCalled = false;lc.collect(1); // OK, but c1 should terminate- lc.setScorer(new ScoreAndDoc());+ lc.setScorer(new Score());assertFalse(c1.setScorerCalled);assertTrue(c2.setScorerCalled);c2.setScorerCalled = false;@@ -586,7 +573,7 @@ public class TestMultiCollector extends LuceneTestCase {() -> {lc.collect(2);});- lc.setScorer(new ScoreAndDoc());+ lc.setScorer(new Score());assertFalse(c1.setScorerCalled);assertFalse(c2.setScorerCalled);diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollectorManager.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollectorManager.javaindex fcb6dce2f79..27543e1ff9b 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollectorManager.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollectorManager.java@@ -92,28 +92,19 @@ public class TestMultiCollectorManager extends LuceneTestCase {LeafReaderContext ctx = reader.leaves().get(0);// no collector needs scores => no caching- CollectorManager<?, ?> cm1 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, ScoreAndDoc.class);- CollectorManager<?, ?> cm2 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, ScoreAndDoc.class);- new MultiCollectorManager(cm1, cm2)- .newCollector()- .getLeafCollector(ctx)- .setScorer(new ScoreAndDoc());+ CollectorManager<?, ?> cm1 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, Score.class);+ CollectorManager<?, ?> cm2 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, Score.class);+ new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());// only one collector needs scores => no caching- cm1 = collectorManager(ScoreMode.COMPLETE, ScoreAndDoc.class);- cm2 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, ScoreAndDoc.class);- new MultiCollectorManager(cm1, cm2)- .newCollector()- .getLeafCollector(ctx)- .setScorer(new ScoreAndDoc());+ cm1 = collectorManager(ScoreMode.COMPLETE, Score.class);+ cm2 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, Score.class);+ new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());// several collectors need scores => cachingcm1 = collectorManager(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);cm2 = collectorManager(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);- new MultiCollectorManager(cm1, cm2)- .newCollector()- .getLeafCollector(ctx)- .setScorer(new ScoreAndDoc());+ new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());reader.close();dir.close();@@ -132,19 +123,13 @@ public class TestMultiCollectorManager extends LuceneTestCase {CollectorManager<?, ?> cm2 =collectorManager(ScoreMode.TOP_SCORES, MultiCollector.MinCompetitiveScoreAwareScorable.class);- new MultiCollectorManager(cm1, cm2)- .newCollector()- .getLeafCollector(ctx)- .setScorer(new ScoreAndDoc());+ new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());// both wrapped collector managers need scores, but one is exhaustive, so they should// see a ScoreCachingWrappingScorer pass in as their scorer:cm1 = collectorManager(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);cm2 = collectorManager(ScoreMode.TOP_SCORES, ScoreCachingWrappingScorer.class);- new MultiCollectorManager(cm1, cm2)- .newCollector()- .getLeafCollector(ctx)- .setScorer(new ScoreAndDoc());+ new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());reader.close();dir.close();diff --git a/lucene/core/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.javaindex 28e84eae4f5..43be0710887 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestScoreCachingWrappingScorer.java@@ -18,6 +18,7 @@ package org.apache.lucene.search;import java.io.IOException;import org.apache.lucene.index.IndexReader;+import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.Term;import org.apache.lucene.store.Directory;import org.apache.lucene.tests.index.RandomIndexWriter;@@ -79,7 +80,7 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase {}}- private static final class ScoreCachingCollector extends SimpleCollector {+ private static final class ScoreCachingCollector implements Collector {private int idx = 0;private Scorable scorer;@@ -90,22 +91,29 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase {}@Override- public void collect(int doc) throws IOException {- // just a sanity check to avoid IOOB.- if (idx == mscores.length) {- return;- }-- // just call score() a couple of times and record the score.- mscores[idx] = scorer.score();- mscores[idx] = scorer.score();- mscores[idx] = scorer.score();- ++idx;- }-- @Override- public void setScorer(Scorable scorer) {- this.scorer = ScoreCachingWrappingScorer.wrap(scorer);+ public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {+ return ScoreCachingWrappingScorer.wrap(+ new LeafCollector() {++ @Override+ public void setScorer(Scorable scorer) {+ ScoreCachingCollector.this.scorer = scorer;+ }++ @Override+ public void collect(int doc) throws IOException {+ // just a sanity check to avoid IOOB.+ if (idx == mscores.length) {+ return;+ }++ // just call score() a couple of times and record the score.+ mscores[idx] = scorer.score();+ mscores[idx] = scorer.score();+ mscores[idx] = scorer.score();+ ++idx;+ }+ });}@Override@@ -142,12 +150,13 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase {new TermQuery(new Term("fake", "weight")).createWeight(searcher, ScoreMode.COMPLETE, 1f);Scorer s = new SimpleScorer(fake);ScoreCachingCollector scc = new ScoreCachingCollector(scores.length);- scc.setScorer(s);+ LeafCollector lc = scc.getLeafCollector(null);+ lc.setScorer(s);// We need to iterate on the scorer so that its doc() advances.int doc;while ((doc = s.iterator().nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {- scc.collect(doc);+ lc.collect(doc);}for (int i = 0; i < scores.length; i++) {@@ -156,28 +165,4 @@ public class TestScoreCachingWrappingScorer extends LuceneTestCase {ir.close();directory.close();}-- public void testNoUnnecessaryWrap() throws Exception {- Scorable base =- new Scorable() {- @Override- public float score() throws IOException {- return -1;- }-- @Override- public int docID() {- return -1;- }- };-- // Wrapping the first time should produce a different instance:- Scorable wrapped = ScoreCachingWrappingScorer.wrap(base);- assertNotEquals(base, wrapped);-- // But if we try to wrap an instance of ScoreCachingWrappingScorer, it shouldn't unnecessarily- // wrap again:- Scorable doubleWrapped = ScoreCachingWrappingScorer.wrap(wrapped);- assertSame(wrapped, doubleWrapped);- }}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java b/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.javaindex c1545973dcd..d3db022029f 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java@@ -110,7 +110,7 @@ public class TestSubScorerFreqs extends LuceneTestCase {private static class CountingCollector extends FilterCollector {public final Map<Integer, Map<Query, Float>> docCounts = new HashMap<>();- private final Map<Query, Scorable> subScorers = new HashMap<>();+ private final Map<Query, Scorer> subScorers = new HashMap<>();private final Set<String> relationships;public CountingCollector(Collector other) {@@ -129,7 +129,7 @@ public class TestSubScorerFreqs extends LuceneTestCase {setSubScorers(child.child);}}- subScorers.put(((Scorer) scorer).getWeight().getQuery(), scorer);+ subScorers.put(((Scorer) scorer).getWeight().getQuery(), (Scorer) scorer);}@Override@@ -140,8 +140,8 @@ public class TestSubScorerFreqs extends LuceneTestCase {@Overridepublic void collect(int doc) throws IOException {final Map<Query, Float> freqs = new HashMap<Query, Float>();- for (Map.Entry<Query, Scorable> ent : subScorers.entrySet()) {- Scorable value = ent.getValue();+ for (Map.Entry<Query, Scorer> ent : subScorers.entrySet()) {+ Scorer value = ent.getValue();int matchId = value.docID();freqs.put(ent.getKey(), matchId == doc ? value.score() : 0.0f);}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTopDocsCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestTopDocsCollector.javaindex 7ad94171f4c..b3d9a9b8c93 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestTopDocsCollector.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestTopDocsCollector.java@@ -279,8 +279,7 @@ public class TestTopDocsCollector extends LuceneTestCase {}}- private static class ScoreAndDoc extends Scorable {- int doc = -1;+ private static class Score extends Scorable {float score;Float minCompetitiveScore = null;@@ -290,11 +289,6 @@ public class TestTopDocsCollector extends LuceneTestCase {this.minCompetitiveScore = score;}- @Override- public int docID() {- return doc;- }-@Overridepublic float score() throws IOException {return score;@@ -315,51 +309,44 @@ public class TestTopDocsCollector extends LuceneTestCase {w.close();TopScoreDocCollector collector = TopScoreDocCollector.create(2, null, 2);- ScoreAndDoc scorer = new ScoreAndDoc();+ Score scorer = new Score();LeafCollector leafCollector = collector.getLeafCollector(reader.leaves().get(0));leafCollector.setScorer(scorer);assertNull(scorer.minCompetitiveScore);- scorer.doc = 0;scorer.score = 1;leafCollector.collect(0);assertNull(scorer.minCompetitiveScore);- scorer.doc = 1;scorer.score = 2;leafCollector.collect(1);assertNull(scorer.minCompetitiveScore);- scorer.doc = 2;scorer.score = 3;leafCollector.collect(2);assertEquals(Math.nextUp(2f), scorer.minCompetitiveScore, 0f);- scorer.doc = 3;scorer.score = 0.5f;// Make sure we do not call setMinCompetitiveScore for non-competitive hitsscorer.minCompetitiveScore = null;leafCollector.collect(3);assertNull(scorer.minCompetitiveScore);- scorer.doc = 4;scorer.score = 4;leafCollector.collect(4);assertEquals(Math.nextUp(3f), scorer.minCompetitiveScore, 0f);// Make sure the min score is set on scorers on new segments- scorer = new ScoreAndDoc();+ scorer = new Score();leafCollector = collector.getLeafCollector(reader.leaves().get(1));leafCollector.setScorer(scorer);assertEquals(Math.nextUp(3f), scorer.minCompetitiveScore, 0f);- scorer.doc = 0;scorer.score = 1;leafCollector.collect(0);assertEquals(Math.nextUp(3f), scorer.minCompetitiveScore, 0f);- scorer.doc = 1;scorer.score = 4;leafCollector.collect(1);assertEquals(Math.nextUp(4f), scorer.minCompetitiveScore, 0f);@@ -406,27 +393,23 @@ public class TestTopDocsCollector extends LuceneTestCase {for (int totalHitsThreshold = 0; totalHitsThreshold < 20; ++totalHitsThreshold) {TopScoreDocCollector collector = TopScoreDocCollector.create(2, null, totalHitsThreshold);- ScoreAndDoc scorer = new ScoreAndDoc();+ Score scorer = new Score();LeafCollector leafCollector = collector.getLeafCollector(reader.leaves().get(0));leafCollector.setScorer(scorer);- scorer.doc = 0;scorer.score = 3;leafCollector.collect(0);- scorer.doc = 1;scorer.score = 3;leafCollector.collect(1);leafCollector = collector.getLeafCollector(reader.leaves().get(1));leafCollector.setScorer(scorer);- scorer.doc = 1;scorer.score = 3;leafCollector.collect(1);- scorer.doc = 5;scorer.score = 4;leafCollector.collect(1);@@ -502,62 +485,54 @@ public class TestTopDocsCollector extends LuceneTestCase {// force the check of the global minimum score on every roundminValueChecker.modInterval = 0;- ScoreAndDoc scorer = new ScoreAndDoc();- ScoreAndDoc scorer2 = new ScoreAndDoc();+ Score scorer = new Score();+ Score scorer2 = new Score();LeafCollector leafCollector = collector.getLeafCollector(reader.leaves().get(0));leafCollector.setScorer(scorer);LeafCollector leafCollector2 = collector2.getLeafCollector(reader.leaves().get(1));leafCollector2.setScorer(scorer2);- scorer.doc = 0;scorer.score = 3;leafCollector.collect(0);assertNull(minValueChecker.get());assertNull(scorer.minCompetitiveScore);- scorer2.doc = 0;scorer2.score = 6;leafCollector2.collect(0);assertNull(minValueChecker.get());assertNull(scorer2.minCompetitiveScore);- scorer.doc = 1;scorer.score = 2;leafCollector.collect(1);assertEquals(2f, minValueChecker.get().score, 0f);assertEquals(Math.nextUp(2f), scorer.minCompetitiveScore, 0f);assertNull(scorer2.minCompetitiveScore);- scorer2.doc = 1;scorer2.score = 9;leafCollector2.collect(1);assertEquals(6f, minValueChecker.get().score, 0f);assertEquals(Math.nextUp(2f), scorer.minCompetitiveScore, 0f);assertEquals(Math.nextUp(6f), scorer2.minCompetitiveScore, 0f);- scorer2.doc = 2;scorer2.score = 7;leafCollector2.collect(2);assertEquals(minValueChecker.get().score, 7f, 0f);assertEquals(Math.nextUp(2f), scorer.minCompetitiveScore, 0f);assertEquals(Math.nextUp(7f), scorer2.minCompetitiveScore, 0f);- scorer2.doc = 3;scorer2.score = 1;leafCollector2.collect(3);assertEquals(minValueChecker.get().score, 7f, 0f);assertEquals(Math.nextUp(2f), scorer.minCompetitiveScore, 0f);assertEquals(Math.nextUp(7f), scorer2.minCompetitiveScore, 0f);- scorer.doc = 2;scorer.score = 10;leafCollector.collect(2);assertEquals(minValueChecker.get().score, 7f, 0f);assertEquals(7f, scorer.minCompetitiveScore, 0f);assertEquals(Math.nextUp(7f), scorer2.minCompetitiveScore, 0f);- scorer.doc = 3;scorer.score = 11;leafCollector.collect(3);assertEquals(minValueChecker.get().score, 10, 0f);@@ -566,17 +541,15 @@ public class TestTopDocsCollector extends LuceneTestCase {TopScoreDocCollector collector3 = manager.newCollector();LeafCollector leafCollector3 = collector3.getLeafCollector(reader.leaves().get(2));- ScoreAndDoc scorer3 = new ScoreAndDoc();+ Score scorer3 = new Score();leafCollector3.setScorer(scorer3);assertEquals(Math.nextUp(10f), scorer3.minCompetitiveScore, 0f);- scorer3.doc = 0;scorer3.score = 1f;leafCollector3.collect(0);assertEquals(10f, minValueChecker.get().score, 0f);assertEquals(Math.nextUp(10f), scorer3.minCompetitiveScore, 0f);- scorer.doc = 4;scorer.score = 11;leafCollector.collect(4);assertEquals(11f, minValueChecker.get().score, 0f);@@ -584,7 +557,6 @@ public class TestTopDocsCollector extends LuceneTestCase {assertEquals(Math.nextUp(7f), scorer2.minCompetitiveScore, 0f);assertEquals(Math.nextUp(10f), scorer3.minCompetitiveScore, 0f);- scorer3.doc = 1;scorer3.score = 2f;leafCollector3.collect(1);assertEquals(minValueChecker.get().score, 11f, 0f);diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.javaindex 9b0b3329006..11d9c1c3301 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java@@ -195,23 +195,20 @@ public class TestTopFieldCollector extends LuceneTestCase {for (int totalHitsThreshold = 0; totalHitsThreshold < 20; ++totalHitsThreshold) {for (FieldDoc after : new FieldDoc[] {null, new FieldDoc(4, Float.NaN, new Object[] {2L})}) {TopFieldCollector collector = TopFieldCollector.create(sort, 2, after, totalHitsThreshold);- ScoreAndDoc scorer = new ScoreAndDoc();+ Score scorer = new Score();LeafCollector leafCollector1 = collector.getLeafCollector(reader.leaves().get(0));leafCollector1.setScorer(scorer);- scorer.doc = 0;scorer.score = 3;leafCollector1.collect(0);- scorer.doc = 1;scorer.score = 3;leafCollector1.collect(1);LeafCollector leafCollector2 = collector.getLeafCollector(reader.leaves().get(1));leafCollector2.setScorer(scorer);- scorer.doc = 1;scorer.score = 3;if (totalHitsThreshold < 3) {expectThrows(CollectionTerminatedException.class, () -> leafCollector2.collect(1));@@ -223,7 +220,6 @@ public class TestTopFieldCollector extends LuceneTestCase {leafCollector2.collect(1);}- scorer.doc = 5;scorer.score = 4;if (totalHitsThreshold == 3) {expectThrows(CollectionTerminatedException.class, () -> leafCollector2.collect(1));@@ -244,8 +240,7 @@ public class TestTopFieldCollector extends LuceneTestCase {dir.close();}- private static class ScoreAndDoc extends Scorable {- int doc = -1;+ private static class Score extends Scorable {float score;Float minCompetitiveScore = null;@@ -254,11 +249,6 @@ public class TestTopFieldCollector extends LuceneTestCase {this.minCompetitiveScore = minCompetitiveScore;}- @Override- public int docID() {- return doc;- }-@Overridepublic float score() throws IOException {return score;@@ -280,51 +270,44 @@ public class TestTopFieldCollector extends LuceneTestCase {Sort sort = new Sort(FIELD_SCORE, new SortField("foo", SortField.Type.LONG));TopFieldCollector collector = TopFieldCollector.create(sort, 2, null, 2);- ScoreAndDoc scorer = new ScoreAndDoc();+ Score scorer = new Score();LeafCollector leafCollector = collector.getLeafCollector(reader.leaves().get(0));leafCollector.setScorer(scorer);assertNull(scorer.minCompetitiveScore);- scorer.doc = 0;scorer.score = 1;leafCollector.collect(0);assertNull(scorer.minCompetitiveScore);- scorer.doc = 1;scorer.score = 2;leafCollector.collect(1);assertNull(scorer.minCompetitiveScore);- scorer.doc = 2;scorer.score = 3;leafCollector.collect(2);assertEquals(2f, scorer.minCompetitiveScore, 0f);- scorer.doc = 3;scorer.score = 0.5f;// Make sure we do not call setMinCompetitiveScore for non-competitive hitsscorer.minCompetitiveScore = Float.NaN;leafCollector.collect(3);assertTrue(Float.isNaN(scorer.minCompetitiveScore));- scorer.doc = 4;scorer.score = 4;leafCollector.collect(4);assertEquals(3f, scorer.minCompetitiveScore, 0f);// Make sure the min score is set on scorers on new segments- scorer = new ScoreAndDoc();+ scorer = new Score();leafCollector = collector.getLeafCollector(reader.leaves().get(1));leafCollector.setScorer(scorer);assertEquals(3f, scorer.minCompetitiveScore, 0f);- scorer.doc = 0;scorer.score = 1;leafCollector.collect(0);assertEquals(3f, scorer.minCompetitiveScore, 0f);- scorer.doc = 1;scorer.score = 4;leafCollector.collect(1);assertEquals(4f, scorer.minCompetitiveScore, 0f);@@ -349,27 +332,23 @@ public class TestTopFieldCollector extends LuceneTestCase {for (int totalHitsThreshold = 0; totalHitsThreshold < 20; ++totalHitsThreshold) {Sort sort = new Sort(FIELD_SCORE, new SortField("foo", SortField.Type.LONG));TopFieldCollector collector = TopFieldCollector.create(sort, 2, null, totalHitsThreshold);- ScoreAndDoc scorer = new ScoreAndDoc();+ Score scorer = new Score();LeafCollector leafCollector = collector.getLeafCollector(reader.leaves().get(0));leafCollector.setScorer(scorer);- scorer.doc = 0;scorer.score = 3;leafCollector.collect(0);- scorer.doc = 1;scorer.score = 3;leafCollector.collect(1);leafCollector = collector.getLeafCollector(reader.leaves().get(1));leafCollector.setScorer(scorer);- scorer.doc = 1;scorer.score = 3;leafCollector.collect(1);- scorer.doc = 5;scorer.score = 4;leafCollector.collect(1);@@ -442,6 +421,15 @@ public class TestTopFieldCollector extends LuceneTestCase {throws IOException {final LeafCollector in = topCollector.getLeafCollector(context);return new FilterLeafCollector(in) {++ int currentDoc = -1;++ @Override+ public void collect(int doc) throws IOException {+ currentDoc = doc;+ super.collect(doc);+ }+@Overridepublic void setScorer(final Scorable scorer) throws IOException {Scorable s =@@ -451,10 +439,10 @@ public class TestTopFieldCollector extends LuceneTestCase {@Overridepublic float score() throws IOException {- if (lastComputedDoc == docID()) {- throw new AssertionError("Score computed twice on " + docID());+ if (lastComputedDoc == currentDoc) {+ throw new AssertionError("Score computed twice on " + currentDoc);}- lastComputedDoc = docID();+ lastComputedDoc = currentDoc;return scorer.score();}};@@ -567,62 +555,54 @@ public class TestTopFieldCollector extends LuceneTestCase {// force the check of the global minimum score on every roundminValueChecker.modInterval = 0;- ScoreAndDoc scorer = new ScoreAndDoc();- ScoreAndDoc scorer2 = new ScoreAndDoc();+ Score scorer = new Score();+ Score scorer2 = new Score();LeafCollector leafCollector = collector.getLeafCollector(reader.leaves().get(0));leafCollector.setScorer(scorer);LeafCollector leafCollector2 = collector2.getLeafCollector(reader.leaves().get(1));leafCollector2.setScorer(scorer2);- scorer.doc = 0;scorer.score = 3;leafCollector.collect(0);assertNull(minValueChecker.get());assertNull(scorer.minCompetitiveScore);- scorer2.doc = 0;scorer2.score = 6;leafCollector2.collect(0);assertNull(minValueChecker.get());assertNull(scorer2.minCompetitiveScore);- scorer.doc = 1;scorer.score = 2;leafCollector.collect(1);assertEquals(2f, minValueChecker.get().score, 0f);assertEquals(2f, scorer.minCompetitiveScore, 0f);assertNull(scorer2.minCompetitiveScore);- scorer2.doc = 1;scorer2.score = 9;leafCollector2.collect(1);assertEquals(6f, minValueChecker.get().score, 0f);assertEquals(2f, scorer.minCompetitiveScore, 0f);assertEquals(6f, scorer2.minCompetitiveScore, 0f);- scorer2.doc = 2;scorer2.score = 7;leafCollector2.collect(2);assertEquals(7f, minValueChecker.get().score, 0f);assertEquals(2f, scorer.minCompetitiveScore, 0f);assertEquals(7f, scorer2.minCompetitiveScore, 0f);- scorer2.doc = 3;scorer2.score = 1;leafCollector2.collect(3);assertEquals(7f, minValueChecker.get().score, 0f);assertEquals(2f, scorer.minCompetitiveScore, 0f);assertEquals(7f, scorer2.minCompetitiveScore, 0f);- scorer.doc = 2;scorer.score = 10;leafCollector.collect(2);assertEquals(7f, minValueChecker.get().score, 0f);assertEquals(7f, scorer.minCompetitiveScore, 0f);assertEquals(7f, scorer2.minCompetitiveScore, 0f);- scorer.doc = 3;scorer.score = 11;leafCollector.collect(3);assertEquals(10f, minValueChecker.get().score, 0f);@@ -631,17 +611,15 @@ public class TestTopFieldCollector extends LuceneTestCase {TopFieldCollector collector3 = manager.newCollector();LeafCollector leafCollector3 = collector3.getLeafCollector(reader.leaves().get(2));- ScoreAndDoc scorer3 = new ScoreAndDoc();+ Score scorer3 = new Score();leafCollector3.setScorer(scorer3);assertEquals(10f, scorer3.minCompetitiveScore, 0f);- scorer3.doc = 0;scorer3.score = 1f;leafCollector3.collect(0);assertEquals(10f, minValueChecker.get().score, 0f);assertEquals(10f, scorer3.minCompetitiveScore, 0f);- scorer.doc = 4;scorer.score = 11;leafCollector.collect(4);assertEquals(11f, minValueChecker.get().score, 0f);@@ -649,7 +627,6 @@ public class TestTopFieldCollector extends LuceneTestCase {assertEquals(7f, scorer2.minCompetitiveScore, 0f);assertEquals(10f, scorer3.minCompetitiveScore, 0f);- scorer3.doc = 1;scorer3.score = 2f;leafCollector3.collect(1);assertEquals(11f, minValueChecker.get().score, 0f);diff --git a/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysScorer.java b/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysScorer.javaindex ad82594f41d..27118eaa59e 100644--- a/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysScorer.java+++ b/lucene/facet/src/java/org/apache/lucene/facet/DrillSidewaysScorer.java@@ -208,7 +208,8 @@ class DrillSidewaysScorer extends BulkScorer {*/private void doQueryFirstScoring(Bits acceptDocs, LeafCollector collector, DocsAndCost[] dims)throws IOException {- setScorer(collector, ScoreCachingWrappingScorer.wrap(baseScorer));+ collector = ScoreCachingWrappingScorer.wrap(collector);+ setScorer(collector, baseScorer);// Specialize the single-dim use-case as we have a more efficient implementation for that:if (dims.length == 1) {@@ -351,7 +352,7 @@ class DrillSidewaysScorer extends BulkScorer {/** Used when drill downs are highly constraining vs baseQuery. */private void doDrillDownAdvanceScoring(Bits acceptDocs, LeafCollector collector, DocsAndCost[] dims) throws IOException {- setScorer(collector, new ScoreAndDoc());+ setScorer(collector, new Score());final int maxDoc = context.reader().maxDoc();final int numDims = dims.length;@@ -564,7 +565,7 @@ class DrillSidewaysScorer extends BulkScorer {// if (DEBUG) {// System.out.println(" doUnionScoring");// }- setScorer(collector, new ScoreAndDoc());+ setScorer(collector, new Score());final int maxDoc = context.reader().maxDoc();final int numDims = dims.length;@@ -784,12 +785,7 @@ class DrillSidewaysScorer extends BulkScorer {}}- private final class ScoreAndDoc extends Scorable {-- @Override- public int docID() {- return collectDocID;- }+ private final class Score extends Scorable {@Overridepublic float score() {diff --git a/lucene/facet/src/test/org/apache/lucene/facet/AssertingSubDocsAtOnceCollectorManager.java b/lucene/facet/src/test/org/apache/lucene/facet/AssertingSubDocsAtOnceCollectorManager.javadeleted file mode 100644index aa64090484b..00000000000--- a/lucene/facet/src/test/org/apache/lucene/facet/AssertingSubDocsAtOnceCollectorManager.java+++ /dev/null@@ -1,76 +0,0 @@-/*- * Licensed to the Apache Software Foundation (ASF) under one or more- * contributor license agreements. See the NOTICE file distributed with- * this work for additional information regarding copyright ownership.- * The ASF licenses this file to You under the Apache License, Version 2.0- * (the "License"); you may not use this file except in compliance with- * the License. You may obtain a copy of the License at- *- * http://www.apache.org/licenses/LICENSE-2.0- *- * Unless required by applicable law or agreed to in writing, software- * distributed under the License is distributed on an "AS IS" BASIS,- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.- * See the License for the specific language governing permissions and- * limitations under the License.- */-package org.apache.lucene.facet;--import java.io.IOException;-import java.util.ArrayList;-import java.util.Collection;-import java.util.List;-import org.apache.lucene.search.CollectorManager;-import org.apache.lucene.search.Scorable;-import org.apache.lucene.search.ScoreMode;-import org.apache.lucene.search.SimpleCollector;--class AssertingSubDocsAtOnceCollectorManager implements CollectorManager<SimpleCollector, Object> {-- @Override- public AssertingSubDocsAtOnceCollector newCollector() {- return new AssertingSubDocsAtOnceCollector();- }-- @Override- public Object reduce(Collection<SimpleCollector> collectors) {- return null;- }-- /** Verifies in collect() that all child subScorers are on the collected doc. */- static class AssertingSubDocsAtOnceCollector extends SimpleCollector {-- // TODO: allow wrapping another Collector-- List<Scorable> allScorers;-- @Override- public void setScorer(Scorable s) throws IOException {- // Gathers all scorers, including s and "under":- allScorers = new ArrayList<>();- allScorers.add(s);- int upto = 0;- while (upto < allScorers.size()) {- s = allScorers.get(upto++);- for (Scorable.ChildScorable sub : s.getChildren()) {- allScorers.add(sub.child);- }- }- }-- @Override- public void collect(int docID) {- for (Scorable s : allScorers) {- if (docID != s.docID()) {- throw new IllegalStateException(- "subScorer=" + s + " has docID=" + s.docID() + " != collected docID=" + docID);- }- }- }-- @Override- public ScoreMode scoreMode() {- return ScoreMode.COMPLETE_NO_SCORES;- }- }-}diff --git a/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java b/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.javaindex 1280e2f7511..2f322ff73c8 100644--- a/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java+++ b/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java@@ -1134,7 +1134,6 @@ public class TestDrillSideways extends FacetTestCase {String[][] drillDowns = new String[numDims][];int count = 0;- boolean anyMultiValuedDrillDowns = false;while (count < numDrillDown) {int dim = random().nextInt(numDims);if (drillDowns[dim] == null) {@@ -1145,7 +1144,6 @@ public class TestDrillSideways extends FacetTestCase {} else {int orCount = TestUtil.nextInt(random(), 1, Math.min(5, dimValues[dim].length));drillDowns[dim] = new String[orCount];- anyMultiValuedDrillDowns |= orCount > 1;for (int i = 0; i < orCount; i++) {while (true) {String value = dimValues[dim][random().nextInt(dimValues[dim].length)];@@ -1277,18 +1275,6 @@ public class TestDrillSideways extends FacetTestCase {Comparator.comparing(cr -> cr.docAndScore.doc),ScoreMode.COMPLETE_NO_SCORES));- // Also separately verify that DS respects the- // scoreSubDocsAtOnce method, to ensure that all- // subScorers are on the same docID:- if (!anyMultiValuedDrillDowns) {- // Can only do this test when there are no OR'd- // drill-down values, because in that case it's- // easily possible for one of the DD terms to be on- // a future docID:- getNewDrillSidewaysScoreSubdocsAtOnce(s, config, tr)- .search(ddq, new AssertingSubDocsAtOnceCollectorManager());- }-Sort sort = new Sort(new SortField("id", SortField.Type.STRING));DrillSideways ds;if (doUseDV) {diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupHeadsCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupHeadsCollector.javaindex 780090cd0bd..f9284501518 100644--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupHeadsCollector.java+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/AllGroupHeadsCollector.java@@ -320,7 +320,6 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {protected ScoringGroupHead(Scorable scorer, T groupValue, int doc, int docBase)throws IOException {super(groupValue, doc, docBase);- assert scorer.docID() == doc;this.scorer = scorer;this.topScore = scorer.score();}@@ -332,7 +331,6 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {@Overrideprotected int compare(int compIDX, int doc) throws IOException {- assert scorer.docID() == doc;assert compIDX == 0;float score = scorer.score();int c = Float.compare(score, topScore);diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.javaindex 26c3c915dd3..cc72deeb411 100644--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.java+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/BlockGroupingCollector.java@@ -275,7 +275,7 @@ public class BlockGroupingCollector extends SimpleCollector {}int totalGroupedHitCount = 0;- final ScoreAndDoc fakeScorer = new ScoreAndDoc();+ final Score fakeScorer = new Score();float maxScore = Float.MIN_VALUE;@@ -306,7 +306,6 @@ public class BlockGroupingCollector extends SimpleCollector {leafCollector.setScorer(fakeScorer);for (int docIDX = 0; docIDX < og.count; docIDX++) {final int doc = og.docs[docIDX];- fakeScorer.doc = doc;if (needsScores) {fakeScorer.score = og.scores[docIDX];groupMaxScore = Math.max(groupMaxScore, fakeScorer.score);@@ -498,15 +497,9 @@ public class BlockGroupingCollector extends SimpleCollector {return needsScores ? ScoreMode.COMPLETE : ScoreMode.COMPLETE_NO_SCORES;}- private static class ScoreAndDoc extends Scorable {+ private static class Score extends Scorable {float score;- int doc = -1;-- @Override- public int docID() {- return doc;- }@Overridepublic float score() {diff --git a/lucene/monitor/src/java/org/apache/lucene/monitor/Monitor.java b/lucene/monitor/src/java/org/apache/lucene/monitor/Monitor.javaindex 51ddd785606..25d187a8a6a 100644--- a/lucene/monitor/src/java/org/apache/lucene/monitor/Monitor.java+++ b/lucene/monitor/src/java/org/apache/lucene/monitor/Monitor.java@@ -377,8 +377,9 @@ public class Monitor implements Closeable {@Overridepublic void matchQuery(final String id, QueryCacheEntry query, QueryIndex.DataValues dataValues)throws IOException {- Weight w = ((Scorer) dataValues.scorer).getWeight();- Matches matches = w.matches(dataValues.ctx, dataValues.scorer.docID());+ Scorer scorer = ((Scorer) dataValues.scorer);+ Weight w = scorer.getWeight();+ Matches matches = w.matches(dataValues.ctx, scorer.docID());for (String field : matches) {MatchesIterator mi = matches.getMatches(field);while (mi.next()) {diff --git a/lucene/monitor/src/java/org/apache/lucene/monitor/QueryIndex.java b/lucene/monitor/src/java/org/apache/lucene/monitor/QueryIndex.javaindex a8ccd44218b..cac6ea15b90 100644--- a/lucene/monitor/src/java/org/apache/lucene/monitor/QueryIndex.java+++ b/lucene/monitor/src/java/org/apache/lucene/monitor/QueryIndex.java@@ -125,7 +125,6 @@ abstract class QueryIndex implements Closeable {LeafReaderContext ctx;void advanceTo(int doc) throws IOException {- assert scorer.docID() == doc;queryId.advanceExact(doc);cacheId.advanceExact(doc);if (mq != null) {diff --git a/lucene/queries/src/java/org/apache/lucene/queries/function/ValueSource.java b/lucene/queries/src/java/org/apache/lucene/queries/function/ValueSource.javaindex 1320f760894..135be0b4c26 100644--- a/lucene/queries/src/java/org/apache/lucene/queries/function/ValueSource.java+++ b/lucene/queries/src/java/org/apache/lucene/queries/function/ValueSource.java@@ -92,11 +92,6 @@ public abstract class ValueSource {this.scores = scores == null ? DoubleValues.EMPTY : scores;}- @Override- public int docID() {- return docId;- }-@Overridepublic float score() throws IOException {// ensure we calculate the score at most oncediff --git a/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.java b/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.javaindex 48a84c105f2..a2a8c27b056 100644--- a/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.java+++ b/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.java@@ -830,7 +830,6 @@ public class TestValueSources extends LuceneTestCase {return new FloatDocValues(this) {@Overridepublic float floatVal(int doc) throws IOException {- assertEquals(doc, scorer.docID());return scorer.score();}};diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingLeafCollector.java b/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingLeafCollector.javaindex bcf3c4b1098..fbe9f990109 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingLeafCollector.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingLeafCollector.java@@ -28,7 +28,6 @@ class AssertingLeafCollector extends FilterLeafCollector {private final int min;private final int max;- private Scorable scorer;private int lastCollected = -1;private boolean finishCalled;@@ -40,7 +39,6 @@ class AssertingLeafCollector extends FilterLeafCollector {@Overridepublic void setScorer(Scorable scorer) throws IOException {- this.scorer = scorer;super.setScorer(AssertingScorable.wrap(scorer));}@@ -49,7 +47,6 @@ class AssertingLeafCollector extends FilterLeafCollector {assert doc > lastCollected : "Out of order : " + lastCollected + " " + doc;assert doc >= min : "Out of range: " + doc + " < " + min;assert doc < max : "Out of range: " + doc + " >= " + max;- assert scorer.docID() == doc : "Collected: " + doc + " but scorer: " + scorer.docID();in.collect(doc);lastCollected = doc;}diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingScorable.java b/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingScorable.javaindex 2a431ab1cfd..3a87d4c0f1a 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingScorable.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/search/AssertingScorable.java@@ -18,7 +18,6 @@package org.apache.lucene.tests.search;import java.io.IOException;-import org.apache.lucene.search.DocIdSetIterator;import org.apache.lucene.search.FilterScorable;import org.apache.lucene.search.FilterScorer;import org.apache.lucene.search.Scorable;@@ -33,9 +32,6 @@ public class AssertingScorable extends FilterScorable {@Overridepublic float score() throws IOException {- int docId = docID();- assert docId != -1 && docId != DocIdSetIterator.NO_MORE_DOCS- : "score() called on unpositioned Scorable docid=" + docID();final float score = in.score();assert !Float.isNaN(score) : "NaN score for in=" + in;return score;