Separate handling of different number types

1 files changed, 101 insertions, 63 deletions

diff --git a/container-search/src/test/java/com/yahoo/prelude/query/MultiRangeItemTestCase.java b/container-search/src/test/java/com/yahoo/prelude/query/MultiRangeItemTestCase.java
index b9ff28971d0..c970f97c70e 100644
--- a/container-search/src/test/java/com/yahoo/prelude/query/MultiRangeItemTestCase.java
+++ b/container-search/src/test/java/com/yahoo/prelude/query/MultiRangeItemTestCase.java
@@ -1,18 +1,22 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.prelude.query;
 
+import com.yahoo.prelude.query.MultiRangeItem.NumberType;
 import com.yahoo.prelude.query.MultiRangeItem.Range;
 import org.junit.jupiter.api.Test;
 
 import java.nio.ByteBuffer;
 import java.util.List;
 
+import static com.yahoo.compress.IntegerCompressor.putCompressedNumber;
 import static com.yahoo.prelude.query.MultiRangeItem.Limit.EXCLUSIVE;
 import static com.yahoo.prelude.query.MultiRangeItem.Limit.INCLUSIVE;
 import static java.lang.Double.NEGATIVE_INFINITY;
 import static java.lang.Double.NaN;
 import static java.lang.Double.POSITIVE_INFINITY;
