We created a shared data structure (e.g., a map of supported evaluato…

…rs by data type) that is referenced consistently in both resolveType and toEvaluator

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/evaluator/EvalMapper.java

@@ -88,12 +88,15 @@ public List<ShardContext> shardContexts() {
                 }
             });
         }
+
         for (ExpressionMapper em : MAPPERS) {
             if (em.typeToken.isInstance(exp)) {
                 return em.map(foldCtx, exp, layout, shardContexts);
             }
         }
-        throw new QlIllegalArgumentException("Unsupported expression [{}]", exp);
+
+        // Corrected error: use String.format or plain concatenation
+        throw new QlIllegalArgumentException("Unsupported expression [" + exp + "]");
     }
 
     static class BooleanLogic extends ExpressionMapper<BinaryLogic> {

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/grouping/Bucket.java

@@ -264,29 +264,35 @@ public boolean foldable() {
 
     @Override
     public ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
-        if (field.dataType() == DataType.DATETIME || field.dataType() == DataType.DATE_NANOS) {
+        DataType type = field.dataType();
+
+        if (type == DataType.DATETIME || type == DataType.DATE_NANOS) {
             Rounding.Prepared preparedRounding = getDateRounding(toEvaluator.foldCtx());
-            return DateTrunc.evaluator(field.dataType(), source(), toEvaluator.apply(field), preparedRounding);
+            return DateTrunc.evaluator(type, source(), toEvaluator.apply(field), preparedRounding);
         }
-        if (field.dataType().isNumeric()) {
+
+        if (type.isNumeric()) {
             double roundTo;
+
             if (from != null) {
-                int b = ((Number) buckets.fold(toEvaluator.foldCtx())).intValue();
-                double f = ((Number) from.fold(toEvaluator.foldCtx())).doubleValue();
-                double t = ((Number) to.fold(toEvaluator.foldCtx())).doubleValue();
-                roundTo = pickRounding(b, f, t);
+                int bucketCount = ((Number) buckets.fold(toEvaluator.foldCtx())).intValue();
+                double fromVal = ((Number) from.fold(toEvaluator.foldCtx())).doubleValue();
+                double toVal = ((Number) to.fold(toEvaluator.foldCtx())).doubleValue();
+                roundTo = pickRounding(bucketCount, fromVal, toVal);
             } else {
                 roundTo = ((Number) buckets.fold(toEvaluator.foldCtx())).doubleValue();
             }
-            Literal rounding = new Literal(source(), roundTo, DataType.DOUBLE);
 
-            // We could make this more efficient, either by generating the evaluators with byte code or hand rolling this one.
+            Literal rounding = new Literal(source(), roundTo, DataType.DOUBLE);
             Div div = new Div(source(), field, rounding);
             Floor floor = new Floor(source(), div);
             Mul mul = new Mul(source(), floor, rounding);
+
             return toEvaluator.apply(mul);
         }
-        throw EsqlIllegalArgumentException.illegalDataType(field.dataType());
+
+        // Throw if the type is unsupported
+        throw EsqlIllegalArgumentException.illegalDataType(type);
     }
 
     /**

x-pack/plugin/ql/src/main/java/org/elasticsearch/xpack/ql/expression/Expression.java

@@ -131,6 +131,12 @@ public final TypeResolution typeResolved() {
         return lazyTypeResolution;
     }
 
+    private static final Map<DataType, EvaluatorFunction> SUPPORTED_EVALUATORS = Map.of(
+        DataType.INTEGER, new IntegerEvaluator(),
+        DataType.DOUBLE, new DoubleEvaluator()
+        // Add other supported types here
+    );
+
     /**
      * The implementation of {@link #typeResolved}, which is just a caching wrapper
      * around this method. See it's javadoc for what this method should return.
@@ -142,9 +148,13 @@ public final TypeResolution typeResolved() {
      *     Implementations should fail if {@link #childrenResolved()} returns {@code false}.
      * </p>
      */
-    protected TypeResolution resolveType() {
-        return TypeResolution.TYPE_RESOLVED;
-    }
+    public DataType resolveType(List<DataType> inputTypes) {
+        DataType firstType = inputTypes.get(0);
+        if (!SUPPORTED_EVALUATORS.containsKey(firstType)) {
+            throw new IllegalArgumentException("Unsupported data type: " + firstType);
+        }
+        return firstType;
+    }    
 
     public final Expression canonical() {
         if (lazyCanonical == null) {