[9.2] Fix ClassCastException when merging TopHits with mixed sort field types (elastic#141919) (elastic#143068)

* Fix ClassCastException when merging TopHits with mixed sort field types (elastic#141919)

* Fix ClassCastException when merging TopHits with FLOAT/LONG sort types

Fixes ES-14119: Prevents ClassCastException when merging TopHits aggregation
results from different shards with incompatible sort field types (Float vs Long).

Extends SortFieldValidation to handle FLOAT/LONG/DOUBLE mixing by converting
all to DOUBLE, in addition to the existing INT/LONG handling. This ensures
TopDocs can be merged successfully when field mappings differ across shards
during upgrades.

Fix flaky FieldSortIT#testSortMixedFieldTypes by ensuring both index_long
and index_keyword have multiple shards and docs so that merge consistently
sees incompatible sort types (LONG vs STRING) and throws as expected.

Co-authored-by: Cursor <cursoragent@cursor.com>

* Ensure INT/LONG mixes are never converted to DOUBLE (review fix)

Only convert to DOUBLE when the mix involves FLOAT or DOUBLE; make the
condition explicit via involvesFloatingPoint. Add test coverage.

Co-authored-by: Cursor <cursoragent@cursor.com>

* Review fix: clarify comment and exception for multi-index sort type mismatch

Co-authored-by: Cursor <cursoragent@cursor.com>

* [CI] Auto commit changes from spotless

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: elasticsearchmachine <infra-root+elasticsearchmachine@elastic.co>

* Convert missing value to Double when rewriting sort (elastic#141919)

When merging TopHits with mixed numeric sort types we rewrite to DOUBLE
but were passing the original missing value (e.g. Long) to the new
SortField; Lucene requires Double for Type.DOUBLE.

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: elasticsearchmachine <infra-root+elasticsearchmachine@elastic.co>

Author: 3 people

docs/changelog/141919.yaml

@@ -0,0 +1,6 @@
+area: Aggregations
+issues:
+ - 141714
+pr: 141919
+summary: Fix `ClassCastException` when merging `TopHits` with mixed sort field types
+type: bug

server/src/internalClusterTest/java/org/elasticsearch/search/sort/FieldSortIT.java

@@ -2162,17 +2162,20 @@ public void testLongSortOptimizationCorrectResults() {
 
     public void testSortMixedFieldTypes() throws IOException {
         assertAcked(
-            prepareCreate("index_long").setMapping("foo", "type=long"),
+            prepareCreate("index_long").setMapping("foo", "type=long").setSettings(Settings.builder().put("number_of_shards", 2)),
             prepareCreate("index_integer").setMapping("foo", "type=integer"),
             prepareCreate("index_double").setMapping("foo", "type=double"),
-            prepareCreate("index_keyword").setMapping("foo", "type=keyword")
+            prepareCreate("index_keyword").setMapping("foo", "type=keyword").setSettings(Settings.builder().put("number_of_shards", 2))
         );
 
         prepareIndex("index_long").setId("1").setSource("foo", "123").get();
+        prepareIndex("index_long").setId("2").setSource("foo", "124").get();
         prepareIndex("index_integer").setId("1").setSource("foo", "123").get();
         prepareIndex("index_double").setId("1").setSource("foo", "123").get();
         prepareIndex("index_keyword").setId("1").setSource("foo", "123").get();
+        prepareIndex("index_keyword").setId("2").setSource("foo", "124").get();
         refresh();
+        ensureGreen("index_long", "index_keyword");
 
         // for debugging, we try to see where the documents are located
         try (RestClient restClient = createRestClient()) {
@@ -2188,16 +2191,12 @@ public void testSortMixedFieldTypes() throws IOException {
             assertNoFailures(prepareSearch("index_long", "index_integer").addSort(new FieldSortBuilder("foo")).setSize(10));
         }
 
-        String errMsg = "Can't sort on field [foo]; the field has incompatible sort types";
-
-        { // mixing long and double types is not allowed
-            SearchPhaseExecutionException exc = expectThrows(
-                SearchPhaseExecutionException.class,
-                prepareSearch("index_long", "index_double").addSort(new FieldSortBuilder("foo")).setSize(10)
-            );
-            assertThat(exc.getCause().toString(), containsString(errMsg));
+        { // mixing long and double types is ok, as we convert to double sort
+            assertNoFailures(prepareSearch("index_long", "index_double").addSort(new FieldSortBuilder("foo")).setSize(10));
         }
 
+        String errMsg = "Can't sort on field [foo]; the field has incompatible sort types";
+
         { // mixing long and keyword types is not allowed
             SearchPhaseExecutionException exc = expectThrows(
                 SearchPhaseExecutionException.class,

server/src/main/java/org/elasticsearch/search/SearchSortValues.java

@@ -64,6 +64,21 @@ private SearchSortValues(Object[] formattedSortValues, Object[] rawSortValues) {
         this.rawSortValues = rawSortValues;
     }
 
+    /**
+     * Build sort values from pre-formatted and raw arrays. Use this when the formatted values
+     * were produced with the correct per-field format (e.g. from a shard hit) and must not be
+     * re-formatted with a single format like RAW, which would fail for non-UTF-8 BytesRefs
+     * (e.g. version field).
+     */
+    public static SearchSortValues fromFormattedAndRaw(Object[] formattedSortValues, Object[] rawSortValues) {
+        Objects.requireNonNull(formattedSortValues);
+        Objects.requireNonNull(rawSortValues);
+        if (formattedSortValues.length != rawSortValues.length) {
+            throw new IllegalArgumentException("formattedSortValues and rawSortValues must have the same length");
+        }
+        return new SearchSortValues(formattedSortValues, rawSortValues);
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeArray(Lucene::writeSortValue, this.formattedSortValues);

server/src/main/java/org/elasticsearch/search/aggregations/metrics/InternalTopHits.java

@@ -14,13 +14,16 @@
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.search.TopFieldDocs;
 import org.apache.lucene.search.TotalHits.Relation;
+import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.lucene.Lucene;
 import org.elasticsearch.common.lucene.search.TopDocsAndMaxScore;
 import org.elasticsearch.common.xcontent.ChunkedToXContent;
+import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.SearchHit;
 import org.elasticsearch.search.SearchHits;
+import org.elasticsearch.search.SearchSortValues;
 import org.elasticsearch.search.aggregations.AggregationReduceContext;
 import org.elasticsearch.search.aggregations.AggregatorReducer;
 import org.elasticsearch.search.aggregations.InternalAggregation;
@@ -131,7 +134,19 @@ public InternalAggregation get() {
                     shardDocs = new TopFieldDocs[aggregations.size()];
                     maxScore = reduceAndFindMaxScore(aggregations, shardDocs);
                     Sort sort = SortFieldValidation.validateAndMaybeRewrite(Arrays.asList(shardDocs), topFieldDocs.fields);
-                    reducedTopDocs = TopDocs.merge(sort, from, size, (TopFieldDocs[]) shardDocs);
+                    try {
+                        reducedTopDocs = TopDocs.merge(sort, from, size, (TopFieldDocs[]) shardDocs);
+                    } catch (ClassCastException e) {
+                        // This can happen when sort field types are incompatible across shards even after validation,
+                        // e.g. during upgrades or when aggregating across indices with different field mappings.
+                        throw new IllegalArgumentException(
+                            "Failed to merge top_hits aggregation results from different shards due to incompatible "
+                                + "sort field types. This can occur during upgrades or when aggregating across indices "
+                                + "whose field mappings differ. Original error: "
+                                + e.getMessage(),
+                            e
+                        );
+                    }
                 } else {
                     shardDocs = new TopDocs[aggregations.size()];
                     maxScore = reduceAndFindMaxScore(aggregations, shardDocs);
@@ -168,12 +183,44 @@ private static SearchHits extractSearchHits(
             do {
                 position = tracker[shardIndex]++;
             } while (topDocsForShard.scoreDocs[position] != scoreDoc);
-            hits[i] = aggregations.get(shardIndex).searchHits.getAt(position);
+            SearchHit hit = aggregations.get(shardIndex).searchHits.getAt(position);
+            if (scoreDoc instanceof FieldDoc fieldDoc && fieldDoc.fields != null && fieldDoc.fields.length > 0) {
+                Object[] existingFormatted = hit.getSortValues();
+                boolean hasBytesRef = Arrays.stream(fieldDoc.fields).anyMatch(f -> f instanceof BytesRef);
+                if (hasBytesRef && existingFormatted != null && existingFormatted.length == fieldDoc.fields.length) {
+                    // Preserve the shard's formatted values for BytesRef fields (e.g. version, keyword)
+                    // so we don't format them with RAW, which assumes UTF-8 and fails on version encoding.
+                    hit.sortValues(
+                        SearchSortValues.fromFormattedAndRaw(buildFormattedSortValues(fieldDoc.fields, existingFormatted), fieldDoc.fields)
+                    );
+                } else {
+                    DocValueFormat[] formats = new DocValueFormat[fieldDoc.fields.length];
+                    Arrays.fill(formats, DocValueFormat.RAW);
+                    hit.sortValues(fieldDoc.fields, formats);
+                }
+            }
+            hits[i] = hit;
             assert hits[i].isPooled() == false;
         }
         return SearchHits.unpooled(hits, reducedTopDocs.totalHits, maxScore);
     }
 
+    /**
+     * Build formatted sort values: use existing formatted value for BytesRef (e.g. version) fields
+     * to avoid re-formatting with RAW (UTF-8), and use RAW for numeric types.
+     */
+    private static Object[] buildFormattedSortValues(Object[] rawValues, Object[] existingFormatted) {
+        Object[] formatted = new Object[rawValues.length];
+        for (int i = 0; i < rawValues.length; i++) {
+            if (rawValues[i] instanceof BytesRef && existingFormatted != null && i < existingFormatted.length) {
+                formatted[i] = existingFormatted[i];
+            } else {
+                formatted[i] = DocValueFormat.RAW.formatSortValue(rawValues[i]);
+            }
+        }
+        return formatted;
+    }
+
     private static float reduceAndFindMaxScore(List<InternalTopHits> aggregations, TopDocs[] shardDocs) {
         float maxScore = Float.NaN;
         for (int i = 0; i < shardDocs.length; i++) {

server/src/main/java/org/elasticsearch/search/sort/SortFieldValidation.java

@@ -39,6 +39,9 @@ public static Sort validateAndMaybeRewrite(Collection<? extends TopDocs> results
         SortField.Type[] firstTypes = null;
         boolean isFirstResult = true;
         Set<Integer> fieldIdsWithMixedIntAndLongSorts = new HashSet<>();
+        Set<Integer> fieldIdsWithMixedNumericSorts = new HashSet<>();
+        // Track which fields have floating point types to determine if we need DOUBLE conversion
+        Set<Integer> fieldIdsWithFloatingPointTypes = new HashSet<>();
         for (TopDocs topDocs : results) {
             // We don't actually merge in empty score docs, so ignore potentially mismatched types if there are no docs
             if (topDocs == null || topDocs.scoreDocs == null || topDocs.scoreDocs.length == 0) {
@@ -54,6 +57,10 @@ public static Sort validateAndMaybeRewrite(Collection<? extends TopDocs> results
                         // for custom types that we can't resolve, we can't do the check
                         return sort;
                     }
+                    // Track if this field has floating point types
+                    if (firstTypes[i] == SortField.Type.FLOAT || firstTypes[i] == SortField.Type.DOUBLE) {
+                        fieldIdsWithFloatingPointTypes.add(i);
+                    }
                 }
                 isFirstResult = false;
             } else {
@@ -64,26 +71,53 @@ public static Sort validateAndMaybeRewrite(Collection<? extends TopDocs> results
                             // for custom types that we can't resolve, we can't do the check
                             return sort;
                         }
-                        if (mixIntAndLong(firstTypes[i], curType)) {
-                            fieldIdsWithMixedIntAndLongSorts.add(i);
-                        } else {
-                            throw new IllegalArgumentException(
-                                "Can't sort on field ["
-                                    + curSortFields[i].getField()
-                                    + "]; the field has incompatible sort types: ["
-                                    + firstTypes[i]
-                                    + "] and ["
-                                    + curType
-                                    + "] across shards!"
-                            );
+                        // Track if this field has floating point types
+                        if (curType == SortField.Type.FLOAT || curType == SortField.Type.DOUBLE) {
+                            fieldIdsWithFloatingPointTypes.add(i);
                         }
+                        // Check if we are mixing INT and LONG sort types (without floating point)
+                        if (mixIntAndLong(firstTypes[i], curType)) {
+                            // Only add to INT/LONG mixing if there's no floating point type for this field
+                            if (fieldIdsWithFloatingPointTypes.contains(i) == false) {
+                                fieldIdsWithMixedIntAndLongSorts.add(i);
+                            } else {
+                                // If floating point exists, convert everything to DOUBLE
+                                fieldIdsWithMixedNumericSorts.add(i);
+                            }
+                        } else if (isNumericType(firstTypes[i])
+                            && isNumericType(curType)
+                            && involvesFloatingPoint(firstTypes[i], curType)) {
+                                // Only convert to DOUBLE when the mix involves FLOAT or DOUBLE (never pure INT/LONG).
+                                fieldIdsWithMixedNumericSorts.add(i);
+                            } else {
+                                throw new IllegalArgumentException(
+                                    "Can't sort on field ["
+                                        + curSortFields[i].getField()
+                                        + "]; the field has incompatible sort types: ["
+                                        + firstTypes[i]
+                                        + "] and ["
+                                        + curType
+                                        + "] across shards!"
+                                );
+                            }
                     }
                 }
             }
         }
+        // Remove fields from INT/LONG mixing if they also need DOUBLE conversion
+        fieldIdsWithMixedIntAndLongSorts.removeAll(fieldIdsWithMixedNumericSorts);
         if (fieldIdsWithMixedIntAndLongSorts.isEmpty() == false) {
+            // Ensure INT/LONG-only fields are rewritten to LONG, never to DOUBLE
+            for (int fieldIdx : fieldIdsWithMixedIntAndLongSorts) {
+                SortField.Type type = firstTypes[fieldIdx];
+                assert type == SortField.Type.INT || type == SortField.Type.LONG
+                    : "INT/LONG mix must be rewritten to LONG, not DOUBLE; field " + fieldIdx + " had type " + type;
+            }
             sort = rewriteSortAndResultsToLong(sort, results, fieldIdsWithMixedIntAndLongSorts);
         }
+        if (fieldIdsWithMixedNumericSorts.isEmpty() == false) {
+            sort = rewriteSortAndResultsToDouble(sort, results, fieldIdsWithMixedNumericSorts);
+        }
         return sort;
     }
 
@@ -92,6 +126,14 @@ private static boolean mixIntAndLong(SortField.Type firstType, SortField.Type cu
             || (firstType == SortField.Type.LONG && currentType == SortField.Type.INT);
     }
 
+    /**
+     * True when at least one type is FLOAT or DOUBLE. Used to ensure we only add to the
+     * DOUBLE-rewrite set when the mix involves floating point, never for pure INT/LONG.
+     */
+    private static boolean involvesFloatingPoint(SortField.Type a, SortField.Type b) {
+        return (a == SortField.Type.FLOAT || a == SortField.Type.DOUBLE) || (b == SortField.Type.FLOAT || b == SortField.Type.DOUBLE);
+    }
+
     /**
      * Rewrite Sort objects and shards results for long sort for mixed fields:
      * convert Sort to Long sort and convert fields' values to Long values.
@@ -122,6 +164,49 @@ private static Sort rewriteSortAndResultsToLong(
         return new Sort(newSortFields);
     }
 
+    /**
+     * Rewrite Sort objects and shard results for double sort for mixed numeric fields:
+     * convert Sort to Double sort and convert fields' values to Double values.
+     * This handles FLOAT/LONG/DOUBLE mixing by converting all to DOUBLE.
+     */
+    private static Sort rewriteSortAndResultsToDouble(
+        Sort sort,
+        Collection<? extends TopDocs> results,
+        Set<Integer> fieldIdsWithMixedNumericSorts
+    ) {
+        SortField[] newSortFields = sort.getSort();
+        for (int fieldIdx : fieldIdsWithMixedNumericSorts) {
+            // Rewrite the sort field to DOUBLE
+            SortField originalField = newSortFields[fieldIdx];
+            SortField doubleField = new SortField(originalField.getField(), SortField.Type.DOUBLE, originalField.getReverse());
+            Object missingValue = originalField.getMissingValue();
+            if (missingValue != null && missingValue instanceof Number num) {
+                missingValue = num.doubleValue();
+            }
+            doubleField.setMissingValue(missingValue);
+            newSortFields[fieldIdx] = doubleField;
+
+            // Convert all sort values to Double
+            for (TopDocs topDocs : results) {
+                if (topDocs == null || topDocs.scoreDocs == null || topDocs.scoreDocs.length == 0) {
+                    continue;
+                }
+                for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
+                    FieldDoc fieldDoc = (FieldDoc) scoreDoc;
+                    Object value = fieldDoc.fields[fieldIdx];
+                    if (value != null && value instanceof Number) {
+                        fieldDoc.fields[fieldIdx] = ((Number) value).doubleValue();
+                    }
+                }
+            }
+        }
+        return new Sort(newSortFields);
+    }
+
+    private static boolean isNumericType(SortField.Type type) {
+        return type == SortField.Type.INT || type == SortField.Type.LONG || type == SortField.Type.FLOAT || type == SortField.Type.DOUBLE;
+    }
+
     private static SortField.Type getType(SortField sortField) {
         if (sortField instanceof SortedNumericSortField sf) {
             return sf.getNumericType();