You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by ro...@apache.org on 2022/01/17 11:46:43 UTC
[lucene] branch branch_9x updated: LUCENE-10377: Replace 'sortPos' with 'enableSkipping' in SortField.getComparator() (#603)
This is an automated email from the ASF dual-hosted git repository.
romseygeek pushed a commit to branch branch_9x
in repository https://gitbox.apache.org/repos/asf/lucene.git
The following commit(s) were added to refs/heads/branch_9x by this push:
new f8c7619 LUCENE-10377: Replace 'sortPos' with 'enableSkipping' in SortField.getComparator() (#603)
f8c7619 is described below
commit f8c76198d21fe57b7c6059d487962917f38629c4
Author: Alan Woodward <ro...@apache.org>
AuthorDate: Mon Jan 17 10:44:57 2022 +0000
LUCENE-10377: Replace 'sortPos' with 'enableSkipping' in SortField.getComparator() (#603)
The sort position parameter in SortField.getComparator() is only ever used
to determine whether or not skipping should be enabled on a given comparator,
so the parameter name should reflect that. This commit also explicitly disables
skipping in a number of cases where it is never used, in particular CheckIndex
and the grouping collectors.
---
lucene/CHANGES.txt | 7 +++
.../apache/lucene/document/FeatureSortField.java | 2 +-
.../lucene/document/LatLonPointSortField.java | 2 +-
.../apache/lucene/document/XYPointSortField.java | 2 +-
.../java/org/apache/lucene/index/CheckIndex.java | 2 +-
.../apache/lucene/search/DoubleValuesSource.java | 10 +--
.../lucene/search/FieldComparatorSource.java | 2 +-
.../apache/lucene/search/FieldValueHitQueue.java | 2 +-
.../org/apache/lucene/search/LongValuesSource.java | 10 +--
.../java/org/apache/lucene/search/SortField.java | 20 +++---
.../lucene/search/SortedNumericSortField.java | 71 ++++++----------------
.../apache/lucene/search/SortedSetSortField.java | 2 +-
.../src/java/org/apache/lucene/search/TopDocs.java | 2 +-
.../lucene/search/comparators/DocComparator.java | 4 +-
.../search/comparators/DoubleComparator.java | 4 +-
.../lucene/search/comparators/FloatComparator.java | 4 +-
.../lucene/search/comparators/IntComparator.java | 4 +-
.../lucene/search/comparators/LongComparator.java | 4 +-
.../search/comparators/NumericComparator.java | 33 ++--------
.../apache/lucene/search/JustCompileSearch.java | 2 +-
.../lucene/search/TestElevationComparator.java | 2 +-
.../search/grouping/AllGroupHeadsCollector.java | 2 +-
.../search/grouping/BlockGroupingCollector.java | 2 +-
.../grouping/FirstPassGroupingCollector.java | 2 +-
.../apache/lucene/search/grouping/SearchGroup.java | 2 +-
.../search/join/ToParentBlockJoinSortField.java | 48 ++++-----------
.../lucene/queries/function/ValueSource.java | 2 +-
.../IndexSortSortedNumericDocValuesRangeQuery.java | 3 +-
.../spatial3d/Geo3DPointOutsideSortField.java | 2 +-
.../lucene/spatial3d/Geo3DPointSortField.java | 2 +-
30 files changed, 86 insertions(+), 170 deletions(-)
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 65c0369..16e3d52 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -25,6 +25,10 @@ API Changes
* LUCENE-10349: WordListLoader methods now return unmodifiable CharArraySets. (Uwe Schindler)
+* LUCENE-10377: SortField.getComparator() has changed signature. The second parameter is now
+ a boolean indicating whether or not skipping should be enabled on the comparator.
+ (Alan Woodward)
+
New Features
---------------------
@@ -143,6 +147,9 @@ Bug Fixes
* LLUCENE-10353: Add random null injection to TestRandomChains. (Robert Muir,
Uwe Schindler)
+* LUCENE-10377: CheckIndex could incorrectly throw an error when checking index sorts
+ defined on older indexes. (Alan Woodward)
+
Other
---------------------
diff --git a/lucene/core/src/java/org/apache/lucene/document/FeatureSortField.java b/lucene/core/src/java/org/apache/lucene/document/FeatureSortField.java
index f06ead5..2a28680 100644
--- a/lucene/core/src/java/org/apache/lucene/document/FeatureSortField.java
+++ b/lucene/core/src/java/org/apache/lucene/document/FeatureSortField.java
@@ -44,7 +44,7 @@ final class FeatureSortField extends SortField {
}
@Override
- public FieldComparator<?> getComparator(int numHits, int sortPos) {
+ public FieldComparator<?> getComparator(int numHits, boolean enableSkipping) {
return new FeatureComparator(numHits, getField(), featureName);
}
diff --git a/lucene/core/src/java/org/apache/lucene/document/LatLonPointSortField.java b/lucene/core/src/java/org/apache/lucene/document/LatLonPointSortField.java
index 36f3935..768b27e 100644
--- a/lucene/core/src/java/org/apache/lucene/document/LatLonPointSortField.java
+++ b/lucene/core/src/java/org/apache/lucene/document/LatLonPointSortField.java
@@ -38,7 +38,7 @@ final class LatLonPointSortField extends SortField {
}
@Override
- public FieldComparator<?> getComparator(int numHits, int sortPos) {
+ public FieldComparator<?> getComparator(int numHits, boolean enableSkipping) {
return new LatLonPointDistanceComparator(getField(), latitude, longitude, numHits);
}
diff --git a/lucene/core/src/java/org/apache/lucene/document/XYPointSortField.java b/lucene/core/src/java/org/apache/lucene/document/XYPointSortField.java
index 2063a6c..f7f1632 100644
--- a/lucene/core/src/java/org/apache/lucene/document/XYPointSortField.java
+++ b/lucene/core/src/java/org/apache/lucene/document/XYPointSortField.java
@@ -35,7 +35,7 @@ final class XYPointSortField extends SortField {
}
@Override
- public FieldComparator<?> getComparator(int numHits, int sortPos) {
+ public FieldComparator<?> getComparator(int numHits, boolean enableSkipping) {
return new XYPointDistanceComparator(getField(), x, y, numHits);
}
diff --git a/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java b/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java
index f699937..3dd5526 100644
--- a/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java
+++ b/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java
@@ -1107,7 +1107,7 @@ public final class CheckIndex implements Closeable {
for (int i = 0; i < fields.length; i++) {
reverseMul[i] = fields[i].getReverse() ? -1 : 1;
- comparators[i] = fields[i].getComparator(1, i).getLeafComparator(readerContext);
+ comparators[i] = fields[i].getComparator(1, false).getLeafComparator(readerContext);
}
int maxDoc = reader.maxDoc();
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 5d4f768..303dc51 100644
--- a/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java
+++ b/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSource.java
@@ -25,7 +25,6 @@ import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.index.NumericDocValues;
-import org.apache.lucene.index.PointValues;
import org.apache.lucene.search.comparators.DoubleComparator;
/**
@@ -483,8 +482,8 @@ public abstract class DoubleValuesSource implements SegmentCacheable {
@Override
public FieldComparator<Double> newComparator(
- String fieldname, int numHits, int sortPos, boolean reversed) {
- return new DoubleComparator(numHits, fieldname, missingValue, reversed, sortPos) {
+ String fieldname, int numHits, boolean enableSkipping, boolean reversed) {
+ return new DoubleComparator(numHits, fieldname, missingValue, reversed, false) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context) throws IOException {
DoubleValuesHolder holder = new DoubleValuesHolder();
@@ -500,11 +499,6 @@ public abstract class DoubleValuesSource implements SegmentCacheable {
}
@Override
- protected PointValues getPointValues(LeafReaderContext context, String field) {
- return null;
- }
-
- @Override
public void setScorer(Scorable scorer) throws IOException {
holder.values = producer.getValues(ctx, fromScorer(scorer));
super.setScorer(scorer);
diff --git a/lucene/core/src/java/org/apache/lucene/search/FieldComparatorSource.java b/lucene/core/src/java/org/apache/lucene/search/FieldComparatorSource.java
index 1539926..fd110b7 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FieldComparatorSource.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FieldComparatorSource.java
@@ -30,5 +30,5 @@ public abstract class FieldComparatorSource {
* @return FieldComparator.
*/
public abstract FieldComparator<?> newComparator(
- String fieldname, int numHits, int sortPos, boolean reversed);
+ String fieldname, int numHits, boolean enableSkipping, boolean reversed);
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/FieldValueHitQueue.java b/lucene/core/src/java/org/apache/lucene/search/FieldValueHitQueue.java
index 60596f3..5654313 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FieldValueHitQueue.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FieldValueHitQueue.java
@@ -134,7 +134,7 @@ public abstract class FieldValueHitQueue<T extends FieldValueHitQueue.Entry>
for (int i = 0; i < numComparators; ++i) {
SortField field = fields[i];
reverseMul[i] = field.reverse ? -1 : 1;
- comparators[i] = field.getComparator(size, i);
+ comparators[i] = field.getComparator(size, i == 0);
}
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/LongValuesSource.java b/lucene/core/src/java/org/apache/lucene/search/LongValuesSource.java
index 4443b05..2b2ed49 100644
--- a/lucene/core/src/java/org/apache/lucene/search/LongValuesSource.java
+++ b/lucene/core/src/java/org/apache/lucene/search/LongValuesSource.java
@@ -22,7 +22,6 @@ import java.util.Objects;
import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.index.NumericDocValues;
-import org.apache.lucene.index.PointValues;
import org.apache.lucene.search.comparators.LongComparator;
/**
@@ -328,8 +327,8 @@ public abstract class LongValuesSource implements SegmentCacheable {
@Override
public FieldComparator<Long> newComparator(
- String fieldname, int numHits, int sortPos, boolean reversed) {
- return new LongComparator(numHits, fieldname, missingValue, reversed, sortPos) {
+ String fieldname, int numHits, boolean enableSkipping, boolean reversed) {
+ return new LongComparator(numHits, fieldname, missingValue, reversed, false) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context) throws IOException {
LongValuesHolder holder = new LongValuesHolder();
@@ -345,11 +344,6 @@ public abstract class LongValuesSource implements SegmentCacheable {
}
@Override
- protected PointValues getPointValues(LeafReaderContext context, String field) {
- return null;
- }
-
- @Override
public void setScorer(Scorable scorer) throws IOException {
holder.values = producer.getValues(ctx, DoubleValuesSource.fromScorer(scorer));
super.setScorer(scorer);
diff --git a/lucene/core/src/java/org/apache/lucene/search/SortField.java b/lucene/core/src/java/org/apache/lucene/search/SortField.java
index 1815413..76815c5 100644
--- a/lucene/core/src/java/org/apache/lucene/search/SortField.java
+++ b/lucene/core/src/java/org/apache/lucene/search/SortField.java
@@ -495,12 +495,11 @@ public class SortField {
*
* @lucene.experimental
* @param numHits number of top hits the queue will store
- * @param sortPos position of this SortField within {@link Sort}. The comparator is primary if
- * sortPos==0, secondary if sortPos==1, etc. Some comparators can optimize themselves when
- * they are the primary sort.
+ * @param enableSkipping true if the comparator can skip documents via {@link
+ * LeafFieldComparator#competitiveIterator()}
* @return {@link FieldComparator} to use when sorting
*/
- public FieldComparator<?> getComparator(final int numHits, final int sortPos) {
+ public FieldComparator<?> getComparator(final int numHits, boolean enableSkipping) {
final FieldComparator<?> fieldComparator;
switch (type) {
case SCORE:
@@ -508,31 +507,32 @@ public class SortField {
break;
case DOC:
- fieldComparator = new DocComparator(numHits, reverse, sortPos);
+ fieldComparator = new DocComparator(numHits, reverse, enableSkipping);
break;
case INT:
fieldComparator =
- new IntComparator(numHits, field, (Integer) missingValue, reverse, sortPos);
+ new IntComparator(numHits, field, (Integer) missingValue, reverse, enableSkipping);
break;
case FLOAT:
fieldComparator =
- new FloatComparator(numHits, field, (Float) missingValue, reverse, sortPos);
+ new FloatComparator(numHits, field, (Float) missingValue, reverse, enableSkipping);
break;
case LONG:
- fieldComparator = new LongComparator(numHits, field, (Long) missingValue, reverse, sortPos);
+ fieldComparator =
+ new LongComparator(numHits, field, (Long) missingValue, reverse, enableSkipping);
break;
case DOUBLE:
fieldComparator =
- new DoubleComparator(numHits, field, (Double) missingValue, reverse, sortPos);
+ new DoubleComparator(numHits, field, (Double) missingValue, reverse, enableSkipping);
break;
case CUSTOM:
assert comparatorSource != null;
- fieldComparator = comparatorSource.newComparator(field, numHits, sortPos, reverse);
+ fieldComparator = comparatorSource.newComparator(field, numHits, enableSkipping, reverse);
break;
case STRING:
diff --git a/lucene/core/src/java/org/apache/lucene/search/SortedNumericSortField.java b/lucene/core/src/java/org/apache/lucene/search/SortedNumericSortField.java
index e01461e..38de654 100644
--- a/lucene/core/src/java/org/apache/lucene/search/SortedNumericSortField.java
+++ b/lucene/core/src/java/org/apache/lucene/search/SortedNumericSortField.java
@@ -22,7 +22,6 @@ import org.apache.lucene.index.IndexSorter;
import org.apache.lucene.index.LeafReader;
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.index.NumericDocValues;
-import org.apache.lucene.index.PointValues;
import org.apache.lucene.index.SortFieldProvider;
import org.apache.lucene.index.SortedNumericDocValues;
import org.apache.lucene.search.comparators.DoubleComparator;
@@ -242,12 +241,21 @@ public class SortedNumericSortField extends SortField {
}
@Override
- public FieldComparator<?> getComparator(int numHits, int sortPos) {
+ public FieldComparator<?> getComparator(int numHits, boolean enableSkipping) {
final FieldComparator<?> fieldComparator;
+ // we can use sort optimization with points if selector is MIN or MAX,
+ // because we can still build successful iterator over points in this case.
+ boolean isMinOrMax =
+ selector == SortedNumericSelector.Type.MAX || selector == SortedNumericSelector.Type.MIN;
switch (type) {
case INT:
fieldComparator =
- new IntComparator(numHits, getField(), (Integer) missingValue, reverse, sortPos) {
+ new IntComparator(
+ numHits,
+ getField(),
+ (Integer) missingValue,
+ reverse,
+ enableSkipping && isMinOrMax) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context)
throws IOException {
@@ -258,25 +266,14 @@ public class SortedNumericSortField extends SortField {
return SortedNumericSelector.wrap(
DocValues.getSortedNumeric(context.reader(), field), selector, type);
}
- // we can use sort optimization with points if selector is MIN or MAX,
- // because we can still build successful iterator over points in this case.
- @Override
- protected PointValues getPointValues(LeafReaderContext context, String field)
- throws IOException {
- if (selector == SortedNumericSelector.Type.MAX
- || selector == SortedNumericSelector.Type.MIN) {
- return super.getPointValues(context, field);
- } else {
- return null;
- }
- }
};
}
};
break;
case FLOAT:
fieldComparator =
- new FloatComparator(numHits, getField(), (Float) missingValue, reverse, sortPos) {
+ new FloatComparator(
+ numHits, getField(), (Float) missingValue, reverse, enableSkipping && isMinOrMax) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context)
throws IOException {
@@ -287,25 +284,14 @@ public class SortedNumericSortField extends SortField {
return SortedNumericSelector.wrap(
DocValues.getSortedNumeric(context.reader(), field), selector, type);
}
- // we can use sort optimization with points if selector is MIN or MAX,
- // because we can still build successful iterator over points in this case.
- @Override
- protected PointValues getPointValues(LeafReaderContext context, String field)
- throws IOException {
- if (selector == SortedNumericSelector.Type.MAX
- || selector == SortedNumericSelector.Type.MIN) {
- return super.getPointValues(context, field);
- } else {
- return null;
- }
- }
};
}
};
break;
case LONG:
fieldComparator =
- new LongComparator(numHits, getField(), (Long) missingValue, reverse, sortPos) {
+ new LongComparator(
+ numHits, getField(), (Long) missingValue, reverse, enableSkipping && isMinOrMax) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context)
throws IOException {
@@ -316,25 +302,14 @@ public class SortedNumericSortField extends SortField {
return SortedNumericSelector.wrap(
DocValues.getSortedNumeric(context.reader(), field), selector, type);
}
- // we can use sort optimization with points if selector is MIN or MAX,
- // because we can still build successful iterator over points in this case.
- @Override
- protected PointValues getPointValues(LeafReaderContext context, String field)
- throws IOException {
- if (selector == SortedNumericSelector.Type.MAX
- || selector == SortedNumericSelector.Type.MIN) {
- return super.getPointValues(context, field);
- } else {
- return null;
- }
- }
};
}
};
break;
case DOUBLE:
fieldComparator =
- new DoubleComparator(numHits, getField(), (Double) missingValue, reverse, sortPos) {
+ new DoubleComparator(
+ numHits, getField(), (Double) missingValue, reverse, enableSkipping && isMinOrMax) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context)
throws IOException {
@@ -345,18 +320,6 @@ public class SortedNumericSortField extends SortField {
return SortedNumericSelector.wrap(
DocValues.getSortedNumeric(context.reader(), field), selector, type);
}
- // we can use sort optimization with points if selector is MIN or MAX,
- // because we can still build successful iterator over points in this case.
- @Override
- protected PointValues getPointValues(LeafReaderContext context, String field)
- throws IOException {
- if (selector == SortedNumericSelector.Type.MAX
- || selector == SortedNumericSelector.Type.MIN) {
- return super.getPointValues(context, field);
- } else {
- return null;
- }
- }
};
}
};
diff --git a/lucene/core/src/java/org/apache/lucene/search/SortedSetSortField.java b/lucene/core/src/java/org/apache/lucene/search/SortedSetSortField.java
index b09bd41..a44e4a8 100644
--- a/lucene/core/src/java/org/apache/lucene/search/SortedSetSortField.java
+++ b/lucene/core/src/java/org/apache/lucene/search/SortedSetSortField.java
@@ -177,7 +177,7 @@ public class SortedSetSortField extends SortField {
}
@Override
- public FieldComparator<?> getComparator(int numHits, int sortPos) {
+ public FieldComparator<?> getComparator(int numHits, boolean enableSkipping) {
return new FieldComparator.TermOrdValComparator(
numHits, getField(), missingValue == STRING_LAST) {
@Override
diff --git a/lucene/core/src/java/org/apache/lucene/search/TopDocs.java b/lucene/core/src/java/org/apache/lucene/search/TopDocs.java
index 0b468a4..7871db9 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TopDocs.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TopDocs.java
@@ -159,7 +159,7 @@ public class TopDocs {
reverseMul = new int[sortFields.length];
for (int compIDX = 0; compIDX < sortFields.length; compIDX++) {
final SortField sortField = sortFields[compIDX];
- comparators[compIDX] = sortField.getComparator(1, compIDX);
+ comparators[compIDX] = sortField.getComparator(1, compIDX == 0);
reverseMul[compIDX] = sortField.getReverse() ? -1 : 1;
}
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/comparators/DocComparator.java b/lucene/core/src/java/org/apache/lucene/search/comparators/DocComparator.java
index 7b8845b..53b1c58 100644
--- a/lucene/core/src/java/org/apache/lucene/search/comparators/DocComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/comparators/DocComparator.java
@@ -35,10 +35,10 @@ public class DocComparator extends FieldComparator<Integer> {
private boolean hitsThresholdReached;
/** Creates a new comparator based on document ids for {@code numHits} */
- public DocComparator(int numHits, boolean reverse, int sortPost) {
+ public DocComparator(int numHits, boolean reverse, boolean enableSkipping) {
this.docIDs = new int[numHits];
// skipping functionality is enabled if we are sorting by _doc in asc order as a primary sort
- this.enableSkipping = (reverse == false && sortPost == 0);
+ this.enableSkipping = (reverse == false && enableSkipping);
}
@Override
diff --git a/lucene/core/src/java/org/apache/lucene/search/comparators/DoubleComparator.java b/lucene/core/src/java/org/apache/lucene/search/comparators/DoubleComparator.java
index 62f46d9..68fc72c 100644
--- a/lucene/core/src/java/org/apache/lucene/search/comparators/DoubleComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/comparators/DoubleComparator.java
@@ -32,8 +32,8 @@ public class DoubleComparator extends NumericComparator<Double> {
protected double bottom;
public DoubleComparator(
- int numHits, String field, Double missingValue, boolean reverse, int sortPos) {
- super(field, missingValue != null ? missingValue : 0.0, reverse, sortPos, Double.BYTES);
+ int numHits, String field, Double missingValue, boolean reverse, boolean enableSkipping) {
+ super(field, missingValue != null ? missingValue : 0.0, reverse, enableSkipping, Double.BYTES);
values = new double[numHits];
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/comparators/FloatComparator.java b/lucene/core/src/java/org/apache/lucene/search/comparators/FloatComparator.java
index ed72db3..8bb9a22 100644
--- a/lucene/core/src/java/org/apache/lucene/search/comparators/FloatComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/comparators/FloatComparator.java
@@ -32,8 +32,8 @@ public class FloatComparator extends NumericComparator<Float> {
protected float bottom;
public FloatComparator(
- int numHits, String field, Float missingValue, boolean reverse, int sortPos) {
- super(field, missingValue != null ? missingValue : 0.0f, reverse, sortPos, Float.BYTES);
+ int numHits, String field, Float missingValue, boolean reverse, boolean enableSkipping) {
+ super(field, missingValue != null ? missingValue : 0.0f, reverse, enableSkipping, Float.BYTES);
values = new float[numHits];
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/comparators/IntComparator.java b/lucene/core/src/java/org/apache/lucene/search/comparators/IntComparator.java
index 9f2f07b..d3576e9 100644
--- a/lucene/core/src/java/org/apache/lucene/search/comparators/IntComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/comparators/IntComparator.java
@@ -32,8 +32,8 @@ public class IntComparator extends NumericComparator<Integer> {
protected int bottom;
public IntComparator(
- int numHits, String field, Integer missingValue, boolean reverse, int sortPos) {
- super(field, missingValue != null ? missingValue : 0, reverse, sortPos, Integer.BYTES);
+ int numHits, String field, Integer missingValue, boolean reverse, boolean enableSkipping) {
+ super(field, missingValue != null ? missingValue : 0, reverse, enableSkipping, Integer.BYTES);
values = new int[numHits];
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/comparators/LongComparator.java b/lucene/core/src/java/org/apache/lucene/search/comparators/LongComparator.java
index 471de2d..a96a163 100644
--- a/lucene/core/src/java/org/apache/lucene/search/comparators/LongComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/comparators/LongComparator.java
@@ -32,8 +32,8 @@ public class LongComparator extends NumericComparator<Long> {
protected long bottom;
public LongComparator(
- int numHits, String field, Long missingValue, boolean reverse, int sortPos) {
- super(field, missingValue != null ? missingValue : 0L, reverse, sortPos, Long.BYTES);
+ int numHits, String field, Long missingValue, boolean reverse, boolean enableSkipping) {
+ super(field, missingValue != null ? missingValue : 0L, reverse, enableSkipping, Long.BYTES);
values = new long[numHits];
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/comparators/NumericComparator.java b/lucene/core/src/java/org/apache/lucene/search/comparators/NumericComparator.java
index d8a597d..a44583f 100644
--- a/lucene/core/src/java/org/apache/lucene/search/comparators/NumericComparator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/comparators/NumericComparator.java
@@ -55,12 +55,12 @@ public abstract class NumericComparator<T extends Number> extends FieldComparato
private boolean canSkipDocuments;
protected NumericComparator(
- String field, T missingValue, boolean reverse, int sortPos, int bytesCount) {
+ String field, T missingValue, boolean reverse, boolean enableSkipping, int bytesCount) {
this.field = field;
this.missingValue = missingValue;
this.reverse = reverse;
// skipping functionality is only relevant for primary sort
- this.canSkipDocuments = (sortPos == 0);
+ this.canSkipDocuments = enableSkipping;
this.bytesCount = bytesCount;
this.bytesComparator = ArrayUtil.getUnsignedComparator(bytesCount);
}
@@ -97,7 +97,7 @@ public abstract class NumericComparator<T extends Number> extends FieldComparato
public NumericLeafComparator(LeafReaderContext context) throws IOException {
this.docValues = getNumericDocValues(context, field);
- this.pointValues = canSkipDocuments ? getPointValues(context, field) : null;
+ this.pointValues = canSkipDocuments ? context.reader().getPointValues(field) : null;
if (pointValues != null) {
FieldInfo info = context.reader().getFieldInfos().fieldInfo(field);
if (info == null || info.getPointDimensionCount() == 0) {
@@ -138,10 +138,9 @@ public abstract class NumericComparator<T extends Number> extends FieldComparato
/**
* Retrieves the NumericDocValues for the field in this segment
*
- * <p>If you override this method, you must also override {@link
- * #getPointValues(LeafReaderContext, String)} This class uses sort optimization that leverages
- * points to filter out non-competitive matches, which relies on the assumption that points and
- * doc values record the same information.
+ * <p>If you override this method, you should probably always disable skipping as the comparator
+ * uses values from the points index to build its competitive iterators, and assumes that the
+ * values in doc values and points are the same.
*
* @param context – reader context
* @param field - field name
@@ -153,26 +152,6 @@ public abstract class NumericComparator<T extends Number> extends FieldComparato
return DocValues.getNumeric(context.reader(), field);
}
- /**
- * Retrieves point values for the field in this segment
- *
- * <p>If you override this method, you must also override {@link
- * #getNumericDocValues(LeafReaderContext, String)} This class uses sort optimization that
- * leverages points to filter out non-competitive matches, which relies on the assumption that
- * points and doc values record the same information. Return {@code null} even if no points
- * implementation is available, in this case sort optimization with points will be disabled.
- *
- * @param context – reader context
- * @param field - field name
- * @return point values for the field in this segment if they are available or {@code null} if
- * sort optimization with points should be disabled.
- * @throws IOException If there is a low-level I/O error
- */
- protected PointValues getPointValues(LeafReaderContext context, String field)
- throws IOException {
- return context.reader().getPointValues(field);
- }
-
@Override
public void setBottom(int slot) throws IOException {
queueFull = true; // if we are setting bottom, it means that we have collected enough hits
diff --git a/lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java b/lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java
index 162c143..c987ecf 100644
--- a/lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java
+++ b/lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java
@@ -118,7 +118,7 @@ final class JustCompileSearch {
@Override
public FieldComparator<?> newComparator(
- String fieldname, int numHits, int sortPos, boolean reversed) {
+ String fieldname, int numHits, boolean enableSkipping, boolean reversed) {
throw new UnsupportedOperationException(UNSUPPORTED_MSG);
}
}
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java b/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
index 2cb8e3a..1b7881f 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestElevationComparator.java
@@ -151,7 +151,7 @@ class ElevationComparatorSource extends FieldComparatorSource {
@Override
public FieldComparator<Integer> newComparator(
- final String fieldname, final int numHits, int sortPos, boolean reversed) {
+ final String fieldname, final int numHits, boolean enableSkipping, boolean reversed) {
return new FieldComparator<Integer>() {
private final int[] values = new int[numHits];
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 56a2d3d..8bfe9f1 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
@@ -258,7 +258,7 @@ public abstract class AllGroupHeadsCollector<T> extends SimpleCollector {
comparators = new FieldComparator[sortFields.length];
leafComparators = new LeafFieldComparator[sortFields.length];
for (int i = 0; i < sortFields.length; i++) {
- comparators[i] = sortFields[i].getComparator(1, i);
+ comparators[i] = sortFields[i].getComparator(1, false);
leafComparators[i] = comparators[i].getLeafComparator(context);
leafComparators[i].setScorer(scorer);
leafComparators[i].copy(0, doc);
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 226aca0..9ead686 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
@@ -240,7 +240,7 @@ public class BlockGroupingCollector extends SimpleCollector {
reversed = new int[sortFields.length];
for (int i = 0; i < sortFields.length; i++) {
final SortField sortField = sortFields[i];
- comparators[i] = sortField.getComparator(topNGroups, i);
+ comparators[i] = sortField.getComparator(topNGroups, false);
reversed[i] = sortField.getReverse() ? -1 : 1;
}
}
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/FirstPassGroupingCollector.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/FirstPassGroupingCollector.java
index 6873eb3..9bcda62 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/FirstPassGroupingCollector.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/FirstPassGroupingCollector.java
@@ -90,7 +90,7 @@ public class FirstPassGroupingCollector<T> extends SimpleCollector {
// use topNGroups + 1 so we have a spare slot to use for comparing (tracked by
// this.spareSlot):
- comparators[i] = sortField.getComparator(topNGroups + 1, i);
+ comparators[i] = sortField.getComparator(topNGroups + 1, false);
reversed[i] = sortField.getReverse() ? -1 : 1;
}
diff --git a/lucene/grouping/src/java/org/apache/lucene/search/grouping/SearchGroup.java b/lucene/grouping/src/java/org/apache/lucene/search/grouping/SearchGroup.java
index d322135..087cae7 100644
--- a/lucene/grouping/src/java/org/apache/lucene/search/grouping/SearchGroup.java
+++ b/lucene/grouping/src/java/org/apache/lucene/search/grouping/SearchGroup.java
@@ -176,7 +176,7 @@ public class SearchGroup<T> {
reversed = new int[sortFields.length];
for (int compIDX = 0; compIDX < sortFields.length; compIDX++) {
final SortField sortField = sortFields[compIDX];
- comparators[compIDX] = sortField.getComparator(1, compIDX);
+ comparators[compIDX] = sortField.getComparator(1, false);
reversed[compIDX] = sortField.getReverse() ? -1 : 1;
}
}
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinSortField.java b/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinSortField.java
index b97a3ca..20307ba 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinSortField.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/ToParentBlockJoinSortField.java
@@ -23,7 +23,6 @@ import org.apache.lucene.index.DocValues;
import org.apache.lucene.index.FilterNumericDocValues;
import org.apache.lucene.index.LeafReaderContext;
import org.apache.lucene.index.NumericDocValues;
-import org.apache.lucene.index.PointValues;
import org.apache.lucene.index.SortedDocValues;
import org.apache.lucene.index.SortedNumericDocValues;
import org.apache.lucene.index.SortedSetDocValues;
@@ -112,18 +111,18 @@ public class ToParentBlockJoinSortField extends SortField {
}
@Override
- public FieldComparator<?> getComparator(int numHits, int sortPos) {
+ public FieldComparator<?> getComparator(int numHits, boolean enableSkipping) {
switch (getType()) {
case STRING:
return getStringComparator(numHits);
case DOUBLE:
- return getDoubleComparator(numHits, sortPos);
+ return getDoubleComparator(numHits);
case FLOAT:
- return getFloatComparator(numHits, sortPos);
+ return getFloatComparator(numHits);
case LONG:
- return getLongComparator(numHits, sortPos);
+ return getLongComparator(numHits);
case INT:
- return getIntComparator(numHits, sortPos);
+ return getIntComparator(numHits);
case CUSTOM:
case DOC:
case REWRITEABLE:
@@ -154,8 +153,8 @@ public class ToParentBlockJoinSortField extends SortField {
};
}
- private FieldComparator<?> getIntComparator(int numHits, int sortPos) {
- return new IntComparator(numHits, getField(), (Integer) missingValue, getReverse(), sortPos) {
+ private FieldComparator<?> getIntComparator(int numHits) {
+ return new IntComparator(numHits, getField(), (Integer) missingValue, getReverse(), false) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context) throws IOException {
return new IntLeafComparator(context) {
@@ -173,18 +172,13 @@ public class ToParentBlockJoinSortField extends SortField {
}
return BlockJoinSelector.wrap(sortedNumeric, type, parents, toIter(children));
}
- // no sort optimization with points
- @Override
- protected PointValues getPointValues(LeafReaderContext context, String field) {
- return null;
- }
};
}
};
}
- private FieldComparator<?> getLongComparator(int numHits, int sortPos) {
- return new LongComparator(numHits, getField(), (Long) missingValue, getReverse(), sortPos) {
+ private FieldComparator<?> getLongComparator(int numHits) {
+ return new LongComparator(numHits, getField(), (Long) missingValue, getReverse(), false) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context) throws IOException {
return new LongLeafComparator(context) {
@@ -202,18 +196,13 @@ public class ToParentBlockJoinSortField extends SortField {
}
return BlockJoinSelector.wrap(sortedNumeric, type, parents, toIter(children));
}
- // no sort optimization with points
- @Override
- protected PointValues getPointValues(LeafReaderContext context, String field) {
- return null;
- }
};
}
};
}
- private FieldComparator<?> getFloatComparator(int numHits, int sortPos) {
- return new FloatComparator(numHits, getField(), (Float) missingValue, getReverse(), sortPos) {
+ private FieldComparator<?> getFloatComparator(int numHits) {
+ return new FloatComparator(numHits, getField(), (Float) missingValue, getReverse(), false) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context) throws IOException {
return new FloatLeafComparator(context) {
@@ -238,20 +227,14 @@ public class ToParentBlockJoinSortField extends SortField {
}
};
}
- // no sort optimization with points
- @Override
- protected PointValues getPointValues(LeafReaderContext context, String field) {
- return null;
- }
};
}
;
};
}
- private FieldComparator<?> getDoubleComparator(int numHits, int sortPost) {
- return new DoubleComparator(
- numHits, getField(), (Double) missingValue, getReverse(), sortPost) {
+ private FieldComparator<?> getDoubleComparator(int numHits) {
+ return new DoubleComparator(numHits, getField(), (Double) missingValue, getReverse(), false) {
@Override
public LeafFieldComparator getLeafComparator(LeafReaderContext context) throws IOException {
return new DoubleLeafComparator(context) {
@@ -276,11 +259,6 @@ public class ToParentBlockJoinSortField extends SortField {
}
};
}
- // no sort optimization with points
- @Override
- protected PointValues getPointValues(LeafReaderContext context, String field) {
- return 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 8865838..1320f76 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
@@ -381,7 +381,7 @@ public abstract class ValueSource {
@Override
public FieldComparator<Double> newComparator(
- String fieldname, int numHits, int sortPos, boolean reversed) {
+ String fieldname, int numHits, boolean enableSkipping, boolean reversed) {
return new ValueSourceComparator(context, numHits);
}
}
diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/IndexSortSortedNumericDocValuesRangeQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/IndexSortSortedNumericDocValuesRangeQuery.java
index a43debd..829ed71 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/IndexSortSortedNumericDocValuesRangeQuery.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/IndexSortSortedNumericDocValuesRangeQuery.java
@@ -247,7 +247,8 @@ public class IndexSortSortedNumericDocValuesRangeQuery extends Query {
private static ValueComparator loadComparator(
SortField sortField, long topValue, LeafReaderContext context) throws IOException {
@SuppressWarnings("unchecked")
- FieldComparator<Long> fieldComparator = (FieldComparator<Long>) sortField.getComparator(1, 0);
+ FieldComparator<Long> fieldComparator =
+ (FieldComparator<Long>) sortField.getComparator(1, false);
fieldComparator.setTopValue(topValue);
LeafFieldComparator leafFieldComparator = fieldComparator.getLeafComparator(context);
diff --git a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointOutsideSortField.java b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointOutsideSortField.java
index c7605e3..8e75e80 100644
--- a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointOutsideSortField.java
+++ b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointOutsideSortField.java
@@ -41,7 +41,7 @@ final class Geo3DPointOutsideSortField extends SortField {
}
@Override
- public FieldComparator<?> getComparator(int numHits, int sortPos) {
+ public FieldComparator<?> getComparator(int numHits, boolean enableSkipping) {
return new Geo3DPointOutsideDistanceComparator(getField(), planetModel, distanceShape, numHits);
}
diff --git a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointSortField.java b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointSortField.java
index 0e5dba5..2b7c252 100644
--- a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointSortField.java
+++ b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/Geo3DPointSortField.java
@@ -41,7 +41,7 @@ final class Geo3DPointSortField extends SortField {
}
@Override
- public FieldComparator<?> getComparator(int numHits, int sortPos) {
+ public FieldComparator<?> getComparator(int numHits, boolean enableSkipping) {
return new Geo3DPointDistanceComparator(getField(), planetModel, distanceShape, numHits);
}