DECOUPLE SED + OFFSET FIELD

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

Author: RyanL1997

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

@@ -23,55 +23,38 @@
 public class Rex extends UnresolvedPlan {
 
   public enum RexMode {
-    EXTRACT,
-    SED
+    EXTRACT
   }
 
   /** Field to extract from. */
   private final UnresolvedExpression field;
 
-  /** Pattern with named capture groups or sed expression. */
+  /** Pattern with named capture groups. */
   private final Literal pattern;
 
+  /** Rex mode (only EXTRACT supported). */
+  private final RexMode mode;
+
   /** Maximum number of matches (optional). */
   private final Optional<Integer> maxMatch;
 
-  /** Offset field name for position tracking (optional). */
-  private final Optional<String> offsetField;
-
-  /** Rex mode (extract or sed). */
-  private final RexMode mode;
-
   /** Child Plan. */
   @Setter private UnresolvedPlan child;
 
   public Rex(UnresolvedExpression field, Literal pattern) {
-    this(field, pattern, Optional.empty(), Optional.empty(), RexMode.EXTRACT);
+    this(field, pattern, RexMode.EXTRACT, Optional.empty());
   }
 
   public Rex(UnresolvedExpression field, Literal pattern, Optional<Integer> maxMatch) {
-    this(field, pattern, maxMatch, Optional.empty(), RexMode.EXTRACT);
+    this(field, pattern, RexMode.EXTRACT, maxMatch);
   }
 
   public Rex(
-      UnresolvedExpression field,
-      Literal pattern,
-      Optional<Integer> maxMatch,
-      Optional<String> offsetField) {
-    this(field, pattern, maxMatch, offsetField, RexMode.EXTRACT);
-  }
-
-  public Rex(
-      UnresolvedExpression field,
-      Literal pattern,
-      Optional<Integer> maxMatch,
-      Optional<String> offsetField,
-      RexMode mode) {
+      UnresolvedExpression field, Literal pattern, RexMode mode, Optional<Integer> maxMatch) {
     this.field = field;
     this.pattern = pattern;
-    this.maxMatch = maxMatch;
-    this.offsetField = offsetField;
     this.mode = mode;
+    this.maxMatch = maxMatch;
   }
 
   @Override

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

@@ -183,13 +183,6 @@ public RelNode visitRex(Rex node, CalcitePlanContext context) {
     RexNode fieldRex = rexVisitor.analyze(node.getField(), context);
     String patternStr = (String) node.getPattern().getValue();
 
-    if (node.getMode() == Rex.RexMode.SED) {
-      RexNode sedCall = createOptimizedSedCall(fieldRex, patternStr, context);
-      String fieldName = node.getField().toString();
-      projectPlusOverriding(List.of(sedCall), List.of(fieldName), context);
-      return context.relBuilder.peek();
-    }
-
     List<String> namedGroups = RegexExpression.getNamedGroupCandidates(patternStr);
 
     if (namedGroups.isEmpty()) {
@@ -203,6 +196,7 @@ public RelNode visitRex(Rex node, CalcitePlanContext context) {
     for (int i = 0; i < namedGroups.size(); i++) {
       RexNode extractCall;
       if (node.getMaxMatch().isPresent() && node.getMaxMatch().get() != 1) {
+        // Use REX_EXTRACT_MULTI for multiple matches
         extractCall =
             PPLFuncImpTable.INSTANCE.resolve(
                 context.rexBuilder,
@@ -212,6 +206,7 @@ public RelNode visitRex(Rex node, CalcitePlanContext context) {
                 context.relBuilder.literal(i + 1),
                 context.relBuilder.literal(node.getMaxMatch().get()));
       } else {
+        // Use REX_EXTRACT for single match (default)
         extractCall =
             PPLFuncImpTable.INSTANCE.resolve(
                 context.rexBuilder,
@@ -224,17 +219,6 @@ public RelNode visitRex(Rex node, CalcitePlanContext context) {
       newFieldNames.add(namedGroups.get(i));
     }
 
-    if (node.getOffsetField().isPresent()) {
-      RexNode offsetCall =
-          PPLFuncImpTable.INSTANCE.resolve(
-              context.rexBuilder,
-              BuiltinFunctionName.REX_OFFSET,
-              fieldRex,
-              context.rexBuilder.makeLiteral(patternStr));
-      newFields.add(offsetCall);
-      newFieldNames.add(node.getOffsetField().get());
-    }
-
     projectPlusOverriding(newFields, newFieldNames, context);
     return context.relBuilder.peek();
   }
@@ -1687,118 +1671,4 @@ private void buildExpandRelNode(
       context.relBuilder.rename(names);
     }
   }
-
-  /**
-   * Creates an optimized sed call using native Calcite functions where possible. Falls back to
-   * custom REX_SED for complex cases.
-   */
-  private RexNode createOptimizedSedCall(
-      RexNode fieldRex, String sedExpression, CalcitePlanContext context) {
-    if (sedExpression.startsWith("s/")) {
-      return createOptimizedSubstitution(fieldRex, sedExpression, context);
-    } else if (sedExpression.startsWith("y/")) {
-      return createOptimizedTransliteration(fieldRex, sedExpression, context);
-    } else {
-      throw new RuntimeException("Unsupported sed pattern: " + sedExpression);
-    }
-  }
-
-  /** Creates optimized substitution calls for s/pattern/replacement/flags syntax. */
-  private RexNode createOptimizedSubstitution(
-      RexNode fieldRex, String sedExpression, CalcitePlanContext context) {
-    try {
-      // Parse sed substitution: s/pattern/replacement/flags
-      if (!sedExpression.matches("s/.+/.*/.*")) {
-        throw new IllegalArgumentException("Invalid sed substitution format");
-      }
-
-      // Find the delimiters - sed format is s/pattern/replacement/flags
-      int firstDelimiter = sedExpression.indexOf('/', 2); // First '/' after 's/'
-      int secondDelimiter = sedExpression.indexOf('/', firstDelimiter + 1); // Second '/'
-      int thirdDelimiter = sedExpression.indexOf('/', secondDelimiter + 1); // Third '/' (optional)
-
-      if (firstDelimiter == -1 || secondDelimiter == -1) {
-        throw new IllegalArgumentException("Invalid sed substitution format");
-      }
-
-      String pattern = sedExpression.substring(2, firstDelimiter);
-      String replacement = sedExpression.substring(firstDelimiter + 1, secondDelimiter);
-      String flags =
-          secondDelimiter + 1 < sedExpression.length()
-              ? sedExpression.substring(secondDelimiter + 1)
-              : "";
-
-      // Convert sed backreferences (\1, \2) to Java style ($1, $2)
-      String javaReplacement = replacement.replaceAll("\\\\(\\d+)", "\\$$1");
-
-      if (flags.isEmpty()) {
-        // 3-parameter REGEXP_REPLACE
-        return PPLFuncImpTable.INSTANCE.resolve(
-            context.rexBuilder,
-            BuiltinFunctionName.INTERNAL_REGEXP_REPLACE_3,
-            fieldRex,
-            context.rexBuilder.makeLiteral(pattern),
-            context.rexBuilder.makeLiteral(javaReplacement));
-      } else if (flags.matches("[gi]+")) {
-        // 4-parameter REGEXP_REPLACE with flags
-        return PPLFuncImpTable.INSTANCE.resolve(
-            context.rexBuilder,
-            BuiltinFunctionName.INTERNAL_REGEXP_REPLACE_PG_4,
-            fieldRex,
-            context.rexBuilder.makeLiteral(pattern),
-            context.rexBuilder.makeLiteral(javaReplacement),
-            context.rexBuilder.makeLiteral(flags));
-      } else if (flags.matches("\\d+")) {
-        // 5-parameter REGEXP_REPLACE with occurrence
-        int occurrence = Integer.parseInt(flags);
-        return PPLFuncImpTable.INSTANCE.resolve(
-            context.rexBuilder,
-            BuiltinFunctionName.INTERNAL_REGEXP_REPLACE_5,
-            fieldRex,
-            context.rexBuilder.makeLiteral(pattern),
-            context.rexBuilder.makeLiteral(javaReplacement),
-            context.relBuilder.literal(1), // start position
-            context.relBuilder.literal(occurrence));
-      } else {
-        throw new RuntimeException(
-            "Unsupported sed flags: " + flags + " in expression: " + sedExpression);
-      }
-    } catch (Exception e) {
-      throw new RuntimeException("Failed to optimize sed expression: " + sedExpression, e);
-    }
-  }
-
-  /** Creates optimized transliteration calls for y/from/to/ syntax. */
-  private RexNode createOptimizedTransliteration(
-      RexNode fieldRex, String sedExpression, CalcitePlanContext context) {
-    try {
-      // Parse sed transliteration: y/from/to/
-      if (!sedExpression.matches("y/.+/.*/.*")) {
-        throw new IllegalArgumentException("Invalid sed transliteration format");
-      }
-
-      int firstSlash = sedExpression.indexOf('/', 1);
-      int secondSlash = sedExpression.indexOf('/', firstSlash + 1);
-      int thirdSlash = sedExpression.indexOf('/', secondSlash + 1);
-
-      if (firstSlash == -1 || secondSlash == -1) {
-        throw new IllegalArgumentException("Invalid sed transliteration format");
-      }
-
-      String from = sedExpression.substring(firstSlash + 1, secondSlash);
-      String to =
-          sedExpression.substring(
-              secondSlash + 1, thirdSlash != -1 ? thirdSlash : sedExpression.length());
-
-      // Use Calcite's native TRANSLATE3 function
-      return PPLFuncImpTable.INSTANCE.resolve(
-          context.rexBuilder,
-          BuiltinFunctionName.INTERNAL_TRANSLATE3,
-          fieldRex,
-          context.rexBuilder.makeLiteral(from),
-          context.rexBuilder.makeLiteral(to));
-    } catch (Exception e) {
-      throw new RuntimeException("Failed to optimize sed expression: " + sedExpression, e);
-    }
-  }
 }

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

@@ -218,7 +218,6 @@ public enum BuiltinFunctionName {
   REGEX_MATCH(FunctionName.of("regex_match")),
   REX_EXTRACT(FunctionName.of("REX_EXTRACT")),
   REX_EXTRACT_MULTI(FunctionName.of("REX_EXTRACT_MULTI")),
-  REX_OFFSET(FunctionName.of("REX_OFFSET")),
   REPLACE(FunctionName.of("replace")),
   REVERSE(FunctionName.of("reverse")),
   RIGHT(FunctionName.of("right")),

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

@@ -57,7 +57,6 @@
 import org.opensearch.sql.expression.function.udf.RelevanceQueryFunction;
 import org.opensearch.sql.expression.function.udf.RexExtractFunction;
 import org.opensearch.sql.expression.function.udf.RexExtractMultiFunction;
-import org.opensearch.sql.expression.function.udf.RexOffsetFunction;
 import org.opensearch.sql.expression.function.udf.SpanFunction;
 import org.opensearch.sql.expression.function.udf.condition.EarliestFunction;
 import org.opensearch.sql.expression.function.udf.condition.EnhancedCoalesceFunction;
@@ -406,7 +405,6 @@ public class PPLBuiltinOperators extends ReflectiveSqlOperatorTable {
   public static final SqlOperator REX_EXTRACT = new RexExtractFunction().toUDF("REX_EXTRACT");
   public static final SqlOperator REX_EXTRACT_MULTI =
       new RexExtractMultiFunction().toUDF("REX_EXTRACT_MULTI");
-  public static final SqlOperator REX_OFFSET = new RexOffsetFunction().toUDF("REX_OFFSET");
 
   // Aggregation functions
   public static final SqlAggFunction AVG_NULLABLE = new NullableSqlAvgAggFunction(SqlKind.AVG);

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

@@ -163,7 +163,6 @@
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.REVERSE;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.REX_EXTRACT;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.REX_EXTRACT_MULTI;
-import static org.opensearch.sql.expression.function.BuiltinFunctionName.REX_OFFSET;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.RIGHT;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.RINT;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.ROUND;
@@ -714,7 +713,6 @@ void populate() {
       registerOperator(MULTI_MATCH, PPLBuiltinOperators.MULTI_MATCH);
       registerOperator(REX_EXTRACT, PPLBuiltinOperators.REX_EXTRACT);
       registerOperator(REX_EXTRACT_MULTI, PPLBuiltinOperators.REX_EXTRACT_MULTI);
-      registerOperator(REX_OFFSET, PPLBuiltinOperators.REX_OFFSET);
 
       // Register PPL Datetime UDF operator
       registerOperator(TIMESTAMP, PPLBuiltinOperators.TIMESTAMP);