Implement Parameter Validation for PPL functions on Calcite

core/src/main/java/org/opensearch/sql/calcite/utils/OpenSearchTypeFactory.java

@@ -245,7 +245,7 @@ public static ExprType convertSqlTypeNameToExprType(SqlTypeName sqlTypeName) {
       case ARRAY -> ARRAY;
       case MAP -> STRUCT;
       case GEOMETRY -> GEO_POINT;
-      case NULL -> UNDEFINED;
+      case NULL, ANY -> UNDEFINED;
       default -> UNKNOWN;
     };
   }

core/src/main/java/org/opensearch/sql/calcite/utils/PPLOperandTypes.java

@@ -0,0 +1,64 @@
+/*
+ *
+ *  * Copyright OpenSearch Contributors
+ *  * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+package org.opensearch.sql.calcite.utils;
+
+import org.apache.calcite.sql.type.CompositeOperandTypeChecker;
+import org.apache.calcite.sql.type.FamilyOperandTypeChecker;
+import org.apache.calcite.sql.type.OperandTypes;
+import org.apache.calcite.sql.type.SqlTypeFamily;
+import org.opensearch.sql.expression.function.UDFOperandMetadata;
+
+/**
+ * This class contains common operand types for PPL functions. They are created by either wrapping a
+ * {@link FamilyOperandTypeChecker} or a {@link CompositeOperandTypeChecker} with a {@link
+ * UDFOperandMetadata}.
+ */
+public class PPLOperandTypes {
+  // This class is not meant to be instantiated.
+  private PPLOperandTypes() {}
+
+  public static final UDFOperandMetadata NONE = UDFOperandMetadata.wrap(OperandTypes.family());
+  public static final UDFOperandMetadata OPTIONAL_INTEGER =
+      UDFOperandMetadata.wrap(
+          (CompositeOperandTypeChecker) OperandTypes.INTEGER.or(OperandTypes.family()));
+  public static final UDFOperandMetadata STRING =
+      UDFOperandMetadata.wrap((FamilyOperandTypeChecker) OperandTypes.STRING);
+  public static final UDFOperandMetadata INTEGER =
+      UDFOperandMetadata.wrap((FamilyOperandTypeChecker) OperandTypes.INTEGER);
+  public static final UDFOperandMetadata NUMERIC =
+      UDFOperandMetadata.wrap((FamilyOperandTypeChecker) OperandTypes.NUMERIC);
+  public static final UDFOperandMetadata INTEGER_INTEGER =
+      UDFOperandMetadata.wrap((FamilyOperandTypeChecker) OperandTypes.INTEGER_INTEGER);
+  public static final UDFOperandMetadata STRING_STRING =
+      UDFOperandMetadata.wrap(OperandTypes.STRING_STRING);
+  public static final UDFOperandMetadata NUMERIC_NUMERIC =
+      UDFOperandMetadata.wrap((FamilyOperandTypeChecker) OperandTypes.NUMERIC_NUMERIC);
+  public static final UDFOperandMetadata NUMERIC_NUMERIC_NUMERIC =
+      UDFOperandMetadata.wrap(
+          OperandTypes.family(SqlTypeFamily.NUMERIC, SqlTypeFamily.NUMERIC, SqlTypeFamily.NUMERIC));
+
+  public static final UDFOperandMetadata DATETIME_OR_STRING =
+      UDFOperandMetadata.wrap(
+          (CompositeOperandTypeChecker) OperandTypes.DATETIME.or(OperandTypes.STRING));
+  public static final UDFOperandMetadata DATETIME_DATETIME =
+      UDFOperandMetadata.wrap(OperandTypes.family(SqlTypeFamily.DATETIME, SqlTypeFamily.DATETIME));
+  public static final UDFOperandMetadata DATETIME_OR_STRING_DATETIME_OR_STRING =
+      UDFOperandMetadata.wrap(
+          (CompositeOperandTypeChecker)
+              OperandTypes.STRING_STRING
+                  .or(OperandTypes.family(SqlTypeFamily.DATETIME, SqlTypeFamily.DATETIME))
+                  .or(OperandTypes.family(SqlTypeFamily.DATETIME, SqlTypeFamily.STRING))
+                  .or(OperandTypes.family(SqlTypeFamily.STRING, SqlTypeFamily.DATETIME)));
+  public static final UDFOperandMetadata TIME_OR_TIMESTAMP_OR_STRING =
+      UDFOperandMetadata.wrap(
+          (CompositeOperandTypeChecker)
+              OperandTypes.STRING.or(OperandTypes.TIME).or(OperandTypes.TIMESTAMP));
+  public static final UDFOperandMetadata DATE_OR_TIMESTAMP_OR_STRING =
+      UDFOperandMetadata.wrap(
+          (CompositeOperandTypeChecker) OperandTypes.DATE_OR_TIMESTAMP.or(OperandTypes.STRING));
+}

