fix calcite push down issue - make sure use PCRE when pushdown

Signed-off-by: Jialiang Liang <jiallian@amazon.com>

Author: RyanL1997

core/src/main/java/org/opensearch/sql/calcite/CalciteRelNodeVisitor.java

@@ -173,25 +173,35 @@ public RelNode visitFilter(Filter node, CalcitePlanContext context) {
   @Override
   public RelNode visitRegex(Regex node, CalcitePlanContext context) {
     visitChildren(node, context);
-    // For Calcite engine, use REGEXP function but the RegexMatch expression will be executed
-    // with PCRE2 support in the script engine during pushdown
-    List<UnresolvedExpression> args = new ArrayList<>();
-    args.add(node.getField());
-    args.add(node.getPattern());
 
-    // Use the standard REGEXP function - the PCRE2 execution happens in the script engine
-    Function regexFunction = new Function("regexp", args);
-    RexNode condition = rexVisitor.analyze(regexFunction, context);
+    // Create our PCRE2 RegexMatch expression directly, just like the legacy engine
+    // This ensures both engines use identical PCRE2 implementation
+
+    // Analyze the field and pattern expressions in the current context
+    RexNode fieldRex = rexVisitor.analyze(node.getField(), context);
+    RexNode patternRex = rexVisitor.analyze(node.getPattern(), context);
+
+    // Create a custom RexNode that represents our RegexMatch expression
+    // This will be handled by the script engine with PCRE2 support
+    RexNode regexCondition = createRegexMatchRexNode(fieldRex, patternRex, context);
 
     // If negated, wrap with NOT
     if (node.isNegated()) {
-      condition = context.rexBuilder.makeCall(SqlStdOperatorTable.NOT, condition);
+      regexCondition = context.rexBuilder.makeCall(SqlStdOperatorTable.NOT, regexCondition);
     }
 
-    context.relBuilder.filter(condition);
+    context.relBuilder.filter(regexCondition);
     return context.relBuilder.peek();
   }
 
+  private RexNode createRegexMatchRexNode(
+      RexNode field, RexNode pattern, CalcitePlanContext context) {
+    // Create a function call that will be specifically handled by our script engine
+    // This bypasses the standard regex routing and ensures PCRE2 usage
+    return context.rexBuilder.makeCall(
+        org.opensearch.sql.calcite.rex.RegexMatchOperator.INSTANCE, field, pattern);
+  }
+
   private boolean containsSubqueryExpression(Node expr) {
     if (expr == null) {
       return false;

core/src/main/java/org/opensearch/sql/calcite/rex/RegexMatchOperator.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.calcite.rex;
+
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlSyntax;
+import org.apache.calcite.sql.type.OperandTypes;
+import org.apache.calcite.sql.type.ReturnTypes;
+
+/**
+ * Custom Calcite operator for PCRE2 regex matching. This operator represents our RegexMatch
+ * expression and ensures PCRE2 support when pushed down to the script engine.
+ */
+public class RegexMatchOperator extends SqlOperator {
+
+  public static final RegexMatchOperator INSTANCE = new RegexMatchOperator();
+
+  private RegexMatchOperator() {
+    super(
+        "REGEX_MATCH",
+        SqlKind.OTHER_FUNCTION,
+        20,
+        false,
+        ReturnTypes.BOOLEAN,
+        null,
+        OperandTypes.STRING_STRING);
+  }
+
+  @Override
+  public SqlSyntax getSyntax() {
+    return SqlSyntax.FUNCTION;
+  }
+}

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

@@ -215,6 +215,7 @@ public enum BuiltinFunctionName {
   LTRIM(FunctionName.of("ltrim")),
   POSITION(FunctionName.of("position")),
   REGEXP(FunctionName.of("regexp")),
+  REGEX_MATCH(FunctionName.of("REGEX_MATCH")),
   REPLACE(FunctionName.of("replace")),
   REVERSE(FunctionName.of("reverse")),
   RIGHT(FunctionName.of("right")),

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

@@ -380,6 +380,10 @@ public class PPLBuiltinOperators extends ReflectiveSqlOperatorTable {
   public static final SqlOperator NUMBER_TO_STRING =
       new NumberToStringFunction().toUDF("NUMBER_TO_STRING");
 
+  // Custom PCRE2 regex operator for Calcite engine
+  public static final SqlOperator REGEX_MATCH =
+      new org.opensearch.sql.expression.function.udf.RegexMatchFunctionImpl().toUDF("REGEX_MATCH");
+
   /**
    * Returns the PPL specific operator table, creating it if necessary.
    *

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

@@ -161,6 +161,7 @@
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.RAND;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.REDUCE;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.REGEXP;
+import static org.opensearch.sql.expression.function.BuiltinFunctionName.REGEX_MATCH;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.REPLACE;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.REVERSE;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.RIGHT;
@@ -844,6 +845,7 @@ void populate() {
       registerOperator(SIMPLE_QUERY_STRING, PPLBuiltinOperators.SIMPLE_QUERY_STRING);
       registerOperator(QUERY_STRING, PPLBuiltinOperators.QUERY_STRING);
       registerOperator(MULTI_MATCH, PPLBuiltinOperators.MULTI_MATCH);
+      registerOperator(REGEX_MATCH, PPLBuiltinOperators.REGEX_MATCH);
 
       // Register PPL Datetime UDF operator
       registerOperator(TIMESTAMP, PPLBuiltinOperators.TIMESTAMP);

core/src/main/java/org/opensearch/sql/expression/function/udf/RegexMatchFunctionImpl.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.expression.function.udf;
+
+import java.util.List;
+import org.apache.calcite.adapter.enumerable.NotNullImplementor;
+import org.apache.calcite.adapter.enumerable.NullPolicy;
+import org.apache.calcite.adapter.enumerable.RexImpTable;
+import org.apache.calcite.adapter.enumerable.RexToLixTranslator;
+import org.apache.calcite.linq4j.tree.Expression;
+import org.apache.calcite.linq4j.tree.Types;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.schema.impl.ScalarFunctionImpl;
+import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlReturnTypeInference;
+import org.opensearch.sql.expression.function.ImplementorUDF;
+import org.opensearch.sql.expression.function.UDFOperandMetadata;
+import org.pcre4j.regex.Pattern;
+
+/**
+ * REGEX_MATCH UDF implementation for Calcite engine. This function provides PCRE2 regex matching
+ * via script query pushdown.
+ */
+public class RegexMatchFunctionImpl extends ImplementorUDF {
+
+  public RegexMatchFunctionImpl() {
+    super(new RegexMatchImplementor(), NullPolicy.ANY);
+  }
+
+  @Override
+  public SqlReturnTypeInference getReturnTypeInference() {
+    return ReturnTypes.BOOLEAN_FORCE_NULLABLE;
+  }
+
+  @Override
+  public UDFOperandMetadata getOperandMetadata() {
+    return null;
+  }
+
+  public static class RegexMatchImplementor implements NotNullImplementor {
+    @Override
+    public Expression implement(
+        RexToLixTranslator translator, RexCall call, List<Expression> translatedOperands) {
+      ScalarFunctionImpl function =
+          (ScalarFunctionImpl)
+              ScalarFunctionImpl.create(
+                  Types.lookupMethod(
+                      RegexMatchFunctionImpl.class, "eval", String.class, String.class));
+      return function.getImplementor().implement(translator, call, RexImpTable.NullAs.NULL);
+    }
+  }
+
+  /**
+   * Evaluation method for REGEX_MATCH function. This method is called by Calcite's generated code
+   * during execution.
+   *
+   * @param field The field value to match against
+   * @param pattern The PCRE2 regex pattern
+   * @return Boolean result of regex match
+   */
+  public static Boolean eval(String field, String pattern) {
+    if (field == null || pattern == null) {
+      return null;
+    }
+
+    // Use PCRE4J library directly for evaluation (same logic as RegexMatch)
+    try {
+      Pattern compiledPattern = Pattern.compile(pattern);
+      org.pcre4j.regex.Matcher matcher = compiledPattern.matcher(field);
+      return matcher.find(); // Use find() for partial match like SPL
+    } catch (Exception e) {
+      // Invalid regex pattern or other error
+      return false;
+    }
+  }
+}

opensearch/src/main/java/org/opensearch/sql/opensearch/storage/script/filter/FilterQueryBuilder.java

@@ -113,6 +113,9 @@ public QueryBuilder visitFunction(FunctionExpression func, Object context) {
         throw new SyntaxCheckException(
             "Invalid syntax used for nested function in WHERE clause: "
                 + "nested(field | field, path) OPERATOR LITERAL");
+      case "REGEX_MATCH":
+        // Handle our custom PCRE2 regex operator from Calcite engine
+        return buildScriptQueryForRegex(createRegexMatchFromFunction(func));
       default:
         {
           LuceneQuery query = luceneQueries.get(name);
@@ -178,4 +181,20 @@ private ScriptQueryBuilder buildScriptQueryForRegex(RegexMatch regexMatch) {
                 ScriptEngineType.V2, serializer.serialize(regexMatch)),
             emptyMap()));
   }
+
+  /**
+   * Convert a REGEX_MATCH function from Calcite to our PCRE2 RegexMatch expression. This ensures
+   * the Calcite engine uses the same PCRE2 implementation as the legacy engine.
+   */
+  private RegexMatch createRegexMatchFromFunction(FunctionExpression func) {
+    if (func.getArguments().size() != 2) {
+      throw new IllegalArgumentException("REGEX_MATCH function requires exactly 2 arguments");
+    }
+
+    Expression fieldExpr = func.getArguments().get(0);
+    Expression patternExpr = func.getArguments().get(1);
+
+    // Create RegexMatch with PCRE2 support
+    return new RegexMatch(fieldExpr, patternExpr, false);
+  }
 }