Remove deprecated function isNotNullAndFoldable

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

@@ -0,0 +1,115 @@
+/*
+ * 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
+ * 2.0.
+ */
+package org.elasticsearch.xpack.esql.expression.function;
+
+import org.elasticsearch.common.lucene.BytesRefs;
+import org.elasticsearch.xpack.esql.EsqlIllegalArgumentException;
+import org.elasticsearch.xpack.esql.common.Failures;
+import org.elasticsearch.xpack.esql.core.expression.Expression;
+import org.elasticsearch.xpack.esql.core.expression.Literal;
+
+import static org.elasticsearch.common.logging.LoggerMessageFormat.format;
+import static org.elasticsearch.xpack.esql.common.Failure.fail;
+
+public class FunctionUtils {
+    public static Integer limitValue(Expression limitField, String sourceText) {
+        if (limitField instanceof Literal literal) {
+            Object value = literal.value();
+            if (value instanceof Integer intValue) {
+                return intValue;
+            }
+        }
+        throw new EsqlIllegalArgumentException(format(null, "Limit value must be an integer in [{}], found [{}]", sourceText, limitField));
+    }
+
+    /**
+     * We check that the limit is not null and that if it is a literal, it is a positive integer
+     * We will do a more thorough check in the postOptimizationVerification once folding is done.
+     */
+    public static Expression.TypeResolution resolveTypeLimit(Expression limitField, String sourceText) {
+        if (limitField == null) {
+            return new Expression.TypeResolution(
+                format(null, "Limit must be a constant integer in [{}], found [{}]", sourceText, limitField)
+            );
+        }
+        if (limitField instanceof Literal literal) {
+            if (literal.value() == null) {
+                return new Expression.TypeResolution(
+                    format(null, "Limit must be a constant integer in [{}], found [{}]", sourceText, limitField)
+                );
+            }
+            int value = (Integer) literal.value();
+            if (value <= 0) {
+                return new Expression.TypeResolution(format(null, "Limit must be greater than 0 in [{}], found [{}]", sourceText, value));
+            }
+        }
+        return Expression.TypeResolution.TYPE_RESOLVED;
+    }
+
+    public static void postOptimizationVerificationLimit(Failures failures, Expression limitField, String sourceText) {
+        if (limitField == null) {
+            failures.add(fail(limitField, "Limit must be a constant integer in [{}], found [{}]", sourceText, limitField));
+        }
+        if (limitField instanceof Literal literal) {
+            int value = (Integer) literal.value();
+            if (value <= 0) {
+                failures.add(fail(limitField, "Limit must be greater than 0 in [{}], found [{}]", sourceText, value));
+            }
+        } else {
+            // it is expected that the expression is a literal after folding
+            // we fail if it is not a literal
+            failures.add(fail(limitField, "Limit must be a constant integer in [{}], found [{}]", sourceText, limitField));
+        }
+    }
+
+    public static Expression.TypeResolution resolveTypeQuery(Expression queryField, String sourceText) {
+        if (queryField == null) {
+            return new Expression.TypeResolution(format(null, "Query must be a valid string in [{}], found [{}]", sourceText, queryField));
+        }
+        if (queryField instanceof Literal literal) {
+            if (literal.value() == null) {
+                return new Expression.TypeResolution(
+                    format(null, "Query value cannot be null in [{}], but got [{}]", sourceText, queryField)
+                );
+            }
+        }
+        return Expression.TypeResolution.TYPE_RESOLVED;
+    }
+
+    public static void postOptimizationVerificationQuery(Failures failures, Expression queryField, String sourceText) {
+        if (queryField == null) {
+            failures.add(fail(queryField, "Query must be a valid string in [{}], found [{}]", sourceText, queryField));
+        }
+        if (queryField instanceof Literal literal) {
+            if (literal.value() == null) {
+                failures.add(fail(queryField, "Invalid query value in [{}], found [{}]", sourceText, literal.value()));
+            }
+        } else {
+            // it is expected that the expression is a literal after folding
+            // we fail if it is not a literal
+            failures.add(fail(queryField, "Query must be a valid string in [{}], found [{}]", sourceText, queryField));
+        }
+    }
+
+    public static Object queryAsObject(Expression queryField, String sourceText) {
+        if (queryField instanceof Literal literal) {
+            return literal.value();
+        }
+        throw new EsqlIllegalArgumentException(
+            format(null, "Query value must be a constant string in [{}], found [{}]", sourceText, queryField)
+        );
+    }
+
+    public static String queryAsString(Expression queryField, String sourceText) {
+        if (queryField instanceof Literal literal) {
+            return BytesRefs.toString(literal.value());
+        }
+        throw new EsqlIllegalArgumentException(
+            format(null, "Query value must be a constant string in [{}], found [{}]", sourceText, queryField)
+        );
+    }
+}

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/Sample.java

