Skip to content

Apache Lucene open-source search software

Remove Scorable#docID. (#12407)

Adrien Grandf527eb3b12df
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 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.md
index 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.java
index 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 {
@Override
public 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.java
index 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();
@Override
public void setScorer(Scorable scorer) throws IOException {
@@ -173,7 +173,6 @@ final class BooleanWeight extends Weight {
@Override
public 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.java
index 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;
@Override
public 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.java
index 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 {
@Override
public 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.java
index 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> {
@Override
public 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;
}
@Override
diff --git a/lucene/core/src/java/org/apache/lucene/search/FilterScorable.java b/lucene/core/src/java/org/apache/lucene/search/FilterScorable.java
index 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();
- }
-
@Override
public 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.java
index 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.java
index 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;
- }
@Override
public 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.java
index 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;
}
@Override
public 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.java
index 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 {
@Override
public 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.java
index 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.java
similarity index 89%
rename from lucene/core/src/java/org/apache/lucene/search/ScoreAndDoc.java
rename to lucene/core/src/java/org/apache/lucene/search/Score.java
index 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;
- }
@Override
public 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.java
index 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 {
@Override
public 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();
- }
-
@Override
public 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.java
index 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.java
index 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.java
index 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.java
index 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.java
index 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.java
index 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.java
index 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.java
index 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();
- }
@Override
public float score() {
@@ -244,10 +240,6 @@ public class TestMultiCollector extends LuceneTestCase {
Scorable scorer =
new Scorable() {
- @Override
- public int docID() {
- throw new UnsupportedOperationException();
- }
@Override
public 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 => caching
c1 = 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;
- }
-
@Override
public 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); // OK
assertTrue("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.java
index 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 => caching
cm1 = 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.java
index 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.java
index 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 {
@Override
public 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.java
index 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;
- }
-
@Override
public 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 hits
scorer.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 round
minValueChecker.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.java
index 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;
- }
-
@Override
public 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 hits
scorer.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);
+ }
+
@Override
public void setScorer(final Scorable scorer) throws IOException {
Scorable s =
@@ -451,10 +439,10 @@ public class TestTopFieldCollector extends LuceneTestCase {
@Override
public 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 round
minValueChecker.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.java
index 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 {
@Override
public 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.java
deleted file mode 100644
index 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.java
index 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.java
index 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 {
@Override
protected 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.java
index 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;
- }
@Override
public 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.java
index 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 {
@Override
public 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.java
index 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.java
index 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;
- }
-
@Override
public float score() throws IOException {
// ensure we calculate the score at most once
diff --git a/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.java b/lucene/queries/src/test/org/apache/lucene/queries/function/TestValueSources.java
index 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) {
@Override
public 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.java
index 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 {
@Override
public 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.java
index 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 {
@Override
public 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;