in server/src/internalClusterTest/java/org/elasticsearch/search/sort/FieldSortIT.java [498:825]
public void testSimpleSorts() throws Exception {
Random random = random();
assertAcked(
prepareCreate("test").setMapping(
XContentFactory.jsonBuilder()
.startObject()
.startObject("_doc")
.startObject("properties")
.startObject("str_value")
.field("type", "keyword")
.endObject()
.startObject("boolean_value")
.field("type", "boolean")
.endObject()
.startObject("byte_value")
.field("type", "byte")
.endObject()
.startObject("short_value")
.field("type", "short")
.endObject()
.startObject("integer_value")
.field("type", "integer")
.endObject()
.startObject("long_value")
.field("type", "long")
.endObject()
.startObject("float_value")
.field("type", "float")
.endObject()
.startObject("half_float_value")
.field("type", "half_float")
.endObject()
.startObject("double_value")
.field("type", "double")
.endObject()
.endObject()
.endObject()
.endObject()
)
);
ensureGreen();
List<IndexRequestBuilder> builders = new ArrayList<>();
final int numDocs = randomIntBetween(10, 127);
for (int i = 0; i < numDocs; i++) {
IndexRequestBuilder builder = prepareIndex("test").setId(Integer.toString(i))
.setSource(
jsonBuilder().startObject()
.field("str_value", new String(new char[] { (char) (97 + i), (char) (97 + i) }))
.field("boolean_value", true)
.field("byte_value", i)
.field("short_value", i)
.field("integer_value", i)
.field("long_value", i)
.field("float_value", 0.1 * i)
.field("half_float_value", 0.1 * i)
.field("double_value", 0.1 * i)
.endObject()
);
builders.add(builder);
}
Collections.shuffle(builders, random);
for (IndexRequestBuilder builder : builders) {
builder.get();
if (random.nextBoolean()) {
if (random.nextInt(5) != 0) {
refresh();
} else {
indicesAdmin().prepareFlush().get();
}
}
}
refresh();
// STRING
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("str_value", SortOrder.ASC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(
response.getHits().getAt(i).getSortValues()[0].toString(),
equalTo(new String(new char[] { (char) (97 + i), (char) (97 + i) }))
);
}
});
}
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("str_value", SortOrder.DESC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
int expectedValue = numDocs - 1 - i;
SearchHit hit = response.getHits().getAt(i);
assertThat(hit.getId(), equalTo(Integer.toString(expectedValue)));
assertThat(
hit.getSortValues()[0].toString(),
equalTo(new String(new char[] { (char) (97 + expectedValue), (char) (97 + expectedValue) }))
);
}
assertThat(response.toString(), not(containsString("error")));
});
}
// BYTE
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("byte_value", SortOrder.ASC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).byteValue(), equalTo((byte) i));
}
});
}
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("byte_value", SortOrder.DESC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
int expectedValue = numDocs - 1 - i;
SearchHit hit = response.getHits().getAt(i);
assertThat(hit.getId(), equalTo(Integer.toString(expectedValue)));
assertThat(((Number) hit.getSortValues()[0]).byteValue(), equalTo((byte) expectedValue));
}
assertThat(response.toString(), not(containsString("error")));
});
}
// SHORT
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("short_value", SortOrder.ASC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).shortValue(), equalTo((short) i));
}
});
}
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("short_value", SortOrder.DESC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
int expectedValue = numDocs - 1 - i;
SearchHit hit = response.getHits().getAt(i);
assertThat(hit.getId(), equalTo(Integer.toString(expectedValue)));
assertThat(((Number) hit.getSortValues()[0]).shortValue(), equalTo((short) expectedValue));
}
assertThat(response.toString(), not(containsString("error")));
});
}
// INTEGER
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("integer_value", SortOrder.ASC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).intValue(), equalTo(i));
}
assertThat(response.toString(), not(containsString("error")));
});
}
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("integer_value", SortOrder.DESC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
int expectedValue = numDocs - 1 - i;
SearchHit hit = response.getHits().getAt(i);
assertThat(hit.getId(), equalTo(Integer.toString(expectedValue)));
assertThat(((Number) hit.getSortValues()[0]).intValue(), equalTo(expectedValue));
}
assertThat(response.toString(), not(containsString("error")));
});
}
// LONG
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("long_value", SortOrder.ASC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).longValue(), equalTo((long) i));
}
assertThat(response.toString(), not(containsString("error")));
});
}
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("long_value", SortOrder.DESC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
int expectedValue = numDocs - 1 - i;
SearchHit hit = response.getHits().getAt(i);
assertThat(hit.getId(), equalTo(Integer.toString(expectedValue)));
assertThat(((Number) hit.getSortValues()[0]).longValue(), equalTo((long) expectedValue));
}
assertThat(response.toString(), not(containsString("error")));
});
}
// FLOAT
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("float_value", SortOrder.ASC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).doubleValue(), closeTo(0.1d * i, 0.000001d));
}
assertThat(response.toString(), not(containsString("error")));
});
}
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("float_value", SortOrder.DESC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
int expectedValue = numDocs - 1 - i;
SearchHit hit = response.getHits().getAt(i);
assertThat(hit.getId(), equalTo(Integer.toString(expectedValue)));
assertThat(((Number) hit.getSortValues()[0]).doubleValue(), closeTo(0.1d * expectedValue, 0.000001d));
}
assertThat(response.toString(), not(containsString("error")));
});
}
{
// assert correctness of cast floats during sort (using numeric_type); no sort optimization is used
int size = 1 + random.nextInt(numDocs);
FieldSortBuilder sort = SortBuilders.fieldSort("float_value").order(SortOrder.ASC).setNumericType("double");
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort(sort), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).doubleValue(), closeTo(0.1d * i, 0.000001d));
}
assertThat(response.toString(), not(containsString("error")));
});
}
// HALF-FLOAT
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("half_float_value", SortOrder.ASC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).doubleValue(), closeTo(0.1d * i, 0.004d));
}
assertThat(response.toString(), not(containsString("error")));
});
}
{
int size = 1 + random.nextInt(numDocs);
assertResponse(
prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("half_float_value", SortOrder.DESC),
response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
int expectedValue = numDocs - 1 - i;
SearchHit hit = response.getHits().getAt(i);
assertThat(hit.getId(), equalTo(Integer.toString(expectedValue)));
assertThat(((Number) hit.getSortValues()[0]).doubleValue(), closeTo(0.1d * expectedValue, 0.004d));
}
assertThat(response.toString(), not(containsString("error")));
}
);
}
{
// assert correctness of cast half_floats during sort (using numeric_type); no sort optimization is used
int size = 1 + random.nextInt(numDocs);
FieldSortBuilder sort = SortBuilders.fieldSort("half_float_value").order(SortOrder.ASC).setNumericType("double");
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort(sort), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).doubleValue(), closeTo(0.1d * i, 0.004));
}
assertThat(response.toString(), not(containsString("error")));
});
}
// DOUBLE
{
int size = 1 + random.nextInt(numDocs);
assertResponse(prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("double_value", SortOrder.ASC), response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
assertThat(response.getHits().getAt(i).getId(), equalTo(Integer.toString(i)));
assertThat(((Number) response.getHits().getAt(i).getSortValues()[0]).doubleValue(), closeTo(0.1d * i, 0.000001d));
}
assertThat(response.toString(), not(containsString("error")));
});
}
{
int size = 1 + random.nextInt(numDocs);
assertNoFailuresAndResponse(
prepareSearch().setQuery(matchAllQuery()).setSize(size).addSort("double_value", SortOrder.DESC),
response -> {
assertHitCount(response, numDocs);
assertThat(response.getHits().getHits().length, equalTo(size));
for (int i = 0; i < size; i++) {
int expectedValue = numDocs - 1 - i;
SearchHit hit = response.getHits().getAt(i);
assertThat(hit.getId(), equalTo(Integer.toString(expectedValue)));
assertThat(((Number) hit.getSortValues()[0]).doubleValue(), closeTo(0.1d * expectedValue, 0.000001d));
}
}
);
}
}