You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by is...@apache.org on 2017/07/29 21:59:56 UTC
[19/28] lucene-solr:jira/solr-6630: Merging master
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/8d00e53b/solr/core/src/test/org/apache/solr/schema/TestPointFields.java
----------------------------------------------------------------------
diff --git a/solr/core/src/test/org/apache/solr/schema/TestPointFields.java b/solr/core/src/test/org/apache/solr/schema/TestPointFields.java
index a1d2260..8192406 100644
--- a/solr/core/src/test/org/apache/solr/schema/TestPointFields.java
+++ b/solr/core/src/test/org/apache/solr/schema/TestPointFields.java
@@ -17,17 +17,24 @@
package org.apache.solr.schema;
import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
@@ -66,16 +73,15 @@ import org.junit.After;
import org.junit.BeforeClass;
import org.junit.Test;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-/**
- * Tests for PointField functionality
- *
- *
- */
+/** Tests for PointField functionality */
public class TestPointFields extends SolrTestCaseJ4 {
-
+
+ // long overflow can occur in some date calculations if gaps are too large, so we limit to a million years BC & AD.
+ private static final long MIN_DATE_EPOCH_MILLIS = LocalDateTime.parse("-1000000-01-01T00:00:00").toInstant(ZoneOffset.ofHours(0)).toEpochMilli();
+ private static final long MAX_DATE_EPOCH_MILLIS = LocalDateTime.parse("+1000000-01-01T00:00:00").toInstant(ZoneOffset.ofHours(0)).toEpochMilli();
+
private static final String[] FIELD_SUFFIXES = new String[] {
"", "_dv", "_mv", "_mv_dv", "_ni", "_ni_dv", "_ni_dv_ns", "_ni_dv_ns_mv",
"_ni_mv", "_ni_mv_dv", "_ni_ns", "_ni_ns_mv", "_dv_ns", "_ni_ns_dv", "_dv_ns_mv",
@@ -115,9 +121,11 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testIntPointFieldReturn() throws Exception {
- testPointFieldReturn("number_p_i", "int", new String[]{"0", "-1", "2", "3", "43", "52", "-60", "74", "80", "99"});
- testPointFieldReturn("number_p_i_dv_ns", "int", new String[]{"0", "-1", "2", "3", "43", "52", "-60", "74", "80", "99"});
- testPointFieldReturn("number_p_i_ni", "int", new String[]{"0", "-1", "2", "3", "43", "52", "-60", "74", "80", "99"});
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ String[] ints = toStringArray(getRandomInts(numValues, false));
+ doTestPointFieldReturn("number_p_i", "int", ints);
+ doTestPointFieldReturn("number_p_i_dv_ns", "int", ints);
+ doTestPointFieldReturn("number_p_i_ni", "int", ints);
}
@Test
@@ -129,9 +137,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testIntPointFieldNonSearchableRangeQuery() throws Exception {
- doTestPointFieldNonSearchableRangeQuery("number_p_i_ni", "42");
- doTestPointFieldNonSearchableRangeQuery("number_p_i_ni_ns", "42");
- doTestPointFieldNonSearchableRangeQuery("number_p_i_ni_ns_mv", "42", "666");
+ doTestPointFieldNonSearchableRangeQuery("number_p_i_ni", toStringArray(getRandomInts(1, false)));
+ doTestPointFieldNonSearchableRangeQuery("number_p_i_ni_ns", toStringArray(getRandomInts(1, false)));
+ int numValues = 2 * RANDOM_MULTIPLIER;
+ doTestPointFieldNonSearchableRangeQuery("number_p_i_ni_ns_mv", toStringArray(getRandomInts(numValues, false)));
}
@Test
@@ -148,7 +157,7 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, sequential);
doTestPointFieldSort(field, randomInts);
- doTestIntPointFunctionQuery(field, "int");
+ doTestIntPointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_i_smf", "*_p_i_dv_smf", "*_p_i_ni_dv_smf",
"*_p_i_sml", "*_p_i_dv_sml", "*_p_i_ni_dv_sml")) {
@@ -156,14 +165,14 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, sequential);
doTestPointFieldSort(field, randomIntsMissing);
- doTestIntPointFunctionQuery(field, "int");
+ doTestIntPointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_i_ni", "*_p_i_ni_ns")) {
assertTrue(r, regexToTest.remove(r));
String field = r.replace("*", "number");
- doTestPointFieldSortError(field, "w/o docValues", "42");
- doTestPointFieldFunctionQueryError(field, "w/o docValues", "42");
+ doTestPointFieldSortError(field, "w/o docValues", toStringArray(getRandomInts(1, false)));
+ doTestPointFieldFunctionQueryError(field, "w/o docValues", toStringArray(getRandomInts(1, false)));
}
for (String r : Arrays.asList("*_p_i_mv", "*_p_i_ni_mv", "*_p_i_ni_mv_dv", "*_p_i_ni_dv_ns_mv",
@@ -172,10 +181,11 @@ public class TestPointFields extends SolrTestCaseJ4 {
"*_p_i_mv_sml", "*_p_i_mv_dv_sml", "*_p_i_ni_mv_dv_sml")) {
assertTrue(r, regexToTest.remove(r));
String field = r.replace("*", "number");
- doTestPointFieldSortError(field, "multivalued", "42");
- doTestPointFieldSortError(field, "multivalued", "42", "666");
- doTestPointFieldFunctionQueryError(field, "multivalued", "42");
- doTestPointFieldFunctionQueryError(field, "multivalued", "42", "666");
+ doTestPointFieldSortError(field, "multivalued", toStringArray(getRandomInts(1, false)));
+ int numValues = 2 * RANDOM_MULTIPLIER;
+ doTestPointFieldSortError(field, "multivalued", toStringArray(getRandomInts(numValues, false)));
+ doTestPointFieldFunctionQueryError(field, "multivalued", toStringArray(getRandomInts(1, false)));
+ doTestPointFieldFunctionQueryError(field, "multivalued", toStringArray(getRandomInts(numValues, false)));
}
assertEquals("Missing types in the test", Collections.<String>emptySet(), regexToTest);
@@ -183,69 +193,215 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testIntPointFieldFacetField() throws Exception {
- testPointFieldFacetField("number_p_i", "number_p_i_dv", getSequentialStringArrayWithInts(10));
+ doTestPointFieldFacetField("number_p_i", "number_p_i_dv", getSequentialStringArrayWithInts(10));
+ clearIndex();
+ assertU(commit());
+ doTestPointFieldFacetField("number_p_i", "number_p_i_dv", toStringArray(getRandomInts(10, false)));
}
@Test
public void testIntPointFieldRangeFacet() throws Exception {
- doTestIntPointFieldRangeFacet("number_p_i_dv", "number_p_i");
+ String docValuesField = "number_p_i_dv";
+ String nonDocValuesField = "number_p_i";
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ int numBuckets = numValues / 2;
+ List<Integer> values;
+ List<Integer> sortedValues;
+ int max;
+ do {
+ values = getRandomInts(numValues, false);
+ sortedValues = values.stream().sorted().collect(Collectors.toList());
+ } while ((max = sortedValues.get(sortedValues.size() - 1)) >= Integer.MAX_VALUE - numValues); // leave room for rounding
+ int min = sortedValues.get(0);
+ int gap = (int)(((long)(max + numValues) - (long)min) / (long)numBuckets);
+ int[] bucketCount = new int[numBuckets];
+ int bucketNum = 0;
+ int minBucketVal = min;
+ for (Integer value : sortedValues) {
+ while (((long)value - (long)minBucketVal) >= (long)gap) {
+ ++bucketNum;
+ minBucketVal += gap;
+ }
+ ++bucketCount[bucketNum];
+ }
+
+ for (int i = 0 ; i < numValues ; i++) {
+ assertU(adoc("id", String.valueOf(i), docValuesField, String.valueOf(values.get(i)), nonDocValuesField, String.valueOf(values.get(i))));
+ }
+ assertU(commit());
+
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).getType() instanceof PointField);
+ String[] testStrings = new String[numBuckets + 1];
+ testStrings[numBuckets] = "//*[@numFound='" + numValues + "']";
+ minBucketVal = min;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + docValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + bucketCount[i] + "']";
+ }
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField, "facet.range.start", String.valueOf(min),
+ "facet.range.end", String.valueOf(max), "facet.range.gap", String.valueOf(gap)),
+ testStrings);
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField, "facet.range.start", String.valueOf(min),
+ "facet.range.end", String.valueOf(max), "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv"),
+ testStrings);
+
+ assertFalse(h.getCore().getLatestSchema().getField(nonDocValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(nonDocValuesField).getType() instanceof PointField);
+ minBucketVal = min;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + nonDocValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + bucketCount[i] + "']";
+ }
+ // Range Faceting with method = filter should work
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField, "facet.range.start", String.valueOf(min),
+ "facet.range.end", String.valueOf(max), "facet.range.gap", String.valueOf(gap), "facet.range.method", "filter"),
+ testStrings);
+ // this should actually use filter method instead of dv
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField, "facet.range.start", String.valueOf(min),
+ "facet.range.end", String.valueOf(max), "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv"),
+ testStrings);
}
@Test
public void testIntPointStats() throws Exception {
- testPointStats("number_p_i", "number_p_i_dv", new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
- 0D, 9D, "10", "1", 0D);
- testPointStats("number_p_i", "number_p_i_mv_dv", new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
- 0D, 9D, "10", "1", 0D);
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ // don't produce numbers with exponents, since XPath comparison operators can't handle them
+ List<Integer> values = getRandomInts(numValues, false, 9999999);
+ // System.err.println(Arrays.toString(values.toArray(new Integer[values.size()])));
+ List<Integer> sortedValues = values.stream().sorted().collect(Collectors.toList());
+ double min = (double)sortedValues.get(0);
+ double max = (double)sortedValues.get(sortedValues.size() - 1);
+
+ String[] valArray = toStringArray(values);
+ doTestPointStats("number_p_i", "number_p_i_dv", valArray, min, max, numValues, 1, 0D);
+ doTestPointStats("number_p_i", "number_p_i_mv_dv", valArray, min, max, numValues, 1, 0D);
}
@Test
public void testIntPointFieldMultiValuedExactQuery() throws Exception {
- testPointFieldMultiValuedExactQuery("number_p_i_mv", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedExactQuery("number_p_i_ni_mv_dv", getSequentialStringArrayWithInts(20));
+ String[] ints = toStringArray(getRandomInts(20, false));
+ doTestPointFieldMultiValuedExactQuery("number_p_i_mv", ints);
+ doTestPointFieldMultiValuedExactQuery("number_p_i_ni_mv_dv", ints);
}
@Test
public void testIntPointFieldMultiValuedNonSearchableExactQuery() throws Exception {
- testPointFieldMultiValuedExactQuery("number_p_i_ni_mv", getSequentialStringArrayWithInts(20), false);
- testPointFieldMultiValuedExactQuery("number_p_i_ni_ns_mv", getSequentialStringArrayWithInts(20), false);
+ String[] ints = toStringArray(getRandomInts(20, false));
+ doTestPointFieldMultiValuedExactQuery("number_p_i_ni_mv", ints, false);
+ doTestPointFieldMultiValuedExactQuery("number_p_i_ni_ns_mv", ints, false);
}
@Test
public void testIntPointFieldMultiValuedReturn() throws Exception {
- testPointFieldMultiValuedReturn("number_p_i_mv", "int", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedReturn("number_p_i_ni_mv_dv", "int", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedReturn("number_p_i_dv_ns_mv", "int", getSequentialStringArrayWithInts(20));
+ String[] ints = toStringArray(getRandomInts(20, false));
+ doTestPointFieldMultiValuedReturn("number_p_i_mv", "int", ints);
+ doTestPointFieldMultiValuedReturn("number_p_i_ni_mv_dv", "int", ints);
+ doTestPointFieldMultiValuedReturn("number_p_i_dv_ns_mv", "int", ints);
}
@Test
public void testIntPointFieldMultiValuedRangeQuery() throws Exception {
- testPointFieldMultiValuedRangeQuery("number_p_i_mv", "int", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedRangeQuery("number_p_i_ni_mv_dv", "int", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedRangeQuery("number_p_i_mv_dv", "int", getSequentialStringArrayWithInts(20));
+ String[] ints = toStringArray(getRandomInts(20, false).stream().sorted().collect(Collectors.toList()));
+ doTestPointFieldMultiValuedRangeQuery("number_p_i_mv", "int", ints);
+ doTestPointFieldMultiValuedRangeQuery("number_p_i_ni_mv_dv", "int", ints);
+ doTestPointFieldMultiValuedRangeQuery("number_p_i_mv_dv", "int", ints);
}
@Test
public void testIntPointFieldNotIndexed() throws Exception {
- doTestFieldNotIndexed("number_p_i_ni", getSequentialStringArrayWithInts(10));
- doTestFieldNotIndexed("number_p_i_ni_mv", getSequentialStringArrayWithInts(10));
+ String[] ints = toStringArray(getRandomInts(10, false));
+ doTestFieldNotIndexed("number_p_i_ni", ints);
+ doTestFieldNotIndexed("number_p_i_ni_mv", ints);
}
//TODO MV SORT?
@Test
public void testIntPointFieldMultiValuedFacetField() throws Exception {
- testPointFieldMultiValuedFacetField("number_p_i_mv", "number_p_i_mv_dv", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedFacetField("number_p_i_mv", "number_p_i_mv_dv", toStringArray(getRandomInts(20, false)));
+ doTestPointFieldMultiValuedFacetField("number_p_i_mv", "number_p_i_mv_dv", getSequentialStringArrayWithInts(20));
+ String[] randomSortedInts = toStringArray(getRandomInts(20, false).stream().sorted().collect(Collectors.toList()));
+ doTestPointFieldMultiValuedFacetField("number_p_i_mv", "number_p_i_mv_dv", randomSortedInts);
}
@Test
public void testIntPointFieldMultiValuedRangeFacet() throws Exception {
- doTestIntPointFieldMultiValuedRangeFacet("number_p_i_mv_dv", "number_p_i_mv");
+ String docValuesField = "number_p_i_mv_dv";
+ String nonDocValuesField = "number_p_i_mv";
+ int numValues = 20 * RANDOM_MULTIPLIER;
+ int numBuckets = numValues / 2;
+ List<Integer> values;
+ List<PosVal<Integer>> sortedValues;
+ int max;
+ do {
+ values = getRandomInts(numValues, false);
+ sortedValues = toAscendingPosVals(values, true);
+ } while ((max = sortedValues.get(sortedValues.size() - 1).val) >= Integer.MAX_VALUE - numValues); // leave room for rounding
+ int min = sortedValues.get(0).val;
+ int gap = (int)(((long)(max + numValues) - (long)min) / (long)numBuckets);
+ List<Set<Integer>> docIdBucket = new ArrayList<>(numBuckets);
+ for (int i = 0 ; i < numBuckets ; ++i) {
+ docIdBucket.add(new HashSet<>());
+ }
+ int bucketNum = 0;
+ int minBucketVal = min;
+ for (PosVal<Integer> value : sortedValues) {
+ while (value.val - minBucketVal >= gap) {
+ ++bucketNum;
+ minBucketVal += gap;
+ }
+ docIdBucket.get(bucketNum).add(value.pos / 2); // each doc gets two consecutive values
+ }
+ for (int i = 0 ; i < numValues ; i += 2) {
+ assertU(adoc("id", String.valueOf(i / 2),
+ docValuesField, String.valueOf(values.get(i)),
+ docValuesField, String.valueOf(values.get(i + 1)),
+ nonDocValuesField, String.valueOf(values.get(i)),
+ nonDocValuesField, String.valueOf(values.get(i + 1))));
+ }
+ assertU(commit());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).getType() instanceof PointField);
+ String[] testStrings = new String[numBuckets + 1];
+ minBucketVal = min;
+ testStrings[numBuckets] = "//*[@numFound='" + (numValues / 2) + "']";
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + docValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + docIdBucket.get(i).size() + "']";
+ }
+
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField,
+ "facet.range.start", String.valueOf(min), "facet.range.end", String.valueOf(max),
+ "facet.range.gap", String.valueOf(gap), "indent", "on"),
+ testStrings);
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField,
+ "facet.range.start", String.valueOf(min), "facet.range.end", String.valueOf(max),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv", "indent", "on"),
+ testStrings);
+
+ assertFalse(h.getCore().getLatestSchema().getField(nonDocValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(nonDocValuesField).getType() instanceof PointField);
+ minBucketVal = min;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + nonDocValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + docIdBucket.get(i).size() + "']";
+ }
+ // Range Faceting with method = filter should work
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField,
+ "facet.range.start", String.valueOf(min), "facet.range.end", String.valueOf(max),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "filter", "indent", "on"),
+ testStrings);
+ // this should actually use filter method instead of dv
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField,
+ "facet.range.start", String.valueOf(min), "facet.range.end", String.valueOf(max),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv", "indent", "on"),
+ testStrings);
}
@Test
- public void testIntPointMultiValuedFunctionQuery() throws Exception {
- testPointMultiValuedFunctionQuery("number_p_i_mv", "number_p_i_mv_dv", "int", getSequentialStringArrayWithInts(20));
+ public void testIntPointMultiValuedFunctionQuery() throws Exception {
+ doTestPointMultiValuedFunctionQuery("number_p_i_mv", "number_p_i_mv_dv", "int", getSequentialStringArrayWithInts(20));
+ doTestPointMultiValuedFunctionQuery("number_p_i_mv", "number_p_i_mv_dv", "int",
+ toStringArray(getRandomInts(20, false).stream().sorted().collect(Collectors.toList())));
}
@Test
@@ -253,9 +409,9 @@ public class TestPointFields extends SolrTestCaseJ4 {
if (!Boolean.getBoolean("enable.update.log")) {
return;
}
- testIntPointFieldsAtomicUpdates("number_p_i", "int");
- testIntPointFieldsAtomicUpdates("number_p_i_dv", "int");
- testIntPointFieldsAtomicUpdates("number_p_i_dv_ns", "int");
+ doTestIntPointFieldsAtomicUpdates("number_p_i");
+ doTestIntPointFieldsAtomicUpdates("number_p_i_dv");
+ doTestIntPointFieldsAtomicUpdates("number_p_i_dv_ns");
}
@Test
@@ -263,9 +419,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
if (!Boolean.getBoolean("enable.update.log")) {
return;
}
- testMultiValuedIntPointFieldsAtomicUpdates("number_p_i_mv", "int");
- testMultiValuedIntPointFieldsAtomicUpdates("number_p_i_ni_mv_dv", "int");
- testMultiValuedIntPointFieldsAtomicUpdates("number_p_i_dv_ns_mv", "int");
+ String[] ints = toStringArray(getRandomInts(3, false));
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_i_mv", "int", ints);
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_i_ni_mv_dv", "int", ints);
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_i_dv_ns_mv", "int", ints);
}
private <T> String[] toStringArray(List<T> list) {
@@ -280,6 +437,9 @@ public class TestPointFields extends SolrTestCaseJ4 {
this.pos = pos;
this.val = val;
}
+ public String toString() {
+ return "(" + pos + ": " + val.toString() + ")";
+ }
}
/** Primary sort by value, with nulls either first or last as specified, and then secondary sort by position. */
@@ -345,33 +505,28 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testDoublePointFieldExactQuery() throws Exception {
- doTestFloatPointFieldExactQuery("number_d");
- doTestFloatPointFieldExactQuery("number_p_d");
- doTestFloatPointFieldExactQuery("number_p_d_mv");
- doTestFloatPointFieldExactQuery("number_p_d_dv");
- doTestFloatPointFieldExactQuery("number_p_d_mv_dv");
- doTestFloatPointFieldExactQuery("number_p_d_ni_dv");
- doTestFloatPointFieldExactQuery("number_p_d_ni_ns_dv");
- doTestFloatPointFieldExactQuery("number_p_d_ni_dv_ns");
- doTestFloatPointFieldExactQuery("number_p_d_ni_mv_dv");
+ doTestFloatPointFieldExactQuery("number_p_d", true);
+ doTestFloatPointFieldExactQuery("number_p_d_mv", true);
+ doTestFloatPointFieldExactQuery("number_p_d_dv", true);
+ doTestFloatPointFieldExactQuery("number_p_d_mv_dv", true);
+ doTestFloatPointFieldExactQuery("number_p_d_ni_dv", true);
+ doTestFloatPointFieldExactQuery("number_p_d_ni_ns_dv", true);
+ doTestFloatPointFieldExactQuery("number_p_d_ni_dv_ns", true);
+ doTestFloatPointFieldExactQuery("number_p_d_ni_mv_dv", true);
}
@Test
public void testDoublePointFieldNonSearchableExactQuery() throws Exception {
- doTestFloatPointFieldExactQuery("number_p_d_ni", false);
- doTestFloatPointFieldExactQuery("number_p_d_ni_ns", false);
+ doTestFloatPointFieldExactQuery("number_p_d_ni", false, true);
+ doTestFloatPointFieldExactQuery("number_p_d_ni_ns", false, true);
}
@Test
public void testDoublePointFieldReturn() throws Exception {
- testPointFieldReturn("number_p_d", "double", new String[]{"0.0", "1.2", "2.5", "3.02", "0.43", "5.2", "6.01", "74.0", "80.0", "9.9"});
- testPointFieldReturn("number_p_d_dv_ns", "double", new String[]{"0.0", "1.2", "2.5", "3.02", "0.43", "5.2", "6.01", "74.0", "80.0", "9.9"});
- String[] arr = new String[atLeast(10)];
- for (int i = 0; i < arr.length; i++) {
- double rand = random().nextDouble() * 10;
- arr[i] = String.valueOf(rand);
- }
- testPointFieldReturn("number_p_d", "double", arr);
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ String[] doubles = toStringArray(getRandomDoubles(numValues, false));
+ doTestPointFieldReturn("number_p_d", "double", doubles);
+ doTestPointFieldReturn("number_p_d_dv_ns", "double", doubles);
}
@Test
@@ -383,9 +538,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testDoubleFieldNonSearchableRangeQuery() throws Exception {
- doTestPointFieldNonSearchableRangeQuery("number_p_d_ni", "42.3");
- doTestPointFieldNonSearchableRangeQuery("number_p_d_ni_ns", "42.3");
- doTestPointFieldNonSearchableRangeQuery("number_p_d_ni_ns_mv", "42.3", "-66.6");
+ doTestPointFieldNonSearchableRangeQuery("number_p_d_ni", toStringArray(getRandomDoubles(1, false)));
+ doTestPointFieldNonSearchableRangeQuery("number_p_d_ni_ns", toStringArray(getRandomDoubles(1, false)));
+ int numValues = 2 * RANDOM_MULTIPLIER;
+ doTestPointFieldNonSearchableRangeQuery("number_p_d_ni_ns_mv", toStringArray(getRandomDoubles(numValues, false)));
}
@@ -402,7 +558,7 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, sequential);
doTestPointFieldSort(field, randomDoubles);
- doTestFloatPointFunctionQuery(field, "double");
+ doTestDoublePointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_d_smf", "*_p_d_dv_smf", "*_p_d_ni_dv_smf",
@@ -411,7 +567,7 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, sequential);
doTestPointFieldSort(field, randomDoublesMissing);
- doTestFloatPointFunctionQuery(field, "double");
+ doTestDoublePointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_d_ni", "*_p_d_ni_ns")) {
@@ -438,66 +594,224 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testDoublePointFieldFacetField() throws Exception {
- testPointFieldFacetField("number_p_d", "number_p_d_dv", getSequentialStringArrayWithDoubles(10));
+ doTestPointFieldFacetField("number_p_d", "number_p_d_dv", getSequentialStringArrayWithDoubles(10));
clearIndex();
assertU(commit());
- testPointFieldFacetField("number_p_d", "number_p_d_dv", toStringArray(getRandomDoubles(10, false)));
+ doTestPointFieldFacetField("number_p_d", "number_p_d_dv", toStringArray(getRandomDoubles(10, false)));
}
@Test
public void testDoublePointFieldRangeFacet() throws Exception {
- doTestFloatPointFieldRangeFacet("number_p_d_dv", "number_p_d");
+ String docValuesField = "number_p_d_dv";
+ String nonDocValuesField = "number_p_d";
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ int numBuckets = numValues / 2;
+ List<Double> values, sortedValues;
+ double min, max, gap, buffer;
+ do {
+ values = getRandomDoubles(numValues, false);
+ sortedValues = values.stream().sorted().collect(Collectors.toList());
+ min = sortedValues.get(0);
+ max = sortedValues.get(sortedValues.size() - 1);
+ buffer = BigDecimal.valueOf(max).subtract(BigDecimal.valueOf(min))
+ .divide(BigDecimal.valueOf(numValues / 2), RoundingMode.HALF_UP).doubleValue();
+ gap = BigDecimal.valueOf(max + buffer).subtract(BigDecimal.valueOf(min - buffer))
+ .divide(BigDecimal.valueOf(numBuckets), RoundingMode.HALF_UP).doubleValue();
+ } while (max >= Double.MAX_VALUE - buffer || min <= -Double.MAX_VALUE + buffer);
+ // System.err.println("min: " + min + " max: " + max + " gap: " + gap + " buffer: " + buffer);
+ int[] bucketCount = new int[numBuckets];
+ int bucketNum = 0;
+ double minBucketVal = min - buffer;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ for (double value : sortedValues) {
+ // System.err.println("value: " + value);
+ while (value - minBucketVal >= gap) {
+ ++bucketNum;
+ minBucketVal += gap;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ }
+ ++bucketCount[bucketNum];
+ }
+
+ for (int i = 0 ; i < numValues ; i++) {
+ assertU(adoc("id", String.valueOf(i),
+ docValuesField, String.valueOf(values.get(i)), nonDocValuesField, String.valueOf(values.get(i))));
+ }
+ assertU(commit());
+
+ String[] testStrings = new String[numBuckets + 1];
+ testStrings[numBuckets] = "//*[@numFound='" + numValues + "']";
+ minBucketVal = min - buffer;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + docValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + bucketCount[i] + "']";
+ }
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField, "facet.range.start", String.valueOf(min - buffer),
+ "facet.range.end", String.valueOf(max + buffer), "facet.range.gap", String.valueOf(gap)),
+ testStrings);
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField, "facet.range.start", String.valueOf(min - buffer),
+ "facet.range.end", String.valueOf(max + buffer), "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv"),
+ testStrings);
+
+ minBucketVal = min - buffer;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + nonDocValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + bucketCount[i] + "']";
+ }
+ // Range Faceting with method = filter should work
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField, "facet.range.start", String.valueOf(min - buffer),
+ "facet.range.end", String.valueOf(max + buffer), "facet.range.gap", String.valueOf(gap), "facet.range.method", "filter"),
+ testStrings);
+ // this should actually use filter method instead of dv
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField, "facet.range.start", String.valueOf(min - buffer),
+ "facet.range.end", String.valueOf(max + buffer), "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv"),
+ testStrings);
}
@Test
public void testDoublePointStats() throws Exception {
- testPointStats("number_p_d", "number_p_d_dv", new String[]{"-10.0", "1.1", "2.2", "3.3", "4.4", "5.5", "6.6", "7.7", "8.8", "9.9"},
- -10.0D, 9.9D, "10", "1", 1E-10D);
- testPointStats("number_p_d_mv", "number_p_d_mv_dv", new String[]{"-10.0", "1.1", "2.2", "3.3", "4.4", "5.5", "6.6", "7.7", "8.8", "9.9"},
- -10.0D, 9.9D, "10", "1", 1E-10D);
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ // don't produce numbers with exponents, since XPath comparison operators can't handle them: 7 digits of precision
+ List<Float> values = getRandomInts(numValues, false, 9999999).stream()
+ .map(v -> (float)((double)v * Math.pow(10D, -1 * random().nextInt(8)))).collect(Collectors.toList());
+ // System.err.println(Arrays.toString(values.toArray(new Float[values.size()])));
+ List<Float> sortedValues = values.stream().sorted().collect(Collectors.toList());
+ double min = (double)sortedValues.get(0);
+ double max = (double)sortedValues.get(sortedValues.size() - 1);
+
+ String[] valArray = toStringArray(values);
+ doTestPointStats("number_p_d", "number_p_d_dv", valArray, min, max, numValues, 1, 1E-7D);
+ doTestPointStats("number_p_d", "number_p_d_mv_dv", valArray, min, max, numValues, 1, 1E-7D);
}
@Test
public void testDoublePointFieldMultiValuedExactQuery() throws Exception {
- testPointFieldMultiValuedExactQuery("number_p_d_mv", toStringArray(getRandomDoubles(20, false)));
- testPointFieldMultiValuedExactQuery("number_p_d_ni_mv_dv", toStringArray(getRandomDoubles(20, false)));
+ String[] doubles = toStringArray(getRandomDoubles(20, false));
+ doTestPointFieldMultiValuedExactQuery("number_p_d_mv", doubles);
+ doTestPointFieldMultiValuedExactQuery("number_p_d_ni_mv_dv", doubles);
}
@Test
public void testDoublePointFieldMultiValuedNonSearchableExactQuery() throws Exception {
- testPointFieldMultiValuedExactQuery("number_p_d_ni_mv", toStringArray(getRandomDoubles(20, false)), false);
- testPointFieldMultiValuedExactQuery("number_p_d_ni_ns_mv", toStringArray(getRandomDoubles(20, false)), false);
+ String[] doubles = toStringArray(getRandomDoubles(20, false));
+ doTestPointFieldMultiValuedExactQuery("number_p_d_ni_mv", doubles, false);
+ doTestPointFieldMultiValuedExactQuery("number_p_d_ni_ns_mv", doubles, false);
}
@Test
public void testDoublePointFieldMultiValuedReturn() throws Exception {
- testPointFieldMultiValuedReturn("number_p_d_mv", "double", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedReturn("number_p_d_ni_mv_dv", "double", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedReturn("number_p_d_dv_ns_mv", "double", getSequentialStringArrayWithDoubles(20));
+ String[] doubles = toStringArray(getRandomDoubles(20, false));
+ doTestPointFieldMultiValuedReturn("number_p_d_mv", "double", doubles);
+ doTestPointFieldMultiValuedReturn("number_p_d_ni_mv_dv", "double", doubles);
+ doTestPointFieldMultiValuedReturn("number_p_d_dv_ns_mv", "double", doubles);
}
@Test
public void testDoublePointFieldMultiValuedRangeQuery() throws Exception {
- testPointFieldMultiValuedRangeQuery("number_p_d_mv", "double", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedRangeQuery("number_p_d_ni_mv_dv", "double", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedRangeQuery("number_p_d_mv_dv", "double", getSequentialStringArrayWithDoubles(20));
+ String[] doubles = toStringArray(getRandomDoubles(20, false).stream().sorted().collect(Collectors.toList()));
+ doTestPointFieldMultiValuedRangeQuery("number_p_d_mv", "double", doubles);
+ doTestPointFieldMultiValuedRangeQuery("number_p_d_ni_mv_dv", "double", doubles);
+ doTestPointFieldMultiValuedRangeQuery("number_p_d_mv_dv", "double", doubles);
}
@Test
public void testDoublePointFieldMultiValuedFacetField() throws Exception {
- testPointFieldMultiValuedFacetField("number_p_d_mv", "number_p_d_mv_dv", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedFacetField("number_p_d_mv", "number_p_d_mv_dv", toStringArray(getRandomDoubles(20, false)));
+ doTestPointFieldMultiValuedFacetField("number_p_d_mv", "number_p_d_mv_dv", getSequentialStringArrayWithDoubles(20));
+ doTestPointFieldMultiValuedFacetField("number_p_d_mv", "number_p_d_mv_dv", toStringArray(getRandomDoubles(20, false)));
}
@Test
public void testDoublePointFieldMultiValuedRangeFacet() throws Exception {
- doTestDoublePointFieldMultiValuedRangeFacet("number_p_d_mv_dv", "number_p_d_mv");
+ String docValuesField = "number_p_d_mv_dv";
+ SchemaField dvSchemaField = h.getCore().getLatestSchema().getField(docValuesField);
+ assertTrue(dvSchemaField.multiValued());
+ assertTrue(dvSchemaField.hasDocValues());
+ assertTrue(dvSchemaField.getType() instanceof PointField);
+
+ String nonDocValuesField = "number_p_d_mv";
+ SchemaField nonDvSchemaField = h.getCore().getLatestSchema().getField(nonDocValuesField);
+ assertTrue(nonDvSchemaField.multiValued());
+ assertFalse(nonDvSchemaField.hasDocValues());
+ assertTrue(nonDvSchemaField.getType() instanceof PointField);
+
+ int numValues = 20 * RANDOM_MULTIPLIER;
+ int numBuckets = numValues / 2;
+ List<Double> values;
+ List<PosVal<Double>> sortedValues;
+ double min, max, gap, buffer;
+ do {
+ values = getRandomDoubles(numValues, false);
+ sortedValues = toAscendingPosVals(values, true);
+ min = sortedValues.get(0).val;
+ max = sortedValues.get(sortedValues.size() - 1).val;
+ buffer = BigDecimal.valueOf(max).subtract(BigDecimal.valueOf(min))
+ .divide(BigDecimal.valueOf(numValues / 2), RoundingMode.HALF_UP).doubleValue();
+ gap = BigDecimal.valueOf(max + buffer).subtract(BigDecimal.valueOf(min - buffer))
+ .divide(BigDecimal.valueOf(numBuckets), RoundingMode.HALF_UP).doubleValue();
+ } while (max >= Double.MAX_VALUE - buffer || min <= -Double.MAX_VALUE + buffer);
+ // System.err.println("min: " + min + " max: " + max + " gap: " + gap + " buffer: " + buffer);
+ List<Set<Integer>> docIdBucket = new ArrayList<>(numBuckets);
+ for (int i = 0 ; i < numBuckets ; ++i) {
+ docIdBucket.add(new HashSet<>());
+ }
+ int bucketNum = 0;
+ double minBucketVal = min - buffer;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ for (PosVal<Double> value : sortedValues) {
+ // System.err.println("value.val: " + value.val);
+ while (value.val - minBucketVal >= gap) {
+ ++bucketNum;
+ minBucketVal += gap;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ }
+ docIdBucket.get(bucketNum).add(value.pos / 2); // each doc gets two consecutive values
+ }
+ for (int i = 0 ; i < numValues ; i += 2) {
+ assertU(adoc("id", String.valueOf(i / 2),
+ docValuesField, String.valueOf(values.get(i)),
+ docValuesField, String.valueOf(values.get(i + 1)),
+ nonDocValuesField, String.valueOf(values.get(i)),
+ nonDocValuesField, String.valueOf(values.get(i + 1))));
+ }
+ assertU(commit());
+
+ String[] testStrings = new String[numBuckets + 1];
+ testStrings[numBuckets] = "//*[@numFound='" + (numValues / 2) + "']";
+ minBucketVal = min - buffer;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + docValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + docIdBucket.get(i).size() + "']";
+ }
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField,
+ "facet.range.start", String.valueOf(min - buffer), "facet.range.end", String.valueOf(max + buffer),
+ "facet.range.gap", String.valueOf(gap), "indent", "on"),
+ testStrings);
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField,
+ "facet.range.start", String.valueOf(min - buffer), "facet.range.end", String.valueOf(max + buffer),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv", "indent", "on"),
+ testStrings);
+
+ minBucketVal = min - buffer;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + nonDocValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + docIdBucket.get(i).size() + "']";
+ }
+ // Range Faceting with method = filter should work
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField,
+ "facet.range.start", String.valueOf(min - buffer), "facet.range.end", String.valueOf(max + buffer),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "filter", "indent", "on"),
+ testStrings);
+ // this should actually use filter method instead of dv
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField,
+ "facet.range.start", String.valueOf(min - buffer), "facet.range.end", String.valueOf(max + buffer),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv", "indent", "on"),
+ testStrings);
}
@Test
public void testDoublePointMultiValuedFunctionQuery() throws Exception {
- testPointMultiValuedFunctionQuery("number_p_d_mv", "number_p_d_mv_dv", "double", getSequentialStringArrayWithDoubles(20));
- testPointMultiValuedFunctionQuery("number_p_d_mv", "number_p_d_mv_dv", "double", toAscendingStringArray(getRandomFloats(20, false), true));
+ doTestPointMultiValuedFunctionQuery("number_p_d_mv", "number_p_d_mv_dv", "double", getSequentialStringArrayWithDoubles(20));
+ doTestPointMultiValuedFunctionQuery("number_p_d_mv", "number_p_d_mv_dv", "double", toAscendingStringArray(getRandomFloats(20, false), true));
}
@Test
@@ -505,9 +819,9 @@ public class TestPointFields extends SolrTestCaseJ4 {
if (!Boolean.getBoolean("enable.update.log")) {
return;
}
- doTestFloatPointFieldsAtomicUpdates("number_p_d", "double");
- doTestFloatPointFieldsAtomicUpdates("number_p_d_dv", "double");
- doTestFloatPointFieldsAtomicUpdates("number_p_d_dv_ns", "double");
+ doTestDoublePointFieldsAtomicUpdates("number_p_d");
+ doTestDoublePointFieldsAtomicUpdates("number_p_d_dv");
+ doTestDoublePointFieldsAtomicUpdates("number_p_d_dv_ns");
}
@Test
@@ -515,51 +829,78 @@ public class TestPointFields extends SolrTestCaseJ4 {
if (!Boolean.getBoolean("enable.update.log")) {
return;
}
- testMultiValuedFloatPointFieldsAtomicUpdates("number_p_d_mv", "double");
- testMultiValuedFloatPointFieldsAtomicUpdates("number_p_d_ni_mv_dv", "double");
- testMultiValuedFloatPointFieldsAtomicUpdates("number_p_d_dv_ns_mv", "double");
+ String[] doubles = toStringArray(getRandomDoubles(3, false));
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_d_mv", "double", doubles);
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_d_ni_mv_dv", "double", doubles);
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_d_dv_ns_mv", "double", doubles);
}
@Test
public void testDoublePointFieldNotIndexed() throws Exception {
- doTestFieldNotIndexed("number_p_d_ni", getSequentialStringArrayWithDoubles(10));
- doTestFieldNotIndexed("number_p_d_ni_mv", getSequentialStringArrayWithDoubles(10));
- }
-
-
- private void doTestFloatPointFieldsAtomicUpdates(String field, String type) throws Exception {
- assertU(adoc(sdoc("id", "1", field, "1.1234")));
+ String[] doubles = toStringArray(getRandomDoubles(10, false));
+ doTestFieldNotIndexed("number_p_d_ni", doubles);
+ doTestFieldNotIndexed("number_p_d_ni_mv", doubles);
+ }
+
+
+ private void doTestFloatPointFieldsAtomicUpdates(String field) throws Exception {
+ float number1 = getRandomFloats(1, false).get(0);
+ float number2;
+ double inc1;
+ for ( ; ; ) {
+ number2 = getRandomFloats(1, false).get(0);
+ inc1 = (double)number2 - (double)number1;
+ if (Math.abs(inc1) < (double)Float.MAX_VALUE) {
+ number2 = number1 + (float)inc1;
+ break;
+ }
+ }
+ assertU(adoc(sdoc("id", "1", field, String.valueOf(number1))));
assertU(commit());
- assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("inc", 1.1F))));
+ assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("inc", (float)inc1))));
assertU(commit());
assertQ(req("q", "id:1"),
- "//result/doc[1]/" + type + "[@name='" + field + "'][.='2.2234']");
-
- assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("inc", -1.1F))));
+ "//result/doc[1]/float[@name='" + field + "'][.='" + number2 + "']");
+
+ float number3 = getRandomFloats(1, false).get(0);
+ assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("set", number3))));
assertU(commit());
-
- // TODO: can this test be better?
+
assertQ(req("q", "id:1"),
- "//result/doc[1]/" + type + "[@name='" + field + "'][.>'1.1233']",
- "//result/doc[1]/" + type + "[@name='" + field + "'][.<'1.1235']");
-
- assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("set", 3.123F))));
+ "//result/doc[1]/float[@name='" + field + "'][.='" + number3 + "']");
+ }
+
+ private void doTestDoublePointFieldsAtomicUpdates(String field) throws Exception {
+ double number1 = getRandomDoubles(1, false).get(0);
+ double number2;
+ BigDecimal inc1;
+ for ( ; ; ) {
+ number2 = getRandomDoubles(1, false).get(0);
+ inc1 = BigDecimal.valueOf(number2).subtract(BigDecimal.valueOf(number1));
+ if (inc1.abs().compareTo(BigDecimal.valueOf(Double.MAX_VALUE)) <= 0) {
+ number2 = number1 + inc1.doubleValue();
+ break;
+ }
+ }
+ assertU(adoc(sdoc("id", "1", field, String.valueOf(number1))));
assertU(commit());
-
- assertQ(req("q", "id:1"),
- "//result/doc[1]/" + type + "[@name='" + field + "'][.='3.123']");
-
- assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("set", 3.14F))));
+
+ assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("inc", inc1.doubleValue()))));
assertU(commit());
- assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("inc", 1F))));
+
+ assertQ(req("q", "id:1"),
+ "//result/doc[1]/double[@name='" + field + "'][.='" + number2 + "']");
+
+ double number3 = getRandomDoubles(1, false).get(0);
+ assertU(adoc(sdoc("id", "1", field, ImmutableMap.of("set", number3))));
assertU(commit());
+
assertQ(req("q", "id:1"),
- "//result/doc[1]/" + type + "[@name='" + field + "'][.>'4.13']",
- "//result/doc[1]/" + type + "[@name='" + field + "'][.<'4.15']");
+ "//result/doc[1]/double[@name='" + field + "'][.='" + number3 + "']");
}
-
+
@Test
public void testDoublePointSetQuery() throws Exception {
doTestSetQueries("number_p_d", toStringArray(getRandomDoubles(20, false)), false);
@@ -571,32 +912,28 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testFloatPointFieldExactQuery() throws Exception {
- doTestFloatPointFieldExactQuery("number_p_f");
- doTestFloatPointFieldExactQuery("number_p_f_mv");
- doTestFloatPointFieldExactQuery("number_p_f_dv");
- doTestFloatPointFieldExactQuery("number_p_f_mv_dv");
- doTestFloatPointFieldExactQuery("number_p_f_ni_dv");
- doTestFloatPointFieldExactQuery("number_p_f_ni_ns_dv");
- doTestFloatPointFieldExactQuery("number_p_f_ni_dv_ns");
- doTestFloatPointFieldExactQuery("number_p_f_ni_mv_dv");
+ doTestFloatPointFieldExactQuery("number_p_f", false);
+ doTestFloatPointFieldExactQuery("number_p_f_mv", false);
+ doTestFloatPointFieldExactQuery("number_p_f_dv", false);
+ doTestFloatPointFieldExactQuery("number_p_f_mv_dv", false);
+ doTestFloatPointFieldExactQuery("number_p_f_ni_dv", false);
+ doTestFloatPointFieldExactQuery("number_p_f_ni_ns_dv", false);
+ doTestFloatPointFieldExactQuery("number_p_f_ni_dv_ns", false);
+ doTestFloatPointFieldExactQuery("number_p_f_ni_mv_dv", false);
}
@Test
public void testFloatPointFieldNonSearchableExactQuery() throws Exception {
- doTestFloatPointFieldExactQuery("number_p_f_ni", false);
- doTestFloatPointFieldExactQuery("number_p_f_ni_ns", false);
+ doTestFloatPointFieldExactQuery("number_p_f_ni", false, false);
+ doTestFloatPointFieldExactQuery("number_p_f_ni_ns", false, false);
}
@Test
public void testFloatPointFieldReturn() throws Exception {
- testPointFieldReturn("number_p_f", "float", new String[]{"0.0", "-1.2", "2.5", "3.02", "0.43", "5.2", "6.01", "74.0", "80.0", "9.9"});
- testPointFieldReturn("number_p_f_dv_ns", "float", new String[]{"0.0", "-1.2", "2.5", "3.02", "0.43", "5.2", "6.01", "74.0", "80.0", "9.9"});
- String[] arr = new String[atLeast(10)];
- for (int i = 0; i < arr.length; i++) {
- float rand = random().nextFloat() * 10;
- arr[i] = String.valueOf(rand);
- }
- testPointFieldReturn("number_p_f", "float", arr);
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ String[] floats = toStringArray(getRandomFloats(numValues, false));
+ doTestPointFieldReturn("number_p_f", "float", floats);
+ doTestPointFieldReturn("number_p_f_dv_ns", "float", floats);
}
@Test
@@ -608,9 +945,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testFloatPointFieldNonSearchableRangeQuery() throws Exception {
- doTestPointFieldNonSearchableRangeQuery("number_p_f_ni", "42.3");
- doTestPointFieldNonSearchableRangeQuery("number_p_f_ni_ns", "42.3");
- doTestPointFieldNonSearchableRangeQuery("number_p_f_ni_ns_mv", "42.3", "-66.6");
+ doTestPointFieldNonSearchableRangeQuery("number_p_f_ni", toStringArray(getRandomFloats(1, false)));
+ doTestPointFieldNonSearchableRangeQuery("number_p_f_ni_ns", toStringArray(getRandomFloats(1, false)));
+ int numValues = 2 * RANDOM_MULTIPLIER;
+ doTestPointFieldNonSearchableRangeQuery("number_p_f_ni_ns_mv", toStringArray(getRandomFloats(numValues, false)));
}
@Test
@@ -627,7 +965,7 @@ public class TestPointFields extends SolrTestCaseJ4 {
doTestPointFieldSort(field, sequential);
doTestPointFieldSort(field, randomFloats);
- doTestFloatPointFunctionQuery(field, "float");
+ doTestFloatPointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_f_smf", "*_p_f_dv_smf", "*_p_f_ni_dv_smf",
"*_p_f_sml", "*_p_f_dv_sml", "*_p_f_ni_dv_sml")) {
@@ -635,7 +973,7 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, sequential);
doTestPointFieldSort(field, randomFloatsMissing);
- doTestFloatPointFunctionQuery(field, "float");
+ doTestFloatPointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_f_ni", "*_p_f_ni_ns")) {
@@ -662,66 +1000,228 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testFloatPointFieldFacetField() throws Exception {
- testPointFieldFacetField("number_p_f", "number_p_f_dv", getSequentialStringArrayWithDoubles(10));
+ doTestPointFieldFacetField("number_p_f", "number_p_f_dv", getSequentialStringArrayWithDoubles(10));
clearIndex();
assertU(commit());
- testPointFieldFacetField("number_p_f", "number_p_f_dv", toStringArray(getRandomFloats(10, false)));
+ doTestPointFieldFacetField("number_p_f", "number_p_f_dv", toStringArray(getRandomFloats(10, false)));
}
@Test
public void testFloatPointFieldRangeFacet() throws Exception {
- doTestFloatPointFieldRangeFacet("number_p_f_dv", "number_p_f");
+ String docValuesField = "number_p_f_dv";
+ String nonDocValuesField = "number_p_f";
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ int numBuckets = numValues / 2;
+ List<Float> values, sortedValues;
+ float min, max, gap, buffer;
+ do {
+ values = getRandomFloats(numValues, false);
+ sortedValues = values.stream().sorted().collect(Collectors.toList());
+ min = sortedValues.get(0);
+ max = sortedValues.get(sortedValues.size() - 1);
+ buffer = (float)(((double)max - (double)min) / (double)numValues / 2.0D);
+ gap = (float)(((double)max + (double)buffer - (double)min + (double)buffer) / (double)numBuckets);
+ } while (max >= Float.MAX_VALUE - buffer || min <= -Float.MAX_VALUE + buffer);
+ // System.err.println("min: " + min + " max: " + max + " gap: " + gap + " buffer: " + buffer);
+ int[] bucketCount = new int[numBuckets];
+ int bucketNum = 0;
+ float minBucketVal = min - buffer;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ for (float value : sortedValues) {
+ // System.err.println("value: " + value);
+ while (value - minBucketVal >= gap) {
+ ++bucketNum;
+ minBucketVal += gap;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ }
+ ++bucketCount[bucketNum];
+ }
+
+ for (int i = 0 ; i < numValues ; i++) {
+ assertU(adoc("id", String.valueOf(i),
+ docValuesField, String.valueOf(values.get(i)), nonDocValuesField, String.valueOf(values.get(i))));
+ }
+ assertU(commit());
+
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).getType() instanceof PointField);
+ String[] testStrings = new String[numBuckets + 1];
+ testStrings[numBuckets] = "//*[@numFound='" + numValues + "']";
+ minBucketVal = min - buffer;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + docValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + bucketCount[i] + "']";
+ }
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField, "facet.range.start", String.valueOf(min - buffer),
+ "facet.range.end", String.valueOf(max + buffer), "facet.range.gap", String.valueOf(gap)),
+ testStrings);
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField, "facet.range.start", String.valueOf(min - buffer),
+ "facet.range.end", String.valueOf(max + buffer), "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv"),
+ testStrings);
+
+ assertFalse(h.getCore().getLatestSchema().getField(nonDocValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(nonDocValuesField).getType() instanceof PointField);
+ minBucketVal = min - buffer;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + nonDocValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + bucketCount[i] + "']";
+ }
+ // Range Faceting with method = filter should work
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField, "facet.range.start", String.valueOf(min - buffer),
+ "facet.range.end", String.valueOf(max + buffer), "facet.range.gap", String.valueOf(gap), "facet.range.method", "filter"),
+ testStrings);
+ // this should actually use filter method instead of dv
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField, "facet.range.start", String.valueOf(min - buffer),
+ "facet.range.end", String.valueOf(max + buffer), "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv"),
+ testStrings);
}
@Test
public void testFloatPointStats() throws Exception {
- testPointStats("number_p_f", "number_p_f_dv", new String[]{"-10.0", "1.1", "2.2", "3.3", "4.4", "5.5", "6.6", "7.7", "8.8", "9.9"},
- -10D, 9.9D, "10", "1", 1E-6D);
- testPointStats("number_p_f_mv", "number_p_f_mv_dv", new String[]{"-10.0", "1.1", "2.2", "3.3", "4.4", "5.5", "6.6", "7.7", "8.8", "9.9"},
- -10D, 9.9D, "10", "1", 1E-6D);
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ // don't produce numbers with exponents, since XPath comparison operators can't handle them: 7 digits of precision
+ List<Float> values = getRandomInts(numValues, false, 9999999).stream()
+ .map(v -> (float)((double)v * Math.pow(10D, -1 * random().nextInt(8)))).collect(Collectors.toList());
+ // System.err.println(Arrays.toString(values.toArray(new Float[values.size()])));
+ List<Float> sortedValues = values.stream().sorted().collect(Collectors.toList());
+ double min = (double)sortedValues.get(0);
+ double max = (double)sortedValues.get(sortedValues.size() - 1);
+
+ String[] valArray = toStringArray(values);
+ doTestPointStats("number_p_f", "number_p_f_dv", valArray, min, max, numValues, 1, 1E-7D);
+ doTestPointStats("number_p_f", "number_p_f_mv_dv", valArray, min, max, numValues, 1, 1E-7D);
}
@Test
public void testFloatPointFieldMultiValuedExactQuery() throws Exception {
- testPointFieldMultiValuedExactQuery("number_p_f_mv", toStringArray(getRandomFloats(20, false)));
- testPointFieldMultiValuedExactQuery("number_p_f_ni_mv_dv", toStringArray(getRandomFloats(20, false)));
+ String[] floats = toStringArray(getRandomFloats(20, false));
+ doTestPointFieldMultiValuedExactQuery("number_p_f_mv", floats);
+ doTestPointFieldMultiValuedExactQuery("number_p_f_ni_mv_dv", floats);
}
@Test
public void testFloatPointFieldMultiValuedNonSearchableExactQuery() throws Exception {
- testPointFieldMultiValuedExactQuery("number_p_f_ni_mv", toStringArray(getRandomFloats(20, false)), false);
- testPointFieldMultiValuedExactQuery("number_p_f_ni_ns_mv", toStringArray(getRandomFloats(20, false)), false);
+ String[] floats = toStringArray(getRandomFloats(20, false));
+ doTestPointFieldMultiValuedExactQuery("number_p_f_ni_mv", floats, false);
+ doTestPointFieldMultiValuedExactQuery("number_p_f_ni_ns_mv", floats, false);
}
@Test
public void testFloatPointFieldMultiValuedReturn() throws Exception {
- testPointFieldMultiValuedReturn("number_p_f_mv", "float", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedReturn("number_p_f_ni_mv_dv", "float", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedReturn("number_p_f_dv_ns_mv", "float", getSequentialStringArrayWithDoubles(20));
+ String[] floats = toStringArray(getRandomFloats(20, false));
+ doTestPointFieldMultiValuedReturn("number_p_f_mv", "float", floats);
+ doTestPointFieldMultiValuedReturn("number_p_f_ni_mv_dv", "float", floats);
+ doTestPointFieldMultiValuedReturn("number_p_f_dv_ns_mv", "float", floats);
}
@Test
public void testFloatPointFieldMultiValuedRangeQuery() throws Exception {
- testPointFieldMultiValuedRangeQuery("number_p_f_mv", "float", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedRangeQuery("number_p_f_ni_mv_dv", "float", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedRangeQuery("number_p_f_mv_dv", "float", getSequentialStringArrayWithDoubles(20));
+ String[] floats = toStringArray(getRandomFloats(20, false).stream().sorted().collect(Collectors.toList()));
+ doTestPointFieldMultiValuedRangeQuery("number_p_f_mv", "float", floats);
+ doTestPointFieldMultiValuedRangeQuery("number_p_f_ni_mv_dv", "float", floats);
+ doTestPointFieldMultiValuedRangeQuery("number_p_f_mv_dv", "float", floats);
}
@Test
public void testFloatPointFieldMultiValuedRangeFacet() throws Exception {
- doTestDoublePointFieldMultiValuedRangeFacet("number_p_f_mv_dv", "number_p_f_mv");
+ String docValuesField = "number_p_f_mv_dv";
+ SchemaField dvSchemaField = h.getCore().getLatestSchema().getField(docValuesField);
+ assertTrue(dvSchemaField.multiValued());
+ assertTrue(dvSchemaField.hasDocValues());
+ assertTrue(dvSchemaField.getType() instanceof PointField);
+
+ String nonDocValuesField = "number_p_f_mv";
+ SchemaField nonDvSchemaField = h.getCore().getLatestSchema().getField(nonDocValuesField);
+ assertTrue(nonDvSchemaField.multiValued());
+ assertFalse(nonDvSchemaField.hasDocValues());
+ assertTrue(nonDvSchemaField.getType() instanceof PointField);
+
+ int numValues = 20 * RANDOM_MULTIPLIER;
+ int numBuckets = numValues / 2;
+ List<Float> values;
+ List<PosVal<Float>> sortedValues;
+ float min, max, gap, buffer;
+ do {
+ values = getRandomFloats(numValues, false);
+ sortedValues = toAscendingPosVals(values, true);
+ min = sortedValues.get(0).val;
+ max = sortedValues.get(sortedValues.size() - 1).val;
+ buffer = (float)(((double)max - (double)min) / (double)numValues / 2.0D);
+ gap = (float)(((double)max + (double)buffer - (double)min + (double)buffer) / (double)numBuckets);
+ } while (max >= Float.MAX_VALUE - buffer || min <= -Float.MAX_VALUE + buffer);
+ // System.err.println("min: " + min + " max: " + max + " gap: " + gap + " buffer: " + buffer);
+ List<Set<Integer>> docIdBucket = new ArrayList<>(numBuckets);
+ for (int i = 0 ; i < numBuckets ; ++i) {
+ docIdBucket.add(new HashSet<>());
+ }
+ int bucketNum = 0;
+ float minBucketVal = min - buffer;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ for (PosVal<Float> value : sortedValues) {
+ // System.err.println("value.val: " + value.val);
+ while (value.val - minBucketVal >= gap) {
+ ++bucketNum;
+ minBucketVal += gap;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ }
+ docIdBucket.get(bucketNum).add(value.pos / 2); // each doc gets two consecutive values
+ }
+ for (int i = 0 ; i < numValues ; i += 2) {
+ assertU(adoc("id", String.valueOf(i / 2),
+ docValuesField, String.valueOf(values.get(i)),
+ docValuesField, String.valueOf(values.get(i + 1)),
+ nonDocValuesField, String.valueOf(values.get(i)),
+ nonDocValuesField, String.valueOf(values.get(i + 1))));
+ }
+ assertU(commit());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).getType() instanceof PointField);
+ String[] testStrings = new String[numBuckets + 1];
+ minBucketVal = min - buffer;
+ testStrings[numBuckets] = "//*[@numFound='" + (numValues / 2) + "']";
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + docValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + docIdBucket.get(i).size() + "']";
+ }
+
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField,
+ "facet.range.start", String.valueOf(min - buffer), "facet.range.end", String.valueOf(max + buffer),
+ "facet.range.gap", String.valueOf(gap), "indent", "on"),
+ testStrings);
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField,
+ "facet.range.start", String.valueOf(min - buffer), "facet.range.end", String.valueOf(max + buffer),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv", "indent", "on"),
+ testStrings);
+
+ assertFalse(h.getCore().getLatestSchema().getField(nonDocValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(nonDocValuesField).getType() instanceof PointField);
+ minBucketVal = min - buffer;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + nonDocValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + docIdBucket.get(i).size() + "']";
+ }
+ // Range Faceting with method = filter should work
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField,
+ "facet.range.start", String.valueOf(min - buffer), "facet.range.end", String.valueOf(max + buffer),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "filter", "indent", "on"),
+ testStrings);
+ // this should actually use filter method instead of dv
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField,
+ "facet.range.start", String.valueOf(min - buffer), "facet.range.end", String.valueOf(max + buffer),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv", "indent", "on"),
+ testStrings);
}
@Test
public void testFloatPointFieldMultiValuedFacetField() throws Exception {
- testPointFieldMultiValuedFacetField("number_p_f_mv", "number_p_f_mv_dv", getSequentialStringArrayWithDoubles(20));
- testPointFieldMultiValuedFacetField("number_p_f_mv", "number_p_f_mv_dv", toStringArray(getRandomFloats(20, false)));
+ doTestPointFieldMultiValuedFacetField("number_p_f_mv", "number_p_f_mv_dv", getSequentialStringArrayWithDoubles(20));
+ doTestPointFieldMultiValuedFacetField("number_p_f_mv", "number_p_f_mv_dv", toStringArray(getRandomFloats(20, false)));
}
@Test
public void testFloatPointMultiValuedFunctionQuery() throws Exception {
- testPointMultiValuedFunctionQuery("number_p_f_mv", "number_p_f_mv_dv", "float", getSequentialStringArrayWithDoubles(20));
- testPointMultiValuedFunctionQuery("number_p_f_mv", "number_p_f_mv_dv", "float", toAscendingStringArray(getRandomFloats(20, false), true));
+ doTestPointMultiValuedFunctionQuery("number_p_f_mv", "number_p_f_mv_dv", "float", getSequentialStringArrayWithDoubles(20));
+ doTestPointMultiValuedFunctionQuery("number_p_f_mv", "number_p_f_mv_dv", "float", toAscendingStringArray(getRandomFloats(20, false), true));
}
@@ -730,19 +1230,20 @@ public class TestPointFields extends SolrTestCaseJ4 {
if (!Boolean.getBoolean("enable.update.log")) {
return;
}
- doTestFloatPointFieldsAtomicUpdates("number_p_f", "float");
- doTestFloatPointFieldsAtomicUpdates("number_p_f_dv", "float");
- doTestFloatPointFieldsAtomicUpdates("number_p_f_dv_ns", "float");
+ doTestFloatPointFieldsAtomicUpdates("number_p_f");
+ doTestFloatPointFieldsAtomicUpdates("number_p_f_dv");
+ doTestFloatPointFieldsAtomicUpdates("number_p_f_dv_ns");
}
@Test
- public void testMultiValuedFloatePointFieldsAtomicUpdates() throws Exception {
+ public void testMultiValuedFloatPointFieldsAtomicUpdates() throws Exception {
if (!Boolean.getBoolean("enable.update.log")) {
return;
}
- testMultiValuedFloatPointFieldsAtomicUpdates("number_p_f_mv", "float");
- testMultiValuedFloatPointFieldsAtomicUpdates("number_p_f_ni_mv_dv", "float");
- testMultiValuedFloatPointFieldsAtomicUpdates("number_p_f_dv_ns_mv", "float");
+ String[] floats = toStringArray(getRandomFloats(3, false));
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_f_mv", "float", floats);
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_f_ni_mv_dv", "float", floats);
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_f_dv_ns_mv", "float", floats);
}
@Test
@@ -754,8 +1255,9 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testFloatPointFieldNotIndexed() throws Exception {
- doTestFieldNotIndexed("number_p_f_ni", getSequentialStringArrayWithDoubles(10));
- doTestFieldNotIndexed("number_p_f_ni_mv", getSequentialStringArrayWithDoubles(10));
+ String[] floats = toStringArray(getRandomFloats(10, false));
+ doTestFieldNotIndexed("number_p_f_ni", floats);
+ doTestFieldNotIndexed("number_p_f_ni_mv", floats);
}
// Long
@@ -780,8 +1282,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testLongPointFieldReturn() throws Exception {
- testPointFieldReturn("number_p_l", "long", new String[]{"0", "-1", "2", "3", "43", "52", "-60", "74", "80", "99", String.valueOf(Long.MAX_VALUE)});
- testPointFieldReturn("number_p_l_dv_ns", "long", new String[]{"0", "-1", "2", "3", "43", "52", "-60", "74", "80", "99", String.valueOf(Long.MAX_VALUE)});
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ String[] longs = toStringArray(getRandomLongs(numValues, false));
+ doTestPointFieldReturn("number_p_l", "long", longs);
+ doTestPointFieldReturn("number_p_l_dv_ns", "long", longs);
}
@Test
@@ -793,9 +1297,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testLongPointFieldNonSearchableRangeQuery() throws Exception {
- doTestPointFieldNonSearchableRangeQuery("number_p_l_ni", "3333333333");
- doTestPointFieldNonSearchableRangeQuery("number_p_l_ni_ns", "3333333333");
- doTestPointFieldNonSearchableRangeQuery("number_p_l_ni_ns_mv", "3333333333", "-4444444444");
+ doTestPointFieldNonSearchableRangeQuery("number_p_l_ni", toStringArray(getRandomLongs(1, false)));
+ doTestPointFieldNonSearchableRangeQuery("number_p_l_ni_ns", toStringArray(getRandomLongs(1, false)));
+ int numValues = 2 * RANDOM_MULTIPLIER;
+ doTestPointFieldNonSearchableRangeQuery("number_p_l_ni_ns_mv", toStringArray(getRandomLongs(numValues, false)));
}
@Test
@@ -813,7 +1318,7 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, vals);
doTestPointFieldSort(field, randomLongs);
- doTestIntPointFunctionQuery(field, "long");
+ doTestLongPointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_l_smf", "*_p_l_dv_smf", "*_p_l_ni_dv_smf",
@@ -822,14 +1327,14 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, vals);
doTestPointFieldSort(field, randomLongsMissing);
- doTestIntPointFunctionQuery(field, "long");
+ doTestLongPointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_l_ni", "*_p_l_ni_ns")) {
assertTrue(r, regexToTest.remove(r));
String field = r.replace("*", "number");
- doTestPointFieldSortError(field, "w/o docValues", "4234");
- doTestPointFieldFunctionQueryError(field, "w/o docValues", "4234");
+ doTestPointFieldSortError(field, "w/o docValues", toStringArray(getRandomLongs(1, false)));
+ doTestPointFieldFunctionQueryError(field, "w/o docValues", toStringArray(getRandomLongs(1, false)));
}
for (String r : Arrays.asList("*_p_l_mv", "*_p_l_ni_mv", "*_p_l_ni_mv_dv", "*_p_l_ni_dv_ns_mv",
@@ -838,10 +1343,11 @@ public class TestPointFields extends SolrTestCaseJ4 {
"*_p_l_mv_sml", "*_p_l_mv_dv_sml", "*_p_l_ni_mv_dv_sml")) {
assertTrue(r, regexToTest.remove(r));
String field = r.replace("*", "number");
- doTestPointFieldSortError(field, "multivalued", "4234");
- doTestPointFieldSortError(field, "multivalued", "4234", "66666666");
- doTestPointFieldFunctionQueryError(field, "multivalued", "4234");
- doTestPointFieldFunctionQueryError(field, "multivalued", "4234", "66666666");
+ doTestPointFieldSortError(field, "multivalued", toStringArray(getRandomLongs(1, false)));
+ int numValues = 2 * RANDOM_MULTIPLIER;
+ doTestPointFieldSortError(field, "multivalued", toStringArray(getRandomLongs(numValues, false)));
+ doTestPointFieldFunctionQueryError(field, "multivalued", toStringArray(getRandomLongs(1, false)));
+ doTestPointFieldFunctionQueryError(field, "multivalued", toStringArray(getRandomLongs(numValues, false)));
}
assertEquals("Missing types in the test", Collections.<String>emptySet(), regexToTest);
@@ -849,65 +1355,212 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testLongPointFieldFacetField() throws Exception {
- testPointFieldFacetField("number_p_l", "number_p_l_dv", getSequentialStringArrayWithInts(10));
+ doTestPointFieldFacetField("number_p_l", "number_p_l_dv", getSequentialStringArrayWithInts(10));
clearIndex();
assertU(commit());
- testPointFieldFacetField("number_p_l", "number_p_l_dv", toStringArray(getRandomLongs(10, false)));
+ doTestPointFieldFacetField("number_p_l", "number_p_l_dv", toStringArray(getRandomLongs(10, false)));
}
@Test
public void testLongPointFieldRangeFacet() throws Exception {
- doTestIntPointFieldRangeFacet("number_p_l_dv", "number_p_l");
+ String docValuesField = "number_p_l_dv";
+ String nonDocValuesField = "number_p_l";
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ int numBuckets = numValues / 2;
+ List<Long> values;
+ List<Long> sortedValues;
+ long max;
+ do {
+ values = getRandomLongs(numValues, false);
+ sortedValues = values.stream().sorted().collect(Collectors.toList());
+ } while ((max = sortedValues.get(sortedValues.size() - 1)) >= Long.MAX_VALUE - numValues); // leave room for rounding
+ long min = sortedValues.get(0);
+ BigInteger bigIntGap = BigInteger.valueOf(max + numValues).subtract(BigInteger.valueOf(min))
+ .divide(BigInteger.valueOf(numBuckets));
+ long gap = bigIntGap.longValueExact();
+ int[] bucketCount = new int[numBuckets];
+ int bucketNum = 0;
+ long minBucketVal = min;
+ // System.err.println("min:" + min + " max: " + max + " gap: " + gap);
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ for (Long value : sortedValues) {
+ // System.err.println("value: " + value);
+ while (BigInteger.valueOf(value).subtract(BigInteger.valueOf(minBucketVal)).compareTo(bigIntGap) > 0) {
+ ++bucketNum;
+ minBucketVal += gap;
+ // System.err.println("bucketNum: " + bucketNum + " minBucketVal: " + minBucketVal);
+ }
+ ++bucketCount[bucketNum];
+ }
+
+ for (int i = 0 ; i < numValues ; i++) {
+ assertU(adoc("id", String.valueOf(i), docValuesField, String.valueOf(values.get(i)), nonDocValuesField, String.valueOf(values.get(i))));
+ }
+ assertU(commit());
+
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).getType() instanceof PointField);
+ String[] testStrings = new String[numBuckets + 1];
+ testStrings[numBuckets] = "//*[@numFound='" + numValues + "']";
+ minBucketVal = min;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + docValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + bucketCount[i] + "']";
+ }
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField, "facet.range.start", String.valueOf(min),
+ "facet.range.end", String.valueOf(max), "facet.range.gap", String.valueOf(gap)),
+ testStrings);
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField, "facet.range.start", String.valueOf(min),
+ "facet.range.end", String.valueOf(max), "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv"),
+ testStrings);
+
+ assertFalse(h.getCore().getLatestSchema().getField(nonDocValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(nonDocValuesField).getType() instanceof PointField);
+ minBucketVal = min;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + nonDocValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + bucketCount[i] + "']";
+ }
+ // Range Faceting with method = filter should work
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField, "facet.range.start", String.valueOf(min),
+ "facet.range.end", String.valueOf(max), "facet.range.gap", String.valueOf(gap), "facet.range.method", "filter"),
+ testStrings);
+ // this should actually use filter method instead of dv
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField, "facet.range.start", String.valueOf(min),
+ "facet.range.end", String.valueOf(max), "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv"),
+ testStrings);
}
@Test
public void testLongPointStats() throws Exception {
- testPointStats("number_p_l", "number_p_l_dv", new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
- 0D, 9D, "10", "1", 0D);
- testPointStats("number_p_l_mv", "number_p_l_mv_dv", new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
- 0D, 9D, "10", "1", 0D);
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ // don't produce numbers with exponents, since XPath comparison operators can't handle them
+ List<Long> values = getRandomLongs(numValues, false, 9999999L);
+ List<Long> sortedValues = values.stream().sorted().collect(Collectors.toList());
+ double min = (double)sortedValues.get(0);
+ double max = (double)sortedValues.get(sortedValues.size() - 1);
+
+ String[] valArray = toStringArray(values);
+ doTestPointStats("number_p_l", "number_p_l_dv", valArray, min, max, numValues, 1, 0D);
+ doTestPointStats("number_p_l", "number_p_l_mv_dv", valArray, min, max, numValues, 1, 0D);
}
@Test
public void testLongPointFieldMultiValuedExactQuery() throws Exception {
- testPointFieldMultiValuedExactQuery("number_p_l_mv", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedExactQuery("number_p_l_ni_mv_dv", getSequentialStringArrayWithInts(20));
+ String[] ints = toStringArray(getRandomInts(20, false));
+ doTestPointFieldMultiValuedExactQuery("number_p_l_mv", ints);
+ doTestPointFieldMultiValuedExactQuery("number_p_l_ni_mv_dv", ints);
}
@Test
public void testLongPointFieldMultiValuedNonSearchableExactQuery() throws Exception {
- testPointFieldMultiValuedExactQuery("number_p_l_ni_mv", getSequentialStringArrayWithInts(20), false);
- testPointFieldMultiValuedExactQuery("number_p_l_ni_ns_mv", getSequentialStringArrayWithInts(20), false);
+ String[] longs = toStringArray(getRandomLongs(20, false));
+ doTestPointFieldMultiValuedExactQuery("number_p_l_ni_mv", longs, false);
+ doTestPointFieldMultiValuedExactQuery("number_p_l_ni_ns_mv", longs, false);
}
@Test
public void testLongPointFieldMultiValuedReturn() throws Exception {
- testPointFieldMultiValuedReturn("number_p_l_mv", "long", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedReturn("number_p_l_ni_mv_dv", "long", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedReturn("number_p_l_dv_ns_mv", "long", getSequentialStringArrayWithInts(20));
+ String[] longs = toStringArray(getRandomLongs(20, false));
+ doTestPointFieldMultiValuedReturn("number_p_l_mv", "long", longs);
+ doTestPointFieldMultiValuedReturn("number_p_l_ni_mv_dv", "long", longs);
+ doTestPointFieldMultiValuedReturn("number_p_l_dv_ns_mv", "long", longs);
}
@Test
public void testLongPointFieldMultiValuedRangeQuery() throws Exception {
- testPointFieldMultiValuedRangeQuery("number_p_l_mv", "long", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedRangeQuery("number_p_l_ni_mv_dv", "long", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedRangeQuery("number_p_l_mv_dv", "long", getSequentialStringArrayWithInts(20));
+ String[] longs = toStringArray(getRandomLongs(20, false).stream().sorted().collect(Collectors.toList()));
+ doTestPointFieldMultiValuedRangeQuery("number_p_l_mv", "long", longs);
+ doTestPointFieldMultiValuedRangeQuery("number_p_l_ni_mv_dv", "long", longs);
+ doTestPointFieldMultiValuedRangeQuery("number_p_l_mv_dv", "long", longs);
}
@Test
public void testLongPointFieldMultiValuedFacetField() throws Exception {
- testPointFieldMultiValuedFacetField("number_p_l_mv", "number_p_l_mv_dv", getSequentialStringArrayWithInts(20));
- testPointFieldMultiValuedFacetField("number_p_l_mv", "number_p_l_mv_dv", toStringArray(getRandomLongs(20, false)));
+ doTestPointFieldMultiValuedFacetField("number_p_l_mv", "number_p_l_mv_dv", getSequentialStringArrayWithInts(20));
+ doTestPointFieldMultiValuedFacetField("number_p_l_mv", "number_p_l_mv_dv", toStringArray(getRandomLongs(20, false)));
}
@Test
public void testLongPointFieldMultiValuedRangeFacet() throws Exception {
- doTestIntPointFieldMultiValuedRangeFacet("number_p_l_mv_dv", "number_p_l_mv");
+ String docValuesField = "number_p_l_mv_dv";
+ String nonDocValuesField = "number_p_l_mv";
+ int numValues = 20 * RANDOM_MULTIPLIER;
+ int numBuckets = numValues / 2;
+ List<Long> values;
+ List<PosVal<Long>> sortedValues;
+ long max;
+ do {
+ values = getRandomLongs(numValues, false);
+ sortedValues = toAscendingPosVals(values, true);
+ } while ((max = sortedValues.get(sortedValues.size() - 1).val) >= Long.MAX_VALUE - numValues); // leave room for rounding
+ long min = sortedValues.get(0).val;
+ long gap = BigInteger.valueOf(max + numValues).subtract(BigInteger.valueOf(min))
+ .divide(BigInteger.valueOf(numBuckets)).longValueExact();
+ List<Set<Integer>> docIdBucket = new ArrayList<>(numBuckets);
+ for (int i = 0 ; i < numBuckets ; ++i) {
+ docIdBucket.add(new HashSet<>());
+ }
+ int bucketNum = 0;
+ long minBucketVal = min;
+ for (PosVal<Long> value : sortedValues) {
+ while (value.val - minBucketVal >= gap) {
+ ++bucketNum;
+ minBucketVal += gap;
+ }
+ docIdBucket.get(bucketNum).add(value.pos / 2); // each doc gets two consecutive values
+ }
+ for (int i = 0 ; i < numValues ; i += 2) {
+ assertU(adoc("id", String.valueOf(i / 2),
+ docValuesField, String.valueOf(values.get(i)),
+ docValuesField, String.valueOf(values.get(i + 1)),
+ nonDocValuesField, String.valueOf(values.get(i)),
+ nonDocValuesField, String.valueOf(values.get(i + 1))));
+ }
+ assertU(commit());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(docValuesField).getType() instanceof PointField);
+ String[] testStrings = new String[numBuckets + 1];
+ testStrings[numBuckets] = "//*[@numFound='" + (numValues / 2) + "']";
+ minBucketVal = min;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + docValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + docIdBucket.get(i).size() + "']";
+ }
+
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField,
+ "facet.range.start", String.valueOf(min), "facet.range.end", String.valueOf(max),
+ "facet.range.gap", String.valueOf(gap), "indent", "on"),
+ testStrings);
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", docValuesField,
+ "facet.range.start", String.valueOf(min), "facet.range.end", String.valueOf(max),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv", "indent", "on"),
+ testStrings);
+
+ assertFalse(h.getCore().getLatestSchema().getField(nonDocValuesField).hasDocValues());
+ assertTrue(h.getCore().getLatestSchema().getField(nonDocValuesField).getType() instanceof PointField);
+ minBucketVal = min;
+ for (int i = 0 ; i < numBuckets ; minBucketVal += gap, ++i) {
+ testStrings[i] = "//lst[@name='facet_counts']/lst[@name='facet_ranges']/lst[@name='" + nonDocValuesField
+ + "']/lst[@name='counts']/int[@name='" + minBucketVal + "'][.='" + docIdBucket.get(i).size() + "']";
+ }
+ // Range Faceting with method = filter should work
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField,
+ "facet.range.start", String.valueOf(min), "facet.range.end", String.valueOf(max),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "filter", "indent", "on"),
+ testStrings);
+ // this should actually use filter method instead of dv
+ assertQ(req("q", "*:*", "facet", "true", "facet.range", nonDocValuesField,
+ "facet.range.start", String.valueOf(min), "facet.range.end", String.valueOf(max),
+ "facet.range.gap", String.valueOf(gap), "facet.range.method", "dv", "indent", "on"),
+ testStrings);
}
@Test
public void testLongPointMultiValuedFunctionQuery() throws Exception {
- testPointMultiValuedFunctionQuery("number_p_l_mv", "number_p_l_mv_dv", "long", getSequentialStringArrayWithInts(20));
+ doTestPointMultiValuedFunctionQuery("number_p_l_mv", "number_p_l_mv_dv", "long", getSequentialStringArrayWithInts(20));
+ doTestPointMultiValuedFunctionQuery("number_p_l_mv", "number_p_l_mv_dv", "long",
+ toStringArray(getRandomLongs(20, false).stream().sorted().collect(Collectors.toList())));
}
@Test
@@ -915,9 +1568,9 @@ public class TestPointFields extends SolrTestCaseJ4 {
if (!Boolean.getBoolean("enable.update.log")) {
return;
}
- testIntPointFieldsAtomicUpdates("number_p_l", "long");
- testIntPointFieldsAtomicUpdates("number_p_l_dv", "long");
- testIntPointFieldsAtomicUpdates("number_p_l_dv_ns", "long");
+ doTestLongPointFieldsAtomicUpdates("number_p_l");
+ doTestLongPointFieldsAtomicUpdates("number_p_l_dv");
+ doTestLongPointFieldsAtomicUpdates("number_p_l_dv_ns");
}
@Test
@@ -925,9 +1578,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
if (!Boolean.getBoolean("enable.update.log")) {
return;
}
- testMultiValuedIntPointFieldsAtomicUpdates("number_p_l_mv", "long");
- testMultiValuedIntPointFieldsAtomicUpdates("number_p_l_ni_mv_dv", "long");
- testMultiValuedIntPointFieldsAtomicUpdates("number_p_l_dv_ns_mv", "long");
+ String[] longs = toStringArray(getRandomLongs(3, false));
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_l_mv", "long", longs);
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_l_ni_mv_dv", "long", longs);
+ doTestMultiValuedPointFieldsAtomicUpdates("number_p_l_dv_ns_mv", "long", longs);
}
@Test
@@ -939,21 +1593,31 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testLongPointFieldNotIndexed() throws Exception {
- doTestFieldNotIndexed("number_p_l_ni", getSequentialStringArrayWithInts(10));
- doTestFieldNotIndexed("number_p_l_ni_mv", getSequentialStringArrayWithInts(10));
+ String[] longs = toStringArray(getRandomLongs(10, false));
+ doTestFieldNotIndexed("number_p_l_ni", longs);
+ doTestFieldNotIndexed("number_p_l_ni_mv", longs);
}
// Date
+ private String getRandomDateMaybeWithMath() {
+ long millis1 = random().nextLong() % MAX_DATE_EPOCH_MILLIS;
+ String date = Instant.ofEpochMilli(millis1).toString();
+ if (random().nextBoolean()) {
+ long millis2 = random().nextLong() % MAX_DATE_EPOCH_MILLIS;
+ DateGapCeiling gap = new DateGapCeiling(millis2 - millis1);
+ date += gap.toString();
+ }
+ return date;
+ }
+
@Test
public void testDatePointFieldExactQuery() throws Exception {
- doTestDatePointFieldExactQuery("number_p_dt", "1995-12-31T23:59:59Z");
- doTestDatePointFieldExactQuery("number_p_dt_mv", "2015-12-31T23:59:59Z-1DAY");
- doTestDatePointFieldExactQuery("number_p_dt_dv", "2000-12-31T23:59:59Z+3DAYS");
- doTestDatePointFieldExactQuery("number_p_dt_mv_dv", "2000-12-31T23:59:59Z+3DAYS");
- doTestDatePointFieldExactQuery("number_p_dt_ni_dv", "2000-12-31T23:59:59Z+3DAYS");
- doTestDatePointFieldExactQuery("number_p_dt_ni_ns_dv", "1995-12-31T23:59:59Z-1MONTH");
- doTestDatePointFieldExactQuery("number_p_dt_ni_mv_dv", "1995-12-31T23:59:59Z+2MONTHS");
+ String baseDate = getRandomDateMaybeWithMath();
+ for (String field : Arrays.asList("number_p_dt","number_p_dt_mv","number_p_dt_dv",
+ "number_p_dt_mv_dv", "number_p_dt_ni_dv", "number_p_dt_ni_ns_dv", "number_p_dt_ni_mv_dv")) {
+ doTestDatePointFieldExactQuery(field, baseDate);
+ }
}
@Test
public void testDatePointFieldNonSearchableExactQuery() throws Exception {
@@ -964,12 +1628,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testDatePointFieldReturn() throws Exception {
- testPointFieldReturn("number_p_dt", "date",
- new String[]{"1995-12-31T23:59:59Z", "1994-02-28T23:59:59Z",
- "2015-12-31T23:59:59Z", "2000-10-31T23:59:59Z", "1999-12-31T12:59:59Z"});
- testPointFieldReturn("number_p_dt_dv_ns", "date",
- new String[]{"1995-12-31T23:59:59Z", "1994-02-28T23:59:59Z",
- "2015-12-31T23:59:59Z", "2000-10-31T23:59:59Z", "1999-12-31T12:59:59Z"});
+ int numValues = 10 * RANDOM_MULTIPLIER;
+ String[] dates = toStringArray(getRandomInstants(numValues, false));
+ doTestPointFieldReturn("number_p_dt", "date", dates);
+ doTestPointFieldReturn("number_p_dt_dv_ns", "date", dates);
}
@Test
@@ -980,9 +1642,10 @@ public class TestPointFields extends SolrTestCaseJ4 {
@Test
public void testDatePointFieldNonSearchableRangeQuery() throws Exception {
- doTestPointFieldNonSearchableRangeQuery("number_p_dt_ni", "1995-12-31T23:59:59Z");
- doTestPointFieldNonSearchableRangeQuery("number_p_dt_ni_ns", "1995-12-31T23:59:59Z");
- doTestPointFieldNonSearchableRangeQuery("number_p_dt_ni_ns_mv", "1995-12-31T23:59:59Z", "2000-10-31T23:59:59Z");
+ doTestPointFieldNonSearchableRangeQuery("number_p_dt_ni", toStringArray(getRandomInstants(1, false)));
+ doTestPointFieldNonSearchableRangeQuery("number_p_dt_ni_ns", toStringArray(getRandomInstants(1, false)));
+ int numValues = 2 * RANDOM_MULTIPLIER;
+ doTestPointFieldNonSearchableRangeQuery("number_p_dt_ni_ns_mv", toStringArray(getRandomInstants(numValues, false)));
}
@Test
@@ -998,7 +1661,7 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, sequential);
doTestPointFieldSort(field, randomDates);
- doTestDatePointFunctionQuery(field, "date");
+ doTestDatePointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_dt_smf", "*_p_dt_dv_smf", "*_p_dt_ni_dv_smf",
"*_p_dt_sml", "*_p_dt_dv_sml", "*_p_dt_ni_dv_sml")) {
@@ -1006,7 +1669,7 @@ public class TestPointFields extends SolrTestCaseJ4 {
String field = r.replace("*", "number");
doTestPointFieldSort(field, sequential);
doTestPointFieldSort(field, randomDatesMissing);
- doTestDatePointFunctionQuery(field, "date");
+ doTestDatePointFunctionQuery(field);
}
for (String r : Arrays.asList("*_p_dt_ni", "*_p_dt_ni_ns"))
<TRUNCATED>