Patterns such (3?)+ should now fall back to CPU

sql-plugin/src/main/scala/com/nvidia/spark/rapids/RegexParser.scala

@@ -610,6 +610,23 @@ class CudfRegexTranspiler(replace: Boolean) {
           // example: "a*+"
           throw new RegexUnsupportedException(nothingToRepeat)
 
+        case (RegexGroup(capture, term), SimpleQuantifier(ch)) if "+*".contains(ch) =>
+          // example: "(3?)+"
+          def isSimpleRepetition(e: RegexAST):Boolean = {
+            e match {
+              case RegexRepetition(term, quantifier) =>
+                term.isInstanceOf[RegexCharacterClassComponent]
+              case RegexSequence(parts) if parts.length == 1 => 
+                isSimpleRepetition(parts.last)
+              case _ => false
+            }
+          }
+          val tr = rewrite(term)
+          if (isSimpleRepetition(tr)) {
+            // perhaps we could rewrite it here
+            throw new RegexUnsupportedException(nothingToRepeat)
+          }
+          RegexRepetition(RegexGroup(capture, tr), quantifier)
         case _ =>
           RegexRepetition(rewrite(base), quantifier)
 

tests/src/test/scala/com/nvidia/spark/rapids/RegularExpressionParserSuite.scala

@@ -140,6 +140,13 @@ class RegularExpressionParserSuite extends FunSuite {
       RegexSequence(ListBuffer(RegexOctalChar("47"), RegexChar('7'))))
   }
 
+  test("repetition with group containing simple repetition") {
+    assert(parse("(3?)+") ===
+      RegexSequence(ListBuffer(RegexRepetition(RegexGroup(capture = true, 
+          RegexSequence(ListBuffer(RegexRepetition(RegexChar('3'), 
+          SimpleQuantifier('?'))))),SimpleQuantifier('+')))))
+  }
+
   test("group containing choice with repetition") {
     assert(parse("(\t+|a)") == RegexSequence(ListBuffer(
       RegexGroup(capture = true, RegexChoice(RegexSequence(ListBuffer(

tests/src/test/scala/com/nvidia/spark/rapids/RegularExpressionTranspilerSuite.scala

@@ -119,6 +119,13 @@ class RegularExpressionTranspilerSuite extends FunSuite with Arm {
     )
   }
 
+  test("cuDF does not support single repetition both inside and outside of capture groups") {
+    // see https://github.com/NVIDIA/spark-rapids/issues/4487
+    val patterns = Seq("(3?)+", "(3?)*", "(3*)+")
+    patterns.foreach(pattern => 
+      assertUnsupported(pattern, replace = false, "nothing to repeat"))
+  }
+
   test("cuDF does not support OR at BOL / EOL") {
     val patterns = Seq("$|a", "^|a")
     patterns.foreach(pattern => {