[Enhancement] Better error handling when using underscore in rex regex pattern Co-authored-by: Simeon Widdis <sawiddis@amazon.com>

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

Author: RyanL1997

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

@@ -277,6 +277,11 @@ public RelNode visitRex(Rex node, CalcitePlanContext context) {
           "Rex pattern must contain at least one named capture group");
     }
 
+    if (namedGroups.stream().anyMatch(g -> g.contains("_"))) {
+      throw new IllegalArgumentException(
+          "Underscores are not permitted in Java Regex capture group names");
+    }
+
     List<RexNode> newFields = new ArrayList<>();
     List<String> newFieldNames = new ArrayList<>();
 

core/src/main/java/org/opensearch/sql/expression/parse/RegexCommonUtils.java

@@ -20,7 +20,7 @@
 public class RegexCommonUtils {
 
   private static final Pattern NAMED_GROUP_PATTERN =
-      Pattern.compile("\\(\\?<([a-zA-Z][a-zA-Z0-9]*)>");
+      Pattern.compile("\\(\\?<([a-zA-Z_][a-zA-Z0-9_]*)>");
 
   private static final int MAX_CACHE_SIZE = 1000;
 

core/src/test/java/org/opensearch/sql/expression/parse/RegexCommonUtilsTest.java

@@ -195,11 +195,12 @@ public void testGetNamedGroupCandidatesWithNumericNames() {
 
   @Test
   public void testGetNamedGroupCandidatesSpecialCharacters() {
-    // Test that groups with special characters are not captured (only alphanumeric starting with
-    // letter)
+    // Test that groups with special characters (except underscores) are not captured
+    // Numbers at start and hyphens are invalid, but underscores are now detected for validation
     String pattern = "(?<valid_group>[a-z]+)\\s+(?<123invalid>[0-9]+)\\s+(?<also-invalid>.*)";
     List<String> groups = RegexCommonUtils.getNamedGroupCandidates(pattern);
-    assertEquals(0, groups.size());
+    assertEquals(1, groups.size());
+    assertEquals("valid_group", groups.get(0));
   }
 
   @Test
@@ -211,4 +212,28 @@ public void testGetNamedGroupCandidatesValidAlphanumeric() {
     assertEquals("groupA", groups.get(0));
     assertEquals("group2B", groups.get(1));
   }
+
+  @Test
+  public void testGetNamedGroupCandidatesWithUnderscores() {
+    // Test that underscores in group names are detected (for validation purposes)
+    String pattern = "(?<user_name>[a-z]+)\\s+(?<domain_name>[a-z]+)";
+    List<String> groups = RegexCommonUtils.getNamedGroupCandidates(pattern);
+
+    assertEquals(2, groups.size());
+    assertEquals("user_name", groups.get(0));
+    assertEquals("domain_name", groups.get(1));
+  }
+
+  @Test
+  public void testGetNamedGroupCandidatesMixedUnderscores() {
+    // Test that mixed patterns with and without underscores are detected
+    String pattern =
+        "(?<validName>[a-z]+)\\s+(?<invalid_name>[0-9]+)\\s+(?<another_invalid_name>.*)";
+    List<String> groups = RegexCommonUtils.getNamedGroupCandidates(pattern);
+
+    assertEquals(3, groups.size());
+    assertEquals("validName", groups.get(0));
+    assertEquals("invalid_name", groups.get(1));
+    assertEquals("another_invalid_name", groups.get(2));
+  }
 }

integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalciteRexCommandIT.java

@@ -50,6 +50,22 @@ public void testRexErrorNoNamedGroups() throws IOException {
     }
   }
 
+  @Test
+  public void testRexErrorUnderscoreInGroupNames() throws IOException {
+    try {
+      executeQuery(
+          String.format(
+              "source=%s | rex field=email \\\"(?<user_name>[^@]+)@(?<domain_name>.+)\\\" | fields"
+                  + " email",
+              TEST_INDEX_ACCOUNT));
+      fail("Should have thrown an exception for underscore in named capture group");
+    } catch (Exception e) {
+      assertTrue(
+          e.getMessage()
+              .contains("Underscores are not permitted in Java Regex capture group names"));
+    }
+  }
+
   @Test
   public void testRexWithFiltering() throws IOException {
     JSONObject result =