Fix cudf::partition* APIs that do not return offsets for empty output table

cpp/src/partitioning/partitioning.cu

@@ -728,7 +728,7 @@ std::pair<std::unique_ptr<table>, std::vector<size_type>> hash_partition(
 
   // Return empty result if there are no partitions or nothing to hash
   if (num_partitions <= 0 || input.num_rows() == 0 || table_to_hash.num_columns() == 0) {
-    return std::pair(empty_like(input), std::vector<size_type>{});
+    return std::pair(empty_like(input), std::vector<size_type>(num_partitions, 0));
   }
 
   if (has_nulls(table_to_hash)) {
@@ -753,7 +753,8 @@ std::pair<std::unique_ptr<table>, std::vector<size_type>> partition(
   CUDF_EXPECTS(not partition_map.has_nulls(), "Unexpected null values in partition_map.");
 
   if (num_partitions == 0 or t.num_rows() == 0) {
-    return std::pair(empty_like(t), std::vector<size_type>{});
+    // The output offsets vector must have size `num_partitions + 1` as per documentation.
+    return std::pair(empty_like(t), std::vector<size_type>(num_partitions + 1, 0));
   }
 
   return cudf::type_dispatcher(

cpp/src/partitioning/round_robin.cu

@@ -166,6 +166,10 @@ std::pair<std::unique_ptr<table>, std::vector<cudf::size_type>> round_robin_part
     "Incorrect start_partition index. Must be positive.");  // since cudf::size_type is an alias for
                                                             // int32_t, it _can_ be negative
 
+  if (nrows == 0) {
+    return std::pair(empty_like(input), std::vector<size_type>(num_partitions, 0));
+  }
+
   // handle degenerate case:
   //
   if (num_partitions >= nrows) {

cpp/tests/partitioning/hash_partition_test.cpp

@@ -72,7 +72,7 @@ TEST_F(HashPartition, ZeroPartitions)
   // Expect empty table with same number of columns and zero partitions
   EXPECT_EQ(input.num_columns(), output->num_columns());
   EXPECT_EQ(0, output->num_rows());
-  EXPECT_EQ(std::size_t{0}, offsets.size());
+  EXPECT_EQ(std::size_t{num_partitions}, offsets.size());
 }
 
 TEST_F(HashPartition, ZeroRows)
@@ -87,10 +87,10 @@ TEST_F(HashPartition, ZeroRows)
   cudf::size_type const num_partitions = 3;
   auto [output, offsets] = cudf::hash_partition(input, columns_to_hash, num_partitions);
 
-  // Expect empty table with same number of columns and zero partitions
+  // Expect empty table with same number of columns and same number of partitions
   EXPECT_EQ(input.num_columns(), output->num_columns());
   EXPECT_EQ(0, output->num_rows());
-  EXPECT_EQ(std::size_t{0}, offsets.size());
+  EXPECT_EQ(std::size_t{num_partitions}, offsets.size());
 }
 
 TEST_F(HashPartition, ZeroColumns)
@@ -102,10 +102,10 @@ TEST_F(HashPartition, ZeroColumns)
   cudf::size_type const num_partitions = 3;
   auto [output, offsets] = cudf::hash_partition(input, columns_to_hash, num_partitions);
 
-  // Expect empty table with same number of columns and zero partitions
+  // Expect empty table with same number of columns and same number of partitions
   EXPECT_EQ(input.num_columns(), output->num_columns());
   EXPECT_EQ(0, output->num_rows());
-  EXPECT_EQ(std::size_t{0}, offsets.size());
+  EXPECT_EQ(std::size_t{num_partitions}, offsets.size());
 }
 
 TEST_F(HashPartition, MixedColumnTypes)

cpp/tests/partitioning/partition_test.cpp

@@ -53,7 +53,7 @@ TYPED_TEST(PartitionTest, EmptyInputs)
 
   auto result_offsets = result.second;
 
-  EXPECT_TRUE(result_offsets.empty());
+  EXPECT_EQ(result_offsets.size(), std::size_t{11});
 
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(empty_column, result.first->get_column(0));
 }

cpp/tests/partitioning/round_robin_test.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021, NVIDIA CORPORATION.
+ * Copyright (c) 2020-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -47,6 +47,18 @@ class RoundRobinTest : public cudf::test::BaseFixture {
 
 TYPED_TEST_SUITE(RoundRobinTest, cudf::test::FixedWidthTypes);
 
+TYPED_TEST(RoundRobinTest, EmptyInput)
+{
+  auto const empty_column    = fixed_width_column_wrapper<TypeParam>{};
+  auto const num_partitions  = 5;
+  auto const start_partition = 0;
+  auto const [out_table, out_offsets] =
+    cudf::round_robin_partition(cudf::table_view{{empty_column}}, num_partitions, start_partition);
+
+  EXPECT_EQ(out_table->num_rows(), 0);
+  EXPECT_EQ(out_offsets.size(), std::size_t{num_partitions});
+}
+
 TYPED_TEST(RoundRobinTest, RoundRobinPartitions13_3)
 {
   strings_column_wrapper rrColWrap1(

python/cudf/cudf/_lib/cpp/table/table.pxd

@@ -1,4 +1,4 @@
-# Copyright (c) 2020, NVIDIA CORPORATION.
+# Copyright (c) 2020-2022, NVIDIA CORPORATION.
 
 from libcpp.memory cimport unique_ptr
 from libcpp.vector cimport vector
@@ -14,6 +14,7 @@ cdef extern from "cudf/table/table.hpp" namespace "cudf" nogil:
         table(vector[unique_ptr[column]]&& columns) except +
         table(table_view) except +
         size_type num_columns() except +
+        size_type num_rows() except +
         table_view view() except +
         mutable_table_view mutable_view() except +
         vector[unique_ptr[column]] release() except +

python/cudf/cudf/_lib/hash.pyx

@@ -33,13 +33,9 @@ def hash_partition(list source_columns, object columns_to_hash,
             )
         )
 
-    # Note that the offsets (`c_result.second`) may be empty when
-    # the original table (`source_columns`) is empty. We need to
-    # return a list of zeros in this case.
     return (
         columns_from_unique_ptr(move(c_result.first)),
         list(c_result.second)
-        if c_result.second.size() else [0] * num_partitions
     )
 
 

python/cudf/cudf/core/indexed_frame.py

@@ -1621,6 +1621,9 @@ def _empty_like(self, keep_index=True):
         )
 
     def _split(self, splits, keep_index=True):
+        if self._num_rows == 0:
+            return []
+
         columns_split = libcudf.copying.columns_split(
             [
                 *(self._index._data.columns if keep_index else []),