chore: fix native shuffle for batches with no columns and 0 row count

native/shuffle/src/partitioners/multi_partition.rs

@@ -203,6 +203,36 @@ impl MultiPartitionShuffleRepartitioner {
             return Ok(());
         }
 
+        // For zero-column schemas (e.g. COUNT queries), assign all rows to partition 0.
+        // No hashing or expression evaluation needed — just route through normal buffering.
+        if input.num_columns() == 0 {
+            let num_rows = input.num_rows();
+            self.metrics.baseline.record_output(num_rows);
+            // All rows go to partition 0: partition_starts = [0, num_rows, num_rows, ...]
+            // partition_row_indices = [0, 1, 2, ..., num_rows-1]
+            let mut scratch = std::mem::take(&mut self.scratch);
+            scratch
+                .partition_starts
+                .resize(self.partition_indices.len() + 1, 0);
+            scratch.partition_starts.fill(num_rows as u32);
+            scratch.partition_starts[0] = 0;
+            scratch.partition_row_indices.resize(num_rows, 0);
+            for (i, v) in scratch.partition_row_indices[..num_rows]
+                .iter_mut()
+                .enumerate()
+            {
+                *v = i as u32;
+            }
+            self.buffer_partitioned_batch_may_spill(
+                input,
+                &scratch.partition_row_indices[..num_rows],
+                &scratch.partition_starts,
+            )
+            .await?;
+            self.scratch = scratch;
+            return Ok(());
+        }
+
         if input.num_rows() > self.batch_size {
             return Err(DataFusionError::Internal(
                 "Input batch size exceeds configured batch size. Call `insert_batch` instead."

native/shuffle/src/partitioners/partitioned_batch_iterator.rs

@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::array::RecordBatch;
+use arrow::array::{RecordBatch, RecordBatchOptions};
 use arrow::compute::interleave_record_batch;
 use datafusion::common::DataFusionError;
 
@@ -97,15 +97,20 @@ impl Iterator for PartitionedBatchIterator<'_> {
 
         let indices_end = std::cmp::min(self.pos + self.batch_size, self.indices.len());
         let indices = &self.indices[self.pos..indices_end];
-        match interleave_record_batch(&self.record_batches, indices) {
-            Ok(batch) => {
-                self.pos = indices_end;
-                Some(Ok(batch))
-            }
-            Err(e) => Some(Err(DataFusionError::ArrowError(
-                Box::from(e),
-                Some(DataFusionError::get_back_trace()),
-            ))),
-        }
+
+        // interleave_record_batch requires at least one column or an explicit row count.
+        // For zero-column batches (e.g. COUNT queries), create the batch directly.
+        let schema = self.record_batches[0].schema();
+        let result = if schema.fields().is_empty() {
+            let options = RecordBatchOptions::new().with_row_count(Some(indices.len()));
+            RecordBatch::try_new_with_options(schema, vec![], &options)
+        } else {
+            interleave_record_batch(&self.record_batches, indices)
+        };
+
+        self.pos = indices_end;
+        Some(result.map_err(|e| {
+            DataFusionError::ArrowError(Box::from(e), Some(DataFusionError::get_back_trace()))
+        }))
     }
 }

spark/src/test/scala/org/apache/comet/exec/CometNativeShuffleSuite.scala

@@ -474,4 +474,34 @@ class CometNativeShuffleSuite extends CometTestBase with AdaptiveSparkPlanHelper
       }
     }
   }
+
+  test("native datafusion scan - repartition count") {
+    withTempPath { dir =>
+      withSQLConf(CometConf.COMET_ENABLED.key -> "false") {
+        spark
+          .range(1000)
+          .selectExpr("id", "concat('name_', id) as name")
+          .repartition(100)
+          .write
+          .parquet(dir.toString)
+      }
+      withSQLConf(
+        CometConf.COMET_NATIVE_SCAN_IMPL.key -> CometConf.SCAN_NATIVE_DATAFUSION,
+        CometConf.COMET_EXEC_SHUFFLE_WITH_ROUND_ROBIN_PARTITIONING_ENABLED.key -> "true") {
+        val testDF = spark.read.parquet(dir.toString).repartition(10)
+        // Verify CometShuffleExchangeExec is in the plan
+        assert(
+          find(testDF.queryExecution.executedPlan) {
+            case _: CometShuffleExchangeExec => true
+            case _ => false
+          }.isDefined,
+          "Expected CometShuffleExchangeExec in the plan")
+        // Actual validation, no crash
+        val count = testDF.count()
+        assert(count == 1000)
+        // Ensure test df evaluated by Comet
+        checkSparkAnswerAndOperator(testDF)
+      }
+    }
+  }
 }