make format, fix shims for 4.0+

Author: mbutrovich

common/src/main/java/org/apache/comet/udf/CometUdfBridge.java

@@ -62,10 +62,10 @@ protected boolean removeEldestEntry(Map.Entry<String, CometUDF> eldest) {
    * @param inputSchemaPtrs addresses of pre-allocated FFI_ArrowSchema structs (one per input)
    * @param outArrayPtr address of pre-allocated FFI_ArrowArray for the result
    * @param outSchemaPtr address of pre-allocated FFI_ArrowSchema for the result
-   * @param numRows number of rows in the current batch. Mirrors DataFusion's
-   *     {@code ScalarFunctionArgs.number_rows} and gives UDFs an explicit batch-size signal for
-   *     cases where no input arg is a batch-length array (e.g. a zero-arg non-deterministic
-   *     ScalaUDF). UDFs that already read size from their input vectors can ignore it.
+   * @param numRows number of rows in the current batch. Mirrors DataFusion's {@code
+   *     ScalarFunctionArgs.number_rows} and gives UDFs an explicit batch-size signal for cases
+   *     where no input arg is a batch-length array (e.g. a zero-arg non-deterministic ScalaUDF).
+   *     UDFs that already read size from their input vectors can ignore it.
    */
   public static void evaluate(
       String udfClassName,

common/src/main/scala/org/apache/comet/udf/CometBatchKernelCodegen.scala

@@ -435,19 +435,10 @@ object CometBatchKernelCodegen extends Logging with CometExprTraitShim {
    * devirtualize. Each getter switches on the column ordinal so the call site (with an inlined
    * constant ordinal from `BoundReference.genCode`) folds down to a single branch.
    *
-   * Current coverage: `isNullAt` plus `getUTF8String` for `VarCharVector` and
-   * `ViewVarCharVector`. Widen by adding vector class cases and new getters for primitive /
-   * decimal / binary / date / timestamp types.
-   *
-   * TODO: the kernel's `isNullAt(int ordinal)` switch has a `return false;` case for every column
-   * with `ArrowColumnSpec.nullable=false`, and every `BoundReference(ord, ...)` in the expression
-   * tree produces a call site `this.isNullAt(ord)` with `ord` known as a compile-time constant.
-   * JIT is expected to inline the method, fold the switch on the constant ordinal, and reduce the
-   * call to `false` at that call site, so `BoundReference.genCode`'s `isNull` branch
-   * constant-folds away too. A tighter pass would rewrite the deserialized `Expression` tree,
-   * setting the matching `BoundReference.nullable=false` so the generated `ev.code` simply omits
-   * the `isNull` branch at source level rather than relying on the JIT. Cheap to do once we start
-   * flipping per-batch nullability (e.g. `v.getNullCount == 0`).
+   * Current coverage: `isNullAt` plus getters for boolean, byte, short, int (including
+   * `DateDayVector`), long (including `TimeStampMicroVector` and its TZ variant), float, double,
+   * decimal, binary, and UTF8 (for both `VarCharVector` and `ViewVarCharVector`). Widen by adding
+   * further vector-class cases to the existing switches.
    */
   private def typedInputAccessors(inputSchema: Seq[ArrowColumnSpec]): String = {
     val withOrd = inputSchema.zipWithIndex
@@ -679,7 +670,7 @@ object CometBatchKernelCodegen extends Logging with CometExprTraitShim {
     val subjectClass = inputSchema(subjectOrd).vectorClass
     require(
       subjectClass == classOf[VarCharVector] || subjectClass == classOf[ViewVarCharVector],
-      s"specializedRegExpReplaceBody expects VarCharVector or ViewVarCharVector at ordinal " +
+      "specializedRegExpReplaceBody expects VarCharVector or ViewVarCharVector at ordinal " +
         s"$subjectOrd, got ${subjectClass.getSimpleName}")
 
     val patternStr = rr.regexp.eval().toString

common/src/main/scala/org/apache/comet/udf/CometCodegenDispatchUDF.scala

@@ -94,7 +94,7 @@ class CometCodegenDispatchUDF extends CometUDF {
   override def evaluate(inputs: Array[ValueVector], numRows: Int): ValueVector = {
     require(
       inputs.length >= 1,
-      s"CometCodegenDispatchUDF requires at least 1 input (serialized expression), " +
+      "CometCodegenDispatchUDF requires at least 1 input (serialized expression), " +
         s"got ${inputs.length}")
     val exprVec = inputs(0).asInstanceOf[VarBinaryVector]
     require(
@@ -338,7 +338,7 @@ object CometCodegenDispatchUDF {
       expr: Expression,
       specs: IndexedSeq[ArrowColumnSpec]): Expression = {
     expr.transform {
-      case b @ BoundReference(ord, dt, true)
+      case BoundReference(ord, dt, true)
           if ord >= 0 && ord < specs.length && !specs(ord).nullable =>
         BoundReference(ord, dt, nullable = false)
       // Fall through unchanged: non-BoundReference nodes and BoundReferences that are already

common/src/main/scala/org/apache/comet/udf/CometUDF.scala

@@ -31,8 +31,8 @@ import org.apache.arrow.vector.ValueVector
  *
  * `numRows` mirrors DataFusion's `ScalarFunctionArgs.number_rows` and is the batch row count.
  * UDFs that always have at least one batch-length input can read length from it and ignore
- * `numRows`; UDFs that may be called with zero data columns (e.g. a zero-arg ScalaUDF through
- * the codegen dispatcher) need `numRows` to know how many rows to produce.
+ * `numRows`; UDFs that may be called with zero data columns (e.g. a zero-arg ScalaUDF through the
+ * codegen dispatcher) need `numRows` to know how many rows to produce.
  *
  * Implementations must have a public no-arg constructor and should be stateless: instances are
  * cached per executor thread for the lifetime of the JVM.

common/src/main/scala/org/apache/comet/udf/RegExpInStrUDF.scala

@@ -70,7 +70,7 @@ class RegExpInStrUDF extends CometUDF {
         compiled
       }
     }
-    val idx = idxVec.get(0)
+    idxVec.get(0)
 
     val n = subject.getValueCount
     val out = new IntVector("regexp_instr_result", CometArrowAllocator)

common/src/main/spark-4.x/org/apache/comet/shims/CometInternalRowShim.scala

@@ -636,7 +636,7 @@ object CometRegExpExtractAll extends CometExpressionSerde[RegExpExtractAll] {
       return None
     }
     (expr.regexp, expr.idx) match {
-      case (Literal(pattern, DataTypes.StringType), Literal(idx, _: IntegerType)) =>
+      case (Literal(pattern, DataTypes.StringType), Literal(_, _: IntegerType)) =>
         if (pattern == null) {
           withInfo(expr, "Null literal pattern is handled by Spark fallback")
           return None

spark/src/main/scala/org/apache/comet/serde/strings.scala

@@ -188,7 +188,7 @@ class CometCodegenSourceSuite extends AnyFunSuite {
     val src = gen(expr, nullable1, nullable2)
     assert(
       !src.contains("this.col0.isNull(i) || this.col1.isNull(i)"),
-      s"expected no pre-null short-circuit when Concat breaks the NullIntolerant chain; " +
+      "expected no pre-null short-circuit when Concat breaks the NullIntolerant chain; " +
         s"got:\n$src")
   }
 

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

@@ -91,7 +91,7 @@ object CometScalaUDFCompositionBenchmark extends CometBenchmarkBase {
           prepareTable(
             dir,
             spark.sql(
-              s"SELECT REPEAT(CAST(value AS STRING), 10) AS c1, " +
+              "SELECT REPEAT(CAST(value AS STRING), 10) AS c1, " +
                 s"CAST(value AS STRING) AS c2 FROM $tbl"))
 
           registerMultiColUdfs()