[Analytics Backend / DataFusion] Append "g" flag in RegexpReplaceAdapter for 3-arg calls

DataFusion's regexp_replace defaults to first-match-only without an explicit
flag; Calcite's REGEXP_REPLACE_3 is already replace-all. PPL relies on the
Calcite contract (every match replaced — used by SIMPLE patterns, regex_replace,
rex mode=sed), so on the DataFusion path the adapter now rewrites every 3-arg
REGEXP_REPLACE_3 to 4-arg REGEXP_REPLACE_PG_4(..., "g") preserving the same
end-user semantics across backends.

Companion change in opensearch-project/sql#5467: the SQL core no longer emits
the 'g' flag itself — that DataFusion-specific concern now lives only here.

Two existing unit tests updated to expect the new always-global behavior
(testAdaptPassesThroughWhenNoQuoteBlock → testAdaptAppendsGlobalFlagFor3Arg,
testAdaptPassesThroughNonLiteralPattern → testAdaptAppendsGlobalFlagForNonLiteralPattern).
The \Q rewrite, $N backreference rewrite, and 4-arg-with-flags pass-through
are unchanged.

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

Author: ahkcs

sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/RegexpReplaceAdapter.java

@@ -13,6 +13,8 @@
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.sql.fun.SqlLibraryOperators;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.opensearch.analytics.spi.FieldStorageInfo;
 import org.opensearch.analytics.spi.ScalarFunctionAdapter;
 
@@ -96,22 +98,35 @@ public RexNode adapt(RexCall original, List<FieldStorageInfo> fieldStorage, RelO
             }
         }
 
-        if (rewrittenPattern == null && rewrittenReplacement == null) {
+        // Append "g" so DataFusion's regexp_replace (first-match-only by default) replaces
+        // every match — matching PPL's contract on the V2/Calcite path where the 3-arg form
+        // is already replace-all. Pure 3-arg calls become REGEXP_REPLACE_PG_4(..., "g").
+        boolean appendGlobalFlag = original.getOperator() == SqlLibraryOperators.REGEXP_REPLACE_3
+            && original.getOperands().size() == 3;
+
+        if (rewrittenPattern == null && rewrittenReplacement == null && !appendGlobalFlag) {
             return original;
         }
 
         RexBuilder rexBuilder = cluster.getRexBuilder();
         // makeLiteral(String) infers a CHAR type sized to the rewritten string. Reusing the
         // original literal's type would right-pad to the OLD length (e.g. CHAR(23) → 8 trailing
         // spaces after a 15-char rewrite), corrupting the value at runtime.
-        List<RexNode> newOperands = new ArrayList<>(original.getOperands().size());
+        List<RexNode> newOperands = new ArrayList<>(original.getOperands().size() + (appendGlobalFlag ? 1 : 0));
         newOperands.add(original.getOperands().get(0));
         newOperands.add(rewrittenPattern != null ? rexBuilder.makeLiteral(rewrittenPattern) : patternOperand);
         newOperands.add(rewrittenReplacement != null ? rexBuilder.makeLiteral(rewrittenReplacement) : replacementOperand);
         // Append any trailing operand (the flags string in the 4-arg form) verbatim.
         for (int i = 3; i < original.getOperands().size(); i++) {
             newOperands.add(original.getOperands().get(i));
         }
+        if (appendGlobalFlag) {
+            newOperands.add(rexBuilder.makeLiteral(
+                "g",
+                rexBuilder.getTypeFactory().createSqlType(SqlTypeName.VARCHAR),
+                true));
+            return rexBuilder.makeCall(original.getType(), SqlLibraryOperators.REGEXP_REPLACE_PG_4, newOperands);
+        }
         return rexBuilder.makeCall(original.getType(), original.getOperator(), newOperands);
     }
 

sandbox/plugins/analytics-backend-datafusion/src/test/java/org/opensearch/be/datafusion/RegexpReplaceAdapterTests.java

@@ -165,30 +165,36 @@ public void testAdaptRewritesPatternLiteral() {
         assertEquals("Java \\Q…\\E rewritten to plain regex", "^BUSINESS(.*?)$", ((RexLiteral) newPatternNode).getValueAs(String.class));
     }
 
-    public void testAdaptPassesThroughWhenNoQuoteBlock() {
-        // Pattern doesn't contain \Q — adapter must return the call unchanged (identity).
+    public void testAdaptAppendsGlobalFlagFor3Arg() {
+        // 3-arg REGEXP_REPLACE_3 with no \Q / $N rewrites still gets rewritten to 4-arg
+        // REGEXP_REPLACE_PG_4 with "g" so DataFusion's regexp_replace (first-match-only by
+        // default) matches Calcite's already-replace-all 3-arg semantics.
         RexNode field = rexBuilder.makeInputRef(varcharType, 0);
         RexNode pattern = rexBuilder.makeLiteral("^OFFICE.*$");
         RexNode replacement = rexBuilder.makeLiteral("OFC");
         RexCall original = (RexCall) rexBuilder.makeCall(SqlLibraryOperators.REGEXP_REPLACE_3, List.of(field, pattern, replacement));
 
-        RexNode adapted = adapter.adapt(original, List.of(), cluster);
+        RexCall adapted = (RexCall) adapter.adapt(original, List.of(), cluster);
 
-        assertSame("identity — no rewrite when pattern has no \\Q", original, adapted);
+        assertSame("operator switched to PG_4", SqlLibraryOperators.REGEXP_REPLACE_PG_4, adapted.getOperator());
+        assertEquals("4 operands after append", 4, adapted.getOperands().size());
+        assertTrue("trailing operand is a literal", adapted.getOperands().get(3) instanceof RexLiteral);
+        assertEquals("trailing flag is \"g\"", "g", ((RexLiteral) adapted.getOperands().get(3)).getValueAs(String.class));
     }
 
-    public void testAdaptPassesThroughNonLiteralPattern() {
-        // Pattern is a column reference (not a literal) — adapter cannot rewrite at planning
-        // time; pass through and let DataFusion error at runtime if the value is incompatible.
-        // Replacement is a plain literal with no $, so neither transform fires.
+    public void testAdaptAppendsGlobalFlagForNonLiteralPattern() {
+        // Pattern is a column reference (not a literal) — \Q / $N rewrites can't fire, but the
+        // 3-arg → 4-arg-with-"g" rewrite still applies so DataFusion replaces every match.
         RexNode field = rexBuilder.makeInputRef(varcharType, 0);
         RexNode patternRef = rexBuilder.makeInputRef(varcharType, 1);
         RexNode replacement = rexBuilder.makeLiteral("X");
         RexCall original = (RexCall) rexBuilder.makeCall(SqlLibraryOperators.REGEXP_REPLACE_3, List.of(field, patternRef, replacement));
 
-        RexNode adapted = adapter.adapt(original, List.of(), cluster);
+        RexCall adapted = (RexCall) adapter.adapt(original, List.of(), cluster);
 
-        assertSame("non-literal pattern must pass through", original, adapted);
+        assertSame("operator switched to PG_4", SqlLibraryOperators.REGEXP_REPLACE_PG_4, adapted.getOperator());
+        assertEquals("pattern reference preserved", patternRef, adapted.getOperands().get(1));
+        assertEquals("4 operands", 4, adapted.getOperands().size());
     }
 
     public void testAdaptRewritesReplacementOnly() {