* Added a new ESQL query pragma:, NATIVE_FLOAT_TYPE, to avoid widening of floats to doubles (the current default behavior).

* Added a flag for ESQL's DataType's `widenSmallType`, to control to widening of floats

* Threaded QueryPragmas into any place in theh code which eventually calls `widenSmallType`, to allow conditioning the
  float widening on the session / query specific pragmas.

* For now, provided `QueryPragmas.EMPTY` as a hard coded argument for all the tests that now needs pragmas because
  of those changes. Ideally, next thing should be to inject pragmas into the tests from a single place, and using
  a Gradle command parameter. This will make sure that all the tests are running with the same pragmas values, and `
  avoid redyndant degrees of freedom where each test manually pass its own value.

Author: shmuelhanoch

benchmarks/src/main/java/org/elasticsearch/benchmark/_nightly/esql/QueryPlanningBenchmark.java

@@ -116,7 +116,7 @@ public void setup() {
     }
 
     private LogicalPlan plan(EsqlParser parser, Analyzer analyzer, LogicalPlanOptimizer optimizer, String query) {
-        var parsed = parser.createStatement(query, new QueryParams(), telemetry);
+        var parsed = parser.createStatement(query, new QueryParams(), telemetry, );
         var analyzed = analyzer.analyze(parsed);
         var optimized = optimizer.optimize(analyzed);
         return optimized;

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

@@ -653,8 +653,8 @@ public boolean isCounter() {
      * If this is a "small" numeric type this contains the type ESQL will
      * widen it into, otherwise this returns {@code this}.
      */
-    public DataType widenSmallNumeric() {
-        return widenSmallNumeric == null ? this : widenSmallNumeric;
+    public DataType widenSmallNumeric(boolean supportNativeFloat) {
+        return widenSmallNumeric == null || supportNativeFloat ? this : widenSmallNumeric;
     }
 
     /**

x-pack/plugin/esql/qa/testFixtures/src/main/java/org/elasticsearch/xpack/esql/EsqlTestUtils.java

@@ -474,7 +474,7 @@ public static Limit asLimit(Object node, Integer limitLiteral, Boolean duplicate
     }
 
     public static Map<String, EsField> loadMapping(String name) {
-        return LoadMapping.loadMapping(name);
+        return new LoadMapping(QueryPragmas.EMPTY).loadMapping(name);
     }
 
     public static String loadUtf8TextFile(String name) {

x-pack/plugin/esql/qa/testFixtures/src/main/java/org/elasticsearch/xpack/esql/LoadMapping.java

@@ -18,6 +18,7 @@
 import org.elasticsearch.xpack.esql.core.type.KeywordEsField;
 import org.elasticsearch.xpack.esql.core.type.TextEsField;
 import org.elasticsearch.xpack.esql.core.type.UnsupportedEsField;
+import org.elasticsearch.xpack.esql.plugin.QueryPragmas;
 import org.elasticsearch.xpack.esql.type.EsqlDataTypeRegistry;
 
 import java.io.IOException;
@@ -36,13 +37,19 @@
 import static org.junit.Assert.assertNotNull;
 
 public class LoadMapping {
-    public static Map<String, EsField> loadMapping(String name) {
+    public LoadMapping(QueryPragmas pragmas) {
+        this.pragmas = pragmas;
+    }
+
+    private final QueryPragmas pragmas;
+
+    public Map<String, EsField> loadMapping(String name) {
         InputStream stream = LoadMapping.class.getResourceAsStream("/" + name);
         assertNotNull("Could not find mapping resource:" + name, stream);
         return loadMapping(stream);
     }
 
-    private static Map<String, EsField> loadMapping(InputStream stream) {
+    private Map<String, EsField> loadMapping(InputStream stream) {
         try (InputStream in = stream) {
             Map<String, Object> map = XContentHelper.convertToMap(JsonXContent.jsonXContent, in, true);
             return fromEs(map);
@@ -52,15 +59,15 @@ private static Map<String, EsField> loadMapping(InputStream stream) {
     }
 
     @SuppressWarnings("unchecked")
-    private static Map<String, EsField> fromEs(Map<String, Object> asMap) {
+    private Map<String, EsField> fromEs(Map<String, Object> asMap) {
         Map<String, Object> props = null;
         if (asMap != null && asMap.isEmpty() == false) {
             props = (Map<String, Object>) asMap.get("properties");
         }
         return props == null || props.isEmpty() ? emptyMap() : startWalking(props);
     }
 
-    private static Map<String, EsField> startWalking(Map<String, Object> mapping) {
+    private Map<String, EsField> startWalking(Map<String, Object> mapping) {
         Map<String, EsField> types = new LinkedHashMap<>();
 
         if (mapping == null) {
@@ -74,7 +81,7 @@ private static Map<String, EsField> startWalking(Map<String, Object> mapping) {
     }
 
     @SuppressWarnings("unchecked")
-    private static void walkMapping(String name, Object value, Map<String, EsField> mapping) {
+    private void walkMapping(String name, Object value, Map<String, EsField> mapping) {
         // object type - only root or nested docs supported
         if (value instanceof Map) {
             Map<String, Object> content = (Map<String, Object>) value;
@@ -122,7 +129,7 @@ private static void walkMapping(String name, Object value, Map<String, EsField>
         }
     }
 
-    private static DataType getType(Map<String, Object> content) {
+    private DataType getType(Map<String, Object> content) {
         if (content.containsKey("type")) {
             String typeName = content.get("type").toString();
             if ("constant_keyword".equals(typeName) || "wildcard".equals(typeName)) {
@@ -136,7 +143,7 @@ private static DataType getType(Map<String, Object> content) {
                 metricType = (TimeSeriesParams.MetricType) metricsTypeParameter;
             }
             try {
-                return EsqlDataTypeRegistry.INSTANCE.fromEs(typeName, metricType);
+                return EsqlDataTypeRegistry.INSTANCE.fromEs(typeName, metricType, pragmas);
             } catch (IllegalArgumentException ex) {
                 return UNSUPPORTED;
             }

x-pack/plugin/esql/qa/testFixtures/src/main/resources/floats.csv-spec

@@ -692,3 +692,11 @@ null
 null
 null
 ;
+
+
+foo
+row d = [3.141] | eval dd = to_double(d);
+
+d:double |dd:double
+[3.141]  |3.142
+;

x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/LookupJoinTypesIT.java

@@ -1,4 +1,4 @@
-/*
+/ql
  * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
  * or more contributor license agreements. Licensed under the Elastic License
  * 2.0; you may not use this file except in compliance with the Elastic License
@@ -514,7 +514,7 @@ private void addFails(DataType mainType, DataType lookupType) {
                 Locale.ROOT,
                 "JOIN left field [%s] of type [%s] is incompatible with right field [%s] of type [%s]",
                 fieldName,
-                mainType.widenSmallNumeric(),
+                mainType.widenSmallNumeric(configuration.),
                 fieldName,
                 lookupType.widenSmallNumeric()
             );

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

@@ -106,6 +106,7 @@
 import org.elasticsearch.xpack.esql.plan.logical.local.EsqlProject;
 import org.elasticsearch.xpack.esql.plan.logical.local.LocalRelation;
 import org.elasticsearch.xpack.esql.plan.logical.local.LocalSupplier;
+import org.elasticsearch.xpack.esql.plugin.QueryPragmas;
 import org.elasticsearch.xpack.esql.rule.ParameterizedRule;
 import org.elasticsearch.xpack.esql.rule.ParameterizedRuleExecutor;
 import org.elasticsearch.xpack.esql.rule.Rule;
@@ -212,18 +213,18 @@ protected List<Batch<LogicalPlan>> batches() {
     }
 
     private static class ResolveTable extends ParameterizedAnalyzerRule<UnresolvedRelation, AnalyzerContext> {
-
         @Override
         protected LogicalPlan rule(UnresolvedRelation plan, AnalyzerContext context) {
             return resolveIndex(
                 plan,
                 plan.indexMode().equals(IndexMode.LOOKUP)
                     ? context.lookupResolution().get(plan.indexPattern().indexPattern())
-                    : context.indexResolution()
+                    : context.indexResolution(),
+                context.configuration().pragmas()
             );
         }
 
-        private LogicalPlan resolveIndex(UnresolvedRelation plan, IndexResolution indexResolution) {
+        private LogicalPlan resolveIndex(UnresolvedRelation plan, IndexResolution indexResolution, QueryPragmas pragmas) {
             if (indexResolution == null || indexResolution.isValid() == false) {
                 String indexResolutionMessage = indexResolution == null ? "[none specified]" : indexResolution.toString();
                 return plan.unresolvedMessage().equals(indexResolutionMessage)
@@ -254,7 +255,7 @@ private LogicalPlan resolveIndex(UnresolvedRelation plan, IndexResolution indexR
 
             EsIndex esIndex = indexResolution.get();
 
-            var attributes = mappingAsAttributes(plan.source(), esIndex.mapping());
+            var attributes = mappingAsAttributes(plan.source(), esIndex.mapping(), pragmas);
             attributes.addAll(plan.metadataFields());
             return new EsRelation(
                 plan.source(),
@@ -264,6 +265,8 @@ private LogicalPlan resolveIndex(UnresolvedRelation plan, IndexResolution indexR
                 attributes.isEmpty() ? NO_FIELDS : attributes
             );
         }
+
+        private QueryPragmas pragmas;
     }
 
     /**
@@ -274,22 +277,28 @@ private LogicalPlan resolveIndex(UnresolvedRelation plan, IndexResolution indexR
      *     Public for testing.
      * </p>
      */
-    public static List<Attribute> mappingAsAttributes(Source source, Map<String, EsField> mapping) {
+    public static List<Attribute> mappingAsAttributes(Source source, Map<String, EsField> mapping, QueryPragmas pragmas) {
         var list = new ArrayList<Attribute>();
-        mappingAsAttributes(list, source, null, mapping);
+        mappingAsAttributes(list, source, null, mapping, pragmas);
         list.sort(Comparator.comparing(Attribute::name));
         return list;
     }
 
-    private static void mappingAsAttributes(List<Attribute> list, Source source, String parentName, Map<String, EsField> mapping) {
+    private static void mappingAsAttributes(
+        List<Attribute> list,
+        Source source,
+        String parentName,
+        Map<String, EsField> mapping,
+        QueryPragmas pragmas
+    ) {
         for (Map.Entry<String, EsField> entry : mapping.entrySet()) {
             String name = entry.getKey();
             EsField t = entry.getValue();
 
             if (t != null) {
                 name = parentName == null ? name : parentName + "." + name;
                 var fieldProperties = t.getProperties();
-                var type = t.getDataType().widenSmallNumeric();
+                var type = t.getDataType().widenSmallNumeric(pragmas.native_float_type());
                 // 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()) {
@@ -305,7 +314,7 @@ private static void mappingAsAttributes(List<Attribute> list, Source source, Str
                 }
                 // allow compound object even if they are unknown
                 if (fieldProperties.isEmpty() == false) {
-                    mappingAsAttributes(list, source, attribute.name(), fieldProperties);
+                    mappingAsAttributes(list, source, attribute.name(), fieldProperties, pragmas);
                 }
             }
         }
@@ -329,7 +338,7 @@ protected LogicalPlan rule(Enrich plan, AnalyzerContext context) {
                 List<NamedExpression> enrichFields = calculateEnrichFields(
                     plan.source(),
                     policyName,
-                    mappingAsAttributes(plan.source(), resolved.mapping()),
+                    mappingAsAttributes(plan.source(), resolved.mapping(), context.configuration().pragmas()),
                     plan.enrichFields(),
                     policy
                 );
@@ -1391,16 +1400,16 @@ public LogicalPlan apply(LogicalPlan plan, AnalyzerContext context) {
             // do implicit casting for function arguments
             return plan.transformExpressionsUp(
                 org.elasticsearch.xpack.esql.core.expression.function.Function.class,
-                e -> ImplicitCasting.cast(e, context.functionRegistry().snapshotRegistry())
+                e -> ImplicitCasting.cast(e, context.functionRegistry().snapshotRegistry(), context.configuration().pragmas())
             );
         }
 
-        private static Expression cast(org.elasticsearch.xpack.esql.core.expression.function.Function f, EsqlFunctionRegistry registry) {
+        private static Expression cast(org.elasticsearch.xpack.esql.core.expression.function.Function f, EsqlFunctionRegistry registry, QueryPragmas pragmas) {
             if (f instanceof In in) {
                 return processIn(in);
             }
             if (f instanceof EsqlScalarFunction || f instanceof GroupingFunction) { // exclude AggregateFunction until it is needed
-                return processScalarOrGroupingFunction(f, registry);
+                return processScalarOrGroupingFunction(f, registry, pragmas);
             }
             if (f instanceof EsqlArithmeticOperation || f instanceof BinaryComparison) {
                 return processBinaryOperator((BinaryOperator) f);
@@ -1413,7 +1422,8 @@ private static Expression cast(org.elasticsearch.xpack.esql.core.expression.func
 
         private static Expression processScalarOrGroupingFunction(
             org.elasticsearch.xpack.esql.core.expression.function.Function f,
-            EsqlFunctionRegistry registry
+            EsqlFunctionRegistry registry,
+            QueryPragmas pragmas
         ) {
             List<Expression> args = f.arguments();
             List<DataType> targetDataTypes = registry.getDataTypeForStringLiteralConversion(f.getClass());
@@ -1456,7 +1466,7 @@ private static Expression processScalarOrGroupingFunction(
             }
             Expression resultF = childrenChanged ? f.replaceChildren(newChildren) : f;
             return targetNumericType != null && castNumericArgs
-                ? castMixedNumericTypes((EsqlScalarFunction) resultF, targetNumericType)
+                ? castMixedNumericTypes((EsqlScalarFunction) resultF, targetNumericType, pragmas)
                 : resultF;
         }
 
@@ -1532,7 +1542,7 @@ private static boolean canCastNumeric(DataType from, DataType to) {
             return commonType == to;
         }
 
-        private static Expression castMixedNumericTypes(EsqlScalarFunction f, DataType targetNumericType) {
+        private static Expression castMixedNumericTypes(EsqlScalarFunction f, DataType targetNumericType, QueryPragmas pragmas) {
             List<Expression> newChildren = new ArrayList<>(f.children().size());
             boolean childrenChanged = false;
             DataType childDataType;
@@ -1549,10 +1559,10 @@ private static Expression castMixedNumericTypes(EsqlScalarFunction f, DataType t
                     childrenChanged = true;
                     // add a casting function
                     switch (targetNumericType) {
-                        case INTEGER -> newChildren.add(new ToInteger(e.source(), e));
-                        case LONG -> newChildren.add(new ToLong(e.source(), e));
-                        case DOUBLE -> newChildren.add(new ToDouble(e.source(), e));
-                        case UNSIGNED_LONG -> newChildren.add(new ToUnsignedLong(e.source(), e));
+                        case INTEGER -> newChildren.add(new ToInteger(e.source(), e, pragmas));
+                        case LONG -> newChildren.add(new ToLong(e.source(), e, pragmas));
+                        case DOUBLE -> newChildren.add(new ToDouble(e.source(), e, pragmas));
+                        case UNSIGNED_LONG -> newChildren.add(new ToUnsignedLong(e.source(), e, pragmas));
                         default -> throw new EsqlIllegalArgumentException("unexpected data type: " + targetNumericType);
                     }
                 } else {
@@ -1720,7 +1730,7 @@ private Expression resolveConvertFunction(ConvertFunction convert, List<FieldAtt
                     return fcf.replaceChildren(Collections.singletonList(ua));
                 }
                 imf.types().forEach(type -> {
-                    if (supportedTypes.contains(type.widenSmallNumeric())) {
+                    if (supportedTypes.contains(type.widenSmallNumeric(convert.getPragmas().native_float_type()))) {
                         typeResolutions(fa, convert, type, imf, typeResolutions);
                     }
                 });
@@ -1745,7 +1755,7 @@ private Expression resolveConvertFunction(ConvertFunction convert, List<FieldAtt
                     // Data type is different between implicit(date_nanos) and explicit casting, if the conversion is supported, create a
                     // new MultiTypeEsField with explicit casting type, and add it to unionFieldAttributes.
                     Set<DataType> supportedTypes = convert.supportedTypes();
-                    if (supportedTypes.contains(fa.dataType()) && canConvertOriginalTypes(mtf, supportedTypes)) {
+                    if (supportedTypes.contains(fa.dataType()) && canConvertOriginalTypes(mtf, supportedTypes, convert.getPragmas())) {
                         // Build the mapping between index name and conversion expressions
                         Map<String, Expression> indexToConversionExpressions = new HashMap<>();
                         for (Map.Entry<String, Expression> entry : mtf.getIndexToConversionExpressions().entrySet()) {
@@ -1807,13 +1817,13 @@ private static MultiTypeEsField resolvedMultiTypeEsField(
             return MultiTypeEsField.resolveFrom(imf, typesToConversionExpressions);
         }
 
-        private static boolean canConvertOriginalTypes(MultiTypeEsField multiTypeEsField, Set<DataType> supportedTypes) {
+        private static boolean canConvertOriginalTypes(MultiTypeEsField multiTypeEsField, Set<DataType> supportedTypes, QueryPragmas pragmas) {
             return multiTypeEsField.getIndexToConversionExpressions()
                 .values()
                 .stream()
                 .allMatch(
                     e -> e instanceof AbstractConvertFunction convertFunction
-                        && supportedTypes.contains(convertFunction.field().dataType().widenSmallNumeric())
+                        && supportedTypes.contains(convertFunction.field().dataType().widenSmallNumeric(pragmas.native_float_type()))
                 );
         }
 
@@ -1911,7 +1921,7 @@ public LogicalPlan apply(LogicalPlan plan) {
                 return relation.transformExpressionsUp(FieldAttribute.class, f -> {
                     if (f.field() instanceof InvalidMappedField imf && imf.types().stream().allMatch(DataType::isDate)) {
                         HashMap<ResolveUnionTypes.TypeResolutionKey, Expression> typeResolutions = new HashMap<>();
-                        var convert = new ToDateNanos(f.source(), f);
+                        var convert = new ToDateNanos(f.source(), f, QueryPragmas.EMPTY); // TODO thread actual pragmas!
                         imf.types().forEach(type -> typeResolutions(f, convert, type, imf, typeResolutions));
                         var resolvedField = ResolveUnionTypes.resolvedMultiTypeEsField(f, typeResolutions);
                         return new FieldAttribute(f.source(), f.parentName(), f.name(), resolvedField, f.nullable(), f.id(), f.synthetic());