-import static java.util.Comparator.comparingDouble;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.Comparator.comparingInt;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -22,20 +26,20 @@ import static org.junit.jupiter.api.Assertions.fail;
 public class MultiRangeItemTestCase {
 
     // We'll add ranges (0, 0), (0, 2), (2, 2), (3, 4), (5, 8), (6, 6), (7, 9), (9, 9), (1, 8), in that order, and in "random" order.
-    final List<Range> ranges = List.of(new Range(1, 8), // Make it "unordered", so sorting is delayed.
-                                       new Range(0, 0),
-                                       new Range(0, 2),
-                                       new Range(2, 2),
-                                       new Range(3, 4),
-                                       new Range(5, 8),
-                                       new Range(6, 6),
-                                       new Range(9, 9),
-                                       new Range(7, 9));
+    final List<Range<Integer>> ranges = List.of(new Range<>(1, 8), // Make it "unordered", so sorting is delayed.
+                                       new Range<>(0, 0),
+                                       new Range<>(0, 2),
+                                       new Range<>(2, 2),
+                                       new Range<>(3, 4),
+                                       new Range<>(5, 8),
+                                       new Range<>(6, 6),
+                                       new Range<>(9, 9),
+                                       new Range<>(7, 9));
 
     @Test
     public void testNanIsDisallowed() {
         try {
-            MultiRangeItem.overPoints("i", INCLUSIVE, EXCLUSIVE).addPoint(NaN);
+            MultiRangeItem.overPoints(NumberType.DOUBLE, "i", INCLUSIVE, EXCLUSIVE).addPoint(NaN);
             fail("NaN should be disallowed");
         }
         catch (IllegalArgumentException e) {
@@ -45,18 +49,18 @@ public class MultiRangeItemTestCase {
 
     @Test
     public void testSpecialValuesWithClosedIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", INCLUSIVE, INCLUSIVE);
+        MultiRangeItem<Double> item = MultiRangeItem.overPoints(NumberType.DOUBLE, "i", INCLUSIVE, INCLUSIVE);
         item.addPoint(0.0);
         item.addPoint(-0.0);
-        assertEquals(List.of(new Range(0.0, 0.0)),
+        assertEquals(List.of(new Range<>(0.0, 0.0)),
                      item.sortedRanges());
 
-        item.addRange(NEGATIVE_INFINITY, 0);
-        assertEquals(List.of(new Range(NEGATIVE_INFINITY, 0.0)),
+        item.addRange(NEGATIVE_INFINITY, 0.0);
+        assertEquals(List.of(new Range<>(NEGATIVE_INFINITY, 0.0)),
                      item.sortedRanges());
 
-        item.addRange(0, POSITIVE_INFINITY);
-        assertEquals(List.of(new Range(NEGATIVE_INFINITY, POSITIVE_INFINITY)),
+        item.addRange(0.0, POSITIVE_INFINITY);
+        assertEquals(List.of(new Range<>(NEGATIVE_INFINITY, POSITIVE_INFINITY)),
                      item.sortedRanges());
 
         try {
@@ -70,18 +74,18 @@ public class MultiRangeItemTestCase {
 
     @Test
     public void testSpecialValuesWithClosedOpenIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", INCLUSIVE, EXCLUSIVE);
+        MultiRangeItem<Double> item = MultiRangeItem.overPoints(NumberType.DOUBLE, "i", INCLUSIVE, EXCLUSIVE);
         item.addPoint( 0.0);
         item.addPoint(-0.0);
-        assertEquals(List.of(new Range(0.0, 0.0)),
+        assertEquals(List.of(new Range<>(0.0, 0.0)),
                      item.sortedRanges());
 
-        item.addRange(NEGATIVE_INFINITY, 0);
-        assertEquals(List.of(new Range(NEGATIVE_INFINITY, 0.0)),
+        item.addRange(NEGATIVE_INFINITY, 0.0);
+        assertEquals(List.of(new Range<>(NEGATIVE_INFINITY, 0.0)),
                      item.sortedRanges());
 
-        item.addRange(0, POSITIVE_INFINITY);
-        assertEquals(List.of(new Range(NEGATIVE_INFINITY, POSITIVE_INFINITY)),
+        item.addRange(0.0, POSITIVE_INFINITY);
+        assertEquals(List.of(new Range<>(NEGATIVE_INFINITY, POSITIVE_INFINITY)),
                      item.sortedRanges());
 
         try {
@@ -95,18 +99,18 @@ public class MultiRangeItemTestCase {
 
     @Test
     public void testSpecialValuesWithOpenClosedIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", EXCLUSIVE, INCLUSIVE);
+        MultiRangeItem<Double> item = MultiRangeItem.overPoints(NumberType.DOUBLE, "i", EXCLUSIVE, INCLUSIVE);
         item.addPoint( 0.0);
         item.addPoint(-0.0);
-        assertEquals(List.of(new Range(0.0, 0.0)),
+        assertEquals(List.of(new Range<>(0.0, 0.0)),
                      item.sortedRanges());
 
-        item.addRange(NEGATIVE_INFINITY, 0);
-        assertEquals(List.of(new Range(NEGATIVE_INFINITY, 0.0)),
+        item.addRange(NEGATIVE_INFINITY, 0.0);
+        assertEquals(List.of(new Range<>(NEGATIVE_INFINITY, 0.0)),
                      item.sortedRanges());
 
-        item.addRange(0, POSITIVE_INFINITY);
-        assertEquals(List.of(new Range(NEGATIVE_INFINITY, POSITIVE_INFINITY)),
+        item.addRange(0.0, POSITIVE_INFINITY);
+        assertEquals(List.of(new Range<>(NEGATIVE_INFINITY, POSITIVE_INFINITY)),
                      item.sortedRanges());
 
         try {
@@ -120,18 +124,18 @@ public class MultiRangeItemTestCase {
 
     @Test
     public void testSpecialValuesWithOpenIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", EXCLUSIVE, EXCLUSIVE);
+        MultiRangeItem<Double> item = MultiRangeItem.overPoints(NumberType.DOUBLE, "i", EXCLUSIVE, EXCLUSIVE);
         item.addPoint( 0.0);
         item.addPoint(-0.0);
-        assertEquals(List.of(new Range(0.0, 0.0)),
+        assertEquals(List.of(new Range<>(0.0, 0.0)),
                      item.sortedRanges());
 
-        item.addRange(NEGATIVE_INFINITY, 0);
-        assertEquals(List.of(new Range(NEGATIVE_INFINITY, 0.0)),
+        item.addRange(NEGATIVE_INFINITY, 0.0);
+        assertEquals(List.of(new Range<>(NEGATIVE_INFINITY, 0.0)),
                      item.sortedRanges());
 
-        item.addRange(0, POSITIVE_INFINITY);
-        assertEquals(List.of(new Range(NEGATIVE_INFINITY, POSITIVE_INFINITY)),
+        item.addRange(0.0, POSITIVE_INFINITY);
+        assertEquals(List.of(new Range<>(NEGATIVE_INFINITY, POSITIVE_INFINITY)),
                      item.sortedRanges());
 
         try {
@@ -145,76 +149,76 @@ public class MultiRangeItemTestCase {
 
     @Test
     public void testAddingRangesOrderedByStartWithClosedIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", INCLUSIVE, INCLUSIVE);
-        ranges.stream().sorted(comparingDouble(range -> range.start.doubleValue()))
+        MultiRangeItem<Integer> item = MultiRangeItem.overPoints(NumberType.INTEGER, "i", INCLUSIVE, INCLUSIVE);
+        ranges.stream().sorted(comparingInt(range -> range.start))
               .forEach(range -> item.addRange(range.start, range.end));
 
-        assertEquals(List.of(new Range(0, 9)),
+        assertEquals(List.of(new Range<>(0, 9)),
                      item.sortedRanges());
     }
 
     @Test
     public void testAddingRangesOrderedByStartWithOpenIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", EXCLUSIVE, EXCLUSIVE);
-        ranges.stream().sorted(comparingDouble(range -> range.start.doubleValue()))
+        MultiRangeItem<Integer> item = MultiRangeItem.overPoints(NumberType.INTEGER, "i", EXCLUSIVE, EXCLUSIVE);
+        ranges.stream().sorted(comparingInt(range -> range.start))
               .forEach(range -> item.addRange(range.start, range.end));
 
-        assertEquals(List.of(new Range(0, 9)),
+        assertEquals(List.of(new Range<>(0, 9)),
                      item.sortedRanges());
     }
 
     @Test
     public void testAddingRangesOrderedByEndWithClosedIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", INCLUSIVE, INCLUSIVE);
-        ranges.stream().sorted(comparingDouble(range -> range.end.doubleValue()))
+        MultiRangeItem<Integer> item = MultiRangeItem.overPoints(NumberType.INTEGER, "i", INCLUSIVE, INCLUSIVE);
+        ranges.stream().sorted(comparingInt(range -> range.end))
               .forEach(range -> item.addRange(range.start, range.end));
 
-        assertEquals(List.of(new Range(0, 9)),
+        assertEquals(List.of(new Range<>(0, 9)),
                      item.sortedRanges());
     }
 
     @Test
     public void testAddingRangesOrderedByEndWithOpenIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", EXCLUSIVE, EXCLUSIVE);
-        ranges.stream().sorted(comparingDouble(range -> range.end.doubleValue()))
+        MultiRangeItem<Integer> item = MultiRangeItem.overPoints(NumberType.INTEGER, "i", EXCLUSIVE, EXCLUSIVE);
+        ranges.stream().sorted(comparingInt(range -> range.end))
               .forEach(range -> item.addRange(range.start, range.end));
 
-        assertEquals(List.of(new Range(0, 9)),
+        assertEquals(List.of(new Range<>(0, 9)),
                      item.sortedRanges());
     }
 
     @Test
     public void testAddingRangesUnorderedWithClosedIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", INCLUSIVE, INCLUSIVE);
-        for (Range range : ranges)
+        MultiRangeItem<Integer> item = MultiRangeItem.overPoints(NumberType.INTEGER, "i", INCLUSIVE, INCLUSIVE);
+        for (Range<Integer> range : ranges)
             item.addRange(range.start, range.end);
 
-        assertEquals(List.of(new Range(0, 9)),
+        assertEquals(List.of(new Range<>(0, 9)),
                      item.sortedRanges());
     }
 
     @Test
     public void testAddingRangesUnorderedWithOpenIntervals() {
-        MultiRangeItem item = MultiRangeItem.overPoints("i", EXCLUSIVE, EXCLUSIVE);
-        for (Range range : ranges)
+        MultiRangeItem<Integer> item = MultiRangeItem.overPoints(NumberType.INTEGER, "i", EXCLUSIVE, EXCLUSIVE);
+        for (Range<Integer> range : ranges)
             item.addRange(range.start, range.end);
 
-        assertEquals(List.of(new Range(0, 9)),
+        assertEquals(List.of(new Range<>(0, 9)),
                      item.sortedRanges());
     }
 
     @Test
-    public void testSerialization() {
+    public void testDoublePointsSerialization() {
         ByteBuffer pointsBuffer = ByteBuffer.allocate(25);
-        MultiRangeItem pointsItem = MultiRangeItem.overPoints("i", EXCLUSIVE, INCLUSIVE)
-                                                  .addRange(NEGATIVE_INFINITY, POSITIVE_INFINITY);
+        MultiRangeItem<Double> pointsItem = MultiRangeItem.overPoints(NumberType.DOUBLE, "i", EXCLUSIVE, INCLUSIVE)
+                                                          .addRange(NEGATIVE_INFINITY, POSITIVE_INFINITY);
         pointsItem.encode(pointsBuffer);
 
         ByteBuffer expected = ByteBuffer.allocate(25);
         expected.put((byte) 0b00000111); // ItemType.MULTI_TERM
         expected.put((byte) 0b00100000); // OR << 5, RANGES
         expected.putInt(1);              // term count
-        expected.put((byte) 0b00000101); // end inclusive, same index
+        expected.put((byte) 0b00010101); // UNIFORM_DOUBLE << 3, end inclusive, same index
         expected.put((byte) 1);          // index name length
         expected.put((byte) 'i');        // index name bytes
         expected.putDouble(NEGATIVE_INFINITY);
@@ -222,20 +226,24 @@ public class MultiRangeItemTestCase {
 
         pointsBuffer.flip();
         expected.flip();
+        assertArrayEquals(expected.array(), pointsBuffer.array());
         assertEquals(expected, pointsBuffer);
+    }
 
+    @Test
+    public void testDoubleRangesSerialization() {
         ByteBuffer rangesBuffer = ByteBuffer.allocate(59);
-        MultiRangeItem rangesItem = MultiRangeItem.overRanges("i", INCLUSIVE, "j", EXCLUSIVE)
-                                                  .addPoint(    -0.0)
-                                                  .addRange( 1,  2.0)
-                                                  .addRange(-1, -0.5);
+        MultiRangeItem<Double> rangesItem = MultiRangeItem.overRanges(NumberType.DOUBLE, "i", INCLUSIVE, "j", EXCLUSIVE)
+                                                          .addPoint(      -0.0)
+                                                          .addRange( 1.0,  2.0)
+                                                          .addRange(-1.0, -0.5);
         rangesItem.encode(rangesBuffer);
 
-        expected = ByteBuffer.allocate(59);
+        ByteBuffer expected = ByteBuffer.allocate(59);
         expected.put((byte) 0b00000111); // ItemType.MULTI_TERM
         expected.put((byte) 0b00100000); // OR << 5, RANGES
         expected.putInt(3);              // term count
-        expected.put((byte) 0b00000010); // end inclusive, same index
+        expected.put((byte) 0b00010010); // UNIFORM_DOUBLE, start inclusive, two indexes
         expected.put((byte) 1);          // index name length
         expected.put((byte) 'i');        // index name bytes
         expected.put((byte) 1);          // index name length
@@ -249,6 +257,36 @@ public class MultiRangeItemTestCase {
 
         rangesBuffer.flip();
         expected.flip();
+        assertArrayEquals(expected.array(), rangesBuffer.array());
+        assertEquals(expected, rangesBuffer);
+    }
+
+    @Test
+    public void testIntegerRangesSerialization() {
+        ByteBuffer rangesBuffer = ByteBuffer.allocate(24);
+        MultiRangeItem<Integer> rangesItem = MultiRangeItem.overRanges(NumberType.INTEGER, "start", INCLUSIVE, "end", EXCLUSIVE)
+                                                          .addPoint(                0)
+                                                          .addRange( 1, (1 << 29) - 1)
+                                                          .addRange(-1,            -0);
+        rangesItem.encode(rangesBuffer);
+
+        ByteBuffer expected = ByteBuffer.allocate(24);
+        expected.put((byte) 0b00000111);              // ItemType.MULTI_TERM
+        expected.put((byte) 0b00100000);              // OR << 5, RANGES
+        expected.putInt(2);                           // term count
+        expected.put((byte) 0b00011010);              // COMPRESSED_INTEGER << 3, start inclusive, two indexes
+        expected.put((byte) 5);                       // index name length
+        expected.put("start".getBytes(UTF_8));        // index name bytes
+        expected.put((byte) 3);                       // index name length
+        expected.put("end".getBytes(UTF_8));          // index name bytes
+        putCompressedNumber(-1, expected);            // 1 byte
+        putCompressedNumber(0, expected);             // 1 byte
+        putCompressedNumber(1, expected);             // 1 byte
+        putCompressedNumber((1 << 29) - 1, expected); // 4 bytes
+
+        rangesBuffer.flip();
+        expected.flip();
+        assertArrayEquals(expected.array(), rangesBuffer.array());
         assertEquals(expected, rangesBuffer);
     }