{@link #compareBottom} Compare a new hit (docID)
* against the "weakest" (bottom) entry in the queue.
*
+ *
{@link #setTopValue} This method is called by
+ * {@link TopFieldCollector} to notify the
+ * FieldComparator of the top most value, which is
+ * used by future calls to {@link #compareTop}.
+ *
+ *
{@link #compareBottom} Compare a new hit (docID)
+ * against the "weakest" (bottom) entry in the queue.
+ *
+ *
{@link #compareTop} Compare a new hit (docID)
+ * against the top value previously set by a call to
+ * {@link #setTopValue}.
+ *
*
{@link #copy} Installs a new hit into the
* priority queue. The {@link FieldValueHitQueue}
* calls this method when a new hit is competitive.
@@ -104,7 +116,15 @@
public abstract void setBottom(final int slot);
/**
- * Compare the bottom of the queue with doc. This will
+ * Record the top value, for future calls to {@link
+ * #compareTop}. This is only called for searches that
+ * use searchAfter (deep paging), and is called before any
+ * calls to {@link #setNextReader}.
+ */
+ public abstract void setTopValue(Object value);
+
+ /**
+ * Compare the bottom of the queue with this doc. This will
* only invoked after setBottom has been called. This
* should return the same result as {@link
* #compare(int,int)}} as if bottom were slot1 and the new
@@ -123,6 +143,22 @@
public abstract int compareBottom(int doc) throws IOException;
/**
+ * Compare the top value with this doc. This will
+ * only invoked after setTopValue has been called. This
+ * should return the same result as {@link
+ * #compare(int,int)}} as if topValue were slot1 and the new
+ * document were slot 2. This is only called for searches that
+ * use searchAfter (deep paging).
+ *
+ * @param doc that was hit
+ * @return any N < 0 if the doc's value is sorted after
+ * the bottom entry (not competitive), any N > 0 if the
+ * doc's value is sorted before the bottom entry and 0 if
+ * they are equal.
+ */
+ public abstract int compareTop(int doc) throws IOException;
+
+ /**
* This method is called when a new hit is competitive.
* You should copy any state associated with this document
* that will be required for future comparisons, into the
@@ -184,10 +220,6 @@
}
}
- /** Returns negative result if the doc's value is less
- * than the provided value. */
- public abstract int compareDocToValue(int doc, T value) throws IOException;
-
/**
* Base FieldComparator class for numeric types
*/
@@ -223,6 +255,7 @@
private final DoubleParser parser;
private FieldCache.Doubles currentReaderValues;
private double bottom;
+ private double topValue;
DoubleComparator(int numHits, String field, FieldCache.Parser parser, Double missingValue) {
super(field, missingValue);
@@ -273,20 +306,24 @@
}
@Override
+ public void setTopValue(Object value) {
+ topValue = (Double)value;
+ }
+
+ @Override
public Double value(int slot) {
return Double.valueOf(values[slot]);
}
@Override
- public int compareDocToValue(int doc, Double valueObj) {
- final double value = valueObj.doubleValue();
+ public int compareTop(int doc) {
double docValue = currentReaderValues.get(doc);
// Test for docValue == 0 to save Bits.get method call for
// the common case (doc has value and value is non-zero):
if (docsWithField != null && docValue == 0 && !docsWithField.get(doc)) {
docValue = missingValue;
}
- return Double.compare(docValue, value);
+ return Double.compare(topValue, docValue);
}
}
@@ -297,6 +334,7 @@
private final FloatParser parser;
private FieldCache.Floats currentReaderValues;
private float bottom;
+ private float topValue;
FloatComparator(int numHits, String field, FieldCache.Parser parser, Float missingValue) {
super(field, missingValue);
@@ -348,20 +386,24 @@
}
@Override
+ public void setTopValue(Object value) {
+ topValue = (Float)value;
+ }
+
+ @Override
public Float value(int slot) {
return Float.valueOf(values[slot]);
}
@Override
- public int compareDocToValue(int doc, Float valueObj) {
- final float value = valueObj.floatValue();
+ public int compareTop(int doc) {
float docValue = currentReaderValues.get(doc);
// Test for docValue == 0 to save Bits.get method call for
// the common case (doc has value and value is non-zero):
if (docsWithField != null && docValue == 0 && !docsWithField.get(doc)) {
docValue = missingValue;
}
- return Float.compare(docValue, value);
+ return Float.compare(topValue, docValue);
}
}
@@ -372,6 +414,7 @@
private final IntParser parser;
private FieldCache.Ints currentReaderValues;
private int bottom; // Value of bottom of queue
+ private int topValue;
IntComparator(int numHits, String field, FieldCache.Parser parser, Integer missingValue) {
super(field, missingValue);
@@ -422,20 +465,24 @@
}
@Override
+ public void setTopValue(Object value) {
+ topValue = (Integer)value;
+ }
+
+ @Override
public Integer value(int slot) {
return Integer.valueOf(values[slot]);
}
@Override
- public int compareDocToValue(int doc, Integer valueObj) {
- final int value = valueObj.intValue();
+ public int compareTop(int doc) {
int docValue = currentReaderValues.get(doc);
// Test for docValue == 0 to save Bits.get method call for
// the common case (doc has value and value is non-zero):
if (docsWithField != null && docValue == 0 && !docsWithField.get(doc)) {
docValue = missingValue;
}
- return Integer.compare(docValue, value);
+ return Integer.compare(topValue, docValue);
}
}
@@ -446,6 +493,7 @@
private final LongParser parser;
private FieldCache.Longs currentReaderValues;
private long bottom;
+ private long topValue;
LongComparator(int numHits, String field, FieldCache.Parser parser, Long missingValue) {
super(field, missingValue);
@@ -498,20 +546,24 @@
}
@Override
+ public void setTopValue(Object value) {
+ topValue = (Long)value;
+ }
+
+ @Override
public Long value(int slot) {
return Long.valueOf(values[slot]);
}
@Override
- public int compareDocToValue(int doc, Long valueObj) {
- final long value = valueObj.longValue();
+ public int compareTop(int doc) {
long docValue = currentReaderValues.get(doc);
// Test for docValue == 0 to save Bits.get method call for
// the common case (doc has value and value is non-zero):
if (docsWithField != null && docValue == 0 && !docsWithField.get(doc)) {
docValue = missingValue;
}
- return Long.compare(docValue, value);
+ return Long.compare(topValue, docValue);
}
}
@@ -525,7 +577,8 @@
private final float[] scores;
private float bottom;
private Scorer scorer;
-
+ private float topValue;
+
RelevanceComparator(int numHits) {
scores = new float[numHits];
}
@@ -559,6 +612,11 @@
}
@Override
+ public void setTopValue(Object value) {
+ topValue = (Float)value;
+ }
+
+ @Override
public void setScorer(Scorer scorer) {
// wrap with a ScoreCachingWrappingScorer so that successive calls to
// score() will not incur score computation over and
@@ -584,11 +642,10 @@
}
@Override
- public int compareDocToValue(int doc, Float valueObj) throws IOException {
- final float value = valueObj.floatValue();
+ public int compareTop(int doc) throws IOException {
float docValue = scorer.score();
assert !Float.isNaN(docValue);
- return Float.compare(value, docValue);
+ return Float.compare(docValue, topValue);
}
}
@@ -597,6 +654,7 @@
private final int[] docIDs;
private int docBase;
private int bottom;
+ private int topValue;
DocComparator(int numHits) {
docIDs = new int[numHits];
@@ -634,15 +692,19 @@
}
@Override
+ public void setTopValue(Object value) {
+ topValue = (Integer)value;
+ }
+
+ @Override
public Integer value(int slot) {
return Integer.valueOf(docIDs[slot]);
}
@Override
- public int compareDocToValue(int doc, Integer valueObj) {
- final int value = valueObj.intValue();
+ public int compareTop(int doc) {
int docValue = docBase + doc;
- return Integer.compare(docValue, value);
+ return Integer.compare(topValue, docValue);
}
}
@@ -700,13 +762,42 @@
@lucene.internal */
BytesRef bottomValue;
+ /** Set by setTopValue. */
+ BytesRef topValue;
+ boolean topSameReader;
+ int topOrd;
+
+ private int docBase;
+
final BytesRef tempBR = new BytesRef();
+ /** -1 if missing values are sorted first, 1 if they are
+ * sorted last */
+ final int missingSortCmp;
+
+ /** Which ordinal to use for a missing value. */
+ final int missingOrd;
+
+ /** Creates this, sorting missing values first. */
public TermOrdValComparator(int numHits, String field) {
+ this(numHits, field, false);
+ }
+
+ /** Creates this, with control over how missing values
+ * are sorted. Pass sortMissingLast=true to put
+ * missing values at the end. */
+ public TermOrdValComparator(int numHits, String field, boolean sortMissingLast) {
ords = new int[numHits];
values = new BytesRef[numHits];
readerGen = new int[numHits];
this.field = field;
+ if (sortMissingLast) {
+ missingSortCmp = 1;
+ missingOrd = Integer.MAX_VALUE;
+ } else {
+ missingSortCmp = -1;
+ missingOrd = -1;
+ }
}
@Override
@@ -721,140 +812,77 @@
if (val2 == null) {
return 0;
}
- return -1;
+ return missingSortCmp;
} else if (val2 == null) {
- return 1;
+ return -missingSortCmp;
}
return val1.compareTo(val2);
}
@Override
public int compareBottom(int doc) {
- throw new UnsupportedOperationException();
+ assert bottomSlot != -1;
+ int docOrd = termsIndex.getOrd(doc);
+ if (docOrd == -1) {
+ docOrd = missingOrd;
+ }
+ if (bottomSameReader) {
+ // ord is precisely comparable, even in the equal case
+ return bottomOrd - docOrd;
+ } else if (bottomOrd >= docOrd) {
+ // the equals case always means bottom is > doc
+ // (because we set bottomOrd to the lower bound in
+ // setBottom):
+ return 1;
+ } else {
+ return -1;
+ }
}
@Override
public void copy(int slot, int doc) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public int compareDocToValue(int doc, BytesRef value) {
int ord = termsIndex.getOrd(doc);
if (ord == -1) {
- if (value == null) {
- return 0;
+ ord = missingOrd;
+ values[slot] = null;
+ } else {
+ assert ord >= 0;
+ if (values[slot] == null) {
+ values[slot] = new BytesRef();
}
- return -1;
- } else if (value == null) {
- return 1;
+ termsIndex.lookupOrd(ord, values[slot]);
}
- termsIndex.lookupOrd(ord, tempBR);
- return tempBR.compareTo(value);
+ ords[slot] = ord;
+ readerGen[slot] = currentReaderGen;
}
+
+ @Override
+ public FieldComparator setNextReader(AtomicReaderContext context) throws IOException {
+ docBase = context.docBase;
+ termsIndex = FieldCache.DEFAULT.getTermsIndex(context.reader(), field);
+ currentReaderGen++;
- /** Base class for specialized (per bit width of the
- * ords) per-segment comparator. NOTE: this is messy;
- * we do this only because hotspot can't reliably inline
- * the underlying array access when looking up doc->ord
- * @lucene.internal
- */
- abstract class PerSegmentComparator extends FieldComparator {
-
- @Override
- public FieldComparator setNextReader(AtomicReaderContext context) throws IOException {
- return TermOrdValComparator.this.setNextReader(context);
- }
-
- @Override
- public int compare(int slot1, int slot2) {
- return TermOrdValComparator.this.compare(slot1, slot2);
- }
-
- @Override
- public void setBottom(final int bottom) {
- TermOrdValComparator.this.setBottom(bottom);
- }
-
- @Override
- public BytesRef value(int slot) {
- return TermOrdValComparator.this.value(slot);
- }
-
- @Override
- public int compareValues(BytesRef val1, BytesRef val2) {
- if (val1 == null) {
- if (val2 == null) {
- return 0;
- }
- return -1;
- } else if (val2 == null) {
- return 1;
- }
- return val1.compareTo(val2);
- }
-
- @Override
- public int compareDocToValue(int doc, BytesRef value) {
- return TermOrdValComparator.this.compareDocToValue(doc, value);
- }
- }
-
- // Used per-segment when docToOrd is null:
- private final class AnyOrdComparator extends PerSegmentComparator {
- private final SortedDocValues termsIndex;
- private final int docBase;
-
- public AnyOrdComparator(SortedDocValues termsIndex, int docBase) {
- this.termsIndex = termsIndex;
- this.docBase = docBase;
- }
-
- @Override
- public int compareBottom(int doc) {
- assert bottomSlot != -1;
- final int docOrd = termsIndex.getOrd(doc);
- if (bottomSameReader) {
- // ord is precisely comparable, even in the equal case
- return bottomOrd - docOrd;
- } else if (bottomOrd >= docOrd) {
- // the equals case always means bottom is > doc
- // (because we set bottomOrd to the lower bound in
- // setBottom):
- return 1;
+ if (topValue != null) {
+ // Recompute topOrd/SameReader
+ int ord = termsIndex.lookupTerm(topValue);
+ if (ord >= 0) {
+ topSameReader = true;
+ topOrd = ord;
} else {
- return -1;
+ topSameReader = false;
+ topOrd = -ord-2;
}
+ } else {
+ topOrd = missingOrd;
+ topSameReader = true;
}
- @Override
- public void copy(int slot, int doc) {
- final int ord = termsIndex.getOrd(doc);
- ords[slot] = ord;
- if (ord == -1) {
- values[slot] = null;
- } else {
- assert ord >= 0;
- if (values[slot] == null) {
- values[slot] = new BytesRef();
- }
- termsIndex.lookupOrd(ord, values[slot]);
- }
- readerGen[slot] = currentReaderGen;
- }
- }
-
- @Override
- public FieldComparator setNextReader(AtomicReaderContext context) throws IOException {
- final int docBase = context.docBase;
- termsIndex = FieldCache.DEFAULT.getTermsIndex(context.reader(), field);
- FieldComparator perSegComp = new AnyOrdComparator(termsIndex, docBase);
- currentReaderGen++;
if (bottomSlot != -1) {
- perSegComp.setBottom(bottomSlot);
+ // Recompute bottomOrd/SameReader
+ setBottom(bottomSlot);
}
- return perSegComp;
+ return this;
}
@Override
@@ -867,18 +895,18 @@
bottomSameReader = true;
} else {
if (bottomValue == null) {
- // -1 ord is null for all segments
- assert ords[bottomSlot] == -1;
- bottomOrd = -1;
+ // missingOrd is null for all segments
+ assert ords[bottomSlot] == missingOrd;
+ bottomOrd = missingOrd;
bottomSameReader = true;
readerGen[bottomSlot] = currentReaderGen;
} else {
- final int index = termsIndex.lookupTerm(bottomValue);
- if (index < 0) {
- bottomOrd = -index - 2;
+ final int ord = termsIndex.lookupTerm(bottomValue);
+ if (ord < 0) {
+ bottomOrd = -ord - 2;
bottomSameReader = false;
} else {
- bottomOrd = index;
+ bottomOrd = ord;
// exact value match
bottomSameReader = true;
readerGen[bottomSlot] = currentReaderGen;
@@ -889,27 +917,70 @@
}
@Override
+ public void setTopValue(Object value) {
+ // null is fine: it means the last doc of the prior
+ // search was missing this value
+ topValue = (BytesRef)value;
+ }
+
+ @Override
public BytesRef value(int slot) {
return values[slot];
}
+
+ @Override
+ public int compareTop(int doc) {
+
+ int ord = termsIndex.getOrd(doc);
+
+ if (topSameReader) {
+ // ord is precisely comparable, even in the equal case
+ return topOrd - ord;
+ } else if (ord <= topOrd) {
+ // the equals case always means doc is < value
+ // (because we set lastOrd to the lower bound)
+ return 1;
+ } else {
+ return -1;
+ }
+ }
+
+ @Override
+ public int compareValues(BytesRef val1, BytesRef val2) {
+ if (val1 == null) {
+ if (val2 == null) {
+ return 0;
+ }
+ return missingSortCmp;
+ } else if (val2 == null) {
+ return -missingSortCmp;
+ }
+ return val1.compareTo(val2);
+ }
}
- // just used internally in this comparator
- private static final byte[] MISSING_BYTES = new byte[0];
-
/** Sorts by field's natural Term sort order. All
* comparisons are done using BytesRef.compareTo, which is
* slow for medium to large result sets but possibly
* very fast for very small results sets. */
+ // TODO: should we remove this? who really uses it?
public static final class TermValComparator extends FieldComparator {
+ // sentinels, just used internally in this comparator
+ private static final byte[] MISSING_BYTES = new byte[0];
+ private static final byte[] NON_MISSING_BYTES = new byte[0];
+
private BytesRef[] values;
private BinaryDocValues docTerms;
private Bits docsWithField;
private final String field;
private BytesRef bottom;
+ private BytesRef topValue;
private final BytesRef tempBR = new BytesRef();
+ // TODO: add missing first/last support here?
+
+ /** Sole constructor. */
TermValComparator(int numHits, String field) {
values = new BytesRef[numHits];
this.field = field;
@@ -919,12 +990,12 @@
public int compare(int slot1, int slot2) {
final BytesRef val1 = values[slot1];
final BytesRef val2 = values[slot2];
- if (val1 == null) {
- if (val2 == null) {
+ if (val1.bytes == MISSING_BYTES) {
+ if (val2.bytes == MISSING_BYTES) {
return 0;
}
return -1;
- } else if (val2 == null) {
+ } else if (val2.bytes == MISSING_BYTES) {
return 1;
}
@@ -934,18 +1005,8 @@
@Override
public int compareBottom(int doc) {
docTerms.get(doc, tempBR);
- if (tempBR.length == 0 && docsWithField.get(doc) == false) {
- tempBR.bytes = MISSING_BYTES;
- }
- if (bottom.bytes == MISSING_BYTES) {
- if (tempBR.bytes == MISSING_BYTES) {
- return 0;
- }
- return -1;
- } else if (tempBR.bytes == MISSING_BYTES) {
- return 1;
- }
- return bottom.compareTo(tempBR);
+ setMissingBytes(doc, tempBR);
+ return compareValues(bottom, tempBR);
}
@Override
@@ -954,9 +1015,7 @@
values[slot] = new BytesRef();
}
docTerms.get(doc, values[slot]);
- if (values[slot].length == 0 && docsWithField.get(doc) == false) {
- values[slot].bytes = MISSING_BYTES;
- }
+ setMissingBytes(doc, values[slot]);
}
@Override
@@ -972,30 +1031,47 @@
}
@Override
+ public void setTopValue(Object value) {
+ if (value == null) {
+ throw new IllegalArgumentException("value cannot be null");
+ }
+ topValue = (BytesRef)value;
+ }
+
+ @Override
public BytesRef value(int slot) {
return values[slot];
}
@Override
public int compareValues(BytesRef val1, BytesRef val2) {
- if (val1 == null) {
- if (val2 == null) {
+ // missing always sorts first:
+ if (val1.bytes == MISSING_BYTES) {
+ if (val2.bytes == MISSING_BYTES) {
return 0;
}
return -1;
- } else if (val2 == null) {
+ } else if (val2.bytes == MISSING_BYTES) {
return 1;
}
return val1.compareTo(val2);
}
@Override
- public int compareDocToValue(int doc, BytesRef value) {
+ public int compareTop(int doc) {
docTerms.get(doc, tempBR);
- if (tempBR.length == 0 && docsWithField.get(doc) == false) {
- tempBR.bytes = MISSING_BYTES;
+ setMissingBytes(doc, tempBR);
+ return compareValues(topValue, tempBR);
+ }
+
+ private void setMissingBytes(int doc, BytesRef br) {
+ if (br.length == 0) {
+ if (docsWithField.get(doc) == false) {
+ br.bytes = MISSING_BYTES;
+ } else {
+ br.bytes = NON_MISSING_BYTES;
+ }
}
- return tempBR.compareTo(value);
}
}
}
Index: lucene/core/src/java/org/apache/lucene/search/FieldDoc.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/FieldDoc.java (revision 1558435)
+++ lucene/core/src/java/org/apache/lucene/search/FieldDoc.java (working copy)
@@ -17,6 +17,8 @@
* limitations under the License.
*/
+import java.util.Arrays;
+
/**
* Expert: A ScoreDoc which also contains information about
* how to sort the referenced document. In addition to the
@@ -69,14 +71,10 @@
@Override
public String toString() {
// super.toString returns the doc and score information, so just add the
- // fields information
+ // fields information
StringBuilder sb = new StringBuilder(super.toString());
- sb.append("[");
- for (int i = 0; i < fields.length; i++) {
- sb.append(fields[i]).append(", ");
- }
- sb.setLength(sb.length() - 2); // discard last ", "
- sb.append("]");
+ sb.append(" fields=");
+ sb.append(Arrays.toString(fields));
return sb.toString();
}
}
Index: lucene/core/src/java/org/apache/lucene/search/SortField.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/SortField.java (revision 1558435)
+++ lucene/core/src/java/org/apache/lucene/search/SortField.java (working copy)
@@ -106,6 +106,9 @@
// Used for 'sortMissingFirst/Last'
public Object missingValue = null;
+ // Only used with type=STRING
+ public boolean sortMissingLast;
+
/** Creates a sort by terms in the given field with the type of term
* values explicitly given.
* @param field Name of field to sort by. Can be null if
@@ -165,13 +168,24 @@
this.reverse = reverse;
this.parser = parser;
}
+
+ /** Pass this to {@link #setMissingValue} to have missing
+ * string values sort first. */
+ public final static Object STRING_FIRST = new Object();
- public SortField setMissingValue(Object missingValue) {
- if (type != Type.INT && type != Type.FLOAT && type != Type.LONG && type != Type.DOUBLE) {
- throw new IllegalArgumentException( "Missing value only works for numeric types" );
+ /** Pass this to {@link #setMissingValue} to have missing
+ * string values sort last. */
+ public final static Object STRING_LAST = new Object();
+
+ public void setMissingValue(Object missingValue) {
+ if (type == Type.STRING) {
+ if (missingValue != STRING_FIRST && missingValue != STRING_LAST) {
+ throw new IllegalArgumentException("For STRING type, missing value must be either STRING_FIRST or STRING_LAST");
+ }
+ } else if (type != Type.INT && type != Type.FLOAT && type != Type.LONG && type != Type.DOUBLE) {
+ throw new IllegalArgumentException("Missing value only works for numeric or STRING types");
}
this.missingValue = missingValue;
- return this;
}
/** Creates a sort with a custom comparison function.
@@ -376,9 +390,10 @@
return comparatorSource.newComparator(field, numHits, sortPos, reverse);
case STRING:
- return new FieldComparator.TermOrdValComparator(numHits, field);
+ return new FieldComparator.TermOrdValComparator(numHits, field, missingValue == STRING_LAST);
case STRING_VAL:
+ // TODO: should we remove this? who really uses it?
return new FieldComparator.TermValComparator(numHits, field);
case REWRITEABLE:
Index: lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java (revision 1558435)
+++ lucene/core/src/java/org/apache/lucene/search/TopFieldCollector.java (working copy)
@@ -869,6 +869,11 @@
// Must set maxScore to NEG_INF, or otherwise Math.max always returns NaN.
maxScore = Float.NEGATIVE_INFINITY;
+
+ // Tell all comparators their top value:
+ for(int i=0;i 0) {
- // Not yet collected
- sameValues = false;
- //System.out.println(" keep: after");
- break;
- }
- }
-
- // Tie-break by docID:
- if (sameValues && doc <= afterDoc) {
- // Already collected on a previous page
- //System.out.println(" skip: tie-break");
- return;
- }
-
- collectedHits++;
-
float score = Float.NaN;
if (trackMaxScore) {
score = scorer.score();
@@ -921,7 +896,8 @@
}
if (queueFull) {
- // Fastmatch: return if this hit is not competitive
+ // Fastmatch: return if this hit is no better than
+ // the worst hit currently in the queue:
for (int i = 0;; i++) {
final int c = reverseMul[i] * comparators[i].compareBottom(doc);
if (c < 0) {
@@ -939,7 +915,37 @@
break;
}
}
+ }
+ //System.out.println(" collect doc=" + doc);
+
+ // Check if this hit was already collected on a
+ // previous page:
+ boolean sameValues = true;
+ for(int compIDX=0;compIDX 0) {
+ // Already collected on a previous page
+ //System.out.println(" skip: before");
+ return;
+ } else if (cmp < 0) {
+ // Not yet collected
+ sameValues = false;
+ //System.out.println(" keep: after");
+ break;
+ }
+ }
+
+ // Tie-break by docID:
+ if (sameValues && doc <= afterDoc) {
+ // Already collected on a previous page
+ //System.out.println(" skip: tie-break");
+ return;
+ }
+
+ if (queueFull) {
// This hit is competitive - replace bottom element in queue & adjustTop
for (int i = 0; i < comparators.length; i++) {
comparators[i].copy(bottom.slot, doc);
@@ -955,6 +961,8 @@
comparators[i].setBottom(bottom.slot);
}
} else {
+ collectedHits++;
+
// Startup transient: queue hasn't gathered numHits yet
final int slot = collectedHits - 1;
//System.out.println(" slot=" + slot);
Index: lucene/core/src/java/org/apache/lucene/util/UnicodeUtil.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/util/UnicodeUtil.java (revision 1558435)
+++ lucene/core/src/java/org/apache/lucene/util/UnicodeUtil.java (working copy)
@@ -96,7 +96,7 @@
public final class UnicodeUtil {
/** A binary term consisting of a number of 0xff bytes, likely to be bigger than other terms
- * one would normally encounter, and definitely bigger than any UTF-8 terms.
+ * (e.g. collation keys) one would normally encounter, and definitely bigger than any UTF-8 terms.
*
* WARNING: This is not a valid UTF8 Term
**/
Index: lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java (revision 1558435)
+++ lucene/core/src/test/org/apache/lucene/search/JustCompileSearch.java (working copy)
@@ -146,6 +146,11 @@
}
@Override
+ public void setTopValue(Object value) {
+ throw new UnsupportedOperationException(UNSUPPORTED_MSG);
+ }
+
+ @Override
public FieldComparator