Skip to content

Apache Lucene open-source search software

Add SegmentOrder utility class for per-query segment re-ordering (#15591)

Alan Woodwardd455fefc6b63
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 1a4412743a4..1ede0b978bb 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -246,6 +246,8 @@ New Features
* GITHUB#15518: Add support for post-collection faceting to the new faceting API in the sandbox module. (Egor Potemkin)
+ * GITHUB#15591: Add SegmentOrder helper class to re-order segments at query time to align with sorts. (Alan Woodward)
+
Improvements
---------------------
* GITHUB#15148: Add support uint8 distance and allow 8 bit scalar quantization (Trevor McCulloch)
@@ -295,7 +297,7 @@ Optimizations
* GITHUB#15397: NumericComparator: immediately check whether a segment is competitive with the recorded bottom (Martijn van Groningen)
-# GITHUB#15303: Speed up NumericUtils#{add,subtract} by operating on integers instead of bytes. (Kaival Parikh)
+* GITHUB#15303: Speed up NumericUtils#{add,subtract} by operating on integers instead of bytes. (Kaival Parikh)
* GITHUB#15003: Avoid reconstructing HNSW graph during merging (Pulkit Gupta)
diff --git a/lucene/core/src/java/org/apache/lucene/index/SegmentOrder.java b/lucene/core/src/java/org/apache/lucene/index/SegmentOrder.java
new file mode 100644
index 00000000000..6f111cfbeeb
--- /dev/null
+++ b/lucene/core/src/java/org/apache/lucene/index/SegmentOrder.java
@@ -0,0 +1,182 @@
+/*
+ * 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.index;
+
+import java.io.IOException;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.ToLongFunction;
+import org.apache.lucene.search.Sort;
+import org.apache.lucene.search.SortField;
+import org.apache.lucene.search.SortedNumericSortField;
+import org.apache.lucene.util.NumericUtils;
+
+/** Utility class to re-order segments within an IndexReader to assist in early termination. */
+public abstract class SegmentOrder {
+
+ /** Produces a new view over an IndexReader by re-ordering the reader's segments */
+ public abstract IndexReader reorder(IndexReader reader) throws IOException;
+
+ /**
+ * Builds a SegmentSorter that will reorder segments based on a given numeric Sort, such that
+ * higher-sorting hits are more likely to be visited first, allowing early termination to more
+ * efficiently skip whole segments. If the primary SortField of the Sort is not numeric then the
+ * returned SegmentSorter will have no effect.
+ */
+ public static SegmentOrder fromSort(Sort sort) {
+ SortField primarySort = sort.getSort()[0];
+ Object missingValue = primarySort.getMissingValue();
+ SortField.Type type = primarySort.getType();
+ if (primarySort instanceof SortedNumericSortField snsf) {
+ type = snsf.getNumericType();
+ }
+ return switch (type) {
+ case INT ->
+ numericSorter(
+ primarySort.getField(),
+ missingValue == null ? null : ((Integer) missingValue).longValue(),
+ primarySort.getReverse(),
+ b -> NumericUtils.sortableBytesToInt(b, 0));
+ case LONG ->
+ numericSorter(
+ primarySort.getField(),
+ missingValue == null ? null : (Long) missingValue,
+ primarySort.getReverse(),
+ b -> NumericUtils.sortableBytesToLong(b, 0));
+ case FLOAT ->
+ numericSorter(
+ primarySort.getField(),
+ missingValue == null
+ ? null
+ : (long) NumericUtils.floatToSortableInt((float) missingValue),
+ primarySort.getReverse(),
+ b -> NumericUtils.sortableBytesToInt(b, 0));
+ case DOUBLE ->
+ numericSorter(
+ primarySort.getField(),
+ missingValue == null
+ ? null
+ : NumericUtils.doubleToSortableLong((double) missingValue),
+ primarySort.getReverse(),
+ b -> NumericUtils.sortableBytesToLong(b, 0));
+ // $CASES-OMITTED$
+ default ->
+ new SegmentOrder() {
+ @Override
+ public IndexReader reorder(IndexReader reader) {
+ return reader;
+ }
+ };
+ };
+ }
+
+ private static SegmentOrder numericSorter(
+ String field, Long missingValue, boolean reverse, ToLongFunction<byte[]> pointDecoder) {
+ NumericFieldReaderContextComparator comparator =
+ new NumericFieldReaderContextComparator(field, missingValue, reverse, pointDecoder);
+ return new SegmentOrder() {
+ @Override
+ public IndexReader reorder(IndexReader reader) throws IOException {
+ return new BaseCompositeReader<>(
+ reader.leaves().stream().map(LeafReaderContext::reader).toArray(LeafReader[]::new),
+ comparator) {
+ @Override
+ protected void doClose() {
+ // no op
+ }
+
+ @Override
+ public CacheHelper getReaderCacheHelper() {
+ return reader.getReaderCacheHelper();
+ }
+ };
+ }
+ };
+ }
+
+ private static class NumericFieldReaderContextComparator implements Comparator<LeafReader> {
+
+ private final Map<Object, Long> cachedSortValues = new HashMap<>();
+ private final String field;
+ private final boolean reverse;
+ private final Long missingValue;
+ private final ToLongFunction<byte[]> pointDecoder;
+
+ NumericFieldReaderContextComparator(
+ String field, Long missingValue, boolean reverse, ToLongFunction<byte[]> pointDecoder) {
+ this.field = field;
+ this.missingValue = missingValue;
+ this.reverse = reverse;
+ this.pointDecoder = pointDecoder;
+ }
+
+ @Override
+ public int compare(LeafReader o1, LeafReader o2) {
+ return reverse
+ ? Long.compare(getSortValue(o2), getSortValue(o1))
+ : Long.compare(getSortValue(o1), getSortValue(o2));
+ }
+
+ private long getSortValue(LeafReader reader) {
+ IndexReader.CacheKey key = reader.getCoreCacheHelper().getKey();
+ if (cachedSortValues.containsKey(key) == false) {
+ cachedSortValues.put(key, loadSortValue(reader));
+ }
+ return cachedSortValues.get(key);
+ }
+
+ private long loadSortValue(LeafReader reader) {
+ try {
+ DocValuesSkipper skipper = reader.getDocValuesSkipper(field);
+ if (skipper != null) {
+ if (skipper.docCount() == reader.maxDoc() || missingValue == null) {
+ return reverse ? skipper.maxValue() : skipper.minValue();
+ }
+ if (reverse) {
+ return Math.max(skipper.maxValue(), missingValue);
+ } else {
+ return Math.min(skipper.minValue(), missingValue);
+ }
+ }
+ PointValues pointValues = reader.getPointValues(field);
+ if (pointValues != null) {
+ if (pointValues.getDocCount() == reader.maxDoc() || missingValue == null) {
+ if (reverse) {
+ return pointDecoder.applyAsLong(pointValues.getMaxPackedValue());
+ } else {
+ return pointDecoder.applyAsLong(pointValues.getMinPackedValue());
+ }
+ }
+ if (reverse) {
+ return Math.max(
+ pointDecoder.applyAsLong(pointValues.getMaxPackedValue()), missingValue);
+ } else {
+ return Math.min(
+ pointDecoder.applyAsLong(pointValues.getMinPackedValue()), missingValue);
+ }
+ }
+ } catch (IOException _) {
+ // We can't rethrow exceptions from inside a Comparator, so we instead
+ // return as if there are no index structures to read values from.
+ return reverse ? Long.MAX_VALUE : Long.MIN_VALUE;
+ }
+ return reverse ? Long.MAX_VALUE : Long.MIN_VALUE;
+ }
+ }
+}
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSegmentReordering.java b/lucene/core/src/test/org/apache/lucene/search/TestSegmentReordering.java
new file mode 100644
index 00000000000..1065919b92e
--- /dev/null
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSegmentReordering.java
@@ -0,0 +1,389 @@
+/*
+ * 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.search;
+
+import java.io.IOException;
+import java.util.List;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.DoubleField;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.FloatField;
+import org.apache.lucene.document.IntField;
+import org.apache.lucene.document.LongField;
+import org.apache.lucene.document.NumericDocValuesField;
+import org.apache.lucene.document.SortedNumericDocValuesField;
+import org.apache.lucene.document.StringField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.NoMergePolicy;
+import org.apache.lucene.index.SegmentOrder;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.tests.util.LuceneTestCase;
+import org.apache.lucene.util.NumericUtils;
+
+public class TestSegmentReordering extends LuceneTestCase {
+
+ public void testSingleValuedNumericSorts() throws Exception {
+
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig().setMergePolicy(NoMergePolicy.INSTANCE);
+ IndexWriter writer = new IndexWriter(dir, iwc);
+
+ for (int i = 0; i < 500; i++) {
+ Document doc = new Document();
+ doc.add(new LongField("long_points", i, Field.Store.NO));
+ doc.add(NumericDocValuesField.indexedField("long_skipper", i));
+ doc.add(new DoubleField("double_points", i * 1.5, Field.Store.NO));
+ doc.add(
+ NumericDocValuesField.indexedField(
+ "double_skipper", NumericUtils.doubleToSortableLong(i * 1.5)));
+ doc.add(new IntField("int_points", i, Field.Store.NO));
+ doc.add(NumericDocValuesField.indexedField("int_skipper", i));
+ doc.add(new FloatField("float_points", i * 1.5f, Field.Store.NO));
+ doc.add(
+ NumericDocValuesField.indexedField(
+ "float_skipper", NumericUtils.floatToSortableInt(i * 1.5f)));
+ writer.addDocument(doc);
+ if (i % 125 == 0) {
+ writer.commit();
+ }
+ }
+ writer.close();
+
+ IndexReader reader = DirectoryReader.open(dir);
+
+ assertSegmentOrder(reader, sort("long_points", SortField.Type.LONG, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, sort("long_skipper", SortField.Type.LONG, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, sort("int_points", SortField.Type.INT, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, sort("int_skipper", SortField.Type.INT, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, sort("double_points", SortField.Type.DOUBLE, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, sort("double_skipper", SortField.Type.DOUBLE, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, sort("float_points", SortField.Type.FLOAT, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, sort("float_skipper", SortField.Type.FLOAT, true), 4, 3, 2, 1, 0);
+
+ assertSegmentOrder(reader, sort("long_points", SortField.Type.LONG, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, sort("long_skipper", SortField.Type.LONG, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, sort("int_points", SortField.Type.INT, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, sort("int_skipper", SortField.Type.INT, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, sort("double_points", SortField.Type.DOUBLE, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, sort("double_skipper", SortField.Type.DOUBLE, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, sort("float_points", SortField.Type.FLOAT, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, sort("float_skipper", SortField.Type.FLOAT, false), 0, 1, 2, 3, 4);
+
+ reader.close();
+ dir.close();
+ }
+
+ public void testMultiValuedSegmentSorts() throws Exception {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig().setMergePolicy(NoMergePolicy.INSTANCE);
+ IndexWriter writer = new IndexWriter(dir, iwc);
+
+ for (int i = 0; i < 1000; i += 2) {
+ Document doc = new Document();
+ doc.add(new LongField("long_points", i, Field.Store.NO));
+ doc.add(SortedNumericDocValuesField.indexedField("long_skipper", i));
+ doc.add(new LongField("long_points", i + 1, Field.Store.NO));
+ doc.add(SortedNumericDocValuesField.indexedField("long_skipper", i + 1));
+
+ doc.add(new DoubleField("double_points", i * 1.5, Field.Store.NO));
+ doc.add(
+ SortedNumericDocValuesField.indexedField(
+ "double_skipper", NumericUtils.doubleToSortableLong(i * 1.5)));
+ doc.add(new DoubleField("double_points", i * 1.5 + 1, Field.Store.NO));
+ doc.add(
+ SortedNumericDocValuesField.indexedField(
+ "double_skipper", NumericUtils.doubleToSortableLong(i * 1.5 + 1)));
+ doc.add(new IntField("int_points", i, Field.Store.NO));
+ doc.add(SortedNumericDocValuesField.indexedField("int_skipper", i));
+ doc.add(new IntField("int_points", i + 1, Field.Store.NO));
+ doc.add(SortedNumericDocValuesField.indexedField("int_skipper", i + 1));
+
+ doc.add(new FloatField("float_points", i * 1.5f, Field.Store.NO));
+ doc.add(
+ SortedNumericDocValuesField.indexedField(
+ "float_skipper", NumericUtils.floatToSortableInt(i * 1.5f)));
+ doc.add(new FloatField("float_points", i * 1.5f + 1, Field.Store.NO));
+ doc.add(
+ SortedNumericDocValuesField.indexedField(
+ "float_skipper", NumericUtils.floatToSortableInt(i * 1.5f + 1)));
+
+ writer.addDocument(doc);
+ if (i % 250 == 0) {
+ writer.commit();
+ }
+ }
+ writer.close();
+
+ IndexReader reader = DirectoryReader.open(dir);
+
+ assertSegmentOrder(reader, msort("long_points", SortField.Type.LONG, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, msort("long_skipper", SortField.Type.LONG, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, msort("int_points", SortField.Type.INT, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, msort("int_skipper", SortField.Type.INT, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, msort("double_points", SortField.Type.DOUBLE, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, msort("double_skipper", SortField.Type.DOUBLE, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, msort("float_points", SortField.Type.FLOAT, true), 4, 3, 2, 1, 0);
+ assertSegmentOrder(reader, msort("float_skipper", SortField.Type.FLOAT, true), 4, 3, 2, 1, 0);
+
+ assertSegmentOrder(reader, msort("long_points", SortField.Type.LONG, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, msort("long_skipper", SortField.Type.LONG, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, msort("int_points", SortField.Type.INT, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, msort("int_skipper", SortField.Type.INT, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, msort("double_points", SortField.Type.DOUBLE, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(
+ reader, msort("double_skipper", SortField.Type.DOUBLE, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, msort("float_points", SortField.Type.FLOAT, false), 0, 1, 2, 3, 4);
+ assertSegmentOrder(reader, msort("float_skipper", SortField.Type.FLOAT, false), 0, 1, 2, 3, 4);
+
+ reader.close();
+ dir.close();
+ }
+
+ private static Sort msort(String field, SortField.Type type, boolean reverse) {
+ return new Sort(new SortedNumericSortField(field, type, reverse));
+ }
+
+ private static Sort sort(String field, SortField.Type type, boolean reverse) {
+ return sort(field, type, reverse, null);
+ }
+
+ private static Sort sort(
+ String field, SortField.Type type, boolean reverse, Object missingValue) {
+ SortField sf = new SortField(field, type, reverse, missingValue);
+ return new Sort(sf);
+ }
+
+ public void testNumericSegmentSortsWithMissingValues() throws Exception {
+ Directory dir = newDirectory();
+ IndexWriterConfig iwc = new IndexWriterConfig().setMergePolicy(NoMergePolicy.INSTANCE);
+ IndexWriter writer = new IndexWriter(dir, iwc);
+ for (int i = 0; i < 500; i++) {
+ Document doc = new Document();
+ doc.add(new StringField("string", "foo", Field.Store.NO));
+ if (i != 200) {
+ doc.add(new LongField("long_points", i, Field.Store.NO));
+ doc.add(NumericDocValuesField.indexedField("long_skipper", i));
+ doc.add(new DoubleField("double_points", i * 1.5, Field.Store.NO));
+ doc.add(
+ NumericDocValuesField.indexedField(
+ "double_skipper", NumericUtils.doubleToSortableLong(i * 1.5)));
+ doc.add(new IntField("int_points", i, Field.Store.NO));
+ doc.add(NumericDocValuesField.indexedField("int_skipper", i));
+ doc.add(new FloatField("float_points", i * 1.5f, Field.Store.NO));
+ doc.add(
+ NumericDocValuesField.indexedField(
+ "float_skipper", NumericUtils.floatToSortableInt(i * 1.5f)));
+ }
+ writer.addDocument(doc);
+ if (i % 125 == 0) {
+ writer.commit();
+ }
+ }
+ writer.close();
+
+ IndexReader reader = DirectoryReader.open(dir);
+
+ assertSegmentOrder(
+ reader, sort("long_points", SortField.Type.LONG, true, Long.MAX_VALUE), 2, 4, 3, 1, 0);
+ assertSegmentOrder(
+ reader, sort("long_points", SortField.Type.LONG, false, Long.MAX_VALUE), 0, 1, 2, 3, 4);
+ assertSegmentOrder(
+ reader, sort("long_points", SortField.Type.LONG, true, Long.MIN_VALUE), 4, 3, 2, 1, 0);
+ assertSegmentOrder(
+ reader, sort("long_points", SortField.Type.LONG, false, Long.MIN_VALUE), 2, 0, 1, 3, 4);
+
+ assertSegmentOrder(
+ reader, sort("long_skipper", SortField.Type.LONG, true, Long.MAX_VALUE), 2, 4, 3, 1, 0);
+ assertSegmentOrder(
+ reader, sort("long_skipper", SortField.Type.LONG, false, Long.MAX_VALUE), 0, 1, 2, 3, 4);
+ assertSegmentOrder(
+ reader, sort("long_skipper", SortField.Type.LONG, true, Long.MIN_VALUE), 4, 3, 2, 1, 0);
+ assertSegmentOrder(
+ reader, sort("long_skipper", SortField.Type.LONG, false, Long.MIN_VALUE), 2, 0, 1, 3, 4);
+
+ assertSegmentOrder(
+ reader, sort("int_points", SortField.Type.INT, true, Integer.MAX_VALUE), 2, 4, 3, 1, 0);
+ assertSegmentOrder(
+ reader, sort("int_points", SortField.Type.INT, false, Integer.MAX_VALUE), 0, 1, 2, 3, 4);
+ assertSegmentOrder(
+ reader, sort("int_points", SortField.Type.INT, true, Integer.MIN_VALUE), 4, 3, 2, 1, 0);
+ assertSegmentOrder(
+ reader, sort("int_points", SortField.Type.INT, false, Integer.MIN_VALUE), 2, 0, 1, 3, 4);
+
+ assertSegmentOrder(
+ reader, sort("int_skipper", SortField.Type.INT, true, Integer.MAX_VALUE), 2, 4, 3, 1, 0);
+ assertSegmentOrder(
+ reader, sort("int_skipper", SortField.Type.INT, false, Integer.MAX_VALUE), 0, 1, 2, 3, 4);
+ assertSegmentOrder(
+ reader, sort("int_skipper", SortField.Type.INT, true, Integer.MIN_VALUE), 4, 3, 2, 1, 0);
+ assertSegmentOrder(
+ reader, sort("int_skipper", SortField.Type.INT, false, Integer.MIN_VALUE), 2, 0, 1, 3, 4);
+
+ assertSegmentOrder(
+ reader,
+ sort("double_points", SortField.Type.DOUBLE, true, Double.POSITIVE_INFINITY),
+ 2,
+ 4,
+ 3,
+ 1,
+ 0);
+ assertSegmentOrder(
+ reader,
+ sort("double_points", SortField.Type.DOUBLE, false, Double.POSITIVE_INFINITY),
+ 0,
+ 1,
+ 2,
+ 3,
+ 4);
+ assertSegmentOrder(
+ reader,
+ sort("double_points", SortField.Type.DOUBLE, true, Double.NEGATIVE_INFINITY),
+ 4,
+ 3,
+ 2,
+ 1,
+ 0);
+ assertSegmentOrder(
+ reader,
+ sort("double_points", SortField.Type.DOUBLE, false, Double.NEGATIVE_INFINITY),
+ 2,
+ 0,
+ 1,
+ 3,
+ 4);
+
+ assertSegmentOrder(
+ reader,
+ sort("double_skipper", SortField.Type.DOUBLE, true, Double.POSITIVE_INFINITY),
+ 2,
+ 4,
+ 3,
+ 1,
+ 0);
+ assertSegmentOrder(
+ reader,
+ sort("double_skipper", SortField.Type.DOUBLE, false, Double.POSITIVE_INFINITY),
+ 0,
+ 1,
+ 2,
+ 3,
+ 4);
+ assertSegmentOrder(
+ reader,
+ sort("double_skipper", SortField.Type.DOUBLE, true, Double.NEGATIVE_INFINITY),
+ 4,
+ 3,
+ 2,
+ 1,
+ 0);
+ assertSegmentOrder(
+ reader,
+ sort("double_skipper", SortField.Type.DOUBLE, false, Double.NEGATIVE_INFINITY),
+ 2,
+ 0,
+ 1,
+ 3,
+ 4);
+
+ assertSegmentOrder(
+ reader,
+ sort("float_points", SortField.Type.FLOAT, true, Float.POSITIVE_INFINITY),
+ 2,
+ 4,
+ 3,
+ 1,
+ 0);
+ assertSegmentOrder(
+ reader,
+ sort("float_points", SortField.Type.FLOAT, false, Float.POSITIVE_INFINITY),
+ 0,
+ 1,
+ 2,
+ 3,
+ 4);
+ assertSegmentOrder(
+ reader,
+ sort("float_points", SortField.Type.FLOAT, true, Float.NEGATIVE_INFINITY),
+ 4,
+ 3,
+ 2,
+ 1,
+ 0);
+ assertSegmentOrder(
+ reader,
+ sort("float_points", SortField.Type.FLOAT, false, Float.NEGATIVE_INFINITY),
+ 2,
+ 0,
+ 1,
+ 3,
+ 4);
+
+ assertSegmentOrder(
+ reader,
+ sort("float_skipper", SortField.Type.FLOAT, true, Float.POSITIVE_INFINITY),
+ 2,
+ 4,
+ 3,
+ 1,
+ 0);
+ assertSegmentOrder(
+ reader,
+ sort("float_skipper", SortField.Type.FLOAT, false, Float.POSITIVE_INFINITY),
+ 0,
+ 1,
+ 2,
+ 3,
+ 4);
+ assertSegmentOrder(
+ reader,
+ sort("float_skipper", SortField.Type.FLOAT, true, Float.NEGATIVE_INFINITY),
+ 4,
+ 3,
+ 2,
+ 1,
+ 0);
+ assertSegmentOrder(
+ reader,
+ sort("float_skipper", SortField.Type.FLOAT, false, Float.NEGATIVE_INFINITY),
+ 2,
+ 0,
+ 1,
+ 3,
+ 4);
+
+ reader.close();
+ dir.close();
+ }
+
+ private void assertSegmentOrder(IndexReader reader, Sort sort, int... expectedOrds)
+ throws IOException {
+
+ List<LeafReaderContext> leaves = reader.leaves();
+ assertEquals(expectedOrds.length, leaves.size());
+ IndexReader reorderedReader = SegmentOrder.fromSort(sort).reorder(reader);
+
+ List<LeafReaderContext> reorderedLeaves = reorderedReader.leaves();
+ for (int i = 0; i < expectedOrds.length; i++) {
+ assertEquals(reorderedLeaves.get(i).reader(), leaves.get(expectedOrds[i]).reader());
+ }
+ }
+}