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.txtindex 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.javanew file mode 100644index 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.javanew file mode 100644index 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());+ }+ }+}