code hygiene fix

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

Author: RyanL1997

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

@@ -700,7 +700,7 @@ public LogicalPlan visitRegex(Regex node, AnalysisContext context) {
     Expression patternExpr = expressionAnalyzer.analyze(node.getPattern(), context);
 
     // Create the RegexMatch expression directly
-    // This is our custom PCRE-based implementation
+    // This is our custom Java regex implementation
     Expression regexExpr =
         new org.opensearch.sql.expression.operator.predicate.RegexMatch(
             fieldExpr, patternExpr, node.isNegated());

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

@@ -174,15 +174,15 @@ public RelNode visitFilter(Filter node, CalcitePlanContext context) {
   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
+    // 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
     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
+    // This will be handled by the script engine with Java regex support
     RexNode regexCondition = createRegexMatchRexNode(fieldRex, patternRex, context);
 
     // If negated, wrap with NOT
@@ -197,7 +197,7 @@ public RelNode visitRegex(Regex node, CalcitePlanContext context) {
   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
+    // 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);
   }

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

@@ -380,7 +380,7 @@ 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
+  // Custom regex operator for Calcite engine
   public static final SqlOperator REGEX_MATCH =
       new org.opensearch.sql.expression.function.udf.RegexMatchFunctionImpl().toUDF("REGEX_MATCH");
 

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

@@ -22,8 +22,8 @@
 import org.opensearch.sql.expression.function.UDFOperandMetadata;
 
 /**
- * REGEX_MATCH UDF implementation for Calcite engine. 
- * This function provides Java regex matching via script query pushdown.
+ * REGEX_MATCH UDF implementation for Calcite engine. This function provides Java regex matching via
+ * script query pushdown.
  */
 public class RegexMatchFunctionImpl extends ImplementorUDF {
 

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

@@ -21,16 +21,12 @@
 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.
- * 
- * Note: Does not support PCRE-specific features like recursion (?R) or conditionals.
+ * 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.
  */
 @ToString
 @EqualsAndHashCode
@@ -47,7 +43,6 @@ public class RegexMatch implements Expression {
   // Maximum cache size to prevent memory issues
   private static final int MAX_CACHE_SIZE = 1000;
 
-
   public RegexMatch(Expression field, Expression pattern, boolean negated) {
     this.field = field;
     this.pattern = pattern;

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

@@ -114,7 +114,7 @@ public QueryBuilder visitFunction(FunctionExpression func, Object context) {
             "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
+        // Handle our custom regex operator from Calcite engine
         return buildScriptQueryForRegex(createRegexMatchFromFunction(func));
       default:
         {
@@ -159,7 +159,7 @@ private ScriptQueryBuilder buildScriptQuery(FunctionExpression node) {
   }
 
   /**
-   * Visit RegexMatch expression and convert to script query. This allows PCRE regex evaluation to
+   * Visit RegexMatch expression and convert to script query. This allows Java regex evaluation to
    * be pushed down to OpenSearch data nodes.
    */
   public QueryBuilder visitRegex(RegexMatch regexMatch, Object context) {
@@ -183,8 +183,8 @@ private ScriptQueryBuilder buildScriptQueryForRegex(RegexMatch regexMatch) {
   }
 
   /**
-   * 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.
+   * Convert a REGEX_MATCH function from Calcite to our Java regex RegexMatch expression. This
+   * ensures the Calcite engine uses the same Java regex implementation as the legacy engine.
    */
   private RegexMatch createRegexMatchFromFunction(FunctionExpression func) {
     if (func.getArguments().size() != 2) {
@@ -194,7 +194,7 @@ private RegexMatch createRegexMatchFromFunction(FunctionExpression func) {
     Expression fieldExpr = func.getArguments().get(0);
     Expression patternExpr = func.getArguments().get(1);
 
-    // Create RegexMatch with PCRE2 support
+    // Create RegexMatch with Java regex support
     return new RegexMatch(fieldExpr, patternExpr, false);
   }
 }