mirror of https://github.com/apache/lucene.git
LUCENE-2504: small optimization to sort missing last comparators - use static inner classes
git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@997449 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Yonik Seeley
parent
76a9dc048c
commit
ff5a2942d3
|
|
@ -30,8 +30,6 @@ import java.io.IOException;
|
||||||
|
|
||||||
|
|
||||||
public class MissingStringLastComparatorSource extends FieldComparatorSource {
|
public class MissingStringLastComparatorSource extends FieldComparatorSource {
|
||||||
|
|
||||||
|
|
||||||
private final BytesRef missingValueProxy;
|
private final BytesRef missingValueProxy;
|
||||||
|
|
||||||
public MissingStringLastComparatorSource() {
|
public MissingStringLastComparatorSource() {
|
||||||
|
|
@ -56,30 +54,96 @@ public class MissingStringLastComparatorSource extends FieldComparatorSource {
|
||||||
|
|
||||||
// Copied from Lucene's TermOrdValComparator and modified since the Lucene version couldn't
|
// Copied from Lucene's TermOrdValComparator and modified since the Lucene version couldn't
|
||||||
// be extended.
|
// be extended.
|
||||||
class TermOrdValComparator_SML extends FieldComparator {
|
class TermOrdValComparator_SML extends FieldComparator {
|
||||||
private static final int NULL_ORD = Integer.MAX_VALUE;
|
private static final int NULL_ORD = Integer.MAX_VALUE;
|
||||||
|
|
||||||
private final int[] ords;
|
|
||||||
private final BytesRef[] values;
|
|
||||||
private final int[] readerGen;
|
|
||||||
|
|
||||||
private int currentReaderGen = -1;
|
private final int[] ords;
|
||||||
private FieldCache.DocTermsIndex termsIndex;
|
private final BytesRef[] values;
|
||||||
private final String field;
|
private final int[] readerGen;
|
||||||
|
|
||||||
private int bottomSlot = -1;
|
private FieldCache.DocTermsIndex termsIndex;
|
||||||
private int bottomOrd;
|
private final String field;
|
||||||
private boolean bottomSameReader;
|
|
||||||
private BytesRef bottomValue;
|
|
||||||
private final BytesRef tempBR = new BytesRef();
|
|
||||||
private final BytesRef NULL_VAL;
|
|
||||||
|
|
||||||
public TermOrdValComparator_SML(int numHits, String field, int sortPos, boolean reversed, BytesRef nullVal) {
|
private final BytesRef NULL_VAL;
|
||||||
ords = new int[numHits];
|
private PerSegmentComparator current;
|
||||||
values = new BytesRef[numHits];
|
|
||||||
readerGen = new int[numHits];
|
public TermOrdValComparator_SML(int numHits, String field, int sortPos, boolean reversed, BytesRef nullVal) {
|
||||||
this.field = field;
|
ords = new int[numHits];
|
||||||
this.NULL_VAL = nullVal;
|
values = new BytesRef[numHits];
|
||||||
|
readerGen = new int[numHits];
|
||||||
|
this.field = field;
|
||||||
|
this.NULL_VAL = nullVal;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int compare(int slot1, int slot2) {
|
||||||
|
throw new UnsupportedOperationException();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void setBottom(int slot) {
|
||||||
|
throw new UnsupportedOperationException();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int compareBottom(int doc) {
|
||||||
|
throw new UnsupportedOperationException();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void copy(int slot, int doc) {
|
||||||
|
throw new UnsupportedOperationException();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Comparable<?> value(int slot) {
|
||||||
|
throw new UnsupportedOperationException();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public FieldComparator setNextReader(IndexReader reader, int docBase) throws IOException {
|
||||||
|
return TermOrdValComparator_SML.createComparator(reader, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
// 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
|
||||||
|
private static abstract class PerSegmentComparator extends FieldComparator {
|
||||||
|
protected TermOrdValComparator_SML parent;
|
||||||
|
protected final int[] ords;
|
||||||
|
protected final BytesRef[] values;
|
||||||
|
protected final int[] readerGen;
|
||||||
|
|
||||||
|
protected int currentReaderGen = -1;
|
||||||
|
protected FieldCache.DocTermsIndex termsIndex;
|
||||||
|
|
||||||
|
protected int bottomSlot = -1;
|
||||||
|
protected int bottomOrd;
|
||||||
|
protected boolean bottomSameReader = false;
|
||||||
|
protected BytesRef bottomValue;
|
||||||
|
protected final BytesRef tempBR = new BytesRef();
|
||||||
|
|
||||||
|
|
||||||
|
public PerSegmentComparator(TermOrdValComparator_SML parent) {
|
||||||
|
this.parent = parent;
|
||||||
|
PerSegmentComparator previous = parent.current;
|
||||||
|
if (previous != null) {
|
||||||
|
currentReaderGen = previous.currentReaderGen;
|
||||||
|
bottomSlot = previous.bottomSlot;
|
||||||
|
bottomOrd = previous.bottomOrd;
|
||||||
|
bottomValue = previous.bottomValue;
|
||||||
|
}
|
||||||
|
ords = parent.ords;
|
||||||
|
values = parent.values;
|
||||||
|
readerGen = parent.readerGen;
|
||||||
|
termsIndex = parent.termsIndex;
|
||||||
|
currentReaderGen++;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public FieldComparator setNextReader(IndexReader reader, int docBase) throws IOException {
|
||||||
|
return TermOrdValComparator_SML.createComparator(reader, parent);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
|
|
@ -101,294 +165,6 @@ public class MissingStringLastComparatorSource extends FieldComparatorSource {
|
||||||
return val1.compareTo(val2);
|
return val1.compareTo(val2);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
|
||||||
public int compareBottom(int doc) {
|
|
||||||
throw new UnsupportedOperationException();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void copy(int slot, int doc) {
|
|
||||||
throw new UnsupportedOperationException();
|
|
||||||
}
|
|
||||||
|
|
||||||
// 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
|
|
||||||
private abstract class PerSegmentComparator extends FieldComparator {
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public FieldComparator setNextReader(IndexReader reader, int docBase) throws IOException {
|
|
||||||
return TermOrdValComparator_SML.this.setNextReader(reader, docBase);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public int compare(int slot1, int slot2) {
|
|
||||||
return TermOrdValComparator_SML.this.compare(slot1, slot2);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void setBottom(final int bottom) {
|
|
||||||
TermOrdValComparator_SML.this.setBottom(bottom);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public Comparable<?> value(int slot) {
|
|
||||||
return TermOrdValComparator_SML.this.value(slot);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Used per-segment when bit width of doc->ord is 8:
|
|
||||||
private final class ByteOrdComparator extends PerSegmentComparator {
|
|
||||||
private final byte[] readerOrds;
|
|
||||||
private final FieldCache.DocTermsIndex termsIndex;
|
|
||||||
private final int docBase;
|
|
||||||
|
|
||||||
public ByteOrdComparator(byte[] readerOrds, FieldCache.DocTermsIndex termsIndex, int docBase) {
|
|
||||||
this.readerOrds = readerOrds;
|
|
||||||
this.termsIndex = termsIndex;
|
|
||||||
this.docBase = docBase;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public int compareBottom(int doc) {
|
|
||||||
assert bottomSlot != -1;
|
|
||||||
int order = readerOrds[doc]&0xFF;
|
|
||||||
if (order == 0) order = NULL_ORD;
|
|
||||||
if (bottomSameReader) {
|
|
||||||
// ord is precisely comparable, even in the equal case
|
|
||||||
return bottomOrd - order;
|
|
||||||
} else {
|
|
||||||
// ord is only approx comparable: if they are not
|
|
||||||
// equal, we can use that; if they are equal, we
|
|
||||||
// must fallback to compare by value
|
|
||||||
final int cmp = bottomOrd - order;
|
|
||||||
if (cmp != 0) {
|
|
||||||
return cmp;
|
|
||||||
}
|
|
||||||
|
|
||||||
// take care of the case where both vals are null
|
|
||||||
if (order == NULL_ORD) return 0;
|
|
||||||
|
|
||||||
// and at this point we know that neither value is null, so safe to compare
|
|
||||||
termsIndex.lookup(order, tempBR);
|
|
||||||
return bottomValue.compareTo(tempBR);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void copy(int slot, int doc) {
|
|
||||||
int ord = readerOrds[doc]&0xFF;
|
|
||||||
if (ord == 0) {
|
|
||||||
ords[slot] = NULL_ORD;
|
|
||||||
values[slot] = null;
|
|
||||||
} else {
|
|
||||||
ords[slot] = ord;
|
|
||||||
assert ord > 0;
|
|
||||||
if (values[slot] == null) {
|
|
||||||
values[slot] = new BytesRef();
|
|
||||||
}
|
|
||||||
termsIndex.lookup(ord, values[slot]);
|
|
||||||
}
|
|
||||||
readerGen[slot] = currentReaderGen;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Used per-segment when bit width of doc->ord is 16:
|
|
||||||
private final class ShortOrdComparator extends PerSegmentComparator {
|
|
||||||
private final short[] readerOrds;
|
|
||||||
private final FieldCache.DocTermsIndex termsIndex;
|
|
||||||
private final int docBase;
|
|
||||||
|
|
||||||
public ShortOrdComparator(short[] readerOrds, FieldCache.DocTermsIndex termsIndex, int docBase) {
|
|
||||||
this.readerOrds = readerOrds;
|
|
||||||
this.termsIndex = termsIndex;
|
|
||||||
this.docBase = docBase;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public int compareBottom(int doc) {
|
|
||||||
assert bottomSlot != -1;
|
|
||||||
int order = readerOrds[doc]&0xFFFF;
|
|
||||||
if (order == 0) order = NULL_ORD;
|
|
||||||
if (bottomSameReader) {
|
|
||||||
// ord is precisely comparable, even in the equal case
|
|
||||||
return bottomOrd - order;
|
|
||||||
} else {
|
|
||||||
// ord is only approx comparable: if they are not
|
|
||||||
// equal, we can use that; if they are equal, we
|
|
||||||
// must fallback to compare by value
|
|
||||||
final int cmp = bottomOrd - order;
|
|
||||||
if (cmp != 0) {
|
|
||||||
return cmp;
|
|
||||||
}
|
|
||||||
|
|
||||||
// take care of the case where both vals are null
|
|
||||||
if (order == NULL_ORD) return 0;
|
|
||||||
|
|
||||||
// and at this point we know that neither value is null, so safe to compare
|
|
||||||
termsIndex.lookup(order, tempBR);
|
|
||||||
return bottomValue.compareTo(tempBR);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void copy(int slot, int doc) {
|
|
||||||
int ord = readerOrds[doc]&0xFFFF;
|
|
||||||
if (ord == 0) {
|
|
||||||
ords[slot] = NULL_ORD;
|
|
||||||
values[slot] = null;
|
|
||||||
} else {
|
|
||||||
ords[slot] = ord;
|
|
||||||
assert ord > 0;
|
|
||||||
if (values[slot] == null) {
|
|
||||||
values[slot] = new BytesRef();
|
|
||||||
}
|
|
||||||
termsIndex.lookup(ord, values[slot]);
|
|
||||||
}
|
|
||||||
readerGen[slot] = currentReaderGen;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Used per-segment when bit width of doc->ord is 32:
|
|
||||||
private final class IntOrdComparator extends PerSegmentComparator {
|
|
||||||
private final int[] readerOrds;
|
|
||||||
private final FieldCache.DocTermsIndex termsIndex;
|
|
||||||
private final int docBase;
|
|
||||||
|
|
||||||
public IntOrdComparator(int[] readerOrds, FieldCache.DocTermsIndex termsIndex, int docBase) {
|
|
||||||
this.readerOrds = readerOrds;
|
|
||||||
this.termsIndex = termsIndex;
|
|
||||||
this.docBase = docBase;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public int compareBottom(int doc) {
|
|
||||||
assert bottomSlot != -1;
|
|
||||||
int order = readerOrds[doc];
|
|
||||||
if (order == 0) order = NULL_ORD;
|
|
||||||
if (bottomSameReader) {
|
|
||||||
// ord is precisely comparable, even in the equal case
|
|
||||||
return bottomOrd - order;
|
|
||||||
} else {
|
|
||||||
// ord is only approx comparable: if they are not
|
|
||||||
// equal, we can use that; if they are equal, we
|
|
||||||
// must fallback to compare by value
|
|
||||||
final int cmp = bottomOrd - order;
|
|
||||||
if (cmp != 0) {
|
|
||||||
return cmp;
|
|
||||||
}
|
|
||||||
|
|
||||||
// take care of the case where both vals are null
|
|
||||||
if (order == NULL_ORD) return 0;
|
|
||||||
|
|
||||||
// and at this point we know that neither value is null, so safe to compare
|
|
||||||
termsIndex.lookup(order, tempBR);
|
|
||||||
return bottomValue.compareTo(tempBR);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void copy(int slot, int doc) {
|
|
||||||
int ord = readerOrds[doc];
|
|
||||||
if (ord == 0) {
|
|
||||||
ords[slot] = NULL_ORD;
|
|
||||||
values[slot] = null;
|
|
||||||
} else {
|
|
||||||
ords[slot] = ord;
|
|
||||||
assert ord > 0;
|
|
||||||
if (values[slot] == null) {
|
|
||||||
values[slot] = new BytesRef();
|
|
||||||
}
|
|
||||||
termsIndex.lookup(ord, values[slot]);
|
|
||||||
}
|
|
||||||
readerGen[slot] = currentReaderGen;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Used per-segment when bit width is not a native array
|
|
||||||
// size (8, 16, 32):
|
|
||||||
private final class AnyOrdComparator extends PerSegmentComparator {
|
|
||||||
private final PackedInts.Reader readerOrds;
|
|
||||||
private final FieldCache.DocTermsIndex termsIndex;
|
|
||||||
private final int docBase;
|
|
||||||
|
|
||||||
public AnyOrdComparator(PackedInts.Reader readerOrds, FieldCache.DocTermsIndex termsIndex, int docBase) {
|
|
||||||
this.readerOrds = readerOrds;
|
|
||||||
this.termsIndex = termsIndex;
|
|
||||||
this.docBase = docBase;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public int compareBottom(int doc) {
|
|
||||||
assert bottomSlot != -1;
|
|
||||||
int order = (int) readerOrds.get(doc);
|
|
||||||
if (order == 0) order = NULL_ORD;
|
|
||||||
if (bottomSameReader) {
|
|
||||||
// ord is precisely comparable, even in the equal case
|
|
||||||
return bottomOrd - order;
|
|
||||||
} else {
|
|
||||||
// ord is only approx comparable: if they are not
|
|
||||||
// equal, we can use that; if they are equal, we
|
|
||||||
// must fallback to compare by value
|
|
||||||
final int cmp = bottomOrd - order;
|
|
||||||
if (cmp != 0) {
|
|
||||||
return cmp;
|
|
||||||
}
|
|
||||||
|
|
||||||
// take care of the case where both vals are null
|
|
||||||
if (order == NULL_ORD) return 0;
|
|
||||||
|
|
||||||
// and at this point we know that neither value is null, so safe to compare
|
|
||||||
termsIndex.lookup(order, tempBR);
|
|
||||||
return bottomValue.compareTo(tempBR);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void copy(int slot, int doc) {
|
|
||||||
int ord = (int) readerOrds.get(doc);
|
|
||||||
if (ord == 0) {
|
|
||||||
ords[slot] = NULL_ORD;
|
|
||||||
values[slot] = null;
|
|
||||||
} else {
|
|
||||||
ords[slot] = ord;
|
|
||||||
assert ord > 0;
|
|
||||||
if (values[slot] == null) {
|
|
||||||
values[slot] = new BytesRef();
|
|
||||||
}
|
|
||||||
termsIndex.lookup(ord, values[slot]);
|
|
||||||
}
|
|
||||||
readerGen[slot] = currentReaderGen;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public FieldComparator setNextReader(IndexReader reader, int docBase) throws IOException {
|
|
||||||
termsIndex = FieldCache.DEFAULT.getTermsIndex(reader, field);
|
|
||||||
final PackedInts.Reader docToOrd = termsIndex.getDocToOrd();
|
|
||||||
FieldComparator perSegComp;
|
|
||||||
if (docToOrd instanceof Direct8) {
|
|
||||||
perSegComp = new ByteOrdComparator(((Direct8) docToOrd).getArray(), termsIndex, docBase);
|
|
||||||
} else if (docToOrd instanceof Direct16) {
|
|
||||||
perSegComp = new ShortOrdComparator(((Direct16) docToOrd).getArray(), termsIndex, docBase);
|
|
||||||
} else if (docToOrd instanceof Direct32) {
|
|
||||||
perSegComp = new IntOrdComparator(((Direct32) docToOrd).getArray(), termsIndex, docBase);
|
|
||||||
} else {
|
|
||||||
perSegComp = new AnyOrdComparator(docToOrd, termsIndex, docBase);
|
|
||||||
}
|
|
||||||
|
|
||||||
currentReaderGen++;
|
|
||||||
if (bottomSlot != -1) {
|
|
||||||
perSegComp.setBottom(bottomSlot);
|
|
||||||
}
|
|
||||||
|
|
||||||
return perSegComp;
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void setBottom(final int bottom) {
|
public void setBottom(final int bottom) {
|
||||||
bottomSlot = bottom;
|
bottomSlot = bottom;
|
||||||
|
|
@ -423,6 +199,244 @@ public class MissingStringLastComparatorSource extends FieldComparatorSource {
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public Comparable<?> value(int slot) {
|
public Comparable<?> value(int slot) {
|
||||||
return values==null ? NULL_VAL : values[slot];
|
return values==null ? parent.NULL_VAL : values[slot];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Used per-segment when bit width of doc->ord is 8:
|
||||||
|
private static final class ByteOrdComparator extends PerSegmentComparator {
|
||||||
|
private final byte[] readerOrds;
|
||||||
|
|
||||||
|
public ByteOrdComparator(byte[] readerOrds, TermOrdValComparator_SML parent) {
|
||||||
|
super(parent);
|
||||||
|
this.readerOrds = readerOrds;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int compareBottom(int doc) {
|
||||||
|
assert bottomSlot != -1;
|
||||||
|
int order = readerOrds[doc]&0xFF;
|
||||||
|
if (order == 0) order = NULL_ORD;
|
||||||
|
if (bottomSameReader) {
|
||||||
|
// ord is precisely comparable, even in the equal case
|
||||||
|
return bottomOrd - order;
|
||||||
|
} else {
|
||||||
|
// ord is only approx comparable: if they are not
|
||||||
|
// equal, we can use that; if they are equal, we
|
||||||
|
// must fallback to compare by value
|
||||||
|
final int cmp = bottomOrd - order;
|
||||||
|
if (cmp != 0) {
|
||||||
|
return cmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
// take care of the case where both vals are null
|
||||||
|
if (order == NULL_ORD) return 0;
|
||||||
|
|
||||||
|
// and at this point we know that neither value is null, so safe to compare
|
||||||
|
termsIndex.lookup(order, tempBR);
|
||||||
|
return bottomValue.compareTo(tempBR);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void copy(int slot, int doc) {
|
||||||
|
int ord = readerOrds[doc]&0xFF;
|
||||||
|
if (ord == 0) {
|
||||||
|
ords[slot] = NULL_ORD;
|
||||||
|
values[slot] = null;
|
||||||
|
} else {
|
||||||
|
ords[slot] = ord;
|
||||||
|
assert ord > 0;
|
||||||
|
if (values[slot] == null) {
|
||||||
|
values[slot] = new BytesRef();
|
||||||
|
}
|
||||||
|
termsIndex.lookup(ord, values[slot]);
|
||||||
|
}
|
||||||
|
readerGen[slot] = currentReaderGen;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Used per-segment when bit width of doc->ord is 16:
|
||||||
|
private static final class ShortOrdComparator extends PerSegmentComparator {
|
||||||
|
private final short[] readerOrds;
|
||||||
|
|
||||||
|
public ShortOrdComparator(short[] readerOrds, TermOrdValComparator_SML parent) {
|
||||||
|
super(parent);
|
||||||
|
this.readerOrds = readerOrds;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int compareBottom(int doc) {
|
||||||
|
assert bottomSlot != -1;
|
||||||
|
int order = readerOrds[doc]&0xFFFF;
|
||||||
|
if (order == 0) order = NULL_ORD;
|
||||||
|
if (bottomSameReader) {
|
||||||
|
// ord is precisely comparable, even in the equal case
|
||||||
|
return bottomOrd - order;
|
||||||
|
} else {
|
||||||
|
// ord is only approx comparable: if they are not
|
||||||
|
// equal, we can use that; if they are equal, we
|
||||||
|
// must fallback to compare by value
|
||||||
|
final int cmp = bottomOrd - order;
|
||||||
|
if (cmp != 0) {
|
||||||
|
return cmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
// take care of the case where both vals are null
|
||||||
|
if (order == NULL_ORD) return 0;
|
||||||
|
|
||||||
|
// and at this point we know that neither value is null, so safe to compare
|
||||||
|
termsIndex.lookup(order, tempBR);
|
||||||
|
return bottomValue.compareTo(tempBR);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void copy(int slot, int doc) {
|
||||||
|
int ord = readerOrds[doc]&0xFFFF;
|
||||||
|
if (ord == 0) {
|
||||||
|
ords[slot] = NULL_ORD;
|
||||||
|
values[slot] = null;
|
||||||
|
} else {
|
||||||
|
ords[slot] = ord;
|
||||||
|
assert ord > 0;
|
||||||
|
if (values[slot] == null) {
|
||||||
|
values[slot] = new BytesRef();
|
||||||
|
}
|
||||||
|
termsIndex.lookup(ord, values[slot]);
|
||||||
|
}
|
||||||
|
readerGen[slot] = currentReaderGen;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Used per-segment when bit width of doc->ord is 32:
|
||||||
|
private static final class IntOrdComparator extends PerSegmentComparator {
|
||||||
|
private final int[] readerOrds;
|
||||||
|
|
||||||
|
public IntOrdComparator(int[] readerOrds, TermOrdValComparator_SML parent) {
|
||||||
|
super(parent);
|
||||||
|
this.readerOrds = readerOrds;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int compareBottom(int doc) {
|
||||||
|
assert bottomSlot != -1;
|
||||||
|
int order = readerOrds[doc];
|
||||||
|
if (order == 0) order = NULL_ORD;
|
||||||
|
if (bottomSameReader) {
|
||||||
|
// ord is precisely comparable, even in the equal case
|
||||||
|
return bottomOrd - order;
|
||||||
|
} else {
|
||||||
|
// ord is only approx comparable: if they are not
|
||||||
|
// equal, we can use that; if they are equal, we
|
||||||
|
// must fallback to compare by value
|
||||||
|
final int cmp = bottomOrd - order;
|
||||||
|
if (cmp != 0) {
|
||||||
|
return cmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
// take care of the case where both vals are null
|
||||||
|
if (order == NULL_ORD) return 0;
|
||||||
|
|
||||||
|
// and at this point we know that neither value is null, so safe to compare
|
||||||
|
termsIndex.lookup(order, tempBR);
|
||||||
|
return bottomValue.compareTo(tempBR);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void copy(int slot, int doc) {
|
||||||
|
int ord = readerOrds[doc];
|
||||||
|
if (ord == 0) {
|
||||||
|
ords[slot] = NULL_ORD;
|
||||||
|
values[slot] = null;
|
||||||
|
} else {
|
||||||
|
ords[slot] = ord;
|
||||||
|
assert ord > 0;
|
||||||
|
if (values[slot] == null) {
|
||||||
|
values[slot] = new BytesRef();
|
||||||
|
}
|
||||||
|
termsIndex.lookup(ord, values[slot]);
|
||||||
|
}
|
||||||
|
readerGen[slot] = currentReaderGen;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Used per-segment when bit width is not a native array
|
||||||
|
// size (8, 16, 32):
|
||||||
|
private static final class AnyOrdComparator extends PerSegmentComparator {
|
||||||
|
private final PackedInts.Reader readerOrds;
|
||||||
|
|
||||||
|
public AnyOrdComparator(PackedInts.Reader readerOrds, TermOrdValComparator_SML parent) {
|
||||||
|
super(parent);
|
||||||
|
this.readerOrds = readerOrds;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int compareBottom(int doc) {
|
||||||
|
assert bottomSlot != -1;
|
||||||
|
int order = (int) readerOrds.get(doc);
|
||||||
|
if (order == 0) order = NULL_ORD;
|
||||||
|
if (bottomSameReader) {
|
||||||
|
// ord is precisely comparable, even in the equal case
|
||||||
|
return bottomOrd - order;
|
||||||
|
} else {
|
||||||
|
// ord is only approx comparable: if they are not
|
||||||
|
// equal, we can use that; if they are equal, we
|
||||||
|
// must fallback to compare by value
|
||||||
|
final int cmp = bottomOrd - order;
|
||||||
|
if (cmp != 0) {
|
||||||
|
return cmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
// take care of the case where both vals are null
|
||||||
|
if (order == NULL_ORD) return 0;
|
||||||
|
|
||||||
|
// and at this point we know that neither value is null, so safe to compare
|
||||||
|
termsIndex.lookup(order, tempBR);
|
||||||
|
return bottomValue.compareTo(tempBR);
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void copy(int slot, int doc) {
|
||||||
|
int ord = (int) readerOrds.get(doc);
|
||||||
|
if (ord == 0) {
|
||||||
|
ords[slot] = NULL_ORD;
|
||||||
|
values[slot] = null;
|
||||||
|
} else {
|
||||||
|
ords[slot] = ord;
|
||||||
|
assert ord > 0;
|
||||||
|
if (values[slot] == null) {
|
||||||
|
values[slot] = new BytesRef();
|
||||||
|
}
|
||||||
|
termsIndex.lookup(ord, values[slot]);
|
||||||
|
}
|
||||||
|
readerGen[slot] = currentReaderGen;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public static FieldComparator createComparator(IndexReader reader, TermOrdValComparator_SML parent) throws IOException {
|
||||||
|
parent.termsIndex = FieldCache.DEFAULT.getTermsIndex(reader, parent.field);
|
||||||
|
final PackedInts.Reader docToOrd = parent.termsIndex.getDocToOrd();
|
||||||
|
PerSegmentComparator perSegComp;
|
||||||
|
|
||||||
|
if (docToOrd instanceof Direct8) {
|
||||||
|
perSegComp = new ByteOrdComparator(((Direct8) docToOrd).getArray(), parent);
|
||||||
|
} else if (docToOrd instanceof Direct16) {
|
||||||
|
perSegComp = new ShortOrdComparator(((Direct16) docToOrd).getArray(), parent);
|
||||||
|
} else if (docToOrd instanceof Direct32) {
|
||||||
|
perSegComp = new IntOrdComparator(((Direct32) docToOrd).getArray(), parent);
|
||||||
|
} else {
|
||||||
|
perSegComp = new AnyOrdComparator(docToOrd, parent);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (perSegComp.bottomSlot != -1) {
|
||||||
|
perSegComp.setBottom(perSegComp.bottomSlot);
|
||||||
|
}
|
||||||
|
|
||||||
|
parent.current = perSegComp;
|
||||||
|
return perSegComp;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue