Experiment: support type checking for built-in operators by accessing composition field of CompositeOperandTypeChecker via relection. May cause fatal errors if IllegalAccessException is thrown.

Signed-off-by: Yuanchun Shen <yuanchu@amazon.com>

Author: yuancu

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

@@ -38,12 +38,15 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.validate.SqlUserDefinedFunction;
 import org.apache.commons.lang3.function.TriFunction;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.opensearch.sql.calcite.utils.OpenSearchTypeFactory;
 import org.opensearch.sql.exception.ExpressionEvaluationException;
 import org.opensearch.sql.executor.QueryType;
 
 public class PPLFuncImpTable {
+  private static final Logger logger = LogManager.getLogger(PPLFuncImpTable.class);
 
   public interface FunctionImp {
     RexNode resolve(RexBuilder builder, RexNode... args);
@@ -186,7 +189,24 @@ void registerOperator(BuiltinFunctionName functionName, SqlOperator operator) {
         register(functionName, createCompositeFunctionImp(operator, compositeTypeChecker));
       } else if (typeChecker instanceof ImplicitCastOperandTypeChecker implicitCastTypeChecker) {
         register(functionName, createImplicitCastFunctionImp(operator, implicitCastTypeChecker));
+      } else if (typeChecker instanceof CompositeOperandTypeChecker compositeTypeChecker) {
+        try {
+          // If compositeTypeChecker contains operand checkers other than family type checkers or
+          // other than OR compositions, this will throw an IllegalArgumentException.
+          register(functionName, createCompositeFunctionImp(operator, compositeTypeChecker));
+        } catch (IllegalArgumentException e) {
+          // register without type checker
+          logger.debug(
+              "Cannot create composite type checker for function: {}. Will skip its type checking",
+              functionName);
+          register(
+              functionName,
+              (RexBuilder builder, RexNode... node) -> builder.makeCall(operator, node));
+        }
       } else {
+        logger.debug(
+            "Cannot create type checker for function: {}. Will skip its type checking",
+            functionName);
         register(
             functionName,
             (RexBuilder builder, RexNode... node) -> builder.makeCall(operator, node));

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

@@ -5,6 +5,7 @@
 
 package org.opensearch.sql.expression.function;
 
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -16,6 +17,7 @@
 import org.apache.calcite.sql.type.SqlOperandTypeChecker;
 import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.logging.log4j.LogManager;
 import org.opensearch.sql.calcite.utils.UserDefinedFunctionUtils;
 
 /**
@@ -228,6 +230,27 @@ static PPLFamilyTypeCheckerWrapper wrapFamily(ImplicitCastOperandTypeChecker typ
    * @throws IllegalArgumentException if any rule is not an {@link ImplicitCastOperandTypeChecker}
    */
   static PPLCompositeTypeChecker wrapComposite(CompositeOperandTypeChecker typeChecker) {
+    try {
+      Field compositionField = CompositeOperandTypeChecker.class.getDeclaredField("composition");
+      compositionField.setAccessible(true);
+      CompositeOperandTypeChecker.Composition composition =
+          (CompositeOperandTypeChecker.Composition) compositionField.get(typeChecker);
+      if (composition != CompositeOperandTypeChecker.Composition.OR) {
+        throw new IllegalArgumentException(
+            String.format(
+                "Currently only OR compositions of ImplicitCastOperandTypeChecker are supported,"
+                    + " but got %s composition",
+                composition.name()));
+      }
+    } catch (IllegalAccessException e) {
+      LogManager.getLogger(PPLTypeChecker.class).error(e);
+    } catch (NoSuchFieldException e) {
+      LogManager.getLogger(PPLTypeChecker.class)
+          .error(
+              "Failed to access the composition field of CompositeOperandTypeChecker. "
+                  + "This may indicate a change in the Calcite library.");
+    }
+
     for (SqlOperandTypeChecker rule : typeChecker.getRules()) {
       if (!(rule instanceof ImplicitCastOperandTypeChecker)) {
         throw new IllegalArgumentException(