Apache Lucene open-source search software
MultiRange query for SortedNumeric DocValues (#14404)
Mikhail Khludnev2eeb71877da4
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex 6af1ca3c0eb..851006f9d58 100644--- a/lucene/CHANGES.txt+++ b/lucene/CHANGES.txt@@ -70,7 +70,8 @@ API ChangesNew Features----------------------(No changes)+* GITHUB#14404: Introducing DocValuesMultiRangeQuery.SortedNumericStabbingBuilder into sandbox.+ (Mikhail Khludnev)Improvements---------------------diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/DocValuesMultiRangeQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/DocValuesMultiRangeQuery.javaindex bc7b47f2b48..e00491e0aef 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/DocValuesMultiRangeQuery.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/DocValuesMultiRangeQuery.java@@ -19,6 +19,7 @@ package org.apache.lucene.sandbox.search;import java.util.ArrayList;import java.util.List;import java.util.Objects;+import org.apache.lucene.document.SortedNumericDocValuesField;import org.apache.lucene.document.SortedSetDocValuesField;import org.apache.lucene.search.*;import org.apache.lucene.util.BytesRef;@@ -72,6 +73,42 @@ public final class DocValuesMultiRangeQuery {}}+ /** Representation of a single clause in a MultiRangeQuery */+ public static class LongRange {+ protected long lower;+ protected long upper;++ /** copies ByteRefs passed */+ public LongRange(long lowerValue, long upperValue) {+ this.lower = lowerValue;+ this.upper = upperValue;+ }++ @Override+ public boolean equals(Object o) {+ if (this == o) {+ return true;+ }+ if (o == null || getClass() != o.getClass()) {+ return false;+ }+ LongRange that = (LongRange) o;+ return lower == that.lower && upper == that.upper;+ }++ @Override+ public int hashCode() {+ int result = (int) lower;+ result = (int) (31L * result + upper);+ return result;+ }++ @Override+ public String toString() {+ return lower + ".." + upper;+ }+ }+/*** Builder for creating a multi-range query for stabbing by SortedSet or Sorted field values. For* example, it matches IPs in docvalues field by multiple IP ranges. For the single range it@@ -114,4 +151,39 @@ public final class DocValuesMultiRangeQuery {return new SortedSetDocValuesMultiRangeQuery(fieldName, clauses);}}++ /**+ * Builder for creating a multi-range query for stabbing by SortedNumerics or Numerics field+ * values. For the single range it behaves like {@link+ * SortedNumericDocValuesField#newSlowRangeQuery(String, long, long)}+ */+ public static class SortedNumericStabbingBuilder {+ protected final String fieldName;+ protected final List<LongRange> clauses = new ArrayList<>();++ public SortedNumericStabbingBuilder(String fieldName) {+ this.fieldName = Objects.requireNonNull(fieldName);+ }++ public SortedNumericStabbingBuilder add(long lowerValue, long upperValue) {+ clauses.add(new LongRange(lowerValue, upperValue));+ return this;+ }++ public Query build() {+ if (clauses.isEmpty()) {+ return new MatchNoDocsQuery();+ }+ if (clauses.size() == 1) {+ LongRange theOnlyOne = clauses.getFirst();+ return SortedNumericDocValuesField.newSlowRangeQuery(+ fieldName, theOnlyOne.lower, theOnlyOne.upper);+ }+ return createSortedNumericDocValuesMultiRangeQuery();+ }++ protected Query createSortedNumericDocValuesMultiRangeQuery() {+ return new SortedNumericDocValuesMultiRangeQuery(fieldName, clauses);+ }+ }}diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/SortedNumericDocValuesMultiRangeQuery.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/SortedNumericDocValuesMultiRangeQuery.javanew file mode 100644index 00000000000..0412e594db7--- /dev/null+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/search/SortedNumericDocValuesMultiRangeQuery.java@@ -0,0 +1,274 @@+/*+ * 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.sandbox.search;++import java.io.IOException;+import java.util.Collection;+import java.util.Comparator;+import java.util.Iterator;+import java.util.List;+import java.util.NavigableSet;+import java.util.Objects;+import java.util.TreeSet;+import org.apache.lucene.index.DocValues;+import org.apache.lucene.index.DocValuesSkipper;+import org.apache.lucene.index.LeafReaderContext;+import org.apache.lucene.index.SortedNumericDocValues;+import org.apache.lucene.search.ConstantScoreScorerSupplier;+import org.apache.lucene.search.ConstantScoreWeight;+import org.apache.lucene.search.DocValuesRangeIterator;+import org.apache.lucene.search.IndexSearcher;+import org.apache.lucene.search.Query;+import org.apache.lucene.search.QueryVisitor;+import org.apache.lucene.search.ScoreMode;+import org.apache.lucene.search.ScorerSupplier;+import org.apache.lucene.search.TwoPhaseIterator;+import org.apache.lucene.search.Weight;+import org.apache.lucene.util.PriorityQueue;++/**+ * A union multiple ranges over SortedNumericDocValuesField+ *+ * @lucene.experimental+ */+public class SortedNumericDocValuesMultiRangeQuery extends Query {++ protected final String fieldName;+ protected final NavigableSet<DocValuesMultiRangeQuery.LongRange> sortedClauses;++ protected SortedNumericDocValuesMultiRangeQuery(+ String fieldName, List<DocValuesMultiRangeQuery.LongRange> clauses) {+ this.fieldName = fieldName;+ sortedClauses = resolveOverlaps(clauses);+ }++ private static final class Edge {+ private final DocValuesMultiRangeQuery.LongRange range;+ private final boolean point;+ private final boolean upper;++ private static Edge createPoint(DocValuesMultiRangeQuery.LongRange r) {+ return new Edge(r);+ }++ long getValue() {+ return upper ? range.upper : range.lower;+ }++ private Edge(DocValuesMultiRangeQuery.LongRange range, boolean upper) {+ this.range = range;+ this.upper = upper;+ this.point = false;+ }++ /** expecting Arrays.equals(lower.bytes,upper.bytes) i.e. point */+ private Edge(DocValuesMultiRangeQuery.LongRange range) {+ this.range = range;+ this.upper = false;+ this.point = true;+ }+ }++ /** Merges overlapping ranges. map.floor() doesn't work with overlaps */+ private static NavigableSet<DocValuesMultiRangeQuery.LongRange> resolveOverlaps(+ Collection<DocValuesMultiRangeQuery.LongRange> clauses) {+ NavigableSet<DocValuesMultiRangeQuery.LongRange> sortedClauses =+ new TreeSet<>(+ Comparator.comparing(r -> r.lower)+ // .thenComparing(r -> r.upper)// have to ignore upper boundary for .floor() lookups+ );+ PriorityQueue<Edge> heap =+ new PriorityQueue<>(clauses.size() * 2) {+ @Override+ protected boolean lessThan(Edge a, Edge b) {+ return a.getValue() - b.getValue() < 0;+ }+ };+ for (DocValuesMultiRangeQuery.LongRange r : clauses) {+ long cmp = r.lower - r.upper;+ if (cmp == 0) {+ heap.add(Edge.createPoint(r));+ } else {+ if (cmp < 0) {+ heap.add(new Edge(r, false));+ heap.add(new Edge(r, true));+ } // else drop reverse ranges+ }+ }+ int totalEdges = heap.size();+ int depth = 0;+ Edge started = null;+ for (int i = 0; i < totalEdges; i++) {+ Edge smallest = heap.pop();+ if (depth == 0 && smallest.point) {+ if (i < totalEdges - 1 && heap.top().point) { // repeating same points+ if (smallest.getValue() == heap.top().getValue()) {+ continue;+ }+ }+ sortedClauses.add(smallest.range);+ }+ if (!smallest.point) {+ if (!smallest.upper) {+ depth++;+ if (depth == 1) { // just started+ started = smallest;+ }+ } else {+ depth--;+ if (depth == 0) {+ sortedClauses.add(+ started.range == smallest.range // no overlap case, the most often+ ? smallest.range+ : new DocValuesMultiRangeQuery.LongRange(+ started.getValue(), smallest.getValue()));+ started = null;+ }+ }+ }+ }+ return sortedClauses;+ }++ @Override+ public String toString(String fld) {+ return (Objects.equals(fieldName, fld) ? "" : fieldName + ":") + sortedClauses;+ }++ @Override+ public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost)+ throws IOException {+ return new MultiRangeWeight(boost, scoreMode);+ }++ @Override+ public void visit(QueryVisitor visitor) {+ if (visitor.acceptField(fieldName)) {+ visitor.visitLeaf(this);+ }+ }++ @Override+ public boolean equals(Object o) {+ if (this == o) return true;+ if (o == null || getClass() != o.getClass()) return false;+ SortedNumericDocValuesMultiRangeQuery that = (SortedNumericDocValuesMultiRangeQuery) o;+ return Objects.equals(fieldName, that.fieldName)+ // && Objects.equals(sortedClauses, that.sortedClauses)+ && upperBoundWiseEquals(sortedClauses, that.sortedClauses);+ }++ /**+ * TreeSet.equals is ruled by {@linkplain Comparator} logic. This comparator have to be upper+ * bound agnostic to support floor() lookups. However, equals() should be upper bound sensitive+ * and here we ensure that.+ */+ private boolean upperBoundWiseEquals(+ NavigableSet<DocValuesMultiRangeQuery.LongRange> left,+ NavigableSet<DocValuesMultiRangeQuery.LongRange> right) {+ for (Iterator<DocValuesMultiRangeQuery.LongRange> li = left.iterator(), ri = right.iterator();+ li.hasNext() && ri.hasNext(); ) {+ if (!li.next().equals(ri.next()) || li.hasNext() != ri.hasNext()) {+ return false;+ }+ }+ return true;+ }++ @Override+ public int hashCode() {+ return Objects.hash(fieldName, sortedClauses);+ }++ /** Weight for {@linkplain SortedNumericDocValuesMultiRangeQuery} */+ protected class MultiRangeWeight extends ConstantScoreWeight {+ final ScoreMode scoreMode;++ public MultiRangeWeight(float boost, ScoreMode scoreMode) {+ super(SortedNumericDocValuesMultiRangeQuery.this, boost);+ this.scoreMode = scoreMode;+ }++ @Override+ public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException {+ if (context.reader().getFieldInfos().fieldInfo(fieldName) == null) {+ return null;+ }+ long lowerValue = sortedClauses.getFirst().lower;+ long upperValue = sortedClauses.getLast().upper;+ int maxDoc = context.reader().maxDoc();+ DocValuesSkipper skipper = context.reader().getDocValuesSkipper(fieldName);+ if (skipper != null) {+ if (skipper.minValue() > upperValue || skipper.maxValue() < lowerValue) {+ return null;+ }+ }++ SortedNumericDocValues values = DocValues.getSortedNumeric(context.reader(), fieldName);+ TwoPhaseIterator iterator;+ iterator =+ new TwoPhaseIterator(values) {+ final DocValuesMultiRangeQuery.LongRange lookupVal =+ new DocValuesMultiRangeQuery.LongRange(-Long.MAX_VALUE, -Long.MAX_VALUE);++ @Override+ public boolean matches() throws IOException {+ NavigableSet<DocValuesMultiRangeQuery.LongRange> rangeTree = sortedClauses;+ for (int i = 0, count = values.docValueCount(); i < count; ++i) {+ final long value = values.nextValue();+ if (value >= lowerValue && value <= upperValue) {+ lookupVal.lower = value;+ lookupVal.upper = value;+ DocValuesMultiRangeQuery.LongRange lessOrEq = rangeTree.floor(lookupVal);+ if (lessOrEq != null) {+ if (lessOrEq.upper >= value) {+ assert lessOrEq.lower <= value;+ return true;+ }+ assert lessOrEq.upper < value+ : "always true. prev range is over before the value";+ // cut range tree for greater values, if we'll look up then+ if (i < count - 1) {+ rangeTree = rangeTree.tailSet(lessOrEq, false);+ }+ } // else+ // lessOrEq == null - value before the first range+ }+ }+ return false; // all values were < lowerValue+ }++ @Override+ public float matchCost() {+ return sortedClauses.size();+ }+ };+ if (skipper != null) {+ iterator =+ new DocValuesRangeIterator(+ iterator, skipper, lowerValue, upperValue, sortedClauses.size() > 1);+ }+ return ConstantScoreScorerSupplier.fromIterator(+ TwoPhaseIterator.asDocIdSetIterator(iterator), score(), scoreMode, maxDoc);+ }++ @Override+ public boolean isCacheable(LeafReaderContext ctx) {+ return DocValues.isCacheable(ctx, fieldName);+ }+ }+}diff --git a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestSsDvMultiRangeQuery.java b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestSortedDvMultiRangeQuery.javasimilarity index 67%rename from lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestSsDvMultiRangeQuery.javarename to lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestSortedDvMultiRangeQuery.javaindex 112feec2cc7..1cd0e561d75 100644--- a/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestSsDvMultiRangeQuery.java+++ b/lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestSortedDvMultiRangeQuery.java@@ -28,7 +28,9 @@ import org.apache.lucene.codecs.lucene90.Lucene90DocValuesFormat;import org.apache.lucene.document.Document;import org.apache.lucene.document.IntPoint;import org.apache.lucene.document.LongPoint;+import org.apache.lucene.document.NumericDocValuesField;import org.apache.lucene.document.SortedDocValuesField;+import org.apache.lucene.document.SortedNumericDocValuesField;import org.apache.lucene.document.SortedSetDocValuesField;import org.apache.lucene.index.IndexReader;import org.apache.lucene.index.IndexWriterConfig;@@ -50,7 +52,7 @@ import org.apache.lucene.tests.util.TestUtil;import org.apache.lucene.util.BytesRef;import org.apache.lucene.util.IOUtils;-public class TestSsDvMultiRangeQuery extends LuceneTestCase {+public class TestSortedDvMultiRangeQuery extends LuceneTestCase {private Codec getCodec() {// small interval size to test with many intervalsreturn TestUtil.alwaysDocValuesFormat(new Lucene90DocValuesFormat(random().nextInt(4, 16)));@@ -69,8 +71,11 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {w = new RandomIndexWriter(random(), dir);} else {IndexWriterConfig config = new IndexWriterConfig().setCodec(getCodec());- config.setIndexSort(- new Sort(new SortField("docVal", SortField.Type.STRING, random().nextBoolean())));+ SortField sortField =+ random().nextBoolean()+ ? new SortField("docVal", SortField.Type.STRING, random().nextBoolean())+ : new SortField("numVal", SortField.Type.LONG, random().nextBoolean());+ config.setIndexSort(new Sort(sortField));w = new RandomIndexWriter(random(), dir);}@@ -84,17 +89,22 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {scratch[v] = RandomNumbers.randomLongBetween(random(), 0, atLeast(100));}doc.add(new LongPoint("point", scratch));+ assert scratch.length == 1;if (singleton) {if (sortedIndex) {doc.add(SortedDocValuesField.indexedField("docVal", LongPoint.pack(scratch)));+ doc.add(NumericDocValuesField.indexedField("numVal", scratch[0]));} else {doc.add(new SortedDocValuesField("docVal", LongPoint.pack(scratch)));+ doc.add(new NumericDocValuesField("numVal", scratch[0]));}} else {if (sortedIndex) {doc.add(SortedSetDocValuesField.indexedField("docVal", LongPoint.pack(scratch)));+ doc.add(SortedNumericDocValuesField.indexedField("numVal", scratch[0]));} else {doc.add(new SortedSetDocValuesField("docVal", LongPoint.pack(scratch)));+ doc.add(new SortedNumericDocValuesField("numVal", scratch[0]));}}}@@ -112,6 +122,8 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {BooleanQuery.Builder builder2 = new BooleanQuery.Builder();DocValuesMultiRangeQuery.SortedSetStabbingBuilder builder3 =new DocValuesMultiRangeQuery.SortedSetStabbingBuilder("docVal");+ DocValuesMultiRangeQuery.SortedNumericStabbingBuilder builderNumeric =+ new DocValuesMultiRangeQuery.SortedNumericStabbingBuilder("numVal");for (int i = 0; i < numRanges; i++) {long[] lower = new long[dims];@@ -127,21 +139,27 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {} else {builder3.add(LongPoint.pack(lower), LongPoint.pack(upper));}+ builderNumeric.add(lower[0], upper[0]);}Query query1 = builder1.build();Query query2 = builder2.build();Query query3 = builder3.build();+ Query queryNumeric = builderNumeric.build();TopDocs result1 = searcher.search(query1, reader.maxDoc(), Sort.INDEXORDER);TopDocs result2 = searcher.search(query2, reader.maxDoc(), Sort.INDEXORDER);TopDocs result3 = searcher.search(query3, reader.maxDoc(), Sort.INDEXORDER);+ TopDocs resultNumeric = searcher.search(queryNumeric, reader.maxDoc(), Sort.INDEXORDER);assertEquals(result2.totalHits, result1.totalHits);assertEquals(result2.totalHits, result3.totalHits);+ assertEquals(resultNumeric.totalHits, result3.totalHits);assertEquals(result2.scoreDocs.length, result1.scoreDocs.length);assertEquals(result2.scoreDocs.length, result3.scoreDocs.length);+ assertEquals(resultNumeric.scoreDocs.length, result3.scoreDocs.length);for (int i = 0; i < result2.scoreDocs.length; i++) {assertEquals(result2.scoreDocs[i].doc, result1.scoreDocs[i].doc);assertEquals(result2.scoreDocs[i].doc, result3.scoreDocs[i].doc);+ assertEquals(result3.scoreDocs[i].doc, resultNumeric.scoreDocs[i].doc);}IOUtils.close(reader, w, dir);@@ -158,11 +176,26 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {QueryUtils.checkUnequal(q1, mrSsDvQ("bar", 3, 5, 7, 9));}+ public void testNumericEquals() {+ Query q1 = mrSNumDvQ("foo", 3, 5, 7, 9);+ QueryUtils.checkEqual(q1, mrSNumDvQ("foo", 3, 5, 7, 9));+ QueryUtils.checkEqual(q1, mrSNumDvQ("foo", 7, 9, 3, 5));+ QueryUtils.checkUnequal(q1, mrSNumDvQ("foo", 7, 9, 5, 3));+ QueryUtils.checkUnequal(q1, mrSNumDvQ("foo", 3, 5 + 1, 7, 9));+ QueryUtils.checkUnequal(q1, mrSNumDvQ("foo", 3, 5, 7 + 1, 9));+ QueryUtils.checkUnequal(q1, mrSNumDvQ("bar", 3, 5, 7, 9));+ }+private Query mrSsDvQ(String field, int... ends) {DocValuesMultiRangeQuery.SortedSetStabbingBuilder b = mrSsDvBuilder(field, ends);return b.build();}+ private Query mrSNumDvQ(String field, int... ends) {+ DocValuesMultiRangeQuery.SortedNumericStabbingBuilder b = mrSNumDvBuilder(field, ends);+ return b.build();+ }+private static DocValuesMultiRangeQuery.SortedSetStabbingBuilder mrSsDvBuilder(String field, int... ends) {DocValuesMultiRangeQuery.SortedSetStabbingBuilder b =@@ -182,6 +215,21 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {return b;}+ private static DocValuesMultiRangeQuery.SortedNumericStabbingBuilder mrSNumDvBuilder(+ String field, int... ends) {+ DocValuesMultiRangeQuery.SortedNumericStabbingBuilder b =+ new DocValuesMultiRangeQuery.SortedNumericStabbingBuilder(field);+ List<Integer> posns =+ IntStream.range(0, ends.length / 2).map(i -> i * 2).boxed().collect(Collectors.toList());+ Collections.shuffle(posns, random());+ for (Integer pos : posns) {+ int lower = ends[pos];+ int upper = ends[pos + 1];+ b.add(lower, upper);+ }+ return b;+ }+public void testToString() {Query q1 = mrSsDvQ("foo", 3, 5, 7, 9);assertEquals("foo:[[80 0 0 3]..[80 0 0 5], [80 0 0 7]..[80 0 0 9]]", q1.toString());@@ -189,6 +237,13 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {assertEquals("foo:[[80 0 0 3]..[80 0 0 5], [80 0 0 7]..[80 0 0 9]]", q1.toString("bar"));}+ public void testNumericToString() {+ Query q1 = mrSNumDvQ("foo", 3, 5, 7, 9);+ assertEquals("foo:[3..5, 7..9]", q1.toString());+ assertEquals("[3..5, 7..9]", q1.toString("foo"));+ assertEquals("foo:[3..5, 7..9]", q1.toString("bar"));+ }+public void testOverrideToString() {DocValuesMultiRangeQuery.SortedSetStabbingBuilder b =new DocValuesMultiRangeQuery.SortedSetStabbingBuilder("foo") {@@ -218,6 +273,33 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {assertEquals("1 2", myrange.toString());}+ public void testOverrideNumericsToString() {+ DocValuesMultiRangeQuery.SortedNumericStabbingBuilder b =+ new DocValuesMultiRangeQuery.SortedNumericStabbingBuilder("foo") {+ @Override+ protected Query createSortedNumericDocValuesMultiRangeQuery() {+ return new SortedNumericDocValuesMultiRangeQuery(fieldName, clauses) {+ @Override+ public String toString(String fld) {+ return fieldName + " " + sortedClauses.size();+ }+ };+ }+ };+ b.add(1, 2);+ b.add(3, 4);+ assertEquals("foo 2", b.build().toString());++ DocValuesMultiRangeQuery.LongRange myrange =+ new DocValuesMultiRangeQuery.LongRange(1, 2) {+ @Override+ public String toString() {+ return lower + " " + upper;+ }+ };+ assertEquals("1 2", myrange.toString());+ }+public void testMissingField() throws IOException {Directory dir = newDirectory();RandomIndexWriter iw = new RandomIndexWriter(random(), dir);@@ -225,7 +307,7 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {IndexReader reader = iw.getReader();iw.close();IndexSearcher searcher = newSearcher(reader);- for (Query query : Collections.singletonList(mrSsDvQ("foo", 1, 2))) {+ for (Query query : List.of(mrSsDvQ("foo", 1, 2), mrSNumDvQ("foo", 1, 2))) {Weight w = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE, 1);assertNull(w.scorer(searcher.getIndexReader().leaves().getFirst()));}@@ -275,4 +357,45 @@ public class TestSsDvMultiRangeQuery extends LuceneTestCase {reader.close();dir.close();}++ public void testNumericCases() throws IOException {+ Directory dir = newDirectory();+ RandomIndexWriter iw = new RandomIndexWriter(random(), dir);+ final Document doc1 = new Document();+ doc1.add(new SortedNumericDocValuesField("foo", 1L));+ iw.addDocument(doc1);+ final Document doc2 = new Document();+ doc2.add(new SortedNumericDocValuesField("foo", 10L));+ iw.addDocument(doc2);++ IndexReader reader = iw.getReader();+ iw.close();+ IndexSearcher searcher = newSearcher(reader);+ for (DocValuesMultiRangeQuery.SortedNumericStabbingBuilder builder :+ List.of(+ mrSNumDvBuilder("foo", 2, 3, 4, 5, -5, -2),+ mrSNumDvBuilder("foo", 2, 3, 4, 5, 12, 15))) {+ assertEquals("no match", 0, searcher.search(builder.build(), 1).totalHits.value());+ long lower;+ long upper;+ builder.add(lower = 100, 200);+ assertEquals("no match", 0, searcher.search(builder.build(), 1).totalHits.value());+ lower = 1;+ upper = 10;+ builder.add(lower, upper);+ Query query = builder.build();+ assertEquals(+ "sanity check for potential match " + query,+ 2,+ searcher.search(query, 100).totalHits.value());+ }+ // hit by value as a range upper==lower+ TopDocs hit1 = searcher.search(mrSNumDvQ("foo", 2, 3, 4, 5, -5, -2, 1, 1), 1);+ TopDocs hit10 = searcher.search(mrSNumDvQ("foo", 2, 3, 4, 5, -5, -2, 10, 10), 1);+ assertEquals(1, hit1.totalHits.value());+ assertEquals(1, hit10.totalHits.value());+ assertNotEquals(hit1.scoreDocs[0].doc, hit10.scoreDocs[0].doc);+ reader.close();+ dir.close();+ }}