fix(opensearch): revert arity-aware toOp; restore spath/JSON_EXTRACT doctest

The arity filter added to ExtendedRelJson.toOp in the previous commit broke
SAFE_CAST → JSON_EXTRACT deserialization (used by `spath` lowering): the
PPL JSON_EXTRACT UDF, registered as an anonymous UserDefinedFunctionBuilder
subclass, doesn't expose a meaningful getOperandCountRange(), so my filter
fell through to the firstKindMatch path and skipped the
AvaticaUtils.instantiatePlugin "class" path that previously resolved the
UDF. spath.md doctest started returning RuntimeException on
`source=structured | spath input=doc_n n | eval n=cast(n as int) | stats sum(n)`.

The RexStandardizer collapse (4-arg `REGEXP_REPLACE_PG_4(..., 'g')` → 3-arg
`REGEXP_REPLACE_3`) already fixes the patterns.md doctest at the source side
— by the time pushdown serialization runs, no 4-arg call exists for toOp to
disambiguate. The arity filter was defensive only and no longer carries its
weight; revert toOp to the original first-kind-match behavior, plus a spotless
re-flow that came in with the same change.

Verified locally on a fresh cluster:
- spath.md doctest query → returns sum(n)=6 (was 500).
- patterns.md doctest query → returns fully-tokenized aggregation rows.
- CalcitePPLDashboardPatternsIT → 1/1 PASS.
- CalcitePPLPatternsIT → 10/15 PASS (same baseline; same five known-pending
  BRAIN failures tracked separately).

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

Author: ahkcs

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

@@ -460,8 +460,7 @@ RexNode toRex(RelInput relInput, @PolyNull Object o) {
               distinct,
               false);
         } else {
-          final SqlOperator operator =
-              requireNonNull(toOp(opMap, rexOperands.size()), "operator");
+          final SqlOperator operator = requireNonNull(toOp(opMap), "operator");
           final RelDataType type;
           if (jsonType != null) {
             type = toType(typeFactory, jsonType);
@@ -554,22 +553,6 @@ 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");
@@ -583,21 +566,11 @@ 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) {
-        continue;
-      }
-      if (firstKindMatch == null) {
-        firstKindMatch = operator;
-      }
-      if (operandCount < 0 || operator.getOperandCountRange().isValidCount(operandCount)) {
+      if (operator.kind == sqlKind) {
         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

@@ -88,11 +88,10 @@ public RexNode visitCall(final RexCall call, ScriptParameterHelper helper) {
         && call.operands.size() == 4
         && call.operands.get(3) instanceof RexLiteral flagsLit
         && "g".equals(flagsLit.getValueAs(String.class))) {
-      return helper.rexBuilder
+      return helper
+          .rexBuilder
           .makeCall(
-              call.getType(),
-              SqlLibraryOperators.REGEXP_REPLACE_3,
-              call.operands.subList(0, 3))
+              call.getType(), SqlLibraryOperators.REGEXP_REPLACE_3, call.operands.subList(0, 3))
           .accept(this, helper);
     }
     // Some functions only support limited numeric type. Keep conservative here.