From 1e141d72484ade0e310754584c4bb346427d32af Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Sun, 29 Sep 2024 18:23:09 +0800
Subject: [PATCH 01/54] WIP

---
 cpp/src/arrow/CMakeLists.txt                  |  1 +
 .../arrow/compute/kernels/vector_gather.cc    | 49 +++++++++++++++++++
 .../compute/kernels/vector_gather_internal.h  | 39 +++++++++++++++
 3 files changed, 89 insertions(+)
 create mode 100644 cpp/src/arrow/compute/kernels/vector_gather.cc
 create mode 100644 cpp/src/arrow/compute/kernels/vector_gather_internal.h

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index c911f0f4e9481..b9d542fce8482 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -786,6 +786,7 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_validity.cc
        compute/kernels/vector_array_sort.cc
        compute/kernels/vector_cumulative_ops.cc
+       compute/kernels/vector_gather.cc
        compute/kernels/vector_pairwise.cc
        compute/kernels/vector_nested.cc
        compute/kernels/vector_rank.cc
diff --git a/cpp/src/arrow/compute/kernels/vector_gather.cc b/cpp/src/arrow/compute/kernels/vector_gather.cc
new file mode 100644
index 0000000000000..46a271099c90a
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_gather.cc
@@ -0,0 +1,49 @@
+// #include "arrow/compute/kernels/vector_gather_internal.h"
+#include "arrow/compute/function.h"
+#include "arrow/compute/kernels/codegen_internal.h"
+#include "arrow/compute/registry.h"
+#include "arrow/util/logging.h"
+
+namespace arrow::compute::internal {
+
+namespace {
+
+struct GatherKernelSignature {
+  InputType indices_type;
+  InputType value_type;
+  ArrayKernelExec exec;
+};
+
+std::unique_ptr<Function> MakeGatherFunction(
+    std::string name, int min_args, std::vector<GatherKernelSignature>&& signatures,
+    FunctionDoc doc) {
+  auto func = std::make_unique<VectorFunction>(std::move(name), Arity::VarArgs(min_args),
+                                               std::move(doc));
+  for (auto& signature : signatures) {
+    auto kernel = VectorKernel{};
+    kernel.signature = KernelSignature::Make(
+        {std::move(signature.indices_type), std::move(signature.value_type)},
+        OutputType(LastType), /*is_varargs=*/true);
+    kernel.exec = signature.exec;
+    kernel.can_execute_chunkwise = false;
+    DCHECK_OK(func->AddKernel(std::move(kernel)));
+  }
+  return func;
+}
+
+const FunctionDoc gather_doc(
+    "Gather values from a list of inputs with an indices vector",
+    "The output is populated with values selected from the inputs, where each value is "
+    "chosen based on the corresponding index from the indices that specifies which input "
+    "in the list to use",
+    {"indices", "*inputs"});
+
+}  // namespace
+
+void RegisterVectorGather(FunctionRegistry* registry) {
+  std::vector<GatherKernelSignature> signatures = {};
+  DCHECK_OK(registry->AddFunction(
+      MakeGatherFunction("gather", /*min_args=*/2, std::move(signatures), gather_doc)));
+}
+
+}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_gather_internal.h b/cpp/src/arrow/compute/kernels/vector_gather_internal.h
new file mode 100644
index 0000000000000..32988b1e148b8
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_gather_internal.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "arrow/compute/function.h"
+
+namespace arrow::compute::internal {
+
+// class GatherMetaFunction : public MetaFunction {
+//  public:
+//   GatherMetaFunction() : MetaFunction("gather", Arity::VarArgs(3), gather_doc) {}
+
+//   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
+//                             const FunctionOptions* options,
+//                             ExecContext* ctx) const override {
+//     for (const auto& arg : args) {
+//       if (arg.kind() != Datum::ARRAY && arg.kind() != Datum::CHUNKED_ARRAY) {
+//         return Status::TypeError("Gather arguments should be array-like");
+//       }
+//     }
+
+//     if (!is_integer(*args[0].type())) {
+//       return Status::NotImplemented("Indices to gather must be integer type");
+//     }
+
+//     if (args[0].kind() == Datum::RECORD_BATCH) {
+//       ARROW_ASSIGN_OR_RAISE(
+//           std::shared_ptr<RecordBatch> out_batch,
+//           FilterRecordBatch(*args[0].record_batch(), args[1], options, ctx));
+//       return Datum(out_batch);
+//     } else if (args[0].kind() == Datum::TABLE) {
+//       ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Table> out_table,
+//                             FilterTable(*args[0].table(), args[1], options, ctx));
+//       return Datum(out_table);
+//     } else {
+//       return CallFunction("array_filter", args, options, ctx);
+//     }
+//   }
+// };
+
+}  // namespace arrow::compute::internal

From 216e217991967338a9db4b6036f4b3630764bc80 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 30 Sep 2024 17:43:37 +0800
Subject: [PATCH 02/54] WIP

---
 cpp/src/arrow/CMakeLists.txt                  |   2 +-
 .../arrow/compute/kernels/vector_gather.cc    |  49 -----
 .../compute/kernels/vector_gather_internal.h  |  39 ----
 .../arrow/compute/kernels/vector_permute.cc   | 175 ++++++++++++++++++
 4 files changed, 176 insertions(+), 89 deletions(-)
 delete mode 100644 cpp/src/arrow/compute/kernels/vector_gather.cc
 delete mode 100644 cpp/src/arrow/compute/kernels/vector_gather_internal.h
 create mode 100644 cpp/src/arrow/compute/kernels/vector_permute.cc

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index b9d542fce8482..428eef04007c2 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -786,8 +786,8 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_validity.cc
        compute/kernels/vector_array_sort.cc
        compute/kernels/vector_cumulative_ops.cc
-       compute/kernels/vector_gather.cc
        compute/kernels/vector_pairwise.cc
+       compute/kernels/vector_permute.cc
        compute/kernels/vector_nested.cc
        compute/kernels/vector_rank.cc
        compute/kernels/vector_replace.cc
diff --git a/cpp/src/arrow/compute/kernels/vector_gather.cc b/cpp/src/arrow/compute/kernels/vector_gather.cc
deleted file mode 100644
index 46a271099c90a..0000000000000
--- a/cpp/src/arrow/compute/kernels/vector_gather.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// #include "arrow/compute/kernels/vector_gather_internal.h"
-#include "arrow/compute/function.h"
-#include "arrow/compute/kernels/codegen_internal.h"
-#include "arrow/compute/registry.h"
-#include "arrow/util/logging.h"
-
-namespace arrow::compute::internal {
-
-namespace {
-
-struct GatherKernelSignature {
-  InputType indices_type;
-  InputType value_type;
-  ArrayKernelExec exec;
-};
-
-std::unique_ptr<Function> MakeGatherFunction(
-    std::string name, int min_args, std::vector<GatherKernelSignature>&& signatures,
-    FunctionDoc doc) {
-  auto func = std::make_unique<VectorFunction>(std::move(name), Arity::VarArgs(min_args),
-                                               std::move(doc));
-  for (auto& signature : signatures) {
-    auto kernel = VectorKernel{};
-    kernel.signature = KernelSignature::Make(
-        {std::move(signature.indices_type), std::move(signature.value_type)},
-        OutputType(LastType), /*is_varargs=*/true);
-    kernel.exec = signature.exec;
-    kernel.can_execute_chunkwise = false;
-    DCHECK_OK(func->AddKernel(std::move(kernel)));
-  }
-  return func;
-}
-
-const FunctionDoc gather_doc(
-    "Gather values from a list of inputs with an indices vector",
-    "The output is populated with values selected from the inputs, where each value is "
-    "chosen based on the corresponding index from the indices that specifies which input "
-    "in the list to use",
-    {"indices", "*inputs"});
-
-}  // namespace
-
-void RegisterVectorGather(FunctionRegistry* registry) {
-  std::vector<GatherKernelSignature> signatures = {};
-  DCHECK_OK(registry->AddFunction(
-      MakeGatherFunction("gather", /*min_args=*/2, std::move(signatures), gather_doc)));
-}
-
-}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_gather_internal.h b/cpp/src/arrow/compute/kernels/vector_gather_internal.h
deleted file mode 100644
index 32988b1e148b8..0000000000000
--- a/cpp/src/arrow/compute/kernels/vector_gather_internal.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include "arrow/compute/function.h"
-
-namespace arrow::compute::internal {
-
-// class GatherMetaFunction : public MetaFunction {
-//  public:
-//   GatherMetaFunction() : MetaFunction("gather", Arity::VarArgs(3), gather_doc) {}
-
-//   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
-//                             const FunctionOptions* options,
-//                             ExecContext* ctx) const override {
-//     for (const auto& arg : args) {
-//       if (arg.kind() != Datum::ARRAY && arg.kind() != Datum::CHUNKED_ARRAY) {
-//         return Status::TypeError("Gather arguments should be array-like");
-//       }
-//     }
-
-//     if (!is_integer(*args[0].type())) {
-//       return Status::NotImplemented("Indices to gather must be integer type");
-//     }
-
-//     if (args[0].kind() == Datum::RECORD_BATCH) {
-//       ARROW_ASSIGN_OR_RAISE(
-//           std::shared_ptr<RecordBatch> out_batch,
-//           FilterRecordBatch(*args[0].record_batch(), args[1], options, ctx));
-//       return Datum(out_batch);
-//     } else if (args[0].kind() == Datum::TABLE) {
-//       ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Table> out_table,
-//                             FilterTable(*args[0].table(), args[1], options, ctx));
-//       return Datum(out_table);
-//     } else {
-//       return CallFunction("array_filter", args, options, ctx);
-//     }
-//   }
-// };
-
-}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_permute.cc b/cpp/src/arrow/compute/kernels/vector_permute.cc
new file mode 100644
index 0000000000000..0c5559c6e7d91
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_permute.cc
@@ -0,0 +1,175 @@
+// #include "arrow/compute/kernels/vector_gather_internal.h"
+#include "arrow/compute/function.h"
+#include "arrow/compute/kernels/codegen_internal.h"
+#include "arrow/compute/registry.h"
+#include "arrow/util/fixed_width_internal.h"
+#include "arrow/util/logging.h"
+
+namespace arrow::compute::internal {
+
+namespace {
+
+template <typename IndexCType, typename ValueBitWidthConstant,
+          typename OutputIsZeroInitialized = std::false_type,
+          typename WithFactor = std::false_type>
+struct FixedWidthTakeImpl {
+  static constexpr int kValueWidthInBits = ValueBitWidthConstant::value;
+
+  static Status Exec(KernelContext* ctx, const ArraySpan& values,
+                     const ArraySpan& indices, ArrayData* out_arr, int64_t factor) {
+#ifndef NDEBUG
+    int64_t bit_width = util::FixedWidthInBits(*values.type);
+    DCHECK(WithFactor::value || (kValueWidthInBits == bit_width && factor == 1));
+    DCHECK(!WithFactor::value ||
+           (factor > 0 && kValueWidthInBits == 8 &&  // factors are used with bytes
+            static_cast<int64_t>(factor * kValueWidthInBits) == bit_width));
+#endif
+    const bool out_has_validity = values.MayHaveNulls() || indices.MayHaveNulls();
+
+    const uint8_t* src;
+    int64_t src_offset;
+    std::tie(src_offset, src) = util::OffsetPointerOfFixedBitWidthValues(values);
+    uint8_t* out = util::MutableFixedWidthValuesPointer(out_arr);
+    int64_t valid_count = 0;
+    arrow::internal::Gather<kValueWidthInBits, IndexCType, WithFactor::value> gather{
+        /*src_length=*/values.length,
+        src,
+        src_offset,
+        /*idx_length=*/indices.length,
+        /*idx=*/indices.GetValues<IndexCType>(1),
+        out,
+        factor};
+    if (out_has_validity) {
+      DCHECK_EQ(out_arr->offset, 0);
+      // out_is_valid must be zero-initiliazed, because Gather::Execute
+      // saves time by not having to ClearBit on every null element.
+      auto out_is_valid = out_arr->GetMutableValues<uint8_t>(0);
+      memset(out_is_valid, 0, bit_util::BytesForBits(out_arr->length));
+      valid_count = gather.template Execute<OutputIsZeroInitialized::value>(
+          /*src_validity=*/values, /*idx_validity=*/indices, out_is_valid);
+    } else {
+      valid_count = gather.Execute();
+    }
+    out_arr->null_count = out_arr->length - valid_count;
+    return Status::OK();
+  }
+};
+
+template <template <typename...> class PermuteImpl, typename... Args>
+Status PermuteIndexDispatch(KernelContext* ctx, const ArraySpan& values,
+                            const ArraySpan& indices, ArrayData* out,
+                            int64_t factor = 1) {
+  switch (indices.type->byte_width()) {
+    case 1:
+      return PermuteImpl<uint8_t, Args...>::Exec(ctx, values, indices, out, factor);
+    case 2:
+      return PermuteImpl<uint16_t, Args...>::Exec(ctx, values, indices, out, factor);
+    case 4:
+      return PermuteImpl<uint32_t, Args...>::Exec(ctx, values, indices, out, factor);
+    default:
+      DCHECK_EQ(indices.type->byte_width(), 8);
+      return PermuteImpl<uint64_t, Args...>::Exec(ctx, values, indices, out, factor);
+  }
+}
+
+Status FixedWidthPermuteExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+  const ArraySpan& values = batch[0].array;
+  const ArraySpan& indices = batch[1].array;
+
+  ArrayData* out_arr = out->array_data().get();
+  DCHECK(util::IsFixedWidthLike(values));
+  // When we know for sure that values nor indices contain nulls, we can skip
+  // allocating the validity bitmap altogether and save time and space.
+  const bool allocate_validity = values.MayHaveNulls() || indices.MayHaveNulls();
+  RETURN_NOT_OK(util::internal::PreallocateFixedWidthArrayData(
+      ctx, indices.length, /*source=*/values, allocate_validity, out_arr));
+  switch (util::FixedWidthInBits(*values.type)) {
+    case 0:
+      DCHECK(values.type->id() == Type::FIXED_SIZE_BINARY ||
+             values.type->id() == Type::FIXED_SIZE_LIST);
+      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 0>>(
+          ctx, values, indices, out_arr);
+    case 1:
+      // Zero-initialize the data buffer for the output array when the bit-width is 1
+      // (e.g. Boolean array) to avoid having to ClearBit on every null element.
+      // This might be profitable for other types as well, but we take the most
+      // conservative approach for now.
+      memset(out_arr->buffers[1]->mutable_data(), 0, out_arr->buffers[1]->size());
+      return PermuteIndexDispatch<
+          FixedWidthTakeImpl, std::integral_constant<int, 1>, /*OutputIsZeroInitialized=*/
+          std::true_type>(ctx, values, indices, out_arr);
+    case 8:
+      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 8>>(
+          ctx, values, indices, out_arr);
+    case 16:
+      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 16>>(
+          ctx, values, indices, out_arr);
+    case 32:
+      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 32>>(
+          ctx, values, indices, out_arr);
+    case 64:
+      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 64>>(
+          ctx, values, indices, out_arr);
+    case 128:
+      // For INTERVAL_MONTH_DAY_NANO, DECIMAL128
+      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 128>>(
+          ctx, values, indices, out_arr);
+    case 256:
+      // For DECIMAL256
+      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 256>>(
+          ctx, values, indices, out_arr);
+  }
+  if (ARROW_PREDICT_TRUE(values.type->id() == Type::FIXED_SIZE_BINARY ||
+                         values.type->id() == Type::FIXED_SIZE_LIST)) {
+    int64_t byte_width = util::FixedWidthInBytes(*values.type);
+    // 0-length fixed-size binary or lists were handled above on `case 0`
+    DCHECK_GT(byte_width, 0);
+    return PermuteIndexDispatch<FixedWidthTakeImpl,
+                             /*ValueBitWidth=*/std::integral_constant<int, 8>,
+                             /*OutputIsZeroInitialized=*/std::false_type,
+                             /*WithFactor=*/std::true_type>(ctx, values, indices, out_arr,
+                                                            /*factor=*/byte_width);
+  }
+  return Status::NotImplemented("Unsupported primitive type for permute: ", *values.type);
+  return Status::OK();
+}
+
+struct PermuteKernelSignature {
+  InputType value_type;
+  InputType indices_type;
+  ArrayKernelExec exec;
+};
+
+std::unique_ptr<Function> MakePermuteFunction(
+    std::string name, std::vector<PermuteKernelSignature>&& signatures, FunctionDoc doc) {
+  auto func =
+      std::make_unique<VectorFunction>(std::move(name), Arity::Binary(), std::move(doc));
+  for (auto& signature : signatures) {
+    auto kernel = VectorKernel{};
+    kernel.signature = KernelSignature::Make(
+        {std::move(signature.value_type), std::move(signature.indices_type)},
+        OutputType(FirstType));
+    kernel.exec = signature.exec;
+    kernel.can_execute_chunkwise = false;
+    DCHECK_OK(func->AddKernel(std::move(kernel)));
+  }
+  return func;
+}
+
+const FunctionDoc permute_doc(
+    "Permute values of an input based on indices from another array",
+    "Place each input value to the output array at position specified by `indices`",
+    {"input", "indices"});
+
+}  // namespace
+
+void RegisterVectorPermute(FunctionRegistry* registry) {
+  auto permute_indices = match::Integer();
+  std::vector<PermuteKernelSignature> signatures = {
+      {InputType(match::Primitive()), permute_indices, FixedWidthPermuteExec},
+  };
+  DCHECK_OK(registry->AddFunction(
+      MakePermuteFunction("permute", std::move(signatures), permute_doc)));
+}
+
+}  // namespace arrow::compute::internal

From f3c73eab0120a0239b39e7d40de92d220ec38851 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Thu, 3 Oct 2024 01:26:17 +0800
Subject: [PATCH 03/54] Add permute function options

---
 cpp/src/arrow/compute/api_vector.cc           | 16 ++++++++++++
 cpp/src/arrow/compute/api_vector.h            | 18 +++++++++++++
 .../arrow/compute/kernels/vector_permute.cc   | 26 ++++++++++++-------
 3 files changed, 51 insertions(+), 9 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index f0d5c0fcc3d72..7e6f186ff84ab 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -155,6 +155,8 @@ static auto kPairwiseOptionsType = GetFunctionOptionsType<PairwiseOptions>(
     DataMember("periods", &PairwiseOptions::periods));
 static auto kListFlattenOptionsType = GetFunctionOptionsType<ListFlattenOptions>(
     DataMember("recursive", &ListFlattenOptions::recursive));
+static auto kPermuteOptionsType =
+    GetFunctionOptionsType<PermuteOptions>(DataMember("bound", &PermuteOptions::bound));
 }  // namespace
 }  // namespace internal
 
@@ -230,6 +232,10 @@ ListFlattenOptions::ListFlattenOptions(bool recursive)
     : FunctionOptions(internal::kListFlattenOptionsType), recursive(recursive) {}
 constexpr char ListFlattenOptions::kTypeName[];
 
+PermuteOptions::PermuteOptions(int64_t bound)
+    : FunctionOptions(internal::kPermuteOptionsType), bound(bound) {}
+constexpr char PermuteOptions::kTypeName[];
+
 namespace internal {
 void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kFilterOptionsType));
@@ -244,6 +250,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kRankOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPairwiseOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kListFlattenOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kPermuteOptionsType));
 }
 }  // namespace internal
 
@@ -429,5 +436,14 @@ Result<Datum> CumulativeMean(const Datum& values, const CumulativeOptions& optio
   return CallFunction("cumulative_mean", {Datum(values)}, &options, ctx);
 }
 
+// ----------------------------------------------------------------------
+// Permute functions
+
+Result<std::shared_ptr<Array>> Permute(const Datum& values, const Datum& indices,
+                                       const PermuteOptions& options, ExecContext* ctx) {
+  ARROW_ASSIGN_OR_RAISE(Datum result, CallFunction("permute", {values, indices}, ctx));
+  return result.make_array();
+}
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index e5bcc37329661..3dd902f58a88b 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -257,6 +257,19 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
   bool recursive = false;
 };
 
+/// \brief Options for permute function
+class ARROW_EXPORT PermuteOptions : public FunctionOptions {
+ public:
+  explicit PermuteOptions(int64_t bound = -1);
+  static constexpr char const kTypeName[] = "PermuteOptions";
+  static PermuteOptions Defaults() { return PermuteOptions(); }
+
+  /// \brief The upper bound of the permutation. If -1, the output will be sized as the
+  /// maximum value in the indices array + 1. Otherwise, the output will be of size bound,
+  /// and any indices that are greater of equal to bound will be ignored.
+  int64_t bound = -1;
+};
+
 /// @}
 
 /// \brief Filter with a boolean selection filter
@@ -705,5 +718,10 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
                                             bool check_overflow = false,
                                             ExecContext* ctx = NULLPTR);
 
+Result<std::shared_ptr<Array>> Permute(
+    const Datum& values, const Datum& indices,
+    const PermuteOptions& options = PermuteOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_permute.cc b/cpp/src/arrow/compute/kernels/vector_permute.cc
index 0c5559c6e7d91..c2b727d8bc4ce 100644
--- a/cpp/src/arrow/compute/kernels/vector_permute.cc
+++ b/cpp/src/arrow/compute/kernels/vector_permute.cc
@@ -1,4 +1,5 @@
 // #include "arrow/compute/kernels/vector_gather_internal.h"
+#include "arrow/compute/api_vector.h"
 #include "arrow/compute/function.h"
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/registry.h"
@@ -125,10 +126,11 @@ Status FixedWidthPermuteExec(KernelContext* ctx, const ExecSpan& batch, ExecResu
     // 0-length fixed-size binary or lists were handled above on `case 0`
     DCHECK_GT(byte_width, 0);
     return PermuteIndexDispatch<FixedWidthTakeImpl,
-                             /*ValueBitWidth=*/std::integral_constant<int, 8>,
-                             /*OutputIsZeroInitialized=*/std::false_type,
-                             /*WithFactor=*/std::true_type>(ctx, values, indices, out_arr,
-                                                            /*factor=*/byte_width);
+                                /*ValueBitWidth=*/std::integral_constant<int, 8>,
+                                /*OutputIsZeroInitialized=*/std::false_type,
+                                /*WithFactor=*/std::true_type>(ctx, values, indices,
+                                                               out_arr,
+                                                               /*factor=*/byte_width);
   }
   return Status::NotImplemented("Unsupported primitive type for permute: ", *values.type);
   return Status::OK();
@@ -141,9 +143,10 @@ struct PermuteKernelSignature {
 };
 
 std::unique_ptr<Function> MakePermuteFunction(
-    std::string name, std::vector<PermuteKernelSignature>&& signatures, FunctionDoc doc) {
-  auto func =
-      std::make_unique<VectorFunction>(std::move(name), Arity::Binary(), std::move(doc));
+    std::string name, std::vector<PermuteKernelSignature>&& signatures, FunctionDoc doc,
+    const FunctionOptions* default_options) {
+  auto func = std::make_unique<VectorFunction>(std::move(name), Arity::Binary(),
+                                               std::move(doc), default_options);
   for (auto& signature : signatures) {
     auto kernel = VectorKernel{};
     kernel.signature = KernelSignature::Make(
@@ -161,6 +164,11 @@ const FunctionDoc permute_doc(
     "Place each input value to the output array at position specified by `indices`",
     {"input", "indices"});
 
+const PermuteOptions* GetDefaultPermuteOptions() {
+  static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
+  return &kDefaultPermuteOptions;
+}
+
 }  // namespace
 
 void RegisterVectorPermute(FunctionRegistry* registry) {
@@ -168,8 +176,8 @@ void RegisterVectorPermute(FunctionRegistry* registry) {
   std::vector<PermuteKernelSignature> signatures = {
       {InputType(match::Primitive()), permute_indices, FixedWidthPermuteExec},
   };
-  DCHECK_OK(registry->AddFunction(
-      MakePermuteFunction("permute", std::move(signatures), permute_doc)));
+  DCHECK_OK(registry->AddFunction(MakePermuteFunction(
+      "permute", std::move(signatures), permute_doc, GetDefaultPermuteOptions())));
 }
 
 }  // namespace arrow::compute::internal

From be88f0c713c64e6d5b22d6339d828a1b9918c856 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 4 Oct 2024 14:40:09 +0800
Subject: [PATCH 04/54] WIP

---
 .../arrow/compute/kernels/vector_permute.cc   | 228 ++++++------------
 1 file changed, 72 insertions(+), 156 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_permute.cc b/cpp/src/arrow/compute/kernels/vector_permute.cc
index c2b727d8bc4ce..eb3964f7b5df1 100644
--- a/cpp/src/arrow/compute/kernels/vector_permute.cc
+++ b/cpp/src/arrow/compute/kernels/vector_permute.cc
@@ -1,8 +1,8 @@
-// #include "arrow/compute/kernels/vector_gather_internal.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/function.h"
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/registry.h"
+#include "arrow/util/checked_cast.h"
 #include "arrow/util/fixed_width_internal.h"
 #include "arrow/util/logging.h"
 
@@ -10,155 +10,6 @@ namespace arrow::compute::internal {
 
 namespace {
 
-template <typename IndexCType, typename ValueBitWidthConstant,
-          typename OutputIsZeroInitialized = std::false_type,
-          typename WithFactor = std::false_type>
-struct FixedWidthTakeImpl {
-  static constexpr int kValueWidthInBits = ValueBitWidthConstant::value;
-
-  static Status Exec(KernelContext* ctx, const ArraySpan& values,
-                     const ArraySpan& indices, ArrayData* out_arr, int64_t factor) {
-#ifndef NDEBUG
-    int64_t bit_width = util::FixedWidthInBits(*values.type);
-    DCHECK(WithFactor::value || (kValueWidthInBits == bit_width && factor == 1));
-    DCHECK(!WithFactor::value ||
-           (factor > 0 && kValueWidthInBits == 8 &&  // factors are used with bytes
-            static_cast<int64_t>(factor * kValueWidthInBits) == bit_width));
-#endif
-    const bool out_has_validity = values.MayHaveNulls() || indices.MayHaveNulls();
-
-    const uint8_t* src;
-    int64_t src_offset;
-    std::tie(src_offset, src) = util::OffsetPointerOfFixedBitWidthValues(values);
-    uint8_t* out = util::MutableFixedWidthValuesPointer(out_arr);
-    int64_t valid_count = 0;
-    arrow::internal::Gather<kValueWidthInBits, IndexCType, WithFactor::value> gather{
-        /*src_length=*/values.length,
-        src,
-        src_offset,
-        /*idx_length=*/indices.length,
-        /*idx=*/indices.GetValues<IndexCType>(1),
-        out,
-        factor};
-    if (out_has_validity) {
-      DCHECK_EQ(out_arr->offset, 0);
-      // out_is_valid must be zero-initiliazed, because Gather::Execute
-      // saves time by not having to ClearBit on every null element.
-      auto out_is_valid = out_arr->GetMutableValues<uint8_t>(0);
-      memset(out_is_valid, 0, bit_util::BytesForBits(out_arr->length));
-      valid_count = gather.template Execute<OutputIsZeroInitialized::value>(
-          /*src_validity=*/values, /*idx_validity=*/indices, out_is_valid);
-    } else {
-      valid_count = gather.Execute();
-    }
-    out_arr->null_count = out_arr->length - valid_count;
-    return Status::OK();
-  }
-};
-
-template <template <typename...> class PermuteImpl, typename... Args>
-Status PermuteIndexDispatch(KernelContext* ctx, const ArraySpan& values,
-                            const ArraySpan& indices, ArrayData* out,
-                            int64_t factor = 1) {
-  switch (indices.type->byte_width()) {
-    case 1:
-      return PermuteImpl<uint8_t, Args...>::Exec(ctx, values, indices, out, factor);
-    case 2:
-      return PermuteImpl<uint16_t, Args...>::Exec(ctx, values, indices, out, factor);
-    case 4:
-      return PermuteImpl<uint32_t, Args...>::Exec(ctx, values, indices, out, factor);
-    default:
-      DCHECK_EQ(indices.type->byte_width(), 8);
-      return PermuteImpl<uint64_t, Args...>::Exec(ctx, values, indices, out, factor);
-  }
-}
-
-Status FixedWidthPermuteExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
-  const ArraySpan& values = batch[0].array;
-  const ArraySpan& indices = batch[1].array;
-
-  ArrayData* out_arr = out->array_data().get();
-  DCHECK(util::IsFixedWidthLike(values));
-  // When we know for sure that values nor indices contain nulls, we can skip
-  // allocating the validity bitmap altogether and save time and space.
-  const bool allocate_validity = values.MayHaveNulls() || indices.MayHaveNulls();
-  RETURN_NOT_OK(util::internal::PreallocateFixedWidthArrayData(
-      ctx, indices.length, /*source=*/values, allocate_validity, out_arr));
-  switch (util::FixedWidthInBits(*values.type)) {
-    case 0:
-      DCHECK(values.type->id() == Type::FIXED_SIZE_BINARY ||
-             values.type->id() == Type::FIXED_SIZE_LIST);
-      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 0>>(
-          ctx, values, indices, out_arr);
-    case 1:
-      // Zero-initialize the data buffer for the output array when the bit-width is 1
-      // (e.g. Boolean array) to avoid having to ClearBit on every null element.
-      // This might be profitable for other types as well, but we take the most
-      // conservative approach for now.
-      memset(out_arr->buffers[1]->mutable_data(), 0, out_arr->buffers[1]->size());
-      return PermuteIndexDispatch<
-          FixedWidthTakeImpl, std::integral_constant<int, 1>, /*OutputIsZeroInitialized=*/
-          std::true_type>(ctx, values, indices, out_arr);
-    case 8:
-      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 8>>(
-          ctx, values, indices, out_arr);
-    case 16:
-      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 16>>(
-          ctx, values, indices, out_arr);
-    case 32:
-      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 32>>(
-          ctx, values, indices, out_arr);
-    case 64:
-      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 64>>(
-          ctx, values, indices, out_arr);
-    case 128:
-      // For INTERVAL_MONTH_DAY_NANO, DECIMAL128
-      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 128>>(
-          ctx, values, indices, out_arr);
-    case 256:
-      // For DECIMAL256
-      return PermuteIndexDispatch<FixedWidthTakeImpl, std::integral_constant<int, 256>>(
-          ctx, values, indices, out_arr);
-  }
-  if (ARROW_PREDICT_TRUE(values.type->id() == Type::FIXED_SIZE_BINARY ||
-                         values.type->id() == Type::FIXED_SIZE_LIST)) {
-    int64_t byte_width = util::FixedWidthInBytes(*values.type);
-    // 0-length fixed-size binary or lists were handled above on `case 0`
-    DCHECK_GT(byte_width, 0);
-    return PermuteIndexDispatch<FixedWidthTakeImpl,
-                                /*ValueBitWidth=*/std::integral_constant<int, 8>,
-                                /*OutputIsZeroInitialized=*/std::false_type,
-                                /*WithFactor=*/std::true_type>(ctx, values, indices,
-                                                               out_arr,
-                                                               /*factor=*/byte_width);
-  }
-  return Status::NotImplemented("Unsupported primitive type for permute: ", *values.type);
-  return Status::OK();
-}
-
-struct PermuteKernelSignature {
-  InputType value_type;
-  InputType indices_type;
-  ArrayKernelExec exec;
-};
-
-std::unique_ptr<Function> MakePermuteFunction(
-    std::string name, std::vector<PermuteKernelSignature>&& signatures, FunctionDoc doc,
-    const FunctionOptions* default_options) {
-  auto func = std::make_unique<VectorFunction>(std::move(name), Arity::Binary(),
-                                               std::move(doc), default_options);
-  for (auto& signature : signatures) {
-    auto kernel = VectorKernel{};
-    kernel.signature = KernelSignature::Make(
-        {std::move(signature.value_type), std::move(signature.indices_type)},
-        OutputType(FirstType));
-    kernel.exec = signature.exec;
-    kernel.can_execute_chunkwise = false;
-    DCHECK_OK(func->AddKernel(std::move(kernel)));
-  }
-  return func;
-}
-
 const FunctionDoc permute_doc(
     "Permute values of an input based on indices from another array",
     "Place each input value to the output array at position specified by `indices`",
@@ -169,15 +20,80 @@ const PermuteOptions* GetDefaultPermuteOptions() {
   return &kDefaultPermuteOptions;
 }
 
+class PermuteMetaFunction : public MetaFunction {
+ public:
+  PermuteMetaFunction()
+      : MetaFunction("permute", Arity::Binary(), permute_doc,
+                     GetDefaultPermuteOptions()) {}
+
+  Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
+                            const FunctionOptions* options,
+                            ExecContext* ctx) const override {
+    const auto& permute_options = checked_cast<const PermuteOptions&>(*options);
+    if (args[0].length() != args[1].length()) {
+      return Status::Invalid("Input and indices must have the same length");
+    }
+    if (args[0].length() == 0) {
+      return args[0];
+    }
+    int64_t output_length = permute_options.bound;
+    if (output_length < 0) {
+      ARROW_ASSIGN_OR_RAISE(auto max_scalar, CallFunction("max", {args[1]}, ctx));
+      DCHECK(max_scalar.is_scalar());
+      ARROW_ASSIGN_OR_RAISE(auto max_i64_scalar, max_scalar.scalar()->CastTo(int64()));
+      output_length = checked_cast<const Int64Scalar*>(max_i64_scalar.get())->value + 1;
+    }
+    if (output_length <= 0) {
+      ARROW_ASSIGN_OR_RAISE(auto output, MakeEmptyArray(args[0].type()));
+      return output->data();
+    }
+    ARROW_ASSIGN_OR_RAISE(auto reverse_indices,
+                          MakeArrayOfNull(int64(), output_length, ctx->memory_pool()));
+    switch (args[1].kind()) {
+      case Datum::ARRAY:
+        RETURN_NOT_OK(ReverseIndices(*args[1].array(), reverse_indices->data()));
+        break;
+      case Datum::CHUNKED_ARRAY:
+        for (const auto& chunk : args[1].chunked_array()->chunks()) {
+          RETURN_NOT_OK(ReverseIndices(*chunk->data(), reverse_indices->data()));
+        }
+        break;
+      default:
+        return Status::NotImplemented("Unsupported shape for permute operation: indices=",
+                                      args[1].ToString());
+        break;
+    }
+    return CallFunction("take", {args[0], reverse_indices}, ctx);
+  }
+
+ private:
+  Status ReverseIndices(const ArraySpan& indices,
+                        const std::shared_ptr<ArrayData>& reverse_indices) const {
+    auto reverse_indices_validity = reverse_indices->GetMutableValues<uint8_t>(0);
+    auto reverse_indices_data = reverse_indices->GetMutableValues<int64_t>(1);
+    auto length = reverse_indices->length;
+    int64_t reverse_index = 0;
+    return VisitArraySpanInline<Int64Type>(
+        indices,
+        [&](int64_t index) {
+          if (ARROW_PREDICT_TRUE(index > 0 && index < length)) {
+            bit_util::SetBitTo(reverse_indices_validity, index, true);
+            reverse_indices_data[index] = reverse_index;
+          }
+          ++reverse_index;
+          return Status::OK();
+        },
+        [&]() {
+          ++reverse_index;
+          return Status::OK();
+        });
+  };
+};
+
 }  // namespace
 
 void RegisterVectorPermute(FunctionRegistry* registry) {
-  auto permute_indices = match::Integer();
-  std::vector<PermuteKernelSignature> signatures = {
-      {InputType(match::Primitive()), permute_indices, FixedWidthPermuteExec},
-  };
-  DCHECK_OK(registry->AddFunction(MakePermuteFunction(
-      "permute", std::move(signatures), permute_doc, GetDefaultPermuteOptions())));
+  DCHECK_OK(registry->AddFunction(std::make_shared<PermuteMetaFunction>()));
 }
 
 }  // namespace arrow::compute::internal

From b445c362bfe39f5d32c342cedcbf3ddb6f1e77d3 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 7 Oct 2024 00:58:02 +0800
Subject: [PATCH 05/54] Implementation done and basic tests

---
 cpp/src/arrow/CMakeLists.txt                  |   2 +-
 cpp/src/arrow/compute/api_vector.cc           |  20 ++
 cpp/src/arrow/compute/api_vector.h            |  19 +
 cpp/src/arrow/compute/kernels/CMakeLists.txt  |   6 +
 .../arrow/compute/kernels/codegen_internal.h  |   5 +-
 .../arrow/compute/kernels/vector_permute.cc   |  99 ------
 .../arrow/compute/kernels/vector_placement.cc | 327 ++++++++++++++++++
 .../compute/kernels/vector_placement_test.cc  | 148 ++++++++
 cpp/src/arrow/compute/registry.cc             |   1 +
 cpp/src/arrow/compute/registry_internal.h     |   1 +
 10 files changed, 526 insertions(+), 102 deletions(-)
 delete mode 100644 cpp/src/arrow/compute/kernels/vector_permute.cc
 create mode 100644 cpp/src/arrow/compute/kernels/vector_placement.cc
 create mode 100644 cpp/src/arrow/compute/kernels/vector_placement_test.cc

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 428eef04007c2..69a0d52512931 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -787,7 +787,7 @@ if(ARROW_COMPUTE)
        compute/kernels/vector_array_sort.cc
        compute/kernels/vector_cumulative_ops.cc
        compute/kernels/vector_pairwise.cc
-       compute/kernels/vector_permute.cc
+       compute/kernels/vector_placement.cc
        compute/kernels/vector_nested.cc
        compute/kernels/vector_rank.cc
        compute/kernels/vector_replace.cc
diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 7e6f186ff84ab..c7e344ef28097 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -155,6 +155,10 @@ static auto kPairwiseOptionsType = GetFunctionOptionsType<PairwiseOptions>(
     DataMember("periods", &PairwiseOptions::periods));
 static auto kListFlattenOptionsType = GetFunctionOptionsType<ListFlattenOptions>(
     DataMember("recursive", &ListFlattenOptions::recursive));
+static auto kReverseIndexOptionsType = GetFunctionOptionsType<ReverseIndexOptions>(
+    DataMember("output_length", &ReverseIndexOptions::output_length),
+    DataMember("output_type", &ReverseIndexOptions::output_type),
+    DataMember("output_non_taken", &ReverseIndexOptions::output_non_taken));
 static auto kPermuteOptionsType =
     GetFunctionOptionsType<PermuteOptions>(DataMember("bound", &PermuteOptions::bound));
 }  // namespace
@@ -232,6 +236,15 @@ ListFlattenOptions::ListFlattenOptions(bool recursive)
     : FunctionOptions(internal::kListFlattenOptionsType), recursive(recursive) {}
 constexpr char ListFlattenOptions::kTypeName[];
 
+ReverseIndexOptions::ReverseIndexOptions(int64_t output_length,
+                                         std::shared_ptr<DataType> output_type,
+                                         std::shared_ptr<Scalar> output_non_taken)
+    : FunctionOptions(internal::kPermuteOptionsType),
+      output_length(output_length),
+      output_type(std::move(output_type)),
+      output_non_taken(std::move(output_non_taken)) {}
+constexpr char ReverseIndexOptions::kTypeName[];
+
 PermuteOptions::PermuteOptions(int64_t bound)
     : FunctionOptions(internal::kPermuteOptionsType), bound(bound) {}
 constexpr char PermuteOptions::kTypeName[];
@@ -439,6 +452,13 @@ Result<Datum> CumulativeMean(const Datum& values, const CumulativeOptions& optio
 // ----------------------------------------------------------------------
 // Permute functions
 
+Result<std::shared_ptr<Array>> ReverseIndex(const Datum& indices,
+                                            const ReverseIndexOptions& options,
+                                            ExecContext* ctx) {
+  ARROW_ASSIGN_OR_RAISE(Datum result, CallFunction("reverse_index", {indices}, ctx));
+  return result.make_array();
+}
+
 Result<std::shared_ptr<Array>> Permute(const Datum& values, const Datum& indices,
                                        const PermuteOptions& options, ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(Datum result, CallFunction("permute", {values, indices}, ctx));
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 3dd902f58a88b..60c53fec1be10 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -257,6 +257,25 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
   bool recursive = false;
 };
 
+/// \brief Options for reverse_index function
+class ARROW_EXPORT ReverseIndexOptions : public FunctionOptions {
+ public:
+  explicit ReverseIndexOptions(int64_t output_length = 0,
+                               std::shared_ptr<DataType> output_type = int32(),
+                               std::shared_ptr<Scalar> output_non_taken = NULLPTR);
+  static constexpr char const kTypeName[] = "ReverseIndexOptions";
+  static ReverseIndexOptions Defaults() { return ReverseIndexOptions(); }
+
+  /// \brief The upper bound of the permutation. If -1, the output will be sized as the
+  /// maximum value in the indices array + 1. Otherwise, the output will be of size bound,
+  /// and any indices that are greater of equal to bound will be ignored.
+  int64_t output_length = 0;
+  /// \brief The type of the output reverse index. If null, the output type will be the
+  /// smallest possible integer type that can hold the maximum value in the indices array.
+  std::shared_ptr<DataType> output_type = int32();
+  std::shared_ptr<Scalar> output_non_taken = NULLPTR;
+};
+
 /// \brief Options for permute function
 class ARROW_EXPORT PermuteOptions : public FunctionOptions {
  public:
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 7c7b9c8b68d45..9499a16b9ef7a 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -115,6 +115,12 @@ add_arrow_compute_test(vector_selection_test
                        EXTRA_LINK_LIBS
                        arrow_compute_kernels_testing)
 
+add_arrow_compute_test(vector_placement_test
+                       SOURCES
+                       vector_placement_test.cc
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
+
 add_arrow_benchmark(vector_hash_benchmark PREFIX "arrow-compute")
 add_arrow_benchmark(vector_sort_benchmark PREFIX "arrow-compute")
 add_arrow_benchmark(vector_partition_benchmark PREFIX "arrow-compute")
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 7f9be92f3a14b..0299f2e96b342 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -985,8 +985,9 @@ ArrayKernelExec GenerateFloatingPoint(detail::GetTypeId get_id) {
 // Generate a kernel given a templated functor for integer types
 //
 // See "Numeric" above for description of the generator functor
-template <template <typename...> class Generator, typename Type0, typename... Args>
-ArrayKernelExec GenerateInteger(detail::GetTypeId get_id) {
+template <template <typename...> class Generator, typename Type0,
+          typename KernelType = ArrayKernelExec, typename... Args>
+KernelType GenerateInteger(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
       return Generator<Type0, Int8Type, Args...>::Exec;
diff --git a/cpp/src/arrow/compute/kernels/vector_permute.cc b/cpp/src/arrow/compute/kernels/vector_permute.cc
deleted file mode 100644
index eb3964f7b5df1..0000000000000
--- a/cpp/src/arrow/compute/kernels/vector_permute.cc
+++ /dev/null
@@ -1,99 +0,0 @@
-#include "arrow/compute/api_vector.h"
-#include "arrow/compute/function.h"
-#include "arrow/compute/kernels/codegen_internal.h"
-#include "arrow/compute/registry.h"
-#include "arrow/util/checked_cast.h"
-#include "arrow/util/fixed_width_internal.h"
-#include "arrow/util/logging.h"
-
-namespace arrow::compute::internal {
-
-namespace {
-
-const FunctionDoc permute_doc(
-    "Permute values of an input based on indices from another array",
-    "Place each input value to the output array at position specified by `indices`",
-    {"input", "indices"});
-
-const PermuteOptions* GetDefaultPermuteOptions() {
-  static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
-  return &kDefaultPermuteOptions;
-}
-
-class PermuteMetaFunction : public MetaFunction {
- public:
-  PermuteMetaFunction()
-      : MetaFunction("permute", Arity::Binary(), permute_doc,
-                     GetDefaultPermuteOptions()) {}
-
-  Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
-                            const FunctionOptions* options,
-                            ExecContext* ctx) const override {
-    const auto& permute_options = checked_cast<const PermuteOptions&>(*options);
-    if (args[0].length() != args[1].length()) {
-      return Status::Invalid("Input and indices must have the same length");
-    }
-    if (args[0].length() == 0) {
-      return args[0];
-    }
-    int64_t output_length = permute_options.bound;
-    if (output_length < 0) {
-      ARROW_ASSIGN_OR_RAISE(auto max_scalar, CallFunction("max", {args[1]}, ctx));
-      DCHECK(max_scalar.is_scalar());
-      ARROW_ASSIGN_OR_RAISE(auto max_i64_scalar, max_scalar.scalar()->CastTo(int64()));
-      output_length = checked_cast<const Int64Scalar*>(max_i64_scalar.get())->value + 1;
-    }
-    if (output_length <= 0) {
-      ARROW_ASSIGN_OR_RAISE(auto output, MakeEmptyArray(args[0].type()));
-      return output->data();
-    }
-    ARROW_ASSIGN_OR_RAISE(auto reverse_indices,
-                          MakeArrayOfNull(int64(), output_length, ctx->memory_pool()));
-    switch (args[1].kind()) {
-      case Datum::ARRAY:
-        RETURN_NOT_OK(ReverseIndices(*args[1].array(), reverse_indices->data()));
-        break;
-      case Datum::CHUNKED_ARRAY:
-        for (const auto& chunk : args[1].chunked_array()->chunks()) {
-          RETURN_NOT_OK(ReverseIndices(*chunk->data(), reverse_indices->data()));
-        }
-        break;
-      default:
-        return Status::NotImplemented("Unsupported shape for permute operation: indices=",
-                                      args[1].ToString());
-        break;
-    }
-    return CallFunction("take", {args[0], reverse_indices}, ctx);
-  }
-
- private:
-  Status ReverseIndices(const ArraySpan& indices,
-                        const std::shared_ptr<ArrayData>& reverse_indices) const {
-    auto reverse_indices_validity = reverse_indices->GetMutableValues<uint8_t>(0);
-    auto reverse_indices_data = reverse_indices->GetMutableValues<int64_t>(1);
-    auto length = reverse_indices->length;
-    int64_t reverse_index = 0;
-    return VisitArraySpanInline<Int64Type>(
-        indices,
-        [&](int64_t index) {
-          if (ARROW_PREDICT_TRUE(index > 0 && index < length)) {
-            bit_util::SetBitTo(reverse_indices_validity, index, true);
-            reverse_indices_data[index] = reverse_index;
-          }
-          ++reverse_index;
-          return Status::OK();
-        },
-        [&]() {
-          ++reverse_index;
-          return Status::OK();
-        });
-  };
-};
-
-}  // namespace
-
-void RegisterVectorPermute(FunctionRegistry* registry) {
-  DCHECK_OK(registry->AddFunction(std::make_shared<PermuteMetaFunction>()));
-}
-
-}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
new file mode 100644
index 0000000000000..f5e878bc93c14
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -0,0 +1,327 @@
+#include "arrow/compute/api_vector.h"
+#include "arrow/compute/function.h"
+#include "arrow/compute/kernels/codegen_internal.h"
+#include "arrow/compute/registry.h"
+#include "arrow/util/checked_cast.h"
+#include "arrow/util/fixed_width_internal.h"
+#include "arrow/util/logging.h"
+
+namespace arrow::compute::internal {
+
+namespace {
+
+struct ReverseIndexState : public KernelState {
+  explicit ReverseIndexState(int64_t length, std::shared_ptr<DataType> type,
+                             std::shared_ptr<Buffer> validity,
+                             std::shared_ptr<Buffer> data)
+      : length(length),
+        type(std::move(type)),
+        validity(std::move(validity)),
+        data(std::move(data)) {}
+
+  const int64_t length = 0;
+  const std::shared_ptr<DataType> type = nullptr;
+  const std::shared_ptr<Buffer> validity = nullptr;
+  const std::shared_ptr<Buffer> data = nullptr;
+};
+
+Result<std::unique_ptr<KernelState>> ReverseIndexInit(KernelContext* ctx,
+                                                      const KernelInitArgs& args) {
+  auto* options = checked_cast<const ReverseIndexOptions*>(args.options);
+  DCHECK_NE(options, nullptr);
+
+  if (options->output_length < 0) {
+    return Status::Invalid("Output length of reverse_index must be non-negative, got " +
+                           std::to_string(options->output_length));
+  }
+  if (!options->output_type || !is_integer(options->output_type->id())) {
+    return Status::Invalid(
+        "Output type of reverse_index must be integer, got " +
+        (options->output_type ? options->output_type->ToString() : "null"));
+  }
+  if (options->output_non_taken &&
+      !options->output_non_taken->type->Equals(options->output_type)) {
+    return Status::Invalid(
+        "Output non-taken of reverse_index must be of the same type with the output "
+        "type, got " +
+        options->output_non_taken->type->ToString());
+  }
+
+  std::shared_ptr<Buffer> validity = nullptr;
+  ARROW_ASSIGN_OR_RAISE(auto data, ctx->Allocate(options->output_length *
+                                                 options->output_type->byte_width()));
+  if (!options->output_non_taken || !options->output_non_taken->is_valid) {
+    ARROW_ASSIGN_OR_RAISE(validity, ctx->AllocateBitmap(options->output_length));
+    std::memset(validity->mutable_data(), 0, options->output_length);
+  } else {
+    auto int_scalar = checked_cast<const arrow::internal::PrimitiveScalarBase*>(
+        options->output_non_taken.get());
+    for (int64_t i = 0; i < options->output_length; ++i) {
+      std::memcpy(data->mutable_data() + int_scalar->type->byte_width() * i,
+                  int_scalar->data(), int_scalar->type->byte_width());
+    }
+  }
+  auto state = std::make_unique<ReverseIndexState>(
+      options->output_length, options->output_type, std::move(validity), std::move(data));
+  return state;
+}
+
+/// \brief The OutputType::Resolver of the "reverse_index" function.
+Result<TypeHolder> ReverseIndexResolveOutputType(KernelContext* ctx,
+                                                 const std::vector<TypeHolder>&) {
+  auto state = checked_cast<const ReverseIndexState*>(ctx->state());
+  DCHECK_NE(state, nullptr);
+  return TypeHolder(state->type);
+}
+
+template <typename ExecType>
+struct ReverseIndexImpl {
+  using ThisType = ReverseIndexImpl<ExecType>;
+  using IndexType = typename ExecType::IndexType;
+  using IndexCType = typename IndexType::c_type;
+  using ShapeType = typename ExecType::ShapeType;
+
+  static Result<std::shared_ptr<ArrayData>> Exec(KernelContext* ctx,
+                                                 const ShapeType& indices) {
+    auto state = checked_cast<ReverseIndexState*>(ctx->state());
+    DCHECK_NE(state, nullptr);
+
+    if (state->length > 0) {
+      ThisType impl(ctx, indices, state);
+      RETURN_NOT_OK(VisitTypeInline(*state->type, &impl));
+    }
+
+    return ArrayData::Make(state->type, state->length, {state->validity, state->data});
+  }
+
+ private:
+  KernelContext* ctx;
+  const ShapeType& indices;
+  ReverseIndexState* state;
+
+ private:
+  ReverseIndexImpl(KernelContext* ctx, const ShapeType& indices, ReverseIndexState* state)
+      : ctx(ctx), indices(indices), state(state) {}
+
+  Status Visit(const DataType& type) { return Status::Invalid(type.ToString()); }
+
+  template <typename Type>
+  enable_if_t<is_integer_type<Type>::value, Status> Visit(const Type&) {
+    if (state->validity) {
+      return VisitInternal<Type, true>();
+    } else {
+      return VisitInternal<Type, false>();
+    }
+  }
+
+  template <typename Type, bool validity_preallocated>
+  Status VisitInternal() {
+    using OutputCType = typename Type::c_type;
+
+    uint8_t* output_validity = nullptr;
+    if constexpr (validity_preallocated) {
+      output_validity = state->validity->mutable_data_as<uint8_t>();
+    }
+    OutputCType* output_data = state->data->mutable_data_as<OutputCType>();
+
+    int64_t reverse_index = 0;
+    return ExecType::template VisitIndex(
+        indices,
+        [&](IndexCType index) {
+          if (ARROW_PREDICT_TRUE(index >= 0 &&
+                                 static_cast<int64_t>(index) < state->length)) {
+            if constexpr (validity_preallocated) {
+              bit_util::SetBitTo(output_validity, index, true);
+            }
+            if (ARROW_PREDICT_FALSE(
+                    static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) <
+                    reverse_index)) {
+              return Status::Invalid("Overflow in reverse_index, got " +
+                                     std::to_string(reverse_index) + " for " +
+                                     state->type->ToString());
+            }
+            output_data[index] = static_cast<OutputCType>(reverse_index);
+          }
+          ++reverse_index;
+          return Status::OK();
+        },
+        [&]() {
+          ++reverse_index;
+          return Status::OK();
+        });
+  }
+
+  template <typename VISITOR, typename... ARGS>
+  friend Status arrow::VisitTypeInline(const DataType&, VISITOR*, ARGS&&... args);
+};
+
+template <typename Ignored, typename Type>
+struct ReverseIndex {
+  using ThisType = ReverseIndex<Ignored, Type>;
+  using IndexType = Type;
+  using ShapeType = ArraySpan;
+
+  template <typename ValidFunc, typename NullFunc>
+  static Status VisitIndex(const ArraySpan& span, ValidFunc&& valid_func,
+                           NullFunc&& null_func) {
+    return VisitArraySpanInline<IndexType>(span, std::forward<ValidFunc>(valid_func),
+                                           std::forward<NullFunc>(null_func));
+  }
+
+  static Status Exec(KernelContext* ctx, const ExecSpan& span, ExecResult* result) {
+    DCHECK(span[0].is_array());
+    const auto& indices = span[0].array;
+    ARROW_ASSIGN_OR_RAISE(auto output, ReverseIndexImpl<ThisType>::Exec(ctx, indices));
+    result->value = std::move(output);
+    return Status::OK();
+  }
+};
+
+template <typename Ignored, typename Type>
+struct ReverseIndexChunked {
+  using ThisType = ReverseIndexChunked<Ignored, Type>;
+  using IndexType = Type;
+  using ShapeType = std::shared_ptr<ChunkedArray>;
+
+  template <typename ValidFunc, typename NullFunc>
+  static Status VisitIndex(const std::shared_ptr<ChunkedArray>& chunked_array,
+                           ValidFunc&& valid_func, NullFunc&& null_func) {
+    for (const auto& chunk : chunked_array->chunks()) {
+      ArraySpan span(*chunk->data());
+      RETURN_NOT_OK(VisitArraySpanInline<IndexType>(
+          span, std::forward<ValidFunc>(valid_func), std::forward<NullFunc>(null_func)));
+    }
+    return Status::OK();
+  }
+
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* result) {
+    DCHECK(batch[0].is_chunked_array());
+    const auto& indices = batch[0].chunked_array();
+    ARROW_ASSIGN_OR_RAISE(auto output, ReverseIndexImpl<ThisType>::Exec(ctx, indices));
+    *result = std::move(output);
+    return Status::OK();
+  }
+};
+
+const FunctionDoc reverse_index_doc(
+    "Compute the reverse indices from an input indices",
+    "Place each input value to the output array at position specified by `indices`",
+    {"indices"});
+
+const PermuteOptions* GetDefaultReverseIndexOptions() {
+  static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
+  return &kDefaultPermuteOptions;
+}
+
+const FunctionDoc permute_doc(
+    "Permute values of an input based on indices from another array",
+    "Place each input value to the output array at position specified by `indices`",
+    {"input", "indices"});
+
+const PermuteOptions* GetDefaultPermuteOptions() {
+  static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
+  return &kDefaultPermuteOptions;
+}
+
+class PermuteMetaFunction : public MetaFunction {
+ public:
+  PermuteMetaFunction()
+      : MetaFunction("permute", Arity::Binary(), permute_doc,
+                     GetDefaultPermuteOptions()) {}
+
+  Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
+                            const FunctionOptions* options,
+                            ExecContext* ctx) const override {
+    const auto& permute_options = checked_cast<const PermuteOptions&>(*options);
+    if (args[0].length() != args[1].length()) {
+      return Status::Invalid("Input and indices must have the same length");
+    }
+    if (args[0].length() == 0) {
+      return args[0];
+    }
+    int64_t output_length = permute_options.bound;
+    if (output_length < 0) {
+      ARROW_ASSIGN_OR_RAISE(auto max_scalar, CallFunction("max", {args[1]}, ctx));
+      DCHECK(max_scalar.is_scalar());
+      ARROW_ASSIGN_OR_RAISE(auto max_i64_scalar, max_scalar.scalar()->CastTo(int64()));
+      output_length = checked_cast<const Int64Scalar*>(max_i64_scalar.get())->value + 1;
+    }
+    if (output_length <= 0) {
+      ARROW_ASSIGN_OR_RAISE(auto output, MakeEmptyArray(args[0].type()));
+      return output->data();
+    }
+    ARROW_ASSIGN_OR_RAISE(auto reverse_indices,
+                          MakeArrayOfNull(int64(), output_length, ctx->memory_pool()));
+    switch (args[1].kind()) {
+      case Datum::ARRAY:
+        RETURN_NOT_OK(ReverseIndices(*args[1].array(), reverse_indices->data()));
+        break;
+      case Datum::CHUNKED_ARRAY:
+        for (const auto& chunk : args[1].chunked_array()->chunks()) {
+          RETURN_NOT_OK(ReverseIndices(*chunk->data(), reverse_indices->data()));
+        }
+        break;
+      default:
+        return Status::NotImplemented("Unsupported shape for permute operation: indices=",
+                                      args[1].ToString());
+        break;
+    }
+    return CallFunction("take", {args[0], reverse_indices}, ctx);
+  }
+
+ private:
+  Status ReverseIndices(const ArraySpan& indices,
+                        const std::shared_ptr<ArrayData>& reverse_indices) const {
+    auto reverse_indices_validity = reverse_indices->GetMutableValues<uint8_t>(0);
+    auto reverse_indices_data = reverse_indices->GetMutableValues<int64_t>(1);
+    auto length = reverse_indices->length;
+    int64_t reverse_index = 0;
+    return VisitArraySpanInline<Int64Type>(
+        indices,
+        [&](int64_t index) {
+          if (ARROW_PREDICT_TRUE(index > 0 && index < length)) {
+            bit_util::SetBitTo(reverse_indices_validity, index, true);
+            reverse_indices_data[index] = reverse_index;
+          }
+          ++reverse_index;
+          return Status::OK();
+        },
+        [&]() {
+          ++reverse_index;
+          return Status::OK();
+        });
+  };
+};
+
+}  // namespace
+
+void RegisterVectorReverseIndex(FunctionRegistry* registry) {
+  auto function =
+      std::make_shared<VectorFunction>("reverse_index", Arity::Unary(), reverse_index_doc,
+                                       GetDefaultReverseIndexOptions());
+
+  auto add_kernel = [&function](Type::type type_id) {
+    VectorKernel kernel;
+    kernel.signature = KernelSignature::Make({InputType(match::SameTypeId(type_id))},
+                                             OutputType(ReverseIndexResolveOutputType));
+    kernel.init = ReverseIndexInit;
+    kernel.exec = GenerateInteger<ReverseIndex, void, ArrayKernelExec>(type_id);
+    kernel.exec_chunked =
+        GenerateInteger<ReverseIndexChunked, void, VectorKernel::ChunkedExec>(type_id);
+    kernel.can_execute_chunkwise = false;
+    kernel.output_chunked = false;
+    DCHECK_OK(function->AddKernel(std::move(kernel)));
+  };
+  for (const auto& ty : IntTypes()) {
+    add_kernel(ty->id());
+  }
+
+  DCHECK_OK(registry->AddFunction(std::move(function)));
+}
+
+void RegisterVectorPlacement(FunctionRegistry* registry) {
+  RegisterVectorReverseIndex(registry);
+  DCHECK_OK(registry->AddFunction(std::make_shared<PermuteMetaFunction>()));
+}
+
+}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
new file mode 100644
index 0000000000000..bfe38c731dc7c
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -0,0 +1,148 @@
+
+#include <gtest/gtest.h>
+
+#include "arrow/chunked_array.h"
+#include "arrow/compute/api.h"
+#include "arrow/compute/api_vector.h"
+#include "arrow/compute/kernels/test_util.h"
+#include "arrow/result.h"
+#include "arrow/testing/generator.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/util/checked_cast.h"
+
+namespace arrow::compute {
+
+TEST(ReverseIndex, Invalid) {
+  {
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ReverseIndexOptions options{0, nullptr};
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid, "Invalid: Output type of reverse_index must be integer, got null",
+        CallFunction("reverse_index", {indices}, &options));
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ReverseIndexOptions options{0, utf8()};
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid, "Invalid: Output type of reverse_index must be integer, got string",
+        CallFunction("reverse_index", {indices}, &options));
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ReverseIndexOptions options{-1, int8()};
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid, "Invalid: Output length of reverse_index must be non-negative, got -1",
+        CallFunction("reverse_index", {indices}, &options));
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ReverseIndexOptions options{0, int8(), MakeScalar(int16_t(-1))};
+    ASSERT_RAISES_WITH_MESSAGE(Invalid,
+                               "Invalid: Output non-taken of reverse_index must be of "
+                               "the same type with the output type, got int16",
+                               CallFunction("reverse_index", {indices}, &options));
+  }
+}
+
+TEST(ReverseIndex, Basic) {
+  {
+    auto indices = ArrayFromJSON(int32(), "[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]");
+    auto expected = ArrayFromJSON(int8(), "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]");
+    ReverseIndexOptions options{10, int8()};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[1, 2]");
+    auto expected = ArrayFromJSON(int8(), "[null, 0, 1, null, null, null, null]");
+    ReverseIndexOptions options{7, int8()};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[1, 2]");
+    auto expected = ArrayFromJSON(int8(), "[null, 0, 1, null, null, null, null]");
+    ReverseIndexOptions options{7, int8(), MakeNullScalar(int8())};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[1, 2]");
+    auto expected = ArrayFromJSON(int8(), "[-1, 0, 1, -1, -1, -1, -1]");
+    ReverseIndexOptions options{7, int8(), MakeScalar(int8_t(-1))};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+    ASSERT_FALSE(result.array()->HasValidityBitmap());
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[1, 2]");
+    auto expected = ArrayFromJSON(int8(), "[]");
+    ReverseIndexOptions options{0, int8()};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[1, 0]");
+    auto expected = ArrayFromJSON(int8(), "[1]");
+    ReverseIndexOptions options{1, int8()};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[1, 2]");
+    auto expected = ArrayFromJSON(int8(), "[null]");
+    ReverseIndexOptions options{1, int8()};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[]");
+    auto expected = ArrayFromJSON(int8(), "[null, null, null, null, null, null, null]");
+    ReverseIndexOptions options{7, int8()};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+}
+
+TEST(ReverseIndex, Overflow) {
+  {
+    auto indices = ConstantArrayGenerator::Zeroes(
+        std::numeric_limits<int8_t>::max() + int64_t(1), int8());
+    auto expected = ArrayFromJSON(
+        int8(), "[" + std::to_string(std::numeric_limits<int8_t>::max()) + "]");
+    ReverseIndexOptions options{1, int8()};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+  {
+    auto indices = ConstantArrayGenerator::Zeroes(
+        std::numeric_limits<int8_t>::max() + int64_t(2), int8());
+    ReverseIndexOptions options{1, int8()};
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid,
+        "Invalid: Overflow in reverse_index, got " +
+            std::to_string(std::numeric_limits<int8_t>::max() + int64_t(1)) + " for int8",
+        CallFunction("reverse_index", {indices}, &options));
+  }
+  {
+    ASSERT_OK_AND_ASSIGN(
+        auto indices,
+        MakeArrayOfNull(int8(), std::numeric_limits<int8_t>::max() + int64_t(2)));
+    auto expected = ArrayFromJSON(int8(), "[null]");
+    ReverseIndexOptions options{1, int8()};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("reverse_index", {indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+}
+
+};  // namespace arrow::compute
diff --git a/cpp/src/arrow/compute/registry.cc b/cpp/src/arrow/compute/registry.cc
index 0f535eb373269..557d7d7b7e408 100644
--- a/cpp/src/arrow/compute/registry.cc
+++ b/cpp/src/arrow/compute/registry.cc
@@ -321,6 +321,7 @@ static std::unique_ptr<FunctionRegistry> CreateBuiltInRegistry() {
   RegisterVectorRunEndEncode(registry.get());
   RegisterVectorRunEndDecode(registry.get());
   RegisterVectorPairwise(registry.get());
+  RegisterVectorPlacement(registry.get());
 
   // Aggregate functions
   RegisterHashAggregateBasic(registry.get());
diff --git a/cpp/src/arrow/compute/registry_internal.h b/cpp/src/arrow/compute/registry_internal.h
index cdc9f804e72f1..36f8067219700 100644
--- a/cpp/src/arrow/compute/registry_internal.h
+++ b/cpp/src/arrow/compute/registry_internal.h
@@ -56,6 +56,7 @@ void RegisterVectorSort(FunctionRegistry* registry);
 void RegisterVectorRunEndEncode(FunctionRegistry* registry);
 void RegisterVectorRunEndDecode(FunctionRegistry* registry);
 void RegisterVectorPairwise(FunctionRegistry* registry);
+void RegisterVectorPlacement(FunctionRegistry* registry);
 void RegisterVectorOptions(FunctionRegistry* registry);
 
 // Aggregate functions

From 3707fa6fb165b9d3985b5ebdb39d430fbbdcd02c Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Tue, 8 Oct 2024 00:50:39 +0800
Subject: [PATCH 06/54] Implement permute

---
 cpp/src/arrow/compute/api_vector.cc           |   8 +-
 cpp/src/arrow/compute/api_vector.h            |  23 ++--
 .../arrow/compute/kernels/vector_placement.cc | 111 ++++++++----------
 .../compute/kernels/vector_placement_test.cc  |  10 ++
 4 files changed, 74 insertions(+), 78 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index c7e344ef28097..524f16d877119 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -159,8 +159,8 @@ static auto kReverseIndexOptionsType = GetFunctionOptionsType<ReverseIndexOption
     DataMember("output_length", &ReverseIndexOptions::output_length),
     DataMember("output_type", &ReverseIndexOptions::output_type),
     DataMember("output_non_taken", &ReverseIndexOptions::output_non_taken));
-static auto kPermuteOptionsType =
-    GetFunctionOptionsType<PermuteOptions>(DataMember("bound", &PermuteOptions::bound));
+static auto kPermuteOptionsType = GetFunctionOptionsType<PermuteOptions>(
+    DataMember("output_length", &PermuteOptions::output_length));
 }  // namespace
 }  // namespace internal
 
@@ -245,8 +245,8 @@ ReverseIndexOptions::ReverseIndexOptions(int64_t output_length,
       output_non_taken(std::move(output_non_taken)) {}
 constexpr char ReverseIndexOptions::kTypeName[];
 
-PermuteOptions::PermuteOptions(int64_t bound)
-    : FunctionOptions(internal::kPermuteOptionsType), bound(bound) {}
+PermuteOptions::PermuteOptions(int64_t output_length)
+    : FunctionOptions(internal::kPermuteOptionsType), output_length(output_length) {}
 constexpr char PermuteOptions::kTypeName[];
 
 namespace internal {
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 60c53fec1be10..152f1bdf80832 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -266,27 +266,30 @@ class ARROW_EXPORT ReverseIndexOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "ReverseIndexOptions";
   static ReverseIndexOptions Defaults() { return ReverseIndexOptions(); }
 
-  /// \brief The upper bound of the permutation. If -1, the output will be sized as the
-  /// maximum value in the indices array + 1. Otherwise, the output will be of size bound,
-  /// and any indices that are greater of equal to bound will be ignored.
+  /// \brief The length of the output reverse index. Must be non-negative. Any indices
+  /// that are greater of equal to this length will be ignored.
   int64_t output_length = 0;
-  /// \brief The type of the output reverse index. If null, the output type will be the
-  /// smallest possible integer type that can hold the maximum value in the indices array.
+  /// \brief The type of the output reverse index. Must be integer types. An overflow
+  /// error will be reported if any reverse indices are out of the bounds of the output
+  /// type.
   std::shared_ptr<DataType> output_type = int32();
+  /// \brief The value to fill in the output reverse index for indices that are not taken.
+  /// Must be of the same type as `output_type` if not null. If not provided or an invalid
+  /// scalar is provided, the non-taken indices will be filled with nulls. Using non-null
+  /// scalars properly may enable efficient processing of reverse index function.
   std::shared_ptr<Scalar> output_non_taken = NULLPTR;
 };
 
 /// \brief Options for permute function
 class ARROW_EXPORT PermuteOptions : public FunctionOptions {
  public:
-  explicit PermuteOptions(int64_t bound = -1);
+  explicit PermuteOptions(int64_t output_length = 0);
   static constexpr char const kTypeName[] = "PermuteOptions";
   static PermuteOptions Defaults() { return PermuteOptions(); }
 
-  /// \brief The upper bound of the permutation. If -1, the output will be sized as the
-  /// maximum value in the indices array + 1. Otherwise, the output will be of size bound,
-  /// and any indices that are greater of equal to bound will be ignored.
-  int64_t bound = -1;
+  /// \brief The length of the output permutation. Must be non-negative. Any values with
+  /// indices that are greater of equal to this length will be ignored.
+  int64_t output_length = 0;
 };
 
 /// @}
diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index f5e878bc93c14..a1d8f4054f45f 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -10,6 +10,18 @@ namespace arrow::compute::internal {
 
 namespace {
 
+// ----------------------------------------------------------------------
+// ReverseIndex
+
+const FunctionDoc reverse_index_doc(
+    "Compute the reverse indices from an input indices",
+    "For the `i`-th `index` in `indices`, the `index`-th output is `i`", {"indices"});
+
+const PermuteOptions* GetDefaultReverseIndexOptions() {
+  static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
+  return &kDefaultPermuteOptions;
+}
+
 struct ReverseIndexState : public KernelState {
   explicit ReverseIndexState(int64_t length, std::shared_ptr<DataType> type,
                              std::shared_ptr<Buffer> validity,
@@ -203,15 +215,8 @@ struct ReverseIndexChunked {
   }
 };
 
-const FunctionDoc reverse_index_doc(
-    "Compute the reverse indices from an input indices",
-    "Place each input value to the output array at position specified by `indices`",
-    {"indices"});
-
-const PermuteOptions* GetDefaultReverseIndexOptions() {
-  static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
-  return &kDefaultPermuteOptions;
-}
+// ----------------------------------------------------------------------
+// Permute
 
 const FunctionDoc permute_doc(
     "Permute values of an input based on indices from another array",
@@ -232,68 +237,40 @@ class PermuteMetaFunction : public MetaFunction {
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
                             ExecContext* ctx) const override {
-    const auto& permute_options = checked_cast<const PermuteOptions&>(*options);
-    if (args[0].length() != args[1].length()) {
-      return Status::Invalid("Input and indices must have the same length");
+    const auto& values = args[0];
+    const auto& indices = args[1];
+    auto* permute_options = checked_cast<const PermuteOptions*>(options);
+    if (values.length() != indices.length()) {
+      return Status::Invalid(
+          "Input and indices of permute must have the same length, got " +
+          std::to_string(values.length()) + " and " + std::to_string(indices.length()));
     }
-    if (args[0].length() == 0) {
-      return args[0];
+    if (!is_integer(indices.type()->id())) {
+      return Status::Invalid("Indices of permute must be of integer type, got ",
+                             indices.type()->ToString());
     }
-    int64_t output_length = permute_options.bound;
+    int64_t output_length = permute_options->output_length;
     if (output_length < 0) {
-      ARROW_ASSIGN_OR_RAISE(auto max_scalar, CallFunction("max", {args[1]}, ctx));
-      DCHECK(max_scalar.is_scalar());
-      ARROW_ASSIGN_OR_RAISE(auto max_i64_scalar, max_scalar.scalar()->CastTo(int64()));
-      output_length = checked_cast<const Int64Scalar*>(max_i64_scalar.get())->value + 1;
+      return Status::Invalid("Output length of permute must be non-negative, got " +
+                             std::to_string(output_length));
     }
-    if (output_length <= 0) {
-      ARROW_ASSIGN_OR_RAISE(auto output, MakeEmptyArray(args[0].type()));
-      return output->data();
+    std::shared_ptr<Scalar> output_non_taken = nullptr;
+    if (is_signed_integer(indices.type()->id())) {
+      // Using -1 (as opposed to null) as output_non_taken for signed integer types to
+      // enable efficient reverse_index.
+      ARROW_ASSIGN_OR_RAISE(output_non_taken, MakeScalar(indices.type(), -1));
     }
-    ARROW_ASSIGN_OR_RAISE(auto reverse_indices,
-                          MakeArrayOfNull(int64(), output_length, ctx->memory_pool()));
-    switch (args[1].kind()) {
-      case Datum::ARRAY:
-        RETURN_NOT_OK(ReverseIndices(*args[1].array(), reverse_indices->data()));
-        break;
-      case Datum::CHUNKED_ARRAY:
-        for (const auto& chunk : args[1].chunked_array()->chunks()) {
-          RETURN_NOT_OK(ReverseIndices(*chunk->data(), reverse_indices->data()));
-        }
-        break;
-      default:
-        return Status::NotImplemented("Unsupported shape for permute operation: indices=",
-                                      args[1].ToString());
-        break;
-    }
-    return CallFunction("take", {args[0], reverse_indices}, ctx);
+    ReverseIndexOptions reverse_index_options{output_length, indices.type(),
+                                              std::move(output_non_taken)};
+    ARROW_ASSIGN_OR_RAISE(
+        auto reverse_indices,
+        CallFunction("reverse_index", {indices}, &reverse_index_options, ctx));
+    TakeOptions take_options{/*boundcheck=*/false};
+    return CallFunction("take", {values, reverse_indices}, &take_options, ctx);
   }
-
- private:
-  Status ReverseIndices(const ArraySpan& indices,
-                        const std::shared_ptr<ArrayData>& reverse_indices) const {
-    auto reverse_indices_validity = reverse_indices->GetMutableValues<uint8_t>(0);
-    auto reverse_indices_data = reverse_indices->GetMutableValues<int64_t>(1);
-    auto length = reverse_indices->length;
-    int64_t reverse_index = 0;
-    return VisitArraySpanInline<Int64Type>(
-        indices,
-        [&](int64_t index) {
-          if (ARROW_PREDICT_TRUE(index > 0 && index < length)) {
-            bit_util::SetBitTo(reverse_indices_validity, index, true);
-            reverse_indices_data[index] = reverse_index;
-          }
-          ++reverse_index;
-          return Status::OK();
-        },
-        [&]() {
-          ++reverse_index;
-          return Status::OK();
-        });
-  };
 };
 
-}  // namespace
+// ----------------------------------------------------------------------
 
 void RegisterVectorReverseIndex(FunctionRegistry* registry) {
   auto function =
@@ -319,9 +296,15 @@ void RegisterVectorReverseIndex(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(function)));
 }
 
+void RegisterVectorPermute(FunctionRegistry* registry) {
+  DCHECK_OK(registry->AddFunction(std::make_shared<PermuteMetaFunction>()));
+}
+
+}  // namespace
+
 void RegisterVectorPlacement(FunctionRegistry* registry) {
   RegisterVectorReverseIndex(registry);
-  DCHECK_OK(registry->AddFunction(std::make_shared<PermuteMetaFunction>()));
+  RegisterVectorPermute(registry);
 }
 
 }  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index bfe38c731dc7c..86203ad53d651 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -145,4 +145,14 @@ TEST(ReverseIndex, Overflow) {
   }
 }
 
+TEST(Permute, Basic) {
+  auto values = ArrayFromJSON(int64(), "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]");
+  auto indices = ArrayFromJSON(int64(), "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]");
+  auto expected = ArrayFromJSON(int64(), "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]");
+  PermuteOptions options{10};
+  ASSERT_OK_AND_ASSIGN(Datum result,
+                       CallFunction("permute", {values, indices}, &options));
+  AssertDatumsEqual(expected, result);
+}
+
 };  // namespace arrow::compute

From 4e9d3a61c6f5d38d287d1426fb6a47ed16e4a877 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Thu, 10 Oct 2024 11:15:58 +0800
Subject: [PATCH 07/54] Reorg reverse_index

---
 .../arrow/compute/kernels/vector_placement.cc | 303 ++++++++++++------
 .../compute/kernels/vector_placement_test.cc  |  84 ++---
 2 files changed, 234 insertions(+), 153 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index a1d8f4054f45f..bbb8e3759682a 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -22,68 +22,78 @@ const PermuteOptions* GetDefaultReverseIndexOptions() {
   return &kDefaultPermuteOptions;
 }
 
-struct ReverseIndexState : public KernelState {
-  explicit ReverseIndexState(int64_t length, std::shared_ptr<DataType> type,
-                             std::shared_ptr<Buffer> validity,
-                             std::shared_ptr<Buffer> data)
-      : length(length),
-        type(std::move(type)),
-        validity(std::move(validity)),
-        data(std::move(data)) {}
-
-  const int64_t length = 0;
-  const std::shared_ptr<DataType> type = nullptr;
-  const std::shared_ptr<Buffer> validity = nullptr;
-  const std::shared_ptr<Buffer> data = nullptr;
-};
-
-Result<std::unique_ptr<KernelState>> ReverseIndexInit(KernelContext* ctx,
-                                                      const KernelInitArgs& args) {
-  auto* options = checked_cast<const ReverseIndexOptions*>(args.options);
-  DCHECK_NE(options, nullptr);
-
-  if (options->output_length < 0) {
-    return Status::Invalid("Output length of reverse_index must be non-negative, got " +
-                           std::to_string(options->output_length));
-  }
-  if (!options->output_type || !is_integer(options->output_type->id())) {
-    return Status::Invalid(
-        "Output type of reverse_index must be integer, got " +
-        (options->output_type ? options->output_type->ToString() : "null"));
-  }
-  if (options->output_non_taken &&
-      !options->output_non_taken->type->Equals(options->output_type)) {
-    return Status::Invalid(
-        "Output non-taken of reverse_index must be of the same type with the output "
-        "type, got " +
-        options->output_non_taken->type->ToString());
-  }
-
-  std::shared_ptr<Buffer> validity = nullptr;
-  ARROW_ASSIGN_OR_RAISE(auto data, ctx->Allocate(options->output_length *
-                                                 options->output_type->byte_width()));
-  if (!options->output_non_taken || !options->output_non_taken->is_valid) {
-    ARROW_ASSIGN_OR_RAISE(validity, ctx->AllocateBitmap(options->output_length));
-    std::memset(validity->mutable_data(), 0, options->output_length);
-  } else {
-    auto int_scalar = checked_cast<const arrow::internal::PrimitiveScalarBase*>(
-        options->output_non_taken.get());
-    for (int64_t i = 0; i < options->output_length; ++i) {
-      std::memcpy(data->mutable_data() + int_scalar->type->byte_width() * i,
-                  int_scalar->data(), int_scalar->type->byte_width());
-    }
-  }
-  auto state = std::make_unique<ReverseIndexState>(
-      options->output_length, options->output_type, std::move(validity), std::move(data));
-  return state;
-}
+using ReverseIndexState = OptionsWrapper<ReverseIndexOptions>;
+
+// struct ReverseIndexState : public KernelState {
+//   explicit ReverseIndexState(int64_t length, std::shared_ptr<DataType> type,
+//                              std::shared_ptr<Buffer> validity,
+//                              std::shared_ptr<Buffer> data)
+//       : length(length),
+//         type(std::move(type)),
+//         validity(std::move(validity)),
+//         data(std::move(data)) {}
+
+//   const int64_t length = 0;
+//   const std::shared_ptr<DataType> type = nullptr;
+//   const std::shared_ptr<Buffer> validity = nullptr;
+//   const std::shared_ptr<Buffer> data = nullptr;
+// };
+
+// Result<std::unique_ptr<KernelState>> ReverseIndexInit(KernelContext* ctx,
+//                                                       const KernelInitArgs& args) {
+//   auto* options = checked_cast<const ReverseIndexOptions*>(args.options);
+//   DCHECK_NE(options, nullptr);
+
+//   if (options->output_length < 0) {
+//     return Status::Invalid("Output length of reverse_index must be non-negative, got "
+//     +
+//                            std::to_string(options->output_length));
+//   }
+//   if (!options->output_type || !is_integer(options->output_type->id())) {
+//     return Status::Invalid(
+//         "Output type of reverse_index must be integer, got " +
+//         (options->output_type ? options->output_type->ToString() : "null"));
+//   }
+//   if (options->output_non_taken &&
+//       !options->output_non_taken->type->Equals(options->output_type)) {
+//     return Status::Invalid(
+//         "Output non-taken of reverse_index must be of the same type with the output "
+//         "type, got " +
+//         options->output_non_taken->type->ToString());
+//   }
+
+//   std::shared_ptr<Buffer> validity = nullptr;
+//   ARROW_ASSIGN_OR_RAISE(auto data, ctx->Allocate(options->output_length *
+//                                                  options->output_type->byte_width()));
+//   if (!options->output_non_taken || !options->output_non_taken->is_valid) {
+//     ARROW_ASSIGN_OR_RAISE(validity, ctx->AllocateBitmap(options->output_length));
+//     std::memset(validity->mutable_data(), 0, options->output_length);
+//   } else {
+//     auto int_scalar = checked_cast<const arrow::internal::PrimitiveScalarBase*>(
+//         options->output_non_taken.get());
+//     for (int64_t i = 0; i < options->output_length; ++i) {
+//       std::memcpy(data->mutable_data() + int_scalar->type->byte_width() * i,
+//                   int_scalar->data(), int_scalar->type->byte_width());
+//     }
+//   }
+//   auto state = std::make_unique<ReverseIndexState>(
+//       options->output_length, options->output_type, std::move(validity),
+//       std::move(data));
+//   return state;
+// }
 
 /// \brief The OutputType::Resolver of the "reverse_index" function.
-Result<TypeHolder> ReverseIndexResolveOutputType(KernelContext* ctx,
+Result<TypeHolder> ResolveReverseIndexOutputType(KernelContext* ctx,
                                                  const std::vector<TypeHolder>&) {
-  auto state = checked_cast<const ReverseIndexState*>(ctx->state());
-  DCHECK_NE(state, nullptr);
-  return TypeHolder(state->type);
+  const auto& output_type = ReverseIndexState::Get(ctx).output_type;
+  if (!output_type) {
+    return Status::Invalid("Output type of reverse_index must not be null");
+  }
+  if (!is_integer(output_type->id())) {
+    return Status::Invalid("Output type of reverse_index must be integer, got " +
+                           output_type->ToString());
+  }
+  return TypeHolder(output_type);
 }
 
 template <typename ExecType>
@@ -94,65 +104,133 @@ struct ReverseIndexImpl {
   using ShapeType = typename ExecType::ShapeType;
 
   static Result<std::shared_ptr<ArrayData>> Exec(KernelContext* ctx,
-                                                 const ShapeType& indices) {
-    auto state = checked_cast<ReverseIndexState*>(ctx->state());
-    DCHECK_NE(state, nullptr);
+                                                 const ShapeType& indices,
+                                                 int64_t length) {
+    const auto& options = ReverseIndexState::Get(ctx);
 
-    if (state->length > 0) {
-      ThisType impl(ctx, indices, state);
-      RETURN_NOT_OK(VisitTypeInline(*state->type, &impl));
+    int64_t output_length = options.output_length;
+    if (output_length < 0) {
+      output_length = length;
     }
 
-    return ArrayData::Make(state->type, state->length, {state->validity, state->data});
+    ThisType impl(ctx, indices, length, output_length);
+    RETURN_NOT_OK(VisitTypeInline(*options.output_type, &impl));
+
+    return ArrayData::Make(options.output_type, options.output_length,
+                           {std::move(impl.validity_buf), std::move(impl.data_buf)});
   }
 
  private:
   KernelContext* ctx;
   const ShapeType& indices;
-  ReverseIndexState* state;
+  const int64_t length;
+  const int64_t output_length;
+  // const std::shared_ptr<DataType> output_type;
+
+  std::shared_ptr<Buffer> validity_buf = nullptr;
+  std::shared_ptr<Buffer> data_buf = nullptr;
 
  private:
-  ReverseIndexImpl(KernelContext* ctx, const ShapeType& indices, ReverseIndexState* state)
-      : ctx(ctx), indices(indices), state(state) {}
+  ReverseIndexImpl(KernelContext* ctx, const ShapeType& indices, int64_t length,
+                   int64_t output_length)
+      : ctx(ctx), indices(indices), length(length), output_length(output_length) {}
 
-  Status Visit(const DataType& type) { return Status::Invalid(type.ToString()); }
+  Status Visit(const DataType& output_type) {
+    DCHECK(false) << "Shouldn't reach here";
+    return Status::Invalid("Shouldn't reach here");
+  }
 
   template <typename Type>
-  enable_if_t<is_integer_type<Type>::value, Status> Visit(const Type&) {
-    if (state->validity) {
-      return VisitInternal<Type, true>();
+  enable_if_t<is_integer_type<Type>::value, Status> Visit(const Type& output_type) {
+    using OutputCType = typename Type::c_type;
+
+    RETURN_NOT_OK(CheckInput(output_type));
+
+    bool likely_many_nulls = IsLikelyManyNulls();
+    if (likely_many_nulls) {
+      RETURN_NOT_OK(AllocateValidityBufAndFill(false));
+      RETURN_NOT_OK(AllocateDataBuf(output_type));
+    } else {
+      RETURN_NOT_OK(
+          AllocateDataBufAndFill(output_type, static_cast<OutputCType>(length)));
+    }
+    if (likely_many_nulls) {
+      return Execute<Type, true>();
     } else {
-      return VisitInternal<Type, false>();
+      return Execute<Type, false>();
     }
   }
 
-  template <typename Type, bool validity_preallocated>
-  Status VisitInternal() {
+  template <typename Type>
+  Status CheckInput(const Type& output_type) {
     using OutputCType = typename Type::c_type;
 
-    uint8_t* output_validity = nullptr;
-    if constexpr (validity_preallocated) {
-      output_validity = state->validity->mutable_data_as<uint8_t>();
+    if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < length) {
+      return Status::Invalid(
+          "Output type " + output_type.ToString() +
+          " of reverse_index is insufficient to store indices of length " +
+          std::to_string(length));
     }
-    OutputCType* output_data = state->data->mutable_data_as<OutputCType>();
 
+    return Status::OK();
+  }
+
+  bool IsLikelyManyNulls() { return output_length > 2 * length; }
+
+  Status AllocateValidityBufAndFill(bool valid) {
+    DCHECK_EQ(validity_buf, nullptr);
+
+    ARROW_ASSIGN_OR_RAISE(validity_buf, ctx->AllocateBitmap(output_length));
+    auto validity = validity_buf->mutable_data_as<uint8_t>();
+    std::memset(validity, valid ? 0xff : 0, bit_util::BytesForBits(output_length));
+
+    return Status::OK();
+  }
+
+  Status AllocateDataBuf(const DataType& output_type) {
+    DCHECK_EQ(data_buf, nullptr);
+
+    ARROW_ASSIGN_OR_RAISE(data_buf,
+                          ctx->Allocate(output_length * output_type.byte_width()));
+
+    return Status::OK();
+  }
+
+  template <typename Type, typename OutputCType = typename Type::c_type>
+  Status AllocateDataBufAndFill(const Type& output_type, OutputCType value) {
+    RETURN_NOT_OK(AllocateDataBuf(output_type));
+
+    OutputCType* data = data_buf->mutable_data_as<OutputCType>();
+    for (int64_t i = 0; i < output_length; ++i) {
+      data[i] = value;
+    }
+
+    return Status::OK();
+  }
+
+  template <typename Type, bool likely_many_nulls>
+  Status Execute() {
+    using OutputCType = typename Type::c_type;
+
+    uint8_t* validity = nullptr;
+    if constexpr (likely_many_nulls) {
+      DCHECK_NE(validity_buf, nullptr);
+      validity = validity_buf->mutable_data_as<uint8_t>();
+    } else {
+      DCHECK_EQ(validity_buf, nullptr);
+    }
+    DCHECK_NE(data_buf, nullptr);
+    OutputCType* data = data_buf->mutable_data_as<OutputCType>();
     int64_t reverse_index = 0;
-    return ExecType::template VisitIndex(
+    RETURN_NOT_OK(ExecType::template VisitIndices(
         indices,
         [&](IndexCType index) {
           if (ARROW_PREDICT_TRUE(index >= 0 &&
-                                 static_cast<int64_t>(index) < state->length)) {
-            if constexpr (validity_preallocated) {
-              bit_util::SetBitTo(output_validity, index, true);
-            }
-            if (ARROW_PREDICT_FALSE(
-                    static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) <
-                    reverse_index)) {
-              return Status::Invalid("Overflow in reverse_index, got " +
-                                     std::to_string(reverse_index) + " for " +
-                                     state->type->ToString());
+                                 static_cast<int64_t>(index) < output_length)) {
+            data[index] = static_cast<OutputCType>(reverse_index);
+            if constexpr (likely_many_nulls) {
+              bit_util::SetBitTo(validity, index, true);
             }
-            output_data[index] = static_cast<OutputCType>(reverse_index);
           }
           ++reverse_index;
           return Status::OK();
@@ -160,7 +238,21 @@ struct ReverseIndexImpl {
         [&]() {
           ++reverse_index;
           return Status::OK();
-        });
+        }));
+
+    if constexpr (!likely_many_nulls) {
+      for (int64_t i = 0; i < output_length; ++i) {
+        if (data[i] == static_cast<OutputCType>(length)) {
+          if (ARROW_PREDICT_FALSE(!validity_buf)) {
+            RETURN_NOT_OK(AllocateValidityBufAndFill(true));
+            validity = validity_buf->mutable_data_as<uint8_t>();
+          }
+          bit_util::SetBitTo(validity, i, false);
+        }
+      }
+    }
+
+    return Status::OK();
   }
 
   template <typename VISITOR, typename... ARGS>
@@ -174,16 +266,19 @@ struct ReverseIndex {
   using ShapeType = ArraySpan;
 
   template <typename ValidFunc, typename NullFunc>
-  static Status VisitIndex(const ArraySpan& span, ValidFunc&& valid_func,
-                           NullFunc&& null_func) {
+  static Status VisitIndices(const ArraySpan& span, ValidFunc&& valid_func,
+                             NullFunc&& null_func) {
     return VisitArraySpanInline<IndexType>(span, std::forward<ValidFunc>(valid_func),
                                            std::forward<NullFunc>(null_func));
   }
 
+  static int64_t IndicesLength(const ShapeType& indices) { return indices.length; }
+
   static Status Exec(KernelContext* ctx, const ExecSpan& span, ExecResult* result) {
     DCHECK(span[0].is_array());
     const auto& indices = span[0].array;
-    ARROW_ASSIGN_OR_RAISE(auto output, ReverseIndexImpl<ThisType>::Exec(ctx, indices));
+    ARROW_ASSIGN_OR_RAISE(auto output,
+                          ReverseIndexImpl<ThisType>::Exec(ctx, indices, indices.length));
     result->value = std::move(output);
     return Status::OK();
   }
@@ -196,8 +291,8 @@ struct ReverseIndexChunked {
   using ShapeType = std::shared_ptr<ChunkedArray>;
 
   template <typename ValidFunc, typename NullFunc>
-  static Status VisitIndex(const std::shared_ptr<ChunkedArray>& chunked_array,
-                           ValidFunc&& valid_func, NullFunc&& null_func) {
+  static Status VisitIndices(const std::shared_ptr<ChunkedArray>& chunked_array,
+                             ValidFunc&& valid_func, NullFunc&& null_func) {
     for (const auto& chunk : chunked_array->chunks()) {
       ArraySpan span(*chunk->data());
       RETURN_NOT_OK(VisitArraySpanInline<IndexType>(
@@ -206,10 +301,13 @@ struct ReverseIndexChunked {
     return Status::OK();
   }
 
+  static int64_t IndicesLength(const ShapeType& indices) { return indices->length(); }
+
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* result) {
     DCHECK(batch[0].is_chunked_array());
     const auto& indices = batch[0].chunked_array();
-    ARROW_ASSIGN_OR_RAISE(auto output, ReverseIndexImpl<ThisType>::Exec(ctx, indices));
+    ARROW_ASSIGN_OR_RAISE(
+        auto output, ReverseIndexImpl<ThisType>::Exec(ctx, indices, indices->length()));
     *result = std::move(output);
     return Status::OK();
   }
@@ -258,7 +356,7 @@ class PermuteMetaFunction : public MetaFunction {
     if (is_signed_integer(indices.type()->id())) {
       // Using -1 (as opposed to null) as output_non_taken for signed integer types to
       // enable efficient reverse_index.
-      ARROW_ASSIGN_OR_RAISE(output_non_taken, MakeScalar(indices.type(), -1));
+      ARROW_ASSIGN_OR_RAISE(output_non_taken, MakeScalar(indices.type(), 0));
     }
     ReverseIndexOptions reverse_index_options{output_length, indices.type(),
                                               std::move(output_non_taken)};
@@ -280,8 +378,9 @@ void RegisterVectorReverseIndex(FunctionRegistry* registry) {
   auto add_kernel = [&function](Type::type type_id) {
     VectorKernel kernel;
     kernel.signature = KernelSignature::Make({InputType(match::SameTypeId(type_id))},
-                                             OutputType(ReverseIndexResolveOutputType));
-    kernel.init = ReverseIndexInit;
+                                             OutputType(ResolveReverseIndexOutputType));
+    kernel.init = ReverseIndexState::Init;
+    // kernel.init = ReverseIndexInit;
     kernel.exec = GenerateInteger<ReverseIndex, void, ArrayKernelExec>(type_id);
     kernel.exec_chunked =
         GenerateInteger<ReverseIndexChunked, void, VectorKernel::ChunkedExec>(type_id);
diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index 86203ad53d651..8c19a3ef61ffa 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -16,9 +16,9 @@ TEST(ReverseIndex, Invalid) {
   {
     auto indices = ArrayFromJSON(int32(), "[]");
     ReverseIndexOptions options{0, nullptr};
-    ASSERT_RAISES_WITH_MESSAGE(
-        Invalid, "Invalid: Output type of reverse_index must be integer, got null",
-        CallFunction("reverse_index", {indices}, &options));
+    ASSERT_RAISES_WITH_MESSAGE(Invalid,
+                               "Invalid: Output type of reverse_index must not be null",
+                               CallFunction("reverse_index", {indices}, &options));
   }
   {
     auto indices = ArrayFromJSON(int32(), "[]");
@@ -27,21 +27,6 @@ TEST(ReverseIndex, Invalid) {
         Invalid, "Invalid: Output type of reverse_index must be integer, got string",
         CallFunction("reverse_index", {indices}, &options));
   }
-  {
-    auto indices = ArrayFromJSON(int32(), "[]");
-    ReverseIndexOptions options{-1, int8()};
-    ASSERT_RAISES_WITH_MESSAGE(
-        Invalid, "Invalid: Output length of reverse_index must be non-negative, got -1",
-        CallFunction("reverse_index", {indices}, &options));
-  }
-  {
-    auto indices = ArrayFromJSON(int32(), "[]");
-    ReverseIndexOptions options{0, int8(), MakeScalar(int16_t(-1))};
-    ASSERT_RAISES_WITH_MESSAGE(Invalid,
-                               "Invalid: Output non-taken of reverse_index must be of "
-                               "the same type with the output type, got int16",
-                               CallFunction("reverse_index", {indices}, &options));
-  }
 }
 
 TEST(ReverseIndex, Basic) {
@@ -69,15 +54,6 @@ TEST(ReverseIndex, Basic) {
                          CallFunction("reverse_index", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
-  {
-    auto indices = ArrayFromJSON(int32(), "[1, 2]");
-    auto expected = ArrayFromJSON(int8(), "[-1, 0, 1, -1, -1, -1, -1]");
-    ReverseIndexOptions options{7, int8(), MakeScalar(int8_t(-1))};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
-    AssertDatumsEqual(expected, result);
-    ASSERT_FALSE(result.array()->HasValidityBitmap());
-  }
   {
     auto indices = ArrayFromJSON(int32(), "[1, 2]");
     auto expected = ArrayFromJSON(int8(), "[]");
@@ -114,45 +90,51 @@ TEST(ReverseIndex, Basic) {
 
 TEST(ReverseIndex, Overflow) {
   {
-    auto indices = ConstantArrayGenerator::Zeroes(
-        std::numeric_limits<int8_t>::max() + int64_t(1), int8());
-    auto expected = ArrayFromJSON(
-        int8(), "[" + std::to_string(std::numeric_limits<int8_t>::max()) + "]");
+    auto indices = ConstantArrayGenerator::Zeroes(127, int8());
+    auto expected = ArrayFromJSON(int8(), "[126]");
     ReverseIndexOptions options{1, int8()};
     ASSERT_OK_AND_ASSIGN(Datum result,
                          CallFunction("reverse_index", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
   {
-    auto indices = ConstantArrayGenerator::Zeroes(
-        std::numeric_limits<int8_t>::max() + int64_t(2), int8());
+    auto indices = ConstantArrayGenerator::Zeroes(128, int8());
     ReverseIndexOptions options{1, int8()};
-    ASSERT_RAISES_WITH_MESSAGE(
-        Invalid,
-        "Invalid: Overflow in reverse_index, got " +
-            std::to_string(std::numeric_limits<int8_t>::max() + int64_t(1)) + " for int8",
-        CallFunction("reverse_index", {indices}, &options));
+    ASSERT_RAISES_WITH_MESSAGE(Invalid,
+                               "Invalid: Output type int8 of reverse_index is "
+                               "insufficient to store indices of length 128",
+                               CallFunction("reverse_index", {indices}, &options));
   }
   {
-    ASSERT_OK_AND_ASSIGN(
-        auto indices,
-        MakeArrayOfNull(int8(), std::numeric_limits<int8_t>::max() + int64_t(2)));
+    ASSERT_OK_AND_ASSIGN(auto indices, MakeArrayOfNull(int8(), 128));
     auto expected = ArrayFromJSON(int8(), "[null]");
     ReverseIndexOptions options{1, int8()};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ASSERT_RAISES_WITH_MESSAGE(Invalid,
+                               "Invalid: Output type int8 of reverse_index is "
+                               "insufficient to store indices of length 128",
+                               CallFunction("reverse_index", {indices}, &options));
   }
 }
 
 TEST(Permute, Basic) {
-  auto values = ArrayFromJSON(int64(), "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]");
-  auto indices = ArrayFromJSON(int64(), "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]");
-  auto expected = ArrayFromJSON(int64(), "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]");
-  PermuteOptions options{10};
-  ASSERT_OK_AND_ASSIGN(Datum result,
-                       CallFunction("permute", {values, indices}, &options));
-  AssertDatumsEqual(expected, result);
+  {
+    auto values = ArrayFromJSON(int64(), "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]");
+    auto indices = ArrayFromJSON(int64(), "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]");
+    auto expected = ArrayFromJSON(int64(), "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]");
+    PermuteOptions options{10};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("permute", {values, indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
+  {
+    auto values = ArrayFromJSON(int64(), "[0, 0, 0, 1, 1, 1]");
+    auto indices = ArrayFromJSON(int64(), "[0, 3, 6, 1, 4, 7]");
+    auto expected = ArrayFromJSON(int64(), "[0, 1, null, 0, 1, null, 0, 1, null]");
+    PermuteOptions options{9};
+    ASSERT_OK_AND_ASSIGN(Datum result,
+                         CallFunction("permute", {values, indices}, &options));
+    AssertDatumsEqual(expected, result);
+  }
 }
 
 };  // namespace arrow::compute

From c4c5c413b97f16246308e9a148f860696620b653 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Thu, 10 Oct 2024 14:26:38 +0800
Subject: [PATCH 08/54] Fix API and doc

---
 cpp/src/arrow/compute/api_vector.cc | 18 ++++----
 cpp/src/arrow/compute/api_vector.h  | 72 ++++++++++++++++++++++-------
 2 files changed, 65 insertions(+), 25 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 524f16d877119..3b5ff0fe8c452 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -157,8 +157,7 @@ static auto kListFlattenOptionsType = GetFunctionOptionsType<ListFlattenOptions>
     DataMember("recursive", &ListFlattenOptions::recursive));
 static auto kReverseIndexOptionsType = GetFunctionOptionsType<ReverseIndexOptions>(
     DataMember("output_length", &ReverseIndexOptions::output_length),
-    DataMember("output_type", &ReverseIndexOptions::output_type),
-    DataMember("output_non_taken", &ReverseIndexOptions::output_non_taken));
+    DataMember("output_type", &ReverseIndexOptions::output_type));
 static auto kPermuteOptionsType = GetFunctionOptionsType<PermuteOptions>(
     DataMember("output_length", &PermuteOptions::output_length));
 }  // namespace
@@ -237,12 +236,10 @@ ListFlattenOptions::ListFlattenOptions(bool recursive)
 constexpr char ListFlattenOptions::kTypeName[];
 
 ReverseIndexOptions::ReverseIndexOptions(int64_t output_length,
-                                         std::shared_ptr<DataType> output_type,
-                                         std::shared_ptr<Scalar> output_non_taken)
+                                         std::shared_ptr<DataType> output_type)
     : FunctionOptions(internal::kPermuteOptionsType),
       output_length(output_length),
-      output_type(std::move(output_type)),
-      output_non_taken(std::move(output_non_taken)) {}
+      output_type(std::move(output_type)) {}
 constexpr char ReverseIndexOptions::kTypeName[];
 
 PermuteOptions::PermuteOptions(int64_t output_length)
@@ -263,6 +260,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kRankOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPairwiseOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kListFlattenOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kReverseIndexOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPermuteOptionsType));
 }
 }  // namespace internal
@@ -450,18 +448,20 @@ Result<Datum> CumulativeMean(const Datum& values, const CumulativeOptions& optio
 }
 
 // ----------------------------------------------------------------------
-// Permute functions
+// Placement functions
 
 Result<std::shared_ptr<Array>> ReverseIndex(const Datum& indices,
                                             const ReverseIndexOptions& options,
                                             ExecContext* ctx) {
-  ARROW_ASSIGN_OR_RAISE(Datum result, CallFunction("reverse_index", {indices}, ctx));
+  ARROW_ASSIGN_OR_RAISE(Datum result,
+                        CallFunction("reverse_index", {indices}, &options, ctx));
   return result.make_array();
 }
 
 Result<std::shared_ptr<Array>> Permute(const Datum& values, const Datum& indices,
                                        const PermuteOptions& options, ExecContext* ctx) {
-  ARROW_ASSIGN_OR_RAISE(Datum result, CallFunction("permute", {values, indices}, ctx));
+  ARROW_ASSIGN_OR_RAISE(Datum result,
+                        CallFunction("permute", {values, indices}, &options, ctx));
   return result.make_array();
 }
 
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 152f1bdf80832..8e2cd2fdcb1f9 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -260,24 +260,18 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
 /// \brief Options for reverse_index function
 class ARROW_EXPORT ReverseIndexOptions : public FunctionOptions {
  public:
-  explicit ReverseIndexOptions(int64_t output_length = 0,
-                               std::shared_ptr<DataType> output_type = int32(),
-                               std::shared_ptr<Scalar> output_non_taken = NULLPTR);
+  explicit ReverseIndexOptions(int64_t output_length = -1,
+                               std::shared_ptr<DataType> output_type = int32());
   static constexpr char const kTypeName[] = "ReverseIndexOptions";
   static ReverseIndexOptions Defaults() { return ReverseIndexOptions(); }
 
-  /// \brief The length of the output reverse index. Must be non-negative. Any indices
-  /// that are greater of equal to this length will be ignored.
-  int64_t output_length = 0;
-  /// \brief The type of the output reverse index. Must be integer types. An overflow
-  /// error will be reported if any reverse indices are out of the bounds of the output
-  /// type.
+  /// \brief The length of the output reverse index. If negative, the output will be of
+  /// the same length as the input indices. Any indices that are greater of equal to this
+  /// length will be ignored.
+  int64_t output_length = -1;
+  /// \brief The type of the output reverse index. Must be integer types that are able to
+  /// store the length of the input indices, otherwise an overflow error will be reported.
   std::shared_ptr<DataType> output_type = int32();
-  /// \brief The value to fill in the output reverse index for indices that are not taken.
-  /// Must be of the same type as `output_type` if not null. If not provided or an invalid
-  /// scalar is provided, the non-taken indices will be filled with nulls. Using non-null
-  /// scalars properly may enable efficient processing of reverse index function.
-  std::shared_ptr<Scalar> output_non_taken = NULLPTR;
 };
 
 /// \brief Options for permute function
@@ -287,8 +281,9 @@ class ARROW_EXPORT PermuteOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "PermuteOptions";
   static PermuteOptions Defaults() { return PermuteOptions(); }
 
-  /// \brief The length of the output permutation. Must be non-negative. Any values with
-  /// indices that are greater of equal to this length will be ignored.
+  /// \brief The length of the output permutation. If negative, the output will be of the
+  /// same length as the input indices. Any values with indices that are greater of equal
+  /// to this length will be ignored.
   int64_t output_length = 0;
 };
 
@@ -740,6 +735,51 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
                                             bool check_overflow = false,
                                             ExecContext* ctx = NULLPTR);
 
+/// \brief Return the reverse indices of the given indices.
+///
+/// For indices[i] = x, reverse_indices[x] = i. And reverse_indices[x] = null if
+/// x does not appear in the indices. For indices[i] = x where x < 0 or x >=
+/// output_length, it is ignored. If multiple indices point to the same value, the last
+/// one is used.
+/// For example, with indices = [null, 0, 3, 2, 4, 1, 1], the reverse indices is
+///   [1, 6, 3]                    if output_length = 3,
+///   [1, 6, 3, 2, 4, null, null]  if output_length = 7.
+/// output_length can also be negative, in which case the reverse indices is of the same
+/// length as the indices.
+///
+/// \param[in] indices array-like indices
+/// \param[in] options configures the output length and the output type
+/// \param[in] ctx the function execution context, optional
+/// \return the resulting reverse indices
+///
+/// \since 19.0.0
+/// \note API not yet finalized
+Result<std::shared_ptr<Array>> ReverseIndex(
+    const Datum& indices,
+    const ReverseIndexOptions& options = ReverseIndexOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
+
+/// \brief Permute the values into specified positions in the output array according to
+/// the indices.
+///
+/// For indices[i] = x, output[x] = values[i]. And output[x] = null if
+/// x does not appear in the indices. For indices[i] = x where x < 0 or x >=
+/// output_length, values[i] is ignored.
+/// For example, with values = [a, b, c, d, e, f, g] and indices = [null, 0, 3, 2, 4, 1,
+/// 1], the permutation is
+///   [b, g, d]                    if output_length = 3,
+///   [b, g, d, c, e, null, null]  if output_length = 7.
+/// output_length can also be negative, in which case the permutation is of the same
+/// length as the values (and indices).
+///
+/// \param[in] values datum to permute
+/// \param[in] indices array-like indices
+/// \param[in] options configures the output length of the permutation
+/// \param[in] ctx the function execution context, optional
+/// \return the resulting permutation
+///
+/// \since 19.0.0
+/// \note API not yet finalized
 Result<std::shared_ptr<Array>> Permute(
     const Datum& values, const Datum& indices,
     const PermuteOptions& options = PermuteOptions::Defaults(),

From 78bb33528c21d34c5c252c3d7ddd603a2d80fd8f Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Thu, 10 Oct 2024 14:34:07 +0800
Subject: [PATCH 09/54] Fix API and doc

---
 cpp/src/arrow/compute/api_vector.cc | 24 ++++++++++++------------
 cpp/src/arrow/compute/api_vector.h  | 24 ++++++++++++------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 3b5ff0fe8c452..ac8b6ac9a7f2a 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -155,9 +155,9 @@ static auto kPairwiseOptionsType = GetFunctionOptionsType<PairwiseOptions>(
     DataMember("periods", &PairwiseOptions::periods));
 static auto kListFlattenOptionsType = GetFunctionOptionsType<ListFlattenOptions>(
     DataMember("recursive", &ListFlattenOptions::recursive));
-static auto kReverseIndexOptionsType = GetFunctionOptionsType<ReverseIndexOptions>(
-    DataMember("output_length", &ReverseIndexOptions::output_length),
-    DataMember("output_type", &ReverseIndexOptions::output_type));
+static auto kReverseIndicesOptionsType = GetFunctionOptionsType<ReverseIndicesOptions>(
+    DataMember("output_length", &ReverseIndicesOptions::output_length),
+    DataMember("output_type", &ReverseIndicesOptions::output_type));
 static auto kPermuteOptionsType = GetFunctionOptionsType<PermuteOptions>(
     DataMember("output_length", &PermuteOptions::output_length));
 }  // namespace
@@ -235,12 +235,12 @@ ListFlattenOptions::ListFlattenOptions(bool recursive)
     : FunctionOptions(internal::kListFlattenOptionsType), recursive(recursive) {}
 constexpr char ListFlattenOptions::kTypeName[];
 
-ReverseIndexOptions::ReverseIndexOptions(int64_t output_length,
-                                         std::shared_ptr<DataType> output_type)
-    : FunctionOptions(internal::kPermuteOptionsType),
+ReverseIndicesOptions::ReverseIndicesOptions(int64_t output_length,
+                                             std::shared_ptr<DataType> output_type)
+    : FunctionOptions(internal::kReverseIndicesOptionsType),
       output_length(output_length),
       output_type(std::move(output_type)) {}
-constexpr char ReverseIndexOptions::kTypeName[];
+constexpr char ReverseIndicesOptions::kTypeName[];
 
 PermuteOptions::PermuteOptions(int64_t output_length)
     : FunctionOptions(internal::kPermuteOptionsType), output_length(output_length) {}
@@ -260,7 +260,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kRankOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPairwiseOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kListFlattenOptionsType));
-  DCHECK_OK(registry->AddFunctionOptionsType(kReverseIndexOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kReverseIndicesOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPermuteOptionsType));
 }
 }  // namespace internal
@@ -450,11 +450,11 @@ Result<Datum> CumulativeMean(const Datum& values, const CumulativeOptions& optio
 // ----------------------------------------------------------------------
 // Placement functions
 
-Result<std::shared_ptr<Array>> ReverseIndex(const Datum& indices,
-                                            const ReverseIndexOptions& options,
-                                            ExecContext* ctx) {
+Result<std::shared_ptr<Array>> ReverseIndices(const Datum& indices,
+                                              const ReverseIndicesOptions& options,
+                                              ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(Datum result,
-                        CallFunction("reverse_index", {indices}, &options, ctx));
+                        CallFunction("reverse_indices", {indices}, &options, ctx));
   return result.make_array();
 }
 
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 8e2cd2fdcb1f9..3bd3ee060a010 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -257,19 +257,19 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
   bool recursive = false;
 };
 
-/// \brief Options for reverse_index function
-class ARROW_EXPORT ReverseIndexOptions : public FunctionOptions {
+/// \brief Options for reverse_indices function
+class ARROW_EXPORT ReverseIndicesOptions : public FunctionOptions {
  public:
-  explicit ReverseIndexOptions(int64_t output_length = -1,
+  explicit ReverseIndicesOptions(int64_t output_length = -1,
                                std::shared_ptr<DataType> output_type = int32());
-  static constexpr char const kTypeName[] = "ReverseIndexOptions";
-  static ReverseIndexOptions Defaults() { return ReverseIndexOptions(); }
+  static constexpr char const kTypeName[] = "ReverseIndicesOptions";
+  static ReverseIndicesOptions Defaults() { return ReverseIndicesOptions(); }
 
-  /// \brief The length of the output reverse index. If negative, the output will be of
-  /// the same length as the input indices. Any indices that are greater of equal to this
+  /// \brief The length of the output reverse indices. If negative, the output will be of
+  /// the same length as the input indices. Any indices that are greater or equal to this
   /// length will be ignored.
   int64_t output_length = -1;
-  /// \brief The type of the output reverse index. Must be integer types that are able to
+  /// \brief The type of the output reverse indices. Must be integer types that are able to
   /// store the length of the input indices, otherwise an overflow error will be reported.
   std::shared_ptr<DataType> output_type = int32();
 };
@@ -282,8 +282,8 @@ class ARROW_EXPORT PermuteOptions : public FunctionOptions {
   static PermuteOptions Defaults() { return PermuteOptions(); }
 
   /// \brief The length of the output permutation. If negative, the output will be of the
-  /// same length as the input indices. Any values with indices that are greater of equal
-  /// to this length will be ignored.
+  /// same length as the input values (and indices). Any values with indices that are
+  /// greater or equal to this length will be ignored.
   int64_t output_length = 0;
 };
 
@@ -754,9 +754,9 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
 ///
 /// \since 19.0.0
 /// \note API not yet finalized
-Result<std::shared_ptr<Array>> ReverseIndex(
+Result<std::shared_ptr<Array>> ReverseIndices(
     const Datum& indices,
-    const ReverseIndexOptions& options = ReverseIndexOptions::Defaults(),
+    const ReverseIndicesOptions& options = ReverseIndicesOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
 /// \brief Permute the values into specified positions in the output array according to

From d88877a0b8958e46fc4731863416c3f3dc0a1cbb Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Thu, 10 Oct 2024 15:07:13 +0800
Subject: [PATCH 10/54] Init docs

---
 docs/source/cpp/compute.rst | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 093b160d8e9a0..7df0027121eaf 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1898,3 +1898,25 @@ operation to the n-th and (n+abs(p))-th inputs.
   ``Subtract``. The period can be specified in :struct:`PairwiseOptions`.
 * \(2) Wraps around the result when overflow is detected.
 * \(3) Returns an ``Invalid`` :class:`Status` when overflow is detected.
+
+Placement functions
+~~~~~~~~~~~~~~~~~~
+
+Placement functions reorder the input array based on placement arguments, e.g.
+indices.
+
++-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
+| Function name   | Arity  | Input type 1 | Input type 2 | Output type  | Options class                   | Notes |
++=================+========+==============+==============+==============+=================================+=======+
+| reverse_indices | Unary  | Integer      |              | Integer      | :struct:`ReverseIndicesOptions` | \(1)  |
++-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
+| permute         | Binary | Any          | Integer      | Input type 1 | :struct:`PermuteOptions`        | \(2)  |
++-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
+
+* \(1) Each element in the input is appended to the output iff it is non-null.
+  If the input is a record batch or table, any null value in a column drops
+  the entire row.
+
+* \(2) Each element in input 1 (the values) is appended to the output iff
+  the corresponding element in input 2 (the filter) is true.  How
+  nulls in the filter are handled can be configured using FilterOptions.

From 2bbf44ba93a9a8d6585d418f052a689c354a3ad3 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 01:41:57 +0800
Subject: [PATCH 11/54] Refine

---
 cpp/src/arrow/compute/api_vector.h            |  12 +-
 .../arrow/compute/kernels/vector_placement.cc | 264 ++++++++----------
 .../compute/kernels/vector_placement_test.cc  | 106 ++++---
 3 files changed, 186 insertions(+), 196 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 3bd3ee060a010..61d7cd7b88880 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -261,7 +261,7 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
 class ARROW_EXPORT ReverseIndicesOptions : public FunctionOptions {
  public:
   explicit ReverseIndicesOptions(int64_t output_length = -1,
-                               std::shared_ptr<DataType> output_type = int32());
+                                 std::shared_ptr<DataType> output_type = nullptr);
   static constexpr char const kTypeName[] = "ReverseIndicesOptions";
   static ReverseIndicesOptions Defaults() { return ReverseIndicesOptions(); }
 
@@ -269,9 +269,10 @@ class ARROW_EXPORT ReverseIndicesOptions : public FunctionOptions {
   /// the same length as the input indices. Any indices that are greater or equal to this
   /// length will be ignored.
   int64_t output_length = -1;
-  /// \brief The type of the output reverse indices. Must be integer types that are able to
-  /// store the length of the input indices, otherwise an overflow error will be reported.
-  std::shared_ptr<DataType> output_type = int32();
+  /// \brief The type of the output reverse indices. If null, the output will be of the
+  /// same type as the input indices, otherwise must be integer types. An overflow error
+  /// will be reported if this type is not able to store the length of the input indices.
+  std::shared_ptr<DataType> output_type = nullptr;
 };
 
 /// \brief Options for permute function
@@ -759,8 +760,7 @@ Result<std::shared_ptr<Array>> ReverseIndices(
     const ReverseIndicesOptions& options = ReverseIndicesOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
-/// \brief Permute the values into specified positions in the output array according to
-/// the indices.
+/// \brief Permute the values into specified positions according to the indices.
 ///
 /// For indices[i] = x, output[x] = values[i]. And output[x] = null if
 /// x does not appear in the indices. For indices[i] = x where x < 0 or x >=
diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index bbb8e3759682a..199fa02c0b61d 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -1,9 +1,25 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.#include "arrow/compute/api_vector.h"
+
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/function.h"
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/registry.h"
 #include "arrow/util/checked_cast.h"
-#include "arrow/util/fixed_width_internal.h"
 #include "arrow/util/logging.h"
 
 namespace arrow::compute::internal {
@@ -11,129 +27,80 @@ namespace arrow::compute::internal {
 namespace {
 
 // ----------------------------------------------------------------------
-// ReverseIndex
+// ReverseIndices
 
-const FunctionDoc reverse_index_doc(
-    "Compute the reverse indices from an input indices",
+const FunctionDoc reverse_indices_doc(
+    "Return the reverse indices of the given indices",
     "For the `i`-th `index` in `indices`, the `index`-th output is `i`", {"indices"});
 
-const PermuteOptions* GetDefaultReverseIndexOptions() {
-  static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
-  return &kDefaultPermuteOptions;
+const ReverseIndicesOptions* GetDefaultReverseIndicesOptions() {
+  static const auto kDefaultReverseIndicesOptions = ReverseIndicesOptions::Defaults();
+  return &kDefaultReverseIndicesOptions;
 }
 
-using ReverseIndexState = OptionsWrapper<ReverseIndexOptions>;
-
-// struct ReverseIndexState : public KernelState {
-//   explicit ReverseIndexState(int64_t length, std::shared_ptr<DataType> type,
-//                              std::shared_ptr<Buffer> validity,
-//                              std::shared_ptr<Buffer> data)
-//       : length(length),
-//         type(std::move(type)),
-//         validity(std::move(validity)),
-//         data(std::move(data)) {}
-
-//   const int64_t length = 0;
-//   const std::shared_ptr<DataType> type = nullptr;
-//   const std::shared_ptr<Buffer> validity = nullptr;
-//   const std::shared_ptr<Buffer> data = nullptr;
-// };
-
-// Result<std::unique_ptr<KernelState>> ReverseIndexInit(KernelContext* ctx,
-//                                                       const KernelInitArgs& args) {
-//   auto* options = checked_cast<const ReverseIndexOptions*>(args.options);
-//   DCHECK_NE(options, nullptr);
-
-//   if (options->output_length < 0) {
-//     return Status::Invalid("Output length of reverse_index must be non-negative, got "
-//     +
-//                            std::to_string(options->output_length));
-//   }
-//   if (!options->output_type || !is_integer(options->output_type->id())) {
-//     return Status::Invalid(
-//         "Output type of reverse_index must be integer, got " +
-//         (options->output_type ? options->output_type->ToString() : "null"));
-//   }
-//   if (options->output_non_taken &&
-//       !options->output_non_taken->type->Equals(options->output_type)) {
-//     return Status::Invalid(
-//         "Output non-taken of reverse_index must be of the same type with the output "
-//         "type, got " +
-//         options->output_non_taken->type->ToString());
-//   }
-
-//   std::shared_ptr<Buffer> validity = nullptr;
-//   ARROW_ASSIGN_OR_RAISE(auto data, ctx->Allocate(options->output_length *
-//                                                  options->output_type->byte_width()));
-//   if (!options->output_non_taken || !options->output_non_taken->is_valid) {
-//     ARROW_ASSIGN_OR_RAISE(validity, ctx->AllocateBitmap(options->output_length));
-//     std::memset(validity->mutable_data(), 0, options->output_length);
-//   } else {
-//     auto int_scalar = checked_cast<const arrow::internal::PrimitiveScalarBase*>(
-//         options->output_non_taken.get());
-//     for (int64_t i = 0; i < options->output_length; ++i) {
-//       std::memcpy(data->mutable_data() + int_scalar->type->byte_width() * i,
-//                   int_scalar->data(), int_scalar->type->byte_width());
-//     }
-//   }
-//   auto state = std::make_unique<ReverseIndexState>(
-//       options->output_length, options->output_type, std::move(validity),
-//       std::move(data));
-//   return state;
-// }
-
-/// \brief The OutputType::Resolver of the "reverse_index" function.
-Result<TypeHolder> ResolveReverseIndexOutputType(KernelContext* ctx,
-                                                 const std::vector<TypeHolder>&) {
-  const auto& output_type = ReverseIndexState::Get(ctx).output_type;
+using ReverseIndicesState = OptionsWrapper<ReverseIndicesOptions>;
+
+Result<TypeHolder> ResolveReverseIndicesOutputType(
+    KernelContext* ctx, const std::vector<TypeHolder>& input_types) {
+  DCHECK_EQ(input_types.size(), 1);
+  DCHECK_NE(input_types[0], nullptr);
+
+  const DataType* output_type = ReverseIndicesState::Get(ctx).output_type.get();
   if (!output_type) {
-    return Status::Invalid("Output type of reverse_index must not be null");
+    output_type = input_types[0].type;
   }
   if (!is_integer(output_type->id())) {
-    return Status::Invalid("Output type of reverse_index must be integer, got " +
+    return Status::Invalid("Output type of reverse_indices must be integer, got " +
                            output_type->ToString());
   }
-  return TypeHolder(output_type);
+
+  return TypeHolder(output_type->GetSharedPtr());
 }
 
 template <typename ExecType>
-struct ReverseIndexImpl {
-  using ThisType = ReverseIndexImpl<ExecType>;
+struct ReverseIndicesImpl {
+  using ThisType = ReverseIndicesImpl<ExecType>;
   using IndexType = typename ExecType::IndexType;
   using IndexCType = typename IndexType::c_type;
   using ShapeType = typename ExecType::ShapeType;
 
-  static Result<std::shared_ptr<ArrayData>> Exec(KernelContext* ctx,
-                                                 const ShapeType& indices,
-                                                 int64_t length) {
-    const auto& options = ReverseIndexState::Get(ctx);
+  static Result<std::shared_ptr<ArrayData>> Exec(
+      KernelContext* ctx, const ShapeType& indices, int64_t input_length,
+      const std::shared_ptr<DataType>& input_type) {
+    const auto& options = ReverseIndicesState::Get(ctx);
 
     int64_t output_length = options.output_length;
     if (output_length < 0) {
-      output_length = length;
+      output_length = input_length;
+    }
+    std::shared_ptr<DataType> output_type = options.output_type;
+    if (!output_type) {
+      output_type = input_type;
     }
 
-    ThisType impl(ctx, indices, length, output_length);
-    RETURN_NOT_OK(VisitTypeInline(*options.output_type, &impl));
+    ThisType impl(ctx, indices, input_length, output_length);
+    RETURN_NOT_OK(VisitTypeInline(*output_type, &impl));
 
-    return ArrayData::Make(options.output_type, options.output_length,
+    return ArrayData::Make(std::move(output_type), output_length,
                            {std::move(impl.validity_buf), std::move(impl.data_buf)});
   }
 
  private:
   KernelContext* ctx;
   const ShapeType& indices;
-  const int64_t length;
+  const int64_t input_length;
   const int64_t output_length;
-  // const std::shared_ptr<DataType> output_type;
 
   std::shared_ptr<Buffer> validity_buf = nullptr;
   std::shared_ptr<Buffer> data_buf = nullptr;
 
  private:
-  ReverseIndexImpl(KernelContext* ctx, const ShapeType& indices, int64_t length,
-                   int64_t output_length)
-      : ctx(ctx), indices(indices), length(length), output_length(output_length) {}
+  ReverseIndicesImpl(KernelContext* ctx, const ShapeType& indices, int64_t input_length,
+                     int64_t output_length)
+      : ctx(ctx),
+        indices(indices),
+        input_length(input_length),
+        output_length(output_length) {}
 
   Status Visit(const DataType& output_type) {
     DCHECK(false) << "Shouldn't reach here";
@@ -152,7 +119,7 @@ struct ReverseIndexImpl {
       RETURN_NOT_OK(AllocateDataBuf(output_type));
     } else {
       RETURN_NOT_OK(
-          AllocateDataBufAndFill(output_type, static_cast<OutputCType>(length)));
+          AllocateDataBufAndFill(output_type, static_cast<OutputCType>(input_length)));
     }
     if (likely_many_nulls) {
       return Execute<Type, true>();
@@ -165,17 +132,17 @@ struct ReverseIndexImpl {
   Status CheckInput(const Type& output_type) {
     using OutputCType = typename Type::c_type;
 
-    if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < length) {
+    if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length) {
       return Status::Invalid(
           "Output type " + output_type.ToString() +
-          " of reverse_index is insufficient to store indices of length " +
-          std::to_string(length));
+          " of reverse_indices is insufficient to store indices of length " +
+          std::to_string(input_length));
     }
 
     return Status::OK();
   }
 
-  bool IsLikelyManyNulls() { return output_length > 2 * length; }
+  bool IsLikelyManyNulls() { return output_length > 2 * input_length; }
 
   Status AllocateValidityBufAndFill(bool valid) {
     DCHECK_EQ(validity_buf, nullptr);
@@ -242,7 +209,7 @@ struct ReverseIndexImpl {
 
     if constexpr (!likely_many_nulls) {
       for (int64_t i = 0; i < output_length; ++i) {
-        if (data[i] == static_cast<OutputCType>(length)) {
+        if (data[i] == static_cast<OutputCType>(input_length)) {
           if (ARROW_PREDICT_FALSE(!validity_buf)) {
             RETURN_NOT_OK(AllocateValidityBufAndFill(true));
             validity = validity_buf->mutable_data_as<uint8_t>();
@@ -260,8 +227,8 @@ struct ReverseIndexImpl {
 };
 
 template <typename Ignored, typename Type>
-struct ReverseIndex {
-  using ThisType = ReverseIndex<Ignored, Type>;
+struct ReverseIndices {
+  using ThisType = ReverseIndices<Ignored, Type>;
   using IndexType = Type;
   using ShapeType = ArraySpan;
 
@@ -272,21 +239,20 @@ struct ReverseIndex {
                                            std::forward<NullFunc>(null_func));
   }
 
-  static int64_t IndicesLength(const ShapeType& indices) { return indices.length; }
-
   static Status Exec(KernelContext* ctx, const ExecSpan& span, ExecResult* result) {
     DCHECK(span[0].is_array());
     const auto& indices = span[0].array;
-    ARROW_ASSIGN_OR_RAISE(auto output,
-                          ReverseIndexImpl<ThisType>::Exec(ctx, indices, indices.length));
+    ARROW_ASSIGN_OR_RAISE(
+        auto output, ReverseIndicesImpl<ThisType>::Exec(ctx, indices, indices.length,
+                                                        indices.type->GetSharedPtr()));
     result->value = std::move(output);
     return Status::OK();
   }
 };
 
 template <typename Ignored, typename Type>
-struct ReverseIndexChunked {
-  using ThisType = ReverseIndexChunked<Ignored, Type>;
+struct ReverseIndicesChunked {
+  using ThisType = ReverseIndicesChunked<Ignored, Type>;
   using IndexType = Type;
   using ShapeType = std::shared_ptr<ChunkedArray>;
 
@@ -301,25 +267,48 @@ struct ReverseIndexChunked {
     return Status::OK();
   }
 
-  static int64_t IndicesLength(const ShapeType& indices) { return indices->length(); }
-
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* result) {
     DCHECK(batch[0].is_chunked_array());
     const auto& indices = batch[0].chunked_array();
     ARROW_ASSIGN_OR_RAISE(
-        auto output, ReverseIndexImpl<ThisType>::Exec(ctx, indices, indices->length()));
+        auto output, ReverseIndicesImpl<ThisType>::Exec(ctx, indices, indices->length(),
+                                                        indices->type()));
     *result = std::move(output);
     return Status::OK();
   }
 };
 
+void RegisterVectorReverseIndices(FunctionRegistry* registry) {
+  auto function = std::make_shared<VectorFunction>("reverse_indices", Arity::Unary(),
+                                                   reverse_indices_doc,
+                                                   GetDefaultReverseIndicesOptions());
+
+  auto add_kernel = [&function](Type::type type_id) {
+    VectorKernel kernel;
+    kernel.signature = KernelSignature::Make({InputType(match::SameTypeId(type_id))},
+                                             OutputType(ResolveReverseIndicesOutputType));
+    kernel.init = ReverseIndicesState::Init;
+    kernel.exec = GenerateInteger<ReverseIndices, void, ArrayKernelExec>(type_id);
+    kernel.exec_chunked =
+        GenerateInteger<ReverseIndicesChunked, void, VectorKernel::ChunkedExec>(type_id);
+    kernel.can_execute_chunkwise = false;
+    kernel.output_chunked = false;
+    DCHECK_OK(function->AddKernel(std::move(kernel)));
+  };
+  for (const auto& ty : IntTypes()) {
+    add_kernel(ty->id());
+  }
+
+  DCHECK_OK(registry->AddFunction(std::move(function)));
+}
+
 // ----------------------------------------------------------------------
 // Permute
 
 const FunctionDoc permute_doc(
-    "Permute values of an input based on indices from another array",
-    "Place each input value to the output array at position specified by `indices`",
-    {"input", "indices"});
+    "Permute the values into specified positions according to the indices",
+    "Place the `i`-th value at the position specified by the `i`-th index",
+    {"values", "indices"});
 
 const PermuteOptions* GetDefaultPermuteOptions() {
   static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
@@ -349,51 +338,30 @@ class PermuteMetaFunction : public MetaFunction {
     }
     int64_t output_length = permute_options->output_length;
     if (output_length < 0) {
-      return Status::Invalid("Output length of permute must be non-negative, got " +
-                             std::to_string(output_length));
-    }
-    std::shared_ptr<Scalar> output_non_taken = nullptr;
-    if (is_signed_integer(indices.type()->id())) {
-      // Using -1 (as opposed to null) as output_non_taken for signed integer types to
-      // enable efficient reverse_index.
-      ARROW_ASSIGN_OR_RAISE(output_non_taken, MakeScalar(indices.type(), 0));
+      output_length = values.length();
     }
-    ReverseIndexOptions reverse_index_options{output_length, indices.type(),
-                                              std::move(output_non_taken)};
+    ReverseIndicesOptions reverse_indices_options{
+        output_length, InferSmallestReverseIndicesType(values.length())};
     ARROW_ASSIGN_OR_RAISE(
         auto reverse_indices,
-        CallFunction("reverse_index", {indices}, &reverse_index_options, ctx));
+        CallFunction("reverse_indices", {indices}, &reverse_indices_options, ctx));
     TakeOptions take_options{/*boundcheck=*/false};
     return CallFunction("take", {values, reverse_indices}, &take_options, ctx);
   }
-};
 
-// ----------------------------------------------------------------------
-
-void RegisterVectorReverseIndex(FunctionRegistry* registry) {
-  auto function =
-      std::make_shared<VectorFunction>("reverse_index", Arity::Unary(), reverse_index_doc,
-                                       GetDefaultReverseIndexOptions());
-
-  auto add_kernel = [&function](Type::type type_id) {
-    VectorKernel kernel;
-    kernel.signature = KernelSignature::Make({InputType(match::SameTypeId(type_id))},
-                                             OutputType(ResolveReverseIndexOutputType));
-    kernel.init = ReverseIndexState::Init;
-    // kernel.init = ReverseIndexInit;
-    kernel.exec = GenerateInteger<ReverseIndex, void, ArrayKernelExec>(type_id);
-    kernel.exec_chunked =
-        GenerateInteger<ReverseIndexChunked, void, VectorKernel::ChunkedExec>(type_id);
-    kernel.can_execute_chunkwise = false;
-    kernel.output_chunked = false;
-    DCHECK_OK(function->AddKernel(std::move(kernel)));
-  };
-  for (const auto& ty : IntTypes()) {
-    add_kernel(ty->id());
+ private:
+  static std::shared_ptr<DataType> InferSmallestReverseIndicesType(int64_t input_length) {
+    if (input_length <= std::numeric_limits<int8_t>::max()) {
+      return int8();
+    } else if (input_length <= std::numeric_limits<int16_t>::max()) {
+      return int16();
+    } else if (input_length <= std::numeric_limits<int32_t>::max()) {
+      return int32();
+    } else {
+      return int64();
+    }
   }
-
-  DCHECK_OK(registry->AddFunction(std::move(function)));
-}
+};
 
 void RegisterVectorPermute(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::make_shared<PermuteMetaFunction>()));
@@ -401,8 +369,10 @@ void RegisterVectorPermute(FunctionRegistry* registry) {
 
 }  // namespace
 
+// ----------------------------------------------------------------------
+
 void RegisterVectorPlacement(FunctionRegistry* registry) {
-  RegisterVectorReverseIndex(registry);
+  RegisterVectorReverseIndices(registry);
   RegisterVectorPermute(registry);
 }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index 8c19a3ef61ffa..32757ed0439e9 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -1,121 +1,141 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
 
 #include <gtest/gtest.h>
 
 #include "arrow/chunked_array.h"
-#include "arrow/compute/api.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/test_util.h"
-#include "arrow/result.h"
 #include "arrow/testing/generator.h"
 #include "arrow/testing/gtest_util.h"
-#include "arrow/util/checked_cast.h"
 
 namespace arrow::compute {
 
-TEST(ReverseIndex, Invalid) {
-  {
-    auto indices = ArrayFromJSON(int32(), "[]");
-    ReverseIndexOptions options{0, nullptr};
-    ASSERT_RAISES_WITH_MESSAGE(Invalid,
-                               "Invalid: Output type of reverse_index must not be null",
-                               CallFunction("reverse_index", {indices}, &options));
-  }
+// ----------------------------------------------------------------------
+// ReverseIndices tests
+
+TEST(ReverseIndices, Invalid) {
   {
     auto indices = ArrayFromJSON(int32(), "[]");
-    ReverseIndexOptions options{0, utf8()};
+    ReverseIndicesOptions options{0, utf8()};
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid, "Invalid: Output type of reverse_index must be integer, got string",
-        CallFunction("reverse_index", {indices}, &options));
+        Invalid, "Invalid: Output type of reverse_indices must be integer, got string",
+        CallFunction("reverse_indices", {indices}, &options));
   }
 }
 
-TEST(ReverseIndex, Basic) {
+TEST(ReverseIndices, DefaultOptions) {
   {
-    auto indices = ArrayFromJSON(int32(), "[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]");
-    auto expected = ArrayFromJSON(int8(), "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]");
-    ReverseIndexOptions options{10, int8()};
+    ReverseIndicesOptions options;
+    ASSERT_EQ(options.output_length, -1);
+    ASSERT_EQ(options.output_type, nullptr);
+  }
+  {
+    auto indices = ArrayFromJSON(int32(), "[0]");
+    ReverseIndicesOptions options;
     ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+                         CallFunction("reverse_indices", {indices}, &options));
+    ASSERT_EQ(result.length(), 1);
+    ASSERT_EQ(result.type()->id(), Type::INT32);
   }
+}
+
+TEST(ReverseIndices, Basic) {
   {
-    auto indices = ArrayFromJSON(int32(), "[1, 2]");
-    auto expected = ArrayFromJSON(int8(), "[null, 0, 1, null, null, null, null]");
-    ReverseIndexOptions options{7, int8()};
+    auto indices = ArrayFromJSON(int32(), "[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]");
+    auto expected = ArrayFromJSON(int8(), "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]");
+    ReverseIndicesOptions options{10, int8()};
     ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
+                         CallFunction("reverse_indices", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
   {
     auto indices = ArrayFromJSON(int32(), "[1, 2]");
     auto expected = ArrayFromJSON(int8(), "[null, 0, 1, null, null, null, null]");
-    ReverseIndexOptions options{7, int8(), MakeNullScalar(int8())};
+    ReverseIndicesOptions options{7, int8()};
     ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
+                         CallFunction("reverse_indices", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
   {
     auto indices = ArrayFromJSON(int32(), "[1, 2]");
     auto expected = ArrayFromJSON(int8(), "[]");
-    ReverseIndexOptions options{0, int8()};
+    ReverseIndicesOptions options{0, int8()};
     ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
+                         CallFunction("reverse_indices", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
   {
     auto indices = ArrayFromJSON(int32(), "[1, 0]");
     auto expected = ArrayFromJSON(int8(), "[1]");
-    ReverseIndexOptions options{1, int8()};
+    ReverseIndicesOptions options{1, int8()};
     ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
+                         CallFunction("reverse_indices", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
   {
     auto indices = ArrayFromJSON(int32(), "[1, 2]");
     auto expected = ArrayFromJSON(int8(), "[null]");
-    ReverseIndexOptions options{1, int8()};
+    ReverseIndicesOptions options{1, int8()};
     ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
+                         CallFunction("reverse_indices", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
   {
     auto indices = ArrayFromJSON(int32(), "[]");
     auto expected = ArrayFromJSON(int8(), "[null, null, null, null, null, null, null]");
-    ReverseIndexOptions options{7, int8()};
+    ReverseIndicesOptions options{7, int8()};
     ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
+                         CallFunction("reverse_indices", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
 }
 
-TEST(ReverseIndex, Overflow) {
+TEST(ReverseIndices, Overflow) {
   {
     auto indices = ConstantArrayGenerator::Zeroes(127, int8());
     auto expected = ArrayFromJSON(int8(), "[126]");
-    ReverseIndexOptions options{1, int8()};
+    ReverseIndicesOptions options{1, int8()};
     ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_index", {indices}, &options));
+                         CallFunction("reverse_indices", {indices}, &options));
     AssertDatumsEqual(expected, result);
   }
   {
     auto indices = ConstantArrayGenerator::Zeroes(128, int8());
-    ReverseIndexOptions options{1, int8()};
+    ReverseIndicesOptions options{1, int8()};
     ASSERT_RAISES_WITH_MESSAGE(Invalid,
-                               "Invalid: Output type int8 of reverse_index is "
+                               "Invalid: Output type int8 of reverse_indices is "
                                "insufficient to store indices of length 128",
-                               CallFunction("reverse_index", {indices}, &options));
+                               CallFunction("reverse_indices", {indices}, &options));
   }
   {
     ASSERT_OK_AND_ASSIGN(auto indices, MakeArrayOfNull(int8(), 128));
     auto expected = ArrayFromJSON(int8(), "[null]");
-    ReverseIndexOptions options{1, int8()};
+    ReverseIndicesOptions options{1, int8()};
     ASSERT_RAISES_WITH_MESSAGE(Invalid,
-                               "Invalid: Output type int8 of reverse_index is "
+                               "Invalid: Output type int8 of reverse_indices is "
                                "insufficient to store indices of length 128",
-                               CallFunction("reverse_index", {indices}, &options));
+                               CallFunction("reverse_indices", {indices}, &options));
   }
 }
 
+// ----------------------------------------------------------------------
+// Permute tests
+
 TEST(Permute, Basic) {
   {
     auto values = ArrayFromJSON(int64(), "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]");

From b31f9f2b7a132bd96101edb9054213daeeaeaf21 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 02:16:57 +0800
Subject: [PATCH 12/54] Update docs

---
 cpp/src/arrow/compute/api_vector.h | 19 ++++++++++---------
 docs/source/cpp/compute.rst        | 19 +++++++++++--------
 2 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 61d7cd7b88880..3d59b7627fd1b 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -738,10 +738,10 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
 
 /// \brief Return the reverse indices of the given indices.
 ///
-/// For indices[i] = x, reverse_indices[x] = i. And reverse_indices[x] = null if
-/// x does not appear in the indices. For indices[i] = x where x < 0 or x >=
-/// output_length, it is ignored. If multiple indices point to the same value, the last
-/// one is used.
+/// For indices[i] = x, reverse_indices[x] = i. And reverse_indices[x] = null if x does
+/// not appear in the input indices. For indices[i] = x where x < 0 or x >= output_length,
+/// it is ignored. If multiple indices point to the same value, the last one is used.
+///
 /// For example, with indices = [null, 0, 3, 2, 4, 1, 1], the reverse indices is
 ///   [1, 6, 3]                    if output_length = 3,
 ///   [1, 6, 3, 2, 4, null, null]  if output_length = 7.
@@ -762,11 +762,12 @@ Result<std::shared_ptr<Array>> ReverseIndices(
 
 /// \brief Permute the values into specified positions according to the indices.
 ///
-/// For indices[i] = x, output[x] = values[i]. And output[x] = null if
-/// x does not appear in the indices. For indices[i] = x where x < 0 or x >=
-/// output_length, values[i] is ignored.
-/// For example, with values = [a, b, c, d, e, f, g] and indices = [null, 0, 3, 2, 4, 1,
-/// 1], the permutation is
+/// For indices[i] = x, output[x] = values[i]. And output[x] = null if x does not appear
+/// in the input indices. For indices[i] = x where x < 0 or x >= output_length, values[i]
+/// is ignored.
+///
+/// For example, with values = [a, b, c, d, e, f, g] and indices = [null, 0,
+/// 3, 2, 4, 1, 1], the permutation is
 ///   [b, g, d]                    if output_length = 3,
 ///   [b, g, d, c, e, null, null]  if output_length = 7.
 /// output_length can also be negative, in which case the permutation is of the same
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 7df0027121eaf..63ceda88978f9 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1908,15 +1908,18 @@ indices.
 +-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
 | Function name   | Arity  | Input type 1 | Input type 2 | Output type  | Options class                   | Notes |
 +=================+========+==============+==============+==============+=================================+=======+
-| reverse_indices | Unary  | Integer      |              | Integer      | :struct:`ReverseIndicesOptions` | \(1)  |
+| reverse_indices | Unary  | Integer      |              | Integer \(1) | :struct:`ReverseIndicesOptions` | \(2)  |
 +-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
-| permute         | Binary | Any          | Integer      | Input type 1 | :struct:`PermuteOptions`        | \(2)  |
+| permute         | Binary | Any          | Integer      | Input type 1 | :struct:`PermuteOptions`        | \(3)  |
 +-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
 
-* \(1) Each element in the input is appended to the output iff it is non-null.
-  If the input is a record batch or table, any null value in a column drops
-  the entire row.
+* \(1) The output type is specified in :struct:`ReverseIndicesOptions`.
 
-* \(2) Each element in input 1 (the values) is appended to the output iff
-  the corresponding element in input 2 (the filter) is true.  How
-  nulls in the filter are handled can be configured using FilterOptions.
+* \(2) For ``indices[i] = x``, ``reverse_indices[x] = i``. And ``reverse_indices[x]
+ = null`` if ``x`` does not appear in the input ``indices``. For ``indices[i] = x``
+ where ``x < 0`` or ``x >= output_length``, it is ignored. If multiple indices point
+ to the same value, the last one is used.
+
+* \(3) For ``indices[i] = x``, ``output[x] = values[i]``. And ``output[x] = null``
+if ``x`` does not appear in the input ``indices``. For ``indices[i] = x`` where
+``x < 0`` or ``x >= output_length``, ``values[i]`` is ignored.

From b951348f03085b00e99d313f1c39361334f5c8d2 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 13:49:32 +0800
Subject: [PATCH 13/54] Refine doc

---
 docs/source/cpp/compute.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 63ceda88978f9..17700c9412813 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1900,7 +1900,7 @@ operation to the n-th and (n+abs(p))-th inputs.
 * \(3) Returns an ``Invalid`` :class:`Status` when overflow is detected.
 
 Placement functions
-~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~
 
 Placement functions reorder the input array based on placement arguments, e.g.
 indices.

From 520b952385f2d620b3634df0cb30af6fec85f354 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 16:21:46 +0800
Subject: [PATCH 14/54] Add comments for the implementation

---
 cpp/src/arrow/compute/api_vector.h            |  2 +-
 .../arrow/compute/kernels/vector_placement.cc | 75 +++++++++++++------
 docs/source/cpp/compute.rst                   |  3 +-
 3 files changed, 55 insertions(+), 25 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 3d59b7627fd1b..a31f855a3f891 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -764,7 +764,7 @@ Result<std::shared_ptr<Array>> ReverseIndices(
 ///
 /// For indices[i] = x, output[x] = values[i]. And output[x] = null if x does not appear
 /// in the input indices. For indices[i] = x where x < 0 or x >= output_length, values[i]
-/// is ignored.
+/// is ignored. If multiple indices point to the same value, the last one is used.
 ///
 /// For example, with values = [a, b, c, d, e, f, g] and indices = [null, 0,
 /// 3, 2, 4, 1, 1], the permutation is
diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index 199fa02c0b61d..4ca1288e98140 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -40,21 +40,23 @@ const ReverseIndicesOptions* GetDefaultReverseIndicesOptions() {
 
 using ReverseIndicesState = OptionsWrapper<ReverseIndicesOptions>;
 
+/// Resolve the output type of reverse_indices. The output type is specified in the
+/// options, and if null, set it to the input type. The output type must be integer.
 Result<TypeHolder> ResolveReverseIndicesOutputType(
     KernelContext* ctx, const std::vector<TypeHolder>& input_types) {
   DCHECK_EQ(input_types.size(), 1);
   DCHECK_NE(input_types[0], nullptr);
 
-  const DataType* output_type = ReverseIndicesState::Get(ctx).output_type.get();
+  std::shared_ptr<DataType> output_type = ReverseIndicesState::Get(ctx).output_type;
   if (!output_type) {
-    output_type = input_types[0].type;
+    output_type = input_types[0].owned_type;
   }
   if (!is_integer(output_type->id())) {
     return Status::Invalid("Output type of reverse_indices must be integer, got " +
                            output_type->ToString());
   }
 
-  return TypeHolder(output_type->GetSharedPtr());
+  return TypeHolder(std::move(output_type));
 }
 
 template <typename ExecType>
@@ -69,6 +71,7 @@ struct ReverseIndicesImpl {
       const std::shared_ptr<DataType>& input_type) {
     const auto& options = ReverseIndicesState::Get(ctx);
 
+    // Apply default options semantics.
     int64_t output_length = options.output_length;
     if (output_length < 0) {
       output_length = input_length;
@@ -113,7 +116,16 @@ struct ReverseIndicesImpl {
 
     RETURN_NOT_OK(CheckInput(output_type));
 
-    bool likely_many_nulls = IsLikelyManyNulls();
+    // Dispatch the execution based on wether there are likely many nulls in the output.
+    // - If many nulls (i.e. the output is "sparse"), preallocate an all-false validity
+    // buffer and an uninitialized data buffer. The subsequent processing will fill the
+    // valid values only.
+    // - Otherwise (i.e. the output is "dense"), the validity buffer is lazily allocated
+    // and filled all-true in the subsequent processing only when needed. The data buffer
+    // is preallocated and filled with an "impossible" value (input_length - note that the
+    // range of reverse_indices is [0, input_length)) for the subsequent processing to
+    // detect validity.
+    bool likely_many_nulls = LikelyManyNulls();
     if (likely_many_nulls) {
       RETURN_NOT_OK(AllocateValidityBufAndFill(false));
       RETURN_NOT_OK(AllocateDataBuf(output_type));
@@ -142,7 +154,7 @@ struct ReverseIndicesImpl {
     return Status::OK();
   }
 
-  bool IsLikelyManyNulls() { return output_length > 2 * input_length; }
+  bool LikelyManyNulls() { return output_length > 2 * input_length; }
 
   Status AllocateValidityBufAndFill(bool valid) {
     DCHECK_EQ(validity_buf, nullptr);
@@ -195,6 +207,7 @@ struct ReverseIndicesImpl {
           if (ARROW_PREDICT_TRUE(index >= 0 &&
                                  static_cast<int64_t>(index) < output_length)) {
             data[index] = static_cast<OutputCType>(reverse_index);
+            // If many nulls, set validity to true for valid values.
             if constexpr (likely_many_nulls) {
               bit_util::SetBitTo(validity, index, true);
             }
@@ -207,9 +220,12 @@ struct ReverseIndicesImpl {
           return Status::OK();
         }));
 
+    // If not many nulls, run another pass iterating over the data to set the validity to
+    // false if the value is "impossible". The validity buffer is allocated and filled
+    // all-true on-the-fly when the first "impossible" value is seen.
     if constexpr (!likely_many_nulls) {
       for (int64_t i = 0; i < output_length; ++i) {
-        if (data[i] == static_cast<OutputCType>(input_length)) {
+        if (ARROW_PREDICT_FALSE(data[i] == static_cast<OutputCType>(input_length))) {
           if (ARROW_PREDICT_FALSE(!validity_buf)) {
             RETURN_NOT_OK(AllocateValidityBufAndFill(true));
             validity = validity_buf->mutable_data_as<uint8_t>();
@@ -240,12 +256,12 @@ struct ReverseIndices {
   }
 
   static Status Exec(KernelContext* ctx, const ExecSpan& span, ExecResult* result) {
+    DCHECK_EQ(span.num_values(), 1);
     DCHECK(span[0].is_array());
     const auto& indices = span[0].array;
     ARROW_ASSIGN_OR_RAISE(
-        auto output, ReverseIndicesImpl<ThisType>::Exec(ctx, indices, indices.length,
-                                                        indices.type->GetSharedPtr()));
-    result->value = std::move(output);
+        result->value, ReverseIndicesImpl<ThisType>::Exec(ctx, indices, indices.length,
+                                                          indices.type->GetSharedPtr()));
     return Status::OK();
   }
 };
@@ -268,12 +284,11 @@ struct ReverseIndicesChunked {
   }
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* result) {
+    DCHECK_EQ(batch.num_values(), 1);
     DCHECK(batch[0].is_chunked_array());
     const auto& indices = batch[0].chunked_array();
-    ARROW_ASSIGN_OR_RAISE(
-        auto output, ReverseIndicesImpl<ThisType>::Exec(ctx, indices, indices->length(),
-                                                        indices->type()));
-    *result = std::move(output);
+    ARROW_ASSIGN_OR_RAISE(*result, ReverseIndicesImpl<ThisType>::Exec(
+                                       ctx, indices, indices->length(), indices->type()));
     return Status::OK();
   }
 };
@@ -295,8 +310,8 @@ void RegisterVectorReverseIndices(FunctionRegistry* registry) {
     kernel.output_chunked = false;
     DCHECK_OK(function->AddKernel(std::move(kernel)));
   };
-  for (const auto& ty : IntTypes()) {
-    add_kernel(ty->id());
+  for (const auto& t : IntTypes()) {
+    add_kernel(t->id());
   }
 
   DCHECK_OK(registry->AddFunction(std::move(function)));
@@ -324,6 +339,7 @@ class PermuteMetaFunction : public MetaFunction {
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
                             ExecContext* ctx) const override {
+    DCHECK_EQ(args.size(), 2);
     const auto& values = args[0];
     const auto& indices = args[1];
     auto* permute_options = checked_cast<const PermuteOptions*>(options);
@@ -336,12 +352,25 @@ class PermuteMetaFunction : public MetaFunction {
       return Status::Invalid("Indices of permute must be of integer type, got ",
                              indices.type()->ToString());
     }
+    // Apply default options semantics.
     int64_t output_length = permute_options->output_length;
     if (output_length < 0) {
       output_length = values.length();
     }
+    // Internally invoke take(values, reverse_indices(indices)) to implement permute.
+    // For example, with
+    //   values = [a, b, c, d, e, f, g]
+    //   indices = [null, 0, 3, 2, 4, 1, 1]
+    // the reverse_indices(indices) is
+    //   [1, 6, 3]                    if output_length = 3,
+    //   [1, 6, 3, 2, 4, null, null]  if output_length = 7.
+    // and take(values, reverse_indices(indices)) is
+    //   [b, g, d]                    if output_length = 3,
+    //   [b, g, d, c, e, null, null]  if output_length = 7.
     ReverseIndicesOptions reverse_indices_options{
-        output_length, InferSmallestReverseIndicesType(values.length())};
+        output_length,
+        // Use the smallest possible uint type to store reverse indices.
+        InferSmallestReverseIndicesType(values.length())};
     ARROW_ASSIGN_OR_RAISE(
         auto reverse_indices,
         CallFunction("reverse_indices", {indices}, &reverse_indices_options, ctx));
@@ -351,14 +380,14 @@ class PermuteMetaFunction : public MetaFunction {
 
  private:
   static std::shared_ptr<DataType> InferSmallestReverseIndicesType(int64_t input_length) {
-    if (input_length <= std::numeric_limits<int8_t>::max()) {
-      return int8();
-    } else if (input_length <= std::numeric_limits<int16_t>::max()) {
-      return int16();
-    } else if (input_length <= std::numeric_limits<int32_t>::max()) {
-      return int32();
+    if (input_length <= std::numeric_limits<uint8_t>::max()) {
+      return uint8();
+    } else if (input_length <= std::numeric_limits<uint16_t>::max()) {
+      return uint16();
+    } else if (input_length <= std::numeric_limits<uint32_t>::max()) {
+      return uint32();
     } else {
-      return int64();
+      return uint64();
     }
   }
 };
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 17700c9412813..ccd605e121a89 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1922,4 +1922,5 @@ indices.
 
 * \(3) For ``indices[i] = x``, ``output[x] = values[i]``. And ``output[x] = null``
 if ``x`` does not appear in the input ``indices``. For ``indices[i] = x`` where
-``x < 0`` or ``x >= output_length``, ``values[i]`` is ignored.
+``x < 0`` or ``x >= output_length``, ``values[i]`` is ignored. If multiple indices
+point to the same value, the last one is used.

From b450f5edcf27233917355bcbf2af2db65c71d1c8 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 16:39:20 +0800
Subject: [PATCH 15/54] Refine docs

---
 cpp/src/arrow/compute/api_vector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index a31f855a3f891..fcc81ba3c687d 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -270,7 +270,7 @@ class ARROW_EXPORT ReverseIndicesOptions : public FunctionOptions {
   /// length will be ignored.
   int64_t output_length = -1;
   /// \brief The type of the output reverse indices. If null, the output will be of the
-  /// same type as the input indices, otherwise must be integer types. An overflow error
+  /// same type as the input indices, otherwise must be integer types. An invalid error
   /// will be reported if this type is not able to store the length of the input indices.
   std::shared_ptr<DataType> output_type = nullptr;
 };

From 4ea1465a8fb308f8462b877b411b3ac096f66c1b Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 20:13:05 +0800
Subject: [PATCH 16/54] Fix uint64 overflow check

---
 .../arrow/compute/kernels/vector_placement.cc  | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index 4ca1288e98140..8bf2b27a07fc8 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -144,11 +144,13 @@ struct ReverseIndicesImpl {
   Status CheckInput(const Type& output_type) {
     using OutputCType = typename Type::c_type;
 
-    if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length) {
-      return Status::Invalid(
-          "Output type " + output_type.ToString() +
-          " of reverse_indices is insufficient to store indices of length " +
-          std::to_string(input_length));
+    if constexpr (!std::is_same_v<OutputCType, uint64_t>) {
+      if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length) {
+        return Status::Invalid(
+            "Output type " + output_type.ToString() +
+            " of reverse_indices is insufficient to store indices of length " +
+            std::to_string(input_length));
+      }
     }
 
     return Status::OK();
@@ -220,9 +222,9 @@ struct ReverseIndicesImpl {
           return Status::OK();
         }));
 
-    // If not many nulls, run another pass iterating over the data to set the validity to
-    // false if the value is "impossible". The validity buffer is allocated and filled
-    // all-true on-the-fly when the first "impossible" value is seen.
+    // If not many nulls, run another pass iterating over the data to set the validity
+    // to false if the value is "impossible". The validity buffer is allocated and
+    // filled all-true on-the-fly when the first "impossible" value is seen.
     if constexpr (!likely_many_nulls) {
       for (int64_t i = 0; i < output_length; ++i) {
         if (ARROW_PREDICT_FALSE(data[i] == static_cast<OutputCType>(input_length))) {

From cbdce2fb6c9fd5806330b02892370dc2dc5ee122 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 20:13:15 +0800
Subject: [PATCH 17/54] Reverse indices tests

---
 .../compute/kernels/vector_placement_test.cc  | 246 +++++++++++++-----
 1 file changed, 178 insertions(+), 68 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index 32757ed0439e9..4e30bcf4a963b 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -28,108 +28,218 @@ namespace arrow::compute {
 // ----------------------------------------------------------------------
 // ReverseIndices tests
 
-TEST(ReverseIndices, Invalid) {
+namespace {
+
+Result<Datum> ReverseIndices(const Datum& indices, int64_t output_length,
+                             std::shared_ptr<DataType> output_type) {
+  ReverseIndicesOptions options{output_length, std::move(output_type)};
+  return ReverseIndices(indices, options);
+}
+
+}  // namespace
+
+TEST(ReverseIndices, InvalidOutputType) {
+  {
+    ARROW_SCOPED_TRACE("Output type float");
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid, "Invalid: Output type of reverse_indices must be integer, got float",
+        ReverseIndices(indices, 0, float32()));
+  }
   {
+    ARROW_SCOPED_TRACE("Output type string");
     auto indices = ArrayFromJSON(int32(), "[]");
-    ReverseIndicesOptions options{0, utf8()};
     ASSERT_RAISES_WITH_MESSAGE(
         Invalid, "Invalid: Output type of reverse_indices must be integer, got string",
-        CallFunction("reverse_indices", {indices}, &options));
+        ReverseIndices(indices, 0, utf8()));
   }
 }
 
+namespace {
+
+static const std::vector<std::shared_ptr<DataType>> kIntegerTypes = {
+    int8(), uint8(), int16(), uint16(), int32(), uint32(), int64(), uint64()};
+
+}  // namespace
+
 TEST(ReverseIndices, DefaultOptions) {
   {
+    ARROW_SCOPED_TRACE("Default options values");
     ReverseIndicesOptions options;
     ASSERT_EQ(options.output_length, -1);
     ASSERT_EQ(options.output_type, nullptr);
   }
   {
-    auto indices = ArrayFromJSON(int32(), "[0]");
-    ReverseIndicesOptions options;
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_indices", {indices}, &options));
-    ASSERT_EQ(result.length(), 1);
-    ASSERT_EQ(result.type()->id(), Type::INT32);
+    ARROW_SCOPED_TRACE("Default options semantics");
+    for (const auto& input_type : kIntegerTypes) {
+      ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+      auto indices = ArrayFromJSON(input_type, "[0]");
+      ASSERT_OK_AND_ASSIGN(Datum result, ReverseIndices(indices));
+      AssertDatumsEqual(result, indices);
+    }
   }
 }
 
-TEST(ReverseIndices, Basic) {
+template <typename ArrowType>
+class TestReverseIndicesSmallOutputType : public ::testing::Test {
+ protected:
+  using CType = typename TypeTraits<ArrowType>::CType;
+
+  std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
+  }
+
+  void JustEnoughOutputType() {
+    auto output_type = type_singleton();
+    ReverseIndicesOptions options{1, output_type};
+    int64_t input_length = static_cast<int64_t>(std::numeric_limits<CType>::max());
+    auto expected = ConstantArrayGenerator::Numeric<ArrowType>(
+        1, static_cast<CType>(input_length - 1));
+    for (const auto& input_type : kIntegerTypes) {
+      ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+      auto indices = ConstantArrayGenerator::Zeroes(input_length, input_type);
+      ASSERT_OK_AND_ASSIGN(Datum result, ReverseIndices(indices, options));
+      AssertDatumsEqual(expected, result);
+    }
+  }
+
+  void InsufficientOutputType() {
+    auto output_type = type_singleton();
+    int64_t input_length = static_cast<int64_t>(std::numeric_limits<CType>::max()) + 1;
+    for (const auto& input_type : kIntegerTypes) {
+      ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+      auto indices = ConstantArrayGenerator::Zeroes(input_length, int64());
+      ReverseIndicesOptions options{1, output_type};
+      ASSERT_RAISES_WITH_MESSAGE(
+          Invalid,
+          "Invalid: Output type " + output_type->ToString() +
+              " of reverse_indices is insufficient to store indices of length " +
+              std::to_string(input_length),
+          ReverseIndices(indices, options));
+    }
+  }
+};
+
+using SmallOutputTypes = ::testing::Types<UInt8Type, UInt16Type, Int8Type, Int16Type>;
+TYPED_TEST_SUITE(TestReverseIndicesSmallOutputType, SmallOutputTypes);
+
+TYPED_TEST(TestReverseIndicesSmallOutputType, JustEnoughOutputType) {
+  this->JustEnoughOutputType();
+}
+
+TYPED_TEST(TestReverseIndicesSmallOutputType, InsufficientOutputType) {
+  this->InsufficientOutputType();
+}
+
+namespace {
+
+template <typename InputString, typename InputShapeFunc>
+void TestReverseIndices(const InputString& indices_str, int64_t output_length,
+                        const std::string& expected_str,
+                        InputShapeFunc&& input_shape_func, bool validity_must_be_null) {
+  for (const auto& input_type : kIntegerTypes) {
+    auto indices = input_shape_func(input_type, indices_str);
+    ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+    for (const auto& output_type : kIntegerTypes) {
+      ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
+      auto expected = ArrayFromJSON(output_type, expected_str);
+      ASSERT_OK_AND_ASSIGN(Datum result,
+                           ReverseIndices(indices, output_length, output_type));
+      AssertDatumsEqual(expected, result);
+      if (validity_must_be_null) {
+        ASSERT_FALSE(result.array()->HasValidityBitmap());
+      }
+    }
+  }
+}
+
+void TestReverseIndices(const std::string& indices_str,
+                        const std::vector<std::string>& indices_chunked_str,
+                        int64_t output_length, const std::string& expected_str,
+                        bool validity_must_be_null = false) {
   {
-    auto indices = ArrayFromJSON(int32(), "[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]");
-    auto expected = ArrayFromJSON(int8(), "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]");
-    ReverseIndicesOptions options{10, int8()};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_indices", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Array");
+    TestReverseIndices(indices_str, output_length, expected_str, ArrayFromJSON,
+                       validity_must_be_null);
   }
   {
-    auto indices = ArrayFromJSON(int32(), "[1, 2]");
-    auto expected = ArrayFromJSON(int8(), "[null, 0, 1, null, null, null, null]");
-    ReverseIndicesOptions options{7, int8()};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_indices", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Chunked");
+    TestReverseIndices(indices_chunked_str, output_length, expected_str,
+                       ChunkedArrayFromJSON, validity_must_be_null);
   }
+}
+
+}  // namespace
+
+TEST(ReverseIndices, Basic) {
   {
-    auto indices = ArrayFromJSON(int32(), "[1, 2]");
-    auto expected = ArrayFromJSON(int8(), "[]");
-    ReverseIndicesOptions options{0, int8()};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_indices", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Basic");
+    auto indices = "[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]";
+    std::vector<std::string> indices_chunked{
+        "[]", "[9, 7, 5, 3, 1]", "[0]", "[2, 4, 6]", "[8]", "[]"};
+    int64_t output_length = 10;
+    auto expected = "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected,
+                       /*validity_must_be_null=*/true);
   }
   {
-    auto indices = ArrayFromJSON(int32(), "[1, 0]");
-    auto expected = ArrayFromJSON(int8(), "[1]");
-    ReverseIndicesOptions options{1, int8()};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_indices", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Empty output");
+    auto indices = "[1, 2]";
+    std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[]", "[2]", "[]"};
+    int64_t output_length = 0;
+    auto expected = "[]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected,
+                       /*validity_must_be_null=*/true);
   }
   {
-    auto indices = ArrayFromJSON(int32(), "[1, 2]");
-    auto expected = ArrayFromJSON(int8(), "[null]");
-    ReverseIndicesOptions options{1, int8()};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_indices", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Output less than input");
+    auto indices = "[1, 0]";
+    std::vector<std::string> indices_chunked{"[]", "[]", "[]", "[1, 0]"};
+    int64_t output_length = 1;
+    auto expected = "[1]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected,
+                       /*validity_must_be_null=*/true);
   }
   {
-    auto indices = ArrayFromJSON(int32(), "[]");
-    auto expected = ArrayFromJSON(int8(), "[null, null, null, null, null, null, null]");
-    ReverseIndicesOptions options{7, int8()};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_indices", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Output greater than input");
+    auto indices = "[1, 2]";
+    std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[2]"};
+    int64_t output_length = 7;
+    auto expected = "[null, 0, 1, null, null, null, null]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected);
   }
-}
-
-TEST(ReverseIndices, Overflow) {
   {
-    auto indices = ConstantArrayGenerator::Zeroes(127, int8());
-    auto expected = ArrayFromJSON(int8(), "[126]");
-    ReverseIndicesOptions options{1, int8()};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("reverse_indices", {indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Input all null");
+    auto indices = "[null, null]";
+    std::vector<std::string> indices_chunked{"[]", "[null]", "[]", "[null]"};
+    int64_t output_length = 1;
+    auto expected = "[null]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output all null");
+    auto indices = "[1, 2]";
+    std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[2]"};
+    int64_t output_length = 1;
+    auto expected = "[null]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected);
   }
   {
-    auto indices = ConstantArrayGenerator::Zeroes(128, int8());
-    ReverseIndicesOptions options{1, int8()};
-    ASSERT_RAISES_WITH_MESSAGE(Invalid,
-                               "Invalid: Output type int8 of reverse_indices is "
-                               "insufficient to store indices of length 128",
-                               CallFunction("reverse_indices", {indices}, &options));
+    ARROW_SCOPED_TRACE("Empty input output null");
+    auto indices = "[]";
+    std::vector<std::string> indices_chunked{"[]", "[]", "[]", "[]"};
+    int64_t output_length = 7;
+    auto expected = "[null, null, null, null, null, null, null]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected);
   }
   {
-    ASSERT_OK_AND_ASSIGN(auto indices, MakeArrayOfNull(int8(), 128));
-    auto expected = ArrayFromJSON(int8(), "[null]");
-    ReverseIndicesOptions options{1, int8()};
-    ASSERT_RAISES_WITH_MESSAGE(Invalid,
-                               "Invalid: Output type int8 of reverse_indices is "
-                               "insufficient to store indices of length 128",
-                               CallFunction("reverse_indices", {indices}, &options));
+    ARROW_SCOPED_TRACE("Input duplicated indices");
+    auto indices = "[1, 2, 3, 1, 2, 3, 1, 2, 3]";
+    std::vector<std::string> indices_chunked{"[]", "[1, 2]", "[3, 1, 2, 3, 1]",
+                                             "[]", "[2]",    "[3]"};
+    int64_t output_length = 5;
+    auto expected = "[null, 6, 7, 8, null]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected);
   }
 }
 

From d2e118a6fd79b0850ed90ef2bdfb281a4777c58a Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 23:32:20 +0800
Subject: [PATCH 18/54] Forbit non-array-like argument

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

diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index 8bf2b27a07fc8..712b3eae0648d 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -343,6 +343,12 @@ class PermuteMetaFunction : public MetaFunction {
                             ExecContext* ctx) const override {
     DCHECK_EQ(args.size(), 2);
     const auto& values = args[0];
+    // Though the way how permute is currently implemented may support record batch or
+    // table, we don't want to promise that yet.
+    if (!values.is_arraylike()) {
+      return Status::NotImplemented("Permute does not support " +
+                                    ToString(values.kind()) + " argument");
+    }
     const auto& indices = args[1];
     auto* permute_options = checked_cast<const PermuteOptions*>(options);
     if (values.length() != indices.length()) {

From 7128a28b9b3eb2378bd4c704229a3400bbb7a330 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Fri, 11 Oct 2024 23:58:50 +0800
Subject: [PATCH 19/54] Fix permute option default

---
 cpp/src/arrow/compute/api_vector.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index fcc81ba3c687d..40e5639874930 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -278,14 +278,14 @@ class ARROW_EXPORT ReverseIndicesOptions : public FunctionOptions {
 /// \brief Options for permute function
 class ARROW_EXPORT PermuteOptions : public FunctionOptions {
  public:
-  explicit PermuteOptions(int64_t output_length = 0);
+  explicit PermuteOptions(int64_t output_length = -1);
   static constexpr char const kTypeName[] = "PermuteOptions";
   static PermuteOptions Defaults() { return PermuteOptions(); }
 
   /// \brief The length of the output permutation. If negative, the output will be of the
   /// same length as the input values (and indices). Any values with indices that are
   /// greater or equal to this length will be ignored.
-  int64_t output_length = 0;
+  int64_t output_length = -1;
 };
 
 /// @}

From 034d3b71ad2f8773e802b3f2ac02b80b5f0b2ff8 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Sat, 12 Oct 2024 00:05:12 +0800
Subject: [PATCH 20/54] Refine

---
 .../arrow/compute/kernels/vector_placement.cc   | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index 712b3eae0648d..2998af3bb1f1c 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -121,21 +121,18 @@ struct ReverseIndicesImpl {
     // buffer and an uninitialized data buffer. The subsequent processing will fill the
     // valid values only.
     // - Otherwise (i.e. the output is "dense"), the validity buffer is lazily allocated
-    // and filled all-true in the subsequent processing only when needed. The data buffer
-    // is preallocated and filled with an "impossible" value (input_length - note that the
-    // range of reverse_indices is [0, input_length)) for the subsequent processing to
-    // detect validity.
+    // and initialized all-true in the subsequent processing only when needed. The data
+    // buffer is preallocated and filled with all "impossible" values (that is,
+    // input_length - note that the range of reverse_indices is [0, input_length)) for the
+    // subsequent processing to detect validity.
     bool likely_many_nulls = LikelyManyNulls();
     if (likely_many_nulls) {
       RETURN_NOT_OK(AllocateValidityBufAndFill(false));
       RETURN_NOT_OK(AllocateDataBuf(output_type));
+      return Execute<Type, true>();
     } else {
       RETURN_NOT_OK(
           AllocateDataBufAndFill(output_type, static_cast<OutputCType>(input_length)));
-    }
-    if (likely_many_nulls) {
-      return Execute<Type, true>();
-    } else {
       return Execute<Type, false>();
     }
   }
@@ -223,8 +220,8 @@ struct ReverseIndicesImpl {
         }));
 
     // If not many nulls, run another pass iterating over the data to set the validity
-    // to false if the value is "impossible". The validity buffer is allocated and
-    // filled all-true on-the-fly when the first "impossible" value is seen.
+    // to false if the value is "impossible". The validity buffer is on demand allocated
+    // and initialized all-true when the first "impossible" value is seen.
     if constexpr (!likely_many_nulls) {
       for (int64_t i = 0; i < output_length; ++i) {
         if (ARROW_PREDICT_FALSE(data[i] == static_cast<OutputCType>(input_length))) {

From 9f93e5ca910b773764a0054f1da201fd7a2bed17 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Sat, 12 Oct 2024 01:45:10 +0800
Subject: [PATCH 21/54] WIP permute tests

---
 .../compute/kernels/vector_placement_test.cc  | 245 ++++++++++++++----
 1 file changed, 190 insertions(+), 55 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index 4e30bcf4a963b..09433e5bd45c6 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -17,6 +17,7 @@
 
 #include <gtest/gtest.h>
 
+#include "arrow/array/concatenate.h"
 #include "arrow/chunked_array.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/test_util.h"
@@ -25,6 +26,15 @@
 
 namespace arrow::compute {
 
+namespace {
+
+static const std::vector<std::shared_ptr<DataType>> kIntegerTypes = {
+    int8(), uint8(), int16(), uint16(), int32(), uint32(), int64(), uint64()};
+
+using SmallOutputTypes = ::testing::Types<UInt8Type, UInt16Type, Int8Type, Int16Type>;
+
+}  // namespace
+
 // ----------------------------------------------------------------------
 // ReverseIndices tests
 
@@ -36,6 +46,42 @@ Result<Datum> ReverseIndices(const Datum& indices, int64_t output_length,
   return ReverseIndices(indices, options);
 }
 
+template <typename InputString, typename InputShapeFunc>
+void TestReverseIndices(const InputString& indices_str, int64_t output_length,
+                        const std::string& expected_str,
+                        InputShapeFunc&& input_shape_func, bool validity_must_be_null) {
+  for (const auto& input_type : kIntegerTypes) {
+    auto indices = input_shape_func(input_type, indices_str);
+    ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+    for (const auto& output_type : kIntegerTypes) {
+      ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
+      auto expected = ArrayFromJSON(output_type, expected_str);
+      ASSERT_OK_AND_ASSIGN(Datum result,
+                           ReverseIndices(indices, output_length, output_type));
+      AssertDatumsEqual(expected, result);
+      if (validity_must_be_null) {
+        ASSERT_FALSE(result.array()->HasValidityBitmap());
+      }
+    }
+  }
+}
+
+void TestReverseIndices(const std::string& indices_str,
+                        const std::vector<std::string>& indices_chunked_str,
+                        int64_t output_length, const std::string& expected_str,
+                        bool validity_must_be_null = false) {
+  {
+    ARROW_SCOPED_TRACE("Array");
+    TestReverseIndices(indices_str, output_length, expected_str, ArrayFromJSON,
+                       validity_must_be_null);
+  }
+  {
+    ARROW_SCOPED_TRACE("Chunked");
+    TestReverseIndices(indices_chunked_str, output_length, expected_str,
+                       ChunkedArrayFromJSON, validity_must_be_null);
+  }
+}
+
 }  // namespace
 
 TEST(ReverseIndices, InvalidOutputType) {
@@ -44,24 +90,17 @@ TEST(ReverseIndices, InvalidOutputType) {
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
         Invalid, "Invalid: Output type of reverse_indices must be integer, got float",
-        ReverseIndices(indices, 0, float32()));
+        ReverseIndices(indices, /*output_length=*/0, /*output_type=*/float32()));
   }
   {
     ARROW_SCOPED_TRACE("Output type string");
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
         Invalid, "Invalid: Output type of reverse_indices must be integer, got string",
-        ReverseIndices(indices, 0, utf8()));
+        ReverseIndices(indices, /*output_length=*/0, /*output_type=*/utf8()));
   }
 }
 
-namespace {
-
-static const std::vector<std::shared_ptr<DataType>> kIntegerTypes = {
-    int8(), uint8(), int16(), uint16(), int32(), uint32(), int64(), uint64()};
-
-}  // namespace
-
 TEST(ReverseIndices, DefaultOptions) {
   {
     ARROW_SCOPED_TRACE("Default options values");
@@ -91,14 +130,14 @@ class TestReverseIndicesSmallOutputType : public ::testing::Test {
 
   void JustEnoughOutputType() {
     auto output_type = type_singleton();
-    ReverseIndicesOptions options{1, output_type};
     int64_t input_length = static_cast<int64_t>(std::numeric_limits<CType>::max());
     auto expected = ConstantArrayGenerator::Numeric<ArrowType>(
-        1, static_cast<CType>(input_length - 1));
+        /*size=*/1, /*value=*/static_cast<CType>(input_length - 1));
     for (const auto& input_type : kIntegerTypes) {
       ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
       auto indices = ConstantArrayGenerator::Zeroes(input_length, input_type);
-      ASSERT_OK_AND_ASSIGN(Datum result, ReverseIndices(indices, options));
+      ASSERT_OK_AND_ASSIGN(Datum result,
+                           ReverseIndices(indices, /*output_length=*/1, output_type));
       AssertDatumsEqual(expected, result);
     }
   }
@@ -109,18 +148,16 @@ class TestReverseIndicesSmallOutputType : public ::testing::Test {
     for (const auto& input_type : kIntegerTypes) {
       ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
       auto indices = ConstantArrayGenerator::Zeroes(input_length, int64());
-      ReverseIndicesOptions options{1, output_type};
       ASSERT_RAISES_WITH_MESSAGE(
           Invalid,
           "Invalid: Output type " + output_type->ToString() +
               " of reverse_indices is insufficient to store indices of length " +
               std::to_string(input_length),
-          ReverseIndices(indices, options));
+          ReverseIndices(indices, /*output_length=*/1, output_type));
     }
   }
 };
 
-using SmallOutputTypes = ::testing::Types<UInt8Type, UInt16Type, Int8Type, Int16Type>;
 TYPED_TEST_SUITE(TestReverseIndicesSmallOutputType, SmallOutputTypes);
 
 TYPED_TEST(TestReverseIndicesSmallOutputType, JustEnoughOutputType) {
@@ -131,46 +168,6 @@ TYPED_TEST(TestReverseIndicesSmallOutputType, InsufficientOutputType) {
   this->InsufficientOutputType();
 }
 
-namespace {
-
-template <typename InputString, typename InputShapeFunc>
-void TestReverseIndices(const InputString& indices_str, int64_t output_length,
-                        const std::string& expected_str,
-                        InputShapeFunc&& input_shape_func, bool validity_must_be_null) {
-  for (const auto& input_type : kIntegerTypes) {
-    auto indices = input_shape_func(input_type, indices_str);
-    ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
-    for (const auto& output_type : kIntegerTypes) {
-      ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
-      auto expected = ArrayFromJSON(output_type, expected_str);
-      ASSERT_OK_AND_ASSIGN(Datum result,
-                           ReverseIndices(indices, output_length, output_type));
-      AssertDatumsEqual(expected, result);
-      if (validity_must_be_null) {
-        ASSERT_FALSE(result.array()->HasValidityBitmap());
-      }
-    }
-  }
-}
-
-void TestReverseIndices(const std::string& indices_str,
-                        const std::vector<std::string>& indices_chunked_str,
-                        int64_t output_length, const std::string& expected_str,
-                        bool validity_must_be_null = false) {
-  {
-    ARROW_SCOPED_TRACE("Array");
-    TestReverseIndices(indices_str, output_length, expected_str, ArrayFromJSON,
-                       validity_must_be_null);
-  }
-  {
-    ARROW_SCOPED_TRACE("Chunked");
-    TestReverseIndices(indices_chunked_str, output_length, expected_str,
-                       ChunkedArrayFromJSON, validity_must_be_null);
-  }
-}
-
-}  // namespace
-
 TEST(ReverseIndices, Basic) {
   {
     ARROW_SCOPED_TRACE("Basic");
@@ -246,6 +243,144 @@ TEST(ReverseIndices, Basic) {
 // ----------------------------------------------------------------------
 // Permute tests
 
+namespace {
+
+Result<Datum> Permute(const Datum& values, const Datum& indices, int64_t output_length) {
+  PermuteOptions options{output_length};
+  return Permute(values, indices, options);
+}
+
+void TestPermuteAAA(const Array& values, const Array& indices, int64_t output_length,
+                    const Array& expected) {
+  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+  AssertDatumsEqual(expected, result);
+}
+
+// void TestPermuteAAA(const std::shared_ptr<DataType>& values_type,
+//                     const std::string& values_str, const std::string& indices_str,
+//                     int64_t output_length, const std::string& expected_str) {
+//   auto values = ArrayFromJSON(values_type, values_str);
+//   auto expected = ArrayFromJSON(values_type, expected_str);
+//   for (const auto& indices_type : kIntegerTypes) {
+//     ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
+//     auto indices = ArrayFromJSON(indices_type, indices_str);
+//     TestPermuteAAA(*values, *indices, output_length, *expected);
+//   }
+// }
+
+void TestPermuteCAC(const std::shared_ptr<ChunkedArray>& values, const Array& indices,
+                    int64_t output_length,
+                    const std::shared_ptr<ChunkedArray>& expected) {
+  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+  AssertDatumsEqual(expected, result);
+}
+
+void TestPermuteCACWithArray(const std::shared_ptr<Array>& values,
+                             const std::shared_ptr<Array>& indices, int64_t output_length,
+                             const std::shared_ptr<Array>& expected) {
+  // PermuteAAA(Concat(V, V, V), I') == Concat(PermuteCAC([V, V, V], I'))
+  // where
+  //   V = values
+  //   I = indices
+  //   I' = Concat(I + 2 * output_length, I, I + output_length)
+  auto values3 = ArrayVector{values, values, values};
+  ASSERT_OK_AND_ASSIGN(auto concat_values3, Concatenate(values3));
+  auto chunked_values3 = std::make_shared<ChunkedArray>(values3);
+
+  std::shared_ptr<Array> concat_indices3;
+  {
+    auto double_length =
+        MakeScalar(indices->type(), 2 * values->length()));
+    auto zero = MakeScalar(indices->type(), 0);
+    auto length = MakeScalar(indices->type(), static_cast<int64_t>(values->length()));
+    ASSERT_OK_AND_ASSIGN(auto indices_prefix, Add(indices, *double_length));
+    ASSERT_OK_AND_ASSIGN(auto indices_middle, Add(indices, *zero));
+    ASSERT_OK_AND_ASSIGN(auto indices_suffix, Add(indices, *length));
+    auto indices3 = ArrayVector{
+        indices_prefix.make_array(),
+        indices_middle.make_array(),
+        indices_suffix.make_array(),
+    };
+    ASSERT_OK_AND_ASSIGN(concat_indices3, Concatenate(indices3));
+  }
+
+  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+  AssertDatumsEqual(expected, result);
+}
+
+// void TestPermuteACA(const Array& values, const std::shared_ptr<ChunkedArray>& indices,
+//                     int64_t output_length, const Array& expected) {
+//   ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+//   AssertDatumsEqual(expected, result);
+// }
+
+}  // namespace
+
+TEST(Permute, Invalid) {
+  {
+    ARROW_SCOPED_TRACE("Length mismatch");
+    auto values = ArrayFromJSON(int32(), "[0, 1]");
+    auto indices = ArrayFromJSON(int32(), "[0]");
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid,
+        "Invalid: Input and indices of permute must have the same length, got 2 and 1",
+        Permute(values, indices));
+  }
+  {
+    ARROW_SCOPED_TRACE("Invalid input type");
+    auto values = ArrayFromJSON(int32(), "[0]");
+    auto indices = ArrayFromJSON(utf8(), R"(["a"])");
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid, "Invalid: Indices of permute must be of integer type, got string",
+        Permute(values, indices));
+  }
+}
+
+TEST(Permute, DefaultOptions) {
+  {
+    ARROW_SCOPED_TRACE("Default options values");
+    PermuteOptions options;
+    ASSERT_EQ(options.output_length, -1);
+  }
+  {
+    ARROW_SCOPED_TRACE("Default options semantics");
+    auto values = ArrayFromJSON(utf8(), R"(["a"])");
+    for (const auto& indices_type : kIntegerTypes) {
+      ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
+      auto indices = ArrayFromJSON(indices_type, "[0]");
+      ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices));
+      AssertDatumsEqual(result, values);
+    }
+  }
+}
+
+template <typename ArrowType>
+class TestPermuteSmallIndicesTypes : public ::testing::Test {
+ protected:
+  using CType = typename TypeTraits<ArrowType>::CType;
+
+  std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
+  }
+
+  void MaxIntegerIndex() {
+    auto values = ArrayFromJSON(utf8(), R"(["a"])");
+    auto indices_type = type_singleton();
+    int64_t max_integer = static_cast<int64_t>(std::numeric_limits<CType>::max());
+    auto indices = ConstantArrayGenerator::Numeric<ArrowType>(1, max_integer - 1);
+    ASSERT_OK_AND_ASSIGN(auto expected_prefix_nulls,
+                         MakeArrayOfNull(utf8(), max_integer - 1));
+    auto expected_suffix_value = ConstantArrayGenerator::String(/*size=*/1, "a");
+    ASSERT_OK_AND_ASSIGN(auto expected,
+                         Concatenate({expected_prefix_nulls, expected_suffix_value}));
+    TestPermuteAAA(*values, *indices, /*output_length=*/max_integer, *expected);
+  }
+};
+
+TYPED_TEST_SUITE(TestPermuteSmallIndicesTypes, SmallOutputTypes);
+
+TYPED_TEST(TestPermuteSmallIndicesTypes, MaxIntegerIndex) { this->MaxIntegerIndex(); }
+
 TEST(Permute, Basic) {
   {
     auto values = ArrayFromJSON(int64(), "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]");

From c320002ffe5460eed9b79a44e97f81ff4b93ed14 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Sat, 12 Oct 2024 18:46:43 +0800
Subject: [PATCH 22/54] Refine tests

---
 cpp/src/arrow/compute/api_vector.cc           |  17 +-
 cpp/src/arrow/compute/api_vector.h            |   9 +-
 .../arrow/compute/kernels/vector_placement.cc |  21 +-
 .../compute/kernels/vector_placement_test.cc  | 314 ++++++++++++------
 4 files changed, 239 insertions(+), 122 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index ac8b6ac9a7f2a..ea4069381ec5a 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -450,19 +450,14 @@ Result<Datum> CumulativeMean(const Datum& values, const CumulativeOptions& optio
 // ----------------------------------------------------------------------
 // Placement functions
 
-Result<std::shared_ptr<Array>> ReverseIndices(const Datum& indices,
-                                              const ReverseIndicesOptions& options,
-                                              ExecContext* ctx) {
-  ARROW_ASSIGN_OR_RAISE(Datum result,
-                        CallFunction("reverse_indices", {indices}, &options, ctx));
-  return result.make_array();
+Result<Datum> ReverseIndices(const Datum& indices, const ReverseIndicesOptions& options,
+                             ExecContext* ctx) {
+  return CallFunction("reverse_indices", {indices}, &options, ctx);
 }
 
-Result<std::shared_ptr<Array>> Permute(const Datum& values, const Datum& indices,
-                                       const PermuteOptions& options, ExecContext* ctx) {
-  ARROW_ASSIGN_OR_RAISE(Datum result,
-                        CallFunction("permute", {values, indices}, &options, ctx));
-  return result.make_array();
+Result<Datum> Permute(const Datum& values, const Datum& indices,
+                      const PermuteOptions& options, ExecContext* ctx) {
+  return CallFunction("permute", {values, indices}, &options, ctx);
 }
 
 }  // namespace compute
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 40e5639874930..dbc8bee753d18 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -755,7 +755,7 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
 ///
 /// \since 19.0.0
 /// \note API not yet finalized
-Result<std::shared_ptr<Array>> ReverseIndices(
+Result<Datum> ReverseIndices(
     const Datum& indices,
     const ReverseIndicesOptions& options = ReverseIndicesOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
@@ -781,10 +781,9 @@ Result<std::shared_ptr<Array>> ReverseIndices(
 ///
 /// \since 19.0.0
 /// \note API not yet finalized
-Result<std::shared_ptr<Array>> Permute(
-    const Datum& values, const Datum& indices,
-    const PermuteOptions& options = PermuteOptions::Defaults(),
-    ExecContext* ctx = NULLPTR);
+Result<Datum> Permute(const Datum& values, const Datum& indices,
+                      const PermuteOptions& options = PermuteOptions::Defaults(),
+                      ExecContext* ctx = NULLPTR);
 
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index 2998af3bb1f1c..d8075202caf0f 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -286,8 +286,11 @@ struct ReverseIndicesChunked {
     DCHECK_EQ(batch.num_values(), 1);
     DCHECK(batch[0].is_chunked_array());
     const auto& indices = batch[0].chunked_array();
-    ARROW_ASSIGN_OR_RAISE(*result, ReverseIndicesImpl<ThisType>::Exec(
-                                       ctx, indices, indices->length(), indices->type()));
+    ARROW_ASSIGN_OR_RAISE(auto reverse_indices,
+                          ReverseIndicesImpl<ThisType>::Exec(
+                              ctx, indices, indices->length(), indices->type()));
+    *result =
+        Datum(std::make_shared<ChunkedArray>(MakeArray(std::move(reverse_indices))));
     return Status::OK();
   }
 };
@@ -340,13 +343,17 @@ class PermuteMetaFunction : public MetaFunction {
                             ExecContext* ctx) const override {
     DCHECK_EQ(args.size(), 2);
     const auto& values = args[0];
+    const auto& indices = args[1];
     // Though the way how permute is currently implemented may support record batch or
     // table, we don't want to promise that yet.
     if (!values.is_arraylike()) {
       return Status::NotImplemented("Permute does not support " +
-                                    ToString(values.kind()) + " argument");
+                                    ToString(values.kind()) + " values");
+    }
+    if (!indices.is_arraylike()) {
+      return Status::NotImplemented("Permute does not support " +
+                                    ToString(values.kind()) + " indices");
     }
-    const auto& indices = args[1];
     auto* permute_options = checked_cast<const PermuteOptions*>(options);
     if (values.length() != indices.length()) {
       return Status::Invalid(
@@ -362,14 +369,14 @@ class PermuteMetaFunction : public MetaFunction {
     if (output_length < 0) {
       output_length = values.length();
     }
-    // Internally invoke take(values, reverse_indices(indices)) to implement permute.
+    // Internally invoke Take(values, ReverseIndices(indices)) to implement permute.
     // For example, with
     //   values = [a, b, c, d, e, f, g]
     //   indices = [null, 0, 3, 2, 4, 1, 1]
-    // the reverse_indices(indices) is
+    // the ReverseIndices(indices) is
     //   [1, 6, 3]                    if output_length = 3,
     //   [1, 6, 3, 2, 4, null, null]  if output_length = 7.
-    // and take(values, reverse_indices(indices)) is
+    // and Take(values, ReverseIndices(indices)) is
     //   [b, g, d]                    if output_length = 3,
     //   [b, g, d, c, e, null, null]  if output_length = 7.
     ReverseIndicesOptions reverse_indices_options{
diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index 09433e5bd45c6..b88e0782b6d90 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -46,23 +46,46 @@ Result<Datum> ReverseIndices(const Datum& indices, int64_t output_length,
   return ReverseIndices(indices, options);
 }
 
-template <typename InputString, typename InputShapeFunc>
-void TestReverseIndices(const InputString& indices_str, int64_t output_length,
-                        const std::string& expected_str,
-                        InputShapeFunc&& input_shape_func, bool validity_must_be_null) {
+void AssertReverseIndices(const Datum& indices, int64_t output_length,
+                          const std::shared_ptr<DataType>& output_type,
+                          const Datum& expected, bool validity_must_be_null) {
+  ASSERT_OK_AND_ASSIGN(auto result, ReverseIndices(indices, output_length, output_type));
+  ASSERT_EQ(indices.kind(), result.kind());
+  std::shared_ptr<Array> result_array;
+  if (result.is_array()) {
+    result_array = result.make_array();
+  } else {
+    ASSERT_TRUE(result.is_chunked_array());
+    ASSERT_OK_AND_ASSIGN(result_array, Concatenate(result.chunked_array()->chunks()));
+  }
+  AssertDatumsEqual(expected, result_array);
+  if (validity_must_be_null) {
+    ASSERT_FALSE(result_array->data()->HasValidityBitmap());
+  }
+}
+
+template <typename InputFunc>
+void DoTestReverseIndicesForAllInputTypes(InputFunc&& input, int64_t output_length,
+                                          const std::shared_ptr<DataType>& output_type,
+                                          const Datum& expected,
+                                          bool validity_must_be_null = false) {
   for (const auto& input_type : kIntegerTypes) {
-    auto indices = input_shape_func(input_type, indices_str);
     ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
-    for (const auto& output_type : kIntegerTypes) {
-      ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
-      auto expected = ArrayFromJSON(output_type, expected_str);
-      ASSERT_OK_AND_ASSIGN(Datum result,
-                           ReverseIndices(indices, output_length, output_type));
-      AssertDatumsEqual(expected, result);
-      if (validity_must_be_null) {
-        ASSERT_FALSE(result.array()->HasValidityBitmap());
-      }
-    }
+    auto indices = input(input_type);
+    AssertReverseIndices(indices, output_length, output_type, expected,
+                         validity_must_be_null);
+  }
+}
+
+template <typename InputFunc>
+void DoTestReverseIndicesForAllInputOutputTypes(InputFunc&& input, int64_t output_length,
+                                                const std::string& expected_str,
+                                                bool validity_must_be_null) {
+  for (const auto& output_type : kIntegerTypes) {
+    ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
+    auto expected = ArrayFromJSON(output_type, expected_str);
+    DoTestReverseIndicesForAllInputTypes(std::forward<InputFunc>(input), output_length,
+                                         output_type, expected, validity_must_be_null);
   }
 }
 
@@ -72,13 +95,19 @@ void TestReverseIndices(const std::string& indices_str,
                         bool validity_must_be_null = false) {
   {
     ARROW_SCOPED_TRACE("Array");
-    TestReverseIndices(indices_str, output_length, expected_str, ArrayFromJSON,
-                       validity_must_be_null);
+    DoTestReverseIndicesForAllInputOutputTypes(
+        [&](const std::shared_ptr<DataType>& input_type) {
+          return ArrayFromJSON(input_type, indices_str);
+        },
+        output_length, expected_str, validity_must_be_null);
   }
   {
     ARROW_SCOPED_TRACE("Chunked");
-    TestReverseIndices(indices_chunked_str, output_length, expected_str,
-                       ChunkedArrayFromJSON, validity_must_be_null);
+    DoTestReverseIndicesForAllInputOutputTypes(
+        [&](const std::shared_ptr<DataType>& input_type) {
+          return ChunkedArrayFromJSON(input_type, indices_chunked_str);
+        },
+        output_length, expected_str, validity_must_be_null);
   }
 }
 
@@ -114,7 +143,7 @@ TEST(ReverseIndices, DefaultOptions) {
       ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
       auto indices = ArrayFromJSON(input_type, "[0]");
       ASSERT_OK_AND_ASSIGN(Datum result, ReverseIndices(indices));
-      AssertDatumsEqual(result, indices);
+      AssertDatumsEqual(indices, result);
     }
   }
 }
@@ -131,15 +160,13 @@ class TestReverseIndicesSmallOutputType : public ::testing::Test {
   void JustEnoughOutputType() {
     auto output_type = type_singleton();
     int64_t input_length = static_cast<int64_t>(std::numeric_limits<CType>::max());
-    auto expected = ConstantArrayGenerator::Numeric<ArrowType>(
-        /*size=*/1, /*value=*/static_cast<CType>(input_length - 1));
-    for (const auto& input_type : kIntegerTypes) {
-      ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
-      auto indices = ConstantArrayGenerator::Zeroes(input_length, input_type);
-      ASSERT_OK_AND_ASSIGN(Datum result,
-                           ReverseIndices(indices, /*output_length=*/1, output_type));
-      AssertDatumsEqual(expected, result);
-    }
+    auto expected =
+        ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
+    DoTestReverseIndicesForAllInputTypes(
+        [&](const std::shared_ptr<DataType>& input_type) {
+          return ConstantArrayGenerator::Zeroes(input_length, input_type);
+        },
+        /*output_length=*/1, output_type, expected);
   }
 
   void InsufficientOutputType() {
@@ -242,6 +269,11 @@ TEST(ReverseIndices, Basic) {
 
 // ----------------------------------------------------------------------
 // Permute tests
+//
+// Shorthand notation:
+//
+//   A = Array
+//   C = ChunkedArray
 
 namespace {
 
@@ -250,69 +282,154 @@ Result<Datum> Permute(const Datum& values, const Datum& indices, int64_t output_
   return Permute(values, indices, options);
 }
 
-void TestPermuteAAA(const Array& values, const Array& indices, int64_t output_length,
-                    const Array& expected) {
+void AssertPermuteAAA(const std::shared_ptr<Array>& values,
+                      const std::shared_ptr<Array>& indices, int64_t output_length,
+                      const std::shared_ptr<Array>& expected) {
   ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
   AssertDatumsEqual(expected, result);
 }
 
-// void TestPermuteAAA(const std::shared_ptr<DataType>& values_type,
-//                     const std::string& values_str, const std::string& indices_str,
-//                     int64_t output_length, const std::string& expected_str) {
-//   auto values = ArrayFromJSON(values_type, values_str);
-//   auto expected = ArrayFromJSON(values_type, expected_str);
-//   for (const auto& indices_type : kIntegerTypes) {
-//     ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
-//     auto indices = ArrayFromJSON(indices_type, indices_str);
-//     TestPermuteAAA(*values, *indices, output_length, *expected);
-//   }
-// }
-
-void TestPermuteCAC(const std::shared_ptr<ChunkedArray>& values, const Array& indices,
-                    int64_t output_length,
-                    const std::shared_ptr<ChunkedArray>& expected) {
+void AssertPermuteCAC(const std::shared_ptr<ChunkedArray>& values,
+                      const std::shared_ptr<Array>& indices, int64_t output_length,
+                      const std::shared_ptr<Array>& expected) {
   ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
-  AssertDatumsEqual(expected, result);
+  ASSERT_TRUE(result.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
+  AssertDatumsEqual(expected, result_array);
 }
 
-void TestPermuteCACWithArray(const std::shared_ptr<Array>& values,
-                             const std::shared_ptr<Array>& indices, int64_t output_length,
-                             const std::shared_ptr<Array>& expected) {
-  // PermuteAAA(Concat(V, V, V), I') == Concat(PermuteCAC([V, V, V], I'))
-  // where
-  //   V = values
-  //   I = indices
-  //   I' = Concat(I + 2 * output_length, I, I + output_length)
-  auto values3 = ArrayVector{values, values, values};
-  ASSERT_OK_AND_ASSIGN(auto concat_values3, Concatenate(values3));
-  auto chunked_values3 = std::make_shared<ChunkedArray>(values3);
-
-  std::shared_ptr<Array> concat_indices3;
-  {
-    auto double_length =
-        MakeScalar(indices->type(), 2 * values->length()));
-    auto zero = MakeScalar(indices->type(), 0);
-    auto length = MakeScalar(indices->type(), static_cast<int64_t>(values->length()));
-    ASSERT_OK_AND_ASSIGN(auto indices_prefix, Add(indices, *double_length));
-    ASSERT_OK_AND_ASSIGN(auto indices_middle, Add(indices, *zero));
-    ASSERT_OK_AND_ASSIGN(auto indices_suffix, Add(indices, *length));
-    auto indices3 = ArrayVector{
-        indices_prefix.make_array(),
-        indices_middle.make_array(),
-        indices_suffix.make_array(),
-    };
-    ASSERT_OK_AND_ASSIGN(concat_indices3, Concatenate(indices3));
-  }
+void AssertPermuteACC(const std::shared_ptr<Array>& values,
+                      const std::shared_ptr<ChunkedArray>& indices, int64_t output_length,
+                      const std::shared_ptr<Array>& expected) {
+  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+  ASSERT_TRUE(result.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
+  AssertDatumsEqual(expected, result_array);
+}
 
+void AssertPermuteCCC(const std::shared_ptr<ChunkedArray>& values,
+                      const std::shared_ptr<ChunkedArray>& indices, int64_t output_length,
+                      const std::shared_ptr<Array>& expected) {
   ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
-  AssertDatumsEqual(expected, result);
+  ASSERT_TRUE(result.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
+  AssertDatumsEqual(expected, result_array);
+}
+
+void DoTestPermuteAAA(const std::shared_ptr<Array>& values,
+                      const std::shared_ptr<Array>& indices, int64_t output_length,
+                      const std::shared_ptr<Array>& expected) {
+  AssertPermuteAAA(values, indices, output_length, expected);
+}
+
+/// The following helper functions are based on the invariant:
+/// PermuteXXA([V, V], [I', I''], 2 * l) == Concat(E, E)
+///
+/// where
+///   V = values
+///   I = indices
+///   l = output_length
+///   I' = ReplaceWithMask(I, i >= l, null)
+///   I'' = I + l
+///   E = PermuteAAA(V, I, l)
+
+/// Make indices prefix I' = ReplaceWithMask(I, i >= l, null).
+Result<std::shared_ptr<Array>> MakeIndicesPrefix(const std::shared_ptr<Array>& indices,
+                                                 int64_t output_length) {
+  ARROW_ASSIGN_OR_RAISE(auto l, MakeScalar(indices->type(), output_length));
+  ARROW_ASSIGN_OR_RAISE(auto ge_than_l, CallFunction("greater_equal", {indices, l}));
+  ARROW_ASSIGN_OR_RAISE(auto all_null,
+                        MakeArrayOfNull(indices->type(), indices->length()));
+  ARROW_ASSIGN_OR_RAISE(auto prefix, ReplaceWithMask(indices, ge_than_l, all_null));
+  return prefix.make_array();
+}
+
+/// Make indices suffix I'' = I + l.
+Result<std::shared_ptr<Array>> MakeIndicesSuffix(const std::shared_ptr<Array>& indices,
+                                                 int64_t output_length) {
+  ARROW_ASSIGN_OR_RAISE(auto l, MakeScalar(indices->type(), output_length));
+  ARROW_ASSIGN_OR_RAISE(auto suffix, Add(indices, l));
+  return suffix.make_array();
 }
 
-// void TestPermuteACA(const Array& values, const std::shared_ptr<ChunkedArray>& indices,
-//                     int64_t output_length, const Array& expected) {
-//   ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
-//   AssertDatumsEqual(expected, result);
-// }
+void DoTestPermuteCACWithArrays(const std::shared_ptr<Array>& values,
+                                const std::shared_ptr<Array>& indices,
+                                int64_t output_length,
+                                const std::shared_ptr<Array>& expected) {
+  auto chunked_values2 = std::make_shared<ChunkedArray>(ArrayVector{values, values});
+
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, output_length));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, output_length));
+  ASSERT_OK_AND_ASSIGN(auto concat_indices2,
+                       Concatenate({indices_prefix, indices_suffix}));
+
+  ASSERT_OK_AND_ASSIGN(auto concat_expected2,
+                       Concatenate(ArrayVector{expected, expected}));
+
+  AssertPermuteCAC(chunked_values2, concat_indices2, output_length * 2, concat_expected2);
+}
+
+void DoTestPermuteACCWithArrays(const std::shared_ptr<Array>& values,
+                                const std::shared_ptr<Array>& indices,
+                                int64_t output_length,
+                                const std::shared_ptr<Array>& expected) {
+  ASSERT_OK_AND_ASSIGN(auto concat_values2, Concatenate(ArrayVector{values, values}));
+
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, output_length));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, output_length));
+  auto chunked_indices2 =
+      std::make_shared<ChunkedArray>(ArrayVector{indices_prefix, indices_suffix});
+
+  ASSERT_OK_AND_ASSIGN(auto concat_expected2,
+                       Concatenate(ArrayVector{expected, expected}));
+
+  AssertPermuteACC(concat_values2, chunked_indices2, output_length * 2, concat_expected2);
+}
+
+void DoTestPermuteCCCWithArrays(const std::shared_ptr<Array>& values,
+                                const std::shared_ptr<Array>& indices,
+                                int64_t output_length,
+                                const std::shared_ptr<Array>& expected) {
+  auto chunked_values2 = std::make_shared<ChunkedArray>(ArrayVector{values, values});
+
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, output_length));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, output_length));
+  auto chunked_indices2 =
+      std::make_shared<ChunkedArray>(ArrayVector{indices_prefix, indices_suffix});
+
+  ASSERT_OK_AND_ASSIGN(auto concat_expected2,
+                       Concatenate(ArrayVector{expected, expected}));
+
+  AssertPermuteCCC(chunked_values2, chunked_indices2, output_length * 2,
+                   concat_expected2);
+}
+
+void TestPermute(const std::shared_ptr<DataType>& values_type,
+                 const std::string& values_str, const std::string& indices_str,
+                 int64_t output_length, const std::string& expected_str) {
+  auto values = ArrayFromJSON(values_type, values_str);
+  auto expected = ArrayFromJSON(values_type, expected_str);
+  for (const auto& indices_type : kIntegerTypes) {
+    ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
+    auto indices = ArrayFromJSON(indices_type, indices_str);
+    {
+      ARROW_SCOPED_TRACE("AAA");
+      DoTestPermuteAAA(values, indices, output_length, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("CAA");
+      DoTestPermuteCACWithArrays(values, indices, output_length, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("ACA");
+      DoTestPermuteACCWithArrays(values, indices, output_length, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("CCA");
+      DoTestPermuteCCCWithArrays(values, indices, output_length, expected);
+    }
+  }
+}
 
 }  // namespace
 
@@ -349,7 +466,7 @@ TEST(Permute, DefaultOptions) {
       ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
       auto indices = ArrayFromJSON(indices_type, "[0]");
       ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices));
-      AssertDatumsEqual(result, values);
+      AssertDatumsEqual(values, result);
     }
   }
 }
@@ -367,13 +484,14 @@ class TestPermuteSmallIndicesTypes : public ::testing::Test {
     auto values = ArrayFromJSON(utf8(), R"(["a"])");
     auto indices_type = type_singleton();
     int64_t max_integer = static_cast<int64_t>(std::numeric_limits<CType>::max());
-    auto indices = ConstantArrayGenerator::Numeric<ArrowType>(1, max_integer - 1);
+    auto indices =
+        ArrayFromJSON(indices_type, "[" + std::to_string(max_integer - 1) + "]");
     ASSERT_OK_AND_ASSIGN(auto expected_prefix_nulls,
                          MakeArrayOfNull(utf8(), max_integer - 1));
-    auto expected_suffix_value = ConstantArrayGenerator::String(/*size=*/1, "a");
+    auto expected_suffix_value = values;
     ASSERT_OK_AND_ASSIGN(auto expected,
                          Concatenate({expected_prefix_nulls, expected_suffix_value}));
-    TestPermuteAAA(*values, *indices, /*output_length=*/max_integer, *expected);
+    DoTestPermuteAAA(values, indices, /*output_length=*/max_integer, expected);
   }
 };
 
@@ -383,22 +501,20 @@ TYPED_TEST(TestPermuteSmallIndicesTypes, MaxIntegerIndex) { this->MaxIntegerInde
 
 TEST(Permute, Basic) {
   {
-    auto values = ArrayFromJSON(int64(), "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]");
-    auto indices = ArrayFromJSON(int64(), "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]");
-    auto expected = ArrayFromJSON(int64(), "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]");
-    PermuteOptions options{10};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("permute", {values, indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Basic");
+    auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
+    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+    int64_t output_length = 10;
+    auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";
+    TestPermute(int64(), values, indices, output_length, expected);
   }
   {
-    auto values = ArrayFromJSON(int64(), "[0, 0, 0, 1, 1, 1]");
-    auto indices = ArrayFromJSON(int64(), "[0, 3, 6, 1, 4, 7]");
-    auto expected = ArrayFromJSON(int64(), "[0, 1, null, 0, 1, null, 0, 1, null]");
-    PermuteOptions options{9};
-    ASSERT_OK_AND_ASSIGN(Datum result,
-                         CallFunction("permute", {values, indices}, &options));
-    AssertDatumsEqual(expected, result);
+    ARROW_SCOPED_TRACE("Output greater than input");
+    auto values = "[0, 0, 0, 1, 1, 1]";
+    auto indices = "[0, 3, 6, 1, 4, 7]";
+    int64_t output_length = 9;
+    auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";
+    TestPermute(int64(), values, indices, output_length, expected);
   }
 }
 

From 3e438e86d2f0afd6241e125e3836eb4fef73fe1e Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Sun, 13 Oct 2024 01:03:07 +0800
Subject: [PATCH 23/54] More permute tests

---
 .../compute/kernels/vector_placement_test.cc  | 574 +++++++++++++++---
 1 file changed, 492 insertions(+), 82 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index b88e0782b6d90..f1496b16ade35 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -28,6 +28,9 @@ namespace arrow::compute {
 
 namespace {
 
+static const std::vector<std::shared_ptr<DataType>> kSignedIntegerTypes = {
+    int8(), int16(), int32(), int64()};
+
 static const std::vector<std::shared_ptr<DataType>> kIntegerTypes = {
     int8(), uint8(), int16(), uint16(), int32(), uint32(), int64(), uint64()};
 
@@ -65,11 +68,11 @@ void AssertReverseIndices(const Datum& indices, int64_t output_length,
 }
 
 template <typename InputFunc>
-void DoTestReverseIndicesForAllInputTypes(InputFunc&& input, int64_t output_length,
-                                          const std::shared_ptr<DataType>& output_type,
-                                          const Datum& expected,
-                                          bool validity_must_be_null = false) {
-  for (const auto& input_type : kIntegerTypes) {
+void DoTestReverseIndicesForInputTypes(
+    const std::vector<std::shared_ptr<DataType>>& input_types, InputFunc&& input,
+    int64_t output_length, const std::shared_ptr<DataType>& output_type,
+    const Datum& expected, bool validity_must_be_null = false) {
+  for (const auto& input_type : input_types) {
     ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
     auto indices = input(input_type);
     AssertReverseIndices(indices, output_length, output_type, expected,
@@ -78,24 +81,28 @@ void DoTestReverseIndicesForAllInputTypes(InputFunc&& input, int64_t output_leng
 }
 
 template <typename InputFunc>
-void DoTestReverseIndicesForAllInputOutputTypes(InputFunc&& input, int64_t output_length,
-                                                const std::string& expected_str,
-                                                bool validity_must_be_null) {
+void DoTestReverseIndicesForInputOutputTypes(
+    const std::vector<std::shared_ptr<DataType>>& input_types,
+    const std::vector<std::shared_ptr<DataType>>& output_types, InputFunc&& input,
+    int64_t output_length, const std::string& expected_str, bool validity_must_be_null) {
   for (const auto& output_type : kIntegerTypes) {
     ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
     auto expected = ArrayFromJSON(output_type, expected_str);
-    DoTestReverseIndicesForAllInputTypes(std::forward<InputFunc>(input), output_length,
-                                         output_type, expected, validity_must_be_null);
+    DoTestReverseIndicesForInputTypes(input_types, std::forward<InputFunc>(input),
+                                      output_length, output_type, expected,
+                                      validity_must_be_null);
   }
 }
 
-void TestReverseIndices(const std::string& indices_str,
-                        const std::vector<std::string>& indices_chunked_str,
-                        int64_t output_length, const std::string& expected_str,
-                        bool validity_must_be_null = false) {
+void TestReverseIndicesForInputOutputTypes(
+    const std::vector<std::shared_ptr<DataType>>& input_types,
+    const std::vector<std::shared_ptr<DataType>>& output_types,
+    const std::string& indices_str, const std::vector<std::string>& indices_chunked_str,
+    int64_t output_length, const std::string& expected_str, bool validity_must_be_null) {
   {
     ARROW_SCOPED_TRACE("Array");
-    DoTestReverseIndicesForAllInputOutputTypes(
+    DoTestReverseIndicesForInputOutputTypes(
+        input_types, output_types,
         [&](const std::shared_ptr<DataType>& input_type) {
           return ArrayFromJSON(input_type, indices_str);
         },
@@ -103,7 +110,8 @@ void TestReverseIndices(const std::string& indices_str,
   }
   {
     ARROW_SCOPED_TRACE("Chunked");
-    DoTestReverseIndicesForAllInputOutputTypes(
+    DoTestReverseIndicesForInputOutputTypes(
+        input_types, output_types,
         [&](const std::shared_ptr<DataType>& input_type) {
           return ChunkedArrayFromJSON(input_type, indices_chunked_str);
         },
@@ -111,6 +119,24 @@ void TestReverseIndices(const std::string& indices_str,
   }
 }
 
+void TestReverseIndicesSigned(const std::string& indices_str,
+                              const std::vector<std::string>& indices_chunked_str,
+                              int64_t output_length, const std::string& expected_str,
+                              bool validity_must_be_null = false) {
+  TestReverseIndicesForInputOutputTypes(kSignedIntegerTypes, kIntegerTypes, indices_str,
+                                        indices_chunked_str, output_length, expected_str,
+                                        validity_must_be_null);
+}
+
+void TestReverseIndices(const std::string& indices_str,
+                        const std::vector<std::string>& indices_chunked_str,
+                        int64_t output_length, const std::string& expected_str,
+                        bool validity_must_be_null = false) {
+  TestReverseIndicesForInputOutputTypes(kIntegerTypes, kIntegerTypes, indices_str,
+                                        indices_chunked_str, output_length, expected_str,
+                                        validity_must_be_null);
+}
+
 }  // namespace
 
 TEST(ReverseIndices, InvalidOutputType) {
@@ -156,43 +182,38 @@ class TestReverseIndicesSmallOutputType : public ::testing::Test {
   std::shared_ptr<DataType> type_singleton() {
     return TypeTraits<ArrowType>::type_singleton();
   }
-
-  void JustEnoughOutputType() {
-    auto output_type = type_singleton();
-    int64_t input_length = static_cast<int64_t>(std::numeric_limits<CType>::max());
-    auto expected =
-        ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
-    DoTestReverseIndicesForAllInputTypes(
-        [&](const std::shared_ptr<DataType>& input_type) {
-          return ConstantArrayGenerator::Zeroes(input_length, input_type);
-        },
-        /*output_length=*/1, output_type, expected);
-  }
-
-  void InsufficientOutputType() {
-    auto output_type = type_singleton();
-    int64_t input_length = static_cast<int64_t>(std::numeric_limits<CType>::max()) + 1;
-    for (const auto& input_type : kIntegerTypes) {
-      ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
-      auto indices = ConstantArrayGenerator::Zeroes(input_length, int64());
-      ASSERT_RAISES_WITH_MESSAGE(
-          Invalid,
-          "Invalid: Output type " + output_type->ToString() +
-              " of reverse_indices is insufficient to store indices of length " +
-              std::to_string(input_length),
-          ReverseIndices(indices, /*output_length=*/1, output_type));
-    }
-  }
 };
 
 TYPED_TEST_SUITE(TestReverseIndicesSmallOutputType, SmallOutputTypes);
 
 TYPED_TEST(TestReverseIndicesSmallOutputType, JustEnoughOutputType) {
-  this->JustEnoughOutputType();
+  auto output_type = this->type_singleton();
+  int64_t input_length =
+      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max());
+  auto expected =
+      ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
+  DoTestReverseIndicesForInputTypes(
+      kIntegerTypes,
+      [&](const std::shared_ptr<DataType>& input_type) {
+        return ConstantArrayGenerator::Zeroes(input_length, input_type);
+      },
+      /*output_length=*/1, output_type, expected);
 }
 
 TYPED_TEST(TestReverseIndicesSmallOutputType, InsufficientOutputType) {
-  this->InsufficientOutputType();
+  auto output_type = this->type_singleton();
+  int64_t input_length =
+      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max()) + 1;
+  for (const auto& input_type : kIntegerTypes) {
+    ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+    auto indices = ConstantArrayGenerator::Zeroes(input_length, input_type);
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid,
+        "Invalid: Output type " + output_type->ToString() +
+            " of reverse_indices is insufficient to store indices of length " +
+            std::to_string(input_length),
+        ReverseIndices(indices, /*output_length=*/1, output_type));
+  }
 }
 
 TEST(ReverseIndices, Basic) {
@@ -206,6 +227,24 @@ TEST(ReverseIndices, Basic) {
     TestReverseIndices(indices, indices_chunked, output_length, expected,
                        /*validity_must_be_null=*/true);
   }
+  {
+    ARROW_SCOPED_TRACE("Basic with nulls");
+    auto indices = "[9, 7, 5, 3, 1, null, null, null, null, null]";
+    std::vector<std::string> indices_chunked{
+        "[]", "[9, 7, 5, 3, 1]", "[null]", "[null, null, null]", "[null]", "[]"};
+    int64_t output_length = 10;
+    auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
+    TestReverseIndices(indices, indices_chunked, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Basic with negatives");
+    auto indices = "[9, 7, 5, 3, 1, -1, -2, -3, -4, -5]";
+    std::vector<std::string> indices_chunked{
+        "[]", "[9, 7, 5, 3, 1]", "[-1]", "[-2, -3, -4]", "[-5]", "[]"};
+    int64_t output_length = 10;
+    auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
+    TestReverseIndicesSigned(indices, indices_chunked, output_length, expected);
+  }
   {
     ARROW_SCOPED_TRACE("Empty output");
     auto indices = "[1, 2]";
@@ -236,16 +275,16 @@ TEST(ReverseIndices, Basic) {
     ARROW_SCOPED_TRACE("Input all null");
     auto indices = "[null, null]";
     std::vector<std::string> indices_chunked{"[]", "[null]", "[]", "[null]"};
-    int64_t output_length = 1;
-    auto expected = "[null]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
     TestReverseIndices(indices, indices_chunked, output_length, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
-    auto indices = "[1, 2]";
-    std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[2]"};
-    int64_t output_length = 1;
-    auto expected = "[null]";
+    auto indices = "[2, 3]";
+    std::vector<std::string> indices_chunked{"[]", "[2]", "[]", "[3]"};
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
     TestReverseIndices(indices, indices_chunked, output_length, expected);
   }
   {
@@ -330,7 +369,7 @@ void DoTestPermuteAAA(const std::shared_ptr<Array>& values,
 ///   I = indices
 ///   l = output_length
 ///   I' = ReplaceWithMask(I, i >= l, null)
-///   I'' = I + l
+///   I'' = ReplaceWithMask(I, i < 0, null) + l
 ///   E = PermuteAAA(V, I, l)
 
 /// Make indices prefix I' = ReplaceWithMask(I, i >= l, null).
@@ -344,11 +383,16 @@ Result<std::shared_ptr<Array>> MakeIndicesPrefix(const std::shared_ptr<Array>& i
   return prefix.make_array();
 }
 
-/// Make indices suffix I'' = I + l.
+/// Make indices suffix I'' = ReplaceWithMask(I, i < 0, null) + l.
 Result<std::shared_ptr<Array>> MakeIndicesSuffix(const std::shared_ptr<Array>& indices,
                                                  int64_t output_length) {
+  ARROW_ASSIGN_OR_RAISE(auto zero, MakeScalar(indices->type(), 0));
+  ARROW_ASSIGN_OR_RAISE(auto negative, CallFunction("less", {indices, zero}));
+  ARROW_ASSIGN_OR_RAISE(auto all_null,
+                        MakeArrayOfNull(indices->type(), indices->length()));
+  ARROW_ASSIGN_OR_RAISE(auto replaced, ReplaceWithMask(indices, negative, all_null));
   ARROW_ASSIGN_OR_RAISE(auto l, MakeScalar(indices->type(), output_length));
-  ARROW_ASSIGN_OR_RAISE(auto suffix, Add(indices, l));
+  ARROW_ASSIGN_OR_RAISE(auto suffix, Add(replaced, l));
   return suffix.make_array();
 }
 
@@ -404,33 +448,75 @@ void DoTestPermuteCCCWithArrays(const std::shared_ptr<Array>& values,
                    concat_expected2);
 }
 
-void TestPermute(const std::shared_ptr<DataType>& values_type,
-                 const std::string& values_str, const std::string& indices_str,
-                 int64_t output_length, const std::string& expected_str) {
-  auto values = ArrayFromJSON(values_type, values_str);
-  auto expected = ArrayFromJSON(values_type, expected_str);
-  for (const auto& indices_type : kIntegerTypes) {
+void DoTestPermuteForIndicesTypes(
+    const std::vector<std::shared_ptr<DataType>>& indices_types,
+    const std::shared_ptr<Array>& values, const std::shared_ptr<Array>& indices,
+    int64_t output_length, const std::shared_ptr<Array>& expected) {
+  for (const auto& indices_type : indices_types) {
     ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
-    auto indices = ArrayFromJSON(indices_type, indices_str);
+    ASSERT_OK_AND_ASSIGN(auto casted, Cast(indices, indices_type));
+    ASSERT_TRUE(casted.is_array());
+    auto casted_indices = casted.make_array();
     {
       ARROW_SCOPED_TRACE("AAA");
-      DoTestPermuteAAA(values, indices, output_length, expected);
+      DoTestPermuteAAA(values, casted_indices, output_length, expected);
     }
     {
       ARROW_SCOPED_TRACE("CAA");
-      DoTestPermuteCACWithArrays(values, indices, output_length, expected);
+      DoTestPermuteCACWithArrays(values, casted_indices, output_length, expected);
     }
     {
       ARROW_SCOPED_TRACE("ACA");
-      DoTestPermuteACCWithArrays(values, indices, output_length, expected);
+      DoTestPermuteACCWithArrays(values, casted_indices, output_length, expected);
     }
     {
       ARROW_SCOPED_TRACE("CCA");
-      DoTestPermuteCCCWithArrays(values, indices, output_length, expected);
+      DoTestPermuteCCCWithArrays(values, casted_indices, output_length, expected);
     }
   }
 }
 
+void DoTestPermuteSignedIndices(const std::shared_ptr<Array>& values,
+                                const std::shared_ptr<Array>& indices,
+                                int64_t output_length,
+                                const std::shared_ptr<Array>& expected) {
+  DoTestPermuteForIndicesTypes(kSignedIntegerTypes, values, indices, output_length,
+                               expected);
+}
+
+void DoTestPermute(const std::shared_ptr<Array>& values,
+                   const std::shared_ptr<Array>& indices, int64_t output_length,
+                   const std::shared_ptr<Array>& expected) {
+  DoTestPermuteForIndicesTypes(kIntegerTypes, values, indices, output_length, expected);
+}
+
+// void TestPermute(const std::shared_ptr<DataType>& values_type,
+//                  const std::string& values_str, const std::string& indices_str,
+//                  int64_t output_length, const std::string& expected_str) {
+//   auto values = ArrayFromJSON(values_type, values_str);
+//   auto expected = ArrayFromJSON(values_type, expected_str);
+//   for (const auto& indices_type : kIntegerTypes) {
+//     ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
+//     auto indices = ArrayFromJSON(indices_type, indices_str);
+//     {
+//       ARROW_SCOPED_TRACE("AAA");
+//       DoTestPermuteAAA(values, indices, output_length, expected);
+//     }
+//     {
+//       ARROW_SCOPED_TRACE("CAA");
+//       DoTestPermuteCACWithArrays(values, indices, output_length, expected);
+//     }
+//     {
+//       ARROW_SCOPED_TRACE("ACA");
+//       DoTestPermuteACCWithArrays(values, indices, output_length, expected);
+//     }
+//     {
+//       ARROW_SCOPED_TRACE("CCA");
+//       DoTestPermuteCCCWithArrays(values, indices, output_length, expected);
+//     }
+//   }
+// }
+
 }  // namespace
 
 TEST(Permute, Invalid) {
@@ -479,34 +565,214 @@ class TestPermuteSmallIndicesTypes : public ::testing::Test {
   std::shared_ptr<DataType> type_singleton() {
     return TypeTraits<ArrowType>::type_singleton();
   }
+};
 
-  void MaxIntegerIndex() {
-    auto values = ArrayFromJSON(utf8(), R"(["a"])");
-    auto indices_type = type_singleton();
-    int64_t max_integer = static_cast<int64_t>(std::numeric_limits<CType>::max());
-    auto indices =
-        ArrayFromJSON(indices_type, "[" + std::to_string(max_integer - 1) + "]");
-    ASSERT_OK_AND_ASSIGN(auto expected_prefix_nulls,
-                         MakeArrayOfNull(utf8(), max_integer - 1));
-    auto expected_suffix_value = values;
-    ASSERT_OK_AND_ASSIGN(auto expected,
-                         Concatenate({expected_prefix_nulls, expected_suffix_value}));
-    DoTestPermuteAAA(values, indices, /*output_length=*/max_integer, expected);
+TYPED_TEST_SUITE(TestPermuteSmallIndicesTypes, SmallOutputTypes);
+
+TYPED_TEST(TestPermuteSmallIndicesTypes, MaxIntegerIndex) {
+  auto values = ArrayFromJSON(utf8(), R"(["a"])");
+  auto indices_type = this->type_singleton();
+  int64_t max_integer =
+      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max());
+  auto indices = ArrayFromJSON(indices_type, "[" + std::to_string(max_integer - 1) + "]");
+  ASSERT_OK_AND_ASSIGN(auto expected_prefix_nulls,
+                       MakeArrayOfNull(utf8(), max_integer - 1));
+  auto expected_suffix_value = values;
+  ASSERT_OK_AND_ASSIGN(auto expected,
+                       Concatenate({expected_prefix_nulls, expected_suffix_value}));
+  DoTestPermuteAAA(values, indices, /*output_length=*/max_integer, expected);
+}
+
+template <typename ArrowType>
+class TestPermuteTyped : public ::testing::Test {
+ protected:
+  virtual std::shared_ptr<DataType> values_type() const {
+    if constexpr (is_parameter_free_type<ArrowType>::value) {
+      return TypeTraits<ArrowType>::type_singleton();
+    } else {
+      EXPECT_TRUE(false) << "values_type() must be overridden for parameterized types";
+      return nullptr;
+    }
+  }
+
+  void TestPermuteSignedIndices(const std::string& values_str,
+                                const std::string& indices_str, int64_t output_length,
+                                const std::string& expected_str) {
+    TestPermute(DoTestPermuteSignedIndices, values_str, indices_str, output_length,
+                expected_str);
+  }
+
+  void TestPermute(const std::string& values_str, const std::string& indices_str,
+                   int64_t output_length, const std::string& expected_str) {
+    TestPermute(DoTestPermute, values_str, indices_str, output_length, expected_str);
+  }
+
+ private:
+  template <typename DoTestFunc>
+  void TestPermute(DoTestFunc&& func, const std::string& values_str,
+                   const std::string& indices_str, int64_t output_length,
+                   const std::string& expected_str) {
+    auto values = ArrayFromJSON(values_type(), values_str);
+    auto indices = ArrayFromJSON(int8(), indices_str);
+    auto expected = ArrayFromJSON(values_type(), expected_str);
+    func(values, indices, output_length, expected);
   }
 };
 
-TYPED_TEST_SUITE(TestPermuteSmallIndicesTypes, SmallOutputTypes);
+class TestPermuteBoolean : public TestPermuteTyped<BooleanType> {};
+
+TEST_F(TestPermuteBoolean, Basic) {
+  {
+    ARROW_SCOPED_TRACE("Basic");
+    auto values = "[true, false, true, true, false, false, true, true, true, false]";
+    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+    int64_t output_length = 10;
+    auto expected = "[false, true, true, true, false, false, true, true, false, true]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Values with nulls");
+    auto values = "[true, false, null, true, true, false, false, null, null, true]";
+    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+    int64_t output_length = 10;
+    auto expected = "[true, null, null, false, false, true, true, null, false, true]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices with nulls");
+    auto values = "[true, false, true, true, false, false, true, true, true, false]";
+    auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
+    int64_t output_length = 10;
+    auto expected = "[null, true, null, true, null, false, null, true, null, true]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices with negatives");
+    auto values = "[true, false, true, true, false, false, true, true, true, false]";
+    auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
+    int64_t output_length = 10;
+    auto expected = "[null, true, null, true, null, false, null, true, null, true]";
+    TestPermuteSignedIndices(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Empty output");
+    auto values = "[true, false]";
+    auto indices = "[0, 1]";
+    int64_t output_length = 0;
+    auto expected = "[]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output less than input");
+    auto values = "[false, true]";
+    auto indices = "[1, 0]";
+    int64_t output_length = 1;
+    auto expected = "[true]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output greater than input");
+    auto values = "[true, true, true, false, false, false]";
+    auto indices = "[0, 3, 6, 1, 4, 7]";
+    int64_t output_length = 9;
+    auto expected = "[true, false, null, true, false, null, true, false, null]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Values all null");
+    auto values = "[null, null]";
+    auto indices = "[0, 1]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices all null");
+    auto values = "[true, false]";
+    auto indices = "[null, null]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output all null");
+    auto values = "[true, false]";
+    auto indices = "[2, 3]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Empty input output null");
+    auto values = "[]";
+    auto indices = "[]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices duplicated indices");
+    auto values = "[true, false, null, null]";
+    auto indices = "[0, 1, 0, 1]";
+    int64_t output_length = 4;
+    auto expected = "[null, null, null, null]";
+    TestPermute(values, indices, output_length, expected);
+  }
+}
 
-TYPED_TEST(TestPermuteSmallIndicesTypes, MaxIntegerIndex) { this->MaxIntegerIndex(); }
+template <typename ArrowType>
+class TestPermuteNumeric : public TestPermuteTyped<ArrowType> {};
+
+TYPED_TEST_SUITE(TestPermuteNumeric, NumericArrowTypes);
 
-TEST(Permute, Basic) {
+TYPED_TEST(TestPermuteNumeric, Basic) {
   {
     ARROW_SCOPED_TRACE("Basic");
     auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t output_length = 10;
     auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";
-    TestPermute(int64(), values, indices, output_length, expected);
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Values with nulls");
+    auto values = "[null, 11, null, 13, null, 15, null, 17, null, 19]";
+    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+    int64_t output_length = 10;
+    auto expected = "[19, null, 17, null, 15, null, 13, null, 11, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices with nulls");
+    auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
+    auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
+    int64_t output_length = 10;
+    auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices with negatives");
+    auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
+    auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
+    int64_t output_length = 10;
+    auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
+    this->TestPermuteSignedIndices(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Empty output");
+    auto values = "[1, 0]";
+    auto indices = "[0, 1]";
+    int64_t output_length = 0;
+    auto expected = "[]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output less than input");
+    auto values = "[1, 0]";
+    auto indices = "[1, 0]";
+    int64_t output_length = 1;
+    auto expected = "[0]";
+    this->TestPermute(values, indices, output_length, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
@@ -514,7 +780,151 @@ TEST(Permute, Basic) {
     auto indices = "[0, 3, 6, 1, 4, 7]";
     int64_t output_length = 9;
     auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";
-    TestPermute(int64(), values, indices, output_length, expected);
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Values all null");
+    auto values = "[null, null]";
+    auto indices = "[0, 1]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices all null");
+    auto values = "[0, 1]";
+    auto indices = "[null, null]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output all null");
+    auto values = "[0, 1]";
+    auto indices = "[2, 3]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Empty input output null");
+    auto values = "[]";
+    auto indices = "[]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices duplicated indices");
+    auto values = "[1, 0, null, null]";
+    auto indices = "[0, 1, 0, 1]";
+    int64_t output_length = 4;
+    auto expected = "[null, null, null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+}
+
+template <typename ArrowType>
+class TestPermuteString : public TestPermuteTyped<ArrowType> {};
+
+TYPED_TEST_SUITE(TestPermuteString, BaseBinaryArrowTypes);
+
+TYPED_TEST(TestPermuteString, Basic) {
+  {
+    ARROW_SCOPED_TRACE("Basic");
+    auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
+    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+    int64_t output_length = 10;
+    auto expected = R"(["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"])";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Values with nulls");
+    auto values = R"([null, "b", null, "d", null, "f", null, "h", null, "j"])";
+    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+    int64_t output_length = 10;
+    auto expected = R"(["j", null, "h", null, "f", null, "d", null, "b", null])";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices with nulls");
+    auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
+    auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
+    int64_t output_length = 10;
+    auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices with negatives");
+    auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
+    auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
+    int64_t output_length = 10;
+    auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
+    this->TestPermuteSignedIndices(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Empty output");
+    auto values = R"(["b", "a"])";
+    auto indices = "[0, 1]";
+    int64_t output_length = 0;
+    auto expected = "[]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output less than input");
+    auto values = R"(["b", "a"])";
+    auto indices = "[1, 0]";
+    int64_t output_length = 1;
+    auto expected = R"(["a"])";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output greater than input");
+    auto values = R"(["a", "a", "a", "b", "b", "b"])";
+    auto indices = "[0, 3, 6, 1, 4, 7]";
+    int64_t output_length = 9;
+    auto expected = R"(["a", "b", null, "a", "b", null, "a", "b", null])";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Values all null");
+    auto values = "[null, null]";
+    auto indices = "[0, 1]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices all null");
+    auto values = R"(["a", "b"])";
+    auto indices = "[null, null]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Output all null");
+    auto values = R"(["a", "b"])";
+    auto indices = "[2, 3]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Empty input output null");
+    auto values = "[]";
+    auto indices = "[]";
+    int64_t output_length = 2;
+    auto expected = "[null, null]";
+    this->TestPermute(values, indices, output_length, expected);
+  }
+  {
+    ARROW_SCOPED_TRACE("Indices duplicated indices");
+    auto values = R"(["a", "b", null, null])";
+    auto indices = "[0, 1, 0, 1]";
+    int64_t output_length = 4;
+    auto expected = "[null, null, null, null]";
+    this->TestPermute(values, indices, output_length, expected);
   }
 }
 

From 0811b2bac1a6ae1b2fa228fc92b413ac5f8ee86d Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Sun, 13 Oct 2024 23:52:01 +0800
Subject: [PATCH 24/54] Add if-else tests using permute

---
 .../compute/kernels/vector_placement_test.cc  | 225 +++++++++++++++---
 1 file changed, 197 insertions(+), 28 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index f1496b16ade35..01a4ab2ad246f 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -23,6 +23,8 @@
 #include "arrow/compute/kernels/test_util.h"
 #include "arrow/testing/generator.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
+#include "arrow/util/logging.h"
 
 namespace arrow::compute {
 
@@ -34,6 +36,14 @@ static const std::vector<std::shared_ptr<DataType>> kSignedIntegerTypes = {
 static const std::vector<std::shared_ptr<DataType>> kIntegerTypes = {
     int8(), uint8(), int16(), uint16(), int32(), uint32(), int64(), uint64()};
 
+static const std::vector<std::shared_ptr<DataType>> kNumericTypes = {
+    uint8(), int8(),   uint16(), int16(),   uint32(),
+    int32(), uint64(), int64(),  float32(), float64()};
+
+static const std::vector<std::shared_ptr<DataType>> kNumericAndBaseBinaryTypes = {
+    uint8(), int8(),    uint16(),  int16(),  uint32(), int32(),        uint64(),
+    int64(), float32(), float64(), binary(), utf8(),   large_binary(), large_utf8()};
+
 using SmallOutputTypes = ::testing::Types<UInt8Type, UInt16Type, Int8Type, Int16Type>;
 
 }  // namespace
@@ -490,33 +500,6 @@ void DoTestPermute(const std::shared_ptr<Array>& values,
   DoTestPermuteForIndicesTypes(kIntegerTypes, values, indices, output_length, expected);
 }
 
-// void TestPermute(const std::shared_ptr<DataType>& values_type,
-//                  const std::string& values_str, const std::string& indices_str,
-//                  int64_t output_length, const std::string& expected_str) {
-//   auto values = ArrayFromJSON(values_type, values_str);
-//   auto expected = ArrayFromJSON(values_type, expected_str);
-//   for (const auto& indices_type : kIntegerTypes) {
-//     ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
-//     auto indices = ArrayFromJSON(indices_type, indices_str);
-//     {
-//       ARROW_SCOPED_TRACE("AAA");
-//       DoTestPermuteAAA(values, indices, output_length, expected);
-//     }
-//     {
-//       ARROW_SCOPED_TRACE("CAA");
-//       DoTestPermuteCACWithArrays(values, indices, output_length, expected);
-//     }
-//     {
-//       ARROW_SCOPED_TRACE("ACA");
-//       DoTestPermuteACCWithArrays(values, indices, output_length, expected);
-//     }
-//     {
-//       ARROW_SCOPED_TRACE("CCA");
-//       DoTestPermuteCCCWithArrays(values, indices, output_length, expected);
-//     }
-//   }
-// }
-
 }  // namespace
 
 TEST(Permute, Invalid) {
@@ -928,4 +911,190 @@ TYPED_TEST(TestPermuteString, Basic) {
   }
 }
 
-};  // namespace arrow::compute
+// ----------------------------------------------------------------------
+// Test Permute using a hypothetical if-else special form.
+// Also demonstrate how Permute can serve as a building block of implementing special
+// forms.
+
+namespace {
+
+/// Execute an if-else expression using regular expression evaluation, as a reference.
+Result<Datum> ExecuteIfElseByExpr(const Expression& cond, const Expression& if_true,
+                                  const Expression& if_false,
+                                  const std::shared_ptr<Schema>& schema,
+                                  const ExecBatch& input) {
+  auto if_else = call("if_else", {cond, if_true, if_false});
+  ARROW_ASSIGN_OR_RAISE(auto bound, if_else.Bind(*schema));
+  return ExecuteScalarExpression(bound, input);
+}
+
+/// Execute an if-else expression in a special form fashion, in which Permute is used as a
+/// building block.
+Result<Datum> ExecuteIfElseByPermute(const Expression& cond, const Expression& if_true,
+                                     const Expression& if_false,
+                                     const std::shared_ptr<Schema>& schema,
+                                     const ExecBatch& input) {
+  for (const auto& column : input.values) {
+    DCHECK(column.is_array());
+  }
+
+  ARROW_ASSIGN_OR_RAISE(auto input_rb, input.ToRecordBatch(schema));
+
+  // 1. Evaluate "cond", getting a boolean array as a mask to branches.
+  ARROW_ASSIGN_OR_RAISE(auto bound_cond, cond.Bind(*schema));
+  ARROW_ASSIGN_OR_RAISE(auto cond_datum, ExecuteScalarExpression(bound_cond, input));
+
+  // 2. Get indices of "true"s from the mask as the selection vector.
+  ARROW_ASSIGN_OR_RAISE(auto sel_if_true_datum,
+                        CallFunction("indices_nonzero", {cond_datum}));
+  DCHECK(sel_if_true_datum.is_array());
+  auto sel_if_true_array = sel_if_true_datum.make_array();
+
+  // 3. Take the "true" rows from input.
+  ARROW_ASSIGN_OR_RAISE(auto if_true_input_datum,
+                        CallFunction("take", {input_rb, sel_if_true_datum}));
+
+  // 4. Get indices of "false"es form the mas as the selection vector - by first inverting
+  // the mask and then getting the non-zero's indices.
+  ARROW_ASSIGN_OR_RAISE(auto invert_cond_datum, CallFunction("invert", {cond_datum}));
+  ARROW_ASSIGN_OR_RAISE(auto sel_if_false_datum,
+                        CallFunction("indices_nonzero", {invert_cond_datum}));
+  DCHECK(sel_if_false_datum.is_array());
+  auto sel_if_false_array = sel_if_false_datum.make_array();
+
+  // 5. Take the "false" rows from input.
+  ARROW_ASSIGN_OR_RAISE(auto if_false_input_datum,
+                        CallFunction("take", {input_rb, sel_if_false_datum}));
+
+  DCHECK_EQ(if_true_input_datum.kind(), Datum::RECORD_BATCH);
+  auto if_true_input_batch = ExecBatch(*if_true_input_datum.record_batch());
+
+  DCHECK_EQ(if_false_input_datum.kind(), Datum::RECORD_BATCH);
+  auto if_false_input_batch = ExecBatch(*if_false_input_datum.record_batch());
+
+  // 6. Evaluate "true" branch on the "true" rows.
+  ARROW_ASSIGN_OR_RAISE(auto bound_if_true, if_true.Bind(*schema));
+  ARROW_ASSIGN_OR_RAISE(auto if_true_result_datum,
+                        ExecuteScalarExpression(bound_if_true, if_true_input_batch));
+  DCHECK(if_true_result_datum.is_array());
+  auto if_true_result_array = if_true_result_datum.make_array();
+
+  // 7. Evaluate "false" branch on the "false" rows.
+  ARROW_ASSIGN_OR_RAISE(auto bound_if_false, if_false.Bind(*schema));
+  ARROW_ASSIGN_OR_RAISE(auto if_false_result_datum,
+                        ExecuteScalarExpression(bound_if_false, if_false_input_batch));
+  DCHECK(if_false_result_datum.is_array());
+  auto if_false_result_array = if_false_result_datum.make_array();
+
+  // 8. Combine the "true"/"false" results/selection vectors into chunked arrays.
+  auto result_ca = std::make_shared<ChunkedArray>(
+      ArrayVector{if_true_result_array, if_false_result_array});
+  auto sel_ca =
+      std::make_shared<ChunkedArray>(ArrayVector{sel_if_true_array, sel_if_false_array});
+
+  // 9. Finally, permute the "true"/"false" results to their original positions in the
+  // input (according to the selection vectors). Note we didn't handle the rows with nulls
+  // in the mask, because Permute will fill nulls for these rows and this is equal to the
+  // null handling policy of if-else, which is pretty nice.
+  return Permute(/*values=*/result_ca, /*indices=*/sel_ca,
+                 /*output_length=*/input.length);
+}
+
+void DoTestIfElse(const Expression& cond, const Expression& if_true,
+                  const Expression& if_false, const std::shared_ptr<Schema>& schema,
+                  const ExecBatch& input) {
+  ASSERT_OK_AND_ASSIGN(Datum result_by_expr,
+                       ExecuteIfElseByExpr(cond, if_true, if_false, schema, input));
+  ASSERT_TRUE(result_by_expr.is_array());
+  ASSERT_OK_AND_ASSIGN(Datum result_by_permute,
+                       ExecuteIfElseByPermute(cond, if_true, if_false, schema, input));
+  ASSERT_TRUE(result_by_permute.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_by_permute_concat,
+                       Concatenate(result_by_permute.chunked_array()->chunks()));
+
+  AssertDatumsEqual(result_by_expr, result_by_permute_concat);
+}
+
+void DoTestIfElse(const Expression& cond, const Expression& if_true,
+                  const Expression& if_false, const std::shared_ptr<Schema>& schema,
+                  const ExecBatch& input, const std::shared_ptr<Array>& expected) {
+  ASSERT_OK_AND_ASSIGN(Datum result,
+                       ExecuteIfElseByPermute(cond, if_true, if_false, schema, input));
+  ASSERT_TRUE(result.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_concat, Concatenate(result.chunked_array()->chunks()));
+
+  AssertDatumsEqual(expected, result_concat);
+}
+
+}  // namespace
+
+TEST(Permute, IfElse) {
+  {
+    ARROW_SCOPED_TRACE("if (b != 0) then a / b else b");
+    auto cond = call("not_equal", {field_ref("b"), literal(0)});
+    auto if_true = call("divide", {field_ref("a"), field_ref("b")});
+    auto if_false = field_ref("b");
+    auto schema = arrow::schema({field("a", int32()), field("b", int32())});
+    {
+      auto rb = RecordBatchFromJSON(schema, R"([
+        [1, 1],
+        [2, 1],
+        [3, 0],
+        [4, 1],
+        [5, 1]
+      ])");
+      auto input = ExecBatch(*rb);
+
+      ASSERT_RAISES_WITH_MESSAGE(
+          Invalid, "Invalid: divide by zero",
+          ExecuteIfElseByExpr(cond, if_true, if_false, schema, input));
+
+      auto expected = ArrayFromJSON(int32(), "[1, 2, 0, 4, 5]");
+      DoTestIfElse(cond, if_true, if_false, schema, input, expected);
+    }
+  }
+  {
+    ARROW_SCOPED_TRACE("if (a > b) then a else b");
+    auto cond = call("greater", {field_ref("a"), field_ref("b")});
+    auto if_true = field_ref("a");
+    auto if_false = field_ref("b");
+    constexpr int64_t length = 5;
+    for (const auto& type : kNumericTypes) {
+      ARROW_SCOPED_TRACE("Type " + type->ToString());
+      auto schema = arrow::schema({field("a", type), field("b", type)});
+      auto big = ArrayFromJSON(type, "[1, 2, 3, 4, 5]");
+      auto small = ArrayFromJSON(type, "[0, 1, 2, 3, 4]");
+      {
+        ARROW_SCOPED_TRACE("All true");
+        auto input =
+            ExecBatch(*RecordBatch::Make(schema, length, {/*a=*/big, /*b=*/small}));
+        DoTestIfElse(cond, if_true, if_false, schema, input);
+      }
+      {
+        ARROW_SCOPED_TRACE("All false");
+        auto input =
+            ExecBatch(*RecordBatch::Make(schema, length, {/*a=*/small, /*b=*/big}));
+        DoTestIfElse(cond, if_true, if_false, schema, input);
+      }
+    }
+    {
+      ARROW_SCOPED_TRACE("Random");
+      auto rng = random::RandomArrayGenerator(42);
+      constexpr int64_t length = 1024;
+      constexpr int repeat = 10;
+      for (const auto& type : kNumericAndBaseBinaryTypes) {
+        ARROW_SCOPED_TRACE("Type " + type->ToString());
+        auto schema = arrow::schema({field("a", type), field("b", type)});
+        for (int i = 0; i < repeat; ++i) {
+          auto a = rng.ArrayOf(type, length, /*null_probability=*/0.2);
+          auto b = rng.ArrayOf(type, length, /*null_probability=*/0.2);
+          auto input =
+              ExecBatch(*RecordBatch::Make(schema, length, {std::move(a), std::move(b)}));
+          DoTestIfElse(cond, if_true, if_false, schema, input);
+        }
+      }
+    }
+  }
+}
+
+}  // namespace arrow::compute

From 154ad9535378c2fd4cbfeee374e13884f89dd06a Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 14 Oct 2024 02:24:18 +0800
Subject: [PATCH 25/54] Update some comments

---
 cpp/src/arrow/compute/kernels/vector_placement_test.cc | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index 01a4ab2ad246f..4c847852f4e62 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -372,7 +372,7 @@ void DoTestPermuteAAA(const std::shared_ptr<Array>& values,
 }
 
 /// The following helper functions are based on the invariant:
-/// PermuteXXA([V, V], [I', I''], 2 * l) == Concat(E, E)
+/// Permute([V, V], [I', I''], 2 * l) == Concat(E, E)
 ///
 /// where
 ///   V = values
@@ -1008,6 +1008,9 @@ void DoTestIfElse(const Expression& cond, const Expression& if_true,
   ASSERT_TRUE(result_by_expr.is_array());
   ASSERT_OK_AND_ASSIGN(Datum result_by_permute,
                        ExecuteIfElseByPermute(cond, if_true, if_false, schema, input));
+  // Permute will output chunked array because we inputs values and indices as chunked
+  // arrays consisting of each branches. We don't care the shape of the output when
+  // comparing the results - only contents, so we concatenate the chunked array.
   ASSERT_TRUE(result_by_permute.is_chunked_array());
   ASSERT_OK_AND_ASSIGN(auto result_by_permute_concat,
                        Concatenate(result_by_permute.chunked_array()->chunks()));

From 66d977a5368a74a9e179047b152ec167f00fde32 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 14 Oct 2024 11:57:54 +0800
Subject: [PATCH 26/54] Fix lint

---
 cpp/src/arrow/compute/api_vector.h     | 6 ++++--
 cpp/src/arrow/compute/function_test.cc | 4 ++++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index dbc8bee753d18..f9448ff0b8794 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -261,7 +261,7 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
 class ARROW_EXPORT ReverseIndicesOptions : public FunctionOptions {
  public:
   explicit ReverseIndicesOptions(int64_t output_length = -1,
-                                 std::shared_ptr<DataType> output_type = nullptr);
+                                 std::shared_ptr<DataType> output_type = NULLPTR);
   static constexpr char const kTypeName[] = "ReverseIndicesOptions";
   static ReverseIndicesOptions Defaults() { return ReverseIndicesOptions(); }
 
@@ -272,7 +272,7 @@ class ARROW_EXPORT ReverseIndicesOptions : public FunctionOptions {
   /// \brief The type of the output reverse indices. If null, the output will be of the
   /// same type as the input indices, otherwise must be integer types. An invalid error
   /// will be reported if this type is not able to store the length of the input indices.
-  std::shared_ptr<DataType> output_type = nullptr;
+  std::shared_ptr<DataType> output_type = NULLPTR;
 };
 
 /// \brief Options for permute function
@@ -755,6 +755,7 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
 ///
 /// \since 19.0.0
 /// \note API not yet finalized
+ARROW_EXPORT
 Result<Datum> ReverseIndices(
     const Datum& indices,
     const ReverseIndicesOptions& options = ReverseIndicesOptions::Defaults(),
@@ -781,6 +782,7 @@ Result<Datum> ReverseIndices(
 ///
 /// \since 19.0.0
 /// \note API not yet finalized
+ARROW_EXPORT
 Result<Datum> Permute(const Datum& values, const Datum& indices,
                       const PermuteOptions& options = PermuteOptions::Defaults(),
                       ExecContext* ctx = NULLPTR);
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index c269de0763217..657cb2aeefc0f 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -136,6 +136,10 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new SelectKOptions(5, {{SortKey("key", SortOrder::Ascending)}}));
   options.emplace_back(new Utf8NormalizeOptions());
   options.emplace_back(new Utf8NormalizeOptions(Utf8NormalizeOptions::NFD));
+  options.emplace_back(
+      new ReverseIndicesOptions(/*output_length=*/42, /*output_type=*/int32()));
+  options.emplace_back(new PermuteOptions());
+  options.emplace_back(new PermuteOptions(/*output_length=*/42));
 
   for (size_t i = 0; i < options.size(); i++) {
     const size_t prev_i = i == 0 ? options.size() - 1 : i - 1;

From 846039d8c821cda4dc9f8b736d2174c7dd0f7d40 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 14 Oct 2024 12:43:14 +0800
Subject: [PATCH 27/54] Update comment

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

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index 4c847852f4e62..d321748f07645 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -380,7 +380,7 @@ void DoTestPermuteAAA(const std::shared_ptr<Array>& values,
 ///   l = output_length
 ///   I' = ReplaceWithMask(I, i >= l, null)
 ///   I'' = ReplaceWithMask(I, i < 0, null) + l
-///   E = PermuteAAA(V, I, l)
+///   E = Permute(V, I, l)
 
 /// Make indices prefix I' = ReplaceWithMask(I, i >= l, null).
 Result<std::shared_ptr<Array>> MakeIndicesPrefix(const std::shared_ptr<Array>& indices,

From 2f2ae47e0d31b0cd01d6c1871cdcd79365a7e808 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 14 Oct 2024 12:53:40 +0800
Subject: [PATCH 28/54] Fix typo

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

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index d321748f07645..c274b064bb41a 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -954,8 +954,8 @@ Result<Datum> ExecuteIfElseByPermute(const Expression& cond, const Expression& i
   ARROW_ASSIGN_OR_RAISE(auto if_true_input_datum,
                         CallFunction("take", {input_rb, sel_if_true_datum}));
 
-  // 4. Get indices of "false"es form the mas as the selection vector - by first inverting
-  // the mask and then getting the non-zero's indices.
+  // 4. Get indices of "false"es from the mask as the selection vector - by first
+  // inverting the mask and then getting the non-zero's indices.
   ARROW_ASSIGN_OR_RAISE(auto invert_cond_datum, CallFunction("invert", {cond_datum}));
   ARROW_ASSIGN_OR_RAISE(auto sel_if_false_datum,
                         CallFunction("indices_nonzero", {invert_cond_datum}));

From 3af49a8e4bad00e1d3ef9f6d9868c112eb7bf9cc Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 14 Oct 2024 17:04:59 +0800
Subject: [PATCH 29/54] Typo

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

diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_placement.cc
index d8075202caf0f..21546f0e7f7e9 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement.cc
@@ -116,7 +116,7 @@ struct ReverseIndicesImpl {
 
     RETURN_NOT_OK(CheckInput(output_type));
 
-    // Dispatch the execution based on wether there are likely many nulls in the output.
+    // Dispatch the execution based on whether there are likely many nulls in the output.
     // - If many nulls (i.e. the output is "sparse"), preallocate an all-false validity
     // buffer and an uninitialized data buffer. The subsequent processing will fill the
     // valid values only.

From 944609c0f4c68a73633d32ca1fd75c2a57198eb2 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Thu, 17 Oct 2024 19:34:55 +0800
Subject: [PATCH 30/54] Refine

---
 .../arrow/compute/kernels/vector_placement_test.cc   | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index c274b064bb41a..baace2d8fb0e0 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -918,7 +918,7 @@ TYPED_TEST(TestPermuteString, Basic) {
 
 namespace {
 
-/// Execute an if-else expression using regular expression evaluation, as a reference.
+/// Execute an if-else expression using regular evaluation, as a reference.
 Result<Datum> ExecuteIfElseByExpr(const Expression& cond, const Expression& if_true,
                                   const Expression& if_false,
                                   const std::shared_ptr<Schema>& schema,
@@ -1038,20 +1038,24 @@ TEST(Permute, IfElse) {
     auto if_true = call("divide", {field_ref("a"), field_ref("b")});
     auto if_false = field_ref("b");
     auto schema = arrow::schema({field("a", int32()), field("b", int32())});
-    {
-      auto rb = RecordBatchFromJSON(schema, R"([
+    auto rb = RecordBatchFromJSON(schema, R"([
         [1, 1],
         [2, 1],
         [3, 0],
         [4, 1],
         [5, 1]
       ])");
-      auto input = ExecBatch(*rb);
+    auto input = ExecBatch(*rb);
 
+    {
+      ARROW_SCOPED_TRACE("Regular evaluation");
       ASSERT_RAISES_WITH_MESSAGE(
           Invalid, "Invalid: divide by zero",
           ExecuteIfElseByExpr(cond, if_true, if_false, schema, input));
+    }
 
+    {
+      ARROW_SCOPED_TRACE("Special form");
       auto expected = ArrayFromJSON(int32(), "[1, 2, 0, 4, 5]");
       DoTestIfElse(cond, if_true, if_false, schema, input, expected);
     }

From e132f0d73e188421401efbf5d0d6d1b7f9dfcc37 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 31 Oct 2024 15:17:32 +0800
Subject: [PATCH 31/54] Update
 cpp/src/arrow/compute/kernels/vector_placement_test.cc

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

diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
index baace2d8fb0e0..5bb5e23457678 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_placement_test.cc
@@ -1008,7 +1008,7 @@ void DoTestIfElse(const Expression& cond, const Expression& if_true,
   ASSERT_TRUE(result_by_expr.is_array());
   ASSERT_OK_AND_ASSIGN(Datum result_by_permute,
                        ExecuteIfElseByPermute(cond, if_true, if_false, schema, input));
-  // Permute will output chunked array because we inputs values and indices as chunked
+  // Permute will output chunked array because we input values and indices as chunked
   // arrays consisting of each branches. We don't care the shape of the output when
   // comparing the results - only contents, so we concatenate the chunked array.
   ASSERT_TRUE(result_by_permute.is_chunked_array());

From 220598b8af200ae169ff85b05f183579eca12359 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 4 Nov 2024 13:30:36 +0800
Subject: [PATCH 32/54] Rename function category to swizzle

---
 cpp/src/arrow/CMakeLists.txt                                | 6 +++---
 cpp/src/arrow/compute/kernels/CMakeLists.txt                | 4 ++--
 .../kernels/{vector_placement.cc => vector_swizzle.cc}      | 2 +-
 .../{vector_placement_test.cc => vector_swizzle_test.cc}    | 0
 cpp/src/arrow/compute/registry.cc                           | 2 +-
 cpp/src/arrow/compute/registry_internal.h                   | 2 +-
 docs/source/cpp/compute.rst                                 | 5 ++---
 7 files changed, 10 insertions(+), 11 deletions(-)
 rename cpp/src/arrow/compute/kernels/{vector_placement.cc => vector_swizzle.cc} (99%)
 rename cpp/src/arrow/compute/kernels/{vector_placement_test.cc => vector_swizzle_test.cc} (100%)

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 69a0d52512931..f1304d5640f22 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -786,14 +786,14 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_validity.cc
        compute/kernels/vector_array_sort.cc
        compute/kernels/vector_cumulative_ops.cc
-       compute/kernels/vector_pairwise.cc
-       compute/kernels/vector_placement.cc
        compute/kernels/vector_nested.cc
+       compute/kernels/vector_pairwise.cc
        compute/kernels/vector_rank.cc
        compute/kernels/vector_replace.cc
        compute/kernels/vector_run_end_encode.cc
        compute/kernels/vector_select_k.cc
-       compute/kernels/vector_sort.cc)
+       compute/kernels/vector_sort.cc
+       compute/kernels/vector_swizzle.cc)
 
   append_runtime_avx2_src(ARROW_COMPUTE_SRCS compute/kernels/aggregate_basic_avx2.cc)
   append_runtime_avx512_src(ARROW_COMPUTE_SRCS compute/kernels/aggregate_basic_avx512.cc)
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 9499a16b9ef7a..84b508f5d9be4 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -115,9 +115,9 @@ add_arrow_compute_test(vector_selection_test
                        EXTRA_LINK_LIBS
                        arrow_compute_kernels_testing)
 
-add_arrow_compute_test(vector_placement_test
+add_arrow_compute_test(vector_swizzle_test
                        SOURCES
-                       vector_placement_test.cc
+                       vector_swizzle_test.cc
                        EXTRA_LINK_LIBS
                        arrow_compute_kernels_testing)
 
diff --git a/cpp/src/arrow/compute/kernels/vector_placement.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
similarity index 99%
rename from cpp/src/arrow/compute/kernels/vector_placement.cc
rename to cpp/src/arrow/compute/kernels/vector_swizzle.cc
index 21546f0e7f7e9..41fb9107722de 100644
--- a/cpp/src/arrow/compute/kernels/vector_placement.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -412,7 +412,7 @@ void RegisterVectorPermute(FunctionRegistry* registry) {
 
 // ----------------------------------------------------------------------
 
-void RegisterVectorPlacement(FunctionRegistry* registry) {
+void RegisterVectorSwizzle(FunctionRegistry* registry) {
   RegisterVectorReverseIndices(registry);
   RegisterVectorPermute(registry);
 }
diff --git a/cpp/src/arrow/compute/kernels/vector_placement_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
similarity index 100%
rename from cpp/src/arrow/compute/kernels/vector_placement_test.cc
rename to cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
diff --git a/cpp/src/arrow/compute/registry.cc b/cpp/src/arrow/compute/registry.cc
index 557d7d7b7e408..ef9f3c7e1fbf5 100644
--- a/cpp/src/arrow/compute/registry.cc
+++ b/cpp/src/arrow/compute/registry.cc
@@ -321,7 +321,7 @@ static std::unique_ptr<FunctionRegistry> CreateBuiltInRegistry() {
   RegisterVectorRunEndEncode(registry.get());
   RegisterVectorRunEndDecode(registry.get());
   RegisterVectorPairwise(registry.get());
-  RegisterVectorPlacement(registry.get());
+  RegisterVectorSwizzle(registry.get());
 
   // Aggregate functions
   RegisterHashAggregateBasic(registry.get());
diff --git a/cpp/src/arrow/compute/registry_internal.h b/cpp/src/arrow/compute/registry_internal.h
index 36f8067219700..8287e6305086d 100644
--- a/cpp/src/arrow/compute/registry_internal.h
+++ b/cpp/src/arrow/compute/registry_internal.h
@@ -56,7 +56,7 @@ void RegisterVectorSort(FunctionRegistry* registry);
 void RegisterVectorRunEndEncode(FunctionRegistry* registry);
 void RegisterVectorRunEndDecode(FunctionRegistry* registry);
 void RegisterVectorPairwise(FunctionRegistry* registry);
-void RegisterVectorPlacement(FunctionRegistry* registry);
+void RegisterVectorSwizzle(FunctionRegistry* registry);
 void RegisterVectorOptions(FunctionRegistry* registry);
 
 // Aggregate functions
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index ccd605e121a89..1061494693390 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1899,11 +1899,10 @@ operation to the n-th and (n+abs(p))-th inputs.
 * \(2) Wraps around the result when overflow is detected.
 * \(3) Returns an ``Invalid`` :class:`Status` when overflow is detected.
 
-Placement functions
+Swizzle functions
 ~~~~~~~~~~~~~~~~~~~
 
-Placement functions reorder the input array based on placement arguments, e.g.
-indices.
+Swizzle functions reorder the input array based on targeting indices.
 
 +-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
 | Function name   | Arity  | Input type 1 | Input type 2 | Output type  | Options class                   | Notes |

From c03f6e086dbc7b043b455115c07fb9bf33f37e2a Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 4 Nov 2024 13:52:57 +0800
Subject: [PATCH 33/54] reverse_indices -> inverse_permutation

---
 cpp/src/arrow/compute/api_vector.cc           |  26 ++--
 cpp/src/arrow/compute/api_vector.h            |  48 +++----
 cpp/src/arrow/compute/function_test.cc        |   2 +-
 .../arrow/compute/kernels/vector_swizzle.cc   | 110 +++++++--------
 .../compute/kernels/vector_swizzle_test.cc    | 126 +++++++++---------
 docs/source/cpp/compute.rst                   |  18 +--
 6 files changed, 170 insertions(+), 160 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index ea4069381ec5a..a9bf6d59b582b 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -155,9 +155,10 @@ static auto kPairwiseOptionsType = GetFunctionOptionsType<PairwiseOptions>(
     DataMember("periods", &PairwiseOptions::periods));
 static auto kListFlattenOptionsType = GetFunctionOptionsType<ListFlattenOptions>(
     DataMember("recursive", &ListFlattenOptions::recursive));
-static auto kReverseIndicesOptionsType = GetFunctionOptionsType<ReverseIndicesOptions>(
-    DataMember("output_length", &ReverseIndicesOptions::output_length),
-    DataMember("output_type", &ReverseIndicesOptions::output_type));
+static auto kInversePermutationOptionsType =
+    GetFunctionOptionsType<InversePermutationOptions>(
+        DataMember("output_length", &InversePermutationOptions::output_length),
+        DataMember("output_type", &InversePermutationOptions::output_type));
 static auto kPermuteOptionsType = GetFunctionOptionsType<PermuteOptions>(
     DataMember("output_length", &PermuteOptions::output_length));
 }  // namespace
@@ -235,12 +236,12 @@ ListFlattenOptions::ListFlattenOptions(bool recursive)
     : FunctionOptions(internal::kListFlattenOptionsType), recursive(recursive) {}
 constexpr char ListFlattenOptions::kTypeName[];
 
-ReverseIndicesOptions::ReverseIndicesOptions(int64_t output_length,
-                                             std::shared_ptr<DataType> output_type)
-    : FunctionOptions(internal::kReverseIndicesOptionsType),
+InversePermutationOptions::InversePermutationOptions(
+    int64_t output_length, std::shared_ptr<DataType> output_type)
+    : FunctionOptions(internal::kInversePermutationOptionsType),
       output_length(output_length),
       output_type(std::move(output_type)) {}
-constexpr char ReverseIndicesOptions::kTypeName[];
+constexpr char InversePermutationOptions::kTypeName[];
 
 PermuteOptions::PermuteOptions(int64_t output_length)
     : FunctionOptions(internal::kPermuteOptionsType), output_length(output_length) {}
@@ -260,7 +261,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kRankOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPairwiseOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kListFlattenOptionsType));
-  DCHECK_OK(registry->AddFunctionOptionsType(kReverseIndicesOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kInversePermutationOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPermuteOptionsType));
 }
 }  // namespace internal
@@ -448,11 +449,12 @@ Result<Datum> CumulativeMean(const Datum& values, const CumulativeOptions& optio
 }
 
 // ----------------------------------------------------------------------
-// Placement functions
+// Swizzle functions
 
-Result<Datum> ReverseIndices(const Datum& indices, const ReverseIndicesOptions& options,
-                             ExecContext* ctx) {
-  return CallFunction("reverse_indices", {indices}, &options, ctx);
+Result<Datum> InversePermutation(const Datum& indices,
+                                 const InversePermutationOptions& options,
+                                 ExecContext* ctx) {
+  return CallFunction("inverse_permutation", {indices}, &options, ctx);
 }
 
 Result<Datum> Permute(const Datum& values, const Datum& indices,
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index f9448ff0b8794..3a6547020eed0 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -257,21 +257,22 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
   bool recursive = false;
 };
 
-/// \brief Options for reverse_indices function
-class ARROW_EXPORT ReverseIndicesOptions : public FunctionOptions {
+/// \brief Options for inverse_permutation function
+class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
  public:
-  explicit ReverseIndicesOptions(int64_t output_length = -1,
-                                 std::shared_ptr<DataType> output_type = NULLPTR);
-  static constexpr char const kTypeName[] = "ReverseIndicesOptions";
-  static ReverseIndicesOptions Defaults() { return ReverseIndicesOptions(); }
-
-  /// \brief The length of the output reverse indices. If negative, the output will be of
-  /// the same length as the input indices. Any indices that are greater or equal to this
-  /// length will be ignored.
+  explicit InversePermutationOptions(int64_t output_length = -1,
+                                     std::shared_ptr<DataType> output_type = NULLPTR);
+  static constexpr char const kTypeName[] = "InversePermutationOptions";
+  static InversePermutationOptions Defaults() { return InversePermutationOptions(); }
+
+  /// \brief The length of the output inverse permutation. If negative, the output will be
+  /// of the same length as the input indices. Any indices that are greater or equal to
+  /// this length will be ignored.
   int64_t output_length = -1;
-  /// \brief The type of the output reverse indices. If null, the output will be of the
-  /// same type as the input indices, otherwise must be integer types. An invalid error
-  /// will be reported if this type is not able to store the length of the input indices.
+  /// \brief The type of the output inverse permutation. If null, the output will be of
+  /// the same type as the input indices, otherwise must be integer types. An invalid
+  /// error will be reported if this type is not able to store the length of the input
+  /// indices.
   std::shared_ptr<DataType> output_type = NULLPTR;
 };
 
@@ -736,29 +737,30 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
                                             bool check_overflow = false,
                                             ExecContext* ctx = NULLPTR);
 
-/// \brief Return the reverse indices of the given indices.
+/// \brief Return the inverse permutation of the given indices.
 ///
-/// For indices[i] = x, reverse_indices[x] = i. And reverse_indices[x] = null if x does
-/// not appear in the input indices. For indices[i] = x where x < 0 or x >= output_length,
-/// it is ignored. If multiple indices point to the same value, the last one is used.
+/// For indices[i] = x, inverse_permutation[x] = i. And inverse_permutation[x] = null if x
+/// does not appear in the input indices. For indices[i] = x where x < 0 or x >=
+/// output_length, it is ignored. If multiple indices point to the same value, the last
+/// one is used.
 ///
-/// For example, with indices = [null, 0, 3, 2, 4, 1, 1], the reverse indices is
+/// For example, with indices = [null, 0, 3, 2, 4, 1, 1], the inverse permutation is
 ///   [1, 6, 3]                    if output_length = 3,
 ///   [1, 6, 3, 2, 4, null, null]  if output_length = 7.
-/// output_length can also be negative, in which case the reverse indices is of the same
-/// length as the indices.
+/// output_length can also be negative, in which case the inverse permutation is of the
+/// same length as the indices.
 ///
 /// \param[in] indices array-like indices
 /// \param[in] options configures the output length and the output type
 /// \param[in] ctx the function execution context, optional
-/// \return the resulting reverse indices
+/// \return the resulting inverse permutation
 ///
 /// \since 19.0.0
 /// \note API not yet finalized
 ARROW_EXPORT
-Result<Datum> ReverseIndices(
+Result<Datum> InversePermutation(
     const Datum& indices,
-    const ReverseIndicesOptions& options = ReverseIndicesOptions::Defaults(),
+    const InversePermutationOptions& options = InversePermutationOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
 /// \brief Permute the values into specified positions according to the indices.
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index 657cb2aeefc0f..af9cd4c8b1d76 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -137,7 +137,7 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new Utf8NormalizeOptions());
   options.emplace_back(new Utf8NormalizeOptions(Utf8NormalizeOptions::NFD));
   options.emplace_back(
-      new ReverseIndicesOptions(/*output_length=*/42, /*output_type=*/int32()));
+      new InversePermutationOptions(/*output_length=*/42, /*output_type=*/int32()));
   options.emplace_back(new PermuteOptions());
   options.emplace_back(new PermuteOptions(/*output_length=*/42));
 
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index 41fb9107722de..d9eedaab91a61 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -27,32 +27,33 @@ namespace arrow::compute::internal {
 namespace {
 
 // ----------------------------------------------------------------------
-// ReverseIndices
+// InversePermutation
 
-const FunctionDoc reverse_indices_doc(
-    "Return the reverse indices of the given indices",
+const FunctionDoc inverse_permutation_doc(
+    "Return the inverse permutation of the given indices",
     "For the `i`-th `index` in `indices`, the `index`-th output is `i`", {"indices"});
 
-const ReverseIndicesOptions* GetDefaultReverseIndicesOptions() {
-  static const auto kDefaultReverseIndicesOptions = ReverseIndicesOptions::Defaults();
-  return &kDefaultReverseIndicesOptions;
+const InversePermutationOptions* GetDefaultInversePermutationOptions() {
+  static const auto kDefaultInversePermutationOptions =
+      InversePermutationOptions::Defaults();
+  return &kDefaultInversePermutationOptions;
 }
 
-using ReverseIndicesState = OptionsWrapper<ReverseIndicesOptions>;
+using InversePermutationState = OptionsWrapper<InversePermutationOptions>;
 
-/// Resolve the output type of reverse_indices. The output type is specified in the
+/// Resolve the output type of inverse_permutation. The output type is specified in the
 /// options, and if null, set it to the input type. The output type must be integer.
-Result<TypeHolder> ResolveReverseIndicesOutputType(
+Result<TypeHolder> ResolveInversePermutationOutputType(
     KernelContext* ctx, const std::vector<TypeHolder>& input_types) {
   DCHECK_EQ(input_types.size(), 1);
   DCHECK_NE(input_types[0], nullptr);
 
-  std::shared_ptr<DataType> output_type = ReverseIndicesState::Get(ctx).output_type;
+  std::shared_ptr<DataType> output_type = InversePermutationState::Get(ctx).output_type;
   if (!output_type) {
     output_type = input_types[0].owned_type;
   }
   if (!is_integer(output_type->id())) {
-    return Status::Invalid("Output type of reverse_indices must be integer, got " +
+    return Status::Invalid("Output type of inverse_permutation must be integer, got " +
                            output_type->ToString());
   }
 
@@ -60,8 +61,8 @@ Result<TypeHolder> ResolveReverseIndicesOutputType(
 }
 
 template <typename ExecType>
-struct ReverseIndicesImpl {
-  using ThisType = ReverseIndicesImpl<ExecType>;
+struct InversePermutationImpl {
+  using ThisType = InversePermutationImpl<ExecType>;
   using IndexType = typename ExecType::IndexType;
   using IndexCType = typename IndexType::c_type;
   using ShapeType = typename ExecType::ShapeType;
@@ -69,7 +70,7 @@ struct ReverseIndicesImpl {
   static Result<std::shared_ptr<ArrayData>> Exec(
       KernelContext* ctx, const ShapeType& indices, int64_t input_length,
       const std::shared_ptr<DataType>& input_type) {
-    const auto& options = ReverseIndicesState::Get(ctx);
+    const auto& options = InversePermutationState::Get(ctx);
 
     // Apply default options semantics.
     int64_t output_length = options.output_length;
@@ -98,8 +99,8 @@ struct ReverseIndicesImpl {
   std::shared_ptr<Buffer> data_buf = nullptr;
 
  private:
-  ReverseIndicesImpl(KernelContext* ctx, const ShapeType& indices, int64_t input_length,
-                     int64_t output_length)
+  InversePermutationImpl(KernelContext* ctx, const ShapeType& indices,
+                         int64_t input_length, int64_t output_length)
       : ctx(ctx),
         indices(indices),
         input_length(input_length),
@@ -123,8 +124,8 @@ struct ReverseIndicesImpl {
     // - Otherwise (i.e. the output is "dense"), the validity buffer is lazily allocated
     // and initialized all-true in the subsequent processing only when needed. The data
     // buffer is preallocated and filled with all "impossible" values (that is,
-    // input_length - note that the range of reverse_indices is [0, input_length)) for the
-    // subsequent processing to detect validity.
+    // input_length - note that the range of inverse_permutation is [0, input_length)) for
+    // the subsequent processing to detect validity.
     bool likely_many_nulls = LikelyManyNulls();
     if (likely_many_nulls) {
       RETURN_NOT_OK(AllocateValidityBufAndFill(false));
@@ -145,7 +146,7 @@ struct ReverseIndicesImpl {
       if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length) {
         return Status::Invalid(
             "Output type " + output_type.ToString() +
-            " of reverse_indices is insufficient to store indices of length " +
+            " of inverse_permutation is insufficient to store indices of length " +
             std::to_string(input_length));
       }
     }
@@ -199,23 +200,23 @@ struct ReverseIndicesImpl {
     }
     DCHECK_NE(data_buf, nullptr);
     OutputCType* data = data_buf->mutable_data_as<OutputCType>();
-    int64_t reverse_index = 0;
+    int64_t inverse = 0;
     RETURN_NOT_OK(ExecType::template VisitIndices(
         indices,
         [&](IndexCType index) {
           if (ARROW_PREDICT_TRUE(index >= 0 &&
                                  static_cast<int64_t>(index) < output_length)) {
-            data[index] = static_cast<OutputCType>(reverse_index);
+            data[index] = static_cast<OutputCType>(inverse);
             // If many nulls, set validity to true for valid values.
             if constexpr (likely_many_nulls) {
               bit_util::SetBitTo(validity, index, true);
             }
           }
-          ++reverse_index;
+          ++inverse;
           return Status::OK();
         },
         [&]() {
-          ++reverse_index;
+          ++inverse;
           return Status::OK();
         }));
 
@@ -242,8 +243,8 @@ struct ReverseIndicesImpl {
 };
 
 template <typename Ignored, typename Type>
-struct ReverseIndices {
-  using ThisType = ReverseIndices<Ignored, Type>;
+struct InversePermutation {
+  using ThisType = InversePermutation<Ignored, Type>;
   using IndexType = Type;
   using ShapeType = ArraySpan;
 
@@ -259,15 +260,15 @@ struct ReverseIndices {
     DCHECK(span[0].is_array());
     const auto& indices = span[0].array;
     ARROW_ASSIGN_OR_RAISE(
-        result->value, ReverseIndicesImpl<ThisType>::Exec(ctx, indices, indices.length,
-                                                          indices.type->GetSharedPtr()));
+        result->value, InversePermutationImpl<ThisType>::Exec(
+                           ctx, indices, indices.length, indices.type->GetSharedPtr()));
     return Status::OK();
   }
 };
 
 template <typename Ignored, typename Type>
-struct ReverseIndicesChunked {
-  using ThisType = ReverseIndicesChunked<Ignored, Type>;
+struct InversePermutationChunked {
+  using ThisType = InversePermutationChunked<Ignored, Type>;
   using IndexType = Type;
   using ShapeType = std::shared_ptr<ChunkedArray>;
 
@@ -286,28 +287,30 @@ struct ReverseIndicesChunked {
     DCHECK_EQ(batch.num_values(), 1);
     DCHECK(batch[0].is_chunked_array());
     const auto& indices = batch[0].chunked_array();
-    ARROW_ASSIGN_OR_RAISE(auto reverse_indices,
-                          ReverseIndicesImpl<ThisType>::Exec(
+    ARROW_ASSIGN_OR_RAISE(auto inverse_permutation,
+                          InversePermutationImpl<ThisType>::Exec(
                               ctx, indices, indices->length(), indices->type()));
     *result =
-        Datum(std::make_shared<ChunkedArray>(MakeArray(std::move(reverse_indices))));
+        Datum(std::make_shared<ChunkedArray>(MakeArray(std::move(inverse_permutation))));
     return Status::OK();
   }
 };
 
-void RegisterVectorReverseIndices(FunctionRegistry* registry) {
-  auto function = std::make_shared<VectorFunction>("reverse_indices", Arity::Unary(),
-                                                   reverse_indices_doc,
-                                                   GetDefaultReverseIndicesOptions());
+void RegisterVectorInversePermutation(FunctionRegistry* registry) {
+  auto function = std::make_shared<VectorFunction>("inverse_permutation", Arity::Unary(),
+                                                   inverse_permutation_doc,
+                                                   GetDefaultInversePermutationOptions());
 
   auto add_kernel = [&function](Type::type type_id) {
     VectorKernel kernel;
-    kernel.signature = KernelSignature::Make({InputType(match::SameTypeId(type_id))},
-                                             OutputType(ResolveReverseIndicesOutputType));
-    kernel.init = ReverseIndicesState::Init;
-    kernel.exec = GenerateInteger<ReverseIndices, void, ArrayKernelExec>(type_id);
+    kernel.signature =
+        KernelSignature::Make({InputType(match::SameTypeId(type_id))},
+                              OutputType(ResolveInversePermutationOutputType));
+    kernel.init = InversePermutationState::Init;
+    kernel.exec = GenerateInteger<InversePermutation, void, ArrayKernelExec>(type_id);
     kernel.exec_chunked =
-        GenerateInteger<ReverseIndicesChunked, void, VectorKernel::ChunkedExec>(type_id);
+        GenerateInteger<InversePermutationChunked, void, VectorKernel::ChunkedExec>(
+            type_id);
     kernel.can_execute_chunkwise = false;
     kernel.output_chunked = false;
     DCHECK_OK(function->AddKernel(std::move(kernel)));
@@ -369,29 +372,30 @@ class PermuteMetaFunction : public MetaFunction {
     if (output_length < 0) {
       output_length = values.length();
     }
-    // Internally invoke Take(values, ReverseIndices(indices)) to implement permute.
+    // Internally invoke Take(values, InversePermutation(indices)) to implement permute.
     // For example, with
     //   values = [a, b, c, d, e, f, g]
     //   indices = [null, 0, 3, 2, 4, 1, 1]
-    // the ReverseIndices(indices) is
+    // the InversePermutation(indices) is
     //   [1, 6, 3]                    if output_length = 3,
     //   [1, 6, 3, 2, 4, null, null]  if output_length = 7.
-    // and Take(values, ReverseIndices(indices)) is
+    // and Take(values, InversePermutation(indices)) is
     //   [b, g, d]                    if output_length = 3,
     //   [b, g, d, c, e, null, null]  if output_length = 7.
-    ReverseIndicesOptions reverse_indices_options{
+    InversePermutationOptions inverse_permutation_options{
         output_length,
-        // Use the smallest possible uint type to store reverse indices.
-        InferSmallestReverseIndicesType(values.length())};
-    ARROW_ASSIGN_OR_RAISE(
-        auto reverse_indices,
-        CallFunction("reverse_indices", {indices}, &reverse_indices_options, ctx));
+        // Use the smallest possible uint type to store inverse permutation.
+        InferSmallestInversePermutationType(values.length())};
+    ARROW_ASSIGN_OR_RAISE(auto inverse_permutation,
+                          CallFunction("inverse_permutation", {indices},
+                                       &inverse_permutation_options, ctx));
     TakeOptions take_options{/*boundcheck=*/false};
-    return CallFunction("take", {values, reverse_indices}, &take_options, ctx);
+    return CallFunction("take", {values, inverse_permutation}, &take_options, ctx);
   }
 
  private:
-  static std::shared_ptr<DataType> InferSmallestReverseIndicesType(int64_t input_length) {
+  static std::shared_ptr<DataType> InferSmallestInversePermutationType(
+      int64_t input_length) {
     if (input_length <= std::numeric_limits<uint8_t>::max()) {
       return uint8();
     } else if (input_length <= std::numeric_limits<uint16_t>::max()) {
@@ -413,7 +417,7 @@ void RegisterVectorPermute(FunctionRegistry* registry) {
 // ----------------------------------------------------------------------
 
 void RegisterVectorSwizzle(FunctionRegistry* registry) {
-  RegisterVectorReverseIndices(registry);
+  RegisterVectorInversePermutation(registry);
   RegisterVectorPermute(registry);
 }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index 5bb5e23457678..f128af26a8bb8 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -49,20 +49,21 @@ using SmallOutputTypes = ::testing::Types<UInt8Type, UInt16Type, Int8Type, Int16
 }  // namespace
 
 // ----------------------------------------------------------------------
-// ReverseIndices tests
+// InversePermutation tests
 
 namespace {
 
-Result<Datum> ReverseIndices(const Datum& indices, int64_t output_length,
-                             std::shared_ptr<DataType> output_type) {
-  ReverseIndicesOptions options{output_length, std::move(output_type)};
-  return ReverseIndices(indices, options);
+Result<Datum> InversePermutation(const Datum& indices, int64_t output_length,
+                                 std::shared_ptr<DataType> output_type) {
+  InversePermutationOptions options{output_length, std::move(output_type)};
+  return InversePermutation(indices, options);
 }
 
-void AssertReverseIndices(const Datum& indices, int64_t output_length,
-                          const std::shared_ptr<DataType>& output_type,
-                          const Datum& expected, bool validity_must_be_null) {
-  ASSERT_OK_AND_ASSIGN(auto result, ReverseIndices(indices, output_length, output_type));
+void AssertInversePermutation(const Datum& indices, int64_t output_length,
+                              const std::shared_ptr<DataType>& output_type,
+                              const Datum& expected, bool validity_must_be_null) {
+  ASSERT_OK_AND_ASSIGN(auto result,
+                       InversePermutation(indices, output_length, output_type));
   ASSERT_EQ(indices.kind(), result.kind());
   std::shared_ptr<Array> result_array;
   if (result.is_array()) {
@@ -78,40 +79,40 @@ void AssertReverseIndices(const Datum& indices, int64_t output_length,
 }
 
 template <typename InputFunc>
-void DoTestReverseIndicesForInputTypes(
+void DoTestInversePermutationForInputTypes(
     const std::vector<std::shared_ptr<DataType>>& input_types, InputFunc&& input,
     int64_t output_length, const std::shared_ptr<DataType>& output_type,
     const Datum& expected, bool validity_must_be_null = false) {
   for (const auto& input_type : input_types) {
     ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
     auto indices = input(input_type);
-    AssertReverseIndices(indices, output_length, output_type, expected,
-                         validity_must_be_null);
+    AssertInversePermutation(indices, output_length, output_type, expected,
+                             validity_must_be_null);
   }
 }
 
 template <typename InputFunc>
-void DoTestReverseIndicesForInputOutputTypes(
+void DoTestInversePermutationForInputOutputTypes(
     const std::vector<std::shared_ptr<DataType>>& input_types,
     const std::vector<std::shared_ptr<DataType>>& output_types, InputFunc&& input,
     int64_t output_length, const std::string& expected_str, bool validity_must_be_null) {
   for (const auto& output_type : kIntegerTypes) {
     ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
     auto expected = ArrayFromJSON(output_type, expected_str);
-    DoTestReverseIndicesForInputTypes(input_types, std::forward<InputFunc>(input),
-                                      output_length, output_type, expected,
-                                      validity_must_be_null);
+    DoTestInversePermutationForInputTypes(input_types, std::forward<InputFunc>(input),
+                                          output_length, output_type, expected,
+                                          validity_must_be_null);
   }
 }
 
-void TestReverseIndicesForInputOutputTypes(
+void TestInversePermutationForInputOutputTypes(
     const std::vector<std::shared_ptr<DataType>>& input_types,
     const std::vector<std::shared_ptr<DataType>>& output_types,
     const std::string& indices_str, const std::vector<std::string>& indices_chunked_str,
     int64_t output_length, const std::string& expected_str, bool validity_must_be_null) {
   {
     ARROW_SCOPED_TRACE("Array");
-    DoTestReverseIndicesForInputOutputTypes(
+    DoTestInversePermutationForInputOutputTypes(
         input_types, output_types,
         [&](const std::shared_ptr<DataType>& input_type) {
           return ArrayFromJSON(input_type, indices_str);
@@ -120,7 +121,7 @@ void TestReverseIndicesForInputOutputTypes(
   }
   {
     ARROW_SCOPED_TRACE("Chunked");
-    DoTestReverseIndicesForInputOutputTypes(
+    DoTestInversePermutationForInputOutputTypes(
         input_types, output_types,
         [&](const std::shared_ptr<DataType>& input_type) {
           return ChunkedArrayFromJSON(input_type, indices_chunked_str);
@@ -129,47 +130,48 @@ void TestReverseIndicesForInputOutputTypes(
   }
 }
 
-void TestReverseIndicesSigned(const std::string& indices_str,
-                              const std::vector<std::string>& indices_chunked_str,
-                              int64_t output_length, const std::string& expected_str,
-                              bool validity_must_be_null = false) {
-  TestReverseIndicesForInputOutputTypes(kSignedIntegerTypes, kIntegerTypes, indices_str,
-                                        indices_chunked_str, output_length, expected_str,
-                                        validity_must_be_null);
+void TestInversePermutationSigned(const std::string& indices_str,
+                                  const std::vector<std::string>& indices_chunked_str,
+                                  int64_t output_length, const std::string& expected_str,
+                                  bool validity_must_be_null = false) {
+  TestInversePermutationForInputOutputTypes(
+      kSignedIntegerTypes, kIntegerTypes, indices_str, indices_chunked_str, output_length,
+      expected_str, validity_must_be_null);
 }
 
-void TestReverseIndices(const std::string& indices_str,
-                        const std::vector<std::string>& indices_chunked_str,
-                        int64_t output_length, const std::string& expected_str,
-                        bool validity_must_be_null = false) {
-  TestReverseIndicesForInputOutputTypes(kIntegerTypes, kIntegerTypes, indices_str,
-                                        indices_chunked_str, output_length, expected_str,
-                                        validity_must_be_null);
+void TestInversePermutation(const std::string& indices_str,
+                            const std::vector<std::string>& indices_chunked_str,
+                            int64_t output_length, const std::string& expected_str,
+                            bool validity_must_be_null = false) {
+  TestInversePermutationForInputOutputTypes(kIntegerTypes, kIntegerTypes, indices_str,
+                                            indices_chunked_str, output_length,
+                                            expected_str, validity_must_be_null);
 }
 
 }  // namespace
 
-TEST(ReverseIndices, InvalidOutputType) {
+TEST(InversePermutation, InvalidOutputType) {
   {
     ARROW_SCOPED_TRACE("Output type float");
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid, "Invalid: Output type of reverse_indices must be integer, got float",
-        ReverseIndices(indices, /*output_length=*/0, /*output_type=*/float32()));
+        Invalid, "Invalid: Output type of inverse_permutation must be integer, got float",
+        InversePermutation(indices, /*output_length=*/0, /*output_type=*/float32()));
   }
   {
     ARROW_SCOPED_TRACE("Output type string");
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid, "Invalid: Output type of reverse_indices must be integer, got string",
-        ReverseIndices(indices, /*output_length=*/0, /*output_type=*/utf8()));
+        Invalid,
+        "Invalid: Output type of inverse_permutation must be integer, got string",
+        InversePermutation(indices, /*output_length=*/0, /*output_type=*/utf8()));
   }
 }
 
-TEST(ReverseIndices, DefaultOptions) {
+TEST(InversePermutation, DefaultOptions) {
   {
     ARROW_SCOPED_TRACE("Default options values");
-    ReverseIndicesOptions options;
+    InversePermutationOptions options;
     ASSERT_EQ(options.output_length, -1);
     ASSERT_EQ(options.output_type, nullptr);
   }
@@ -178,14 +180,14 @@ TEST(ReverseIndices, DefaultOptions) {
     for (const auto& input_type : kIntegerTypes) {
       ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
       auto indices = ArrayFromJSON(input_type, "[0]");
-      ASSERT_OK_AND_ASSIGN(Datum result, ReverseIndices(indices));
+      ASSERT_OK_AND_ASSIGN(Datum result, InversePermutation(indices));
       AssertDatumsEqual(indices, result);
     }
   }
 }
 
 template <typename ArrowType>
-class TestReverseIndicesSmallOutputType : public ::testing::Test {
+class TestInversePermutationSmallOutputType : public ::testing::Test {
  protected:
   using CType = typename TypeTraits<ArrowType>::CType;
 
@@ -194,15 +196,15 @@ class TestReverseIndicesSmallOutputType : public ::testing::Test {
   }
 };
 
-TYPED_TEST_SUITE(TestReverseIndicesSmallOutputType, SmallOutputTypes);
+TYPED_TEST_SUITE(TestInversePermutationSmallOutputType, SmallOutputTypes);
 
-TYPED_TEST(TestReverseIndicesSmallOutputType, JustEnoughOutputType) {
+TYPED_TEST(TestInversePermutationSmallOutputType, JustEnoughOutputType) {
   auto output_type = this->type_singleton();
   int64_t input_length =
       static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max());
   auto expected =
       ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
-  DoTestReverseIndicesForInputTypes(
+  DoTestInversePermutationForInputTypes(
       kIntegerTypes,
       [&](const std::shared_ptr<DataType>& input_type) {
         return ConstantArrayGenerator::Zeroes(input_length, input_type);
@@ -210,7 +212,7 @@ TYPED_TEST(TestReverseIndicesSmallOutputType, JustEnoughOutputType) {
       /*output_length=*/1, output_type, expected);
 }
 
-TYPED_TEST(TestReverseIndicesSmallOutputType, InsufficientOutputType) {
+TYPED_TEST(TestInversePermutationSmallOutputType, InsufficientOutputType) {
   auto output_type = this->type_singleton();
   int64_t input_length =
       static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max()) + 1;
@@ -220,13 +222,13 @@ TYPED_TEST(TestReverseIndicesSmallOutputType, InsufficientOutputType) {
     ASSERT_RAISES_WITH_MESSAGE(
         Invalid,
         "Invalid: Output type " + output_type->ToString() +
-            " of reverse_indices is insufficient to store indices of length " +
+            " of inverse_permutation is insufficient to store indices of length " +
             std::to_string(input_length),
-        ReverseIndices(indices, /*output_length=*/1, output_type));
+        InversePermutation(indices, /*output_length=*/1, output_type));
   }
 }
 
-TEST(ReverseIndices, Basic) {
+TEST(InversePermutation, Basic) {
   {
     ARROW_SCOPED_TRACE("Basic");
     auto indices = "[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]";
@@ -234,8 +236,8 @@ TEST(ReverseIndices, Basic) {
         "[]", "[9, 7, 5, 3, 1]", "[0]", "[2, 4, 6]", "[8]", "[]"};
     int64_t output_length = 10;
     auto expected = "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected,
-                       /*validity_must_be_null=*/true);
+    TestInversePermutation(indices, indices_chunked, output_length, expected,
+                           /*validity_must_be_null=*/true);
   }
   {
     ARROW_SCOPED_TRACE("Basic with nulls");
@@ -244,7 +246,7 @@ TEST(ReverseIndices, Basic) {
         "[]", "[9, 7, 5, 3, 1]", "[null]", "[null, null, null]", "[null]", "[]"};
     int64_t output_length = 10;
     auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, output_length, expected);
   }
   {
     ARROW_SCOPED_TRACE("Basic with negatives");
@@ -253,7 +255,7 @@ TEST(ReverseIndices, Basic) {
         "[]", "[9, 7, 5, 3, 1]", "[-1]", "[-2, -3, -4]", "[-5]", "[]"};
     int64_t output_length = 10;
     auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
-    TestReverseIndicesSigned(indices, indices_chunked, output_length, expected);
+    TestInversePermutationSigned(indices, indices_chunked, output_length, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty output");
@@ -261,8 +263,8 @@ TEST(ReverseIndices, Basic) {
     std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[]", "[2]", "[]"};
     int64_t output_length = 0;
     auto expected = "[]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected,
-                       /*validity_must_be_null=*/true);
+    TestInversePermutation(indices, indices_chunked, output_length, expected,
+                           /*validity_must_be_null=*/true);
   }
   {
     ARROW_SCOPED_TRACE("Output less than input");
@@ -270,8 +272,8 @@ TEST(ReverseIndices, Basic) {
     std::vector<std::string> indices_chunked{"[]", "[]", "[]", "[1, 0]"};
     int64_t output_length = 1;
     auto expected = "[1]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected,
-                       /*validity_must_be_null=*/true);
+    TestInversePermutation(indices, indices_chunked, output_length, expected,
+                           /*validity_must_be_null=*/true);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
@@ -279,7 +281,7 @@ TEST(ReverseIndices, Basic) {
     std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[2]"};
     int64_t output_length = 7;
     auto expected = "[null, 0, 1, null, null, null, null]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, output_length, expected);
   }
   {
     ARROW_SCOPED_TRACE("Input all null");
@@ -287,7 +289,7 @@ TEST(ReverseIndices, Basic) {
     std::vector<std::string> indices_chunked{"[]", "[null]", "[]", "[null]"};
     int64_t output_length = 2;
     auto expected = "[null, null]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, output_length, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
@@ -295,7 +297,7 @@ TEST(ReverseIndices, Basic) {
     std::vector<std::string> indices_chunked{"[]", "[2]", "[]", "[3]"};
     int64_t output_length = 2;
     auto expected = "[null, null]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, output_length, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
@@ -303,7 +305,7 @@ TEST(ReverseIndices, Basic) {
     std::vector<std::string> indices_chunked{"[]", "[]", "[]", "[]"};
     int64_t output_length = 7;
     auto expected = "[null, null, null, null, null, null, null]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, output_length, expected);
   }
   {
     ARROW_SCOPED_TRACE("Input duplicated indices");
@@ -312,7 +314,7 @@ TEST(ReverseIndices, Basic) {
                                              "[]", "[2]",    "[3]"};
     int64_t output_length = 5;
     auto expected = "[null, 6, 7, 8, null]";
-    TestReverseIndices(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, output_length, expected);
   }
 }
 
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 1061494693390..28c31f3e7de38 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1904,17 +1904,17 @@ Swizzle functions
 
 Swizzle functions reorder the input array based on targeting indices.
 
-+-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
-| Function name   | Arity  | Input type 1 | Input type 2 | Output type  | Options class                   | Notes |
-+=================+========+==============+==============+==============+=================================+=======+
-| reverse_indices | Unary  | Integer      |              | Integer \(1) | :struct:`ReverseIndicesOptions` | \(2)  |
-+-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
-| permute         | Binary | Any          | Integer      | Input type 1 | :struct:`PermuteOptions`        | \(3)  |
-+-----------------+--------+--------------+--------------+--------------+---------------------------------+-------+
++---------------------+--------+--------------+--------------+--------------+-------------------------------------+-------+
+| Function name       | Arity  | Input type 1 | Input type 2 | Output type  | Options class                       | Notes |
++=====================+========+==============+==============+==============+=====================================+=======+
+| inverse_permutation | Unary  | Integer      |              | Integer \(1) | :struct:`InversePermutationOptions` | \(2)  |
++---------------------+--------+--------------+--------------+--------------+-------------------------------------+-------+
+| scatter             | Binary | Any          | Integer      | Input type 1 | :struct:`ScatterOptions`            | \(3)  |
++---------------------+--------+--------------+--------------+--------------+-------------------------------------+-------+
 
-* \(1) The output type is specified in :struct:`ReverseIndicesOptions`.
+* \(1) The output type is specified in :struct:`InversePermutationOptions`.
 
-* \(2) For ``indices[i] = x``, ``reverse_indices[x] = i``. And ``reverse_indices[x]
+* \(2) For ``indices[i] = x``, ``inverse_permutation[x] = i``. And ``inverse_permutation[x]
  = null`` if ``x`` does not appear in the input ``indices``. For ``indices[i] = x``
  where ``x < 0`` or ``x >= output_length``, it is ignored. If multiple indices point
  to the same value, the last one is used.

From 705c7b2fa21553780141c79509a6972cd1f29ae4 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 4 Nov 2024 15:50:29 +0800
Subject: [PATCH 34/54] output_length -> max_index

---
 cpp/src/arrow/compute/api_vector.cc           |  12 +-
 cpp/src/arrow/compute/api_vector.h            |  43 +-
 cpp/src/arrow/compute/function_test.cc        |   4 +-
 .../arrow/compute/kernels/vector_swizzle.cc   |  20 +-
 .../compute/kernels/vector_swizzle_test.cc    | 372 ++++++++----------
 5 files changed, 197 insertions(+), 254 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index a9bf6d59b582b..8fff8c92f4086 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -157,10 +157,10 @@ static auto kListFlattenOptionsType = GetFunctionOptionsType<ListFlattenOptions>
     DataMember("recursive", &ListFlattenOptions::recursive));
 static auto kInversePermutationOptionsType =
     GetFunctionOptionsType<InversePermutationOptions>(
-        DataMember("output_length", &InversePermutationOptions::output_length),
+        DataMember("max_index", &InversePermutationOptions::max_index),
         DataMember("output_type", &InversePermutationOptions::output_type));
 static auto kPermuteOptionsType = GetFunctionOptionsType<PermuteOptions>(
-    DataMember("output_length", &PermuteOptions::output_length));
+    DataMember("max_index", &PermuteOptions::max_index));
 }  // namespace
 }  // namespace internal
 
@@ -237,14 +237,14 @@ ListFlattenOptions::ListFlattenOptions(bool recursive)
 constexpr char ListFlattenOptions::kTypeName[];
 
 InversePermutationOptions::InversePermutationOptions(
-    int64_t output_length, std::shared_ptr<DataType> output_type)
+    int64_t max_index, std::shared_ptr<DataType> output_type)
     : FunctionOptions(internal::kInversePermutationOptionsType),
-      output_length(output_length),
+      max_index(max_index),
       output_type(std::move(output_type)) {}
 constexpr char InversePermutationOptions::kTypeName[];
 
-PermuteOptions::PermuteOptions(int64_t output_length)
-    : FunctionOptions(internal::kPermuteOptionsType), output_length(output_length) {}
+PermuteOptions::PermuteOptions(int64_t max_index)
+    : FunctionOptions(internal::kPermuteOptionsType), max_index(max_index) {}
 constexpr char PermuteOptions::kTypeName[];
 
 namespace internal {
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 3a6547020eed0..ac3e88510795b 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -260,15 +260,15 @@ class ARROW_EXPORT ListFlattenOptions : public FunctionOptions {
 /// \brief Options for inverse_permutation function
 class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
  public:
-  explicit InversePermutationOptions(int64_t output_length = -1,
+  explicit InversePermutationOptions(int64_t max_index = -1,
                                      std::shared_ptr<DataType> output_type = NULLPTR);
   static constexpr char const kTypeName[] = "InversePermutationOptions";
   static InversePermutationOptions Defaults() { return InversePermutationOptions(); }
 
-  /// \brief The length of the output inverse permutation. If negative, the output will be
-  /// of the same length as the input indices. Any indices that are greater or equal to
-  /// this length will be ignored.
-  int64_t output_length = -1;
+  /// \brief The max value in the input indices to process. Any indices that are greater
+  /// to this length will be ignored. If negative, this value will be set to the length of
+  /// the input indices minus 1.
+  int64_t max_index = -1;
   /// \brief The type of the output inverse permutation. If null, the output will be of
   /// the same type as the input indices, otherwise must be integer types. An invalid
   /// error will be reported if this type is not able to store the length of the input
@@ -279,14 +279,14 @@ class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
 /// \brief Options for permute function
 class ARROW_EXPORT PermuteOptions : public FunctionOptions {
  public:
-  explicit PermuteOptions(int64_t output_length = -1);
+  explicit PermuteOptions(int64_t max_index = -1);
   static constexpr char const kTypeName[] = "PermuteOptions";
   static PermuteOptions Defaults() { return PermuteOptions(); }
 
-  /// \brief The length of the output permutation. If negative, the output will be of the
-  /// same length as the input values (and indices). Any values with indices that are
-  /// greater or equal to this length will be ignored.
-  int64_t output_length = -1;
+  /// \brief The max value in the input indices to process. Any values with indices that
+  /// are greater to this length will be ignored. If negative, this value will be set to
+  /// the length of the input minus 1.
+  int64_t max_index = -1;
 };
 
 /// @}
@@ -740,18 +740,15 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
 /// \brief Return the inverse permutation of the given indices.
 ///
 /// For indices[i] = x, inverse_permutation[x] = i. And inverse_permutation[x] = null if x
-/// does not appear in the input indices. For indices[i] = x where x < 0 or x >=
-/// output_length, it is ignored. If multiple indices point to the same value, the last
-/// one is used.
+/// does not appear in the input indices. For indices[i] = x where x < 0 or x > max_index,
+/// it is ignored. If multiple indices point to the same value, the last one is used.
 ///
 /// For example, with indices = [null, 0, 3, 2, 4, 1, 1], the inverse permutation is
-///   [1, 6, 3]                    if output_length = 3,
-///   [1, 6, 3, 2, 4, null, null]  if output_length = 7.
-/// output_length can also be negative, in which case the inverse permutation is of the
-/// same length as the indices.
+///   [1, 6, 3]                    if max_index = 2,
+///   [1, 6, 3, 2, 4, null, null]  if max_index = 6.
 ///
 /// \param[in] indices array-like indices
-/// \param[in] options configures the output length and the output type
+/// \param[in] options configures the max index and the output type
 /// \param[in] ctx the function execution context, optional
 /// \return the resulting inverse permutation
 ///
@@ -766,19 +763,17 @@ Result<Datum> InversePermutation(
 /// \brief Permute the values into specified positions according to the indices.
 ///
 /// For indices[i] = x, output[x] = values[i]. And output[x] = null if x does not appear
-/// in the input indices. For indices[i] = x where x < 0 or x >= output_length, values[i]
+/// in the input indices. For indices[i] = x where x < 0 or x > max_index, values[i]
 /// is ignored. If multiple indices point to the same value, the last one is used.
 ///
 /// For example, with values = [a, b, c, d, e, f, g] and indices = [null, 0,
 /// 3, 2, 4, 1, 1], the permutation is
-///   [b, g, d]                    if output_length = 3,
-///   [b, g, d, c, e, null, null]  if output_length = 7.
-/// output_length can also be negative, in which case the permutation is of the same
-/// length as the values (and indices).
+///   [b, g, d]                    if max_index = 2,
+///   [b, g, d, c, e, null, null]  if max_index = 6.
 ///
 /// \param[in] values datum to permute
 /// \param[in] indices array-like indices
-/// \param[in] options configures the output length of the permutation
+/// \param[in] options configures the max index of the permutation
 /// \param[in] ctx the function execution context, optional
 /// \return the resulting permutation
 ///
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index af9cd4c8b1d76..75b2b8789f534 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -137,9 +137,9 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new Utf8NormalizeOptions());
   options.emplace_back(new Utf8NormalizeOptions(Utf8NormalizeOptions::NFD));
   options.emplace_back(
-      new InversePermutationOptions(/*output_length=*/42, /*output_type=*/int32()));
+      new InversePermutationOptions(/*max_index=*/42, /*output_type=*/int32()));
   options.emplace_back(new PermuteOptions());
-  options.emplace_back(new PermuteOptions(/*output_length=*/42));
+  options.emplace_back(new PermuteOptions(/*max_index=*/42));
 
   for (size_t i = 0; i < options.size(); i++) {
     const size_t prev_i = i == 0 ? options.size() - 1 : i - 1;
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index d9eedaab91a61..6324fe62f66af 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -73,10 +73,7 @@ struct InversePermutationImpl {
     const auto& options = InversePermutationState::Get(ctx);
 
     // Apply default options semantics.
-    int64_t output_length = options.output_length;
-    if (output_length < 0) {
-      output_length = input_length;
-    }
+    int64_t output_length = options.max_index < 0 ? input_length : options.max_index + 1;
     std::shared_ptr<DataType> output_type = options.output_type;
     if (!output_type) {
       output_type = input_type;
@@ -367,23 +364,18 @@ class PermuteMetaFunction : public MetaFunction {
       return Status::Invalid("Indices of permute must be of integer type, got ",
                              indices.type()->ToString());
     }
-    // Apply default options semantics.
-    int64_t output_length = permute_options->output_length;
-    if (output_length < 0) {
-      output_length = values.length();
-    }
     // Internally invoke Take(values, InversePermutation(indices)) to implement permute.
     // For example, with
     //   values = [a, b, c, d, e, f, g]
     //   indices = [null, 0, 3, 2, 4, 1, 1]
     // the InversePermutation(indices) is
-    //   [1, 6, 3]                    if output_length = 3,
-    //   [1, 6, 3, 2, 4, null, null]  if output_length = 7.
+    //   [1, 6, 3]                    if max_index = 2,
+    //   [1, 6, 3, 2, 4, null, null]  if max_index = 6.
     // and Take(values, InversePermutation(indices)) is
-    //   [b, g, d]                    if output_length = 3,
-    //   [b, g, d, c, e, null, null]  if output_length = 7.
+    //   [b, g, d]                    if max_index = 2,
+    //   [b, g, d, c, e, null, null]  if max_index = 6.
     InversePermutationOptions inverse_permutation_options{
-        output_length,
+        permute_options->max_index,
         // Use the smallest possible uint type to store inverse permutation.
         InferSmallestInversePermutationType(values.length())};
     ARROW_ASSIGN_OR_RAISE(auto inverse_permutation,
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index f128af26a8bb8..b840025c815f0 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -53,17 +53,16 @@ using SmallOutputTypes = ::testing::Types<UInt8Type, UInt16Type, Int8Type, Int16
 
 namespace {
 
-Result<Datum> InversePermutation(const Datum& indices, int64_t output_length,
+Result<Datum> InversePermutation(const Datum& indices, int64_t max_index,
                                  std::shared_ptr<DataType> output_type) {
-  InversePermutationOptions options{output_length, std::move(output_type)};
+  InversePermutationOptions options{max_index, std::move(output_type)};
   return InversePermutation(indices, options);
 }
 
-void AssertInversePermutation(const Datum& indices, int64_t output_length,
+void AssertInversePermutation(const Datum& indices, int64_t max_index,
                               const std::shared_ptr<DataType>& output_type,
                               const Datum& expected, bool validity_must_be_null) {
-  ASSERT_OK_AND_ASSIGN(auto result,
-                       InversePermutation(indices, output_length, output_type));
+  ASSERT_OK_AND_ASSIGN(auto result, InversePermutation(indices, max_index, output_type));
   ASSERT_EQ(indices.kind(), result.kind());
   std::shared_ptr<Array> result_array;
   if (result.is_array()) {
@@ -81,12 +80,12 @@ void AssertInversePermutation(const Datum& indices, int64_t output_length,
 template <typename InputFunc>
 void DoTestInversePermutationForInputTypes(
     const std::vector<std::shared_ptr<DataType>>& input_types, InputFunc&& input,
-    int64_t output_length, const std::shared_ptr<DataType>& output_type,
+    int64_t max_index, const std::shared_ptr<DataType>& output_type,
     const Datum& expected, bool validity_must_be_null = false) {
   for (const auto& input_type : input_types) {
     ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
     auto indices = input(input_type);
-    AssertInversePermutation(indices, output_length, output_type, expected,
+    AssertInversePermutation(indices, max_index, output_type, expected,
                              validity_must_be_null);
   }
 }
@@ -95,12 +94,12 @@ template <typename InputFunc>
 void DoTestInversePermutationForInputOutputTypes(
     const std::vector<std::shared_ptr<DataType>>& input_types,
     const std::vector<std::shared_ptr<DataType>>& output_types, InputFunc&& input,
-    int64_t output_length, const std::string& expected_str, bool validity_must_be_null) {
+    int64_t max_index, const std::string& expected_str, bool validity_must_be_null) {
   for (const auto& output_type : kIntegerTypes) {
     ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
     auto expected = ArrayFromJSON(output_type, expected_str);
     DoTestInversePermutationForInputTypes(input_types, std::forward<InputFunc>(input),
-                                          output_length, output_type, expected,
+                                          max_index, output_type, expected,
                                           validity_must_be_null);
   }
 }
@@ -109,7 +108,7 @@ void TestInversePermutationForInputOutputTypes(
     const std::vector<std::shared_ptr<DataType>>& input_types,
     const std::vector<std::shared_ptr<DataType>>& output_types,
     const std::string& indices_str, const std::vector<std::string>& indices_chunked_str,
-    int64_t output_length, const std::string& expected_str, bool validity_must_be_null) {
+    int64_t max_index, const std::string& expected_str, bool validity_must_be_null) {
   {
     ARROW_SCOPED_TRACE("Array");
     DoTestInversePermutationForInputOutputTypes(
@@ -117,7 +116,7 @@ void TestInversePermutationForInputOutputTypes(
         [&](const std::shared_ptr<DataType>& input_type) {
           return ArrayFromJSON(input_type, indices_str);
         },
-        output_length, expected_str, validity_must_be_null);
+        max_index, expected_str, validity_must_be_null);
   }
   {
     ARROW_SCOPED_TRACE("Chunked");
@@ -126,26 +125,26 @@ void TestInversePermutationForInputOutputTypes(
         [&](const std::shared_ptr<DataType>& input_type) {
           return ChunkedArrayFromJSON(input_type, indices_chunked_str);
         },
-        output_length, expected_str, validity_must_be_null);
+        max_index, expected_str, validity_must_be_null);
   }
 }
 
 void TestInversePermutationSigned(const std::string& indices_str,
                                   const std::vector<std::string>& indices_chunked_str,
-                                  int64_t output_length, const std::string& expected_str,
+                                  int64_t max_index, const std::string& expected_str,
                                   bool validity_must_be_null = false) {
-  TestInversePermutationForInputOutputTypes(
-      kSignedIntegerTypes, kIntegerTypes, indices_str, indices_chunked_str, output_length,
-      expected_str, validity_must_be_null);
+  TestInversePermutationForInputOutputTypes(kSignedIntegerTypes, kIntegerTypes,
+                                            indices_str, indices_chunked_str, max_index,
+                                            expected_str, validity_must_be_null);
 }
 
 void TestInversePermutation(const std::string& indices_str,
                             const std::vector<std::string>& indices_chunked_str,
-                            int64_t output_length, const std::string& expected_str,
+                            int64_t max_index, const std::string& expected_str,
                             bool validity_must_be_null = false) {
   TestInversePermutationForInputOutputTypes(kIntegerTypes, kIntegerTypes, indices_str,
-                                            indices_chunked_str, output_length,
-                                            expected_str, validity_must_be_null);
+                                            indices_chunked_str, max_index, expected_str,
+                                            validity_must_be_null);
 }
 
 }  // namespace
@@ -156,7 +155,7 @@ TEST(InversePermutation, InvalidOutputType) {
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
         Invalid, "Invalid: Output type of inverse_permutation must be integer, got float",
-        InversePermutation(indices, /*output_length=*/0, /*output_type=*/float32()));
+        InversePermutation(indices, /*max_index=*/0, /*output_type=*/float32()));
   }
   {
     ARROW_SCOPED_TRACE("Output type string");
@@ -164,7 +163,7 @@ TEST(InversePermutation, InvalidOutputType) {
     ASSERT_RAISES_WITH_MESSAGE(
         Invalid,
         "Invalid: Output type of inverse_permutation must be integer, got string",
-        InversePermutation(indices, /*output_length=*/0, /*output_type=*/utf8()));
+        InversePermutation(indices, /*max_index=*/0, /*output_type=*/utf8()));
   }
 }
 
@@ -172,7 +171,7 @@ TEST(InversePermutation, DefaultOptions) {
   {
     ARROW_SCOPED_TRACE("Default options values");
     InversePermutationOptions options;
-    ASSERT_EQ(options.output_length, -1);
+    ASSERT_EQ(options.max_index, -1);
     ASSERT_EQ(options.output_type, nullptr);
   }
   {
@@ -209,7 +208,7 @@ TYPED_TEST(TestInversePermutationSmallOutputType, JustEnoughOutputType) {
       [&](const std::shared_ptr<DataType>& input_type) {
         return ConstantArrayGenerator::Zeroes(input_length, input_type);
       },
-      /*output_length=*/1, output_type, expected);
+      /*max_index=*/0, output_type, expected);
 }
 
 TYPED_TEST(TestInversePermutationSmallOutputType, InsufficientOutputType) {
@@ -224,7 +223,7 @@ TYPED_TEST(TestInversePermutationSmallOutputType, InsufficientOutputType) {
         "Invalid: Output type " + output_type->ToString() +
             " of inverse_permutation is insufficient to store indices of length " +
             std::to_string(input_length),
-        InversePermutation(indices, /*output_length=*/1, output_type));
+        InversePermutation(indices, /*max_index=*/0, output_type));
   }
 }
 
@@ -234,9 +233,9 @@ TEST(InversePermutation, Basic) {
     auto indices = "[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]";
     std::vector<std::string> indices_chunked{
         "[]", "[9, 7, 5, 3, 1]", "[0]", "[2, 4, 6]", "[8]", "[]"};
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected,
+    TestInversePermutation(indices, indices_chunked, max_index, expected,
                            /*validity_must_be_null=*/true);
   }
   {
@@ -244,77 +243,59 @@ TEST(InversePermutation, Basic) {
     auto indices = "[9, 7, 5, 3, 1, null, null, null, null, null]";
     std::vector<std::string> indices_chunked{
         "[]", "[9, 7, 5, 3, 1]", "[null]", "[null, null, null]", "[null]", "[]"};
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Basic with negatives");
     auto indices = "[9, 7, 5, 3, 1, -1, -2, -3, -4, -5]";
     std::vector<std::string> indices_chunked{
         "[]", "[9, 7, 5, 3, 1]", "[-1]", "[-2, -3, -4]", "[-5]", "[]"};
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
-    TestInversePermutationSigned(indices, indices_chunked, output_length, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Empty output");
-    auto indices = "[1, 2]";
-    std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[]", "[2]", "[]"};
-    int64_t output_length = 0;
-    auto expected = "[]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected,
-                           /*validity_must_be_null=*/true);
-  }
-  {
-    ARROW_SCOPED_TRACE("Output less than input");
-    auto indices = "[1, 0]";
-    std::vector<std::string> indices_chunked{"[]", "[]", "[]", "[1, 0]"};
-    int64_t output_length = 1;
-    auto expected = "[1]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected,
-                           /*validity_must_be_null=*/true);
+    TestInversePermutationSigned(indices, indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
     auto indices = "[1, 2]";
     std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[2]"};
-    int64_t output_length = 7;
+    int64_t max_index = 6;
     auto expected = "[null, 0, 1, null, null, null, null]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Input all null");
     auto indices = "[null, null]";
     std::vector<std::string> indices_chunked{"[]", "[null]", "[]", "[null]"};
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
     auto indices = "[2, 3]";
     std::vector<std::string> indices_chunked{"[]", "[2]", "[]", "[3]"};
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
     auto indices = "[]";
     std::vector<std::string> indices_chunked{"[]", "[]", "[]", "[]"};
-    int64_t output_length = 7;
+    int64_t max_index = 6;
     auto expected = "[null, null, null, null, null, null, null]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Input duplicated indices");
     auto indices = "[1, 2, 3, 1, 2, 3, 1, 2, 3]";
     std::vector<std::string> indices_chunked{"[]", "[1, 2]", "[3, 1, 2, 3, 1]",
                                              "[]", "[2]",    "[3]"};
-    int64_t output_length = 5;
+    int64_t max_index = 4;
     auto expected = "[null, 6, 7, 8, null]";
-    TestInversePermutation(indices, indices_chunked, output_length, expected);
+    TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
 }
 
@@ -328,142 +309,143 @@ TEST(InversePermutation, Basic) {
 
 namespace {
 
-Result<Datum> Permute(const Datum& values, const Datum& indices, int64_t output_length) {
-  PermuteOptions options{output_length};
+Result<Datum> Permute(const Datum& values, const Datum& indices, int64_t max_index) {
+  PermuteOptions options{max_index};
   return Permute(values, indices, options);
 }
 
 void AssertPermuteAAA(const std::shared_ptr<Array>& values,
-                      const std::shared_ptr<Array>& indices, int64_t output_length,
+                      const std::shared_ptr<Array>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, max_index));
   AssertDatumsEqual(expected, result);
 }
 
 void AssertPermuteCAC(const std::shared_ptr<ChunkedArray>& values,
-                      const std::shared_ptr<Array>& indices, int64_t output_length,
+                      const std::shared_ptr<Array>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, max_index));
   ASSERT_TRUE(result.is_chunked_array());
   ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
   AssertDatumsEqual(expected, result_array);
 }
 
 void AssertPermuteACC(const std::shared_ptr<Array>& values,
-                      const std::shared_ptr<ChunkedArray>& indices, int64_t output_length,
+                      const std::shared_ptr<ChunkedArray>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, max_index));
   ASSERT_TRUE(result.is_chunked_array());
   ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
   AssertDatumsEqual(expected, result_array);
 }
 
 void AssertPermuteCCC(const std::shared_ptr<ChunkedArray>& values,
-                      const std::shared_ptr<ChunkedArray>& indices, int64_t output_length,
+                      const std::shared_ptr<ChunkedArray>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, output_length));
+  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, max_index));
   ASSERT_TRUE(result.is_chunked_array());
   ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
   AssertDatumsEqual(expected, result_array);
 }
 
 void DoTestPermuteAAA(const std::shared_ptr<Array>& values,
-                      const std::shared_ptr<Array>& indices, int64_t output_length,
+                      const std::shared_ptr<Array>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  AssertPermuteAAA(values, indices, output_length, expected);
+  AssertPermuteAAA(values, indices, max_index, expected);
 }
 
 /// The following helper functions are based on the invariant:
-/// Permute([V, V], [I', I''], 2 * l) == Concat(E, E)
+/// Permute([V, V], [I', I''], 2 * (m + 1) - 1) == Concat(E, E)
 ///
 /// where
 ///   V = values
 ///   I = indices
-///   l = output_length
-///   I' = ReplaceWithMask(I, i >= l, null)
-///   I'' = ReplaceWithMask(I, i < 0, null) + l
-///   E = Permute(V, I, l)
+///   m = max_index
+///   I' = ReplaceWithMask(I, i > m, null)
+///   I'' = ReplaceWithMask(I, i < 0, null) + m + 1
+///   E = Permute(V, I, m)
 
-/// Make indices prefix I' = ReplaceWithMask(I, i >= l, null).
+/// Make indices prefix I' = ReplaceWithMask(I, i > m, null).
 Result<std::shared_ptr<Array>> MakeIndicesPrefix(const std::shared_ptr<Array>& indices,
-                                                 int64_t output_length) {
-  ARROW_ASSIGN_OR_RAISE(auto l, MakeScalar(indices->type(), output_length));
-  ARROW_ASSIGN_OR_RAISE(auto ge_than_l, CallFunction("greater_equal", {indices, l}));
+                                                 int64_t max_index) {
+  ARROW_ASSIGN_OR_RAISE(auto m, MakeScalar(indices->type(), max_index));
+  ARROW_ASSIGN_OR_RAISE(auto ge_than_l, CallFunction("greater", {indices, m}));
   ARROW_ASSIGN_OR_RAISE(auto all_null,
                         MakeArrayOfNull(indices->type(), indices->length()));
   ARROW_ASSIGN_OR_RAISE(auto prefix, ReplaceWithMask(indices, ge_than_l, all_null));
   return prefix.make_array();
 }
 
-/// Make indices suffix I'' = ReplaceWithMask(I, i < 0, null) + l.
+/// Make indices suffix I'' = ReplaceWithMask(I, i < 0, null) + m + 1.
 Result<std::shared_ptr<Array>> MakeIndicesSuffix(const std::shared_ptr<Array>& indices,
-                                                 int64_t output_length) {
+                                                 int64_t max_index) {
   ARROW_ASSIGN_OR_RAISE(auto zero, MakeScalar(indices->type(), 0));
   ARROW_ASSIGN_OR_RAISE(auto negative, CallFunction("less", {indices, zero}));
   ARROW_ASSIGN_OR_RAISE(auto all_null,
                         MakeArrayOfNull(indices->type(), indices->length()));
   ARROW_ASSIGN_OR_RAISE(auto replaced, ReplaceWithMask(indices, negative, all_null));
-  ARROW_ASSIGN_OR_RAISE(auto l, MakeScalar(indices->type(), output_length));
-  ARROW_ASSIGN_OR_RAISE(auto suffix, Add(replaced, l));
+  ARROW_ASSIGN_OR_RAISE(auto m, MakeScalar(indices->type(), max_index));
+  ARROW_ASSIGN_OR_RAISE(auto replaced_plus_m, Add(replaced, m));
+  ARROW_ASSIGN_OR_RAISE(auto one, MakeScalar(indices->type(), 1));
+  ARROW_ASSIGN_OR_RAISE(auto suffix, Add(replaced_plus_m, one));
   return suffix.make_array();
 }
 
 void DoTestPermuteCACWithArrays(const std::shared_ptr<Array>& values,
-                                const std::shared_ptr<Array>& indices,
-                                int64_t output_length,
+                                const std::shared_ptr<Array>& indices, int64_t max_index,
                                 const std::shared_ptr<Array>& expected) {
   auto chunked_values2 = std::make_shared<ChunkedArray>(ArrayVector{values, values});
 
-  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, output_length));
-  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, output_length));
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, max_index));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, max_index));
   ASSERT_OK_AND_ASSIGN(auto concat_indices2,
                        Concatenate({indices_prefix, indices_suffix}));
 
   ASSERT_OK_AND_ASSIGN(auto concat_expected2,
                        Concatenate(ArrayVector{expected, expected}));
 
-  AssertPermuteCAC(chunked_values2, concat_indices2, output_length * 2, concat_expected2);
+  AssertPermuteCAC(chunked_values2, concat_indices2, (max_index + 1) * 2 - 1,
+                   concat_expected2);
 }
 
 void DoTestPermuteACCWithArrays(const std::shared_ptr<Array>& values,
-                                const std::shared_ptr<Array>& indices,
-                                int64_t output_length,
+                                const std::shared_ptr<Array>& indices, int64_t max_index,
                                 const std::shared_ptr<Array>& expected) {
   ASSERT_OK_AND_ASSIGN(auto concat_values2, Concatenate(ArrayVector{values, values}));
 
-  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, output_length));
-  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, output_length));
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, max_index));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, max_index));
   auto chunked_indices2 =
       std::make_shared<ChunkedArray>(ArrayVector{indices_prefix, indices_suffix});
 
   ASSERT_OK_AND_ASSIGN(auto concat_expected2,
                        Concatenate(ArrayVector{expected, expected}));
 
-  AssertPermuteACC(concat_values2, chunked_indices2, output_length * 2, concat_expected2);
+  AssertPermuteACC(concat_values2, chunked_indices2, (max_index + 1) * 2 - 1,
+                   concat_expected2);
 }
 
 void DoTestPermuteCCCWithArrays(const std::shared_ptr<Array>& values,
-                                const std::shared_ptr<Array>& indices,
-                                int64_t output_length,
+                                const std::shared_ptr<Array>& indices, int64_t max_index,
                                 const std::shared_ptr<Array>& expected) {
   auto chunked_values2 = std::make_shared<ChunkedArray>(ArrayVector{values, values});
 
-  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, output_length));
-  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, output_length));
+  ASSERT_OK_AND_ASSIGN(auto indices_prefix, MakeIndicesPrefix(indices, max_index));
+  ASSERT_OK_AND_ASSIGN(auto indices_suffix, MakeIndicesSuffix(indices, max_index));
   auto chunked_indices2 =
       std::make_shared<ChunkedArray>(ArrayVector{indices_prefix, indices_suffix});
 
   ASSERT_OK_AND_ASSIGN(auto concat_expected2,
                        Concatenate(ArrayVector{expected, expected}));
 
-  AssertPermuteCCC(chunked_values2, chunked_indices2, output_length * 2,
+  AssertPermuteCCC(chunked_values2, chunked_indices2, (max_index + 1) * 2 - 1,
                    concat_expected2);
 }
 
 void DoTestPermuteForIndicesTypes(
     const std::vector<std::shared_ptr<DataType>>& indices_types,
     const std::shared_ptr<Array>& values, const std::shared_ptr<Array>& indices,
-    int64_t output_length, const std::shared_ptr<Array>& expected) {
+    int64_t max_index, const std::shared_ptr<Array>& expected) {
   for (const auto& indices_type : indices_types) {
     ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
     ASSERT_OK_AND_ASSIGN(auto casted, Cast(indices, indices_type));
@@ -471,35 +453,33 @@ void DoTestPermuteForIndicesTypes(
     auto casted_indices = casted.make_array();
     {
       ARROW_SCOPED_TRACE("AAA");
-      DoTestPermuteAAA(values, casted_indices, output_length, expected);
+      DoTestPermuteAAA(values, casted_indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("CAA");
-      DoTestPermuteCACWithArrays(values, casted_indices, output_length, expected);
+      DoTestPermuteCACWithArrays(values, casted_indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("ACA");
-      DoTestPermuteACCWithArrays(values, casted_indices, output_length, expected);
+      DoTestPermuteACCWithArrays(values, casted_indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("CCA");
-      DoTestPermuteCCCWithArrays(values, casted_indices, output_length, expected);
+      DoTestPermuteCCCWithArrays(values, casted_indices, max_index, expected);
     }
   }
 }
 
 void DoTestPermuteSignedIndices(const std::shared_ptr<Array>& values,
-                                const std::shared_ptr<Array>& indices,
-                                int64_t output_length,
+                                const std::shared_ptr<Array>& indices, int64_t max_index,
                                 const std::shared_ptr<Array>& expected) {
-  DoTestPermuteForIndicesTypes(kSignedIntegerTypes, values, indices, output_length,
-                               expected);
+  DoTestPermuteForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);
 }
 
 void DoTestPermute(const std::shared_ptr<Array>& values,
-                   const std::shared_ptr<Array>& indices, int64_t output_length,
+                   const std::shared_ptr<Array>& indices, int64_t max_index,
                    const std::shared_ptr<Array>& expected) {
-  DoTestPermuteForIndicesTypes(kIntegerTypes, values, indices, output_length, expected);
+  DoTestPermuteForIndicesTypes(kIntegerTypes, values, indices, max_index, expected);
 }
 
 }  // namespace
@@ -528,7 +508,7 @@ TEST(Permute, DefaultOptions) {
   {
     ARROW_SCOPED_TRACE("Default options values");
     PermuteOptions options;
-    ASSERT_EQ(options.output_length, -1);
+    ASSERT_EQ(options.max_index, -1);
   }
   {
     ARROW_SCOPED_TRACE("Default options semantics");
@@ -565,7 +545,7 @@ TYPED_TEST(TestPermuteSmallIndicesTypes, MaxIntegerIndex) {
   auto expected_suffix_value = values;
   ASSERT_OK_AND_ASSIGN(auto expected,
                        Concatenate({expected_prefix_nulls, expected_suffix_value}));
-  DoTestPermuteAAA(values, indices, /*output_length=*/max_integer, expected);
+  DoTestPermuteAAA(values, indices, /*max_index=*/max_integer - 1, expected);
 }
 
 template <typename ArrowType>
@@ -581,26 +561,26 @@ class TestPermuteTyped : public ::testing::Test {
   }
 
   void TestPermuteSignedIndices(const std::string& values_str,
-                                const std::string& indices_str, int64_t output_length,
+                                const std::string& indices_str, int64_t max_index,
                                 const std::string& expected_str) {
-    TestPermute(DoTestPermuteSignedIndices, values_str, indices_str, output_length,
+    TestPermute(DoTestPermuteSignedIndices, values_str, indices_str, max_index,
                 expected_str);
   }
 
   void TestPermute(const std::string& values_str, const std::string& indices_str,
-                   int64_t output_length, const std::string& expected_str) {
-    TestPermute(DoTestPermute, values_str, indices_str, output_length, expected_str);
+                   int64_t max_index, const std::string& expected_str) {
+    TestPermute(DoTestPermute, values_str, indices_str, max_index, expected_str);
   }
 
  private:
   template <typename DoTestFunc>
   void TestPermute(DoTestFunc&& func, const std::string& values_str,
-                   const std::string& indices_str, int64_t output_length,
+                   const std::string& indices_str, int64_t max_index,
                    const std::string& expected_str) {
     auto values = ArrayFromJSON(values_type(), values_str);
     auto indices = ArrayFromJSON(int8(), indices_str);
     auto expected = ArrayFromJSON(values_type(), expected_str);
-    func(values, indices, output_length, expected);
+    func(values, indices, max_index, expected);
   }
 };
 
@@ -611,97 +591,89 @@ TEST_F(TestPermuteBoolean, Basic) {
     ARROW_SCOPED_TRACE("Basic");
     auto values = "[true, false, true, true, false, false, true, true, true, false]";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[false, true, true, true, false, false, true, true, false, true]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values with nulls");
     auto values = "[true, false, null, true, true, false, false, null, null, true]";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[true, null, null, false, false, true, true, null, false, true]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with nulls");
     auto values = "[true, false, true, true, false, false, true, true, true, false]";
     auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[null, true, null, true, null, false, null, true, null, true]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with negatives");
     auto values = "[true, false, true, true, false, false, true, true, true, false]";
     auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[null, true, null, true, null, false, null, true, null, true]";
-    TestPermuteSignedIndices(values, indices, output_length, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Empty output");
-    auto values = "[true, false]";
-    auto indices = "[0, 1]";
-    int64_t output_length = 0;
-    auto expected = "[]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermuteSignedIndices(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output less than input");
     auto values = "[false, true]";
     auto indices = "[1, 0]";
-    int64_t output_length = 1;
+    int64_t max_index = 0;
     auto expected = "[true]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
     auto values = "[true, true, true, false, false, false]";
     auto indices = "[0, 3, 6, 1, 4, 7]";
-    int64_t output_length = 9;
+    int64_t max_index = 8;
     auto expected = "[true, false, null, true, false, null, true, false, null]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values all null");
     auto values = "[null, null]";
     auto indices = "[0, 1]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices all null");
     auto values = "[true, false]";
     auto indices = "[null, null]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
     auto values = "[true, false]";
     auto indices = "[2, 3]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
     auto values = "[]";
     auto indices = "[]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices duplicated indices");
     auto values = "[true, false, null, null]";
     auto indices = "[0, 1, 0, 1]";
-    int64_t output_length = 4;
+    int64_t max_index = 3;
     auto expected = "[null, null, null, null]";
-    TestPermute(values, indices, output_length, expected);
+    TestPermute(values, indices, max_index, expected);
   }
 }
 
@@ -715,97 +687,89 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     ARROW_SCOPED_TRACE("Basic");
     auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values with nulls");
     auto values = "[null, 11, null, 13, null, 15, null, 17, null, 19]";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[19, null, 17, null, 15, null, 13, null, 11, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with nulls");
     auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
     auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with negatives");
     auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
     auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
-    this->TestPermuteSignedIndices(values, indices, output_length, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Empty output");
-    auto values = "[1, 0]";
-    auto indices = "[0, 1]";
-    int64_t output_length = 0;
-    auto expected = "[]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermuteSignedIndices(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output less than input");
     auto values = "[1, 0]";
     auto indices = "[1, 0]";
-    int64_t output_length = 1;
+    int64_t max_index = 0;
     auto expected = "[0]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
     auto values = "[0, 0, 0, 1, 1, 1]";
     auto indices = "[0, 3, 6, 1, 4, 7]";
-    int64_t output_length = 9;
+    int64_t max_index = 8;
     auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values all null");
     auto values = "[null, null]";
     auto indices = "[0, 1]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices all null");
     auto values = "[0, 1]";
     auto indices = "[null, null]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
     auto values = "[0, 1]";
     auto indices = "[2, 3]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
     auto values = "[]";
     auto indices = "[]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices duplicated indices");
     auto values = "[1, 0, null, null]";
     auto indices = "[0, 1, 0, 1]";
-    int64_t output_length = 4;
+    int64_t max_index = 3;
     auto expected = "[null, null, null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
 }
 
@@ -819,97 +783,89 @@ TYPED_TEST(TestPermuteString, Basic) {
     ARROW_SCOPED_TRACE("Basic");
     auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = R"(["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"])";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values with nulls");
     auto values = R"([null, "b", null, "d", null, "f", null, "h", null, "j"])";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = R"(["j", null, "h", null, "f", null, "d", null, "b", null])";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with nulls");
     auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
     auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with negatives");
     auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
     auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
-    int64_t output_length = 10;
+    int64_t max_index = 9;
     auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
-    this->TestPermuteSignedIndices(values, indices, output_length, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Empty output");
-    auto values = R"(["b", "a"])";
-    auto indices = "[0, 1]";
-    int64_t output_length = 0;
-    auto expected = "[]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermuteSignedIndices(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output less than input");
     auto values = R"(["b", "a"])";
     auto indices = "[1, 0]";
-    int64_t output_length = 1;
+    int64_t max_index = 0;
     auto expected = R"(["a"])";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
     auto values = R"(["a", "a", "a", "b", "b", "b"])";
     auto indices = "[0, 3, 6, 1, 4, 7]";
-    int64_t output_length = 9;
+    int64_t max_index = 8;
     auto expected = R"(["a", "b", null, "a", "b", null, "a", "b", null])";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values all null");
     auto values = "[null, null]";
     auto indices = "[0, 1]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices all null");
     auto values = R"(["a", "b"])";
     auto indices = "[null, null]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
     auto values = R"(["a", "b"])";
     auto indices = "[2, 3]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
     auto values = "[]";
     auto indices = "[]";
-    int64_t output_length = 2;
+    int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices duplicated indices");
     auto values = R"(["a", "b", null, null])";
     auto indices = "[0, 1, 0, 1]";
-    int64_t output_length = 4;
+    int64_t max_index = 3;
     auto expected = "[null, null, null, null]";
-    this->TestPermute(values, indices, output_length, expected);
+    this->TestPermute(values, indices, max_index, expected);
   }
 }
 
@@ -999,7 +955,7 @@ Result<Datum> ExecuteIfElseByPermute(const Expression& cond, const Expression& i
   // in the mask, because Permute will fill nulls for these rows and this is equal to the
   // null handling policy of if-else, which is pretty nice.
   return Permute(/*values=*/result_ca, /*indices=*/sel_ca,
-                 /*output_length=*/input.length);
+                 /*max_index=*/input.length - 1);
 }
 
 void DoTestIfElse(const Expression& cond, const Expression& if_true,

From 9e9ccb09e0eaff017f4b89740559c9c55568eb35 Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Mon, 4 Nov 2024 16:01:32 +0800
Subject: [PATCH 35/54] Permute -> Scatter

---
 cpp/src/arrow/compute/api_vector.cc           |  18 +-
 cpp/src/arrow/compute/api_vector.h            |  24 +-
 cpp/src/arrow/compute/function_test.cc        |   4 +-
 .../arrow/compute/kernels/vector_swizzle.cc   |  42 ++--
 .../compute/kernels/vector_swizzle_test.cc    | 212 +++++++++---------
 5 files changed, 150 insertions(+), 150 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 8fff8c92f4086..22ecf1cc87844 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -159,8 +159,8 @@ static auto kInversePermutationOptionsType =
     GetFunctionOptionsType<InversePermutationOptions>(
         DataMember("max_index", &InversePermutationOptions::max_index),
         DataMember("output_type", &InversePermutationOptions::output_type));
-static auto kPermuteOptionsType = GetFunctionOptionsType<PermuteOptions>(
-    DataMember("max_index", &PermuteOptions::max_index));
+static auto kScatterOptionsType = GetFunctionOptionsType<ScatterOptions>(
+    DataMember("max_index", &ScatterOptions::max_index));
 }  // namespace
 }  // namespace internal
 
@@ -243,9 +243,9 @@ InversePermutationOptions::InversePermutationOptions(
       output_type(std::move(output_type)) {}
 constexpr char InversePermutationOptions::kTypeName[];
 
-PermuteOptions::PermuteOptions(int64_t max_index)
-    : FunctionOptions(internal::kPermuteOptionsType), max_index(max_index) {}
-constexpr char PermuteOptions::kTypeName[];
+ScatterOptions::ScatterOptions(int64_t max_index)
+    : FunctionOptions(internal::kScatterOptionsType), max_index(max_index) {}
+constexpr char ScatterOptions::kTypeName[];
 
 namespace internal {
 void RegisterVectorOptions(FunctionRegistry* registry) {
@@ -262,7 +262,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kPairwiseOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kListFlattenOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kInversePermutationOptionsType));
-  DCHECK_OK(registry->AddFunctionOptionsType(kPermuteOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kScatterOptionsType));
 }
 }  // namespace internal
 
@@ -457,9 +457,9 @@ Result<Datum> InversePermutation(const Datum& indices,
   return CallFunction("inverse_permutation", {indices}, &options, ctx);
 }
 
-Result<Datum> Permute(const Datum& values, const Datum& indices,
-                      const PermuteOptions& options, ExecContext* ctx) {
-  return CallFunction("permute", {values, indices}, &options, ctx);
+Result<Datum> Scatter(const Datum& values, const Datum& indices,
+                      const ScatterOptions& options, ExecContext* ctx) {
+  return CallFunction("scatter", {values, indices}, &options, ctx);
 }
 
 }  // namespace compute
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index ac3e88510795b..b53b4697f048a 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -276,12 +276,12 @@ class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
   std::shared_ptr<DataType> output_type = NULLPTR;
 };
 
-/// \brief Options for permute function
-class ARROW_EXPORT PermuteOptions : public FunctionOptions {
+/// \brief Options for scatter function
+class ARROW_EXPORT ScatterOptions : public FunctionOptions {
  public:
-  explicit PermuteOptions(int64_t max_index = -1);
-  static constexpr char const kTypeName[] = "PermuteOptions";
-  static PermuteOptions Defaults() { return PermuteOptions(); }
+  explicit ScatterOptions(int64_t max_index = -1);
+  static constexpr char const kTypeName[] = "ScatterOptions";
+  static ScatterOptions Defaults() { return ScatterOptions(); }
 
   /// \brief The max value in the input indices to process. Any values with indices that
   /// are greater to this length will be ignored. If negative, this value will be set to
@@ -760,28 +760,28 @@ Result<Datum> InversePermutation(
     const InversePermutationOptions& options = InversePermutationOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
-/// \brief Permute the values into specified positions according to the indices.
+/// \brief Scatter the values into specified positions according to the indices.
 ///
 /// For indices[i] = x, output[x] = values[i]. And output[x] = null if x does not appear
 /// in the input indices. For indices[i] = x where x < 0 or x > max_index, values[i]
 /// is ignored. If multiple indices point to the same value, the last one is used.
 ///
 /// For example, with values = [a, b, c, d, e, f, g] and indices = [null, 0,
-/// 3, 2, 4, 1, 1], the permutation is
+/// 3, 2, 4, 1, 1], the output is
 ///   [b, g, d]                    if max_index = 2,
 ///   [b, g, d, c, e, null, null]  if max_index = 6.
 ///
-/// \param[in] values datum to permute
+/// \param[in] values datum to scatter
 /// \param[in] indices array-like indices
-/// \param[in] options configures the max index of the permutation
+/// \param[in] options configures the max index of to scatter
 /// \param[in] ctx the function execution context, optional
-/// \return the resulting permutation
+/// \return the resulting datum
 ///
 /// \since 19.0.0
 /// \note API not yet finalized
 ARROW_EXPORT
-Result<Datum> Permute(const Datum& values, const Datum& indices,
-                      const PermuteOptions& options = PermuteOptions::Defaults(),
+Result<Datum> Scatter(const Datum& values, const Datum& indices,
+                      const ScatterOptions& options = ScatterOptions::Defaults(),
                       ExecContext* ctx = NULLPTR);
 
 }  // namespace compute
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index 75b2b8789f534..b7d017d482013 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -138,8 +138,8 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new Utf8NormalizeOptions(Utf8NormalizeOptions::NFD));
   options.emplace_back(
       new InversePermutationOptions(/*max_index=*/42, /*output_type=*/int32()));
-  options.emplace_back(new PermuteOptions());
-  options.emplace_back(new PermuteOptions(/*max_index=*/42));
+  options.emplace_back(new ScatterOptions());
+  options.emplace_back(new ScatterOptions(/*max_index=*/42));
 
   for (size_t i = 0; i < options.size(); i++) {
     const size_t prev_i = i == 0 ? options.size() - 1 : i - 1;
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index 6324fe62f66af..03330240d9f5d 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -320,23 +320,23 @@ void RegisterVectorInversePermutation(FunctionRegistry* registry) {
 }
 
 // ----------------------------------------------------------------------
-// Permute
+// Scatter
 
-const FunctionDoc permute_doc(
-    "Permute the values into specified positions according to the indices",
+const FunctionDoc scatter_doc(
+    "Scatter the values into specified positions according to the indices",
     "Place the `i`-th value at the position specified by the `i`-th index",
     {"values", "indices"});
 
-const PermuteOptions* GetDefaultPermuteOptions() {
-  static const auto kDefaultPermuteOptions = PermuteOptions::Defaults();
-  return &kDefaultPermuteOptions;
+const ScatterOptions* GetDefaultScatterOptions() {
+  static const auto kDefaultScatterOptions = ScatterOptions::Defaults();
+  return &kDefaultScatterOptions;
 }
 
-class PermuteMetaFunction : public MetaFunction {
+class ScatterMetaFunction : public MetaFunction {
  public:
-  PermuteMetaFunction()
-      : MetaFunction("permute", Arity::Binary(), permute_doc,
-                     GetDefaultPermuteOptions()) {}
+  ScatterMetaFunction()
+      : MetaFunction("scatter", Arity::Binary(), scatter_doc,
+                     GetDefaultScatterOptions()) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
@@ -344,27 +344,27 @@ class PermuteMetaFunction : public MetaFunction {
     DCHECK_EQ(args.size(), 2);
     const auto& values = args[0];
     const auto& indices = args[1];
-    // Though the way how permute is currently implemented may support record batch or
+    // Though the way how scatter is currently implemented may support record batch or
     // table, we don't want to promise that yet.
     if (!values.is_arraylike()) {
-      return Status::NotImplemented("Permute does not support " +
+      return Status::NotImplemented("Scatter does not support " +
                                     ToString(values.kind()) + " values");
     }
     if (!indices.is_arraylike()) {
-      return Status::NotImplemented("Permute does not support " +
+      return Status::NotImplemented("Scatter does not support " +
                                     ToString(values.kind()) + " indices");
     }
-    auto* permute_options = checked_cast<const PermuteOptions*>(options);
+    auto* scatter_options = checked_cast<const ScatterOptions*>(options);
     if (values.length() != indices.length()) {
       return Status::Invalid(
-          "Input and indices of permute must have the same length, got " +
+          "Input and indices of scatter must have the same length, got " +
           std::to_string(values.length()) + " and " + std::to_string(indices.length()));
     }
     if (!is_integer(indices.type()->id())) {
-      return Status::Invalid("Indices of permute must be of integer type, got ",
+      return Status::Invalid("Indices of scatter must be of integer type, got ",
                              indices.type()->ToString());
     }
-    // Internally invoke Take(values, InversePermutation(indices)) to implement permute.
+    // Internally invoke Take(values, InversePermutation(indices)) to implement scatter.
     // For example, with
     //   values = [a, b, c, d, e, f, g]
     //   indices = [null, 0, 3, 2, 4, 1, 1]
@@ -375,7 +375,7 @@ class PermuteMetaFunction : public MetaFunction {
     //   [b, g, d]                    if max_index = 2,
     //   [b, g, d, c, e, null, null]  if max_index = 6.
     InversePermutationOptions inverse_permutation_options{
-        permute_options->max_index,
+        scatter_options->max_index,
         // Use the smallest possible uint type to store inverse permutation.
         InferSmallestInversePermutationType(values.length())};
     ARROW_ASSIGN_OR_RAISE(auto inverse_permutation,
@@ -400,8 +400,8 @@ class PermuteMetaFunction : public MetaFunction {
   }
 };
 
-void RegisterVectorPermute(FunctionRegistry* registry) {
-  DCHECK_OK(registry->AddFunction(std::make_shared<PermuteMetaFunction>()));
+void RegisterVectorScatter(FunctionRegistry* registry) {
+  DCHECK_OK(registry->AddFunction(std::make_shared<ScatterMetaFunction>()));
 }
 
 }  // namespace
@@ -410,7 +410,7 @@ void RegisterVectorPermute(FunctionRegistry* registry) {
 
 void RegisterVectorSwizzle(FunctionRegistry* registry) {
   RegisterVectorInversePermutation(registry);
-  RegisterVectorPermute(registry);
+  RegisterVectorScatter(registry);
 }
 
 }  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index b840025c815f0..4c1ec8e891647 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -300,7 +300,7 @@ TEST(InversePermutation, Basic) {
 }
 
 // ----------------------------------------------------------------------
-// Permute tests
+// Scatter tests
 //
 // Shorthand notation:
 //
@@ -309,53 +309,53 @@ TEST(InversePermutation, Basic) {
 
 namespace {
 
-Result<Datum> Permute(const Datum& values, const Datum& indices, int64_t max_index) {
-  PermuteOptions options{max_index};
-  return Permute(values, indices, options);
+Result<Datum> Scatter(const Datum& values, const Datum& indices, int64_t max_index) {
+  ScatterOptions options{max_index};
+  return Scatter(values, indices, options);
 }
 
-void AssertPermuteAAA(const std::shared_ptr<Array>& values,
+void AssertScatterAAA(const std::shared_ptr<Array>& values,
                       const std::shared_ptr<Array>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, max_index));
+  ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices, max_index));
   AssertDatumsEqual(expected, result);
 }
 
-void AssertPermuteCAC(const std::shared_ptr<ChunkedArray>& values,
+void AssertScatterCAC(const std::shared_ptr<ChunkedArray>& values,
                       const std::shared_ptr<Array>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, max_index));
+  ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices, max_index));
   ASSERT_TRUE(result.is_chunked_array());
   ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
   AssertDatumsEqual(expected, result_array);
 }
 
-void AssertPermuteACC(const std::shared_ptr<Array>& values,
+void AssertScatterACC(const std::shared_ptr<Array>& values,
                       const std::shared_ptr<ChunkedArray>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, max_index));
+  ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices, max_index));
   ASSERT_TRUE(result.is_chunked_array());
   ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
   AssertDatumsEqual(expected, result_array);
 }
 
-void AssertPermuteCCC(const std::shared_ptr<ChunkedArray>& values,
+void AssertScatterCCC(const std::shared_ptr<ChunkedArray>& values,
                       const std::shared_ptr<ChunkedArray>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices, max_index));
+  ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices, max_index));
   ASSERT_TRUE(result.is_chunked_array());
   ASSERT_OK_AND_ASSIGN(auto result_array, Concatenate(result.chunked_array()->chunks()));
   AssertDatumsEqual(expected, result_array);
 }
 
-void DoTestPermuteAAA(const std::shared_ptr<Array>& values,
+void DoTestScatterAAA(const std::shared_ptr<Array>& values,
                       const std::shared_ptr<Array>& indices, int64_t max_index,
                       const std::shared_ptr<Array>& expected) {
-  AssertPermuteAAA(values, indices, max_index, expected);
+  AssertScatterAAA(values, indices, max_index, expected);
 }
 
 /// The following helper functions are based on the invariant:
-/// Permute([V, V], [I', I''], 2 * (m + 1) - 1) == Concat(E, E)
+/// Scatter([V, V], [I', I''], 2 * (m + 1) - 1) == Concat(E, E)
 ///
 /// where
 ///   V = values
@@ -363,7 +363,7 @@ void DoTestPermuteAAA(const std::shared_ptr<Array>& values,
 ///   m = max_index
 ///   I' = ReplaceWithMask(I, i > m, null)
 ///   I'' = ReplaceWithMask(I, i < 0, null) + m + 1
-///   E = Permute(V, I, m)
+///   E = Scatter(V, I, m)
 
 /// Make indices prefix I' = ReplaceWithMask(I, i > m, null).
 Result<std::shared_ptr<Array>> MakeIndicesPrefix(const std::shared_ptr<Array>& indices,
@@ -391,7 +391,7 @@ Result<std::shared_ptr<Array>> MakeIndicesSuffix(const std::shared_ptr<Array>& i
   return suffix.make_array();
 }
 
-void DoTestPermuteCACWithArrays(const std::shared_ptr<Array>& values,
+void DoTestScatterCACWithArrays(const std::shared_ptr<Array>& values,
                                 const std::shared_ptr<Array>& indices, int64_t max_index,
                                 const std::shared_ptr<Array>& expected) {
   auto chunked_values2 = std::make_shared<ChunkedArray>(ArrayVector{values, values});
@@ -404,11 +404,11 @@ void DoTestPermuteCACWithArrays(const std::shared_ptr<Array>& values,
   ASSERT_OK_AND_ASSIGN(auto concat_expected2,
                        Concatenate(ArrayVector{expected, expected}));
 
-  AssertPermuteCAC(chunked_values2, concat_indices2, (max_index + 1) * 2 - 1,
+  AssertScatterCAC(chunked_values2, concat_indices2, (max_index + 1) * 2 - 1,
                    concat_expected2);
 }
 
-void DoTestPermuteACCWithArrays(const std::shared_ptr<Array>& values,
+void DoTestScatterACCWithArrays(const std::shared_ptr<Array>& values,
                                 const std::shared_ptr<Array>& indices, int64_t max_index,
                                 const std::shared_ptr<Array>& expected) {
   ASSERT_OK_AND_ASSIGN(auto concat_values2, Concatenate(ArrayVector{values, values}));
@@ -421,11 +421,11 @@ void DoTestPermuteACCWithArrays(const std::shared_ptr<Array>& values,
   ASSERT_OK_AND_ASSIGN(auto concat_expected2,
                        Concatenate(ArrayVector{expected, expected}));
 
-  AssertPermuteACC(concat_values2, chunked_indices2, (max_index + 1) * 2 - 1,
+  AssertScatterACC(concat_values2, chunked_indices2, (max_index + 1) * 2 - 1,
                    concat_expected2);
 }
 
-void DoTestPermuteCCCWithArrays(const std::shared_ptr<Array>& values,
+void DoTestScatterCCCWithArrays(const std::shared_ptr<Array>& values,
                                 const std::shared_ptr<Array>& indices, int64_t max_index,
                                 const std::shared_ptr<Array>& expected) {
   auto chunked_values2 = std::make_shared<ChunkedArray>(ArrayVector{values, values});
@@ -438,11 +438,11 @@ void DoTestPermuteCCCWithArrays(const std::shared_ptr<Array>& values,
   ASSERT_OK_AND_ASSIGN(auto concat_expected2,
                        Concatenate(ArrayVector{expected, expected}));
 
-  AssertPermuteCCC(chunked_values2, chunked_indices2, (max_index + 1) * 2 - 1,
+  AssertScatterCCC(chunked_values2, chunked_indices2, (max_index + 1) * 2 - 1,
                    concat_expected2);
 }
 
-void DoTestPermuteForIndicesTypes(
+void DoTestScatterForIndicesTypes(
     const std::vector<std::shared_ptr<DataType>>& indices_types,
     const std::shared_ptr<Array>& values, const std::shared_ptr<Array>& indices,
     int64_t max_index, const std::shared_ptr<Array>& expected) {
@@ -453,61 +453,61 @@ void DoTestPermuteForIndicesTypes(
     auto casted_indices = casted.make_array();
     {
       ARROW_SCOPED_TRACE("AAA");
-      DoTestPermuteAAA(values, casted_indices, max_index, expected);
+      DoTestScatterAAA(values, casted_indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("CAA");
-      DoTestPermuteCACWithArrays(values, casted_indices, max_index, expected);
+      DoTestScatterCACWithArrays(values, casted_indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("ACA");
-      DoTestPermuteACCWithArrays(values, casted_indices, max_index, expected);
+      DoTestScatterACCWithArrays(values, casted_indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("CCA");
-      DoTestPermuteCCCWithArrays(values, casted_indices, max_index, expected);
+      DoTestScatterCCCWithArrays(values, casted_indices, max_index, expected);
     }
   }
 }
 
-void DoTestPermuteSignedIndices(const std::shared_ptr<Array>& values,
+void DoTestScatterSignedIndices(const std::shared_ptr<Array>& values,
                                 const std::shared_ptr<Array>& indices, int64_t max_index,
                                 const std::shared_ptr<Array>& expected) {
-  DoTestPermuteForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);
+  DoTestScatterForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);
 }
 
-void DoTestPermute(const std::shared_ptr<Array>& values,
+void DoTestScatter(const std::shared_ptr<Array>& values,
                    const std::shared_ptr<Array>& indices, int64_t max_index,
                    const std::shared_ptr<Array>& expected) {
-  DoTestPermuteForIndicesTypes(kIntegerTypes, values, indices, max_index, expected);
+  DoTestScatterForIndicesTypes(kIntegerTypes, values, indices, max_index, expected);
 }
 
 }  // namespace
 
-TEST(Permute, Invalid) {
+TEST(Scatter, Invalid) {
   {
     ARROW_SCOPED_TRACE("Length mismatch");
     auto values = ArrayFromJSON(int32(), "[0, 1]");
     auto indices = ArrayFromJSON(int32(), "[0]");
     ASSERT_RAISES_WITH_MESSAGE(
         Invalid,
-        "Invalid: Input and indices of permute must have the same length, got 2 and 1",
-        Permute(values, indices));
+        "Invalid: Input and indices of scatter must have the same length, got 2 and 1",
+        Scatter(values, indices));
   }
   {
     ARROW_SCOPED_TRACE("Invalid input type");
     auto values = ArrayFromJSON(int32(), "[0]");
     auto indices = ArrayFromJSON(utf8(), R"(["a"])");
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid, "Invalid: Indices of permute must be of integer type, got string",
-        Permute(values, indices));
+        Invalid, "Invalid: Indices of scatter must be of integer type, got string",
+        Scatter(values, indices));
   }
 }
 
-TEST(Permute, DefaultOptions) {
+TEST(Scatter, DefaultOptions) {
   {
     ARROW_SCOPED_TRACE("Default options values");
-    PermuteOptions options;
+    ScatterOptions options;
     ASSERT_EQ(options.max_index, -1);
   }
   {
@@ -516,14 +516,14 @@ TEST(Permute, DefaultOptions) {
     for (const auto& indices_type : kIntegerTypes) {
       ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
       auto indices = ArrayFromJSON(indices_type, "[0]");
-      ASSERT_OK_AND_ASSIGN(Datum result, Permute(values, indices));
+      ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices));
       AssertDatumsEqual(values, result);
     }
   }
 }
 
 template <typename ArrowType>
-class TestPermuteSmallIndicesTypes : public ::testing::Test {
+class TestScatterSmallIndicesTypes : public ::testing::Test {
  protected:
   using CType = typename TypeTraits<ArrowType>::CType;
 
@@ -532,9 +532,9 @@ class TestPermuteSmallIndicesTypes : public ::testing::Test {
   }
 };
 
-TYPED_TEST_SUITE(TestPermuteSmallIndicesTypes, SmallOutputTypes);
+TYPED_TEST_SUITE(TestScatterSmallIndicesTypes, SmallOutputTypes);
 
-TYPED_TEST(TestPermuteSmallIndicesTypes, MaxIntegerIndex) {
+TYPED_TEST(TestScatterSmallIndicesTypes, MaxIntegerIndex) {
   auto values = ArrayFromJSON(utf8(), R"(["a"])");
   auto indices_type = this->type_singleton();
   int64_t max_integer =
@@ -545,11 +545,11 @@ TYPED_TEST(TestPermuteSmallIndicesTypes, MaxIntegerIndex) {
   auto expected_suffix_value = values;
   ASSERT_OK_AND_ASSIGN(auto expected,
                        Concatenate({expected_prefix_nulls, expected_suffix_value}));
-  DoTestPermuteAAA(values, indices, /*max_index=*/max_integer - 1, expected);
+  DoTestScatterAAA(values, indices, /*max_index=*/max_integer - 1, expected);
 }
 
 template <typename ArrowType>
-class TestPermuteTyped : public ::testing::Test {
+class TestScatterTyped : public ::testing::Test {
  protected:
   virtual std::shared_ptr<DataType> values_type() const {
     if constexpr (is_parameter_free_type<ArrowType>::value) {
@@ -560,21 +560,21 @@ class TestPermuteTyped : public ::testing::Test {
     }
   }
 
-  void TestPermuteSignedIndices(const std::string& values_str,
+  void TestScatterSignedIndices(const std::string& values_str,
                                 const std::string& indices_str, int64_t max_index,
                                 const std::string& expected_str) {
-    TestPermute(DoTestPermuteSignedIndices, values_str, indices_str, max_index,
+    TestScatter(DoTestScatterSignedIndices, values_str, indices_str, max_index,
                 expected_str);
   }
 
-  void TestPermute(const std::string& values_str, const std::string& indices_str,
+  void TestScatter(const std::string& values_str, const std::string& indices_str,
                    int64_t max_index, const std::string& expected_str) {
-    TestPermute(DoTestPermute, values_str, indices_str, max_index, expected_str);
+    TestScatter(DoTestScatter, values_str, indices_str, max_index, expected_str);
   }
 
  private:
   template <typename DoTestFunc>
-  void TestPermute(DoTestFunc&& func, const std::string& values_str,
+  void TestScatter(DoTestFunc&& func, const std::string& values_str,
                    const std::string& indices_str, int64_t max_index,
                    const std::string& expected_str) {
     auto values = ArrayFromJSON(values_type(), values_str);
@@ -584,16 +584,16 @@ class TestPermuteTyped : public ::testing::Test {
   }
 };
 
-class TestPermuteBoolean : public TestPermuteTyped<BooleanType> {};
+class TestScatterBoolean : public TestScatterTyped<BooleanType> {};
 
-TEST_F(TestPermuteBoolean, Basic) {
+TEST_F(TestScatterBoolean, Basic) {
   {
     ARROW_SCOPED_TRACE("Basic");
     auto values = "[true, false, true, true, false, false, true, true, true, false]";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t max_index = 9;
     auto expected = "[false, true, true, true, false, false, true, true, false, true]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values with nulls");
@@ -601,7 +601,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t max_index = 9;
     auto expected = "[true, null, null, false, false, true, true, null, false, true]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with nulls");
@@ -609,7 +609,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
     int64_t max_index = 9;
     auto expected = "[null, true, null, true, null, false, null, true, null, true]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with negatives");
@@ -617,7 +617,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
     int64_t max_index = 9;
     auto expected = "[null, true, null, true, null, false, null, true, null, true]";
-    TestPermuteSignedIndices(values, indices, max_index, expected);
+    TestScatterSignedIndices(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output less than input");
@@ -625,7 +625,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[1, 0]";
     int64_t max_index = 0;
     auto expected = "[true]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
@@ -633,7 +633,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[0, 3, 6, 1, 4, 7]";
     int64_t max_index = 8;
     auto expected = "[true, false, null, true, false, null, true, false, null]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values all null");
@@ -641,7 +641,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[0, 1]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices all null");
@@ -649,7 +649,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[null, null]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
@@ -657,7 +657,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[2, 3]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
@@ -665,7 +665,7 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices duplicated indices");
@@ -673,23 +673,23 @@ TEST_F(TestPermuteBoolean, Basic) {
     auto indices = "[0, 1, 0, 1]";
     int64_t max_index = 3;
     auto expected = "[null, null, null, null]";
-    TestPermute(values, indices, max_index, expected);
+    TestScatter(values, indices, max_index, expected);
   }
 }
 
 template <typename ArrowType>
-class TestPermuteNumeric : public TestPermuteTyped<ArrowType> {};
+class TestScatterNumeric : public TestScatterTyped<ArrowType> {};
 
-TYPED_TEST_SUITE(TestPermuteNumeric, NumericArrowTypes);
+TYPED_TEST_SUITE(TestScatterNumeric, NumericArrowTypes);
 
-TYPED_TEST(TestPermuteNumeric, Basic) {
+TYPED_TEST(TestScatterNumeric, Basic) {
   {
     ARROW_SCOPED_TRACE("Basic");
     auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t max_index = 9;
     auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values with nulls");
@@ -697,7 +697,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t max_index = 9;
     auto expected = "[19, null, 17, null, 15, null, 13, null, 11, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with nulls");
@@ -705,7 +705,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
     int64_t max_index = 9;
     auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with negatives");
@@ -713,7 +713,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
     int64_t max_index = 9;
     auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
-    this->TestPermuteSignedIndices(values, indices, max_index, expected);
+    this->TestScatterSignedIndices(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output less than input");
@@ -721,7 +721,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[1, 0]";
     int64_t max_index = 0;
     auto expected = "[0]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
@@ -729,7 +729,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[0, 3, 6, 1, 4, 7]";
     int64_t max_index = 8;
     auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values all null");
@@ -737,7 +737,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[0, 1]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices all null");
@@ -745,7 +745,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[null, null]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
@@ -753,7 +753,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[2, 3]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
@@ -761,7 +761,7 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices duplicated indices");
@@ -769,23 +769,23 @@ TYPED_TEST(TestPermuteNumeric, Basic) {
     auto indices = "[0, 1, 0, 1]";
     int64_t max_index = 3;
     auto expected = "[null, null, null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
 }
 
 template <typename ArrowType>
-class TestPermuteString : public TestPermuteTyped<ArrowType> {};
+class TestScatterString : public TestScatterTyped<ArrowType> {};
 
-TYPED_TEST_SUITE(TestPermuteString, BaseBinaryArrowTypes);
+TYPED_TEST_SUITE(TestScatterString, BaseBinaryArrowTypes);
 
-TYPED_TEST(TestPermuteString, Basic) {
+TYPED_TEST(TestScatterString, Basic) {
   {
     ARROW_SCOPED_TRACE("Basic");
     auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t max_index = 9;
     auto expected = R"(["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"])";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values with nulls");
@@ -793,7 +793,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t max_index = 9;
     auto expected = R"(["j", null, "h", null, "f", null, "d", null, "b", null])";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with nulls");
@@ -801,7 +801,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
     int64_t max_index = 9;
     auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with negatives");
@@ -809,7 +809,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
     int64_t max_index = 9;
     auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
-    this->TestPermuteSignedIndices(values, indices, max_index, expected);
+    this->TestScatterSignedIndices(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output less than input");
@@ -817,7 +817,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[1, 0]";
     int64_t max_index = 0;
     auto expected = R"(["a"])";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
@@ -825,7 +825,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[0, 3, 6, 1, 4, 7]";
     int64_t max_index = 8;
     auto expected = R"(["a", "b", null, "a", "b", null, "a", "b", null])";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values all null");
@@ -833,7 +833,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[0, 1]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices all null");
@@ -841,7 +841,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[null, null]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output all null");
@@ -849,7 +849,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[2, 3]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
@@ -857,7 +857,7 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices duplicated indices");
@@ -865,13 +865,13 @@ TYPED_TEST(TestPermuteString, Basic) {
     auto indices = "[0, 1, 0, 1]";
     int64_t max_index = 3;
     auto expected = "[null, null, null, null]";
-    this->TestPermute(values, indices, max_index, expected);
+    this->TestScatter(values, indices, max_index, expected);
   }
 }
 
 // ----------------------------------------------------------------------
-// Test Permute using a hypothetical if-else special form.
-// Also demonstrate how Permute can serve as a building block of implementing special
+// Test Scatter using a hypothetical if-else special form.
+// Also demonstrate how Scatter can serve as a building block of implementing special
 // forms.
 
 namespace {
@@ -886,9 +886,9 @@ Result<Datum> ExecuteIfElseByExpr(const Expression& cond, const Expression& if_t
   return ExecuteScalarExpression(bound, input);
 }
 
-/// Execute an if-else expression in a special form fashion, in which Permute is used as a
+/// Execute an if-else expression in a special form fashion, in which Scatter is used as a
 /// building block.
-Result<Datum> ExecuteIfElseByPermute(const Expression& cond, const Expression& if_true,
+Result<Datum> ExecuteIfElseByScatter(const Expression& cond, const Expression& if_true,
                                      const Expression& if_false,
                                      const std::shared_ptr<Schema>& schema,
                                      const ExecBatch& input) {
@@ -950,11 +950,11 @@ Result<Datum> ExecuteIfElseByPermute(const Expression& cond, const Expression& i
   auto sel_ca =
       std::make_shared<ChunkedArray>(ArrayVector{sel_if_true_array, sel_if_false_array});
 
-  // 9. Finally, permute the "true"/"false" results to their original positions in the
+  // 9. Finally, scatter the "true"/"false" results to their original positions in the
   // input (according to the selection vectors). Note we didn't handle the rows with nulls
-  // in the mask, because Permute will fill nulls for these rows and this is equal to the
+  // in the mask, because Scatter will fill nulls for these rows and this is equal to the
   // null handling policy of if-else, which is pretty nice.
-  return Permute(/*values=*/result_ca, /*indices=*/sel_ca,
+  return Scatter(/*values=*/result_ca, /*indices=*/sel_ca,
                  /*max_index=*/input.length - 1);
 }
 
@@ -964,23 +964,23 @@ void DoTestIfElse(const Expression& cond, const Expression& if_true,
   ASSERT_OK_AND_ASSIGN(Datum result_by_expr,
                        ExecuteIfElseByExpr(cond, if_true, if_false, schema, input));
   ASSERT_TRUE(result_by_expr.is_array());
-  ASSERT_OK_AND_ASSIGN(Datum result_by_permute,
-                       ExecuteIfElseByPermute(cond, if_true, if_false, schema, input));
-  // Permute will output chunked array because we input values and indices as chunked
+  ASSERT_OK_AND_ASSIGN(Datum result_by_scatter,
+                       ExecuteIfElseByScatter(cond, if_true, if_false, schema, input));
+  // Scatter will output chunked array because we input values and indices as chunked
   // arrays consisting of each branches. We don't care the shape of the output when
   // comparing the results - only contents, so we concatenate the chunked array.
-  ASSERT_TRUE(result_by_permute.is_chunked_array());
-  ASSERT_OK_AND_ASSIGN(auto result_by_permute_concat,
-                       Concatenate(result_by_permute.chunked_array()->chunks()));
+  ASSERT_TRUE(result_by_scatter.is_chunked_array());
+  ASSERT_OK_AND_ASSIGN(auto result_by_scatter_concat,
+                       Concatenate(result_by_scatter.chunked_array()->chunks()));
 
-  AssertDatumsEqual(result_by_expr, result_by_permute_concat);
+  AssertDatumsEqual(result_by_expr, result_by_scatter_concat);
 }
 
 void DoTestIfElse(const Expression& cond, const Expression& if_true,
                   const Expression& if_false, const std::shared_ptr<Schema>& schema,
                   const ExecBatch& input, const std::shared_ptr<Array>& expected) {
   ASSERT_OK_AND_ASSIGN(Datum result,
-                       ExecuteIfElseByPermute(cond, if_true, if_false, schema, input));
+                       ExecuteIfElseByScatter(cond, if_true, if_false, schema, input));
   ASSERT_TRUE(result.is_chunked_array());
   ASSERT_OK_AND_ASSIGN(auto result_concat, Concatenate(result.chunked_array()->chunks()));
 
@@ -989,7 +989,7 @@ void DoTestIfElse(const Expression& cond, const Expression& if_true,
 
 }  // namespace
 
-TEST(Permute, IfElse) {
+TEST(Scatter, IfElse) {
   {
     ARROW_SCOPED_TRACE("if (b != 0) then a / b else b");
     auto cond = call("not_equal", {field_ref("b"), literal(0)});

From bd334fe7b8aa657836eea45630330eb29132f66f Mon Sep 17 00:00:00 2001
From: Ruoxi Sun <zanmato1984@gmail.com>
Date: Wed, 6 Nov 2024 14:50:15 +0800
Subject: [PATCH 36/54] Fixing some renamings

---
 cpp/src/arrow/compute/api_vector.h              | 6 +++---
 cpp/src/arrow/compute/kernels/vector_swizzle.cc | 5 ++---
 docs/source/cpp/compute.rst                     | 6 +++---
 3 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index b53b4697f048a..c7dd4acef2ac1 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -266,8 +266,8 @@ class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
   static InversePermutationOptions Defaults() { return InversePermutationOptions(); }
 
   /// \brief The max value in the input indices to process. Any indices that are greater
-  /// to this length will be ignored. If negative, this value will be set to the length of
-  /// the input indices minus 1.
+  /// than this value will be ignored. If negative, this value will be set to the length
+  /// of the input indices minus 1.
   int64_t max_index = -1;
   /// \brief The type of the output inverse permutation. If null, the output will be of
   /// the same type as the input indices, otherwise must be integer types. An invalid
@@ -284,7 +284,7 @@ class ARROW_EXPORT ScatterOptions : public FunctionOptions {
   static ScatterOptions Defaults() { return ScatterOptions(); }
 
   /// \brief The max value in the input indices to process. Any values with indices that
-  /// are greater to this length will be ignored. If negative, this value will be set to
+  /// are greater than this value will be ignored. If negative, this value will be set to
   /// the length of the input minus 1.
   int64_t max_index = -1;
 };
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index 03330240d9f5d..3975e74dff9ea 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -123,8 +123,7 @@ struct InversePermutationImpl {
     // buffer is preallocated and filled with all "impossible" values (that is,
     // input_length - note that the range of inverse_permutation is [0, input_length)) for
     // the subsequent processing to detect validity.
-    bool likely_many_nulls = LikelyManyNulls();
-    if (likely_many_nulls) {
+    if (LikelyManyNulls()) {
       RETURN_NOT_OK(AllocateValidityBufAndFill(false));
       RETURN_NOT_OK(AllocateDataBuf(output_type));
       return Execute<Type, true>();
@@ -158,7 +157,7 @@ struct InversePermutationImpl {
 
     ARROW_ASSIGN_OR_RAISE(validity_buf, ctx->AllocateBitmap(output_length));
     auto validity = validity_buf->mutable_data_as<uint8_t>();
-    std::memset(validity, valid ? 0xff : 0, bit_util::BytesForBits(output_length));
+    std::memset(validity, valid ? 0xff : 0, validity_buf->size());
 
     return Status::OK();
   }
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 28c31f3e7de38..98c31669d8107 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1902,7 +1902,7 @@ operation to the n-th and (n+abs(p))-th inputs.
 Swizzle functions
 ~~~~~~~~~~~~~~~~~~~
 
-Swizzle functions reorder the input array based on targeting indices.
+Swizzle functions reorder the input array based on the specified indices.
 
 +---------------------+--------+--------------+--------------+--------------+-------------------------------------+-------+
 | Function name       | Arity  | Input type 1 | Input type 2 | Output type  | Options class                       | Notes |
@@ -1916,10 +1916,10 @@ Swizzle functions reorder the input array based on targeting indices.
 
 * \(2) For ``indices[i] = x``, ``inverse_permutation[x] = i``. And ``inverse_permutation[x]
  = null`` if ``x`` does not appear in the input ``indices``. For ``indices[i] = x``
- where ``x < 0`` or ``x >= output_length``, it is ignored. If multiple indices point
+ where ``x < 0`` or ``x > max_index``, it is ignored. If multiple indices point
  to the same value, the last one is used.
 
 * \(3) For ``indices[i] = x``, ``output[x] = values[i]``. And ``output[x] = null``
 if ``x`` does not appear in the input ``indices``. For ``indices[i] = x`` where
-``x < 0`` or ``x >= output_length``, ``values[i]`` is ignored. If multiple indices
+``x < 0`` or ``x > max_index``, ``values[i]`` is ignored. If multiple indices
 point to the same value, the last one is used.

From bbe328d7a1991b7b9b7a4b861b2f63380955e81a Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Wed, 11 Dec 2024 10:18:06 +0800
Subject: [PATCH 37/54] Update docs/source/cpp/compute.rst

Co-authored-by: Antoine Pitrou <pitrou@free.fr>
---
 docs/source/cpp/compute.rst | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 98c31669d8107..bb1c06b8b1ae0 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1915,11 +1915,11 @@ Swizzle functions reorder the input array based on the specified indices.
 * \(1) The output type is specified in :struct:`InversePermutationOptions`.
 
 * \(2) For ``indices[i] = x``, ``inverse_permutation[x] = i``. And ``inverse_permutation[x]
- = null`` if ``x`` does not appear in the input ``indices``. For ``indices[i] = x``
- where ``x < 0`` or ``x > max_index``, it is ignored. If multiple indices point
- to the same value, the last one is used.
+  = null`` if ``x`` does not appear in the input ``indices``. For ``indices[i] = x``
+  where ``x < 0`` or ``x > max_index``, it is ignored. If multiple indices point
+  to the same value, the last one is used.
 
 * \(3) For ``indices[i] = x``, ``output[x] = values[i]``. And ``output[x] = null``
-if ``x`` does not appear in the input ``indices``. For ``indices[i] = x`` where
-``x < 0`` or ``x > max_index``, ``values[i]`` is ignored. If multiple indices
-point to the same value, the last one is used.
+  if ``x`` does not appear in the input ``indices``. For ``indices[i] = x`` where
+  ``x < 0`` or ``x > max_index``, ``values[i]`` is ignored. If multiple indices
+  point to the same value, the last one is used.

From 6cd7f4045bd04e387dce94d5b485addc42edb9e4 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Wed, 11 Dec 2024 17:42:35 +0800
Subject: [PATCH 38/54] Update cpp/src/arrow/compute/api_vector.h

Co-authored-by: Antoine Pitrou <pitrou@free.fr>
---
 cpp/src/arrow/compute/api_vector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index c7dd4acef2ac1..a4f4af67d57c0 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -270,7 +270,7 @@ class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
   /// of the input indices minus 1.
   int64_t max_index = -1;
   /// \brief The type of the output inverse permutation. If null, the output will be of
-  /// the same type as the input indices, otherwise must be integer types. An invalid
+  /// the same type as the input indices, otherwise must be integer type. An invalid
   /// error will be reported if this type is not able to store the length of the input
   /// indices.
   std::shared_ptr<DataType> output_type = NULLPTR;

From 9364e4cf6ed722490529ccee2c06f1d80e66b052 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Wed, 11 Dec 2024 17:42:59 +0800
Subject: [PATCH 39/54] Update cpp/src/arrow/compute/api_vector.h

Co-authored-by: Antoine Pitrou <pitrou@free.fr>
---
 cpp/src/arrow/compute/api_vector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index a4f4af67d57c0..a735ddc2de296 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -265,7 +265,7 @@ class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "InversePermutationOptions";
   static InversePermutationOptions Defaults() { return InversePermutationOptions(); }
 
-  /// \brief The max value in the input indices to process. Any indices that are greater
+  /// \brief The max value in the input indices to allow. Any indices that are greater
   /// than this value will be ignored. If negative, this value will be set to the length
   /// of the input indices minus 1.
   int64_t max_index = -1;

From 18f1f32612c328f4ab4a3b3e228a6ace2d7ea923 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Wed, 11 Dec 2024 17:43:39 +0800
Subject: [PATCH 40/54] Update
 cpp/src/arrow/compute/kernels/vector_swizzle_test.cc

Co-authored-by: Antoine Pitrou <pitrou@free.fr>
---
 cpp/src/arrow/compute/kernels/vector_swizzle_test.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index 4c1ec8e891647..8788ad2fd18e6 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -63,6 +63,7 @@ void AssertInversePermutation(const Datum& indices, int64_t max_index,
                               const std::shared_ptr<DataType>& output_type,
                               const Datum& expected, bool validity_must_be_null) {
   ASSERT_OK_AND_ASSIGN(auto result, InversePermutation(indices, max_index, output_type));
+  ValidateOutput(result);
   ASSERT_EQ(indices.kind(), result.kind());
   std::shared_ptr<Array> result_array;
   if (result.is_array()) {

From d27782b290b1dafa0cbc7a180d7e2112d85506b1 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Wed, 11 Dec 2024 17:44:18 +0800
Subject: [PATCH 41/54] Update
 cpp/src/arrow/compute/kernels/vector_swizzle_test.cc

Co-authored-by: Antoine Pitrou <pitrou@free.fr>
---
 cpp/src/arrow/compute/kernels/vector_swizzle_test.cc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index 8788ad2fd18e6..7ee014c90c2fe 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -312,7 +312,9 @@ namespace {
 
 Result<Datum> Scatter(const Datum& values, const Datum& indices, int64_t max_index) {
   ScatterOptions options{max_index};
-  return Scatter(values, indices, options);
+  ARROW_ASSIGN_OR_RAISE(Datum result, Scatter(values, indices, options));
+  ValidateOutput(result);
+  return result;
 }
 
 void AssertScatterAAA(const std::shared_ptr<Array>& values,

From 2d09a8e698dcbf6569ccc7ea57bb824f711d47df Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Wed, 11 Dec 2024 18:28:00 +0800
Subject: [PATCH 42/54] Limit input/output type to signed integers

---
 .../arrow/compute/kernels/vector_swizzle.cc   |  27 +-
 .../compute/kernels/vector_swizzle_test.cc    | 240 ++----------------
 docs/source/cpp/compute.rst                   |  14 +-
 3 files changed, 44 insertions(+), 237 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index 3975e74dff9ea..fc1b5a6e88e89 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -42,7 +42,8 @@ const InversePermutationOptions* GetDefaultInversePermutationOptions() {
 using InversePermutationState = OptionsWrapper<InversePermutationOptions>;
 
 /// Resolve the output type of inverse_permutation. The output type is specified in the
-/// options, and if null, set it to the input type. The output type must be integer.
+/// options, and if null, set it to the input type. The output type must be signed
+/// integer.
 Result<TypeHolder> ResolveInversePermutationOutputType(
     KernelContext* ctx, const std::vector<TypeHolder>& input_types) {
   DCHECK_EQ(input_types.size(), 1);
@@ -52,9 +53,10 @@ Result<TypeHolder> ResolveInversePermutationOutputType(
   if (!output_type) {
     output_type = input_types[0].owned_type;
   }
-  if (!is_integer(output_type->id())) {
-    return Status::Invalid("Output type of inverse_permutation must be integer, got " +
-                           output_type->ToString());
+  if (!is_signed_integer(output_type->id())) {
+    return Status::Invalid(
+        "Output type of inverse_permutation must be signed integer, got " +
+        output_type->ToString());
   }
 
   return TypeHolder(std::move(output_type));
@@ -311,7 +313,7 @@ void RegisterVectorInversePermutation(FunctionRegistry* registry) {
     kernel.output_chunked = false;
     DCHECK_OK(function->AddKernel(std::move(kernel)));
   };
-  for (const auto& t : IntTypes()) {
+  for (const auto& t : SignedIntTypes()) {
     add_kernel(t->id());
   }
 
@@ -387,14 +389,15 @@ class ScatterMetaFunction : public MetaFunction {
  private:
   static std::shared_ptr<DataType> InferSmallestInversePermutationType(
       int64_t input_length) {
-    if (input_length <= std::numeric_limits<uint8_t>::max()) {
-      return uint8();
-    } else if (input_length <= std::numeric_limits<uint16_t>::max()) {
-      return uint16();
-    } else if (input_length <= std::numeric_limits<uint32_t>::max()) {
-      return uint32();
+    DCHECK_GE(input_length, 0);
+    if (input_length <= std::numeric_limits<int8_t>::max()) {
+      return int8();
+    } else if (input_length <= std::numeric_limits<int16_t>::max()) {
+      return int16();
+    } else if (input_length <= std::numeric_limits<int32_t>::max()) {
+      return int32();
     } else {
-      return uint64();
+      return int64();
     }
   }
 };
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index 7ee014c90c2fe..cf5c0b1d90126 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -33,9 +33,6 @@ namespace {
 static const std::vector<std::shared_ptr<DataType>> kSignedIntegerTypes = {
     int8(), int16(), int32(), int64()};
 
-static const std::vector<std::shared_ptr<DataType>> kIntegerTypes = {
-    int8(), uint8(), int16(), uint16(), int32(), uint32(), int64(), uint64()};
-
 static const std::vector<std::shared_ptr<DataType>> kNumericTypes = {
     uint8(), int8(),   uint16(), int16(),   uint32(),
     int32(), uint64(), int64(),  float32(), float64()};
@@ -44,7 +41,7 @@ static const std::vector<std::shared_ptr<DataType>> kNumericAndBaseBinaryTypes =
     uint8(), int8(),    uint16(),  int16(),  uint32(), int32(),        uint64(),
     int64(), float32(), float64(), binary(), utf8(),   large_binary(), large_utf8()};
 
-using SmallOutputTypes = ::testing::Types<UInt8Type, UInt16Type, Int8Type, Int16Type>;
+using SmallOutputTypes = ::testing::Types<Int8Type, Int16Type>;
 
 }  // namespace
 
@@ -96,7 +93,7 @@ void DoTestInversePermutationForInputOutputTypes(
     const std::vector<std::shared_ptr<DataType>>& input_types,
     const std::vector<std::shared_ptr<DataType>>& output_types, InputFunc&& input,
     int64_t max_index, const std::string& expected_str, bool validity_must_be_null) {
-  for (const auto& output_type : kIntegerTypes) {
+  for (const auto& output_type : output_types) {
     ARROW_SCOPED_TRACE("Output type: " + output_type->ToString());
     auto expected = ArrayFromJSON(output_type, expected_str);
     DoTestInversePermutationForInputTypes(input_types, std::forward<InputFunc>(input),
@@ -130,32 +127,32 @@ void TestInversePermutationForInputOutputTypes(
   }
 }
 
-void TestInversePermutationSigned(const std::string& indices_str,
-                                  const std::vector<std::string>& indices_chunked_str,
-                                  int64_t max_index, const std::string& expected_str,
-                                  bool validity_must_be_null = false) {
-  TestInversePermutationForInputOutputTypes(kSignedIntegerTypes, kIntegerTypes,
-                                            indices_str, indices_chunked_str, max_index,
-                                            expected_str, validity_must_be_null);
-}
-
 void TestInversePermutation(const std::string& indices_str,
                             const std::vector<std::string>& indices_chunked_str,
                             int64_t max_index, const std::string& expected_str,
                             bool validity_must_be_null = false) {
-  TestInversePermutationForInputOutputTypes(kIntegerTypes, kIntegerTypes, indices_str,
-                                            indices_chunked_str, max_index, expected_str,
-                                            validity_must_be_null);
+  TestInversePermutationForInputOutputTypes(kSignedIntegerTypes, kSignedIntegerTypes,
+                                            indices_str, indices_chunked_str, max_index,
+                                            expected_str, validity_must_be_null);
 }
 
 }  // namespace
 
 TEST(InversePermutation, InvalidOutputType) {
+  {
+    ARROW_SCOPED_TRACE("Output type unsigned");
+    auto indices = ArrayFromJSON(int32(), "[]");
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid,
+        "Invalid: Output type of inverse_permutation must be signed integer, got uint32",
+        InversePermutation(indices, /*max_index=*/0, /*output_type=*/uint32()));
+  }
   {
     ARROW_SCOPED_TRACE("Output type float");
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid, "Invalid: Output type of inverse_permutation must be integer, got float",
+        Invalid,
+        "Invalid: Output type of inverse_permutation must be signed integer, got float",
         InversePermutation(indices, /*max_index=*/0, /*output_type=*/float32()));
   }
   {
@@ -163,7 +160,7 @@ TEST(InversePermutation, InvalidOutputType) {
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
         Invalid,
-        "Invalid: Output type of inverse_permutation must be integer, got string",
+        "Invalid: Output type of inverse_permutation must be signed integer, got string",
         InversePermutation(indices, /*max_index=*/0, /*output_type=*/utf8()));
   }
 }
@@ -177,7 +174,7 @@ TEST(InversePermutation, DefaultOptions) {
   }
   {
     ARROW_SCOPED_TRACE("Default options semantics");
-    for (const auto& input_type : kIntegerTypes) {
+    for (const auto& input_type : kSignedIntegerTypes) {
       ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
       auto indices = ArrayFromJSON(input_type, "[0]");
       ASSERT_OK_AND_ASSIGN(Datum result, InversePermutation(indices));
@@ -205,7 +202,7 @@ TYPED_TEST(TestInversePermutationSmallOutputType, JustEnoughOutputType) {
   auto expected =
       ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
   DoTestInversePermutationForInputTypes(
-      kIntegerTypes,
+      kSignedIntegerTypes,
       [&](const std::shared_ptr<DataType>& input_type) {
         return ConstantArrayGenerator::Zeroes(input_length, input_type);
       },
@@ -216,7 +213,7 @@ TYPED_TEST(TestInversePermutationSmallOutputType, InsufficientOutputType) {
   auto output_type = this->type_singleton();
   int64_t input_length =
       static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max()) + 1;
-  for (const auto& input_type : kIntegerTypes) {
+  for (const auto& input_type : kSignedIntegerTypes) {
     ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
     auto indices = ConstantArrayGenerator::Zeroes(input_length, input_type);
     ASSERT_RAISES_WITH_MESSAGE(
@@ -255,7 +252,7 @@ TEST(InversePermutation, Basic) {
         "[]", "[9, 7, 5, 3, 1]", "[-1]", "[-2, -3, -4]", "[-5]", "[]"};
     int64_t max_index = 9;
     auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
-    TestInversePermutationSigned(indices, indices_chunked, max_index, expected);
+    TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
@@ -482,7 +479,7 @@ void DoTestScatterSignedIndices(const std::shared_ptr<Array>& values,
 void DoTestScatter(const std::shared_ptr<Array>& values,
                    const std::shared_ptr<Array>& indices, int64_t max_index,
                    const std::shared_ptr<Array>& expected) {
-  DoTestScatterForIndicesTypes(kIntegerTypes, values, indices, max_index, expected);
+  DoTestScatterForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);
 }
 
 }  // namespace
@@ -516,7 +513,7 @@ TEST(Scatter, DefaultOptions) {
   {
     ARROW_SCOPED_TRACE("Default options semantics");
     auto values = ArrayFromJSON(utf8(), R"(["a"])");
-    for (const auto& indices_type : kIntegerTypes) {
+    for (const auto& indices_type : kSignedIntegerTypes) {
       ARROW_SCOPED_TRACE("Indices type: " + indices_type->ToString());
       auto indices = ArrayFromJSON(indices_type, "[0]");
       ASSERT_OK_AND_ASSIGN(Datum result, Scatter(values, indices));
@@ -872,197 +869,4 @@ TYPED_TEST(TestScatterString, Basic) {
   }
 }
 
-// ----------------------------------------------------------------------
-// Test Scatter using a hypothetical if-else special form.
-// Also demonstrate how Scatter can serve as a building block of implementing special
-// forms.
-
-namespace {
-
-/// Execute an if-else expression using regular evaluation, as a reference.
-Result<Datum> ExecuteIfElseByExpr(const Expression& cond, const Expression& if_true,
-                                  const Expression& if_false,
-                                  const std::shared_ptr<Schema>& schema,
-                                  const ExecBatch& input) {
-  auto if_else = call("if_else", {cond, if_true, if_false});
-  ARROW_ASSIGN_OR_RAISE(auto bound, if_else.Bind(*schema));
-  return ExecuteScalarExpression(bound, input);
-}
-
-/// Execute an if-else expression in a special form fashion, in which Scatter is used as a
-/// building block.
-Result<Datum> ExecuteIfElseByScatter(const Expression& cond, const Expression& if_true,
-                                     const Expression& if_false,
-                                     const std::shared_ptr<Schema>& schema,
-                                     const ExecBatch& input) {
-  for (const auto& column : input.values) {
-    DCHECK(column.is_array());
-  }
-
-  ARROW_ASSIGN_OR_RAISE(auto input_rb, input.ToRecordBatch(schema));
-
-  // 1. Evaluate "cond", getting a boolean array as a mask to branches.
-  ARROW_ASSIGN_OR_RAISE(auto bound_cond, cond.Bind(*schema));
-  ARROW_ASSIGN_OR_RAISE(auto cond_datum, ExecuteScalarExpression(bound_cond, input));
-
-  // 2. Get indices of "true"s from the mask as the selection vector.
-  ARROW_ASSIGN_OR_RAISE(auto sel_if_true_datum,
-                        CallFunction("indices_nonzero", {cond_datum}));
-  DCHECK(sel_if_true_datum.is_array());
-  auto sel_if_true_array = sel_if_true_datum.make_array();
-
-  // 3. Take the "true" rows from input.
-  ARROW_ASSIGN_OR_RAISE(auto if_true_input_datum,
-                        CallFunction("take", {input_rb, sel_if_true_datum}));
-
-  // 4. Get indices of "false"es from the mask as the selection vector - by first
-  // inverting the mask and then getting the non-zero's indices.
-  ARROW_ASSIGN_OR_RAISE(auto invert_cond_datum, CallFunction("invert", {cond_datum}));
-  ARROW_ASSIGN_OR_RAISE(auto sel_if_false_datum,
-                        CallFunction("indices_nonzero", {invert_cond_datum}));
-  DCHECK(sel_if_false_datum.is_array());
-  auto sel_if_false_array = sel_if_false_datum.make_array();
-
-  // 5. Take the "false" rows from input.
-  ARROW_ASSIGN_OR_RAISE(auto if_false_input_datum,
-                        CallFunction("take", {input_rb, sel_if_false_datum}));
-
-  DCHECK_EQ(if_true_input_datum.kind(), Datum::RECORD_BATCH);
-  auto if_true_input_batch = ExecBatch(*if_true_input_datum.record_batch());
-
-  DCHECK_EQ(if_false_input_datum.kind(), Datum::RECORD_BATCH);
-  auto if_false_input_batch = ExecBatch(*if_false_input_datum.record_batch());
-
-  // 6. Evaluate "true" branch on the "true" rows.
-  ARROW_ASSIGN_OR_RAISE(auto bound_if_true, if_true.Bind(*schema));
-  ARROW_ASSIGN_OR_RAISE(auto if_true_result_datum,
-                        ExecuteScalarExpression(bound_if_true, if_true_input_batch));
-  DCHECK(if_true_result_datum.is_array());
-  auto if_true_result_array = if_true_result_datum.make_array();
-
-  // 7. Evaluate "false" branch on the "false" rows.
-  ARROW_ASSIGN_OR_RAISE(auto bound_if_false, if_false.Bind(*schema));
-  ARROW_ASSIGN_OR_RAISE(auto if_false_result_datum,
-                        ExecuteScalarExpression(bound_if_false, if_false_input_batch));
-  DCHECK(if_false_result_datum.is_array());
-  auto if_false_result_array = if_false_result_datum.make_array();
-
-  // 8. Combine the "true"/"false" results/selection vectors into chunked arrays.
-  auto result_ca = std::make_shared<ChunkedArray>(
-      ArrayVector{if_true_result_array, if_false_result_array});
-  auto sel_ca =
-      std::make_shared<ChunkedArray>(ArrayVector{sel_if_true_array, sel_if_false_array});
-
-  // 9. Finally, scatter the "true"/"false" results to their original positions in the
-  // input (according to the selection vectors). Note we didn't handle the rows with nulls
-  // in the mask, because Scatter will fill nulls for these rows and this is equal to the
-  // null handling policy of if-else, which is pretty nice.
-  return Scatter(/*values=*/result_ca, /*indices=*/sel_ca,
-                 /*max_index=*/input.length - 1);
-}
-
-void DoTestIfElse(const Expression& cond, const Expression& if_true,
-                  const Expression& if_false, const std::shared_ptr<Schema>& schema,
-                  const ExecBatch& input) {
-  ASSERT_OK_AND_ASSIGN(Datum result_by_expr,
-                       ExecuteIfElseByExpr(cond, if_true, if_false, schema, input));
-  ASSERT_TRUE(result_by_expr.is_array());
-  ASSERT_OK_AND_ASSIGN(Datum result_by_scatter,
-                       ExecuteIfElseByScatter(cond, if_true, if_false, schema, input));
-  // Scatter will output chunked array because we input values and indices as chunked
-  // arrays consisting of each branches. We don't care the shape of the output when
-  // comparing the results - only contents, so we concatenate the chunked array.
-  ASSERT_TRUE(result_by_scatter.is_chunked_array());
-  ASSERT_OK_AND_ASSIGN(auto result_by_scatter_concat,
-                       Concatenate(result_by_scatter.chunked_array()->chunks()));
-
-  AssertDatumsEqual(result_by_expr, result_by_scatter_concat);
-}
-
-void DoTestIfElse(const Expression& cond, const Expression& if_true,
-                  const Expression& if_false, const std::shared_ptr<Schema>& schema,
-                  const ExecBatch& input, const std::shared_ptr<Array>& expected) {
-  ASSERT_OK_AND_ASSIGN(Datum result,
-                       ExecuteIfElseByScatter(cond, if_true, if_false, schema, input));
-  ASSERT_TRUE(result.is_chunked_array());
-  ASSERT_OK_AND_ASSIGN(auto result_concat, Concatenate(result.chunked_array()->chunks()));
-
-  AssertDatumsEqual(expected, result_concat);
-}
-
-}  // namespace
-
-TEST(Scatter, IfElse) {
-  {
-    ARROW_SCOPED_TRACE("if (b != 0) then a / b else b");
-    auto cond = call("not_equal", {field_ref("b"), literal(0)});
-    auto if_true = call("divide", {field_ref("a"), field_ref("b")});
-    auto if_false = field_ref("b");
-    auto schema = arrow::schema({field("a", int32()), field("b", int32())});
-    auto rb = RecordBatchFromJSON(schema, R"([
-        [1, 1],
-        [2, 1],
-        [3, 0],
-        [4, 1],
-        [5, 1]
-      ])");
-    auto input = ExecBatch(*rb);
-
-    {
-      ARROW_SCOPED_TRACE("Regular evaluation");
-      ASSERT_RAISES_WITH_MESSAGE(
-          Invalid, "Invalid: divide by zero",
-          ExecuteIfElseByExpr(cond, if_true, if_false, schema, input));
-    }
-
-    {
-      ARROW_SCOPED_TRACE("Special form");
-      auto expected = ArrayFromJSON(int32(), "[1, 2, 0, 4, 5]");
-      DoTestIfElse(cond, if_true, if_false, schema, input, expected);
-    }
-  }
-  {
-    ARROW_SCOPED_TRACE("if (a > b) then a else b");
-    auto cond = call("greater", {field_ref("a"), field_ref("b")});
-    auto if_true = field_ref("a");
-    auto if_false = field_ref("b");
-    constexpr int64_t length = 5;
-    for (const auto& type : kNumericTypes) {
-      ARROW_SCOPED_TRACE("Type " + type->ToString());
-      auto schema = arrow::schema({field("a", type), field("b", type)});
-      auto big = ArrayFromJSON(type, "[1, 2, 3, 4, 5]");
-      auto small = ArrayFromJSON(type, "[0, 1, 2, 3, 4]");
-      {
-        ARROW_SCOPED_TRACE("All true");
-        auto input =
-            ExecBatch(*RecordBatch::Make(schema, length, {/*a=*/big, /*b=*/small}));
-        DoTestIfElse(cond, if_true, if_false, schema, input);
-      }
-      {
-        ARROW_SCOPED_TRACE("All false");
-        auto input =
-            ExecBatch(*RecordBatch::Make(schema, length, {/*a=*/small, /*b=*/big}));
-        DoTestIfElse(cond, if_true, if_false, schema, input);
-      }
-    }
-    {
-      ARROW_SCOPED_TRACE("Random");
-      auto rng = random::RandomArrayGenerator(42);
-      constexpr int64_t length = 1024;
-      constexpr int repeat = 10;
-      for (const auto& type : kNumericAndBaseBinaryTypes) {
-        ARROW_SCOPED_TRACE("Type " + type->ToString());
-        auto schema = arrow::schema({field("a", type), field("b", type)});
-        for (int i = 0; i < repeat; ++i) {
-          auto a = rng.ArrayOf(type, length, /*null_probability=*/0.2);
-          auto b = rng.ArrayOf(type, length, /*null_probability=*/0.2);
-          auto input =
-              ExecBatch(*RecordBatch::Make(schema, length, {std::move(a), std::move(b)}));
-          DoTestIfElse(cond, if_true, if_false, schema, input);
-        }
-      }
-    }
-  }
-}
-
 }  // namespace arrow::compute
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 098b9e0b3a1c8..bfbe7ef490aac 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1935,13 +1935,13 @@ Swizzle functions
 
 Swizzle functions reorder the input array based on the specified indices.
 
-+---------------------+--------+--------------+--------------+--------------+-------------------------------------+-------+
-| Function name       | Arity  | Input type 1 | Input type 2 | Output type  | Options class                       | Notes |
-+=====================+========+==============+==============+==============+=====================================+=======+
-| inverse_permutation | Unary  | Integer      |              | Integer \(1) | :struct:`InversePermutationOptions` | \(2)  |
-+---------------------+--------+--------------+--------------+--------------+-------------------------------------+-------+
-| scatter             | Binary | Any          | Integer      | Input type 1 | :struct:`ScatterOptions`            | \(3)  |
-+---------------------+--------+--------------+--------------+--------------+-------------------------------------+-------+
++---------------------+--------+----------------+--------------+---------------------+-------------------------------------+-------+
+| Function name       | Arity  | Input type 1   | Input type 2 | Output type         | Options class                       | Notes |
++=====================+========+================+==============+=====================+=====================================+=======+
+| inverse_permutation | Unary  | Signed Integer |              | Signed Integer \(1) | :struct:`InversePermutationOptions` | \(2)  |
++---------------------+--------+----------------+--------------+---------------------+-------------------------------------+-------+
+| scatter             | Binary | Any            | Integer      | Input type 1        | :struct:`ScatterOptions`            | \(3)  |
++---------------------+--------+----------------+--------------+---------------------+-------------------------------------+-------+
 
 * \(1) The output type is specified in :struct:`InversePermutationOptions`.
 

From b0c52e823d69833fccd433b2a979a3ef68457b0c Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Wed, 11 Dec 2024 18:39:13 +0800
Subject: [PATCH 43/54] Make visit method public and remove friend

---
 .../arrow/compute/kernels/vector_swizzle.cc   | 46 +++++++++----------
 1 file changed, 21 insertions(+), 25 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index fc1b5a6e88e89..f9b906b340746 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -88,28 +88,6 @@ struct InversePermutationImpl {
                            {std::move(impl.validity_buf), std::move(impl.data_buf)});
   }
 
- private:
-  KernelContext* ctx;
-  const ShapeType& indices;
-  const int64_t input_length;
-  const int64_t output_length;
-
-  std::shared_ptr<Buffer> validity_buf = nullptr;
-  std::shared_ptr<Buffer> data_buf = nullptr;
-
- private:
-  InversePermutationImpl(KernelContext* ctx, const ShapeType& indices,
-                         int64_t input_length, int64_t output_length)
-      : ctx(ctx),
-        indices(indices),
-        input_length(input_length),
-        output_length(output_length) {}
-
-  Status Visit(const DataType& output_type) {
-    DCHECK(false) << "Shouldn't reach here";
-    return Status::Invalid("Shouldn't reach here");
-  }
-
   template <typename Type>
   enable_if_t<is_integer_type<Type>::value, Status> Visit(const Type& output_type) {
     using OutputCType = typename Type::c_type;
@@ -136,6 +114,27 @@ struct InversePermutationImpl {
     }
   }
 
+  Status Visit(const DataType& output_type) {
+    DCHECK(false) << "Shouldn't reach here";
+    return Status::Invalid("Shouldn't reach here");
+  }
+
+ private:
+  KernelContext* ctx;
+  const ShapeType& indices;
+  const int64_t input_length;
+  const int64_t output_length;
+
+  std::shared_ptr<Buffer> validity_buf = nullptr;
+  std::shared_ptr<Buffer> data_buf = nullptr;
+
+  InversePermutationImpl(KernelContext* ctx, const ShapeType& indices,
+                         int64_t input_length, int64_t output_length)
+      : ctx(ctx),
+        indices(indices),
+        input_length(input_length),
+        output_length(output_length) {}
+
   template <typename Type>
   Status CheckInput(const Type& output_type) {
     using OutputCType = typename Type::c_type;
@@ -235,9 +234,6 @@ struct InversePermutationImpl {
 
     return Status::OK();
   }
-
-  template <typename VISITOR, typename... ARGS>
-  friend Status arrow::VisitTypeInline(const DataType&, VISITOR*, ARGS&&... args);
 };
 
 template <typename Ignored, typename Type>

From 9315ce5e46c9ba4ba4b5800c1f2a3e597e3e0828 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 15:02:05 +0800
Subject: [PATCH 44/54] Show no mercy to index out of bounds

---
 cpp/src/arrow/compute/api_vector.h            |  32 ++-
 .../arrow/compute/kernels/vector_swizzle.cc   |  37 ++-
 .../compute/kernels/vector_swizzle_test.cc    | 229 +++++++-----------
 docs/source/cpp/compute.rst                   |  12 +-
 4 files changed, 124 insertions(+), 186 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index a735ddc2de296..acedbe9aa458d 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -265,14 +265,13 @@ class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "InversePermutationOptions";
   static InversePermutationOptions Defaults() { return InversePermutationOptions(); }
 
-  /// \brief The max value in the input indices to allow. Any indices that are greater
-  /// than this value will be ignored. If negative, this value will be set to the length
-  /// of the input indices minus 1.
+  /// \brief The max value in the input indices to allow. If negative, this value will be
+  /// set to the length of the input indices minus 1.
   int64_t max_index = -1;
   /// \brief The type of the output inverse permutation. If null, the output will be of
-  /// the same type as the input indices, otherwise must be integer type. An invalid
-  /// error will be reported if this type is not able to store the length of the input
-  /// indices.
+  /// the same type as the input indices, otherwise must be signed integer type. An
+  /// invalid error will be reported if this type is not able to store the length of the
+  /// input indices.
   std::shared_ptr<DataType> output_type = NULLPTR;
 };
 
@@ -283,9 +282,8 @@ class ARROW_EXPORT ScatterOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "ScatterOptions";
   static ScatterOptions Defaults() { return ScatterOptions(); }
 
-  /// \brief The max value in the input indices to process. Any values with indices that
-  /// are greater than this value will be ignored. If negative, this value will be set to
-  /// the length of the input minus 1.
+  /// \brief The max value in the input indices to allow. If negative, this value will be
+  /// set to the length of the input minus 1.
   int64_t max_index = -1;
 };
 
@@ -740,12 +738,12 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
 /// \brief Return the inverse permutation of the given indices.
 ///
 /// For indices[i] = x, inverse_permutation[x] = i. And inverse_permutation[x] = null if x
-/// does not appear in the input indices. For indices[i] = x where x < 0 or x > max_index,
-/// it is ignored. If multiple indices point to the same value, the last one is used.
+/// does not appear in the input indices. Indices must be in the range of [0, max_index],
+/// or null, which will be ignored. If multiple indices point to the same value, the last
+/// one is used.
 ///
 /// For example, with indices = [null, 0, 3, 2, 4, 1, 1], the inverse permutation is
-///   [1, 6, 3]                    if max_index = 2,
-///   [1, 6, 3, 2, 4, null, null]  if max_index = 6.
+/// [1, 6, 3, 2, 4, null, null] if max_index = 6.
 ///
 /// \param[in] indices array-like indices
 /// \param[in] options configures the max index and the output type
@@ -763,13 +761,13 @@ Result<Datum> InversePermutation(
 /// \brief Scatter the values into specified positions according to the indices.
 ///
 /// For indices[i] = x, output[x] = values[i]. And output[x] = null if x does not appear
-/// in the input indices. For indices[i] = x where x < 0 or x > max_index, values[i]
-/// is ignored. If multiple indices point to the same value, the last one is used.
+/// in the input indices. Indices must be in the range of [0, max_index], or null, in
+/// which case the corresponding value will be ignored. If multiple indices point to the
+/// same value, the last one is used.
 ///
 /// For example, with values = [a, b, c, d, e, f, g] and indices = [null, 0,
 /// 3, 2, 4, 1, 1], the output is
-///   [b, g, d]                    if max_index = 2,
-///   [b, g, d, c, e, null, null]  if max_index = 6.
+/// [b, g, d, c, e, null, null] if max_index = 6.
 ///
 /// \param[in] values datum to scatter
 /// \param[in] indices array-like indices
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index f9b906b340746..de9fa42f9e3cc 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -139,13 +139,11 @@ struct InversePermutationImpl {
   Status CheckInput(const Type& output_type) {
     using OutputCType = typename Type::c_type;
 
-    if constexpr (!std::is_same_v<OutputCType, uint64_t>) {
-      if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length) {
-        return Status::Invalid(
-            "Output type " + output_type.ToString() +
-            " of inverse_permutation is insufficient to store indices of length " +
-            std::to_string(input_length));
-      }
+    if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length) {
+      return Status::Invalid(
+          "Output type " + output_type.ToString() +
+          " of inverse_permutation is insufficient to store indices of length " +
+          std::to_string(input_length));
     }
 
     return Status::OK();
@@ -201,13 +199,14 @@ struct InversePermutationImpl {
     RETURN_NOT_OK(ExecType::template VisitIndices(
         indices,
         [&](IndexCType index) {
-          if (ARROW_PREDICT_TRUE(index >= 0 &&
-                                 static_cast<int64_t>(index) < output_length)) {
-            data[index] = static_cast<OutputCType>(inverse);
-            // If many nulls, set validity to true for valid values.
-            if constexpr (likely_many_nulls) {
-              bit_util::SetBitTo(validity, index, true);
-            }
+          if (ARROW_PREDICT_FALSE(index < 0 ||
+                                  static_cast<int64_t>(index) >= output_length)) {
+            return Status::IndexError("Index out of bounds: ", std::to_string(index));
+          }
+          data[index] = static_cast<OutputCType>(inverse);
+          // If many nulls, set validity to true for valid values.
+          if constexpr (likely_many_nulls) {
+            bit_util::SetBitTo(validity, index, true);
           }
           ++inverse;
           return Status::OK();
@@ -357,8 +356,8 @@ class ScatterMetaFunction : public MetaFunction {
           "Input and indices of scatter must have the same length, got " +
           std::to_string(values.length()) + " and " + std::to_string(indices.length()));
     }
-    if (!is_integer(indices.type()->id())) {
-      return Status::Invalid("Indices of scatter must be of integer type, got ",
+    if (!is_signed_integer(indices.type()->id())) {
+      return Status::Invalid("Indices of scatter must be of signed integer type, got ",
                              indices.type()->ToString());
     }
     // Internally invoke Take(values, InversePermutation(indices)) to implement scatter.
@@ -366,11 +365,9 @@ class ScatterMetaFunction : public MetaFunction {
     //   values = [a, b, c, d, e, f, g]
     //   indices = [null, 0, 3, 2, 4, 1, 1]
     // the InversePermutation(indices) is
-    //   [1, 6, 3]                    if max_index = 2,
-    //   [1, 6, 3, 2, 4, null, null]  if max_index = 6.
+    // [1, 6, 3, 2, 4, null, null]  if max_index = 6.
     // and Take(values, InversePermutation(indices)) is
-    //   [b, g, d]                    if max_index = 2,
-    //   [b, g, d, c, e, null, null]  if max_index = 6.
+    // [b, g, d, c, e, null, null]  if max_index = 6.
     InversePermutationOptions inverse_permutation_options{
         scatter_options->max_index,
         // Use the smallest possible uint type to store inverse permutation.
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index cf5c0b1d90126..cf7fbbd0cd444 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -183,45 +183,19 @@ TEST(InversePermutation, DefaultOptions) {
   }
 }
 
-template <typename ArrowType>
-class TestInversePermutationSmallOutputType : public ::testing::Test {
- protected:
-  using CType = typename TypeTraits<ArrowType>::CType;
-
-  std::shared_ptr<DataType> type_singleton() {
-    return TypeTraits<ArrowType>::type_singleton();
+TEST(InversePermutation, InvalidIndex) {
+  {
+    ARROW_SCOPED_TRACE("Negative index");
+    auto indices = ArrayFromJSON(int32(), "[-1]");
+    ASSERT_RAISES_WITH_MESSAGE(IndexError, "Index error: Index out of bounds: -1",
+                               InversePermutation(indices));
   }
-};
-
-TYPED_TEST_SUITE(TestInversePermutationSmallOutputType, SmallOutputTypes);
-
-TYPED_TEST(TestInversePermutationSmallOutputType, JustEnoughOutputType) {
-  auto output_type = this->type_singleton();
-  int64_t input_length =
-      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max());
-  auto expected =
-      ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
-  DoTestInversePermutationForInputTypes(
-      kSignedIntegerTypes,
-      [&](const std::shared_ptr<DataType>& input_type) {
-        return ConstantArrayGenerator::Zeroes(input_length, input_type);
-      },
-      /*max_index=*/0, output_type, expected);
-}
-
-TYPED_TEST(TestInversePermutationSmallOutputType, InsufficientOutputType) {
-  auto output_type = this->type_singleton();
-  int64_t input_length =
-      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max()) + 1;
-  for (const auto& input_type : kSignedIntegerTypes) {
-    ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
-    auto indices = ConstantArrayGenerator::Zeroes(input_length, input_type);
+  {
+    ARROW_SCOPED_TRACE("Exceeds max_index");
+    auto indices = ArrayFromJSON(int32(), "[42]");
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid,
-        "Invalid: Output type " + output_type->ToString() +
-            " of inverse_permutation is insufficient to store indices of length " +
-            std::to_string(input_length),
-        InversePermutation(indices, /*max_index=*/0, output_type));
+        IndexError, "Index error: Index out of bounds: 42",
+        InversePermutation(indices, /*max_index=*/1, /*output_type=*/int32()));
   }
 }
 
@@ -245,15 +219,6 @@ TEST(InversePermutation, Basic) {
     auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
     TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
-  {
-    ARROW_SCOPED_TRACE("Basic with negatives");
-    auto indices = "[9, 7, 5, 3, 1, -1, -2, -3, -4, -5]";
-    std::vector<std::string> indices_chunked{
-        "[]", "[9, 7, 5, 3, 1]", "[-1]", "[-2, -3, -4]", "[-5]", "[]"};
-    int64_t max_index = 9;
-    auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
-    TestInversePermutation(indices, indices_chunked, max_index, expected);
-  }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
     auto indices = "[1, 2]";
@@ -270,14 +235,6 @@ TEST(InversePermutation, Basic) {
     auto expected = "[null, null]";
     TestInversePermutation(indices, indices_chunked, max_index, expected);
   }
-  {
-    ARROW_SCOPED_TRACE("Output all null");
-    auto indices = "[2, 3]";
-    std::vector<std::string> indices_chunked{"[]", "[2]", "[]", "[3]"};
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    TestInversePermutation(indices, indices_chunked, max_index, expected);
-  }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
     auto indices = "[]";
@@ -297,6 +254,48 @@ TEST(InversePermutation, Basic) {
   }
 }
 
+template <typename ArrowType>
+class TestInversePermutationSmallOutputType : public ::testing::Test {
+ protected:
+  using CType = typename TypeTraits<ArrowType>::CType;
+
+  std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
+  }
+};
+
+TYPED_TEST_SUITE(TestInversePermutationSmallOutputType, SmallOutputTypes);
+
+TYPED_TEST(TestInversePermutationSmallOutputType, JustEnoughOutputType) {
+  auto output_type = this->type_singleton();
+  int64_t input_length =
+      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max());
+  auto expected =
+      ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
+  DoTestInversePermutationForInputTypes(
+      kSignedIntegerTypes,
+      [&](const std::shared_ptr<DataType>& input_type) {
+        return ConstantArrayGenerator::Zeroes(input_length, input_type);
+      },
+      /*max_index=*/0, output_type, expected);
+}
+
+TYPED_TEST(TestInversePermutationSmallOutputType, InsufficientOutputType) {
+  auto output_type = this->type_singleton();
+  int64_t input_length =
+      static_cast<int64_t>(std::numeric_limits<typename TestFixture::CType>::max()) + 1;
+  for (const auto& input_type : kSignedIntegerTypes) {
+    ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
+    auto indices = ConstantArrayGenerator::Zeroes(input_length, input_type);
+    ASSERT_RAISES_WITH_MESSAGE(
+        Invalid,
+        "Invalid: Output type " + output_type->ToString() +
+            " of inverse_permutation is insufficient to store indices of length " +
+            std::to_string(input_length),
+        InversePermutation(indices, /*max_index=*/0, output_type));
+  }
+}
+
 // ----------------------------------------------------------------------
 // Scatter tests
 //
@@ -470,12 +469,6 @@ void DoTestScatterForIndicesTypes(
   }
 }
 
-void DoTestScatterSignedIndices(const std::shared_ptr<Array>& values,
-                                const std::shared_ptr<Array>& indices, int64_t max_index,
-                                const std::shared_ptr<Array>& expected) {
-  DoTestScatterForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);
-}
-
 void DoTestScatter(const std::shared_ptr<Array>& values,
                    const std::shared_ptr<Array>& indices, int64_t max_index,
                    const std::shared_ptr<Array>& expected) {
@@ -497,10 +490,22 @@ TEST(Scatter, Invalid) {
   {
     ARROW_SCOPED_TRACE("Invalid input type");
     auto values = ArrayFromJSON(int32(), "[0]");
-    auto indices = ArrayFromJSON(utf8(), R"(["a"])");
-    ASSERT_RAISES_WITH_MESSAGE(
-        Invalid, "Invalid: Indices of scatter must be of integer type, got string",
-        Scatter(values, indices));
+    {
+      ARROW_SCOPED_TRACE("uint32");
+      auto indices = ArrayFromJSON(uint32(), R"([0])");
+      ASSERT_RAISES_WITH_MESSAGE(
+          Invalid,
+          "Invalid: Indices of scatter must be of signed integer type, got uint32",
+          Scatter(values, indices));
+    }
+    {
+      ARROW_SCOPED_TRACE("string");
+      auto indices = ArrayFromJSON(utf8(), R"(["a"])");
+      ASSERT_RAISES_WITH_MESSAGE(
+          Invalid,
+          "Invalid: Indices of scatter must be of signed integer type, got string",
+          Scatter(values, indices));
+    }
   }
 }
 
@@ -522,6 +527,23 @@ TEST(Scatter, DefaultOptions) {
   }
 }
 
+TEST(Scatter, InvalidIndex) {
+  {
+    ARROW_SCOPED_TRACE("Negative index");
+    auto values = ArrayFromJSON(utf8(), R"(["a"])");
+    auto indices = ArrayFromJSON(int32(), "[-1]");
+    ASSERT_RAISES_WITH_MESSAGE(IndexError, "Index error: Index out of bounds: -1",
+                               Scatter(values, indices));
+  }
+  {
+    ARROW_SCOPED_TRACE("Exceeds max_index");
+    auto values = ArrayFromJSON(utf8(), R"(["a"])");
+    auto indices = ArrayFromJSON(int32(), "[42]");
+    ASSERT_RAISES_WITH_MESSAGE(IndexError, "Index error: Index out of bounds: 42",
+                               Scatter(values, indices, /*max_index=*/1));
+  }
+}
+
 template <typename ArrowType>
 class TestScatterSmallIndicesTypes : public ::testing::Test {
  protected:
@@ -560,13 +582,6 @@ class TestScatterTyped : public ::testing::Test {
     }
   }
 
-  void TestScatterSignedIndices(const std::string& values_str,
-                                const std::string& indices_str, int64_t max_index,
-                                const std::string& expected_str) {
-    TestScatter(DoTestScatterSignedIndices, values_str, indices_str, max_index,
-                expected_str);
-  }
-
   void TestScatter(const std::string& values_str, const std::string& indices_str,
                    int64_t max_index, const std::string& expected_str) {
     TestScatter(DoTestScatter, values_str, indices_str, max_index, expected_str);
@@ -611,22 +626,6 @@ TEST_F(TestScatterBoolean, Basic) {
     auto expected = "[null, true, null, true, null, false, null, true, null, true]";
     TestScatter(values, indices, max_index, expected);
   }
-  {
-    ARROW_SCOPED_TRACE("Indices with negatives");
-    auto values = "[true, false, true, true, false, false, true, true, true, false]";
-    auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
-    int64_t max_index = 9;
-    auto expected = "[null, true, null, true, null, false, null, true, null, true]";
-    TestScatterSignedIndices(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Output less than input");
-    auto values = "[false, true]";
-    auto indices = "[1, 0]";
-    int64_t max_index = 0;
-    auto expected = "[true]";
-    TestScatter(values, indices, max_index, expected);
-  }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
     auto values = "[true, true, true, false, false, false]";
@@ -651,14 +650,6 @@ TEST_F(TestScatterBoolean, Basic) {
     auto expected = "[null, null]";
     TestScatter(values, indices, max_index, expected);
   }
-  {
-    ARROW_SCOPED_TRACE("Output all null");
-    auto values = "[true, false]";
-    auto indices = "[2, 3]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    TestScatter(values, indices, max_index, expected);
-  }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
     auto values = "[]";
@@ -707,22 +698,6 @@ TYPED_TEST(TestScatterNumeric, Basic) {
     auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
     this->TestScatter(values, indices, max_index, expected);
   }
-  {
-    ARROW_SCOPED_TRACE("Indices with negatives");
-    auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
-    auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
-    int64_t max_index = 9;
-    auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
-    this->TestScatterSignedIndices(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Output less than input");
-    auto values = "[1, 0]";
-    auto indices = "[1, 0]";
-    int64_t max_index = 0;
-    auto expected = "[0]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
     auto values = "[0, 0, 0, 1, 1, 1]";
@@ -747,14 +722,6 @@ TYPED_TEST(TestScatterNumeric, Basic) {
     auto expected = "[null, null]";
     this->TestScatter(values, indices, max_index, expected);
   }
-  {
-    ARROW_SCOPED_TRACE("Output all null");
-    auto values = "[0, 1]";
-    auto indices = "[2, 3]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
     auto values = "[]";
@@ -803,22 +770,6 @@ TYPED_TEST(TestScatterString, Basic) {
     auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
     this->TestScatter(values, indices, max_index, expected);
   }
-  {
-    ARROW_SCOPED_TRACE("Indices with negatives");
-    auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
-    auto indices = "[9, -1, 7, -2, 5, -3, 3, -4, 1, -5]";
-    int64_t max_index = 9;
-    auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
-    this->TestScatterSignedIndices(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Output less than input");
-    auto values = R"(["b", "a"])";
-    auto indices = "[1, 0]";
-    int64_t max_index = 0;
-    auto expected = R"(["a"])";
-    this->TestScatter(values, indices, max_index, expected);
-  }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
     auto values = R"(["a", "a", "a", "b", "b", "b"])";
@@ -843,14 +794,6 @@ TYPED_TEST(TestScatterString, Basic) {
     auto expected = "[null, null]";
     this->TestScatter(values, indices, max_index, expected);
   }
-  {
-    ARROW_SCOPED_TRACE("Output all null");
-    auto values = R"(["a", "b"])";
-    auto indices = "[2, 3]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
     auto values = "[]";
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index bfbe7ef490aac..04d1123cf235f 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1946,11 +1946,11 @@ Swizzle functions reorder the input array based on the specified indices.
 * \(1) The output type is specified in :struct:`InversePermutationOptions`.
 
 * \(2) For ``indices[i] = x``, ``inverse_permutation[x] = i``. And ``inverse_permutation[x]
-  = null`` if ``x`` does not appear in the input ``indices``. For ``indices[i] = x``
-  where ``x < 0`` or ``x > max_index``, it is ignored. If multiple indices point
-  to the same value, the last one is used.
+  = null`` if ``x`` does not appear in the input ``indices``. Indices must be in the range
+  of ``[0, max_index]``, or null, which will be ignored. If multiple indices point to the
+  same value, the last one is used.
 
 * \(3) For ``indices[i] = x``, ``output[x] = values[i]``. And ``output[x] = null``
-  if ``x`` does not appear in the input ``indices``. For ``indices[i] = x`` where
-  ``x < 0`` or ``x > max_index``, ``values[i]`` is ignored. If multiple indices
-  point to the same value, the last one is used.
+  if ``x`` does not appear in the input ``indices``. Indices must be in the range
+  of ``[0, max_index]``, or null, in which case the corresponding value will be
+  ignored. If multiple indices point to the same value, the last one is used.

From 17b6b2b8aad3c0d3639deb738733544e108ad6da Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 15:05:49 +0800
Subject: [PATCH 45/54] Use type error instead of invalid

---
 .../arrow/compute/kernels/vector_swizzle.cc   |  6 ++---
 .../compute/kernels/vector_swizzle_test.cc    | 23 +++++++++++--------
 2 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index de9fa42f9e3cc..a80c3ed0f57d8 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -54,7 +54,7 @@ Result<TypeHolder> ResolveInversePermutationOutputType(
     output_type = input_types[0].owned_type;
   }
   if (!is_signed_integer(output_type->id())) {
-    return Status::Invalid(
+    return Status::TypeError(
         "Output type of inverse_permutation must be signed integer, got " +
         output_type->ToString());
   }
@@ -357,8 +357,8 @@ class ScatterMetaFunction : public MetaFunction {
           std::to_string(values.length()) + " and " + std::to_string(indices.length()));
     }
     if (!is_signed_integer(indices.type()->id())) {
-      return Status::Invalid("Indices of scatter must be of signed integer type, got ",
-                             indices.type()->ToString());
+      return Status::TypeError("Indices of scatter must be of signed integer type, got ",
+                               indices.type()->ToString());
     }
     // Internally invoke Take(values, InversePermutation(indices)) to implement scatter.
     // For example, with
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index cf7fbbd0cd444..8c5b7853f31b9 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -143,24 +143,27 @@ TEST(InversePermutation, InvalidOutputType) {
     ARROW_SCOPED_TRACE("Output type unsigned");
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid,
-        "Invalid: Output type of inverse_permutation must be signed integer, got uint32",
+        TypeError,
+        "Type error: Output type of inverse_permutation must be signed integer, got "
+        "uint32",
         InversePermutation(indices, /*max_index=*/0, /*output_type=*/uint32()));
   }
   {
     ARROW_SCOPED_TRACE("Output type float");
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid,
-        "Invalid: Output type of inverse_permutation must be signed integer, got float",
+        TypeError,
+        "Type error: Output type of inverse_permutation must be signed integer, got "
+        "float",
         InversePermutation(indices, /*max_index=*/0, /*output_type=*/float32()));
   }
   {
     ARROW_SCOPED_TRACE("Output type string");
     auto indices = ArrayFromJSON(int32(), "[]");
     ASSERT_RAISES_WITH_MESSAGE(
-        Invalid,
-        "Invalid: Output type of inverse_permutation must be signed integer, got string",
+        TypeError,
+        "Type error: Output type of inverse_permutation must be signed integer, got "
+        "string",
         InversePermutation(indices, /*max_index=*/0, /*output_type=*/utf8()));
   }
 }
@@ -494,16 +497,16 @@ TEST(Scatter, Invalid) {
       ARROW_SCOPED_TRACE("uint32");
       auto indices = ArrayFromJSON(uint32(), R"([0])");
       ASSERT_RAISES_WITH_MESSAGE(
-          Invalid,
-          "Invalid: Indices of scatter must be of signed integer type, got uint32",
+          TypeError,
+          "Type error: Indices of scatter must be of signed integer type, got uint32",
           Scatter(values, indices));
     }
     {
       ARROW_SCOPED_TRACE("string");
       auto indices = ArrayFromJSON(utf8(), R"(["a"])");
       ASSERT_RAISES_WITH_MESSAGE(
-          Invalid,
-          "Invalid: Indices of scatter must be of signed integer type, got string",
+          TypeError,
+          "Type error: Indices of scatter must be of signed integer type, got string",
           Scatter(values, indices));
     }
   }

From 57d2c3d13b7d02dd5b9a96c909a358862dc2108b Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 15:08:39 +0800
Subject: [PATCH 46/54] Remove errornous predict false

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

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index a80c3ed0f57d8..23cca2831c4d5 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -221,7 +221,7 @@ struct InversePermutationImpl {
     // and initialized all-true when the first "impossible" value is seen.
     if constexpr (!likely_many_nulls) {
       for (int64_t i = 0; i < output_length; ++i) {
-        if (ARROW_PREDICT_FALSE(data[i] == static_cast<OutputCType>(input_length))) {
+        if (data[i] == static_cast<OutputCType>(input_length)) {
           if (ARROW_PREDICT_FALSE(!validity_buf)) {
             RETURN_NOT_OK(AllocateValidityBufAndFill(true));
             validity = validity_buf->mutable_data_as<uint8_t>();

From 55d46112eb4efea9796b19e863545b0d7c80e392 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 15:44:59 +0800
Subject: [PATCH 47/54] Avoid uninitialized data buf

---
 .../arrow/compute/kernels/vector_swizzle.cc   | 23 ++++++++-----------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index 23cca2831c4d5..f63e81fa448d9 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -96,16 +96,17 @@ struct InversePermutationImpl {
 
     // Dispatch the execution based on whether there are likely many nulls in the output.
     // - If many nulls (i.e. the output is "sparse"), preallocate an all-false validity
-    // buffer and an uninitialized data buffer. The subsequent processing will fill the
-    // valid values only.
+    // buffer and a zero-initialized data buffer (just to avoid exposing previous memory
+    // contents - even if it is shadowed by the validity bit). The subsequent processing
+    // will fill the valid values only.
     // - Otherwise (i.e. the output is "dense"), the validity buffer is lazily allocated
     // and initialized all-true in the subsequent processing only when needed. The data
-    // buffer is preallocated and filled with all "impossible" values (that is,
-    // input_length - note that the range of inverse_permutation is [0, input_length)) for
-    // the subsequent processing to detect validity.
+    // buffer is preallocated and filled with "impossible" values (that is, input_length -
+    // note that the range of inverse_permutation is [0, input_length)) for the subsequent
+    // processing to detect validity.
     if (LikelyManyNulls()) {
       RETURN_NOT_OK(AllocateValidityBufAndFill(false));
-      RETURN_NOT_OK(AllocateDataBuf(output_type));
+      RETURN_NOT_OK(AllocateDataBufAndFill(output_type, static_cast<OutputCType>(0)));
       return Execute<Type, true>();
     } else {
       RETURN_NOT_OK(
@@ -161,19 +162,13 @@ struct InversePermutationImpl {
     return Status::OK();
   }
 
-  Status AllocateDataBuf(const DataType& output_type) {
+  template <typename Type, typename OutputCType = typename Type::c_type>
+  Status AllocateDataBufAndFill(const Type& output_type, OutputCType value) {
     DCHECK_EQ(data_buf, nullptr);
 
     ARROW_ASSIGN_OR_RAISE(data_buf,
                           ctx->Allocate(output_length * output_type.byte_width()));
 
-    return Status::OK();
-  }
-
-  template <typename Type, typename OutputCType = typename Type::c_type>
-  Status AllocateDataBufAndFill(const Type& output_type, OutputCType value) {
-    RETURN_NOT_OK(AllocateDataBuf(output_type));
-
     OutputCType* data = data_buf->mutable_data_as<OutputCType>();
     for (int64_t i = 0; i < output_length; ++i) {
       data[i] = value;

From e8fed69e92d0a7e016911eb2a1b1ad88e5da12ff Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 15:52:10 +0800
Subject: [PATCH 48/54] Coding convention of instantce variables

---
 .../arrow/compute/kernels/vector_swizzle.cc   | 70 +++++++++----------
 1 file changed, 35 insertions(+), 35 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index f63e81fa448d9..0ce220d2c4be3 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -85,7 +85,7 @@ struct InversePermutationImpl {
     RETURN_NOT_OK(VisitTypeInline(*output_type, &impl));
 
     return ArrayData::Make(std::move(output_type), output_length,
-                           {std::move(impl.validity_buf), std::move(impl.data_buf)});
+                           {std::move(impl.validity_buf_), std::move(impl.data_buf_)});
   }
 
   template <typename Type>
@@ -110,7 +110,7 @@ struct InversePermutationImpl {
       return Execute<Type, true>();
     } else {
       RETURN_NOT_OK(
-          AllocateDataBufAndFill(output_type, static_cast<OutputCType>(input_length)));
+          AllocateDataBufAndFill(output_type, static_cast<OutputCType>(input_length_)));
       return Execute<Type, false>();
     }
   }
@@ -121,56 +121,56 @@ struct InversePermutationImpl {
   }
 
  private:
-  KernelContext* ctx;
-  const ShapeType& indices;
-  const int64_t input_length;
-  const int64_t output_length;
+  KernelContext* ctx_;
+  const ShapeType& indices_;
+  const int64_t input_length_;
+  const int64_t output_length_;
 
-  std::shared_ptr<Buffer> validity_buf = nullptr;
-  std::shared_ptr<Buffer> data_buf = nullptr;
+  std::shared_ptr<Buffer> validity_buf_;
+  std::shared_ptr<Buffer> data_buf_;
 
   InversePermutationImpl(KernelContext* ctx, const ShapeType& indices,
                          int64_t input_length, int64_t output_length)
-      : ctx(ctx),
-        indices(indices),
-        input_length(input_length),
-        output_length(output_length) {}
+      : ctx_(ctx),
+        indices_(indices),
+        input_length_(input_length),
+        output_length_(output_length) {}
 
   template <typename Type>
   Status CheckInput(const Type& output_type) {
     using OutputCType = typename Type::c_type;
 
-    if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length) {
+    if (static_cast<int64_t>(std::numeric_limits<OutputCType>::max()) < input_length_) {
       return Status::Invalid(
           "Output type " + output_type.ToString() +
           " of inverse_permutation is insufficient to store indices of length " +
-          std::to_string(input_length));
+          std::to_string(input_length_));
     }
 
     return Status::OK();
   }
 
-  bool LikelyManyNulls() { return output_length > 2 * input_length; }
+  bool LikelyManyNulls() { return output_length_ > 2 * input_length_; }
 
   Status AllocateValidityBufAndFill(bool valid) {
-    DCHECK_EQ(validity_buf, nullptr);
+    DCHECK_EQ(validity_buf_, nullptr);
 
-    ARROW_ASSIGN_OR_RAISE(validity_buf, ctx->AllocateBitmap(output_length));
-    auto validity = validity_buf->mutable_data_as<uint8_t>();
-    std::memset(validity, valid ? 0xff : 0, validity_buf->size());
+    ARROW_ASSIGN_OR_RAISE(validity_buf_, ctx_->AllocateBitmap(output_length_));
+    auto validity = validity_buf_->mutable_data_as<uint8_t>();
+    std::memset(validity, valid ? 0xff : 0, validity_buf_->size());
 
     return Status::OK();
   }
 
   template <typename Type, typename OutputCType = typename Type::c_type>
   Status AllocateDataBufAndFill(const Type& output_type, OutputCType value) {
-    DCHECK_EQ(data_buf, nullptr);
+    DCHECK_EQ(data_buf_, nullptr);
 
-    ARROW_ASSIGN_OR_RAISE(data_buf,
-                          ctx->Allocate(output_length * output_type.byte_width()));
+    ARROW_ASSIGN_OR_RAISE(data_buf_,
+                          ctx_->Allocate(output_length_ * output_type.byte_width()));
 
-    OutputCType* data = data_buf->mutable_data_as<OutputCType>();
-    for (int64_t i = 0; i < output_length; ++i) {
+    OutputCType* data = data_buf_->mutable_data_as<OutputCType>();
+    for (int64_t i = 0; i < output_length_; ++i) {
       data[i] = value;
     }
 
@@ -183,19 +183,19 @@ struct InversePermutationImpl {
 
     uint8_t* validity = nullptr;
     if constexpr (likely_many_nulls) {
-      DCHECK_NE(validity_buf, nullptr);
-      validity = validity_buf->mutable_data_as<uint8_t>();
+      DCHECK_NE(validity_buf_, nullptr);
+      validity = validity_buf_->mutable_data_as<uint8_t>();
     } else {
-      DCHECK_EQ(validity_buf, nullptr);
+      DCHECK_EQ(validity_buf_, nullptr);
     }
-    DCHECK_NE(data_buf, nullptr);
-    OutputCType* data = data_buf->mutable_data_as<OutputCType>();
+    DCHECK_NE(data_buf_, nullptr);
+    OutputCType* data = data_buf_->mutable_data_as<OutputCType>();
     int64_t inverse = 0;
     RETURN_NOT_OK(ExecType::template VisitIndices(
-        indices,
+        indices_,
         [&](IndexCType index) {
           if (ARROW_PREDICT_FALSE(index < 0 ||
-                                  static_cast<int64_t>(index) >= output_length)) {
+                                  static_cast<int64_t>(index) >= output_length_)) {
             return Status::IndexError("Index out of bounds: ", std::to_string(index));
           }
           data[index] = static_cast<OutputCType>(inverse);
@@ -215,11 +215,11 @@ struct InversePermutationImpl {
     // to false if the value is "impossible". The validity buffer is on demand allocated
     // and initialized all-true when the first "impossible" value is seen.
     if constexpr (!likely_many_nulls) {
-      for (int64_t i = 0; i < output_length; ++i) {
-        if (data[i] == static_cast<OutputCType>(input_length)) {
-          if (ARROW_PREDICT_FALSE(!validity_buf)) {
+      for (int64_t i = 0; i < output_length_; ++i) {
+        if (data[i] == static_cast<OutputCType>(input_length_)) {
+          if (ARROW_PREDICT_FALSE(!validity_buf_)) {
             RETURN_NOT_OK(AllocateValidityBufAndFill(true));
-            validity = validity_buf->mutable_data_as<uint8_t>();
+            validity = validity_buf_->mutable_data_as<uint8_t>();
           }
           bit_util::SetBitTo(validity, i, false);
         }

From 3fbd35fa989b7a6fce9b61bc29d4390833426184 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 16:09:57 +0800
Subject: [PATCH 49/54] Optimize buffer initializing

---
 .../arrow/compute/kernels/vector_swizzle.cc   | 24 +++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index 0ce220d2c4be3..c6f34f8bfcf18 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -106,7 +106,7 @@ struct InversePermutationImpl {
     // processing to detect validity.
     if (LikelyManyNulls()) {
       RETURN_NOT_OK(AllocateValidityBufAndFill(false));
-      RETURN_NOT_OK(AllocateDataBufAndFill(output_type, static_cast<OutputCType>(0)));
+      RETURN_NOT_OK(AllocateDataBufAndZero(output_type));
       return Execute<Type, true>();
     } else {
       RETURN_NOT_OK(
@@ -155,20 +155,36 @@ struct InversePermutationImpl {
   Status AllocateValidityBufAndFill(bool valid) {
     DCHECK_EQ(validity_buf_, nullptr);
 
-    ARROW_ASSIGN_OR_RAISE(validity_buf_, ctx_->AllocateBitmap(output_length_));
+    ARROW_ASSIGN_OR_RAISE(validity_buf_,
+                          AllocateEmptyBitmap(output_length_, ctx_->memory_pool()));
     auto validity = validity_buf_->mutable_data_as<uint8_t>();
     std::memset(validity, valid ? 0xff : 0, validity_buf_->size());
 
     return Status::OK();
   }
 
-  template <typename Type, typename OutputCType = typename Type::c_type>
-  Status AllocateDataBufAndFill(const Type& output_type, OutputCType value) {
+  Status AllocateDataBuf(const DataType& output_type) {
     DCHECK_EQ(data_buf_, nullptr);
 
     ARROW_ASSIGN_OR_RAISE(data_buf_,
                           ctx_->Allocate(output_length_ * output_type.byte_width()));
 
+    return Status::OK();
+  }
+
+  Status AllocateDataBufAndZero(const DataType& output_type) {
+    RETURN_NOT_OK(AllocateDataBuf(output_type));
+
+    uint8_t* data = data_buf_->mutable_data();
+    std::memset(data, 0, output_length_ * output_type.byte_width());
+
+    return Status::OK();
+  }
+
+  template <typename Type, typename OutputCType = typename Type::c_type>
+  Status AllocateDataBufAndFill(const Type& output_type, OutputCType value) {
+    RETURN_NOT_OK(AllocateDataBuf(output_type));
+
     OutputCType* data = data_buf_->mutable_data_as<OutputCType>();
     for (int64_t i = 0; i < output_length_; ++i) {
       data[i] = value;

From 3859abf541fd930204291b5aa74a18ff723989d9 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 16:36:49 +0800
Subject: [PATCH 50/54] Reduce typed tests

---
 .../compute/kernels/vector_swizzle_test.cc    | 339 ++++++++----------
 1 file changed, 154 insertions(+), 185 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index 8c5b7853f31b9..859df44053e9c 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -33,13 +33,8 @@ namespace {
 static const std::vector<std::shared_ptr<DataType>> kSignedIntegerTypes = {
     int8(), int16(), int32(), int64()};
 
-static const std::vector<std::shared_ptr<DataType>> kNumericTypes = {
-    uint8(), int8(),   uint16(), int16(),   uint32(),
-    int32(), uint64(), int64(),  float32(), float64()};
-
-static const std::vector<std::shared_ptr<DataType>> kNumericAndBaseBinaryTypes = {
-    uint8(), int8(),    uint16(),  int16(),  uint32(), int32(),        uint64(),
-    int64(), float32(), float64(), binary(), utf8(),   large_binary(), large_utf8()};
+static const std::vector<std::shared_ptr<DataType>> kBinaryTypes = {
+    binary(), utf8(), large_binary(), large_utf8()};
 
 using SmallOutputTypes = ::testing::Types<Int8Type, Int16Type>;
 
@@ -478,6 +473,15 @@ void DoTestScatter(const std::shared_ptr<Array>& values,
   DoTestScatterForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);
 }
 
+void TestScatter(const std::shared_ptr<DataType>& type, const std::string& values_str,
+                 const std::string& indices_str, int64_t max_index,
+                 const std::string& expected_str) {
+  auto values = ArrayFromJSON(type, values_str);
+  auto indices = ArrayFromJSON(int8(), indices_str);
+  auto expected = ArrayFromJSON(type, expected_str);
+  DoTestScatter(values, indices, max_index, expected);
+}
+
 }  // namespace
 
 TEST(Scatter, Invalid) {
@@ -573,45 +577,14 @@ TYPED_TEST(TestScatterSmallIndicesTypes, MaxIntegerIndex) {
   DoTestScatterAAA(values, indices, /*max_index=*/max_integer - 1, expected);
 }
 
-template <typename ArrowType>
-class TestScatterTyped : public ::testing::Test {
- protected:
-  virtual std::shared_ptr<DataType> values_type() const {
-    if constexpr (is_parameter_free_type<ArrowType>::value) {
-      return TypeTraits<ArrowType>::type_singleton();
-    } else {
-      EXPECT_TRUE(false) << "values_type() must be overridden for parameterized types";
-      return nullptr;
-    }
-  }
-
-  void TestScatter(const std::string& values_str, const std::string& indices_str,
-                   int64_t max_index, const std::string& expected_str) {
-    TestScatter(DoTestScatter, values_str, indices_str, max_index, expected_str);
-  }
-
- private:
-  template <typename DoTestFunc>
-  void TestScatter(DoTestFunc&& func, const std::string& values_str,
-                   const std::string& indices_str, int64_t max_index,
-                   const std::string& expected_str) {
-    auto values = ArrayFromJSON(values_type(), values_str);
-    auto indices = ArrayFromJSON(int8(), indices_str);
-    auto expected = ArrayFromJSON(values_type(), expected_str);
-    func(values, indices, max_index, expected);
-  }
-};
-
-class TestScatterBoolean : public TestScatterTyped<BooleanType> {};
-
-TEST_F(TestScatterBoolean, Basic) {
+TEST(Scatter, Boolean) {
   {
     ARROW_SCOPED_TRACE("Basic");
     auto values = "[true, false, true, true, false, false, true, true, true, false]";
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t max_index = 9;
     auto expected = "[false, true, true, true, false, false, true, true, false, true]";
-    TestScatter(values, indices, max_index, expected);
+    TestScatter(boolean(), values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values with nulls");
@@ -619,7 +592,7 @@ TEST_F(TestScatterBoolean, Basic) {
     auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
     int64_t max_index = 9;
     auto expected = "[true, null, null, false, false, true, true, null, false, true]";
-    TestScatter(values, indices, max_index, expected);
+    TestScatter(boolean(), values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices with nulls");
@@ -627,7 +600,7 @@ TEST_F(TestScatterBoolean, Basic) {
     auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
     int64_t max_index = 9;
     auto expected = "[null, true, null, true, null, false, null, true, null, true]";
-    TestScatter(values, indices, max_index, expected);
+    TestScatter(boolean(), values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
@@ -635,7 +608,7 @@ TEST_F(TestScatterBoolean, Basic) {
     auto indices = "[0, 3, 6, 1, 4, 7]";
     int64_t max_index = 8;
     auto expected = "[true, false, null, true, false, null, true, false, null]";
-    TestScatter(values, indices, max_index, expected);
+    TestScatter(boolean(), values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Values all null");
@@ -643,7 +616,7 @@ TEST_F(TestScatterBoolean, Basic) {
     auto indices = "[0, 1]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestScatter(values, indices, max_index, expected);
+    TestScatter(boolean(), values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices all null");
@@ -651,7 +624,7 @@ TEST_F(TestScatterBoolean, Basic) {
     auto indices = "[null, null]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestScatter(values, indices, max_index, expected);
+    TestScatter(boolean(), values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
@@ -659,7 +632,7 @@ TEST_F(TestScatterBoolean, Basic) {
     auto indices = "[]";
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestScatter(values, indices, max_index, expected);
+    TestScatter(boolean(), values, indices, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Indices duplicated indices");
@@ -667,151 +640,147 @@ TEST_F(TestScatterBoolean, Basic) {
     auto indices = "[0, 1, 0, 1]";
     int64_t max_index = 3;
     auto expected = "[null, null, null, null]";
-    TestScatter(values, indices, max_index, expected);
+    TestScatter(boolean(), values, indices, max_index, expected);
   }
 }
 
-template <typename ArrowType>
-class TestScatterNumeric : public TestScatterTyped<ArrowType> {};
-
-TYPED_TEST_SUITE(TestScatterNumeric, NumericArrowTypes);
-
-TYPED_TEST(TestScatterNumeric, Basic) {
-  {
-    ARROW_SCOPED_TRACE("Basic");
-    auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
-    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t max_index = 9;
-    auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Values with nulls");
-    auto values = "[null, 11, null, 13, null, 15, null, 17, null, 19]";
-    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t max_index = 9;
-    auto expected = "[19, null, 17, null, 15, null, 13, null, 11, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Indices with nulls");
-    auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
-    auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
-    int64_t max_index = 9;
-    auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Output greater than input");
-    auto values = "[0, 0, 0, 1, 1, 1]";
-    auto indices = "[0, 3, 6, 1, 4, 7]";
-    int64_t max_index = 8;
-    auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Values all null");
-    auto values = "[null, null]";
-    auto indices = "[0, 1]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Indices all null");
-    auto values = "[0, 1]";
-    auto indices = "[null, null]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Empty input output null");
-    auto values = "[]";
-    auto indices = "[]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Indices duplicated indices");
-    auto values = "[1, 0, null, null]";
-    auto indices = "[0, 1, 0, 1]";
-    int64_t max_index = 3;
-    auto expected = "[null, null, null, null]";
-    this->TestScatter(values, indices, max_index, expected);
+TEST(Scatter, Numeric) {
+  for (const auto& type : kSignedIntegerTypes) {
+    ARROW_SCOPED_TRACE(type->ToString());
+    {
+      ARROW_SCOPED_TRACE("Basic");
+      auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
+      auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+      int64_t max_index = 9;
+      auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Values with nulls");
+      auto values = "[null, 11, null, 13, null, 15, null, 17, null, 19]";
+      auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+      int64_t max_index = 9;
+      auto expected = "[19, null, 17, null, 15, null, 13, null, 11, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices with nulls");
+      auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
+      auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
+      int64_t max_index = 9;
+      auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Output greater than input");
+      auto values = "[0, 0, 0, 1, 1, 1]";
+      auto indices = "[0, 3, 6, 1, 4, 7]";
+      int64_t max_index = 8;
+      auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Values all null");
+      auto values = "[null, null]";
+      auto indices = "[0, 1]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices all null");
+      auto values = "[0, 1]";
+      auto indices = "[null, null]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Empty input output null");
+      auto values = "[]";
+      auto indices = "[]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices duplicated indices");
+      auto values = "[1, 0, null, null]";
+      auto indices = "[0, 1, 0, 1]";
+      int64_t max_index = 3;
+      auto expected = "[null, null, null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
   }
 }
 
-template <typename ArrowType>
-class TestScatterString : public TestScatterTyped<ArrowType> {};
-
-TYPED_TEST_SUITE(TestScatterString, BaseBinaryArrowTypes);
-
-TYPED_TEST(TestScatterString, Basic) {
-  {
-    ARROW_SCOPED_TRACE("Basic");
-    auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
-    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t max_index = 9;
-    auto expected = R"(["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"])";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Values with nulls");
-    auto values = R"([null, "b", null, "d", null, "f", null, "h", null, "j"])";
-    auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
-    int64_t max_index = 9;
-    auto expected = R"(["j", null, "h", null, "f", null, "d", null, "b", null])";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Indices with nulls");
-    auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
-    auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
-    int64_t max_index = 9;
-    auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Output greater than input");
-    auto values = R"(["a", "a", "a", "b", "b", "b"])";
-    auto indices = "[0, 3, 6, 1, 4, 7]";
-    int64_t max_index = 8;
-    auto expected = R"(["a", "b", null, "a", "b", null, "a", "b", null])";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Values all null");
-    auto values = "[null, null]";
-    auto indices = "[0, 1]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Indices all null");
-    auto values = R"(["a", "b"])";
-    auto indices = "[null, null]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Empty input output null");
-    auto values = "[]";
-    auto indices = "[]";
-    int64_t max_index = 1;
-    auto expected = "[null, null]";
-    this->TestScatter(values, indices, max_index, expected);
-  }
-  {
-    ARROW_SCOPED_TRACE("Indices duplicated indices");
-    auto values = R"(["a", "b", null, null])";
-    auto indices = "[0, 1, 0, 1]";
-    int64_t max_index = 3;
-    auto expected = "[null, null, null, null]";
-    this->TestScatter(values, indices, max_index, expected);
+TEST(Scatter, Binary) {
+  for (const auto& type : kBinaryTypes) {
+    ARROW_SCOPED_TRACE(type->ToString());
+    {
+      ARROW_SCOPED_TRACE("Basic");
+      auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
+      auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+      int64_t max_index = 9;
+      auto expected = R"(["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"])";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Values with nulls");
+      auto values = R"([null, "b", null, "d", null, "f", null, "h", null, "j"])";
+      auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
+      int64_t max_index = 9;
+      auto expected = R"(["j", null, "h", null, "f", null, "d", null, "b", null])";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices with nulls");
+      auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
+      auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
+      int64_t max_index = 9;
+      auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Output greater than input");
+      auto values = R"(["a", "a", "a", "b", "b", "b"])";
+      auto indices = "[0, 3, 6, 1, 4, 7]";
+      int64_t max_index = 8;
+      auto expected = R"(["a", "b", null, "a", "b", null, "a", "b", null])";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Values all null");
+      auto values = "[null, null]";
+      auto indices = "[0, 1]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices all null");
+      auto values = R"(["a", "b"])";
+      auto indices = "[null, null]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Empty input output null");
+      auto values = "[]";
+      auto indices = "[]";
+      int64_t max_index = 1;
+      auto expected = "[null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
+    {
+      ARROW_SCOPED_TRACE("Indices duplicated indices");
+      auto values = R"(["a", "b", null, null])";
+      auto indices = "[0, 1, 0, 1]";
+      int64_t max_index = 3;
+      auto expected = "[null, null, null, null]";
+      TestScatter(type, values, indices, max_index, expected);
+    }
   }
 }
 

From d17b88bdd4f619d9e58baf9121501f2067009b0f Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 16:40:08 +0800
Subject: [PATCH 51/54] Naming

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

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index 859df44053e9c..46a67e26cee82 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -36,7 +36,7 @@ static const std::vector<std::shared_ptr<DataType>> kSignedIntegerTypes = {
 static const std::vector<std::shared_ptr<DataType>> kBinaryTypes = {
     binary(), utf8(), large_binary(), large_utf8()};
 
-using SmallOutputTypes = ::testing::Types<Int8Type, Int16Type>;
+using SmallSignedIntegerTypes = ::testing::Types<Int8Type, Int16Type>;
 
 }  // namespace
 
@@ -262,7 +262,7 @@ class TestInversePermutationSmallOutputType : public ::testing::Test {
   }
 };
 
-TYPED_TEST_SUITE(TestInversePermutationSmallOutputType, SmallOutputTypes);
+TYPED_TEST_SUITE(TestInversePermutationSmallOutputType, SmallSignedIntegerTypes);
 
 TYPED_TEST(TestInversePermutationSmallOutputType, JustEnoughOutputType) {
   auto output_type = this->type_singleton();
@@ -561,7 +561,7 @@ class TestScatterSmallIndicesTypes : public ::testing::Test {
   }
 };
 
-TYPED_TEST_SUITE(TestScatterSmallIndicesTypes, SmallOutputTypes);
+TYPED_TEST_SUITE(TestScatterSmallIndicesTypes, SmallSignedIntegerTypes);
 
 TYPED_TEST(TestScatterSmallIndicesTypes, MaxIntegerIndex) {
   auto values = ArrayFromJSON(utf8(), R"(["a"])");

From cf543270108fb7d05576b4ab21145031609d2b40 Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 17:36:30 +0800
Subject: [PATCH 52/54] Remove repetition of test cases

---
 .../compute/kernels/vector_swizzle_test.cc    | 40 ++++++++-----------
 1 file changed, 17 insertions(+), 23 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
index 46a67e26cee82..be5fbdeaed506 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -77,7 +77,7 @@ void DoTestInversePermutationForInputTypes(
     const Datum& expected, bool validity_must_be_null = false) {
   for (const auto& input_type : input_types) {
     ARROW_SCOPED_TRACE("Input type: " + input_type->ToString());
-    auto indices = input(input_type);
+    ASSERT_OK_AND_ASSIGN(auto indices, input(input_type));
     AssertInversePermutation(indices, max_index, output_type, expected,
                              validity_must_be_null);
   }
@@ -100,14 +100,15 @@ void DoTestInversePermutationForInputOutputTypes(
 void TestInversePermutationForInputOutputTypes(
     const std::vector<std::shared_ptr<DataType>>& input_types,
     const std::vector<std::shared_ptr<DataType>>& output_types,
-    const std::string& indices_str, const std::vector<std::string>& indices_chunked_str,
-    int64_t max_index, const std::string& expected_str, bool validity_must_be_null) {
+    const std::vector<std::string>& indices_chunked_str, int64_t max_index,
+    const std::string& expected_str, bool validity_must_be_null) {
   {
     ARROW_SCOPED_TRACE("Array");
     DoTestInversePermutationForInputOutputTypes(
         input_types, output_types,
-        [&](const std::shared_ptr<DataType>& input_type) {
-          return ArrayFromJSON(input_type, indices_str);
+        [&](const std::shared_ptr<DataType>& input_type) -> Result<Datum> {
+          auto chunked = ChunkedArrayFromJSON(input_type, indices_chunked_str);
+          return Concatenate(chunked->chunks());
         },
         max_index, expected_str, validity_must_be_null);
   }
@@ -115,20 +116,19 @@ void TestInversePermutationForInputOutputTypes(
     ARROW_SCOPED_TRACE("Chunked");
     DoTestInversePermutationForInputOutputTypes(
         input_types, output_types,
-        [&](const std::shared_ptr<DataType>& input_type) {
+        [&](const std::shared_ptr<DataType>& input_type) -> Result<Datum> {
           return ChunkedArrayFromJSON(input_type, indices_chunked_str);
         },
         max_index, expected_str, validity_must_be_null);
   }
 }
 
-void TestInversePermutation(const std::string& indices_str,
-                            const std::vector<std::string>& indices_chunked_str,
+void TestInversePermutation(const std::vector<std::string>& indices_chunked_str,
                             int64_t max_index, const std::string& expected_str,
                             bool validity_must_be_null = false) {
   TestInversePermutationForInputOutputTypes(kSignedIntegerTypes, kSignedIntegerTypes,
-                                            indices_str, indices_chunked_str, max_index,
-                                            expected_str, validity_must_be_null);
+                                            indices_chunked_str, max_index, expected_str,
+                                            validity_must_be_null);
 }
 
 }  // namespace
@@ -200,55 +200,49 @@ TEST(InversePermutation, InvalidIndex) {
 TEST(InversePermutation, Basic) {
   {
     ARROW_SCOPED_TRACE("Basic");
-    auto indices = "[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]";
     std::vector<std::string> indices_chunked{
         "[]", "[9, 7, 5, 3, 1]", "[0]", "[2, 4, 6]", "[8]", "[]"};
     int64_t max_index = 9;
     auto expected = "[5, 4, 6, 3, 7, 2, 8, 1, 9, 0]";
-    TestInversePermutation(indices, indices_chunked, max_index, expected,
+    TestInversePermutation(indices_chunked, max_index, expected,
                            /*validity_must_be_null=*/true);
   }
   {
     ARROW_SCOPED_TRACE("Basic with nulls");
-    auto indices = "[9, 7, 5, 3, 1, null, null, null, null, null]";
     std::vector<std::string> indices_chunked{
         "[]", "[9, 7, 5, 3, 1]", "[null]", "[null, null, null]", "[null]", "[]"};
     int64_t max_index = 9;
     auto expected = "[null, 4, null, 3, null, 2, null, 1, null, 0]";
-    TestInversePermutation(indices, indices_chunked, max_index, expected);
+    TestInversePermutation(indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Output greater than input");
-    auto indices = "[1, 2]";
     std::vector<std::string> indices_chunked{"[]", "[1]", "[]", "[2]"};
     int64_t max_index = 6;
     auto expected = "[null, 0, 1, null, null, null, null]";
-    TestInversePermutation(indices, indices_chunked, max_index, expected);
+    TestInversePermutation(indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Input all null");
-    auto indices = "[null, null]";
     std::vector<std::string> indices_chunked{"[]", "[null]", "[]", "[null]"};
     int64_t max_index = 1;
     auto expected = "[null, null]";
-    TestInversePermutation(indices, indices_chunked, max_index, expected);
+    TestInversePermutation(indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Empty input output null");
-    auto indices = "[]";
     std::vector<std::string> indices_chunked{"[]", "[]", "[]", "[]"};
     int64_t max_index = 6;
     auto expected = "[null, null, null, null, null, null, null]";
-    TestInversePermutation(indices, indices_chunked, max_index, expected);
+    TestInversePermutation(indices_chunked, max_index, expected);
   }
   {
     ARROW_SCOPED_TRACE("Input duplicated indices");
-    auto indices = "[1, 2, 3, 1, 2, 3, 1, 2, 3]";
     std::vector<std::string> indices_chunked{"[]", "[1, 2]", "[3, 1, 2, 3, 1]",
                                              "[]", "[2]",    "[3]"};
     int64_t max_index = 4;
     auto expected = "[null, 6, 7, 8, null]";
-    TestInversePermutation(indices, indices_chunked, max_index, expected);
+    TestInversePermutation(indices_chunked, max_index, expected);
   }
 }
 
@@ -272,7 +266,7 @@ TYPED_TEST(TestInversePermutationSmallOutputType, JustEnoughOutputType) {
       ArrayFromJSON(output_type, "[" + std::to_string(input_length - 1) + "]");
   DoTestInversePermutationForInputTypes(
       kSignedIntegerTypes,
-      [&](const std::shared_ptr<DataType>& input_type) {
+      [&](const std::shared_ptr<DataType>& input_type) -> Result<Datum> {
         return ConstantArrayGenerator::Zeroes(input_length, input_type);
       },
       /*max_index=*/0, output_type, expected);

From 53f3c33004c496ef6c3f706d430af22ad8fd15bb Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 17:50:32 +0800
Subject: [PATCH 53/54] Doc about output length

---
 cpp/src/arrow/compute/api_vector.h | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index acedbe9aa458d..48b4e8068f3b9 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -265,8 +265,10 @@ class ARROW_EXPORT InversePermutationOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "InversePermutationOptions";
   static InversePermutationOptions Defaults() { return InversePermutationOptions(); }
 
-  /// \brief The max value in the input indices to allow. If negative, this value will be
-  /// set to the length of the input indices minus 1.
+  /// \brief The max value in the input indices to allow. The length of the function's
+  /// output will be this value plus 1. If negative, this value will be set to the length
+  /// of the input indices minus 1 and the length of the function's output will be the
+  /// length of the input indices.
   int64_t max_index = -1;
   /// \brief The type of the output inverse permutation. If null, the output will be of
   /// the same type as the input indices, otherwise must be signed integer type. An
@@ -282,8 +284,10 @@ class ARROW_EXPORT ScatterOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "ScatterOptions";
   static ScatterOptions Defaults() { return ScatterOptions(); }
 
-  /// \brief The max value in the input indices to allow. If negative, this value will be
-  /// set to the length of the input minus 1.
+  /// \brief The max value in the input indices to allow. The length of the function's
+  /// output will be this value plus 1. If negative, this value will be set to the length
+  /// of the input indices minus 1 and the length of the function's output will be the
+  /// length of the input indices.
   int64_t max_index = -1;
 };
 

From 688b4d0fcff22f4f475318f199ec7d1cf27a124f Mon Sep 17 00:00:00 2001
From: Rossi Sun <zanmato1984@gmail.com>
Date: Thu, 12 Dec 2024 18:27:36 +0800
Subject: [PATCH 54/54] Fix ci error

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

diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle.cc b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
index c6f34f8bfcf18..1611a2e90b271 100644
--- a/cpp/src/arrow/compute/kernels/vector_swizzle.cc
+++ b/cpp/src/arrow/compute/kernels/vector_swizzle.cc
@@ -207,7 +207,7 @@ struct InversePermutationImpl {
     DCHECK_NE(data_buf_, nullptr);
     OutputCType* data = data_buf_->mutable_data_as<OutputCType>();
     int64_t inverse = 0;
-    RETURN_NOT_OK(ExecType::template VisitIndices(
+    RETURN_NOT_OK(ExecType::VisitIndices(
         indices_,
         [&](IndexCType index) {
           if (ARROW_PREDICT_FALSE(index < 0 ||