implement regex cmd with calcite support by suing java library

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

Author: RyanL1997

core/build.gradle

@@ -34,6 +34,7 @@ plugins {
 
 repositories {
     mavenCentral()
+    maven { url 'https://jitpack.io' }
 }
 
 pitest {

core/src/main/java/org/opensearch/sql/analysis/Analyzer.java

@@ -77,6 +77,7 @@
 import org.opensearch.sql.ast.tree.Patterns;
 import org.opensearch.sql.ast.tree.Project;
 import org.opensearch.sql.ast.tree.RareTopN;
+import org.opensearch.sql.ast.tree.Regex;
 import org.opensearch.sql.ast.tree.Relation;
 import org.opensearch.sql.ast.tree.RelationSubquery;
 import org.opensearch.sql.ast.tree.Rename;
@@ -689,6 +690,28 @@ public LogicalPlan visitReverse(Reverse node, AnalysisContext context) {
         "REVERSE is supported only when " + CALCITE_ENGINE_ENABLED.getKeyValue() + "=true");
   }
 
+  @Override
+  public LogicalPlan visitRegex(Regex node, AnalysisContext context) {
+    // Get the child plan (source of data)
+    LogicalPlan child = node.getChild().get(0).accept(this, context);
+
+    // Analyze the field and pattern expressions
+    Expression fieldExpr = expressionAnalyzer.analyze(node.getField(), context);
+    Expression patternExpr = expressionAnalyzer.analyze(node.getPattern(), context);
+
+    // Create the RegexMatch expression directly
+    // This is our custom PCRE-based implementation
+    Expression regexExpr =
+        new org.opensearch.sql.expression.operator.predicate.RegexMatch(
+            fieldExpr, patternExpr, node.isNegated());
+
+    // Return a LogicalFilter with the regex condition
+    // No need for optimization since RegexMatch is already a concrete expression
+    LogicalFilter result = new LogicalFilter(child, regexExpr);
+
+    return result;
+  }
+
   @Override
   public LogicalPlan visitPaginate(Paginate paginate, AnalysisContext context) {
     LogicalPlan child = paginate.getChild().get(0).accept(this, context);

core/src/main/java/org/opensearch/sql/ast/AbstractNodeVisitor.java

@@ -66,6 +66,7 @@
 import org.opensearch.sql.ast.tree.Patterns;
 import org.opensearch.sql.ast.tree.Project;
 import org.opensearch.sql.ast.tree.RareTopN;
+import org.opensearch.sql.ast.tree.Regex;
 import org.opensearch.sql.ast.tree.Relation;
 import org.opensearch.sql.ast.tree.RelationSubquery;
 import org.opensearch.sql.ast.tree.Rename;
@@ -249,6 +250,10 @@ public T visitReverse(Reverse node, C context) {
     return visitChildren(node, context);
   }
 
+  public T visitRegex(Regex node, C context) {
+    return visitChildren(node, context);
+  }
+
   public T visitLambdaFunction(LambdaFunction node, C context) {
     return visitChildren(node, context);
   }

core/src/main/java/org/opensearch/sql/ast/tree/Regex.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.ast.tree;
+
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import org.opensearch.sql.ast.AbstractNodeVisitor;
+import org.opensearch.sql.ast.expression.Literal;
+import org.opensearch.sql.ast.expression.UnresolvedExpression;
+
+/** AST node represent Regex filtering operation. */
+@Getter
+@ToString
+@EqualsAndHashCode(callSuper = false)
+public class Regex extends UnresolvedPlan {
+  /** Field to match against. */
+  private final UnresolvedExpression field;
+
+  /** Whether this is a negated match (!=). */
+  private final boolean negated;
+
+  /** Pattern. */
+  private final Literal pattern;
+
+  /** Child Plan. */
+  @Setter private UnresolvedPlan child;
+
+  public Regex(UnresolvedExpression field, String operator, Literal pattern) {
+    // Require explicit field - no default to _source for PoC
+    this.field = field;
+    this.negated = "!=".equals(operator);
+    this.pattern = pattern;
+  }
+
+  @Override
+  public Regex attach(UnresolvedPlan child) {
+    this.child = child;
+    return this;
+  }
+
+  @Override
+  public List<UnresolvedPlan> getChild() {
+    return this.child == null ? ImmutableList.of() : ImmutableList.of(this.child);
+  }
+
+  @Override
+  public <T, C> T accept(AbstractNodeVisitor<T, C> nodeVisitor, C context) {
+    return nodeVisitor.visitRegex(this, context);
+  }
+}

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

@@ -97,6 +97,7 @@
 import org.opensearch.sql.ast.tree.Patterns;
 import org.opensearch.sql.ast.tree.Project;
 import org.opensearch.sql.ast.tree.RareTopN;
+import org.opensearch.sql.ast.tree.Regex;
 import org.opensearch.sql.ast.tree.Relation;
 import org.opensearch.sql.ast.tree.Rename;
 import org.opensearch.sql.ast.tree.Sort;
@@ -169,6 +170,38 @@ public RelNode visitFilter(Filter node, CalcitePlanContext context) {
     return context.relBuilder.peek();
   }
 
+  @Override
+  public RelNode visitRegex(Regex node, CalcitePlanContext context) {
+    visitChildren(node, 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()) {
+      regexCondition = context.rexBuilder.makeCall(SqlStdOperatorTable.NOT, regexCondition);
+    }
+
+    context.relBuilder.filter(regexCondition);
+    return context.relBuilder.peek();
+  }
+
+  private RexNode createRegexMatchRexNode(
+      RexNode field, RexNode pattern, CalcitePlanContext context) {
+    // Use the UDF version that has proper enumerable implementation support
+    // This ensures PCRE2 usage for both pushdown and in-memory execution
+    return context.rexBuilder.makeCall(
+        org.opensearch.sql.expression.function.PPLBuiltinOperators.REGEX_MATCH, field, pattern);
+  }
+
   private boolean containsSubqueryExpression(Node expr) {
     if (expr == null) {
       return false;

core/src/main/java/org/opensearch/sql/expression/ExpressionNodeVisitor.java

@@ -101,4 +101,14 @@ public T visitWhen(WhenClause node, C context) {
   public T visitNamedArgument(NamedArgumentExpression node, C context) {
     return visitNode(node, context);
   }
+
+  public T visitRegex(org.opensearch.sql.expression.operator.predicate.RegexMatch node, C context) {
+    // Visit field and pattern expressions to ensure field extraction works properly
+    T result = defaultResult();
+    T fieldResult = node.getField().accept(this, context);
+    result = aggregateResult(result, fieldResult);
+    T patternResult = node.getPattern().accept(this, context);
+    result = aggregateResult(result, patternResult);
+    return result;
+  }
 }

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 java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+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;
+
+/**
+ * REGEX_MATCH UDF implementation for Calcite engine. 
+ * This function provides Java 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 Java regex pattern
+   * @return Boolean result of regex match
+   */
+  public static Boolean eval(String field, String pattern) {
+    if (field == null || pattern == null) {
+      return null;
+    }
+
+    // Use Java regex library for evaluation (same logic as RegexMatch)
+    try {
+      Pattern compiledPattern = Pattern.compile(pattern);
+      java.util.regex.Matcher matcher = compiledPattern.matcher(field);
+      return matcher.find(); // Use find() for partial match like SPL
+    } catch (PatternSyntaxException e) {
+      throw new IllegalArgumentException("Invalid regex pattern: " + e.getMessage());
+    }
+  }
+}