fix: address CI failures for java-regexp PR

Drop redundant interpolators in COMET_REGEXP_ENGINE doc string and remove
the redundant CometConf self-import in CometStringExpressionSuite to
satisfy scalafix. Switch existing rlike/regexp_replace tests to opt in via
COMET_REGEXP_ENGINE=rust now that the engine selector is the gate for the
Rust path, and reformat regex.md via prettier.

Author: andygrove

docs/source/user-guide/latest/compatibility/regex.md

@@ -36,12 +36,12 @@ The JVM UDF framework is experimental and disabled by default. With pure default
 
 ## Choosing an engine
 
-|                      | Rust engine                             | Java engine (experimental, default)                                                                                  |
-| -------------------- | --------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
-| **Compatibility**    | Differs from Java regex (see below)     | 100% compatible with Spark                                                                                           |
-| **Feature coverage** | `rlike`, `regexp_replace`, `split` only | All regexp expressions (`rlike`, `regexp_extract`, `regexp_extract_all`, `regexp_instr`, `regexp_replace`, `split`)  |
-| **Performance**      | Fully native, no JNI overhead           | One JNI round-trip per batch (Arrow vectors stay columnar)                                                           |
-| **Pattern support**  | Linear-time subset only                 | All Java regex features (backreferences, lookaround, etc.)                                                           |
+|                      | Rust engine                             | Java engine (experimental, default)                                                                                 |
+| -------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| **Compatibility**    | Differs from Java regex (see below)     | 100% compatible with Spark                                                                                          |
+| **Feature coverage** | `rlike`, `regexp_replace`, `split` only | All regexp expressions (`rlike`, `regexp_extract`, `regexp_extract_all`, `regexp_instr`, `regexp_replace`, `split`) |
+| **Performance**      | Fully native, no JNI overhead           | One JNI round-trip per batch (Arrow vectors stay columnar)                                                          |
+| **Pattern support**  | Linear-time subset only                 | All Java regex features (backreferences, lookaround, etc.)                                                          |
 
 The **Rust engine** is faster but cannot match Java regex semantics for every pattern. Because the engine
 choice is itself the opt-in, setting `spark.comet.exec.regexp.engine=rust` declares acceptance of those

spark/src/main/scala/org/apache/comet/CometConf.scala

@@ -400,15 +400,15 @@ object CometConf extends ShimCometConf {
     conf("spark.comet.exec.regexp.engine")
       .category(CATEGORY_EXEC)
       .doc(
-        s"Selects the engine used to evaluate Spark regular-expression expressions. " +
+        "Selects the engine used to evaluate Spark regular-expression expressions. " +
           s"`$REGEXP_ENGINE_JAVA` (default) routes through a JVM-side UDF " +
-          s"(java.util.regex.Pattern) for Spark-compatible semantics, at the cost of JNI " +
+          "(java.util.regex.Pattern) for Spark-compatible semantics, at the cost of JNI " +
           s"roundtrips per batch; this requires ${COMET_JVM_UDF_ENABLED.key}=true and " +
           s"falls back to Spark otherwise. `$REGEXP_ENGINE_RUST` runs the native DataFusion " +
           "regexp engine when an implementation exists; setting this is itself the opt-in " +
           "for the semantic differences between Java and Rust regex. Affected expressions: " +
           "rlike, regexp_extract, regexp_extract_all, regexp_replace, regexp_instr, and " +
-          s"split (the extract/instr family has no native Rust path; they fall back to Spark " +
+          "split (the extract/instr family has no native Rust path; they fall back to Spark " +
           s"under `$REGEXP_ENGINE_RUST`).")
       .stringConf
       .transform(_.toLowerCase(Locale.ROOT))

spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala

@@ -934,7 +934,7 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
         // add repetitive data to trigger dictionary encoding
         Range(0, 100).map(_ => "John Smith")
       withParquetFile(data.zipWithIndex, withDictionary) { file =>
-        withSQLConf(CometConf.getExprAllowIncompatConfigKey("regexp") -> "true") {
+        withSQLConf(CometConf.COMET_REGEXP_ENGINE.key -> CometConf.REGEXP_ENGINE_RUST) {
           spark.read.parquet(file).createOrReplaceTempView(table)
           val query = sql(s"select _2 as id, _1 rlike 'R[a-z]+s [Rr]ose' from $table")
           checkSparkAnswerAndOperator(query)
@@ -1006,7 +1006,7 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
         // "Smith$",
         "Smith\\Z",
         "Smith\\z")
-      withSQLConf(CometConf.getExprAllowIncompatConfigKey("regexp") -> "true") {
+      withSQLConf(CometConf.COMET_REGEXP_ENGINE.key -> CometConf.REGEXP_ENGINE_RUST) {
         patterns.foreach { pattern =>
           val query2 = sql(s"select name, '$pattern', name rlike '$pattern' from $table")
           checkSparkAnswerAndOperator(query2)
@@ -1066,7 +1066,7 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
         "\\V")
       val qualifiers = Seq("", "+", "*", "?", "{1,}")
 
-      withSQLConf(CometConf.getExprAllowIncompatConfigKey("regexp") -> "true") {
+      withSQLConf(CometConf.COMET_REGEXP_ENGINE.key -> CometConf.REGEXP_ENGINE_RUST) {
         // testing every possible combination takes too long, so we pick some
         // random combinations
         for (_ <- 0 until 100) {

spark/src/test/scala/org/apache/comet/CometFuzzIcebergSuite.scala

@@ -133,7 +133,7 @@ class CometFuzzIcebergSuite extends CometFuzzIcebergBase {
   }
 
   test("regexp_replace") {
-    withSQLConf(CometConf.getExprAllowIncompatConfigKey("regexp") -> "true") {
+    withSQLConf(CometConf.COMET_REGEXP_ENGINE.key -> CometConf.REGEXP_ENGINE_RUST) {
       val df = spark.table(icebergTableName)
       // We want to make sure that the schema generator wasn't modified to accidentally omit
       // StringType, since then this test would not run any queries and silently pass.

spark/src/test/scala/org/apache/comet/CometFuzzTestSuite.scala

@@ -219,7 +219,7 @@ class CometFuzzTestSuite extends CometFuzzTestBase {
   }
 
   test("regexp_replace") {
-    withSQLConf(CometConf.getExprAllowIncompatConfigKey("regexp") -> "true") {
+    withSQLConf(CometConf.COMET_REGEXP_ENGINE.key -> CometConf.REGEXP_ENGINE_RUST) {
       val df = spark.read.parquet(filename)
       df.createOrReplaceTempView("t1")
       // We want to make sure that the schema generator wasn't modified to accidentally omit

spark/src/test/scala/org/apache/comet/CometStringExpressionSuite.scala

@@ -26,7 +26,6 @@ import org.apache.spark.sql.{CometTestBase, DataFrame}
 import org.apache.spark.sql.internal.SQLConf
 import org.apache.spark.sql.types.{DataTypes, StructField, StructType}
 
-import org.apache.comet.CometConf
 import org.apache.comet.testing.{DataGenOptions, FuzzDataGenerator}
 
 class CometStringExpressionSuite extends CometTestBase {