From 62b9d016af1ff3014784b9efb373ce00061eb715 Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Wed, 23 Jun 2021 15:30:44 -0400
Subject: [PATCH 01/16] adding bool sort and partition_nth_indices

---
 cpp/src/arrow/compute/kernels/vector_sort.cc  | 23 ++++++++++++
 .../arrow/compute/kernels/vector_sort_test.cc | 35 +++++++++++++++++++
 2 files changed, 58 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 6c425d65550..e84b952f1be 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -370,6 +370,17 @@ inline void VisitRawValuesInline(const ArrayType& values,
       [&](int64_t i) { visitor_not_null(data[i]); }, [&]() { visitor_null(); });
 }
 
+template <typename VisitorNotNull, typename VisitorNull>
+inline void VisitRawValuesInline(const BooleanArray& values,
+                                 VisitorNotNull&& visitor_not_null,
+                                 VisitorNull&& visitor_null) {
+  const uint8_t* data = values.data()->buffers[1]->data();
+  VisitBitBlocksVoid(
+      values.null_bitmap(), values.offset(), values.length(),
+      [&](int64_t i) { visitor_not_null(BitUtil::GetBit(data, values.offset() + i)); },
+      [&]() { visitor_null(); });
+}
+
 template <typename ArrowType>
 class ArrayCompareSorter {
   using ArrayType = typename TypeTraits<ArrowType>::ArrayType;
@@ -527,6 +538,12 @@ class ArrayCountOrCompareSorter {
 template <typename Type, typename Enable = void>
 struct ArraySorter;
 
+template <>
+struct ArraySorter<BooleanType> {
+  ArrayCountSorter<BooleanType> impl;
+  ArraySorter() : impl(false, true) {}
+};
+
 template <>
 struct ArraySorter<UInt8Type> {
   ArrayCountSorter<UInt8Type> impl;
@@ -576,11 +593,17 @@ struct ArraySortIndices {
 
 // Sort indices kernels implemented for
 //
+// * Boolean type
 // * Number types
 // * Base binary types
 
 template <template <typename...> class ExecTemplate>
 void AddSortingKernels(VectorKernel base, VectorFunction* func) {
+  // bool type
+  base.signature = KernelSignature::Make({InputType::Array(boolean())}, uint64());
+  base.exec = ExecTemplate<UInt64Type, BooleanType>::Exec;
+  DCHECK_OK(func->AddKernel(base));
+
   for (const auto& ty : NumericTypes()) {
     auto physical_type = GetPhysicalType(ty);
     base.signature = KernelSignature::Make({InputType::Array(ty)}, uint64());
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index 2d76f0102f0..a12b4b761a2 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -180,6 +180,10 @@ template <typename ArrowType>
 class TestNthToIndicesForIntegral : public TestNthToIndices<ArrowType> {};
 TYPED_TEST_SUITE(TestNthToIndicesForIntegral, IntegralArrowTypes);
 
+template <typename ArrowType>
+class TestNthToIndicesForBool : public TestNthToIndices<ArrowType> {};
+TYPED_TEST_SUITE(TestNthToIndicesForBool, ::testing::Types<BooleanType>);
+
 template <typename ArrowType>
 class TestNthToIndicesForTemporal : public TestNthToIndices<ArrowType> {};
 TYPED_TEST_SUITE(TestNthToIndicesForTemporal, TemporalArrowTypes);
@@ -223,6 +227,13 @@ TYPED_TEST(TestNthToIndicesForIntegral, Integral) {
   this->AssertNthToIndicesJson("[null, 1, 3, null, 2, 5]", 6);
 }
 
+TYPED_TEST(TestNthToIndicesForBool, Bool) {
+  this->AssertNthToIndicesJson("[null, false, true, null, false, true]", 0);
+  this->AssertNthToIndicesJson("[null, false, true, null, false, true]", 2);
+  this->AssertNthToIndicesJson("[null, false, true, null, false, true]", 5);
+  this->AssertNthToIndicesJson("[null, false, true, null, false, true]", 6);
+}
+
 TYPED_TEST(TestNthToIndicesForTemporal, Temporal) {
   this->AssertNthToIndicesJson("[null, 1, 3, null, 2, 5]", 0);
   this->AssertNthToIndicesJson("[null, 1, 3, null, 2, 5]", 2);
@@ -402,6 +413,10 @@ template <typename ArrowType>
 class TestArraySortIndicesForReal : public TestArraySortIndices<ArrowType> {};
 TYPED_TEST_SUITE(TestArraySortIndicesForReal, RealArrowTypes);
 
+template <typename ArrowType>
+class TestArraySortIndicesForBool : public TestArraySortIndices<ArrowType> {};
+TYPED_TEST_SUITE(TestArraySortIndicesForBool, ::testing::Types<BooleanType>);
+
 template <typename ArrowType>
 class TestArraySortIndicesForIntegral : public TestArraySortIndices<ArrowType> {};
 TYPED_TEST_SUITE(TestArraySortIndicesForIntegral, IntegralArrowTypes);
@@ -464,6 +479,26 @@ TYPED_TEST(TestArraySortIndicesForIntegral, SortIntegral) {
                           "[5, 2, 4, 1, 0, 3]");
 }
 
+TYPED_TEST(TestArraySortIndicesForBool, SortBool) {
+  this->AssertSortIndices("[]", "[]");
+
+  this->AssertSortIndices("[true, true, false]", "[2, 0, 1]");
+  this->AssertSortIndices("[false, false,  false, true, true, true, true]",
+                          "[0, 1, 2, 3, 4, 5, 6]");
+  this->AssertSortIndices("[true, true, true, true, false, false, false]",
+                          "[4, 5, 6, 0, 1, 2, 3]");
+
+  this->AssertSortIndices("[false, true, false, true, true, false, false]",
+                          SortOrder::Ascending, "[0, 2, 5, 6, 1, 3, 4]");
+  this->AssertSortIndices("[false, true, false, true, true, false, false]",
+                          SortOrder::Descending, "[1, 3, 4, 0, 2, 5, 6]");
+
+  this->AssertSortIndices("[null, true, false, null, false, true]", SortOrder::Ascending,
+                          "[2, 4, 1, 5, 0, 3]");
+  this->AssertSortIndices("[null, true, false, null, false, true]", SortOrder::Descending,
+                          "[1, 5, 2, 4, 0, 3]");
+}
+
 TYPED_TEST(TestArraySortIndicesForTemporal, SortTemporal) {
   this->AssertSortIndices("[]", "[]");
 

From bec60ae2f7181ad0eda1a7c645d6fcd0bd89abad Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Wed, 23 Jun 2021 16:05:47 -0400
Subject: [PATCH 02/16] adding chunked array capability

---
 cpp/src/arrow/compute/kernels/vector_sort.cc      | 2 ++
 cpp/src/arrow/compute/kernels/vector_sort_test.cc | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index e84b952f1be..858302b4e11 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -694,6 +694,8 @@ class ChunkedArraySorter : public TypeVisitor {
 
   Status Sort() { return physical_type_->Accept(this); }
 
+  Status Visit(const BooleanType& type) override { return SortInternal<BooleanType>(); }
+
 #define VISIT(TYPE) \
   Status Visit(const TYPE& type) override { return SortInternal<TYPE>(); }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index a12b4b761a2..621105d15d2 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -581,7 +581,7 @@ class TestArraySortIndicesRandomCompare : public TestBase {};
 using SortIndicesableTypes =
     ::testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int8Type, Int16Type,
                      Int32Type, Int64Type, FloatType, DoubleType, StringType,
-                     Decimal128Type>;
+                     Decimal128Type, BooleanType>;
 
 template <typename ArrayType>
 void ValidateSorted(const ArrayType& array, UInt64Array& offsets, SortOrder order) {

From be3f0eb4fe369c1f0a3695dee7ffc4559613aa43 Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Wed, 23 Jun 2021 16:08:02 -0400
Subject: [PATCH 03/16] editing R files

---
 r/tests/testthat/helper-data.R        | 2 +-
 r/tests/testthat/test-dplyr-arrange.R | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/r/tests/testthat/helper-data.R b/r/tests/testthat/helper-data.R
index 43b5bf0354f..b4b1bac4d7b 100644
--- a/r/tests/testthat/helper-data.R
+++ b/r/tests/testthat/helper-data.R
@@ -152,7 +152,7 @@ example_data_for_sorting <- tibble::tibble(
   int = c(-.Machine$integer.max, -101L, -100L, 0L, 0L, 1L, 100L, 1000L, .Machine$integer.max, NA_integer_),
   dbl = c(-Inf, -.Machine$double.xmax, -.Machine$double.xmin, 0, .Machine$double.xmin, pi, .Machine$double.xmax, Inf, NaN, NA_real_),
   chr = c("", "", "\"", "&", "ABC", "NULL", "a", "abc", "zzz", NA_character_),
-  lgl = c(rep(FALSE, 4L), rep(TRUE, 5L), NA), # bool is not supported (ARROW-12016)
+  lgl = c(rep(FALSE, 4L), rep(TRUE, 5L), NA),
   dttm = lubridate::ymd_hms(c(
     "0000-01-01 00:00:00",
     "1919-05-29 13:08:55",
diff --git a/r/tests/testthat/test-dplyr-arrange.R b/r/tests/testthat/test-dplyr-arrange.R
index 6e663d23ec6..5131653146b 100644
--- a/r/tests/testthat/test-dplyr-arrange.R
+++ b/r/tests/testthat/test-dplyr-arrange.R
@@ -159,7 +159,6 @@ test_that("arrange() on datetime columns", {
 })
 
 test_that("arrange() on logical columns", {
-  skip("Sorting by bool columns is not supported (ARROW-12016)")
   expect_dplyr_equal(
     input %>%
       arrange(lgl, int) %>%

From 5af2751244f6498c4cec228a8ffb0b3e41022e2d Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Thu, 24 Jun 2021 12:34:39 -0400
Subject: [PATCH 04/16] adding bool type for record batches and tables

---
 cpp/src/arrow/compute/kernels/vector_sort.cc  |   3 +-
 .../arrow/compute/kernels/vector_sort_test.cc | 103 ++++++++++++++++++
 2 files changed, 104 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 858302b4e11..7f7c17c2dce 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -42,6 +42,7 @@ namespace internal {
 
 // Visit all physical types for which sorting is implemented.
 #define VISIT_PHYSICAL_TYPES(VISIT) \
+  VISIT(BooleanType)                \
   VISIT(Int8Type)                   \
   VISIT(Int16Type)                  \
   VISIT(Int32Type)                  \
@@ -694,8 +695,6 @@ class ChunkedArraySorter : public TypeVisitor {
 
   Status Sort() { return physical_type_->Accept(this); }
 
-  Status Visit(const BooleanType& type) override { return SortInternal<BooleanType>(); }
-
 #define VISIT(TYPE) \
   Status Visit(const TYPE& type) override { return SortInternal<TYPE>(); }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index 621105d15d2..29f84085e2c 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -877,6 +877,47 @@ TEST_F(TestRecordBatchSortIndices, NaNAndNull) {
   AssertSortIndices(batch, options, "[7, 1, 2, 6, 5, 4, 0, 3]");
 }
 
+TEST_F(TestRecordBatchSortIndices, Boolean) {
+  auto schema = ::arrow::schema({
+      {field("a", boolean())},
+      {field("b", boolean())},
+  });
+  SortOptions options(
+      {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
+
+  auto batch = RecordBatchFromJSON(schema,
+                                   R"([{"a": true,    "b": false},
+                                       {"a": false,   "b": true},
+                                       {"a": true,    "b": false},
+                                       {"a": false,   "b": true},
+                                       {"a": true,    "b": false},
+                                       {"a": false,   "b": false},
+                                       {"a": false,   "b": true}
+                                       ])");
+  AssertSortIndices(batch, options, "[1, 3, 6, 5, 0, 2, 4]");
+}
+
+TEST_F(TestRecordBatchSortIndices, BooleanNull) {
+  auto schema = ::arrow::schema({
+      {field("a", boolean())},
+      {field("b", boolean())},
+  });
+  SortOptions options(
+      {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
+
+  auto batch = RecordBatchFromJSON(schema,
+                                   R"([{"a": true,    "b": null},
+                                       {"a": false,   "b": null},
+                                       {"a": true,    "b": true},
+                                       {"a": false,   "b": true},
+                                       {"a": true,    "b": false},
+                                       {"a": null,    "b": false},
+                                       {"a": false,   "b": null},
+                                       {"a": null,    "b": true}
+                                       ])");
+  AssertSortIndices(batch, options, "[3, 1, 6, 2, 4, 0, 7, 5]");
+}
+
 TEST_F(TestRecordBatchSortIndices, MoreTypes) {
   auto schema = ::arrow::schema({
       {field("a", timestamp(TimeUnit::MICRO))},
@@ -1015,6 +1056,68 @@ TEST_F(TestTableSortIndices, NaNAndNull) {
   AssertSortIndices(table, options, "[7, 1, 2, 6, 5, 4, 0, 3]");
 }
 
+TEST_F(TestTableSortIndices, Boolean) {
+  auto schema = ::arrow::schema({
+      {field("a", boolean())},
+      {field("b", boolean())},
+  });
+  SortOptions options(
+      {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
+  std::shared_ptr<Table> table;
+
+  table = TableFromJSON(schema, {R"([{"a": true,    "b": false},
+                                       {"a": false,   "b": true},
+                                       {"a": true,    "b": false},
+                                       {"a": false,   "b": true},
+                                       {"a": true,    "b": false},
+                                       {"a": false,   "b": false},
+                                       {"a": false,   "b": true}
+                                       ])"});
+  AssertSortIndices(table, options, "[1, 3, 6, 5, 0, 2, 4]");
+
+  table = TableFromJSON(schema, {
+                                    R"([{"a": true,    "b": false},
+                                         {"a": false,   "b": true},
+                                         {"a": true,    "b": false},
+                                         {"a": false,   "b": true}])",
+                                    R"([{"a": true,    "b": false},
+                                      {"a": false,   "b": false},
+                                      {"a": false,   "b": true}])"});
+  AssertSortIndices(table, options, "[1, 3, 6, 5, 0, 2, 4]");
+}
+
+TEST_F(TestTableSortIndices, BooleanNull) {
+  auto schema = ::arrow::schema({
+      {field("a", boolean())},
+      {field("b", boolean())},
+  });
+  SortOptions options(
+      {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
+  std::shared_ptr<Table> table;
+  table = TableFromJSON(schema, {R"([{"a": true,    "b": null},
+                                       {"a": false,   "b": null},
+                                       {"a": true,    "b": true},
+                                       {"a": false,   "b": true},
+                                       {"a": true,    "b": false},
+                                       {"a": null,    "b": false},
+                                       {"a": false,   "b": null},
+                                       {"a": null,    "b": true}
+                                       ])"});
+
+  AssertSortIndices(table, options, "[3, 1, 6, 2, 4, 0, 7, 5]");
+
+  table = TableFromJSON(schema, {R"([{"a": true,    "b": null},
+                                       {"a": false,   "b": null},
+                                       {"a": true,    "b": true},
+                                       {"a": false,   "b": true}])",
+                                 R"([{"a": true,    "b": false},
+                                       {"a": null,    "b": false},
+                                       {"a": false,   "b": null},
+                                       {"a": null,    "b": true}
+                                       ])"});
+  AssertSortIndices(table, options, "[3, 1, 6, 2, 4, 0, 7, 5]");
+}
+
 TEST_F(TestTableSortIndices, BinaryLike) {
   auto schema = ::arrow::schema({
       {field("a", large_utf8())},

From ad1fe2be86a809d768a2221702b8e7272a0ef7d8 Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Thu, 24 Jun 2021 14:15:00 -0400
Subject: [PATCH 05/16] adding a simple bench

---
 .../compute/kernels/vector_sort_benchmark.cc     | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
index 820c51ba8ec..662f1a1a6b8 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
@@ -81,6 +81,16 @@ static void ArraySortIndicesInt64Wide(benchmark::State& state) {
   ArraySortIndicesInt64Benchmark(state, min, max);
 }
 
+static void ArraySortIndicesBool(benchmark::State& state) {
+  RegressionArgs args(state);
+
+  const int64_t array_size = args.size / 8;
+  auto rand = random::RandomArrayGenerator(kSeed);
+  auto values = rand.Boolean(array_size, 0.5, args.null_proportion);
+
+  ArraySortIndicesBenchmark(state, values);
+}
+
 static void ChunkedArraySortIndicesInt64Narrow(benchmark::State& state) {
   ChunkedArraySortIndicesInt64Benchmark(state, -100, 100);
 }
@@ -235,6 +245,12 @@ BENCHMARK(ArraySortIndicesInt64Wide)
     ->Args({1 << 23, 100})
     ->Unit(benchmark::TimeUnit::kNanosecond);
 
+BENCHMARK(ArraySortIndicesBool)
+    ->Apply(RegressionSetArgs)
+    ->Args({1 << 20, 100})
+    ->Args({1 << 23, 100})
+    ->Unit(benchmark::TimeUnit::kNanosecond);
+
 BENCHMARK(ChunkedArraySortIndicesInt64Narrow)
     ->Apply(RegressionSetArgs)
     ->Args({1 << 20, 100})

From cc0f7904c7975ab8d350630a4f7b1e28bc38674a Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Mon, 28 Jun 2021 16:02:37 -0400
Subject: [PATCH 06/16] minor change

---
 cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
index 662f1a1a6b8..d8e3b9b8081 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
@@ -84,7 +84,7 @@ static void ArraySortIndicesInt64Wide(benchmark::State& state) {
 static void ArraySortIndicesBool(benchmark::State& state) {
   RegressionArgs args(state);
 
-  const int64_t array_size = args.size / 8;
+  const int64_t array_size = args.size * 8;
   auto rand = random::RandomArrayGenerator(kSeed);
   auto values = rand.Boolean(array_size, 0.5, args.null_proportion);
 

From efb4800d41fed4f17eee1d6c8cb6370f290e30aa Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Fri, 2 Jul 2021 19:04:06 -0400
Subject: [PATCH 07/16] adding specialized impl for bool

---
 cpp/src/arrow/compute/kernels/vector_sort.cc | 84 +++++++++++++++++++-
 1 file changed, 83 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 7f7c17c2dce..f9f8f94591a 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -29,6 +29,8 @@
 #include "arrow/table.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/bit_block_counter.h"
+#include "arrow/util/bitmap.h"
+#include "arrow/util/bitmap_ops.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/optional.h"
 #include "arrow/visitor_inline.h"
@@ -489,6 +491,87 @@ class ArrayCountSorter {
   }
 };
 
+using ::arrow::internal::Bitmap;
+
+template <>
+class ArrayCountSorter<BooleanType> {
+ public:
+  ArrayCountSorter() = default;
+
+  // Returns where null starts.
+  uint64_t* Sort(uint64_t* indices_begin, uint64_t* indices_end,
+                 const BooleanArray& values, int64_t offset,
+                 const ArraySortOptions& options) {
+    // 32bit counter performs much better than 64bit one
+    if (values.length() < (1LL << 32)) {
+      return SortInternal<uint32_t>(indices_begin, indices_end, values, offset, options);
+    } else {
+      return SortInternal<uint64_t>(indices_begin, indices_end, values, offset, options);
+    }
+  }
+
+ private:
+  template <typename CounterType>
+  void CountBits(const BooleanArray& values, int64_t offset, CounterType* set_count,
+                 CounterType* null_count) {
+    if (values.data()->buffers[0]) {  // if validity buffer present
+      Bitmap bitmaps[2]{
+          {values.data()->buffers[0], offset, values.length()},
+          {values.data()->buffers[1], offset, values.length()},
+      };
+      *set_count = 0;
+      *null_count = 0;
+      Bitmap::VisitWords(bitmaps, [&](std::array<uint64_t, 2> words) {
+        // count valid count for the moment
+        *null_count += BitUtil::PopCount(words[0]);
+        *set_count += BitUtil::PopCount(words[0] & words[1]);
+      });
+
+      *null_count = values.length() - *null_count;  // convert valid count to null count
+    } else {                                        // all are valid
+      *null_count = 0;
+      *set_count = ::arrow::internal::CountSetBits(values.data()->buffers[1]->data(),
+                                                   offset, values.length());
+    }
+  }
+
+  // Returns where null starts.
+  //
+  // `offset` is used when this is called on a chunk of a chunked array
+  template <typename CounterType>
+  uint64_t* SortInternal(uint64_t* indices_begin, uint64_t* indices_end,
+                         const BooleanArray& values, int64_t offset,
+                         const ArraySortOptions& options) {
+    // first slot reserved for prefix sum
+    std::vector<CounterType> counts(3);
+
+    CounterType ones, nulls;
+    CountBits(values, offset, &ones, &nulls);
+
+    if (options.order == SortOrder::Ascending) {
+      counts[1] = values.length() - ones - nulls;  // 0's
+      counts[2] = values.length() - nulls;         // 0's + 1's
+      auto null_position = counts[2];
+      auto nulls_begin = indices_begin + null_position;
+      int64_t index = offset;
+      VisitRawValuesInline(
+          values, [&](bool v) { indices_begin[counts[v]++] = index++; },
+          [&]() { indices_begin[null_position++] = index++; });
+      return nulls_begin;
+    } else {
+      counts[0] = values.length() - nulls;  // 0's + 1's
+      counts[1] = ones;                     // 1's
+      auto null_position = counts[0];
+      auto nulls_begin = indices_begin + null_position;
+      int64_t index = offset;
+      VisitRawValuesInline(
+          values, [&](bool v) { indices_begin[counts[v + 1]++] = index++; },
+          [&]() { indices_begin[null_position++] = index++; });
+      return nulls_begin;
+    }
+  }
+};
+
 // Sort integers with counting sort or comparison based sorting algorithm
 // - Use O(n) counting sort if values are in a small range
 // - Use O(nlogn) std::stable_sort otherwise
@@ -542,7 +625,6 @@ struct ArraySorter;
 template <>
 struct ArraySorter<BooleanType> {
   ArrayCountSorter<BooleanType> impl;
-  ArraySorter() : impl(false, true) {}
 };
 
 template <>

From cb0ceadbc0a9560a626b7bb1e8c5db3a5e025161 Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Fri, 2 Jul 2021 19:13:21 -0400
Subject: [PATCH 08/16] changing vector to array

---
 cpp/src/arrow/compute/kernels/vector_sort.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index f9f8f94591a..1dbd30ef224 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -543,7 +543,7 @@ class ArrayCountSorter<BooleanType> {
                          const BooleanArray& values, int64_t offset,
                          const ArraySortOptions& options) {
     // first slot reserved for prefix sum
-    std::vector<CounterType> counts(3);
+    std::array<CounterType, 3> counts{0, 0, 0};
 
     CounterType ones, nulls;
     CountBits(values, offset, &ones, &nulls);

From c81df3fcbdca734a3eb2be1fdec19dbad619b6d3 Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Tue, 6 Jul 2021 10:18:50 -0400
Subject: [PATCH 09/16] adding PR comments

---
 cpp/src/arrow/compute/kernels/vector_sort.cc  | 27 +---------
 .../arrow/compute/kernels/vector_sort_test.cc | 50 -------------------
 2 files changed, 1 insertion(+), 76 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 1dbd30ef224..f779105b6e8 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -511,30 +511,6 @@ class ArrayCountSorter<BooleanType> {
   }
 
  private:
-  template <typename CounterType>
-  void CountBits(const BooleanArray& values, int64_t offset, CounterType* set_count,
-                 CounterType* null_count) {
-    if (values.data()->buffers[0]) {  // if validity buffer present
-      Bitmap bitmaps[2]{
-          {values.data()->buffers[0], offset, values.length()},
-          {values.data()->buffers[1], offset, values.length()},
-      };
-      *set_count = 0;
-      *null_count = 0;
-      Bitmap::VisitWords(bitmaps, [&](std::array<uint64_t, 2> words) {
-        // count valid count for the moment
-        *null_count += BitUtil::PopCount(words[0]);
-        *set_count += BitUtil::PopCount(words[0] & words[1]);
-      });
-
-      *null_count = values.length() - *null_count;  // convert valid count to null count
-    } else {                                        // all are valid
-      *null_count = 0;
-      *set_count = ::arrow::internal::CountSetBits(values.data()->buffers[1]->data(),
-                                                   offset, values.length());
-    }
-  }
-
   // Returns where null starts.
   //
   // `offset` is used when this is called on a chunk of a chunked array
@@ -545,8 +521,7 @@ class ArrayCountSorter<BooleanType> {
     // first slot reserved for prefix sum
     std::array<CounterType, 3> counts{0, 0, 0};
 
-    CounterType ones, nulls;
-    CountBits(values, offset, &ones, &nulls);
+    CounterType ones = values.true_count(), nulls = values.null_count();
 
     if (options.order == SortOrder::Ascending) {
       counts[1] = values.length() - ones - nulls;  // 0's
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index 29f84085e2c..55c74e58f6a 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -885,26 +885,6 @@ TEST_F(TestRecordBatchSortIndices, Boolean) {
   SortOptions options(
       {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
 
-  auto batch = RecordBatchFromJSON(schema,
-                                   R"([{"a": true,    "b": false},
-                                       {"a": false,   "b": true},
-                                       {"a": true,    "b": false},
-                                       {"a": false,   "b": true},
-                                       {"a": true,    "b": false},
-                                       {"a": false,   "b": false},
-                                       {"a": false,   "b": true}
-                                       ])");
-  AssertSortIndices(batch, options, "[1, 3, 6, 5, 0, 2, 4]");
-}
-
-TEST_F(TestRecordBatchSortIndices, BooleanNull) {
-  auto schema = ::arrow::schema({
-      {field("a", boolean())},
-      {field("b", boolean())},
-  });
-  SortOptions options(
-      {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
-
   auto batch = RecordBatchFromJSON(schema,
                                    R"([{"a": true,    "b": null},
                                        {"a": false,   "b": null},
@@ -1064,36 +1044,6 @@ TEST_F(TestTableSortIndices, Boolean) {
   SortOptions options(
       {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
   std::shared_ptr<Table> table;
-
-  table = TableFromJSON(schema, {R"([{"a": true,    "b": false},
-                                       {"a": false,   "b": true},
-                                       {"a": true,    "b": false},
-                                       {"a": false,   "b": true},
-                                       {"a": true,    "b": false},
-                                       {"a": false,   "b": false},
-                                       {"a": false,   "b": true}
-                                       ])"});
-  AssertSortIndices(table, options, "[1, 3, 6, 5, 0, 2, 4]");
-
-  table = TableFromJSON(schema, {
-                                    R"([{"a": true,    "b": false},
-                                         {"a": false,   "b": true},
-                                         {"a": true,    "b": false},
-                                         {"a": false,   "b": true}])",
-                                    R"([{"a": true,    "b": false},
-                                      {"a": false,   "b": false},
-                                      {"a": false,   "b": true}])"});
-  AssertSortIndices(table, options, "[1, 3, 6, 5, 0, 2, 4]");
-}
-
-TEST_F(TestTableSortIndices, BooleanNull) {
-  auto schema = ::arrow::schema({
-      {field("a", boolean())},
-      {field("b", boolean())},
-  });
-  SortOptions options(
-      {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
-  std::shared_ptr<Table> table;
   table = TableFromJSON(schema, {R"([{"a": true,    "b": null},
                                        {"a": false,   "b": null},
                                        {"a": true,    "b": true},

From 5d58b531e7e28c34dc78827fb8cae85b001a9ccb Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Tue, 6 Jul 2021 11:04:02 -0400
Subject: [PATCH 10/16] Update vector_sort.cc

---
 cpp/src/arrow/compute/kernels/vector_sort.cc | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index f779105b6e8..c81c9a5268f 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -521,8 +521,9 @@ class ArrayCountSorter<BooleanType> {
     // first slot reserved for prefix sum
     std::array<CounterType, 3> counts{0, 0, 0};
 
-    CounterType ones = values.true_count(), nulls = values.null_count();
-
+    CounterType ones = static_cast<CounterType>(values.true_count()),
+                nulls = static_cast<CounterType>(values.null_count());
+    
     if (options.order == SortOrder::Ascending) {
       counts[1] = values.length() - ones - nulls;  // 0's
       counts[2] = values.length() - nulls;         // 0's + 1's

From ce74d34ed23d783c7653fc2fe87abc3a8a07e985 Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Tue, 6 Jul 2021 12:01:04 -0400
Subject: [PATCH 11/16] minor changes

---
 cpp/src/arrow/compute/kernels/vector_sort.cc | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index c81c9a5268f..424b55d96ee 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -523,10 +523,10 @@ class ArrayCountSorter<BooleanType> {
 
     CounterType ones = static_cast<CounterType>(values.true_count()),
                 nulls = static_cast<CounterType>(values.null_count());
-    
+
     if (options.order == SortOrder::Ascending) {
-      counts[1] = values.length() - ones - nulls;  // 0's
-      counts[2] = values.length() - nulls;         // 0's + 1's
+      counts[1] = static_cast<CounterType>(values.length()) - ones - nulls;  // 0's
+      counts[2] = static_cast<CounterType>(values.length()) - nulls;         // 0's + 1's
       auto null_position = counts[2];
       auto nulls_begin = indices_begin + null_position;
       int64_t index = offset;
@@ -535,8 +535,8 @@ class ArrayCountSorter<BooleanType> {
           [&]() { indices_begin[null_position++] = index++; });
       return nulls_begin;
     } else {
-      counts[0] = values.length() - nulls;  // 0's + 1's
-      counts[1] = ones;                     // 1's
+      counts[0] = static_cast<CounterType>(values.length()) - nulls;  // 0's + 1's
+      counts[1] = ones;                                               // 1's
       auto null_position = counts[0];
       auto nulls_begin = indices_begin + null_position;
       int64_t index = offset;

From 151e466caed1100b580fca4b66aa610eb893138c Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Mon, 19 Jul 2021 11:46:07 -0400
Subject: [PATCH 12/16] removing non-null case in TestTableSortIndices

---
 .../arrow/compute/kernels/vector_sort_test.cc   | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index 55c74e58f6a..478f6ccac3a 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -1043,24 +1043,11 @@ TEST_F(TestTableSortIndices, Boolean) {
   });
   SortOptions options(
       {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)});
-  std::shared_ptr<Table> table;
-  table = TableFromJSON(schema, {R"([{"a": true,    "b": null},
-                                       {"a": false,   "b": null},
-                                       {"a": true,    "b": true},
-                                       {"a": false,   "b": true},
-                                       {"a": true,    "b": false},
-                                       {"a": null,    "b": false},
-                                       {"a": false,   "b": null},
-                                       {"a": null,    "b": true}
-                                       ])"});
-
-  AssertSortIndices(table, options, "[3, 1, 6, 2, 4, 0, 7, 5]");
-
-  table = TableFromJSON(schema, {R"([{"a": true,    "b": null},
+  auto table = TableFromJSON(schema, {R"([{"a": true,    "b": null},
                                        {"a": false,   "b": null},
                                        {"a": true,    "b": true},
                                        {"a": false,   "b": true}])",
-                                 R"([{"a": true,    "b": false},
+                                      R"([{"a": true,    "b": false},
                                        {"a": null,    "b": false},
                                        {"a": false,   "b": null},
                                        {"a": null,    "b": true}

From fbb212905c365f36cb7155f14d646665eb7e60d8 Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Mon, 19 Jul 2021 11:53:33 -0400
Subject: [PATCH 13/16] removing unnecessary uint32/ uint64 branch

---
 cpp/src/arrow/compute/kernels/vector_sort.cc | 34 ++++++--------------
 1 file changed, 9 insertions(+), 25 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 424b55d96ee..6c743913c49 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -499,34 +499,18 @@ class ArrayCountSorter<BooleanType> {
   ArrayCountSorter() = default;
 
   // Returns where null starts.
-  uint64_t* Sort(uint64_t* indices_begin, uint64_t* indices_end,
-                 const BooleanArray& values, int64_t offset,
-                 const ArraySortOptions& options) {
-    // 32bit counter performs much better than 64bit one
-    if (values.length() < (1LL << 32)) {
-      return SortInternal<uint32_t>(indices_begin, indices_end, values, offset, options);
-    } else {
-      return SortInternal<uint64_t>(indices_begin, indices_end, values, offset, options);
-    }
-  }
-
- private:
-  // Returns where null starts.
-  //
   // `offset` is used when this is called on a chunk of a chunked array
-  template <typename CounterType>
-  uint64_t* SortInternal(uint64_t* indices_begin, uint64_t* indices_end,
-                         const BooleanArray& values, int64_t offset,
-                         const ArraySortOptions& options) {
+  static uint64_t* Sort(uint64_t* indices_begin, uint64_t* indices_end,
+                        const BooleanArray& values, int64_t offset,
+                        const ArraySortOptions& options) {
     // first slot reserved for prefix sum
-    std::array<CounterType, 3> counts{0, 0, 0};
+    std::array<int64_t, 3> counts{0, 0, 0};
 
-    CounterType ones = static_cast<CounterType>(values.true_count()),
-                nulls = static_cast<CounterType>(values.null_count());
+    int64_t ones = values.true_count(), nulls = values.null_count();
 
     if (options.order == SortOrder::Ascending) {
-      counts[1] = static_cast<CounterType>(values.length()) - ones - nulls;  // 0's
-      counts[2] = static_cast<CounterType>(values.length()) - nulls;         // 0's + 1's
+      counts[1] = values.length() - ones - nulls;  // 0's
+      counts[2] = values.length() - nulls;         // 0's + 1's
       auto null_position = counts[2];
       auto nulls_begin = indices_begin + null_position;
       int64_t index = offset;
@@ -535,8 +519,8 @@ class ArrayCountSorter<BooleanType> {
           [&]() { indices_begin[null_position++] = index++; });
       return nulls_begin;
     } else {
-      counts[0] = static_cast<CounterType>(values.length()) - nulls;  // 0's + 1's
-      counts[1] = ones;                                               // 1's
+      counts[0] = values.length() - nulls;  // 0's + 1's
+      counts[1] = ones;                     // 1's
       auto null_position = counts[0];
       auto nulls_begin = indices_begin + null_position;
       int64_t index = offset;

From b6ccdb228b746114783f714d65c2c9dea408de09 Mon Sep 17 00:00:00 2001
From: niranda perera <niranda.perera@gmail.com>
Date: Tue, 20 Jul 2021 02:11:06 -0400
Subject: [PATCH 14/16] trying to fix appveyor error

---
 cpp/src/arrow/compute/kernels/vector_sort.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 6c743913c49..94aa233036d 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -500,9 +500,9 @@ class ArrayCountSorter<BooleanType> {
 
   // Returns where null starts.
   // `offset` is used when this is called on a chunk of a chunked array
-  static uint64_t* Sort(uint64_t* indices_begin, uint64_t* indices_end,
-                        const BooleanArray& values, int64_t offset,
-                        const ArraySortOptions& options) {
+  uint64_t* Sort(uint64_t* indices_begin, uint64_t* indices_end,
+                 const BooleanArray& values, int64_t offset,
+                 const ArraySortOptions& options) {
     // first slot reserved for prefix sum
     std::array<int64_t, 3> counts{0, 0, 0};
 

From 3de75a71f3916f0dfd8ba06c3eb2fd2d8a5a37b4 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 21 Jul 2021 12:41:51 +0200
Subject: [PATCH 15/16] Update docs, simplify code

---
 cpp/src/arrow/compute/kernels/vector_sort.cc | 28 ++++++++----------
 docs/source/cpp/compute.rst                  | 30 ++++++++++----------
 2 files changed, 27 insertions(+), 31 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 94aa233036d..52990940226 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -503,32 +503,28 @@ class ArrayCountSorter<BooleanType> {
   uint64_t* Sort(uint64_t* indices_begin, uint64_t* indices_end,
                  const BooleanArray& values, int64_t offset,
                  const ArraySortOptions& options) {
-    // first slot reserved for prefix sum
-    std::array<int64_t, 3> counts{0, 0, 0};
+    std::array<int64_t, 2> counts{0, 0};
+
+    const int64_t nulls = values.null_count();
+    const int64_t ones = values.true_count();
+    const int64_t zeros = values.length() - ones - nulls;
 
-    int64_t ones = values.true_count(), nulls = values.null_count();
+    int64_t null_position = values.length() - nulls;
+    int64_t index = offset;
+    const auto nulls_begin = indices_begin + null_position;
 
     if (options.order == SortOrder::Ascending) {
-      counts[1] = values.length() - ones - nulls;  // 0's
-      counts[2] = values.length() - nulls;         // 0's + 1's
-      auto null_position = counts[2];
-      auto nulls_begin = indices_begin + null_position;
-      int64_t index = offset;
+      counts[1] = zeros;
       VisitRawValuesInline(
           values, [&](bool v) { indices_begin[counts[v]++] = index++; },
           [&]() { indices_begin[null_position++] = index++; });
-      return nulls_begin;
     } else {
-      counts[0] = values.length() - nulls;  // 0's + 1's
-      counts[1] = ones;                     // 1's
-      auto null_position = counts[0];
-      auto nulls_begin = indices_begin + null_position;
-      int64_t index = offset;
+      counts[0] = ones;
       VisitRawValuesInline(
-          values, [&](bool v) { indices_begin[counts[v + 1]++] = index++; },
+          values, [&](bool v) { indices_begin[counts[v]++] = index++; },
           [&]() { indices_begin[null_position++] = index++; });
-      return nulls_begin;
     }
+    return nulls_begin;
   }
 };
 
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 4bcb568fdc2..b389b43c02e 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1163,21 +1163,21 @@ In these functions, nulls are considered greater than any other value
 Floating-point NaN values are considered greater than any other non-null
 value, but smaller than nulls.
 
-+-----------------------+------------+-------------------------+-------------------+--------------------------------+----------------+
-| Function name         | Arity      | Input types             | Output type       | Options class                  | Notes          |
-+=======================+============+=========================+===================+================================+================+
-| partition_nth_indices | Unary      | Binary- and String-like | UInt64            | :struct:`PartitionNthOptions`  | \(1) \(3)      |
-+-----------------------+------------+-------------------------+-------------------+--------------------------------+----------------+
-| partition_nth_indices | Unary      | Numeric                 | UInt64            | :struct:`PartitionNthOptions`  | \(1)           |
-+-----------------------+------------+-------------------------+-------------------+--------------------------------+----------------+
-| array_sort_indices    | Unary      | Binary- and String-like | UInt64            | :struct:`ArraySortOptions`     | \(2) \(3) \(4) |
-+-----------------------+------------+-------------------------+-------------------+--------------------------------+----------------+
-| array_sort_indices    | Unary      | Numeric                 | UInt64            | :struct:`ArraySortOptions`     | \(2) \(4)      |
-+-----------------------+------------+-------------------------+-------------------+--------------------------------+----------------+
-| sort_indices          | Unary      | Binary- and String-like | UInt64            | :struct:`SortOptions`          | \(2) \(3) \(5) |
-+-----------------------+------------+-------------------------+-------------------+--------------------------------+----------------+
-| sort_indices          | Unary      | Numeric                 | UInt64            | :struct:`SortOptions`          | \(2) \(5)      |
-+-----------------------+------------+-------------------------+-------------------+--------------------------------+----------------+
++-----------------------+------------+-----------------------------+-------------------+--------------------------------+----------------+
+| Function name         | Arity      | Input types                 | Output type       | Options class                  | Notes          |
++=======================+============+=============================+===================+================================+================+
+| partition_nth_indices | Unary      | Binary- and String-like     | UInt64            | :struct:`PartitionNthOptions`  | \(1) \(3)      |
++-----------------------+------------+-----------------------------+-------------------+--------------------------------+----------------+
+| partition_nth_indices | Unary      | Boolean, Numeric, Temporal  | UInt64            | :struct:`PartitionNthOptions`  | \(1)           |
++-----------------------+------------+-----------------------------+-------------------+--------------------------------+----------------+
+| array_sort_indices    | Unary      | Binary- and String-like     | UInt64            | :struct:`ArraySortOptions`     | \(2) \(3) \(4) |
++-----------------------+------------+-----------------------------+-------------------+--------------------------------+----------------+
+| array_sort_indices    | Unary      | Boolean, Numeric, Temporal  | UInt64            | :struct:`ArraySortOptions`     | \(2) \(4)      |
++-----------------------+------------+-----------------------------+-------------------+--------------------------------+----------------+
+| sort_indices          | Unary      | Binary- and String-like     | UInt64            | :struct:`SortOptions`          | \(2) \(3) \(5) |
++-----------------------+------------+-----------------------------+-------------------+--------------------------------+----------------+
+| sort_indices          | Unary      | Boolean, Numeric, Temporal  | UInt64            | :struct:`SortOptions`          | \(2) \(5)      |
++-----------------------+------------+-----------------------------+-------------------+--------------------------------+----------------+
 
 * \(1) The output is an array of indices into the input array, that define
   a partial non-stable sort such that the *N*'th index points to the *N*'th

From 257527c9de339ab41b9f1af125e18a042b9a3ae5 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 21 Jul 2021 13:05:34 +0200
Subject: [PATCH 16/16] Improve performance in the no-nulls case

---
 cpp/src/arrow/compute/kernels/vector_sort.cc | 28 ++++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 52990940226..7fa43e715d8 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -377,11 +377,18 @@ template <typename VisitorNotNull, typename VisitorNull>
 inline void VisitRawValuesInline(const BooleanArray& values,
                                  VisitorNotNull&& visitor_not_null,
                                  VisitorNull&& visitor_null) {
-  const uint8_t* data = values.data()->buffers[1]->data();
-  VisitBitBlocksVoid(
-      values.null_bitmap(), values.offset(), values.length(),
-      [&](int64_t i) { visitor_not_null(BitUtil::GetBit(data, values.offset() + i)); },
-      [&]() { visitor_null(); });
+  if (values.null_count() != 0) {
+    const uint8_t* data = values.data()->GetValues<uint8_t>(1, 0);
+    VisitBitBlocksVoid(
+        values.null_bitmap(), values.offset(), values.length(),
+        [&](int64_t i) { visitor_not_null(BitUtil::GetBit(data, values.offset() + i)); },
+        [&]() { visitor_null(); });
+  } else {
+    // Can avoid GetBit() overhead in the no-nulls case
+    VisitBitBlocksVoid(
+        values.data()->buffers[1], values.offset(), values.length(),
+        [&](int64_t i) { visitor_not_null(true); }, [&]() { visitor_not_null(false); });
+  }
 }
 
 template <typename ArrowType>
@@ -514,16 +521,15 @@ class ArrayCountSorter<BooleanType> {
     const auto nulls_begin = indices_begin + null_position;
 
     if (options.order == SortOrder::Ascending) {
+      // ones start after zeros
       counts[1] = zeros;
-      VisitRawValuesInline(
-          values, [&](bool v) { indices_begin[counts[v]++] = index++; },
-          [&]() { indices_begin[null_position++] = index++; });
     } else {
+      // zeros start after ones
       counts[0] = ones;
-      VisitRawValuesInline(
-          values, [&](bool v) { indices_begin[counts[v]++] = index++; },
-          [&]() { indices_begin[null_position++] = index++; });
     }
+    VisitRawValuesInline(
+        values, [&](bool v) { indices_begin[counts[v]++] = index++; },
+        [&]() { indices_begin[null_position++] = index++; });
     return nulls_begin;
   }
 };