fix(opensearch): collapse 4-arg REGEXP_REPLACE_PG_4 'g' to 3-arg at script pushdown

The `feat(core)` commit on this branch lowered PPL `patterns` to a 4-arg
`REGEXP_REPLACE_PG_4(field, pattern, replacement, 'g')` so DataFusion (which
defaults to first-match-only) does global replacement on the analytics-engine
route. Calcite's enumerable runtime — which the V2 / Calcite-pushdown path uses
to compile the serialized RexCall into Janino bytecode — has no matching
`SqlFunctions.regexpReplace(String, String, String, String)` impl (only
`(String, String, String, int[, ...])` variants where the 4th arg is start
position, not a flags string). Janino codegen failed with
`No applicable constructor/method found` for the 4-arg-with-flags call shape,
breaking the patterns.md doctest (`source=apache | patterns message
method=simple_pattern mode=aggregation`).

Two complementary fixes:

1. `RexStandardizer.visitCall`: before serializing for pushdown, collapse
   `REGEXP_REPLACE_PG_4(field, pattern, replacement, 'g')` to the 3-arg
   `REGEXP_REPLACE_3` form. Safe because Calcite's 3-arg variant is already
   replace-all (same semantics as PG_4 with `g`). Only fires when the flags
   literal is exactly `"g"` so any future `i`/`m`/etc. use cases pass through
   untouched.

2. `ExtendedRelJson.toOp`: pass operand count when looking up an operator on
   the deserialization side so multi-arity SQL names (REGEXP_REPLACE_3 vs
   REGEXP_REPLACE_PG_4 vs REGEXP_REPLACE_5 all share `name="REGEXP_REPLACE"`)
   resolve to the right overload. Defensive — the standardizer fix above is
   what actually unblocks the doctest, but the resolver was picking by name
   alone and would have surfaced the same bug for any other overloaded
   builtin.

Verified locally:
- doctest queries (`patterns ... method=simple_pattern mode=aggregation [...]`)
  now return fully-tokenized output;
- `CalcitePPLDashboardPatternsIT` still 1/1 PASS;
- `CalcitePPLPatternsIT` still 10/15 with the same five known-pending failures
  (LogicalCorrelate + `_ShowNumberedToken` BRAIN cases).

Signed-off-by: Kai Huang <ahkcs@amazon.com>

Author: ahkcs

opensearch/src/main/java/org/opensearch/sql/opensearch/storage/serde/ExtendedRelJson.java

@@ -460,7 +460,8 @@ RexNode toRex(RelInput relInput, @PolyNull Object o) {
               distinct,
               false);
         } else {
-          final SqlOperator operator = requireNonNull(toOp(opMap), "operator");
+          final SqlOperator operator =
+              requireNonNull(toOp(opMap, rexOperands.size()), "operator");
           final RelDataType type;
           if (jsonType != null) {
             type = toType(typeFactory, jsonType);
@@ -553,6 +554,22 @@ private static <T extends Object> T get(Map<String, ? extends @Nullable Object>
 
   // Copied from RelJson for the usage of custom operatorTable
   @Nullable SqlOperator toOp(Map<String, ? extends @Nullable Object> map) {
+    return toOp(map, -1);
+  }
+
+  /**
+   * Look up an operator matching the {@code map}'s {@code name} / {@code kind} / {@code syntax}.
+   *
+   * <p>When {@code operandCount >= 0}, prefer an overload whose declared operand-count range
+   * accepts {@code operandCount} — Calcite registers multiple operators under the same SQL name
+   * with different arities (e.g. {@code REGEXP_REPLACE} maps to {@code REGEXP_REPLACE_3},
+   * {@code REGEXP_REPLACE_PG_4}, and {@code REGEXP_REPLACE_5} in PostgreSQL library). Picking by
+   * name + kind alone returns whichever overload is listed first, so a 4-arg call would bind to
+   * the 3-arg operator and fail at runtime with {@code IllegalArgumentException: no matching
+   * method} during {@code RexToLixTranslator} code-gen. Fall back to the first kind match when
+   * no overload's arity range fits, preserving prior behavior for callers that pass {@code -1}.
+   */
+  @Nullable SqlOperator toOp(Map<String, ? extends @Nullable Object> map, int operandCount) {
     // in case different operator has the same kind, check with both name and kind.
     String name = get(map, "name");
     String kind = get(map, "kind");
@@ -566,11 +583,21 @@ private static <T extends Object> T get(Map<String, ? extends @Nullable Object>
         sqlSyntax,
         operators,
         SqlNameMatchers.liberal());
+    SqlOperator firstKindMatch = null;
     for (SqlOperator operator : operators) {
-      if (operator.kind == sqlKind) {
+      if (operator.kind != sqlKind) {
+        continue;
+      }
+      if (firstKindMatch == null) {
+        firstKindMatch = operator;
+      }
+      if (operandCount < 0 || operator.getOperandCountRange().isValidCount(operandCount)) {
         return operator;
       }
     }
+    if (firstKindMatch != null) {
+      return firstKindMatch;
+    }
     String class_ = (String) map.get("class");
     if (class_ != null) {
       return AvaticaUtils.instantiatePlugin(SqlOperator.class, class_);

opensearch/src/main/java/org/opensearch/sql/opensearch/storage/serde/RexStandardizer.java

@@ -32,6 +32,7 @@
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.sql.type.BasicSqlType;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
@@ -73,6 +74,27 @@ public RexNode visitCall(final RexCall call, ScriptParameterHelper helper) {
         // We can downgrade to still use `Sarg` literal instead of replacing it with parameter.
       }
     }
+    // PPL's `patterns` lowering emits 4-arg `REGEXP_REPLACE_PG_4(field, pattern, replacement,
+    // 'g')` so the analytics-engine/DataFusion path gets global replacement (DataFusion's
+    // `regexp_replace` defaults to first-match-only without an explicit flag). Calcite's
+    // 3-arg `REGEXP_REPLACE_3` is already replace-all in its enumerable runtime, but the PG_4
+    // form has no matching `SqlFunctions.regexpReplace(String, String, String, String)` impl
+    // — Calcite's runtime only ships the `(String, String, String, int[, ...])` shapes (the
+    // 4-arg variant treats the 4th arg as start-position, not a flags string). The script
+    // pushdown path codegen would fail with `No applicable constructor/method found`. Collapse
+    // the 4-arg call to the 3-arg form whenever the flags literal is exactly `"g"`, which
+    // preserves replace-all semantics on the V2 / Calcite-pushdown side.
+    if (call.op == SqlLibraryOperators.REGEXP_REPLACE_PG_4
+        && call.operands.size() == 4
+        && call.operands.get(3) instanceof RexLiteral flagsLit
+        && "g".equals(flagsLit.getValueAs(String.class))) {
+      return helper.rexBuilder
+          .makeCall(
+              call.getType(),
+              SqlLibraryOperators.REGEXP_REPLACE_3,
+              call.operands.subList(0, 3))
+          .accept(this, helper);
+    }
     // Some functions only support limited numeric type. Keep conservative here.
     boolean allowNumericTypeWiden =
         call.op.kind.belongsTo(SqlKind.BINARY_ARITHMETIC)