Reimplement atan, sqrt, strcmp, xor with SqlCall rewrite

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

Author: yuancu

core/src/main/java/org/opensearch/sql/calcite/validate/PplOpTable.java

@@ -101,6 +101,7 @@ private BuiltinFunctionName sqlFunctionNameToPplFunctionName(String name) {
       case "CONVERT" -> BuiltinFunctionName.CONV;
       case "ILIKE" -> BuiltinFunctionName.LIKE;
       case "CHAR_LENGTH" -> BuiltinFunctionName.LENGTH;
+      case "NOT_EQUALS", "<>" -> BuiltinFunctionName.XOR;
       default -> BuiltinFunctionName.of(name).orElse(null);
     };
   }

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

@@ -130,7 +130,7 @@ public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
           return super.rewriteCall(validator, call);
         }
       };
-  public static final SqlOperator ATAN =
+  public static final SqlFunction ATAN =
       new SqlFunction(
           "ATAN",
           SqlKind.OTHER_FUNCTION,
@@ -149,6 +149,24 @@ public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
         }
       };
 
+  public static final SqlFunction SQRT =
+      new SqlFunction(
+          "SQRT",
+          SqlKind.OTHER_FUNCTION,
+          ReturnTypes.DOUBLE_NULLABLE,
+          null,
+          OperandTypes.NUMERIC,
+          SqlFunctionCategory.USER_DEFINED_FUNCTION) {
+        @Override
+        public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
+          // Rewrite SQRT(x) to POWER(x, 0.5)
+          return SqlStdOperatorTable.POWER.createCall(
+              call.getParserPosition(),
+              call.operand(0),
+              SqlLiteral.createExactNumeric("0.5", call.getParserPosition()));
+        }
+      };
+
   // String functions
   public static final SqlFunction TRIM =
       new SqlFunction(
@@ -235,6 +253,21 @@ public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
   // Condition function
   public static final SqlOperator EARLIEST = new EarliestFunction().toUDF("EARLIEST");
   public static final SqlOperator LATEST = new LatestFunction().toUDF("LATEST");
+  public static final SqlFunction XOR =
+      new SqlFunction(
+          "XOR",
+          SqlKind.OTHER_FUNCTION,
+          ReturnTypes.BOOLEAN_NULLABLE,
+          null,
+          OperandTypes.BOOLEAN_BOOLEAN,
+          SqlFunctionCategory.USER_DEFINED_FUNCTION) {
+        @Override
+        public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
+          // Rewrite XOR(x, y) to NOT_EQUALS(x, y)
+          return SqlStdOperatorTable.NOT_EQUALS.createCall(
+              call.getParserPosition(), call.operand(0), call.operand(1));
+        }
+      };
 
   // Datetime function
   public static final SqlOperator TIMESTAMP = new TimestampFunction().toUDF("TIMESTAMP");

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

@@ -214,7 +214,6 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -332,6 +331,18 @@ default PPLTypeChecker getTypeChecker() {
     final AggBuilder aggBuilder = new AggBuilder();
     aggBuilder.populate();
     INSTANCE = new PPLFuncImpTable(builder, aggBuilder);
+
+    // Some operators are registered via register instead of registerOperator
+    // We add them explicitly so that they can be found during validation
+    var pplOps = PplOpTable.getInstance();
+    pplOps.add(JSON_ARRAY, SqlStdOperatorTable.JSON_ARRAY);
+    pplOps.add(JSON_OBJECT, SqlStdOperatorTable.JSON_OBJECT);
+    pplOps.add(INTERNAL_ITEM, SqlStdOperatorTable.ITEM);
+    // pplOps.add(TYPEOF, ... );
+    pplOps.add(IF, SqlStdOperatorTable.CASE);
+    pplOps.add(NULLIF, SqlStdOperatorTable.CASE);
+    pplOps.add(IS_EMPTY, SqlStdOperatorTable.IS_EMPTY);
+    pplOps.add(IS_BLANK, SqlStdOperatorTable.IS_EMPTY);
   }
 
   /**
@@ -535,7 +546,9 @@ private static void registerToCatalogWithReplace(
               TRIM,
               SqlStdOperatorTable.TRIM,
               STRCMP,
-              SqlLibraryOperators.STRCMP);
+              SqlLibraryOperators.STRCMP,
+              XOR,
+              SqlStdOperatorTable.NOT_EQUALS);
       PplOpTable.getInstance().add(functionName, replacement.getOrDefault(functionName, operator));
     }
 
@@ -720,6 +733,9 @@ void populate() {
       registerOperator(CRC32, PPLBuiltinOperators.CRC32);
       registerOperator(DIVIDE, PPLBuiltinOperators.DIVIDE);
       registerOperator(DIVIDEFUNCTION, PPLBuiltinOperators.DIVIDE);
+      // SqlStdOperatorTable.SQRT is declared but not implemented. The call to SQRT in Calcite is
+      // converted to POWER(x, 0.5).
+      registerOperator(SQRT, PPLBuiltinOperators.SQRT);
       registerOperator(SHA2, PPLBuiltinOperators.SHA2);
       registerOperator(CIDRMATCH, PPLBuiltinOperators.CIDRMATCH);
       registerOperator(INTERNAL_GROK, PPLBuiltinOperators.GROK);
@@ -860,23 +876,12 @@ void populate() {
                   OperandTypes.family(SqlTypeFamily.ARRAY, SqlTypeFamily.INTEGER)
                       .or(OperandTypes.family(SqlTypeFamily.MAP, SqlTypeFamily.ANY)),
               false));
-      // SqlStdOperatorTable.SQRT is declared but not implemented. The call to SQRT in Calcite is
-      // converted to POWER(x, 0.5).
-      register(
-          SQRT,
-          createFunctionImpWithTypeChecker(
-              (builder, arg) ->
-                  builder.makeCall(
-                      SqlStdOperatorTable.POWER,
-                      arg,
-                      builder.makeApproxLiteral(BigDecimal.valueOf(0.5))),
-              PPLTypeChecker.family(SqlTypeFamily.NUMERIC)));
       register(
           TYPEOF,
           (FunctionImp1)
               (builder, arg) ->
                   builder.makeLiteral(getLegacyTypeName(arg.getType(), QueryType.PPL)));
-      register(XOR, new XOR_FUNC());
+      registerOperator(XOR, PPLBuiltinOperators.XOR);
       // SqlStdOperatorTable.CASE.getOperandTypeChecker is null. We manually create a type checker
       // for it. The second and third operands are required to be of the same type. If not,
       // it will throw an IllegalArgumentException with information Can't find leastRestrictive type