core/src/main/java/org/opensearch/sql/calcite/utils/UserDefinedFunctionUtils.java

@@ -15,6 +15,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.TimeZone;
+import javax.annotation.Nullable;
 import org.apache.calcite.DataContext;
 import org.apache.calcite.adapter.enumerable.NotNullImplementor;
 import org.apache.calcite.adapter.enumerable.NullPolicy;
@@ -34,12 +35,14 @@
 import org.apache.calcite.sql.validate.SqlUserDefinedAggFunction;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.util.Optionality;
+import org.opensearch.sql.calcite.type.AbstractExprRelDataType;
 import org.opensearch.sql.calcite.udf.UserDefinedAggFunction;
 import org.opensearch.sql.data.model.ExprValueUtils;
 import org.opensearch.sql.data.type.ExprType;
 import org.opensearch.sql.executor.QueryType;
 import org.opensearch.sql.expression.function.FunctionProperties;
 import org.opensearch.sql.expression.function.ImplementorUDF;
+import org.opensearch.sql.expression.function.UDFOperandMetadata;
 
 public class UserDefinedFunctionUtils {
 
@@ -88,7 +91,20 @@ static SqlReturnTypeInference getReturnTypeInferenceForArray() {
     };
   }
 
-  // TODO: pass the function properties directly to the UDF instead of string
+  public static SqlTypeName convertRelDataTypeToSqlTypeName(RelDataType type) {
+    if (type instanceof AbstractExprRelDataType<?> exprType) {
+      return switch (exprType.getUdt()) {
+        case EXPR_DATE -> SqlTypeName.DATE;
+        case EXPR_TIME -> SqlTypeName.TIME;
+        case EXPR_TIMESTAMP -> SqlTypeName.TIMESTAMP;
+        case EXPR_IP -> SqlTypeName.VARCHAR;
+        case EXPR_BINARY -> SqlTypeName.VARBINARY;
+        default -> type.getSqlTypeName();
+      };
+    }
+    return type.getSqlTypeName();
+  }
+
   public static FunctionProperties restoreFunctionProperties(DataContext dataContext) {
     long currentTimeInNanos = DataContext.Variable.UTC_TIMESTAMP.get(dataContext);
     Instant instant =
@@ -148,13 +164,15 @@ public static List<Expression> convertToExprValues(
    * @param methodName the name of the method
    * @param returnTypeInference the return type inference of the UDF
    * @param nullPolicy the null policy of the UDF
+   * @param operandMetadata type checker
    * @return an adapted ImplementorUDF with the expr method, which is a UserDefinedFunctionBuilder
    */
   public static ImplementorUDF adaptExprMethodToUDF(
       java.lang.reflect.Type type,
       String methodName,
       SqlReturnTypeInference returnTypeInference,
-      NullPolicy nullPolicy) {
+      NullPolicy nullPolicy,
+      @Nullable UDFOperandMetadata operandMetadata) {
     NotNullImplementor implementor =
         (translator, call, translatedOperands) -> {
           List<Expression> operands =
@@ -168,6 +186,11 @@ public static ImplementorUDF adaptExprMethodToUDF(
       public SqlReturnTypeInference getReturnTypeInference() {
         return returnTypeInference;
       }
+
+      @Override
+      public UDFOperandMetadata getOperandMetadata() {
+        return operandMetadata;
+      }
     };
   }
 
@@ -185,7 +208,8 @@ public static ImplementorUDF adaptExprMethodWithPropertiesToUDF(
       java.lang.reflect.Type type,
       String methodName,
       SqlReturnTypeInference returnTypeInference,
-      NullPolicy nullPolicy) {
+      NullPolicy nullPolicy,
+      UDFOperandMetadata operandMetadata) {
     NotNullImplementor implementor =
         (translator, call, translatedOperands) -> {
           List<Expression> operands =
@@ -200,6 +224,11 @@ public static ImplementorUDF adaptExprMethodWithPropertiesToUDF(
       public SqlReturnTypeInference getReturnTypeInference() {
         return returnTypeInference;
       }
+
+      @Override
+      public UDFOperandMetadata getOperandMetadata() {
+        return operandMetadata;
+      }
     };
   }
 }

core/src/main/java/org/opensearch/sql/exception/CalciteUnsupportedException.java

@@ -10,4 +10,8 @@ public class CalciteUnsupportedException extends QueryEngineException {
   public CalciteUnsupportedException(String message) {
     super(message);
   }
+
+  public CalciteUnsupportedException(String message, Throwable cause) {
+    super(message, cause);
+  }
 }

core/src/main/java/org/opensearch/sql/exception/ExpressionEvaluationException.java

@@ -7,7 +7,12 @@
 
 /** Exception for Expression Evaluation. */
 public class ExpressionEvaluationException extends QueryEngineException {
+
   public ExpressionEvaluationException(String message) {
     super(message);
   }
+
+  public ExpressionEvaluationException(String message, Throwable cause) {
+    super(message, cause);
+  }
 }

core/src/main/java/org/opensearch/sql/executor/QueryService.java

@@ -113,7 +113,7 @@ public void executeWithCalcite(
       } else {
         if (t instanceof Error) {
           // Calcite may throw AssertError during query execution.
-          listener.onFailure(new CalciteUnsupportedException(t.getMessage()));
+          listener.onFailure(new CalciteUnsupportedException(t.getMessage(), t));
         } else {
           listener.onFailure((Exception) t);
         }

core/src/main/java/org/opensearch/sql/expression/function/CalciteFuncSignature.java

@@ -5,26 +5,18 @@
 
 package org.opensearch.sql.expression.function;
 
-import static org.opensearch.sql.expression.function.PPLFuncImpTable.FunctionImp.ANY_TYPE;
-
 import java.util.List;
 import org.apache.calcite.rel.type.RelDataType;
 
 /** Function signature is composed by function name and arguments list. */
-public record CalciteFuncSignature(FunctionName functionName, List<RelDataType> funcArgTypes) {
+public record CalciteFuncSignature(FunctionName functionName, PPLTypeChecker typeChecker) {
 
   public boolean match(FunctionName functionName, List<RelDataType> paramTypeList) {
-    if (funcArgTypes == null) return true;
-    if (!functionName.equals(this.functionName()) || paramTypeList.size() != funcArgTypes.size()) {
-      return false;
-    }
-    for (int i = 0; i < paramTypeList.size(); i++) {
-      RelDataType paramType = paramTypeList.get(i);
-      RelDataType funcType = funcArgTypes.get(i);
-      if (ANY_TYPE != funcType && paramType.getFamily() != funcType.getFamily()) {
-        return false;
-      }
-    }
-    return true;
+    if (!functionName.equals(this.functionName())) return false;
+    // For complex type checkers (e.g., OperandTypes.COMPARABLE_UNORDERED_COMPARABLE_UNORDERED),
+    // the typeChecker will be null because only simple family-based type checks are currently
+    // supported.
+    if (typeChecker == null) return true;
+    return typeChecker.checkOperandTypes(paramTypeList);
   }
 }