/** we fake a double test using long2double conversion of NumericUtils */
private void testDoubleRange(int precisionStep) throws Exception {
final String field = "ascfield" + precisionStep;
final long lower = -1000L, upper = +2000L;
Query tq =
NumericRangeQuery.newDoubleRange(
field,
precisionStep,
NumericUtils.sortableLongToDouble(lower),
NumericUtils.sortableLongToDouble(upper),
true,
true);
TopDocs tTopDocs = searcher.search(tq, 1);
assertEquals(
"Returned count of range query must be equal to inclusive range length",
upper - lower + 1,
tTopDocs.totalHits);
Filter tf =
NumericRangeFilter.newDoubleRange(
field,
precisionStep,
NumericUtils.sortableLongToDouble(lower),
NumericUtils.sortableLongToDouble(upper),
true,
true);
tTopDocs = searcher.search(new MatchAllDocsQuery(), tf, 1);
assertEquals(
"Returned count of range filter must be equal to inclusive range length",
upper - lower + 1,
tTopDocs.totalHits);
}
@Override
public Filter getFilter(Element e) throws ParserException {
String field = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
String lowerTerm = DOMUtils.getAttributeOrFail(e, "lowerTerm");
String upperTerm = DOMUtils.getAttributeOrFail(e, "upperTerm");
boolean lowerInclusive = DOMUtils.getAttribute(e, "includeLower", true);
boolean upperInclusive = DOMUtils.getAttribute(e, "includeUpper", true);
int precisionStep =
DOMUtils.getAttribute(e, "precisionStep", NumericUtils.PRECISION_STEP_DEFAULT);
String type = DOMUtils.getAttribute(e, "type", "int");
try {
Filter filter;
if (type.equalsIgnoreCase("int")) {
filter =
NumericRangeFilter.newIntRange(
field,
precisionStep,
Integer.valueOf(lowerTerm),
Integer.valueOf(upperTerm),
lowerInclusive,
upperInclusive);
} else if (type.equalsIgnoreCase("long")) {
filter =
NumericRangeFilter.newLongRange(
field,
precisionStep,
Long.valueOf(lowerTerm),
Long.valueOf(upperTerm),
lowerInclusive,
upperInclusive);
} else if (type.equalsIgnoreCase("double")) {
filter =
NumericRangeFilter.newDoubleRange(
field,
precisionStep,
Double.valueOf(lowerTerm),
Double.valueOf(upperTerm),
lowerInclusive,
upperInclusive);
} else if (type.equalsIgnoreCase("float")) {
filter =
NumericRangeFilter.newFloatRange(
field,
precisionStep,
Float.valueOf(lowerTerm),
Float.valueOf(upperTerm),
lowerInclusive,
upperInclusive);
} else {
throw new ParserException("type attribute must be one of: [long, int, double, float]");
}
return filter;
} catch (NumberFormatException nfe) {
if (strictMode) {
throw new ParserException("Could not parse lowerTerm or upperTerm into a number", nfe);
}
return NO_MATCH_FILTER;
}
}
@Override
public Filter nullValueFilter() {
if (nullValue == null) {
return null;
}
return NumericRangeFilter.newDoubleRange(
names.indexName(), precisionStep, nullValue, nullValue, true, true);
}
@Override
public Filter rangeFilter(
Object lowerTerm,
Object upperTerm,
boolean includeLower,
boolean includeUpper,
@Nullable QueryParseContext context) {
return NumericRangeFilter.newDoubleRange(
names.indexName(),
precisionStep,
lowerTerm == null ? null : parseDoubleValue(lowerTerm),
upperTerm == null ? null : parseDoubleValue(upperTerm),
includeLower,
includeUpper);
}
public Filter rangeFilter(
Double lowerTerm, Double upperTerm, boolean includeLower, boolean includeUpper) {
return NumericRangeFilter.newDoubleRange(
names.indexName(), precisionStep, lowerTerm, upperTerm, includeLower, includeUpper);
}
@Override
public Filter termFilter(Object value, @Nullable QueryParseContext context) {
double dValue = parseDoubleValue(value);
return NumericRangeFilter.newDoubleRange(
names.indexName(), precisionStep, dValue, dValue, true, true);
}
