Skip to content

Apache Lucene open-source search software

MultiRange query for SortedNumeric DocValues (#14404)

Mikhail Khludnev2eeb71877da4
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 6af1ca3c0eb..851006f9d58 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -70,7 +70,8 @@ API Changes
New 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.java
index 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.java
new file mode 100644
index 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.java
similarity index 67%
rename from lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestSsDvMultiRangeQuery.java
rename to lucene/sandbox/src/test/org/apache/lucene/sandbox/search/TestSortedDvMultiRangeQuery.java
index 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 intervals
return 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();
+ }
}