github-mirrors/elasticsearch
1
0
Fork 0
mirror of https://github.com/elastic/elasticsearch.git synced 2025-06-27 17:10:22 -04:00
Code Issues Projects Releases Packages Wiki Activity

Revert "Use IndexOrDocValuesQuery in NumberFieldType#termQuery implementations (#128293)" (#129206)

Browse source 
This reverts commit de7c91c1d9.
This commit is contained in:
Ignacio Vera 2025-06-12 10:10:29 +02:00 • committed by GitHub
parent 0702e429f0
commit f02a3c423f
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
10 changed files with 80 additions and 221 deletions
Download patch file Download diff file Expand all files Collapse all files

5
docs/changelog/128293.yaml
View file

@ -1,5 +0,0 @@
pr: 128293
summary: Use `IndexOrDocValuesQuery` in `NumberFieldType#termQuery` implementations
area: Search
type: enhancement
issues: []

2
modules/mapper-extras/src/main/java/org/elasticsearch/index/mapper/extras/ScaledFloatFieldMapper.java
View file

@ -323,7 +323,7 @@ public class ScaledFloatFieldMapper extends FieldMapper {
public Query termQuery(Object value, SearchExecutionContext context) {
failIfNotIndexedNorDocValuesFallback(context);
long scaledValue = Math.round(scale(value));
return NumberFieldMapper.NumberType.LONG.termQuery(name(), scaledValue, isIndexed(), hasDocValues());
return NumberFieldMapper.NumberType.LONG.termQuery(name(), scaledValue, isIndexed());
}
@Override

3
modules/mapper-extras/src/test/java/org/elasticsearch/index/mapper/extras/ScaledFloatFieldTypeTests.java
View file

@ -30,7 +30,6 @@ import org.elasticsearch.index.mapper.FieldTypeTestCase;
import org.elasticsearch.index.mapper.MappedFieldType;
import org.elasticsearch.index.mapper.MapperBuilderContext;
import org.elasticsearch.index.mapper.NumberFieldMapper;
import org.elasticsearch.lucene.document.NumericField;
import java.io.IOException;
import java.util.Arrays;
@ -48,7 +47,7 @@ public class ScaledFloatFieldTypeTests extends FieldTypeTestCase {
);
double value = (randomDouble() * 2 - 1) * 10000;
long scaledValue = Math.round(value * ft.getScalingFactor());
assertEquals(NumericField.newExactLongQuery("scaled_float", scaledValue), ft.termQuery(value, MOCK_CONTEXT));
assertEquals(LongPoint.newExactQuery("scaled_float", scaledValue), ft.termQuery(value, MOCK_CONTEXT));
MappedFieldType ft2 = new ScaledFloatFieldMapper.ScaledFloatFieldType("scaled_float", 0.1 + randomDouble() * 100, false);
ElasticsearchException e2 = expectThrows(ElasticsearchException.class, () -> ft2.termQuery("42", MOCK_CONTEXT_DISALLOW_EXPENSIVE));

51
server/src/main/java/org/elasticsearch/index/mapper/NumberFieldMapper.java
View file

@ -46,7 +46,6 @@ import org.elasticsearch.index.fielddata.plain.SortedDoublesIndexFieldData;
import org.elasticsearch.index.fielddata.plain.SortedNumericIndexFieldData;
import org.elasticsearch.index.mapper.TimeSeriesParams.MetricType;
import org.elasticsearch.index.query.SearchExecutionContext;
import org.elasticsearch.lucene.document.NumericField;
import org.elasticsearch.lucene.search.XIndexSortSortedNumericDocValuesRangeQuery;
import org.elasticsearch.script.DoubleFieldScript;
import org.elasticsearch.script.LongFieldScript;
@ -352,19 +351,13 @@ public class NumberFieldMapper extends FieldMapper {
}
@Override
public Query termQuery(String field, Object value, boolean isIndexed, boolean hasDocValues) {
public Query termQuery(String field, Object value, boolean isIndexed) {
float v = parseToFloat(value);
if (Float.isFinite(HalfFloatPoint.sortableShortToHalfFloat(HalfFloatPoint.halfFloatToSortableShort(v))) == false) {
return Queries.newMatchNoDocsQuery("Value [" + value + "] is out of range");
}
if (isIndexed) {
if (hasDocValues) {
return new IndexOrDocValuesQuery(
HalfFloatPoint.newExactQuery(field, v),
SortedNumericDocValuesField.newSlowExactQuery(field, HalfFloatPoint.halfFloatToSortableShort(v))
);
}
return HalfFloatPoint.newExactQuery(field, v);
} else {
return SortedNumericDocValuesField.newSlowExactQuery(field, HalfFloatPoint.halfFloatToSortableShort(v));
@ -548,15 +541,13 @@ public class NumberFieldMapper extends FieldMapper {
}
@Override
public Query termQuery(String field, Object value, boolean isIndexed, boolean hasDocValues) {
public Query termQuery(String field, Object value, boolean isIndexed) {
float v = parseToFloat(value);
if (Float.isFinite(v) == false) {
return new MatchNoDocsQuery("Value [" + value + "] is out of range");
}
if (isIndexed && hasDocValues) {
return FloatField.newExactQuery(field, v);
} else if (isIndexed) {
if (isIndexed) {
return FloatPoint.newExactQuery(field, v);
} else {
return SortedNumericDocValuesField.newSlowExactQuery(field, NumericUtils.floatToSortableInt(v));
@ -723,15 +714,13 @@ public class NumberFieldMapper extends FieldMapper {
}
@Override
public Query termQuery(String field, Object value, boolean isIndexed, boolean hasDocValues) {
public Query termQuery(String field, Object value, boolean isIndexed) {
double v = objectToDouble(value);
if (Double.isFinite(v) == false) {
return Queries.newMatchNoDocsQuery("Value [" + value + "] has a decimal part");
}
if (isIndexed && hasDocValues) {
return DoubleField.newExactQuery(field, v);
} else if (isIndexed) {
if (isIndexed) {
return DoublePoint.newExactQuery(field, v);
} else {
return SortedNumericDocValuesField.newSlowExactQuery(field, NumericUtils.doubleToSortableLong(v));
@ -885,12 +874,12 @@ public class NumberFieldMapper extends FieldMapper {
}
@Override
public Query termQuery(String field, Object value, boolean isIndexed, boolean hasDocValues) {
public Query termQuery(String field, Object value, boolean isIndexed) {
if (isOutOfRange(value)) {
return new MatchNoDocsQuery("Value [" + value + "] is out of range");
}
return INTEGER.termQuery(field, value, isIndexed, hasDocValues);
return INTEGER.termQuery(field, value, isIndexed);
}
@Override
@ -1009,11 +998,11 @@ public class NumberFieldMapper extends FieldMapper {
}
@Override
public Query termQuery(String field, Object value, boolean isIndexed, boolean hasDocValues) {
public Query termQuery(String field, Object value, boolean isIndexed) {
if (isOutOfRange(value)) {
return Queries.newMatchNoDocsQuery("Value [" + value + "] is out of range");
}
return INTEGER.termQuery(field, value, isIndexed, hasDocValues);
return INTEGER.termQuery(field, value, isIndexed);
}
@Override
@ -1135,7 +1124,7 @@ public class NumberFieldMapper extends FieldMapper {
}
@Override
public Query termQuery(String field, Object value, boolean isIndexed, boolean hasDocValues) {
public Query termQuery(String field, Object value, boolean isIndexed) {
if (hasDecimalPart(value)) {
return Queries.newMatchNoDocsQuery("Value [" + value + "] has a decimal part");
}
@ -1146,9 +1135,7 @@ public class NumberFieldMapper extends FieldMapper {
}
int v = parse(value, true);
if (isIndexed && hasDocValues) {
return NumericField.newExactIntQuery(field, v);
} else if (isIndexed) {
if (isIndexed) {
return IntPoint.newExactQuery(field, v);
} else {
return SortedNumericDocValuesField.newSlowExactQuery(field, v);
@ -1321,7 +1308,7 @@ public class NumberFieldMapper extends FieldMapper {
}
@Override
public Query termQuery(String field, Object value, boolean isIndexed, boolean hasDocValues) {
public Query termQuery(String field, Object value, boolean isIndexed) {
if (hasDecimalPart(value)) {
return Queries.newMatchNoDocsQuery("Value [" + value + "] has a decimal part");
}
@ -1330,9 +1317,7 @@ public class NumberFieldMapper extends FieldMapper {
}
long v = parse(value, true);
if (isIndexed && hasDocValues) {
return NumericField.newExactLongQuery(field, v);
} else if (isIndexed) {
if (isIndexed) {
return LongPoint.newExactQuery(field, v);
} else {
return SortedNumericDocValuesField.newSlowExactQuery(field, v);
@ -1515,7 +1500,7 @@ public class NumberFieldMapper extends FieldMapper {
return parser;
}
public abstract Query termQuery(String field, Object value, boolean isIndexed, boolean hasDocValues);
public abstract Query termQuery(String field, Object value, boolean isIndexed);
public abstract Query termsQuery(String field, Collection<?> values);
@ -1906,11 +1891,11 @@ public class NumberFieldMapper extends FieldMapper {
}
public NumberFieldType(String name, NumberType type) {
this(name, type, true, true);
this(name, type, true);
}
public NumberFieldType(String name, NumberType type, boolean isIndexed, boolean hasDocValues) {
this(name, type, isIndexed, false, hasDocValues, true, null, Collections.emptyMap(), null, false, null, null, false);
public NumberFieldType(String name, NumberType type, boolean isIndexed) {
this(name, type, isIndexed, false, true, true, null, Collections.emptyMap(), null, false, null, null, false);
}
@Override
@ -1949,7 +1934,7 @@ public class NumberFieldMapper extends FieldMapper {
@Override
public Query termQuery(Object value, SearchExecutionContext context) {
failIfNotIndexedNorDocValuesFallback(context);
return type.termQuery(name(), value, isIndexed(), hasDocValues());
return type.termQuery(name(), value, isIndexed());
}
@Override

214
server/src/test/java/org/elasticsearch/index/mapper/NumberFieldTypeTests.java
View file

@ -12,9 +12,7 @@ package org.elasticsearch.index.mapper;
import com.carrotsearch.randomizedtesting.generators.RandomPicks;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.DoubleField;
import org.apache.lucene.document.DoublePoint;
import org.apache.lucene.document.FloatField;
import org.apache.lucene.document.FloatPoint;
import org.apache.lucene.document.IntPoint;
import org.apache.lucene.document.LongPoint;
@ -46,7 +44,6 @@ import org.elasticsearch.index.mapper.NumberFieldMapper.NumberFieldType;
import org.elasticsearch.index.mapper.NumberFieldMapper.NumberType;
import org.elasticsearch.index.query.SearchExecutionContext;
import org.elasticsearch.index.query.SearchExecutionContextHelper;
import org.elasticsearch.lucene.document.NumericField;
import org.elasticsearch.lucene.search.XIndexSortSortedNumericDocValuesRangeQuery;
import org.elasticsearch.script.ScriptCompiler;
import org.elasticsearch.search.MultiValueMode;
@ -60,6 +57,7 @@ import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.Supplier;
@ -110,117 +108,60 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
}
public void testByteTermQueryWithDecimalPart() {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.BYTE, true, true);
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
ft = new NumberFieldMapper.NumberFieldType("field", NumberType.BYTE, true, false);
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
ft = new NumberFieldMapper.NumberFieldType("field", NumberType.BYTE, false, true);
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.BYTE, randomBoolean());
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
}
public void testShortTermQueryWithDecimalPart() {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.SHORT, true, true);
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
ft = new NumberFieldMapper.NumberFieldType("field", NumberType.SHORT, false, true);
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
ft = new NumberFieldMapper.NumberFieldType("field", NumberType.SHORT, true, false);
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.SHORT, randomBoolean());
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
}
public void testIntegerTermQueryWithDecimalPart() {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, true, true);
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
ft = new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, true, false);
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
ft = new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, false, true);
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, randomBoolean());
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
}
public void testLongTermQueryWithDecimalPart() {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, true, true);
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, true, false);
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, false, true);
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, randomBoolean());
assertTrue(ft.termQuery(42.1, MOCK_CONTEXT) instanceof MatchNoDocsQuery);
}
private record TermQueryTestCase(NumberType type, Query[] expectedQueries) {}
private static MappedFieldType unsearchable() {
return new NumberFieldType(
"field",
NumberType.LONG,
false,
false,
false,
true,
null,
Collections.emptyMap(),
null,
false,
null,
null,
false
);
}
public void testTermQuery() {
Query[] expectedIntegerQueries = new Query[] {
NumericField.newExactIntQuery("field", 42),
IntPoint.newExactQuery("field", 42),
SortedNumericDocValuesField.newSlowExactQuery("field", 42) };
List<TermQueryTestCase> testCases = List.of(
new TermQueryTestCase(NumberType.BYTE, expectedIntegerQueries),
new TermQueryTestCase(NumberType.SHORT, expectedIntegerQueries),
new TermQueryTestCase(NumberType.INTEGER, expectedIntegerQueries),
new TermQueryTestCase(
NumberType.LONG,
new Query[] {
NumericField.newExactLongQuery("field", 42),
LongPoint.newExactQuery("field", 42),
SortedNumericDocValuesField.newSlowExactQuery("field", 42) }
),
new TermQueryTestCase(
NumberType.FLOAT,
new Query[] {
FloatField.newExactQuery("field", 42),
FloatPoint.newExactQuery("field", 42),
SortedNumericDocValuesField.newSlowExactQuery("field", NumericUtils.floatToSortableInt(42)) }
),
new TermQueryTestCase(
NumberType.DOUBLE,
new Query[] {
DoubleField.newExactQuery("field", 42),
DoublePoint.newExactQuery("field", 42),
SortedNumericDocValuesField.newSlowExactQuery("field", NumericUtils.doubleToSortableLong(42)) }
),
new TermQueryTestCase(
NumberType.HALF_FLOAT,
new Query[] {
new IndexOrDocValuesQuery(
HalfFloatPoint.newExactQuery("field", 42),
SortedNumericDocValuesField.newSlowExactQuery("field", HalfFloatPoint.halfFloatToSortableShort(42))
),
HalfFloatPoint.newExactQuery("field", 42),
SortedNumericDocValuesField.newSlowExactQuery("field", HalfFloatPoint.halfFloatToSortableShort(42)) }
)
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG);
assertEquals(LongPoint.newExactQuery("field", 42), ft.termQuery("42", MOCK_CONTEXT));
ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, false);
assertEquals(SortedNumericDocValuesField.newSlowExactQuery("field", 42), ft.termQuery("42", MOCK_CONTEXT));
MappedFieldType unsearchable = unsearchable();
IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> unsearchable.termQuery("42", MOCK_CONTEXT));
assertEquals("Cannot search on field [field] since it is not indexed nor has doc values.", e.getMessage());
MappedFieldType ft2 = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, false);
ElasticsearchException e2 = expectThrows(ElasticsearchException.class, () -> ft2.termQuery("42", MOCK_CONTEXT_DISALLOW_EXPENSIVE));
assertEquals(
"Cannot search on field [field] since it is not indexed and 'search.allow_expensive_queries' is set to false.",
e2.getMessage()
);
for (TermQueryTestCase testCase : testCases) {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", testCase.type());
assertEquals(testCase.expectedQueries[0], ft.termQuery("42", MOCK_CONTEXT));
ft = new NumberFieldMapper.NumberFieldType("field", testCase.type(), true, false);
assertEquals(testCase.expectedQueries[1], ft.termQuery("42", MOCK_CONTEXT));
ft = new NumberFieldMapper.NumberFieldType("field", testCase.type(), false, true);
assertEquals(testCase.expectedQueries[2], ft.termQuery("42", MOCK_CONTEXT));
MappedFieldType unsearchable = new NumberFieldMapper.NumberFieldType("field", testCase.type(), false, false);
IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> unsearchable.termQuery("42", MOCK_CONTEXT));
assertEquals("Cannot search on field [field] since it is not indexed nor has doc values.", e.getMessage());
MappedFieldType ft2 = new NumberFieldMapper.NumberFieldType("field", testCase.type(), false, true);
ElasticsearchException e2 = expectThrows(
ElasticsearchException.class,
() -> ft2.termQuery("42", MOCK_CONTEXT_DISALLOW_EXPENSIVE)
);
assertEquals(
"Cannot search on field [field] since it is not indexed and 'search.allow_expensive_queries' is set to false.",
e2.getMessage()
);
}
}
private record OutOfRangeTermQueryTestCase(NumberType type, Object value) {}
@ -260,23 +201,12 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
);
for (OutOfRangeTermQueryTestCase testCase : testCases) {
boolean indexed = randomBoolean();
boolean hasDocValues = indexed == false || randomBoolean();
assertTrue(testCase.type.termQuery("field", testCase.value, indexed, hasDocValues) instanceof MatchNoDocsQuery);
assertTrue(testCase.type.termQuery("field", testCase.value, randomBoolean()) instanceof MatchNoDocsQuery);
}
}
public void testRangeQueryWithNegativeBounds() {
testIntegerRangeQueryWithNegativeBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, true, true));
testIntegerRangeQueryWithNegativeBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, false, true));
testIntegerRangeQueryWithNegativeBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, true, false));
testLongRangeQueryWithNegativeBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.LONG, true, true));
testLongRangeQueryWithNegativeBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.LONG, false, true));
testLongRangeQueryWithNegativeBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.LONG, true, false));
}
private void testIntegerRangeQueryWithNegativeBounds(MappedFieldType ftInt) {
MappedFieldType ftInt = new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, randomBoolean());
assertEquals(
ftInt.rangeQuery(-3, -3, true, true, null, null, null, MOCK_CONTEXT),
ftInt.rangeQuery(-3.5, -2.5, true, true, null, null, null, MOCK_CONTEXT)
@ -326,9 +256,8 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
ftInt.rangeQuery(-2, -1, true, true, null, null, null, MOCK_CONTEXT),
ftInt.rangeQuery(-2.5, -0.5, false, false, null, null, null, MOCK_CONTEXT)
);
}
private void testLongRangeQueryWithNegativeBounds(MappedFieldType ftLong) {
MappedFieldType ftLong = new NumberFieldMapper.NumberFieldType("field", NumberType.LONG, randomBoolean());
assertEquals(
ftLong.rangeQuery(-3, -3, true, true, null, null, null, MOCK_CONTEXT),
ftLong.rangeQuery(-3.5, -2.5, true, true, null, null, null, MOCK_CONTEXT)
@ -381,12 +310,7 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
}
public void testByteRangeQueryWithDecimalParts() {
testByteRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.BYTE, true, true));
testByteRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.BYTE, false, true));
testByteRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.BYTE, true, false));
}
private void testByteRangeQueryWithDecimalParts(MappedFieldType ft) {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.BYTE, randomBoolean());
assertEquals(
ft.rangeQuery(2, 10, true, true, null, null, null, MOCK_CONTEXT),
ft.rangeQuery(1.1, 10, true, true, null, null, null, MOCK_CONTEXT)
@ -406,12 +330,7 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
}
public void testShortRangeQueryWithDecimalParts() {
testShortRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.SHORT, true, true));
testShortRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.SHORT, true, false));
testShortRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.SHORT, false, true));
}
private void testShortRangeQueryWithDecimalParts(MappedFieldType ft) {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.SHORT, randomBoolean());
assertEquals(
ft.rangeQuery(2, 10, true, true, null, null, null, MOCK_CONTEXT),
ft.rangeQuery(1.1, 10, true, true, null, null, null, MOCK_CONTEXT)
@ -431,12 +350,7 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
}
public void testIntegerRangeQueryWithDecimalParts() {
testIntegerRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, true, true));
testIntegerRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, false, true));
testIntegerRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, true, false));
}
private void testIntegerRangeQueryWithDecimalParts(MappedFieldType ft) {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER, randomBoolean());
assertEquals(
ft.rangeQuery(2, 10, true, true, null, null, null, MOCK_CONTEXT),
ft.rangeQuery(1.1, 10, true, true, null, null, null, MOCK_CONTEXT)
@ -456,12 +370,7 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
}
public void testLongRangeQueryWithDecimalParts() {
testLongRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.LONG, true, true));
testLongRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.LONG, false, true));
testLongRangeQueryWithDecimalParts(new NumberFieldMapper.NumberFieldType("field", NumberType.LONG, true, false));
}
private void testLongRangeQueryWithDecimalParts(MappedFieldType ft) {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.LONG, randomBoolean());
assertEquals(
ft.rangeQuery(2, 10, true, true, null, null, null, MOCK_CONTEXT),
ft.rangeQuery(1.1, 10, true, true, null, null, null, MOCK_CONTEXT)
@ -481,12 +390,7 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
}
public void testHalfFloatRangeQueryWithOverflowingBounds() {
testHalfFloatRangeQueryWithOverflowingBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.HALF_FLOAT, true, true));
testHalfFloatRangeQueryWithOverflowingBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.HALF_FLOAT, false, true));
testHalfFloatRangeQueryWithOverflowingBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.HALF_FLOAT, true, false));
}
private void testHalfFloatRangeQueryWithOverflowingBounds(MappedFieldType ft) {
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.HALF_FLOAT, randomBoolean());
final float min_half_float = -65504;
final float max_half_float = 65504;
assertEquals(
@ -531,12 +435,8 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
}
public void testFloatRangeQueryWithOverflowingBounds() {
testFloatRangeQueryWithOverflowingBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.FLOAT, true, true));
testFloatRangeQueryWithOverflowingBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.FLOAT, false, true));
testFloatRangeQueryWithOverflowingBounds(new NumberFieldMapper.NumberFieldType("field", NumberType.FLOAT, true, false));
}
MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.FLOAT, randomBoolean());
private void testFloatRangeQueryWithOverflowingBounds(MappedFieldType ft) {
assertEquals(
ft.rangeQuery(-Float.MAX_VALUE, 10.0, true, true, null, null, null, MOCK_CONTEXT),
ft.rangeQuery(-1e+300, 10.0, true, true, null, null, null, MOCK_CONTEXT)
@ -586,18 +486,18 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
);
assertEquals(expected, ft.rangeQuery("1", "3", true, true, null, null, null, MOCK_CONTEXT));
ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, false, true);
ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, false);
expected = SortedNumericDocValuesField.newSlowRangeQuery("field", 1, 3);
assertEquals(expected, ft.rangeQuery("1", "3", true, true, null, null, null, MOCK_CONTEXT));
MappedFieldType unsearchable = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, false, false);
MappedFieldType unsearchable = unsearchable();
IllegalArgumentException e = expectThrows(
IllegalArgumentException.class,
() -> unsearchable.rangeQuery("1", "3", true, true, null, null, null, MOCK_CONTEXT)
);
assertEquals("Cannot search on field [field] since it is not indexed nor has doc values.", e.getMessage());
MappedFieldType ft2 = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, false, true);
MappedFieldType ft2 = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG, false);
ElasticsearchException e2 = expectThrows(
ElasticsearchException.class,
() -> ft2.rangeQuery("1", "3", true, true, null, null, null, MOCK_CONTEXT_DISALLOW_EXPENSIVE)
@ -738,19 +638,9 @@ public class NumberFieldTypeTests extends FieldTypeTestCase {
NumberType.HALF_FLOAT.rangeQuery("field", null, +0f, true, false, false, MOCK_CONTEXT, isIndexed)
);
final boolean hasDocValues = isIndexed == false || randomBoolean(); // at least one should be true
assertNotEquals(
NumberType.DOUBLE.termQuery("field", -0d, isIndexed, hasDocValues),
NumberType.DOUBLE.termQuery("field", +0d, isIndexed, hasDocValues)
);
assertNotEquals(
NumberType.FLOAT.termQuery("field", -0f, isIndexed, hasDocValues),
NumberType.FLOAT.termQuery("field", +0f, isIndexed, hasDocValues)
);
assertNotEquals(
NumberType.HALF_FLOAT.termQuery("field", -0f, isIndexed, hasDocValues),
NumberType.HALF_FLOAT.termQuery("field", +0f, isIndexed, hasDocValues)
);
assertNotEquals(NumberType.DOUBLE.termQuery("field", -0d, isIndexed), NumberType.DOUBLE.termQuery("field", +0d, isIndexed));
assertNotEquals(NumberType.FLOAT.termQuery("field", -0f, isIndexed), NumberType.FLOAT.termQuery("field", +0f, isIndexed));
assertNotEquals(NumberType.HALF_FLOAT.termQuery("field", -0f, isIndexed), NumberType.HALF_FLOAT.termQuery("field", +0f, isIndexed));
}
// Make sure we construct the IndexOrDocValuesQuery objects with queries that match

