recommended cast

Author: limotova

x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/type/DataType.java

@@ -708,6 +708,29 @@ public boolean isDate() {
         };
     }
 
+    public static DataType suggestedCast(Set<DataType> originalTypes) {
+        if (originalTypes.isEmpty() || originalTypes.contains(UNSUPPORTED)) {
+            return null;
+        }
+        if (originalTypes.contains(DATE_NANOS) && originalTypes.contains(DATETIME) && originalTypes.size() == 2) {
+            return DATETIME;
+        }
+        if (originalTypes.contains(AGGREGATE_METRIC_DOUBLE)) {
+            boolean allNumeric = true;
+            for (DataType type : originalTypes) {
+                if (type.isNumeric() == false && type != AGGREGATE_METRIC_DOUBLE) {
+                    allNumeric = false;
+                    break;
+                }
+            }
+            if (allNumeric) {
+                return AGGREGATE_METRIC_DOUBLE;
+            }
+        }
+
+        return KEYWORD;
+    }
+
     /**
      * Named parameters with default values. It's just easier to do this with
      * a builder in java....

x-pack/plugin/esql/qa/server/src/main/java/org/elasticsearch/xpack/esql/qa/rest/FieldExtractorTestCase.java

@@ -32,6 +32,7 @@
 import org.elasticsearch.xcontent.XContentType;
 import org.elasticsearch.xcontent.json.JsonXContent;
 import org.elasticsearch.xpack.esql.action.EsqlCapabilities;
+import org.elasticsearch.xpack.esql.core.type.DataType;
 import org.elasticsearch.xpack.esql.plugin.QueryPragmas;
 import org.hamcrest.Matcher;
 import org.junit.Before;
@@ -45,8 +46,10 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.TreeMap;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import static org.elasticsearch.test.ListMatcher.matchesList;
 import static org.elasticsearch.test.MapMatcher.assertMap;
@@ -690,7 +693,7 @@ public void testByteFieldWithIntSubfieldTooBig() throws IOException {
      * </pre>.
      */
     public void testIncompatibleTypes() throws IOException {
-        assumeOriginalTypesReported();
+        assumeSuggestedCastReported();
         keywordTest().createIndex("test1", "f");
         index("test1", """
             {"f": "f1"}""");
@@ -764,7 +767,7 @@ public void testDistinctInEachIndex() throws IOException {
      * </pre>.
      */
     public void testMergeKeywordAndObject() throws IOException {
-        assumeOriginalTypesReported();
+        assumeSuggestedCastReported();
         keywordTest().createIndex("test1", "file");
         index("test1", """
             {"file": "f1"}""");
@@ -959,7 +962,7 @@ public void testIntegerDocValuesConflict() throws IOException {
      * In an ideal world we'd promote the {@code integer} to an {@code long} and just go.
      */
     public void testLongIntegerConflict() throws IOException {
-        assumeOriginalTypesReported();
+        assumeSuggestedCastReported();
         longTest().sourceMode(SourceMode.DEFAULT).createIndex("test1", "emp_no");
         index("test1", """
             {"emp_no": 1}""");
@@ -1002,7 +1005,7 @@ public void testLongIntegerConflict() throws IOException {
      * In an ideal world we'd promote the {@code short} to an {@code integer} and just go.
      */
     public void testIntegerShortConflict() throws IOException {
-        assumeOriginalTypesReported();
+        assumeSuggestedCastReported();
         intTest().sourceMode(SourceMode.DEFAULT).createIndex("test1", "emp_no");
         index("test1", """
             {"emp_no": 1}""");
@@ -1051,7 +1054,7 @@ public void testIntegerShortConflict() throws IOException {
      * </pre>.
      */
     public void testTypeConflictInObject() throws IOException {
-        assumeOriginalTypesReported();
+        assumeSuggestedCastReported();
         createIndex("test1", empNoInObject("integer"));
         index("test1", """
             {"foo": {"emp_no": 1}}""");
@@ -1379,6 +1382,12 @@ private void assumeOriginalTypesReported() throws IOException {
         assumeTrue("This test makes sense for versions that report original types", requiredClusterCapability);
     }
 
+    private void assumeSuggestedCastReported() throws IOException {
+        var capsName = EsqlCapabilities.Cap.SUGGESTED_CAST.name().toLowerCase(Locale.ROOT);
+        boolean requiredClusterCapability = clusterHasCapability("POST", "/_query", List.of(), List.of(capsName)).orElse(false);
+        assumeTrue("This test makes sense for versions that report suggested casts", requiredClusterCapability);
+    }
+
     private CheckedConsumer<XContentBuilder, IOException> empNoInObject(String empNoType) {
         return index -> {
             index.startObject("properties");
@@ -1715,7 +1724,23 @@ private static Map<String, Object> columnInfo(String name, String type) {
     }
 
     private static Map<String, Object> unsupportedColumnInfo(String name, String... originalTypes) {
-        return Map.of("name", name, "type", "unsupported", "original_types", List.of(originalTypes));
+        DataType suggested = DataType.suggestedCast(
+            List.of(originalTypes).stream().map(DataType::fromTypeName).filter(Objects::nonNull).collect(Collectors.toSet())
+        );
+        if (suggested == null) {
+            return Map.of("name", name, "type", "unsupported", "original_types", List.of(originalTypes));
+        } else {
+            return Map.of(
+                "name",
+                name,
+                "type",
+                "unsupported",
+                "original_types",
+                List.of(originalTypes),
+                "suggested_cast",
+                suggested.typeName()
+            );
+        }
     }
 
     private static void index(String name, String... docs) throws IOException {

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/ColumnInfoImpl.java

@@ -23,6 +23,7 @@
 import java.io.IOException;
 import java.util.List;
 import java.util.Objects;
+import java.util.stream.Collectors;
 
 import static org.elasticsearch.xcontent.ConstructingObjectParser.constructorArg;
 import static org.elasticsearch.xcontent.ConstructingObjectParser.optionalConstructorArg;
@@ -72,6 +73,9 @@ public static ColumnInfo fromXContent(XContentParser parser) {
     @Nullable
     private final List<String> originalTypes;
 
+    @Nullable
+    private final DataType suggestedCast;
+
     @ParserConstructor
     public ColumnInfoImpl(String name, String type, @Nullable List<String> originalTypes) {
         this(name, DataType.fromEs(type), originalTypes);
@@ -81,15 +85,27 @@ public ColumnInfoImpl(String name, DataType type, @Nullable List<String> origina
         this.name = name;
         this.type = type;
         this.originalTypes = originalTypes;
+        this.suggestedCast = calculateSuggestedCast(this.originalTypes);
+    }
+
+    private static DataType calculateSuggestedCast(List<String> originalTypes) {
+        if (originalTypes == null) {
+            return null;
+        }
+        return DataType.suggestedCast(
+            originalTypes.stream().map(DataType::fromTypeName).filter(Objects::nonNull).collect(Collectors.toSet())
+        );
     }
 
     public ColumnInfoImpl(StreamInput in) throws IOException {
         this.name = in.readString();
         this.type = DataType.fromEs(in.readString());
         if (in.getTransportVersion().onOrAfter(TransportVersions.ESQL_REPORT_ORIGINAL_TYPES)) {
             this.originalTypes = in.readOptionalStringCollectionAsList();
+            this.suggestedCast = calculateSuggestedCast(this.originalTypes);
         } else {
             this.originalTypes = null;
+            this.suggestedCast = null;
         }
     }
 
@@ -110,6 +126,9 @@ public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params par
         if (originalTypes != null) {
             builder.field("original_types", originalTypes);
         }
+        if (suggestedCast != null) {
+            builder.field("suggested_cast", suggestedCast.typeName());
+        }
         builder.endObject();
         return builder;
     }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlCapabilities.java

@@ -1038,7 +1038,12 @@ public enum Cap {
         /**
          * Support for the SAMPLE command
          */
-        SAMPLE(Build.current().isSnapshot());
+        SAMPLE(Build.current().isSnapshot()),
+
+        /**
+         * The {@code _query} API now gives a cast recommendation if multiple types are found in certain instances.
+         */
+        SUGGESTED_CAST;
 
         private final boolean enabled;
 

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/type/EsqlDataTypeConverterTests.java

@@ -12,9 +12,14 @@
 import org.elasticsearch.xpack.esql.core.type.DataType;
 
 import java.time.Instant;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
+import static org.elasticsearch.xpack.esql.core.type.DataType.AGGREGATE_METRIC_DOUBLE;
 import static org.elasticsearch.xpack.esql.core.type.DataType.BOOLEAN;
 import static org.elasticsearch.xpack.esql.core.type.DataType.BYTE;
 import static org.elasticsearch.xpack.esql.core.type.DataType.CARTESIAN_POINT;
@@ -47,6 +52,7 @@
 import static org.elasticsearch.xpack.esql.core.type.DataType.isDateTime;
 import static org.elasticsearch.xpack.esql.core.type.DataType.isDateTimeOrNanosOrTemporal;
 import static org.elasticsearch.xpack.esql.core.type.DataType.isString;
+import static org.elasticsearch.xpack.esql.core.type.DataType.suggestedCast;
 import static org.elasticsearch.xpack.esql.type.EsqlDataTypeConverter.commonType;
 
 public class EsqlDataTypeConverterTests extends ESTestCase {
@@ -186,4 +192,33 @@ private static void assertNullCommonType(DataType dataType1, DataType dataType2)
         assertNull("Expected null for " + dataType1 + " and " + dataType2, commonType(dataType1, dataType2));
         assertNull("Expected null for " + dataType1 + " and " + dataType2, commonType(dataType2, dataType1));
     }
+
+    public void testSuggestedCast() {
+        // date
+        {
+            assertEquals(DATETIME, DataType.suggestedCast(Set.of(DATETIME, DATE_NANOS)));
+            DataType randomType = DataType.values()[random().nextInt(DataType.values().length)];
+            DataType suggested = DataType.suggestedCast(Set.of(DATETIME, DATE_NANOS, randomType));
+            if (randomType != DATETIME && randomType != DATE_NANOS) {
+                assertEquals(KEYWORD, suggested);
+            } else {
+                assertEquals(DATETIME, suggested);
+            }
+        }
+
+        // aggregate metric double
+        {
+            List<DataType> NUMERICS = new ArrayList<>(Arrays.stream(DataType.values()).filter(DataType::isNumeric).toList());
+            Collections.shuffle(NUMERICS, random());
+            Set<DataType> subset = new HashSet<>(NUMERICS.subList(0, random().nextInt(NUMERICS.size())));
+            subset.add(AGGREGATE_METRIC_DOUBLE);
+            assertEquals(AGGREGATE_METRIC_DOUBLE, suggestedCast(subset));
+        }
+
+        // unsupported tests
+        {
+            assertNull(DataType.suggestedCast(Set.of()));
+            assertNull(DataType.suggestedCast(Set.of(UNSUPPORTED, DataType.values()[random().nextInt(DataType.values().length)])));
+        }
+    }
 }

x-pack/plugin/src/yamlRestTest/resources/rest-api-spec/test/esql/160_union_types.yml

@@ -905,3 +905,80 @@ CASE:
   - match: { values.2.0: 3 }
   - match: { values.2.1: null }
   - match: { values.2.2: "a" }
+
+---
+suggested_type:
+  - requires:
+      capabilities:
+        - method: POST
+          path: /_query
+          parameters: []
+          capabilities: [recommended_cast]
+      reason: "uses recommended_cast"
+
+  - do:
+      indices.create:
+        index: metrics_1
+        body:
+          mappings:
+            properties:
+              my_metric:
+                type: aggregate_metric_double
+                metrics: [ min, max, sum, value_count ]
+                default_metric: max
+              my_date:
+                type: date
+              my_double:
+                type: double
+              some_other_field:
+                type: geo_point
+  - do:
+      indices.create:
+        index: metrics_2
+        body:
+          mappings:
+            properties:
+              my_metric:
+                type: long
+              my_date:
+                type: date_nanos
+              my_double:
+                type: double
+              some_other_field:
+                type: ip
+
+  - do:
+      bulk:
+        refresh: true
+        body:
+          - { "index" : { "_index": "metrics_1" } }
+          - { "my_metric":  { "min": 1.0, "max": 3.0, "sum": 10.1, "value_count": 5 }, "my_date": "2021-04-28T18:50:04.467Z", "my_double": 105.2, "some_other_field": "52.374081,4.912350" }
+          - { "index" : { "_index": "metrics_2" } }
+          - { "my_metric": 5, "my_date": "2021-04-28T19:34:00.000Z", "my_double": 843205.9, "some_other_field": 192.168.30.1 }
+
+
+  - do:
+      allowed_warnings_regex:
+        - "No limit defined, adding default limit of \\[.*\\]"
+      esql.query:
+        body:
+          query: 'FROM metrics_* | KEEP my_metric, my_date, my_double, some_other_field'
+
+  - match: { columns.0.name: "my_metric" }
+  - match: { columns.0.type: "unsupported" }
+  - match: { columns.0.original_types: ["aggregate_metric_double", "long"] }
+  - match: { columns.0.suggested_cast: "aggregate_metric_double" }
+  - match: { columns.1.name: "my_date" }
+  - match: { columns.1.type: "unsupported" }
+  - match: { columns.1.original_types: ["date_nanos", "datetime"] }
+  - match: { columns.1.suggested_cast: "datetime" }
+  - match: { columns.2.name: "my_double" }
+  - match: { columns.2.type: "double" }
+  - is_false: columns.2.original_types
+  - is_false: columns.2.suggested_cast
+  - match: { columns.3.name: "some_other_field" }
+  - match: { columns.3.type: "unsupported" }
+  - match: { columns.3.original_types: ["geo_point", "ip"] }
+  - match: { columns.3.suggested_cast: "keyword" }
+  - length: { values: 2 }
+