SQL: Fix esType for DATETIME/DATE and INTERVALS (#38179)

matriv · matriv · commit 46cca7fe558d · 2019-02-05T23:13:54.000+02:00
Since introduction of data types that don't have a corresponding type in ES the `esType` is error-prone when used for `unmappedType()` calls. Moreover since the renaming of `DATE` to `DATETIME` and the introduction of an actual date-only `DATE` the `esType` would return `datetime` which is not a valid type for ES mapping. Fixes: #38051
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/analysis/analyzer/Analyzer.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/analysis/analyzer/Analyzer.java
@@ -219,7 +219,7 @@ else if (DataTypes.isUnsupported(fa.dataType())) {
             // compound fields
             else if (allowCompound == false && fa.dataType().isPrimitive() == false) {
                 named = u.withUnresolvedMessage(
-                        "Cannot use field [" + fa.name() + "] type [" + fa.dataType().esType + "] only its subfields");
+                        "Cannot use field [" + fa.name() + "] type [" + fa.dataType().typeName + "] only its subfields");
             }
         }
         return named;
@@ -1228,4 +1228,4 @@ protected boolean skipResolved() {
             return true;
         }
     }
-}
+}
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/analysis/analyzer/Verifier.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/analysis/analyzer/Verifier.java
@@ -682,7 +682,7 @@ private static void validateInExpression(LogicalPlan p, Set<Failure> localFailur
                     for (Expression value : in.list()) {
                         if (areTypesCompatible(dt, value.dataType()) == false) {
                             localFailures.add(fail(value, "expected data type [{}], value provided is of type [{}]",
-                                dt.esType, value.dataType().esType));
+                                dt.typeName, value.dataType().typeName));
                             return;
                         }
                     }
@@ -703,7 +703,7 @@ private static void validateConditional(LogicalPlan p, Set<Failure> localFailure
                         } else {
                             if (areTypesCompatible(dt, child.dataType()) == false) {
                                 localFailures.add(fail(child, "expected data type [{}], value provided is of type [{}]",
-                                    dt.esType, child.dataType().esType));
+                                    dt.typeName, child.dataType().typeName));
                                 return;
                             }
                         }
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/execution/search/SourceGenerator.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/execution/search/SourceGenerator.java
@@ -175,4 +175,4 @@ private static void disableSource(SearchSourceBuilder builder) {
             builder.storedFields(NO_STORED_FIELD);
         }
     }
-}
+}
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/execution/search/extractor/FieldHitExtractor.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/execution/search/extractor/FieldHitExtractor.java
@@ -87,7 +87,7 @@ public String getWriteableName() {
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeString(fieldName);
-        out.writeOptionalString(dataType == null ? null : dataType.esType);
+        out.writeOptionalString(dataType == null ? null : dataType.typeName);
         out.writeBoolean(useDocValue);
         out.writeOptionalString(hitName);
     }
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/Expressions.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/Expressions.java
@@ -191,7 +191,7 @@ public static TypeResolution typeMustBe(Expression e,
                 paramOrd == null || paramOrd == ParamOrdinal.DEFAULT ? "" : " " + paramOrd.name().toLowerCase(Locale.ROOT),
                 acceptedTypesForErrorMsg(acceptedTypes),
                 Expressions.name(e),
-                e.dataType().esType));
+                e.dataType().typeName));
     }
 
     private static String acceptedTypesForErrorMsg(String... acceptedTypes) {
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/function/aggregate/TopHits.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/function/aggregate/TopHits.java
@@ -46,7 +46,7 @@ protected TypeResolution resolveType() {
             ((FieldAttribute) field()).exactAttribute();
         } catch (MappingException ex) {
             return new TypeResolution(format(null, "[{}] cannot operate on first argument field of data type [{}]",
-                functionName(), field().dataType().esType));
+                functionName(), field().dataType().typeName));
         }
 
         if (orderField() != null) {
@@ -59,7 +59,7 @@ protected TypeResolution resolveType() {
                 ((FieldAttribute) orderField()).exactAttribute();
             } catch (MappingException ex) {
                 return new TypeResolution(format(null, "[{}] cannot operate on second argument field of data type [{}]",
-                    functionName(), orderField().dataType().esType));
+                    functionName(), orderField().dataType().typeName));
             }
         }
         return TypeResolution.TYPE_RESOLVED;
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/predicate/operator/arithmetic/Sub.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/predicate/operator/arithmetic/Sub.java
@@ -7,8 +7,8 @@
 
 import org.elasticsearch.xpack.sql.expression.Expression;
 import org.elasticsearch.xpack.sql.expression.predicate.operator.arithmetic.BinaryArithmeticProcessor.BinaryArithmeticOperation;
