comment clean up

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

Author: RyanL1997

core/build.gradle

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

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

@@ -699,14 +699,12 @@ public LogicalPlan visitRegex(Regex node, AnalysisContext context) {
     Expression fieldExpr = expressionAnalyzer.analyze(node.getField(), context);
     Expression patternExpr = expressionAnalyzer.analyze(node.getPattern(), context);
 
-    // Create the RegexMatch expression directly
-    // This is our custom Java regex implementation
+    // Create the RegexMatch expression
     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;

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

@@ -33,7 +33,6 @@ public class Regex extends UnresolvedPlan {
   @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;

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

@@ -174,16 +174,16 @@ public RelNode visitFilter(Filter node, CalcitePlanContext context) {
   public RelNode visitRegex(Regex node, CalcitePlanContext context) {
     visitChildren(node, context);
 
-    // Create our Java regex RegexMatch expression directly, just like the legacy engine
-    // This ensures both engines use identical Java regex implementation
-
-    // Analyze the field and pattern expressions in the current context
+    // Analyze the field and pattern expressions
     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 Java regex support
-    RexNode regexCondition = createRegexMatchRexNode(fieldRex, patternRex, context);
+    // Create RexNode using the REGEX_MATCH UDF
+    RexNode regexCondition =
+        context.rexBuilder.makeCall(
+            org.opensearch.sql.expression.function.PPLBuiltinOperators.REGEX_MATCH,
+            fieldRex,
+            patternRex);
 
     // If negated, wrap with NOT
     if (node.isNegated()) {
@@ -194,14 +194,6 @@ public RelNode visitRegex(Regex node, CalcitePlanContext context) {
     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 Java regex 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/function/udf/RegexMatchFunctionImpl.java

@@ -67,7 +67,7 @@ public static Boolean eval(String field, String pattern) {
       return null;
     }
 
-    // Use Java regex library for evaluation (same logic as RegexMatch)
+    // Match using find() for partial match semantics
     try {
       Pattern compiledPattern = Pattern.compile(pattern);
       java.util.regex.Matcher matcher = compiledPattern.matcher(field);

core/src/main/java/org/opensearch/sql/expression/operator/predicate/RegexMatch.java

@@ -21,12 +21,9 @@
 import org.opensearch.sql.expression.env.Environment;
 
 /**
- * Expression for regex matching using Java's built-in regex engine. Supports Java regex features
- * including: - Named groups (?<name>...) - Lookahead/lookbehind (limited to fixed-width) -
- * Backreferences - Atomic groups (?>...) - Possessive quantifiers (*+, ++, etc.) - Inline flags
- * (?i), (?m), (?s), etc.
- *
- * <p>Note: Does not support PCRE-specific features like recursion (?R) or conditionals.
+ * Expression for regex matching using Java's built-in regex engine. Supports standard Java regex
+ * features including named groups, lookahead/lookbehind, backreferences, and inline flags. Uses
+ * find() for partial matching to align with SPL semantics.
  */
 @ToString
 @EqualsAndHashCode