@@ -17,29 +17,32 @@
 import org.elasticsearch.compute.aggregation.SampleIntAggregatorFunctionSupplier;
 import org.elasticsearch.compute.aggregation.SampleLongAggregatorFunctionSupplier;
 import org.elasticsearch.xpack.esql.EsqlIllegalArgumentException;
+import org.elasticsearch.xpack.esql.capabilities.PostOptimizationVerificationAware;
+import org.elasticsearch.xpack.esql.common.Failures;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
-import org.elasticsearch.xpack.esql.core.expression.FoldContext;
 import org.elasticsearch.xpack.esql.core.expression.Literal;
 import org.elasticsearch.xpack.esql.core.tree.NodeInfo;
 import org.elasticsearch.xpack.esql.core.tree.Source;
 import org.elasticsearch.xpack.esql.core.type.DataType;
 import org.elasticsearch.xpack.esql.expression.function.Example;
 import org.elasticsearch.xpack.esql.expression.function.FunctionInfo;
 import org.elasticsearch.xpack.esql.expression.function.FunctionType;
+import org.elasticsearch.xpack.esql.expression.function.FunctionUtils;
 import org.elasticsearch.xpack.esql.expression.function.Param;
 import org.elasticsearch.xpack.esql.planner.PlannerUtils;
 import org.elasticsearch.xpack.esql.planner.ToAggregator;
 
 import java.io.IOException;
 import java.util.List;
 
-import static org.elasticsearch.common.logging.LoggerMessageFormat.format;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.FIRST;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.SECOND;
-import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isNotNullAndFoldable;
+import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isNotNull;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isType;
+import static org.elasticsearch.xpack.esql.expression.function.FunctionUtils.postOptimizationVerificationLimit;
+import static org.elasticsearch.xpack.esql.expression.function.FunctionUtils.resolveTypeLimit;
 
