Implementation done and basic tests

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

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));

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:

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")

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;