begin wiring up the time series types

Author: not-napoleon

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

@@ -7,6 +7,7 @@
 package org.elasticsearch.xpack.esql.core.type;
 
 import org.elasticsearch.TransportVersions;
+import org.elasticsearch.action.fieldcaps.IndexFieldCapabilities;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.io.stream.Writeable;
@@ -31,10 +32,36 @@ public class EsField implements Writeable {
      * roles within the ESQL query processing pipeline.
      */
     public enum TimeSeriesFieldType implements Writeable {
-        UNKNOWN(0),
-        NONE(1),
-        METRIC(2),
-        DIMENSION(3);
+        UNKNOWN(0) {
+            @Override
+            public TimeSeriesFieldType merge(TimeSeriesFieldType other) {
+                return other;
+            }
+        },
+        NONE(1) {
+            @Override
+            public TimeSeriesFieldType merge(TimeSeriesFieldType other) {
+                return other;
+            }
+        },
+        METRIC(2) {
+            @Override
+            public TimeSeriesFieldType merge(TimeSeriesFieldType other) {
+                if (other != DIMENSION) {
+                    return METRIC;
+                }
+                throw new IllegalStateException("Time Series Metadata conflict.  Cannot merge [" + other + "] with [METRIC].");
+            }
+        },
+        DIMENSION(3) {
+            @Override
+            public TimeSeriesFieldType merge(TimeSeriesFieldType other) {
+                if (other != METRIC) {
+                    return DIMENSION;
+                }
+                throw new IllegalStateException("Time Series Metadata conflict.  Cannot merge [" + other + "] with [DIMENSION].");
+            }
+        };
 
         private final int id;
 
@@ -57,6 +84,18 @@ public static TimeSeriesFieldType readFromStream(StreamInput in) throws IOExcept
                 default -> throw new IOException("Unexpected value for TimeSeriesFieldType: " + id);
             };
         }
+
+        public static TimeSeriesFieldType fromIndexFieldCapabilities(IndexFieldCapabilities capabilities) {
+            if (capabilities.isDimension()) {
+                return DIMENSION;
+            }
+            if (capabilities.metricType() != null) {
+                return METRIC;
+            }
+            return NONE;
+        }
+
+        public abstract TimeSeriesFieldType merge(TimeSeriesFieldType other);
     }
 
     private static Map<String, Reader<? extends EsField>> readers = Map.ofEntries(
@@ -83,7 +122,6 @@ public static Reader<? extends EsField> getReader(String name) {
     private final Map<String, EsField> properties;
     private final String name;
     private final boolean isAlias;
-    // Because the subclasses all reimplement serialization, this needs to be writeable from subclass constructors
     private final TimeSeriesFieldType timeSeriesFieldType;
 
     public EsField(String name, DataType esDataType, Map<String, EsField> properties, boolean aggregatable) {
@@ -247,6 +285,10 @@ public Exact getExactInfo() {
         return Exact.EXACT_FIELD;
     }
 
+    public TimeSeriesFieldType getTimeSeriesFieldType() {
+        return timeSeriesFieldType;
+    }
+
     @Override
     public String toString() {
         return name + "@" + esDataType.typeName() + "=" + properties;

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/Analyzer.java

@@ -294,7 +294,7 @@ private static void mappingAsAttributes(List<Attribute> list, Source source, Str
                 // due to a bug also copy the field since the Attribute hierarchy extracts the data type
                 // directly even if the data type is passed explicitly
                 if (type != t.getDataType()) {
-                    t = new EsField(t.getName(), type, t.getProperties(), t.isAggregatable(), t.isAlias());
+                    t = new EsField(t.getName(), type, t.getProperties(), t.isAggregatable(), t.isAlias(), t.getTimeSeriesFieldType());
                 }
 
                 FieldAttribute attribute = t instanceof UnsupportedEsField uef

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/session/IndexResolver.java

@@ -100,6 +100,7 @@ public static IndexResolution mergedMappings(String indexPattern, FieldCapabilit
             return IndexResolution.notFound(indexPattern);
         }
 
+        // For each field name, store a list of the field caps responses from each index
         Map<String, List<IndexFieldCapabilities>> fieldsCaps = collectFieldCaps(fieldCapsResponse);
 
         // Build hierarchical fields - it's easier to do it in sorted order so the object fields come first.
@@ -121,7 +122,8 @@ public static IndexResolution mergedMappings(String indexPattern, FieldCapabilit
                 String parent = name.substring(0, nextDot);
                 EsField obj = fields.get(parent);
                 if (obj == null) {
-                    obj = new EsField(parent, OBJECT, new HashMap<>(), false, true);
+                    // Object fields can't be dimensions, so we can safely hard code that here
+                    obj = new EsField(parent, OBJECT, new HashMap<>(), false, true, EsField.TimeSeriesFieldType.NONE);
                     isAlias = true;
                     fields.put(parent, obj);
                 } else if (firstUnsupportedParent == null && obj instanceof UnsupportedEsField unsupportedParent) {
@@ -204,11 +206,17 @@ private static EsField createField(
         List<IndexFieldCapabilities> rest = fcs.subList(1, fcs.size());
         DataType type = EsqlDataTypeRegistry.INSTANCE.fromEs(first.type(), first.metricType());
         boolean aggregatable = first.isAggregatable();
+        EsField.TimeSeriesFieldType timeSeriesFieldType = EsField.TimeSeriesFieldType.UNKNOWN;
         if (rest.isEmpty() == false) {
             for (IndexFieldCapabilities fc : rest) {
                 if (first.metricType() != fc.metricType()) {
                     return conflictingMetricTypes(name, fullName, fieldCapsResponse);
                 }
+                try {
+                    timeSeriesFieldType = timeSeriesFieldType.merge(EsField.TimeSeriesFieldType.fromIndexFieldCapabilities(fc));
+                } catch (IllegalArgumentException e) {
+                    return new InvalidMappedField(name, e.getMessage());
+                }
             }
             for (IndexFieldCapabilities fc : rest) {
                 if (type != EsqlDataTypeRegistry.INSTANCE.fromEs(fc.type(), fc.metricType())) {
@@ -223,7 +231,7 @@ private static EsField createField(
         // TODO I think we only care about unmapped fields if we're aggregating on them. do we even then?
 
         if (type == TEXT) {
-            return new TextEsField(name, new HashMap<>(), false, isAlias);
+            return new TextEsField(name, new HashMap<>(), false, isAlias, timeSeriesFieldType);
         }
         if (type == KEYWORD) {
             int length = Short.MAX_VALUE;