2
server/src/test/java/org/elasticsearch/index/query/MatchPhraseQueryBuilderTests.java
View file

@ -20,7 +20,6 @@ import org.apache.lucene.search.TermQuery;
import org.apache.lucene.util.BytesRef;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.core.Strings;
import org.elasticsearch.lucene.search.XIndexSortSortedNumericDocValuesRangeQuery;
import org.elasticsearch.test.AbstractQueryTestCase;
import java.io.IOException;
@ -107,7 +106,6 @@ public class MatchPhraseQueryBuilderTests extends AbstractQueryTestCase<MatchPhr
.or(instanceOf(PointRangeQuery.class))
.or(instanceOf(IndexOrDocValuesQuery.class))
.or(instanceOf(MatchNoDocsQuery.class))
.or(instanceOf(XIndexSortSortedNumericDocValuesRangeQuery.class))
);
}

4
server/src/test/java/org/elasticsearch/index/query/TermQueryBuilderTests.java
View file

@ -12,7 +12,6 @@ package org.elasticsearch.index.query;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.AutomatonQuery;
import org.apache.lucene.search.IndexOrDocValuesQuery;
import org.apache.lucene.search.MatchNoDocsQuery;
import org.apache.lucene.search.PointRangeQuery;
import org.apache.lucene.search.Query;
@ -21,7 +20,6 @@ import org.elasticsearch.common.ParsingException;
import org.elasticsearch.index.mapper.DateFieldMapper;
import org.elasticsearch.index.mapper.FieldTypeTestCase;
import org.elasticsearch.index.mapper.MappedFieldType;
import org.elasticsearch.lucene.search.XIndexSortSortedNumericDocValuesRangeQuery;
import org.elasticsearch.xcontent.json.JsonStringEncoder;
import org.hamcrest.CoreMatchers;
@ -95,8 +93,6 @@ public class TermQueryBuilderTests extends AbstractTermQueryTestCase<TermQueryBu
either(instanceOf(TermQuery.class)).or(instanceOf(PointRangeQuery.class))
.or(instanceOf(MatchNoDocsQuery.class))
.or(instanceOf(AutomatonQuery.class))
.or(instanceOf(IndexOrDocValuesQuery.class))
.or(instanceOf(XIndexSortSortedNumericDocValuesRangeQuery.class))
);
MappedFieldType mapper = context.getFieldType(queryBuilder.fieldName());
if (query instanceof TermQuery termQuery) {

12
x-pack/plugin/analytics/src/test/java/org/elasticsearch/xpack/analytics/ttest/TTestAggregatorTests.java
View file

@ -582,8 +582,8 @@ public class TTestAggregatorTests extends AggregatorTestCase {
public void testFiltered() throws IOException {
TTestType tTestType = randomFrom(TTestType.values());
MappedFieldType fieldType1 = new NumberFieldMapper.NumberFieldType("a", NumberFieldMapper.NumberType.INTEGER, false, true);
MappedFieldType fieldType2 = new NumberFieldMapper.NumberFieldType("b", NumberFieldMapper.NumberType.INTEGER, true, false);
MappedFieldType fieldType1 = new NumberFieldMapper.NumberFieldType("a", NumberFieldMapper.NumberType.INTEGER);
MappedFieldType fieldType2 = new NumberFieldMapper.NumberFieldType("b", NumberFieldMapper.NumberType.INTEGER);
TTestAggregationBuilder aggregationBuilder = new TTestAggregationBuilder("t_test").a(
new MultiValuesSourceFieldConfig.Builder().setFieldName("a").setFilter(QueryBuilders.termQuery("b", 1)).build()
)
@ -638,9 +638,9 @@ public class TTestAggregatorTests extends AggregatorTestCase {
public void testFilteredAsSubAgg() throws IOException {
TTestType tTestType = randomFrom(TTestType.values());
MappedFieldType fieldType1 = new NumberFieldMapper.NumberFieldType("h", NumberFieldMapper.NumberType.INTEGER, false, true);
MappedFieldType fieldType2 = new NumberFieldMapper.NumberFieldType("a", NumberFieldMapper.NumberType.INTEGER, false, true);
MappedFieldType fieldType3 = new NumberFieldMapper.NumberFieldType("b", NumberFieldMapper.NumberType.INTEGER, true, false);
MappedFieldType fieldType1 = new NumberFieldMapper.NumberFieldType("h", NumberFieldMapper.NumberType.INTEGER);
MappedFieldType fieldType2 = new NumberFieldMapper.NumberFieldType("a", NumberFieldMapper.NumberType.INTEGER);
MappedFieldType fieldType3 = new NumberFieldMapper.NumberFieldType("b", NumberFieldMapper.NumberType.INTEGER);
TTestAggregationBuilder ttestAggregationBuilder = new TTestAggregationBuilder("t_test").a(
new MultiValuesSourceFieldConfig.Builder().setFieldName("a").setFilter(QueryBuilders.termQuery("b", 1)).build()
)
@ -711,7 +711,7 @@ public class TTestAggregatorTests extends AggregatorTestCase {
boolean fieldInA = randomBoolean();
TTestType tTestType = randomFrom(TTestType.HOMOSCEDASTIC, TTestType.HETEROSCEDASTIC);
MappedFieldType fieldType1 = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.INTEGER, false, true);
MappedFieldType fieldType1 = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.INTEGER);
MappedFieldType fieldType2 = new NumberFieldMapper.NumberFieldType("term", NumberFieldMapper.NumberType.INTEGER);
boolean filterTermOne = randomBoolean();

5
x-pack/plugin/esql/qa/server/single-node/src/javaRestTest/java/org/elasticsearch/xpack/esql/qa/single_node/PushQueriesIT.java
View file

@ -152,10 +152,7 @@ public class PushQueriesIT extends ESRestTestCase {
* single_value_match is here because there are extra documents hiding in the index
* that don't have the `foo` field.
*/
List.of(
"#foo:[1 TO 1] #single_value_match(foo) #FieldExistsQuery [field=_primary_term]",
"#foo:[1 TO 1] #FieldExistsQuery [field=_primary_term]"
);
List.of("#foo:[1 TO 1] #single_value_match(foo)", "foo:[1 TO 1]");
default -> throw new UnsupportedOperationException("unknown type [" + type + "]");
};
boolean filterInCompute = switch (type) {

3
x-pack/plugin/mapper-aggregate-metric/src/test/java/org/elasticsearch/xpack/aggregatemetric/mapper/AggregateMetricDoubleFieldTypeTests.java
View file

@ -6,7 +6,6 @@
*/
package org.elasticsearch.xpack.aggregatemetric.mapper;
import org.apache.lucene.document.DoubleField;
import org.apache.lucene.document.DoublePoint;
import org.apache.lucene.document.NumericDocValuesField;
import org.apache.lucene.index.DirectoryReader;
@ -66,7 +65,7 @@ public class AggregateMetricDoubleFieldTypeTests extends FieldTypeTestCase {
public void testTermQuery() {
final MappedFieldType fieldType = createDefaultFieldType("foo", Collections.emptyMap(), Metric.max);
Query query = fieldType.termQuery(55.2, MOCK_CONTEXT);
assertThat(query, equalTo(DoubleField.newRangeQuery("foo.max", 55.2, 55.2)));
assertThat(query, equalTo(DoublePoint.newRangeQuery("foo.max", 55.2, 55.2)));
}
public void testTermsQuery() {