-public class Sample extends AggregateFunction implements ToAggregator {
+public class Sample extends AggregateFunction implements ToAggregator, PostOptimizationVerificationAware {
     public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(Expression.class, "Sample", Sample::new);
 
     @FunctionInfo(
@@ -110,14 +113,14 @@ protected TypeResolution resolveType() {
             return new TypeResolution("Unresolved children");
         }
         var typeResolution = isType(field(), dt -> dt != DataType.UNSIGNED_LONG, sourceText(), FIRST, "any type except unsigned_long").and(
-            isNotNullAndFoldable(limitField(), sourceText(), SECOND)
+            isNotNull(limitField(), sourceText(), SECOND)
         ).and(isType(limitField(), dt -> dt == DataType.INTEGER, sourceText(), SECOND, "integer"));
         if (typeResolution.unresolved()) {
             return typeResolution;
         }
-        int limit = limitValue();
-        if (limit <= 0) {
-            return new TypeResolution(format(null, "Limit must be greater than 0 in [{}], found [{}]", sourceText(), limit));
+        TypeResolution result = resolveTypeLimit(limitField(), sourceText());
+        if (result.equals(TypeResolution.TYPE_RESOLVED) == false) {
+            return result;
         }
         return TypeResolution.TYPE_RESOLVED;
     }
@@ -164,11 +167,15 @@ Expression limitField() {
     }
 
     private int limitValue() {
-        return (int) limitField().fold(FoldContext.small() /* TODO remove me */);
+        return FunctionUtils.limitValue(limitField(), sourceText());
     }
 
     Expression uuid() {
         return parameters().get(1);
     }
 
+    @Override
+    public void postOptimizationVerification(Failures failures) {
+        postOptimizationVerificationLimit(failures, limitField(), sourceText());
+    }
 }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/Top.java

@@ -20,8 +20,9 @@
 import org.elasticsearch.compute.aggregation.TopIpAggregatorFunctionSupplier;
 import org.elasticsearch.compute.aggregation.TopLongAggregatorFunctionSupplier;
 import org.elasticsearch.xpack.esql.EsqlIllegalArgumentException;
+import org.elasticsearch.xpack.esql.capabilities.PostOptimizationVerificationAware;
+import org.elasticsearch.xpack.esql.common.Failures;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
-import org.elasticsearch.xpack.esql.core.expression.FoldContext;
 import org.elasticsearch.xpack.esql.core.expression.Literal;
 import org.elasticsearch.xpack.esql.core.tree.NodeInfo;
 import org.elasticsearch.xpack.esql.core.tree.Source;
@@ -30,6 +31,7 @@
 import org.elasticsearch.xpack.esql.expression.function.Example;
 import org.elasticsearch.xpack.esql.expression.function.FunctionInfo;
 import org.elasticsearch.xpack.esql.expression.function.FunctionType;
+import org.elasticsearch.xpack.esql.expression.function.FunctionUtils;
 import org.elasticsearch.xpack.esql.expression.function.Param;
 import org.elasticsearch.xpack.esql.io.stream.PlanStreamInput;
 import org.elasticsearch.xpack.esql.planner.ToAggregator;
@@ -39,14 +41,15 @@
 
 import static java.util.Arrays.asList;
 import static org.elasticsearch.common.logging.LoggerMessageFormat.format;
+import static org.elasticsearch.xpack.esql.common.Failure.fail;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.FIRST;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.SECOND;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.THIRD;
-import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isNotNullAndFoldable;
+import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isNotNull;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isString;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isType;
 
-public class Top extends AggregateFunction implements ToAggregator, SurrogateExpression {
+public class Top extends AggregateFunction implements ToAggregator, SurrogateExpression, PostOptimizationVerificationAware {
     public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(Expression.class, "Top", Top::new);
 
     private static final String ORDER_ASC = "ASC";
@@ -116,16 +119,18 @@ Expression orderField() {
         return parameters().get(1);
     }
 
-    private int limitValue() {
-        return (int) limitField().fold(FoldContext.small() /* TODO remove me */);
-    }
-
-    private String orderRawValue() {
-        return BytesRefs.toString(orderField().fold(FoldContext.small() /* TODO remove me */));
+    private Integer limitValue() {
+        return FunctionUtils.limitValue(limitField(), sourceText());
     }
 
     private boolean orderValue() {
-        return orderRawValue().equalsIgnoreCase(ORDER_ASC);
+        if (orderField() instanceof Literal literal) {
+            String order = BytesRefs.toString(literal.value());
+            if (ORDER_ASC.equalsIgnoreCase(order) || ORDER_DESC.equalsIgnoreCase(order)) {
+                return order.equalsIgnoreCase(ORDER_ASC);
+            }
+        }
+        throw new EsqlIllegalArgumentException("Order value must be a literal, found: " + orderField());
     }
 
     @Override
@@ -148,31 +153,88 @@ protected TypeResolution resolveType() {
             "ip",
             "string",
             "numeric except unsigned_long or counter types"
-        ).and(isNotNullAndFoldable(limitField(), sourceText(), SECOND))
+        ).and(isNotNull(limitField(), sourceText(), SECOND))
             .and(isType(limitField(), dt -> dt == DataType.INTEGER, sourceText(), SECOND, "integer"))
-            .and(isNotNullAndFoldable(orderField(), sourceText(), THIRD))
+            .and(isNotNull(orderField(), sourceText(), THIRD))
             .and(isString(orderField(), sourceText(), THIRD));
 
         if (typeResolution.unresolved()) {
             return typeResolution;
         }
 
-        var limit = limitValue();
-        var order = orderRawValue();
-
-        if (limit <= 0) {
-            return new TypeResolution(format(null, "Limit must be greater than 0 in [{}], found [{}]", sourceText(), limit));
+        TypeResolution result = resolveTypeLimit();
+        if (result.equals(TypeResolution.TYPE_RESOLVED) == false) {
+            return result;
         }
-
-        if (order.equalsIgnoreCase(ORDER_ASC) == false && order.equalsIgnoreCase(ORDER_DESC) == false) {
-            return new TypeResolution(
-                format(null, "Invalid order value in [{}], expected [{}, {}] but got [{}]", sourceText(), ORDER_ASC, ORDER_DESC, order)
-            );
+        result = resolveTypeOrder();
+        if (result.equals(TypeResolution.TYPE_RESOLVED) == false) {
+            return result;
         }
+        return TypeResolution.TYPE_RESOLVED;
+    }
+
+    /**
+     * We check that the limit is not null and that if it is a literal, it is a positive integer
+     * We will do a more thorough check in the postOptimizationVerification once folding is done.
+     */
+    private TypeResolution resolveTypeLimit() {
+        return FunctionUtils.resolveTypeLimit(limitField(), sourceText());
+    }
 
+    /**
+     * We check that the order is not null and that if it is a literal, it is one of the two valid values: "asc" or "desc".
+     * We will do a more thorough check in the postOptimizationVerification once folding is done.
+     */
+    private TypeResolution resolveTypeOrder() {
+        Expression order = orderField();
+        if (order == null) {
+            return new TypeResolution(format(null, "Order must be a valid string in [{}], found [{}]", sourceText(), order));
+        }
+        if (order instanceof Literal literal) {
+            if (literal.value() == null) {
+                return new TypeResolution(
+                    format(null, "Invalid order value in [{}], expected [{}, {}] but got [{}]", sourceText(), ORDER_ASC, ORDER_DESC, order)
+                );
+            }
+            String value = BytesRefs.toString(literal.value());
+            if (value == null || value.equalsIgnoreCase(ORDER_ASC) == false && value.equalsIgnoreCase(ORDER_DESC) == false) {
+                return new TypeResolution(
+                    format(null, "Invalid order value in [{}], expected [{}, {}] but got [{}]", sourceText(), ORDER_ASC, ORDER_DESC, order)
+                );
+            }
+        }
         return TypeResolution.TYPE_RESOLVED;
     }
 
+    @Override
+    public void postOptimizationVerification(Failures failures) {
+        postOptimizationVerificationLimit(failures);
+        postOptimizationVerificationOrder(failures);
+    }
+
+    private void postOptimizationVerificationLimit(Failures failures) {
+        FunctionUtils.postOptimizationVerificationLimit(failures, limitField(), sourceText());
+    }
+
+    private void postOptimizationVerificationOrder(Failures failures) {
+        Expression order = orderField();
+        if (order == null) {
+            failures.add(fail(order, "Order must be a valid string in [{}], found [{}]", sourceText(), order));
+        }
+        if (order instanceof Literal literal) {
+            String value = BytesRefs.toString(literal.value());
+            if (value == null || value.equalsIgnoreCase(ORDER_ASC) == false && value.equalsIgnoreCase(ORDER_DESC) == false) {
+                failures.add(
+                    fail(order, "Invalid order value in [{}], expected [{}, {}] but got [{}]", sourceText(), ORDER_ASC, ORDER_DESC, order)
+                );
+            }
+        } else {
+            // it is expected that the expression is a literal after folding
+            // we fail if it is not a literal
+            failures.add(fail(order, "Order must be a valid string in [{}], found [{}]", sourceText(), order));
+        }
+    }
+
     @Override
     public DataType dataType() {
         return field().dataType().noText();
@@ -215,15 +277,20 @@ public AggregatorFunctionSupplier supplier() {
     @Override
     public Expression surrogate() {
         var s = source();
-
-        if (limitValue() == 1) {
-            if (orderValue()) {
-                return new Min(s, field());
-            } else {
-                return new Max(s, field());
+        try {
+            if (limitValue() == 1) {
+                if (orderValue()) {
+                    return new Min(s, field());
+                } else {
+                    return new Max(s, field());
+                }
             }
+        } catch (EsqlIllegalArgumentException e) {
+            // If the limit is not a literal or is not a positive integer, we cannot create a surrogate
+            // so we return null to indicate that no surrogate can be created.
+            // This is possible if the limit is an expression, and folding has not been done yet.
+            return null;
         }
-
         return null;
     }
 }