Refactor Least function to use evaluator map

This commit refactors the Least function to use an evaluator map for better
code organization. The changes include:
- Added EVALUATOR_MAP for evaluator factory mapping
- Updated toEvaluator to use map-based lookup
- Added NULL type validation
- Updated error messages to use getWriteableName()

The refactoring improves code readability and maintainability by:
- Replacing if-else chains with a map-based lookup
- Centralizing evaluator factory creation
- Adding consistent NULL type validation
- Using getWriteableName() for error messages

Relates to #114036

Author: shinsj4653

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/conditional/Least.java

@@ -12,6 +12,7 @@
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.compute.ann.Evaluator;
+import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.compute.operator.EvalOperator.ExpressionEvaluator;
 import org.elasticsearch.xpack.esql.EsqlIllegalArgumentException;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
@@ -30,6 +31,10 @@
 
 import java.io.IOException;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
 import static org.elasticsearch.xpack.esql.core.type.DataType.NULL;
@@ -42,6 +47,17 @@ public class Least extends EsqlScalarFunction implements OptionalArgument {
 
     private DataType dataType;
 
+    private static final Map<DataType, Function<ExpressionEvaluator.Factory[], ExpressionEvaluator.Factory>> EVALUATOR_MAP = Map.of(
+        DataType.BOOLEAN, factories -> new LeastBooleanEvaluator.Factory(Source.EMPTY, factories),
+        DataType.DOUBLE, factories -> new LeastDoubleEvaluator.Factory(Source.EMPTY, factories),
+        DataType.INTEGER, factories -> new LeastIntEvaluator.Factory(Source.EMPTY, factories),
+        DataType.LONG, factories -> new LeastLongEvaluator.Factory(Source.EMPTY, factories),
+        DataType.DATETIME, factories -> new LeastLongEvaluator.Factory(Source.EMPTY, factories),
+        DataType.DATE_NANOS, factories -> new LeastLongEvaluator.Factory(Source.EMPTY, factories),
+        DataType.IP, factories -> new LeastBytesRefEvaluator.Factory(Source.EMPTY, factories),
+        DataType.VERSION, factories -> new LeastBytesRefEvaluator.Factory(Source.EMPTY, factories)
+    );
+
     @FunctionInfo(
         returnType = { "boolean", "date", "date_nanos", "double", "integer", "ip", "keyword", "long", "version" },
         description = "Returns the minimum value from multiple columns. "
@@ -116,6 +132,11 @@ protected TypeResolution resolveType() {
                 return resolution;
             }
         }
+
+        if (dataType != NULL && !EVALUATOR_MAP.containsKey(dataType) && !DataType.isString(dataType)) {
+            return new TypeResolution("Cannot use [" + dataType.typeName() + "] with function [" + getWriteableName() + "]");
+        }
+
         return TypeResolution.TYPE_RESOLVED;
     }
 
@@ -138,27 +159,24 @@ public boolean foldable() {
     public ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
         // force datatype initialization
         var dataType = dataType();
+        if (dataType == DataType.NULL) {
+            throw EsqlIllegalArgumentException.illegalDataType(dataType);
+        }
 
         ExpressionEvaluator.Factory[] factories = children().stream()
             .map(e -> toEvaluator.apply(new MvMin(e.source(), e)))
             .toArray(ExpressionEvaluator.Factory[]::new);
-        if (dataType == DataType.BOOLEAN) {
-            return new LeastBooleanEvaluator.Factory(source(), factories);
-        }
-        if (dataType == DataType.DOUBLE) {
-            return new LeastDoubleEvaluator.Factory(source(), factories);
-        }
-        if (dataType == DataType.INTEGER) {
-            return new LeastIntEvaluator.Factory(source(), factories);
-        }
-        if (dataType == DataType.LONG || dataType == DataType.DATETIME || dataType == DataType.DATE_NANOS) {
-            return new LeastLongEvaluator.Factory(source(), factories);
-        }
-        if (DataType.isString(dataType) || dataType == DataType.IP || dataType == DataType.VERSION || dataType == DataType.UNSUPPORTED) {
 
+        if (DataType.isString(dataType)) {
             return new LeastBytesRefEvaluator.Factory(source(), factories);
         }
-        throw EsqlIllegalArgumentException.illegalDataType(dataType);
+
+        var evaluatorFactory = EVALUATOR_MAP.get(dataType);
+        if (evaluatorFactory == null) {
+            throw EsqlIllegalArgumentException.illegalDataType(dataType);
+        }
+
+        return evaluatorFactory.apply(factories);
     }
 
     @Evaluator(extraName = "Boolean")