-import org.elasticsearch.xpack.sql.tree.Source;
 import org.elasticsearch.xpack.sql.tree.NodeInfo;
+import org.elasticsearch.xpack.sql.tree.Source;
 import org.elasticsearch.xpack.sql.type.DataTypes;
 
 import static org.elasticsearch.common.logging.LoggerMessageFormat.format;
@@ -36,7 +36,7 @@ protected Sub replaceChildren(Expression newLeft, Expression newRight) {
     protected TypeResolution resolveWithIntervals() {
         if (right().dataType().isDateBased() && DataTypes.isInterval(left().dataType())) {
             return new TypeResolution(format(null, "Cannot subtract a {}[{}] from an interval[{}]; do you mean the reverse?",
-                right().dataType().esType, right().source().text(), left().source().text()));
+                right().dataType().typeName, right().source().text(), left().source().text()));
         }
         return TypeResolution.TYPE_RESOLVED;
     }
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/plan/logical/command/ShowColumns.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/plan/logical/command/ShowColumns.java
@@ -81,7 +81,7 @@ private void fillInRows(Map<String, EsField> mapping, String prefix, List<List<?
             String name = e.getKey();
             if (dt != null) {
                 // show only fields that exist in ES
-                rows.add(asList(prefix != null ? prefix + "." + name : name, dt.sqlName(), dt.esType));
+                rows.add(asList(prefix != null ? prefix + "." + name : name, dt.sqlName(), dt.typeName));
                 if (field.getProperties().isEmpty() == false) {
                     String newPrefix = prefix != null ? prefix + "." + name : name;
                     fillInRows(field.getProperties(), newPrefix, rows);
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysColumns.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysColumns.java
@@ -24,7 +24,6 @@
 import java.sql.DatabaseMetaData;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.regex.Pattern;
@@ -143,7 +142,7 @@ static void fillInRows(String clusterName, String indexName, Map<String, EsField
                             indexName,
                             name,
                             odbcCompatible(type.sqlType.getVendorTypeNumber(), isOdbcClient),
-                            type.esType.toUpperCase(Locale.ROOT),
+                            type.toString(),
                             type.displaySize,
                             // TODO: is the buffer_length correct?
                             type.size,
@@ -208,4 +207,4 @@ public boolean equals(Object obj) {
                 && Objects.equals(pattern, other.pattern)
                 && Objects.equals(columnPattern, other.columnPattern);
     }
-}
+}
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTypes.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTypes.java
@@ -11,15 +11,14 @@
 import org.elasticsearch.xpack.sql.session.Rows;
 import org.elasticsearch.xpack.sql.session.SchemaRowSet;
 import org.elasticsearch.xpack.sql.session.SqlSession;
-import org.elasticsearch.xpack.sql.tree.Source;
 import org.elasticsearch.xpack.sql.tree.NodeInfo;
+import org.elasticsearch.xpack.sql.tree.Source;
 import org.elasticsearch.xpack.sql.type.DataType;
 import org.elasticsearch.xpack.sql.type.DataTypes;
 
 import java.sql.DatabaseMetaData;
 import java.util.Comparator;
 import java.util.List;
-import java.util.Locale;
 import java.util.stream.Stream;
 
 import static java.util.Arrays.asList;
@@ -81,7 +80,7 @@ public final void execute(SqlSession session, ActionListener<SchemaRowSet> liste
         List<List<?>> rows = values
                 // sort by SQL int type (that's what the JDBC/ODBC specs want) followed by name
                 .sorted(Comparator.comparing((DataType t) -> t.sqlType.getVendorTypeNumber()).thenComparing(DataType::sqlName))
-                .map(t -> asList(t.esType.toUpperCase(Locale.ROOT),
+                .map(t -> asList(t.toString(),
                         t.sqlType.getVendorTypeNumber(),
                         //https://docs.microsoft.com/en-us/sql/odbc/reference/appendixes/column-size?view=sql-server-2017
                         t.defaultPrecision,
@@ -132,4 +131,4 @@ public boolean equals(Object obj) {
 
         return type.equals(((SysTypes) obj).type);
     }
-}
+}
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/plugin/TransportSqlQueryAction.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/plugin/TransportSqlQueryAction.java
@@ -88,9 +88,9 @@ static SqlQueryResponse createResponse(SqlQueryRequest request, SchemaRowSet row
         List<ColumnInfo> columns = new ArrayList<>(rowSet.columnCount());
         for (Schema.Entry entry : rowSet.schema()) {
             if (Mode.isDriver(request.mode())) {
-                columns.add(new ColumnInfo("", entry.name(), entry.type().esType, entry.type().displaySize));
+                columns.add(new ColumnInfo("", entry.name(), entry.type().typeName, entry.type().displaySize));
             } else {
-                columns.add(new ColumnInfo("", entry.name(), entry.type().esType));
+                columns.add(new ColumnInfo("", entry.name(), entry.type().typeName));
             }
         }
         columns = unmodifiableList(columns);
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/querydsl/container/TopHitsAggRef.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/querydsl/container/TopHitsAggRef.java
@@ -33,6 +33,6 @@ public DataType fieldDataType() {
 
     @Override
     public String toString() {
-        return ">" + name + "[" + fieldDataType.esType + "]";
+        return ">" + name + "[" + fieldDataType.typeName + "]";
     }
 }
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/type/DataType.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/type/DataType.java
@@ -23,41 +23,41 @@
 public enum DataType {
 
     // @formatter:off
-    //                     jdbc type,          size,              defPrecision,dispSize, int,   rat,   docvals
-    NULL(                  JDBCType.NULL,      0,                 0,                 0,  false, false, false),
-    UNSUPPORTED(           JDBCType.OTHER,     0,                 0,                 0,  false, false, false),
-    BOOLEAN(               JDBCType.BOOLEAN,   1,                 1,                 1,  false, false, false),
-    BYTE(                  JDBCType.TINYINT,   Byte.BYTES,        3,                 5,  true,  false, true),
-    SHORT(                 JDBCType.SMALLINT,  Short.BYTES,       5,                 6,  true,  false, true),
-    INTEGER(               JDBCType.INTEGER,   Integer.BYTES,     10,                11, true,  false, true),
-    LONG(                  JDBCType.BIGINT,    Long.BYTES,        19,                20, true,  false, true),
+    //             esType            jdbc type,          size,              defPrecision,dispSize, int,   rat,   docvals
+    NULL(          "null",           JDBCType.NULL,      0,                 0,                 0,  false, false, false),
+    UNSUPPORTED(                     JDBCType.OTHER,     0,                 0,                 0,  false, false, false),
+    BOOLEAN(       "boolean",        JDBCType.BOOLEAN,   1,                 1,                 1,  false, false, false),
+    BYTE(          "byte",           JDBCType.TINYINT,   Byte.BYTES,        3,                 5,  true,  false, true),
+    SHORT(         "short",          JDBCType.SMALLINT,  Short.BYTES,       5,                 6,  true,  false, true),
+    INTEGER(       "integer",        JDBCType.INTEGER,   Integer.BYTES,     10,                11, true,  false, true),
+    LONG(          "long",           JDBCType.BIGINT,    Long.BYTES,        19,                20, true,  false, true),
     // 53 bits defaultPrecision ~ 15(15.95) decimal digits (53log10(2)),
-    DOUBLE(                JDBCType.DOUBLE,    Double.BYTES,      15,                25, false, true,  true),
+    DOUBLE(        "double",         JDBCType.DOUBLE,    Double.BYTES,      15,                25, false, true,  true),
     // 24 bits defaultPrecision - 24*log10(2) =~ 7 (7.22)
-    FLOAT(                 JDBCType.REAL,      Float.BYTES,       7,                 15, false, true,  true),
-    HALF_FLOAT(            JDBCType.FLOAT,     Double.BYTES,      16,                25, false, true,  true),
+    FLOAT(         "float",          JDBCType.REAL,      Float.BYTES,       7,                 15, false, true,  true),
+    HALF_FLOAT(    "half_float",     JDBCType.FLOAT,     Double.BYTES,      16,                25, false, true,  true),
     // precision is based on long
-    SCALED_FLOAT(          JDBCType.FLOAT,     Double.BYTES,      19,                25, false, true,  true),
-    KEYWORD(               JDBCType.VARCHAR,   Integer.MAX_VALUE, 256,               0,  false, false, true),
-    TEXT(                  JDBCType.VARCHAR,   Integer.MAX_VALUE, Integer.MAX_VALUE, 0,  false, false, false),
-    OBJECT(                JDBCType.STRUCT,    -1,                0,                 0,  false, false, false),
-    NESTED(                JDBCType.STRUCT,    -1,                0,                 0,  false, false, false),
-    BINARY(                JDBCType.VARBINARY, -1,                Integer.MAX_VALUE, 0,  false, false, false),
-    DATE(                  JDBCType.DATE,      Long.BYTES,        10,                10, false, false, true),
+    SCALED_FLOAT(  "scaled_float",   JDBCType.FLOAT,     Double.BYTES,      19,                25, false, true,  true),
+    KEYWORD(       "keyword",        JDBCType.VARCHAR,   Integer.MAX_VALUE, 256,               0,  false, false, true),
+    TEXT(          "text",           JDBCType.VARCHAR,   Integer.MAX_VALUE, Integer.MAX_VALUE, 0,  false, false, false),
+    OBJECT(        "object",         JDBCType.STRUCT,    -1,                0,                 0,  false, false, false),
+    NESTED(        "nested",         JDBCType.STRUCT,    -1,                0,                 0,  false, false, false),
+    BINARY(        "binary",         JDBCType.VARBINARY, -1,                Integer.MAX_VALUE, 0,  false, false, false),
+    DATE(                            JDBCType.DATE,      Long.BYTES,        10,                10, false, false, true),
     // since ODBC and JDBC interpret precision for Date as display size
     // the precision is 23 (number of chars in ISO8601 with millis) + Z (the UTC timezone)
     // see https://github.com/elastic/elasticsearch/issues/30386#issuecomment-386807288
-    DATETIME(              JDBCType.TIMESTAMP, Long.BYTES,        24,                24, false, false, true),
+    DATETIME(      "date",           JDBCType.TIMESTAMP, Long.BYTES,        24,                24, false, false, true),
     //
     // specialized types
     //
     // IP can be v4 or v6. The latter has 2^128 addresses or 340,282,366,920,938,463,463,374,607,431,768,211,456
     // aka 39 chars
-    IP(                    JDBCType.VARCHAR,   39,               39,                 0,  false, false, true),
+    IP(            "ip",             JDBCType.VARCHAR,   39,               39,                 0,  false, false, true),
     //
     // INTERVALS
     // the list is long as there are a lot of variations and that's what clients (ODBC) expect
-    //                        jdbc type,                         size,            prec,disp, int,   rat,   docvals
+    //           esType:null  jdbc type,                         size,            prec,disp, int,   rat,   docvals
     INTERVAL_YEAR(            ExtTypes.INTERVAL_YEAR,            Integer.BYTES,   7,    7,   false, false, false),
     INTERVAL_MONTH(           ExtTypes.INTERVAL_MONTH,           Integer.BYTES,   7,    7,   false, false, false),
     INTERVAL_DAY(             ExtTypes.INTERVAL_DAY,             Long.BYTES,      23,   23,  false, false, false),
@@ -126,7 +126,12 @@ public enum DataType {
 
 
     /**
-     * Elasticsearch type name
+     * Type's name used for error messages and column info for the clients
+     */
+    public final String typeName;
+
+    /**
+     * Elasticsearch data type that it maps to
      */
     public final String esType;
 
@@ -176,7 +181,13 @@ public enum DataType {
 
     DataType(SQLType sqlType, int size, int defaultPrecision, int displaySize, boolean isInteger,
             boolean isRational, boolean defaultDocValues) {
-        this.esType = name().toLowerCase(Locale.ROOT);
+        this(null, sqlType, size, defaultPrecision, displaySize, isInteger, isRational, defaultDocValues);
+    }
+
+    DataType(String esType, SQLType sqlType, int size, int defaultPrecision, int displaySize, boolean isInteger,
+             boolean isRational, boolean defaultDocValues) {
+        this.typeName = name().toLowerCase(Locale.ROOT);
+        this.esType = esType;
         this.sqlType = sqlType;
         this.size = size;
         this.defaultPrecision = defaultPrecision;
@@ -228,8 +239,6 @@ public static DataType fromOdbcType(String odbcType) {
     
     /**
      * Creates returns DataType enum corresponding to the specified es type
-     * <p>
-     * For any dataType DataType.fromTypeName(dataType.esType) == dataType
      */
     public static DataType fromTypeName(String esType) {
         String uppercase = esType.toUpperCase(Locale.ROOT);
diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/type/Schema.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/type/Schema.java
@@ -120,9 +120,9 @@ public String toString() {
             }
             sb.append(names.get(i));
             sb.append(":");
-            sb.append(types.get(i).esType);
+            sb.append(types.get(i).typeName);
         }
         sb.append("]");
         return sb.toString();
     }
-}
+}
diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/analysis/index/IndexResolverTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/analysis/index/IndexResolverTests.java
@@ -154,7 +154,7 @@ public static Map<String, Map<String, FieldCapabilities>> fromMappings(EsIndex..
             if (entry.getValue().size() > 1) {
                 for (EsIndex index : indices) {
                     EsField field = index.mapping().get(fieldName);
-                    UpdateableFieldCapabilities fieldCaps = (UpdateableFieldCapabilities) caps.get(field.getDataType().esType);
+                    UpdateableFieldCapabilities fieldCaps = (UpdateableFieldCapabilities) caps.get(field.getDataType().typeName);
                     fieldCaps.indices.add(index.name());
                 }
                 //TODO: what about nonAgg/SearchIndices?
@@ -171,7 +171,7 @@ private static void addFieldCaps(String parent, EsField field, String indexName,
             map = new HashMap<>();
             merged.put(fieldName, map);
         }
-        FieldCapabilities caps = map.computeIfAbsent(field.getDataType().esType,
+        FieldCapabilities caps = map.computeIfAbsent(field.getDataType().typeName,
                 esType -> new UpdateableFieldCapabilities(fieldName, esType,
                 isSearchable(field.getDataType()),
                         isAggregatable(field.getDataType())));
diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/expression/ParameterTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/expression/ParameterTests.java
@@ -28,7 +28,7 @@ public class ParameterTests extends ESTestCase {
     public void testSingleParameter() {
         Expression expression = new SqlParser().createExpression("a = \n?",
                 Collections.singletonList(
-                        new SqlTypedParamValue(DataType.KEYWORD.esType, "foo")
+                        new SqlTypedParamValue(DataType.KEYWORD.typeName, "foo")
                 ));
         logger.info(expression);
         assertThat(expression, instanceOf(Equals.class));
@@ -42,10 +42,10 @@ public void testSingleParameter() {
 
     public void testMultipleParameters() {
         Expression expression = new SqlParser().createExpression("(? + ? * ?) - ?", Arrays.asList(
-                new SqlTypedParamValue(DataType.LONG.esType, 1L),
-                new SqlTypedParamValue(DataType.LONG.esType, 2L),
-                new SqlTypedParamValue(DataType.LONG.esType, 3L),
-                new SqlTypedParamValue(DataType.LONG.esType, 4L)
+                new SqlTypedParamValue(DataType.LONG.typeName, 1L),
+                new SqlTypedParamValue(DataType.LONG.typeName, 2L),
+                new SqlTypedParamValue(DataType.LONG.typeName, 3L),
+                new SqlTypedParamValue(DataType.LONG.typeName, 4L)
                 ));
         assertThat(expression, instanceOf(Sub.class));
         Sub sub = (Sub) expression;
@@ -62,9 +62,9 @@ public void testMultipleParameters() {
     public void testNotEnoughParameters() {
         ParsingException ex = expectThrows(ParsingException.class,
                 () -> new SqlParser().createExpression("(? + ? * ?) - ?", Arrays.asList(
-                        new SqlTypedParamValue(DataType.LONG.esType, 1L),
-                        new SqlTypedParamValue(DataType.LONG.esType, 2L),
-                        new SqlTypedParamValue(DataType.LONG.esType, 3L)
+                        new SqlTypedParamValue(DataType.LONG.typeName, 1L),
+                        new SqlTypedParamValue(DataType.LONG.typeName, 2L),
+                        new SqlTypedParamValue(DataType.LONG.typeName, 3L)
                 )));
         assertThat(ex.getMessage(), containsString("Not enough actual parameters"));
     }
diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/parser/EscapedFunctionsTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/parser/EscapedFunctionsTests.java
diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/parser/LikeEscapingParsingTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/parser/LikeEscapingParsingTests.java
diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTablesTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTablesTests.java
diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/planner/QueryTranslatorTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/planner/QueryTranslatorTests.java
diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/type/DataTypeConversionTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/type/DataTypeConversionTests.java
diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/type/TypesTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/type/TypesTests.java

Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ else if (DataTypes.isUnsupported(fa.dataType())) {`
`219`	`219`	`// compound fields`
`220`	`220`	`else if (allowCompound == false && fa.dataType().isPrimitive() == false) {`
`221`	`221`	`named = u.withUnresolvedMessage(`
`222`		`- "Cannot use field [" + fa.name() + "] type [" + fa.dataType().esType + "] only its subfields");`
	`222`	`+ "Cannot use field [" + fa.name() + "] type [" + fa.dataType().typeName + "] only its subfields");`
`223`	`223`	`}`
`224`	`224`	`}`
`225`	`225`	`return named;`
`@@ -1228,4 +1228,4 @@ protected boolean skipResolved() {`
`1228`	`1228`	`return true;`
`1229`	`1229`	`}`
`1230`	`1230`	`}`
`1231`		`-}`
	`1231`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -682,7 +682,7 @@ private static void validateInExpression(LogicalPlan p, Set<Failure> localFailur`
`682`	`682`	`for (Expression value : in.list()) {`
`683`	`683`	`if (areTypesCompatible(dt, value.dataType()) == false) {`
`684`	`684`	`localFailures.add(fail(value, "expected data type [{}], value provided is of type [{}]",`
`685`		`- dt.esType, value.dataType().esType));`
	`685`	`+ dt.typeName, value.dataType().typeName));`
`686`	`686`	`return;`
`687`	`687`	`}`
`688`	`688`	`}`
`@@ -703,7 +703,7 @@ private static void validateConditional(LogicalPlan p, Set<Failure> localFailure`
`703`	`703`	`} else {`
`704`	`704`	`if (areTypesCompatible(dt, child.dataType()) == false) {`
`705`	`705`	`localFailures.add(fail(child, "expected data type [{}], value provided is of type [{}]",`
`706`		`- dt.esType, child.dataType().esType));`
	`706`	`+ dt.typeName, child.dataType().typeName));`
`707`	`707`	`return;`
`708`	`708`	`}`
`709`	`709`	`}`
Original file line number	Diff line number	Diff line change
`@@ -175,4 +175,4 @@ private static void disableSource(SearchSourceBuilder builder) {`
`175`	`175`	`builder.storedFields(NO_STORED_FIELD);`
`176`	`176`	`}`
`177`	`177`	`}`
`178`		`-}`
	`178`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ public String getWriteableName() {`
`87`	`87`	`@Override`
`88`	`88`	`public void writeTo(StreamOutput out) throws IOException {`
`89`	`89`	`out.writeString(fieldName);`
`90`		`- out.writeOptionalString(dataType == null ? null : dataType.esType);`
	`90`	`+ out.writeOptionalString(dataType == null ? null : dataType.typeName);`
`91`	`91`	`out.writeBoolean(useDocValue);`
`92`	`92`	`out.writeOptionalString(hitName);`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ public static TypeResolution typeMustBe(Expression e,`
`191`	`191`	`paramOrd == null \|\| paramOrd == ParamOrdinal.DEFAULT ? "" : " " + paramOrd.name().toLowerCase(Locale.ROOT),`
`192`	`192`	`acceptedTypesForErrorMsg(acceptedTypes),`
`193`	`193`	`Expressions.name(e),`
`194`		`- e.dataType().esType));`
	`194`	`+ e.dataType().typeName));`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`private static String acceptedTypesForErrorMsg(String... acceptedTypes) {`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ protected TypeResolution resolveType() {`
`46`	`46`	`((FieldAttribute) field()).exactAttribute();`
`47`	`47`	`} catch (MappingException ex) {`
`48`	`48`	`return new TypeResolution(format(null, "[{}] cannot operate on first argument field of data type [{}]",`
`49`		`- functionName(), field().dataType().esType));`
	`49`	`+ functionName(), field().dataType().typeName));`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`if (orderField() != null) {`
`@@ -59,7 +59,7 @@ protected TypeResolution resolveType() {`
`59`	`59`	`((FieldAttribute) orderField()).exactAttribute();`
`60`	`60`	`} catch (MappingException ex) {`
`61`	`61`	`return new TypeResolution(format(null, "[{}] cannot operate on second argument field of data type [{}]",`
`62`		`- functionName(), orderField().dataType().esType));`
	`62`	`+ functionName(), orderField().dataType().typeName));`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`return TypeResolution.TYPE_RESOLVED;`
Original file line number	Diff line number	Diff line change
`@@ -88,9 +88,9 @@ static SqlQueryResponse createResponse(SqlQueryRequest request, SchemaRowSet row`
`88`	`88`	`List<ColumnInfo> columns = new ArrayList<>(rowSet.columnCount());`
`89`	`89`	`for (Schema.Entry entry : rowSet.schema()) {`
`90`	`90`	`if (Mode.isDriver(request.mode())) {`
`91`		`- columns.add(new ColumnInfo("", entry.name(), entry.type().esType, entry.type().displaySize));`
	`91`	`+ columns.add(new ColumnInfo("", entry.name(), entry.type().typeName, entry.type().displaySize));`
`92`	`92`	`} else {`
`93`		`- columns.add(new ColumnInfo("", entry.name(), entry.type().esType));`
	`93`	`+ columns.add(new ColumnInfo("", entry.name(), entry.type().typeName));`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`columns = unmodifiableList(columns);`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,6 @@ public DataType fieldDataType() {`
`33`	`33`
`34`	`34`	`@Override`
`35`	`35`	`public String toString() {`
`36`		`- return ">" + name + "[" + fieldDataType.esType + "]";`
	`36`	`+ return ">" + name + "[" + fieldDataType.typeName + "]";`
`37`	`37`	`}`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,9 +120,9 @@ public String toString() {`
`120`	`120`	`}`
`121`	`121`	`sb.append(names.get(i));`
`122`	`122`	`sb.append(":");`
`123`		`- sb.append(types.get(i).esType);`
	`123`	`+ sb.append(types.get(i).typeName);`
`124`	`124`	`}`
`125`	`125`	`sb.append("]");`
`126`	`126`	`return sb.toString();`
`127`	`127`	`}`
`128`		`-}`
	`128`	`+}`