From 66c08249589789fa5bbdff66b05c596c6b5bb506 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 14 Jul 2020 11:13:04 +0200
Subject: [PATCH 1/3] ARROW-9390: [C++][Doc] Review compute function names

Modified function names:
* minmax -> min_max
* binary_isascii -> string_isascii (only works on string types)
* ascii_length -> binary_length (also make it work on binary types)
* binary_contains_exact -> match_substring
  (other possibility: has_substring ?)
* match -> index_in
* isin -> is_in
* list_value_lengths -> list_value_length
* partition_indices -> partition_nth_indices
  (other kinds of partitioning would be possible, e.g. using a predicate)

Document string predicate functions (ARROW-9444).

Also fix the allocation of IsValid output buffer in certain cases.
---
 cpp/src/arrow/compute/api_aggregate.cc        |   2 +-
 cpp/src/arrow/compute/api_scalar.cc           |   6 +-
 cpp/src/arrow/compute/api_scalar.h            |  17 +-
 cpp/src/arrow/compute/api_vector.cc           |   6 +-
 cpp/src/arrow/compute/api_vector.h            |   4 +-
 .../arrow/compute/kernels/aggregate_basic.cc  |   2 +-
 .../arrow/compute/kernels/aggregate_test.cc   |   4 +-
 .../arrow/compute/kernels/scalar_nested.cc    |  16 +-
 .../compute/kernels/scalar_nested_test.cc     |   4 +-
 .../compute/kernels/scalar_set_lookup.cc      |  47 ++---
 .../compute/kernels/scalar_set_lookup_test.cc |  22 +--
 .../arrow/compute/kernels/scalar_string.cc    |  67 +++----
 .../kernels/scalar_string_benchmark.cc        |   8 +-
 .../compute/kernels/scalar_string_test.cc     |  88 ++++-----
 .../arrow/compute/kernels/scalar_validity.cc  |  36 ++--
 cpp/src/arrow/compute/kernels/test_util.cc    |   5 +-
 .../compute/kernels/vector_nested_test.cc     |  12 +-
 .../compute/kernels/vector_selection_test.cc  |   1 +
 cpp/src/arrow/compute/kernels/vector_sort.cc  |  18 +-
 .../arrow/compute/kernels/vector_sort_test.cc |   3 +-
 cpp/src/arrow/dataset/partition.cc            |   2 +-
 cpp/src/arrow/type_traits.h                   |   2 +
 docs/source/cpp/compute.rst                   | 168 +++++++++++++-----
 python/pyarrow/_compute.pyx                   |  13 +-
 python/pyarrow/array.pxi                      |   2 +-
 python/pyarrow/compute.py                     |  24 ++-
 python/pyarrow/includes/libarrow.pxd          |   6 +-
 python/pyarrow/tests/test_compute.py          |  24 ++-
 r/R/compute.R                                 |   4 +-
 r/src/compute.cpp                             |   2 +-
 30 files changed, 374 insertions(+), 241 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.cc b/cpp/src/arrow/compute/api_aggregate.cc
index 358a5ad0cee..95e859e20ee 100644
--- a/cpp/src/arrow/compute/api_aggregate.cc
+++ b/cpp/src/arrow/compute/api_aggregate.cc
@@ -38,7 +38,7 @@ Result<Datum> Sum(const Datum& value, ExecContext* ctx) {
 }
 
 Result<Datum> MinMax(const Datum& value, const MinMaxOptions& options, ExecContext* ctx) {
-  return CallFunction("minmax", {value}, &options, ctx);
+  return CallFunction("min_max", {value}, &options, ctx);
 }
 
 }  // namespace compute
diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 77893f74fcd..9a911030999 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -73,12 +73,12 @@ static Result<Datum> ExecSetLookup(const std::string& func_name, const Datum& da
 }
 
 Result<Datum> IsIn(const Datum& values, const Datum& value_set, ExecContext* ctx) {
-  return ExecSetLookup("isin", values, value_set,
+  return ExecSetLookup("is_in", values, value_set,
                        /*add_nulls_to_hash_table=*/false, ctx);
 }
 
-Result<Datum> Match(const Datum& values, const Datum& value_set, ExecContext* ctx) {
-  return ExecSetLookup("match", values, value_set,
+Result<Datum> IndexIn(const Datum& values, const Datum& value_set, ExecContext* ctx) {
+  return ExecSetLookup("index_in", values, value_set,
                        /*add_nulls_to_hash_table=*/true, ctx);
 }
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 1d8ef091815..80e3ebb98b3 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -42,15 +42,14 @@ struct ArithmeticOptions : public FunctionOptions {
   bool check_overflow;
 };
 
-struct ARROW_EXPORT BinaryContainsExactOptions : public FunctionOptions {
-  explicit BinaryContainsExactOptions(std::string pattern)
-      : pattern(std::move(pattern)) {}
+struct ARROW_EXPORT MatchSubstringOptions : public FunctionOptions {
+  explicit MatchSubstringOptions(std::string pattern) : pattern(std::move(pattern)) {}
 
-  /// The exact pattern to look for inside input values.
+  /// The exact substring to look for inside input values.
   std::string pattern;
 };
 
-/// Options for IsIn and Match functions
+/// Options for IsIn and IndexIn functions
 struct ARROW_EXPORT SetLookupOptions : public FunctionOptions {
   explicit SetLookupOptions(Datum value_set, bool skip_nulls)
       : value_set(std::move(value_set)), skip_nulls(skip_nulls) {}
@@ -60,7 +59,7 @@ struct ARROW_EXPORT SetLookupOptions : public FunctionOptions {
   /// Whether nulls in `value_set` count for lookup.
   ///
   /// If true, any null in `value_set` is ignored and nulls in the input
-  /// produce null (Match) or false (IsIn) values in the output.
+  /// produce null (IndexIn) or false (IsIn) values in the output.
   /// If false, any null in `value_set` is successfully matched in
   /// the input.
   bool skip_nulls;
@@ -238,7 +237,7 @@ ARROW_EXPORT
 Result<Datum> IsIn(const Datum& values, const Datum& value_set,
                    ExecContext* ctx = NULLPTR);
 
-/// \brief Match examines each slot in the values against a value_set array.
+/// \brief IndexIn examines each slot in the values against a value_set array.
 /// If the value is not found in value_set, null will be output.
 /// If found, the index of occurrence within value_set (ignoring duplicates)
 /// will be output.
@@ -259,8 +258,8 @@ Result<Datum> IsIn(const Datum& values, const Datum& value_set,
 /// \since 1.0.0
 /// \note API not yet finalized
 ARROW_EXPORT
-Result<Datum> Match(const Datum& values, const Datum& value_set,
-                    ExecContext* ctx = NULLPTR);
+Result<Datum> IndexIn(const Datum& values, const Datum& value_set,
+                      ExecContext* ctx = NULLPTR);
 
 /// \brief IsValid returns true for each element of `values` that is not null,
 /// false otherwise
diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index dd9c43910f1..9a36714d107 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -35,9 +35,9 @@ namespace compute {
 
 Result<std::shared_ptr<Array>> NthToIndices(const Array& values, int64_t n,
                                             ExecContext* ctx) {
-  PartitionOptions options(/*pivot=*/n);
-  ARROW_ASSIGN_OR_RAISE(
-      Datum result, CallFunction("partition_indices", {Datum(values)}, &options, ctx));
+  PartitionNthOptions options(/*pivot=*/n);
+  ARROW_ASSIGN_OR_RAISE(Datum result, CallFunction("partition_nth_indices",
+                                                   {Datum(values)}, &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 c3e9dc9d2fc..3aa3434c098 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -59,8 +59,8 @@ struct ARROW_EXPORT TakeOptions : public FunctionOptions {
 };
 
 /// \brief Partitioning options for NthToIndices
-struct PartitionOptions : public FunctionOptions {
-  explicit PartitionOptions(int64_t pivot) : pivot(pivot) {}
+struct PartitionNthOptions : public FunctionOptions {
+  explicit PartitionNthOptions(int64_t pivot) : pivot(pivot) {}
 
   /// The index into the equivalent sorted array of the partition pivot element.
   int64_t pivot;
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 8765914ac73..2349360ba82 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -398,7 +398,7 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
   static auto default_minmax_options = MinMaxOptions::Defaults();
-  func = std::make_shared<ScalarAggregateFunction>("minmax", Arity::Unary(),
+  func = std::make_shared<ScalarAggregateFunction>("min_max", Arity::Unary(),
                                                    &default_minmax_options);
   aggregate::AddMinMaxKernels(aggregate::MinMaxInit, {boolean()}, func.get());
   aggregate::AddMinMaxKernels(aggregate::MinMaxInit, NumericTypes(), func.get());
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index db548f27b36..6658a7e9234 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -583,11 +583,11 @@ TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
 TYPED_TEST(TestFloatingMinMaxKernel, DefaultOptions) {
   auto values = ArrayFromJSON(this->type_singleton(), "[0, 1, 2, 3, 4]");
 
-  ASSERT_OK_AND_ASSIGN(auto no_options_provided, CallFunction("minmax", {values}));
+  ASSERT_OK_AND_ASSIGN(auto no_options_provided, CallFunction("min_max", {values}));
 
   auto default_options = MinMaxOptions::Defaults();
   ASSERT_OK_AND_ASSIGN(auto explicit_defaults,
-                       CallFunction("minmax", {values}, &default_options));
+                       CallFunction("min_max", {values}, &default_options));
 
   AssertDatumsEqual(explicit_defaults, no_options_provided);
 }
diff --git a/cpp/src/arrow/compute/kernels/scalar_nested.cc b/cpp/src/arrow/compute/kernels/scalar_nested.cc
index 7c61aa3b476..677c577364e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_nested.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_nested.cc
@@ -28,7 +28,7 @@ namespace internal {
 namespace {
 
 template <typename Type, typename offset_type = typename Type::offset_type>
-void ListValueLengths(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+void ListValueLength(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
   using ScalarType = typename TypeTraits<Type>::ScalarType;
   using OffsetScalarType = typename TypeTraits<Type>::OffsetScalarType;
 
@@ -55,13 +55,13 @@ void ListValueLengths(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
 }  // namespace
 
 void RegisterScalarNested(FunctionRegistry* registry) {
-  auto list_value_lengths =
-      std::make_shared<ScalarFunction>("list_value_lengths", Arity::Unary());
-  DCHECK_OK(list_value_lengths->AddKernel({InputType(Type::LIST)}, int32(),
-                                          ListValueLengths<ListType>));
-  DCHECK_OK(list_value_lengths->AddKernel({InputType(Type::LARGE_LIST)}, int64(),
-                                          ListValueLengths<LargeListType>));
-  DCHECK_OK(registry->AddFunction(std::move(list_value_lengths)));
+  auto list_value_length =
+      std::make_shared<ScalarFunction>("list_value_length", Arity::Unary());
+  DCHECK_OK(list_value_length->AddKernel({InputType(Type::LIST)}, int32(),
+                                         ListValueLength<ListType>));
+  DCHECK_OK(list_value_length->AddKernel({InputType(Type::LARGE_LIST)}, int64(),
+                                         ListValueLength<LargeListType>));
+  DCHECK_OK(registry->AddFunction(std::move(list_value_length)));
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_nested_test.cc b/cpp/src/arrow/compute/kernels/scalar_nested_test.cc
index 4657c41a407..24776913ee0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_nested_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_nested_test.cc
@@ -29,9 +29,9 @@ static std::shared_ptr<DataType> GetOffsetType(const DataType& type) {
   return type.id() == Type::LIST ? int32() : int64();
 }
 
-TEST(TestScalarNested, ListValueLengths) {
+TEST(TestScalarNested, ListValueLength) {
   for (auto ty : {list(int32()), large_list(int32())}) {
-    CheckScalarUnary("list_value_lengths", ty, "[[0, null, 1], null, [2, 3], []]",
+    CheckScalarUnary("list_value_length", ty, "[[0, null, 1], null, [2, 3], []]",
                      GetOffsetType(*ty), "[3, null, 2, 0]");
   }
 }
diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
index 67e6204a8de..726b01fb477 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
@@ -165,13 +165,13 @@ std::unique_ptr<KernelState> InitSetLookup(KernelContext* ctx,
   return result;
 }
 
-struct MatchVisitor {
+struct IndexInVisitor {
   KernelContext* ctx;
   const ArrayData& data;
   Datum* out;
   Int32Builder builder;
 
-  MatchVisitor(KernelContext* ctx, const ArrayData& data, Datum* out)
+  IndexInVisitor(KernelContext* ctx, const ArrayData& data, Datum* out)
       : ctx(ctx), data(data), out(out), builder(ctx->exec_context()->memory_pool()) {}
 
   Status Visit(const DataType&) {
@@ -190,7 +190,7 @@ struct MatchVisitor {
   }
 
   template <typename Type>
-  Status ProcessMatch() {
+  Status ProcessIndexIn() {
     using T = typename GetViewType<Type>::T;
 
     const auto& state = checked_cast<const SetLookupState<Type>&>(*ctx->state());
@@ -223,23 +223,24 @@ struct MatchVisitor {
 
   template <typename Type>
   enable_if_boolean<Type, Status> Visit(const Type&) {
-    return ProcessMatch<BooleanType>();
+    return ProcessIndexIn<BooleanType>();
   }
 
   template <typename Type>
   enable_if_t<has_c_type<Type>::value && !is_boolean_type<Type>::value, Status> Visit(
       const Type&) {
-    return ProcessMatch<typename UnsignedIntType<sizeof(typename Type::c_type)>::Type>();
+    return ProcessIndexIn<
+        typename UnsignedIntType<sizeof(typename Type::c_type)>::Type>();
   }
 
   template <typename Type>
   enable_if_base_binary<Type, Status> Visit(const Type&) {
-    return ProcessMatch<typename Type::PhysicalType>();
+    return ProcessIndexIn<typename Type::PhysicalType>();
   }
 
   // Handle Decimal128Type, FixedSizeBinaryType
   Status Visit(const FixedSizeBinaryType& type) {
-    return ProcessMatch<FixedSizeBinaryType>();
+    return ProcessIndexIn<FixedSizeBinaryType>();
   }
 
   Status Execute() {
@@ -269,9 +270,9 @@ void ExecArrayOrScalar(KernelContext* ctx, const Datum& in, Datum* out,
   *out = std::move(out_scalar);
 }
 
-void ExecMatch(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+void ExecIndexIn(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
   ExecArrayOrScalar(ctx, batch[0], out, [&](const ArrayData& in) {
-    return MatchVisitor(ctx, in, out).Execute();
+    return IndexInVisitor(ctx, in, out).Execute();
   });
 }
 
@@ -395,10 +396,10 @@ void AddBasicSetLookupKernels(ScalarKernel kernel,
   }
 }
 
-// Enables calling isin with CallFunction as though it were binary.
+// Enables calling is_in with CallFunction as though it were binary.
 class IsInMetaBinary : public MetaFunction {
  public:
-  IsInMetaBinary() : MetaFunction("isin_meta_binary", Arity::Binary()) {}
+  IsInMetaBinary() : MetaFunction("is_in_meta_binary", Arity::Binary()) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
@@ -408,16 +409,16 @@ class IsInMetaBinary : public MetaFunction {
   }
 };
 
-// Enables calling match with CallFunction as though it were binary.
-class MatchMetaBinary : public MetaFunction {
+// Enables calling index_in with CallFunction as though it were binary.
+class IndexInMetaBinary : public MetaFunction {
  public:
-  MatchMetaBinary() : MetaFunction("match_meta_binary", Arity::Binary()) {}
+  IndexInMetaBinary() : MetaFunction("index_in_meta_binary", Arity::Binary()) {}
 
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
                             ExecContext* ctx) const override {
     DCHECK_EQ(options, nullptr);
-    return Match(args[0], args[1], ctx);
+    return IndexIn(args[0], args[1], ctx);
   }
 };
 
@@ -429,33 +430,33 @@ void RegisterScalarSetLookup(FunctionRegistry* registry) {
     ScalarKernel isin_base;
     isin_base.init = InitSetLookup;
     isin_base.exec = ExecIsIn;
-    auto isin = std::make_shared<ScalarFunction>("isin", Arity::Unary());
+    auto is_in = std::make_shared<ScalarFunction>("is_in", Arity::Unary());
 
-    AddBasicSetLookupKernels(isin_base, /*output_type=*/boolean(), isin.get());
+    AddBasicSetLookupKernels(isin_base, /*output_type=*/boolean(), is_in.get());
 
     isin_base.signature = KernelSignature::Make({null()}, boolean());
     isin_base.null_handling = NullHandling::COMPUTED_PREALLOCATE;
-    DCHECK_OK(isin->AddKernel(isin_base));
-    DCHECK_OK(registry->AddFunction(isin));
+    DCHECK_OK(is_in->AddKernel(isin_base));
+    DCHECK_OK(registry->AddFunction(is_in));
 
     DCHECK_OK(registry->AddFunction(std::make_shared<IsInMetaBinary>()));
   }
 
-  // Match uses Int32Builder and so is responsible for all its own allocation
+  // IndexIn uses Int32Builder and so is responsible for all its own allocation
   {
     ScalarKernel match_base;
     match_base.init = InitSetLookup;
-    match_base.exec = ExecMatch;
+    match_base.exec = ExecIndexIn;
     match_base.null_handling = NullHandling::COMPUTED_NO_PREALLOCATE;
     match_base.mem_allocation = MemAllocation::NO_PREALLOCATE;
-    auto match = std::make_shared<ScalarFunction>("match", Arity::Unary());
+    auto match = std::make_shared<ScalarFunction>("index_in", Arity::Unary());
     AddBasicSetLookupKernels(match_base, /*output_type=*/int32(), match.get());
 
     match_base.signature = KernelSignature::Make({null()}, int32());
     DCHECK_OK(match->AddKernel(match_base));
     DCHECK_OK(registry->AddFunction(match));
 
-    DCHECK_OK(registry->AddFunction(std::make_shared<MatchMetaBinary>()));
+    DCHECK_OK(registry->AddFunction(std::make_shared<IndexInMetaBinary>()));
   }
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
index a20fe61d1bc..e1540d15b1f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
@@ -73,9 +73,9 @@ class TestIsInKernel : public ::testing::Test {};
 TEST_F(TestIsInKernel, CallBinary) {
   auto haystack = ArrayFromJSON(int8(), "[0, 1, 2, 3, 4, 5, 6, 7, 8]");
   auto needles = ArrayFromJSON(int8(), "[2, 3, 5, 7]");
-  ASSERT_RAISES(Invalid, CallFunction("isin", {haystack, needles}));
+  ASSERT_RAISES(Invalid, CallFunction("is_in", {haystack, needles}));
 
-  ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("isin_meta_binary", {haystack, needles}));
+  ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("is_in_meta_binary", {haystack, needles}));
   auto expected = ArrayFromJSON(boolean(), ("[false, false, true, true, false,"
                                             "true, false, true, false]"));
   AssertArraysEqual(*expected, *out.make_array());
@@ -118,6 +118,7 @@ TYPED_TEST(TestIsInKernelPrimitive, IsIn) {
   CheckIsIn<TypeParam, T>(
       type, {2, 1, 2, 3}, {false, false, false, false}, {2, 1, 2, 1, 2, 3, 3},
       {false, false, false, false, false, false, false}, {true, true, true, true}, {});
+
   // No Match
   CheckIsIn<TypeParam, T>(
       type, {2, 1, 7, 3, 8}, {true, false, true, true, true}, {2, 1, 2, 1, 6, 3, 3},
@@ -411,7 +412,7 @@ TEST_F(TestIsInKernel, IsInChunkedArrayInvoke) {
   AssertChunkedEquivalent(*expected_carr, *encoded_out.chunked_array());
 }
 // ----------------------------------------------------------------------
-// Match tests
+// IndexIn tests
 
 class TestMatchKernel : public ::testing::Test {
  public:
@@ -421,7 +422,7 @@ class TestMatchKernel : public ::testing::Test {
     std::shared_ptr<Array> needles = ArrayFromJSON(type, needles_json);
     std::shared_ptr<Array> expected = ArrayFromJSON(int32(), expected_json);
 
-    ASSERT_OK_AND_ASSIGN(Datum actual_datum, Match(haystack, needles));
+    ASSERT_OK_AND_ASSIGN(Datum actual_datum, IndexIn(haystack, needles));
     std::shared_ptr<Array> actual = actual_datum.make_array();
     AssertArraysEqual(*expected, *actual, /*verbose=*/true);
   }
@@ -430,9 +431,10 @@ class TestMatchKernel : public ::testing::Test {
 TEST_F(TestMatchKernel, CallBinary) {
   auto haystack = ArrayFromJSON(int8(), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]");
   auto needles = ArrayFromJSON(int8(), "[2, 3, 5, 7]");
-  ASSERT_RAISES(Invalid, CallFunction("match", {haystack, needles}));
+  ASSERT_RAISES(Invalid, CallFunction("index_in", {haystack, needles}));
 
-  ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("match_meta_binary", {haystack, needles}));
+  ASSERT_OK_AND_ASSIGN(Datum out,
+                       CallFunction("index_in_meta_binary", {haystack, needles}));
   auto expected = ArrayFromJSON(int32(), ("[null, null, 0, 1, null, 2, null, 3, null,"
                                           " null, null]"));
   AssertArraysEqual(*expected, *out.make_array());
@@ -448,7 +450,7 @@ using PrimitiveDictionaries =
 
 TYPED_TEST_SUITE(TestMatchKernelPrimitive, PrimitiveDictionaries);
 
-TYPED_TEST(TestMatchKernelPrimitive, Match) {
+TYPED_TEST(TestMatchKernelPrimitive, IndexIn) {
   auto type = TypeTraits<TypeParam>::type_singleton();
 
   // No Nulls
@@ -508,7 +510,7 @@ TYPED_TEST(TestMatchKernelPrimitive, PrimitiveResizeTable) {
   needles = haystack;
   ASSERT_OK(expected_builder.Finish(&expected));
 
-  ASSERT_OK_AND_ASSIGN(Datum actual_datum, Match(haystack, needles));
+  ASSERT_OK_AND_ASSIGN(Datum actual_datum, IndexIn(haystack, needles));
   std::shared_ptr<Array> actual = actual_datum.make_array();
   ASSERT_ARRAYS_EQUAL(*expected, *actual);
 }
@@ -667,7 +669,7 @@ TEST_F(TestMatchKernel, BinaryResizeTable) {
   needles = haystack;
   ASSERT_OK(expected_builder.Finish(&expected));
 
-  ASSERT_OK_AND_ASSIGN(Datum actual_datum, Match(haystack, needles));
+  ASSERT_OK_AND_ASSIGN(Datum actual_datum, IndexIn(haystack, needles));
   std::shared_ptr<Array> actual = actual_datum.make_array();
   ASSERT_ARRAYS_EQUAL(*expected, *actual);
 }
@@ -749,7 +751,7 @@ TEST_F(TestMatchKernel, MatchChunkedArrayInvoke) {
   ArrayVector expected = {i1, i2};
   auto expected_carr = std::make_shared<ChunkedArray>(expected);
 
-  ASSERT_OK_AND_ASSIGN(Datum encoded_out, Match(carr, Datum(member_set)));
+  ASSERT_OK_AND_ASSIGN(Datum encoded_out, IndexIn(carr, Datum(member_set)));
   ASSERT_EQ(Datum::CHUNKED_ARRAY, encoded_out.kind());
 
   AssertChunkedEquivalent(*expected_carr, *encoded_out.chunked_array());
diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index fbacaab54d6..31517930c06 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -55,9 +55,7 @@ static inline bool IsAsciiCharacter(T character) {
   return character < 128;
 }
 
-// TODO: optional ascii validation
-
-struct AsciiLength {
+struct BinaryLength {
   template <typename OUT, typename ARG0 = util::string_view>
   static OUT Call(KernelContext*, ARG0 val) {
     return static_cast<OUT>(val.size());
@@ -297,17 +295,6 @@ struct AsciiLower {
   }
 };
 
-void AddAsciiLength(FunctionRegistry* registry) {
-  auto func = std::make_shared<ScalarFunction>("ascii_length", Arity::Unary());
-  ArrayKernelExec exec_offset_32 =
-      applicator::ScalarUnaryNotNull<Int32Type, StringType, AsciiLength>::Exec;
-  ArrayKernelExec exec_offset_64 =
-      applicator::ScalarUnaryNotNull<Int64Type, LargeStringType, AsciiLength>::Exec;
-  DCHECK_OK(func->AddKernel({utf8()}, int32(), exec_offset_32));
-  DCHECK_OK(func->AddKernel({large_utf8()}, int64(), exec_offset_64));
-  DCHECK_OK(registry->AddFunction(std::move(func)));
-}
-
 // ----------------------------------------------------------------------
 // exact pattern detection
 
@@ -344,10 +331,9 @@ void StringBoolTransform(KernelContext* ctx, const ExecBatch& batch,
 }
 
 template <typename offset_type>
-void TransformBinaryContainsExact(const uint8_t* pattern, int64_t pattern_length,
-                                  const offset_type* offsets, const uint8_t* data,
-                                  int64_t length, int64_t output_offset,
-                                  uint8_t* output) {
+void TransformMatchSubstring(const uint8_t* pattern, int64_t pattern_length,
+                             const offset_type* offsets, const uint8_t* data,
+                             int64_t length, int64_t output_offset, uint8_t* output) {
   // This is an implementation of the Knuth-Morris-Pratt algorithm
 
   // Phase 1: Build the prefix table
@@ -385,20 +371,20 @@ void TransformBinaryContainsExact(const uint8_t* pattern, int64_t pattern_length
   bitmap_writer.Finish();
 }
 
-using BinaryContainsExactState = OptionsWrapper<BinaryContainsExactOptions>;
+using MatchSubstringState = OptionsWrapper<MatchSubstringOptions>;
 
 template <typename Type>
-struct BinaryContainsExact {
+struct MatchSubstring {
   using offset_type = typename Type::offset_type;
   static void Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    BinaryContainsExactOptions arg = BinaryContainsExactState::Get(ctx);
+    MatchSubstringOptions arg = MatchSubstringState::Get(ctx);
     const uint8_t* pat = reinterpret_cast<const uint8_t*>(arg.pattern.c_str());
     const int64_t pat_size = arg.pattern.length();
     StringBoolTransform<Type>(
         ctx, batch,
         [pat, pat_size](const void* offsets, const uint8_t* data, int64_t length,
                         int64_t output_offset, uint8_t* output) {
-          TransformBinaryContainsExact<offset_type>(
+          TransformMatchSubstring<offset_type>(
               pat, pat_size, reinterpret_cast<const offset_type*>(offsets), data, length,
               output_offset, output);
         },
@@ -406,14 +392,13 @@ struct BinaryContainsExact {
   }
 };
 
-void AddBinaryContainsExact(FunctionRegistry* registry) {
-  auto func = std::make_shared<ScalarFunction>("binary_contains_exact", Arity::Unary());
-  auto exec_32 = BinaryContainsExact<StringType>::Exec;
-  auto exec_64 = BinaryContainsExact<LargeStringType>::Exec;
+void AddMatchSubstring(FunctionRegistry* registry) {
+  auto func = std::make_shared<ScalarFunction>("match_substring", Arity::Unary());
+  auto exec_32 = MatchSubstring<StringType>::Exec;
+  auto exec_64 = MatchSubstring<LargeStringType>::Exec;
+  DCHECK_OK(func->AddKernel({utf8()}, boolean(), exec_32, MatchSubstringState::Init));
   DCHECK_OK(
-      func->AddKernel({utf8()}, boolean(), exec_32, BinaryContainsExactState::Init));
-  DCHECK_OK(func->AddKernel({large_utf8()}, boolean(), exec_64,
-                            BinaryContainsExactState::Init));
+      func->AddKernel({large_utf8()}, boolean(), exec_64, MatchSubstringState::Init));
   DCHECK_OK(registry->AddFunction(std::move(func)));
 }
 
@@ -870,6 +855,21 @@ void AddStrptime(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(func)));
 }
 
+void AddBinaryLength(FunctionRegistry* registry) {
+  auto func = std::make_shared<ScalarFunction>("binary_length", Arity::Unary());
+  ArrayKernelExec exec_offset_32 =
+      applicator::ScalarUnaryNotNull<Int32Type, StringType, BinaryLength>::Exec;
+  ArrayKernelExec exec_offset_64 =
+      applicator::ScalarUnaryNotNull<Int64Type, LargeStringType, BinaryLength>::Exec;
+  for (const auto input_type : {binary(), utf8()}) {
+    DCHECK_OK(func->AddKernel({input_type}, int32(), exec_offset_32));
+  }
+  for (const auto input_type : {large_binary(), large_utf8()}) {
+    DCHECK_OK(func->AddKernel({input_type}, int64(), exec_offset_64));
+  }
+  DCHECK_OK(registry->AddFunction(std::move(func)));
+}
+
 template <template <typename> class ExecFunctor>
 void MakeUnaryStringBatchKernel(std::string name, FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarFunction>(name, Arity::Unary());
@@ -944,7 +944,7 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   MakeUnaryStringBatchKernel<AsciiUpper>("ascii_upper", registry);
   MakeUnaryStringBatchKernel<AsciiLower>("ascii_lower", registry);
 
-  AddUnaryStringPredicate<IsAscii>("binary_isascii", registry);
+  AddUnaryStringPredicate<IsAscii>("string_isascii", registry);
 
   AddUnaryStringPredicate<IsAlphaNumericAscii>("ascii_isalnum", registry);
   AddUnaryStringPredicate<IsAlphaAscii>("ascii_isalpha", registry);
@@ -956,9 +956,11 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   AddUnaryStringPredicate<IsSpaceAscii>("ascii_isspace", registry);
   AddUnaryStringPredicate<IsTitleAscii>("ascii_istitle", registry);
   AddUnaryStringPredicate<IsUpperAscii>("ascii_isupper", registry);
+
 #ifdef ARROW_WITH_UTF8PROC
   MakeUnaryStringUTF8TransformKernel<UTF8Upper>("utf8_upper", registry);
   MakeUnaryStringUTF8TransformKernel<UTF8Lower>("utf8_lower", registry);
+
   AddUnaryStringPredicate<IsAlphaNumericUnicode>("utf8_isalnum", registry);
   AddUnaryStringPredicate<IsAlphaUnicode>("utf8_isalpha", registry);
   AddUnaryStringPredicate<IsDecimalUnicode>("utf8_isdecimal", registry);
@@ -969,11 +971,10 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   AddUnaryStringPredicate<IsSpaceUnicode>("utf8_isspace", registry);
   AddUnaryStringPredicate<IsTitleUnicode>("utf8_istitle", registry);
   AddUnaryStringPredicate<IsUpperUnicode>("utf8_isupper", registry);
-
 #endif
 
-  AddAsciiLength(registry);
-  AddBinaryContainsExact(registry);
+  AddBinaryLength(registry);
+  AddMatchSubstring(registry);
   AddStrptime(registry);
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index 01a32c71f34..b409b6a05e6 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -61,9 +61,9 @@ static void IsAlphaNumericAscii(benchmark::State& state) {
   UnaryStringBenchmark(state, "ascii_isalnum");
 }
 
-static void BinaryContainsExact(benchmark::State& state) {
-  BinaryContainsExactOptions options("abac");
-  UnaryStringBenchmark(state, "binary_contains_exact", &options);
+static void MatchSubstring(benchmark::State& state) {
+  MatchSubstringOptions options("abac");
+  UnaryStringBenchmark(state, "match_substring", &options);
 }
 
 #ifdef ARROW_WITH_UTF8PROC
@@ -83,7 +83,7 @@ static void IsAlphaNumericUnicode(benchmark::State& state) {
 BENCHMARK(AsciiLower);
 BENCHMARK(AsciiUpper);
 BENCHMARK(IsAlphaNumericAscii);
-BENCHMARK(BinaryContainsExact);
+BENCHMARK(MatchSubstring);
 #ifdef ARROW_WITH_UTF8PROC
 BENCHMARK(Utf8Lower);
 BENCHMARK(Utf8Upper);
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 9ed629c1a05..5268eefc53f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -30,6 +30,8 @@
 namespace arrow {
 namespace compute {
 
+using BinaryTypes =
+    ::testing::Types<BinaryType, LargeBinaryType, StringType, LargeStringType>;
 using StringTypes = ::testing::Types<StringType, LargeStringType>;
 
 // interesting utf8 characters for testing (lower case / upper case):
@@ -40,43 +42,48 @@ using StringTypes = ::testing::Types<StringType, LargeStringType>;
 //  * Ⱥ / ⱥ  (2 to 3 code units)
 
 template <typename TestType>
-class TestStringKernels : public ::testing::Test {
+class BaseTestStringKernels : public ::testing::Test {
  protected:
   using OffsetType = typename TypeTraits<TestType>::OffsetType;
 
   void CheckUnary(std::string func_name, std::string json_input,
                   std::shared_ptr<DataType> out_ty, std::string json_expected,
                   const FunctionOptions* options = nullptr) {
-    CheckScalarUnary(func_name, string_type(), json_input, out_ty, json_expected,
-                     options);
+    CheckScalarUnary(func_name, type(), json_input, out_ty, json_expected, options);
   }
 
-  std::shared_ptr<DataType> string_type() {
-    return TypeTraits<TestType>::type_singleton();
-  }
+  std::shared_ptr<DataType> type() { return TypeTraits<TestType>::type_singleton(); }
 
   std::shared_ptr<DataType> offset_type() {
     return TypeTraits<OffsetType>::type_singleton();
   }
 };
 
-TYPED_TEST_SUITE(TestStringKernels, StringTypes);
+template <typename TestType>
+class TestBinaryKernels : public BaseTestStringKernels<TestType> {};
+
+TYPED_TEST_SUITE(TestBinaryKernels, BinaryTypes);
 
-TYPED_TEST(TestStringKernels, AsciiLength) {
-  this->CheckUnary("ascii_length", R"(["aaa", null, "", "b"])", this->offset_type(),
+TYPED_TEST(TestBinaryKernels, BinaryLength) {
+  this->CheckUnary("binary_length", R"(["aaa", null, "", "b"])", this->offset_type(),
                    "[3, null, 0, 1]");
 }
 
+template <typename TestType>
+class TestStringKernels : public BaseTestStringKernels<TestType> {};
+
+TYPED_TEST_SUITE(TestStringKernels, StringTypes);
+
 TYPED_TEST(TestStringKernels, AsciiUpper) {
-  this->CheckUnary("ascii_upper", "[]", this->string_type(), "[]");
-  this->CheckUnary("ascii_upper", "[\"aAazZæÆ&\", null, \"\", \"bbb\"]",
-                   this->string_type(), "[\"AAAZZæÆ&\", null, \"\", \"BBB\"]");
+  this->CheckUnary("ascii_upper", "[]", this->type(), "[]");
+  this->CheckUnary("ascii_upper", "[\"aAazZæÆ&\", null, \"\", \"bbb\"]", this->type(),
+                   "[\"AAAZZæÆ&\", null, \"\", \"BBB\"]");
 }
 
 TYPED_TEST(TestStringKernels, AsciiLower) {
-  this->CheckUnary("ascii_lower", "[]", this->string_type(), "[]");
-  this->CheckUnary("ascii_lower", "[\"aAazZæÆ&\", null, \"\", \"BBB\"]",
-                   this->string_type(), "[\"aaazzæÆ&\", null, \"\", \"bbb\"]");
+  this->CheckUnary("ascii_lower", "[]", this->type(), "[]");
+  this->CheckUnary("ascii_lower", "[\"aAazZæÆ&\", null, \"\", \"BBB\"]", this->type(),
+                   "[\"aaazzæÆ&\", null, \"\", \"bbb\"]");
 }
 
 TEST(TestStringKernels, LARGE_MEMORY_TEST(Utf8Upper32bitGrowth)) {
@@ -101,46 +108,44 @@ TEST(TestStringKernels, LARGE_MEMORY_TEST(Utf8Upper32bitGrowth)) {
 #ifdef ARROW_WITH_UTF8PROC
 
 TYPED_TEST(TestStringKernels, Utf8Upper) {
-  this->CheckUnary("utf8_upper", "[\"aAazZæÆ&\", null, \"\", \"b\"]", this->string_type(),
+  this->CheckUnary("utf8_upper", "[\"aAazZæÆ&\", null, \"\", \"b\"]", this->type(),
                    "[\"AAAZZÆÆ&\", null, \"\", \"B\"]");
 
   // test varying encoding lenghts and thus changing indices/offsets
-  this->CheckUnary("utf8_upper", "[\"ɑɽⱤoW\", null, \"ıI\", \"b\"]", this->string_type(),
+  this->CheckUnary("utf8_upper", "[\"ɑɽⱤoW\", null, \"ıI\", \"b\"]", this->type(),
                    "[\"ⱭⱤⱤOW\", null, \"II\", \"B\"]");
 
   // ῦ to Υ͂ not supported
-  // this->CheckUnary("utf8_upper", "[\"ῦɐɜʞȿ\"]", this->string_type(),
+  // this->CheckUnary("utf8_upper", "[\"ῦɐɜʞȿ\"]", this->type(),
   // "[\"Υ͂ⱯꞫꞰⱾ\"]");
 
   // test maximum buffer growth
-  this->CheckUnary("utf8_upper", "[\"ɑɑɑɑ\"]", this->string_type(), "[\"ⱭⱭⱭⱭ\"]");
+  this->CheckUnary("utf8_upper", "[\"ɑɑɑɑ\"]", this->type(), "[\"ⱭⱭⱭⱭ\"]");
 
   // Test invalid data
-  auto invalid_input =
-      ArrayFromJSON(this->string_type(), "[\"ɑa\xFFɑ\", \"ɽ\xe1\xbdɽaa\"]");
+  auto invalid_input = ArrayFromJSON(this->type(), "[\"ɑa\xFFɑ\", \"ɽ\xe1\xbdɽaa\"]");
   EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("Invalid UTF8 sequence"),
                                   CallFunction("utf8_upper", {invalid_input}));
 }
 
 TYPED_TEST(TestStringKernels, Utf8Lower) {
-  this->CheckUnary("utf8_lower", "[\"aAazZæÆ&\", null, \"\", \"b\"]", this->string_type(),
+  this->CheckUnary("utf8_lower", "[\"aAazZæÆ&\", null, \"\", \"b\"]", this->type(),
                    "[\"aaazzææ&\", null, \"\", \"b\"]");
 
   // test varying encoding lenghts and thus changing indices/offsets
-  this->CheckUnary("utf8_lower", "[\"ⱭɽⱤoW\", null, \"ıI\", \"B\"]", this->string_type(),
+  this->CheckUnary("utf8_lower", "[\"ⱭɽⱤoW\", null, \"ıI\", \"B\"]", this->type(),
                    "[\"ɑɽɽow\", null, \"ıi\", \"b\"]");
 
   // ῦ to Υ͂ is not supported, but in principle the reverse is, but it would need
   // normalization
-  // this->CheckUnary("utf8_lower", "[\"Υ͂ⱯꞫꞰⱾ\"]", this->string_type(),
+  // this->CheckUnary("utf8_lower", "[\"Υ͂ⱯꞫꞰⱾ\"]", this->type(),
   // "[\"ῦɐɜʞȿ\"]");
 
   // test maximum buffer growth
-  this->CheckUnary("utf8_lower", "[\"ȺȺȺȺ\"]", this->string_type(), "[\"ⱥⱥⱥⱥ\"]");
+  this->CheckUnary("utf8_lower", "[\"ȺȺȺȺ\"]", this->type(), "[\"ⱥⱥⱥⱥ\"]");
 
   // Test invalid data
-  auto invalid_input =
-      ArrayFromJSON(this->string_type(), "[\"Ⱥa\xFFⱭ\", \"Ɽ\xe1\xbdⱤaA\"]");
+  auto invalid_input = ArrayFromJSON(this->type(), "[\"Ⱥa\xFFⱭ\", \"Ɽ\xe1\xbdⱤaA\"]");
   EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("Invalid UTF8 sequence"),
                                   CallFunction("utf8_lower", {invalid_input}));
 }
@@ -160,7 +165,7 @@ TYPED_TEST(TestStringKernels, IsAlphaUnicode) {
 }
 
 TYPED_TEST(TestStringKernels, IsAscii) {
-  this->CheckUnary("binary_isascii", "[\"azAZ~\", null, \"Ɑ\", \"\"]", boolean(),
+  this->CheckUnary("string_isascii", "[\"azAZ~\", null, \"Ɑ\", \"\"]", boolean(),
                    "[true, null, false, true]");
 }
 
@@ -311,23 +316,23 @@ TYPED_TEST(TestStringKernels, IsUpperAscii) {
                    boolean(), "[false, null, false, true, true, false, false]");
 }
 
-TYPED_TEST(TestStringKernels, BinaryContainsExact) {
-  BinaryContainsExactOptions options{"ab"};
-  this->CheckUnary("binary_contains_exact", "[]", boolean(), "[]", &options);
-  this->CheckUnary("binary_contains_exact", R"(["abc", "acb", "cab", null, "bac"])",
-                   boolean(), "[true, false, true, null, false]", &options);
+TYPED_TEST(TestStringKernels, MatchSubstring) {
+  MatchSubstringOptions options{"ab"};
+  this->CheckUnary("match_substring", "[]", boolean(), "[]", &options);
+  this->CheckUnary("match_substring", R"(["abc", "acb", "cab", null, "bac"])", boolean(),
+                   "[true, false, true, null, false]", &options);
 
-  BinaryContainsExactOptions options_repeated{"abab"};
-  this->CheckUnary("binary_contains_exact", R"(["abab", "ab", "cababc", null, "bac"])",
+  MatchSubstringOptions options_repeated{"abab"};
+  this->CheckUnary("match_substring", R"(["abab", "ab", "cababc", null, "bac"])",
                    boolean(), "[true, false, true, null, false]", &options_repeated);
 
   // ARROW-9460
-  BinaryContainsExactOptions options_double_char{"aab"};
-  this->CheckUnary("binary_contains_exact", R"(["aacb", "aab", "ab", "aaab"])", boolean(),
+  MatchSubstringOptions options_double_char{"aab"};
+  this->CheckUnary("match_substring", R"(["aacb", "aab", "ab", "aaab"])", boolean(),
                    "[false, true, false, true]", &options_double_char);
-  BinaryContainsExactOptions options_double_char_2{"bbcaa"};
-  this->CheckUnary("binary_contains_exact", R"(["abcbaabbbcaabccabaab"])", boolean(),
-                   "[true]", &options_double_char_2);
+  MatchSubstringOptions options_double_char_2{"bbcaa"};
+  this->CheckUnary("match_substring", R"(["abcbaabbbcaabccabaab"])", boolean(), "[true]",
+                   &options_double_char_2);
 }
 
 TYPED_TEST(TestStringKernels, Strptime) {
@@ -338,8 +343,7 @@ TYPED_TEST(TestStringKernels, Strptime) {
 }
 
 TYPED_TEST(TestStringKernels, StrptimeDoesNotProvideDefaultOptions) {
-  auto input =
-      ArrayFromJSON(this->string_type(), R"(["2020-05-01", null, "1900-12-11"])");
+  auto input = ArrayFromJSON(this->type(), R"(["2020-05-01", null, "1900-12-11"])");
   ASSERT_RAISES(Invalid, CallFunction("strptime", {input}));
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_validity.cc b/cpp/src/arrow/compute/kernels/scalar_validity.cc
index 8f251a88f27..01366decc51 100644
--- a/cpp/src/arrow/compute/kernels/scalar_validity.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_validity.cc
@@ -37,23 +37,22 @@ struct IsValidOperator {
   static void Call(KernelContext* ctx, const ArrayData& arr, ArrayData* out) {
     DCHECK_EQ(out->offset, 0);
     DCHECK_LE(out->length, arr.length);
-    if (arr.buffers[0] != nullptr) {
-      out->buffers[1] = arr.offset == 0
-                            ? arr.buffers[0]
-                            : SliceBuffer(arr.buffers[0], arr.offset / 8, arr.length / 8);
+    if (arr.null_count != 0 && arr.buffers[0] != nullptr) {
+      // Input has nulls => output is the null (validity) bitmap.
+      // To avoid copying the null bitmap, slice from the starting byte offset
+      // and set the offset to the remaining bit offset.
       out->offset = arr.offset % 8;
+      out->buffers[1] =
+          arr.offset == 0 ? arr.buffers[0]
+                          : SliceBuffer(arr.buffers[0], arr.offset / 8,
+                                        BitUtil::BytesForBits(out->length + out->offset));
       return;
     }
 
-    KERNEL_RETURN_IF_ERROR(ctx, ctx->AllocateBitmap(out->length).Value(&out->buffers[1]));
-
-    if (arr.null_count == 0 || arr.buffers[0] == nullptr) {
-      BitUtil::SetBitsTo(out->buffers[1]->mutable_data(), out->offset, out->length, true);
-      return;
-    }
-
-    CopyBitmap(arr.buffers[0]->data(), arr.offset, arr.length,
-               out->buffers[1]->mutable_data(), out->offset);
+    // Input has no nulls => output is entirely true.
+    KERNEL_ASSIGN_OR_RAISE(out->buffers[1], ctx,
+                           ctx->AllocateBitmap(out->length + out->offset));
+    BitUtil::SetBitsTo(out->buffers[1]->mutable_data(), out->offset, out->length, true);
   }
 };
 
@@ -63,14 +62,15 @@ struct IsNullOperator {
   }
 
   static void Call(KernelContext* ctx, const ArrayData& arr, ArrayData* out) {
-    if (arr.null_count == 0 || arr.buffers[0] == nullptr) {
-      BitUtil::SetBitsTo(out->buffers[1]->mutable_data(), out->offset, out->length,
-                         false);
+    if (arr.null_count != 0 && arr.buffers[0] != nullptr) {
+      // Input has nulls => output is the inverted null (validity) bitmap.
+      InvertBitmap(arr.buffers[0]->data(), arr.offset, arr.length,
+                   out->buffers[1]->mutable_data(), out->offset);
       return;
     }
 
-    InvertBitmap(arr.buffers[0]->data(), arr.offset, arr.length,
-                 out->buffers[1]->mutable_data(), out->offset);
+    // Input has no nulls => output is entirely false.
+    BitUtil::SetBitsTo(out->buffers[1]->mutable_data(), out->offset, out->length, false);
   }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/test_util.cc b/cpp/src/arrow/compute/kernels/test_util.cc
index 19340c923b7..443585da455 100644
--- a/cpp/src/arrow/compute/kernels/test_util.cc
+++ b/cpp/src/arrow/compute/kernels/test_util.cc
@@ -34,7 +34,9 @@ namespace compute {
 void CheckScalarUnary(std::string func_name, std::shared_ptr<Array> input,
                       std::shared_ptr<Array> expected, const FunctionOptions* options) {
   ASSERT_OK_AND_ASSIGN(Datum out, CallFunction(func_name, {input}, options));
-  AssertArraysEqual(*expected, *out.make_array(), /*verbose=*/true);
+  std::shared_ptr<Array> actual = std::move(out).make_array();
+  ASSERT_OK(actual->ValidateFull());
+  AssertArraysEqual(*expected, *actual, /*verbose=*/true);
 
   // Check all the scalars
   for (int64_t i = 0; i < input->length(); ++i) {
@@ -44,6 +46,7 @@ void CheckScalarUnary(std::string func_name, std::shared_ptr<Array> input,
   }
 
   if (auto length = input->length() / 3) {
+    // XXX Is the recursive call intended?
     CheckScalarUnary(func_name, input->Slice(0, length), expected->Slice(0, length),
                      options);
 
diff --git a/cpp/src/arrow/compute/kernels/vector_nested_test.cc b/cpp/src/arrow/compute/kernels/vector_nested_test.cc
index 906772a0693..0ddcc431ac4 100644
--- a/cpp/src/arrow/compute/kernels/vector_nested_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_nested_test.cc
@@ -30,7 +30,9 @@ TEST(TestVectorNested, ListFlatten) {
     auto input = ArrayFromJSON(ty, "[[0, null, 1], null, [2, 3], []]");
     auto expected = ArrayFromJSON(int32(), "[0, null, 1, 2, 3]");
     ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("list_flatten", {input}));
-    AssertArraysEqual(*expected, *out.make_array());
+    std::shared_ptr<Array> actual = std::move(out).make_array();
+    ASSERT_OK(actual->ValidateFull());
+    AssertArraysEqual(*expected, *actual);
   }
 }
 
@@ -41,7 +43,9 @@ TEST(TestVectorNested, ListParentIndices) {
     auto out_ty = ty->id() == Type::LIST ? int32() : int64();
     auto expected = ArrayFromJSON(out_ty, "[0, 0, 0, 2, 2, 4, 4]");
     ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("list_parent_indices", {input}));
-    AssertArraysEqual(*expected, *out.make_array());
+    std::shared_ptr<Array> actual = std::move(out).make_array();
+    ASSERT_OK(actual->ValidateFull());
+    AssertArraysEqual(*expected, *actual);
   }
 
   // Construct a list with non-empty null slots
@@ -51,7 +55,9 @@ TEST(TestVectorNested, ListParentIndices) {
       (ArrayFromJSON(boolean(), "[true, false, true, true, true]")->data()->buffers[1]);
   auto expected = ArrayFromJSON(int32(), "[0, 0, 0, 1, 1, 2, 2, 4, 4]");
   ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("list_parent_indices", {data}));
-  AssertArraysEqual(*expected, *out.make_array());
+  std::shared_ptr<Array> actual = std::move(out).make_array();
+  ASSERT_OK(actual->ValidateFull());
+  AssertArraysEqual(*expected, *actual);
 }
 
 }  // namespace compute
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_test.cc b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
index 7210c7115ef..47c8d5b7a32 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
@@ -168,6 +168,7 @@ class TestFilterKernel : public ::testing::Test {
     expected = out_datum.make_array();
     ASSERT_OK_AND_ASSIGN(out_datum, Filter(values, filter, drop_));
     actual = out_datum.make_array();
+    ASSERT_OK(actual->ValidateFull());
     AssertArraysEqual(*expected, *actual);
   }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 220b3ae938d..c8c1b109230 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -30,10 +30,10 @@ namespace compute {
 namespace {
 
 // ----------------------------------------------------------------------
-// partition_indices implementation
+// partition_nth_indices implementation
 
 // We need to preserve the options
-using PartitionIndicesState = internal::OptionsWrapper<PartitionOptions>;
+using PartitionNthToIndicesState = internal::OptionsWrapper<PartitionNthOptions>;
 
 Status GetPhysicalView(const std::shared_ptr<ArrayData>& arr,
                        const std::shared_ptr<DataType>& type,
@@ -47,11 +47,11 @@ Status GetPhysicalView(const std::shared_ptr<ArrayData>& arr,
 }
 
 template <typename OutType, typename InType>
-struct PartitionIndices {
+struct PartitionNthToIndices {
   using ArrayType = typename TypeTraits<InType>::ArrayType;
   static void Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     if (ctx->state() == nullptr) {
-      ctx->SetStatus(Status::Invalid("NthToIndices requires PartitionOptions"));
+      ctx->SetStatus(Status::Invalid("NthToIndices requires PartitionNthOptions"));
       return;
     }
 
@@ -61,7 +61,7 @@ struct PartitionIndices {
         GetPhysicalView(batch[0].array(), TypeTraits<InType>::type_singleton(), &arg0));
     ArrayType arr(arg0);
 
-    int64_t pivot = PartitionIndicesState::Get(ctx).pivot;
+    int64_t pivot = PartitionNthToIndicesState::Get(ctx).pivot;
     if (pivot > arr.length()) {
       ctx->SetStatus(Status::IndexError("NthToIndices index out of bound"));
       return;
@@ -312,11 +312,11 @@ void RegisterVectorSort(FunctionRegistry* registry) {
   AddSortingKernels<SortIndices>(base, sort_indices.get());
   DCHECK_OK(registry->AddFunction(std::move(sort_indices)));
 
-  // partition_indices has a parameter so needs its init function
+  // partition_nth_indices has a parameter so needs its init function
   auto part_indices =
-      std::make_shared<VectorFunction>("partition_indices", Arity::Unary());
-  base.init = PartitionIndicesState::Init;
-  AddSortingKernels<PartitionIndices>(base, part_indices.get());
+      std::make_shared<VectorFunction>("partition_nth_indices", Arity::Unary());
+  base.init = PartitionNthToIndicesState::Init;
+  AddSortingKernels<PartitionNthToIndices>(base, part_indices.get());
   DCHECK_OK(registry->AddFunction(std::move(part_indices)));
 }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
index f05f48546c1..d5bc8a23792 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -113,7 +113,7 @@ TYPED_TEST_SUITE(TestNthToIndicesForStrings, testing::Types<StringType>);
 
 TYPED_TEST(TestNthToIndicesForReal, NthToIndicesDoesNotProvideDefaultOptions) {
   auto input = ArrayFromJSON(this->type_singleton(), "[null, 1, 3.3, null, 2, 5.3]");
-  ASSERT_RAISES(Invalid, CallFunction("partition_indices", {input}));
+  ASSERT_RAISES(Invalid, CallFunction("partition_nth_indices", {input}));
 }
 
 TYPED_TEST(TestNthToIndicesForReal, Real) {
@@ -308,6 +308,7 @@ using SortToIndicesableTypes =
 
 template <typename ArrayType>
 void ValidateSorted(const ArrayType& array, UInt64Array& offsets) {
+  ASSERT_OK(array.ValidateFull());
   SortComparator<ArrayType> compare;
   for (int i = 1; i < array.length(); i++) {
     uint64_t lhs = offsets.Value(i - 1);
diff --git a/cpp/src/arrow/dataset/partition.cc b/cpp/src/arrow/dataset/partition.cc
index 2a2ecdf483d..5f94e38ae81 100644
--- a/cpp/src/arrow/dataset/partition.cc
+++ b/cpp/src/arrow/dataset/partition.cc
@@ -178,7 +178,7 @@ Result<std::shared_ptr<Expression>> KeyValuePartitioning::ConvertKey(
 
     // look up the partition value in the dictionary
     ARROW_ASSIGN_OR_RAISE(converted, Scalar::Parse(value.dictionary->type(), key.value));
-    ARROW_ASSIGN_OR_RAISE(auto index, compute::Match(converted, value.dictionary));
+    ARROW_ASSIGN_OR_RAISE(auto index, compute::IndexIn(converted, value.dictionary));
     value.index = index.scalar();
     if (!value.index->is_valid) {
       return Status::Invalid("Dictionary supplied for field ", field->ToString(),
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index eea4e86d27c..f6fd4dd9b2e 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -241,6 +241,7 @@ struct TypeTraits<BinaryType> {
   using ArrayType = BinaryArray;
   using BuilderType = BinaryBuilder;
   using ScalarType = BinaryScalar;
+  using OffsetType = Int32Type;
   constexpr static bool is_parameter_free = true;
   static inline std::shared_ptr<DataType> type_singleton() { return binary(); }
 };
@@ -250,6 +251,7 @@ struct TypeTraits<LargeBinaryType> {
   using ArrayType = LargeBinaryArray;
   using BuilderType = LargeBinaryBuilder;
   using ScalarType = LargeBinaryScalar;
+  using OffsetType = Int64Type;
   constexpr static bool is_parameter_free = true;
   static inline std::shared_ptr<DataType> type_singleton() { return large_binary(); }
 };
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 149dbb39e7f..1d976be5676 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -86,16 +86,16 @@ exact semantics of the function::
    options.null_handling = MinMaxOptions::OUTPUT_NULL;
 
    std::shared_ptr<arrow::Array> array = ...;
-   arrow::Datum minmax_datum;
+   arrow::Datum min_max_datum;
 
-   ARROW_ASSIGN_OR_RAISE(minmax_datum,
-                         arrow::compute::CallFunction("minmax", {array}, &options));
+   ARROW_ASSIGN_OR_RAISE(min_max_datum,
+                         arrow::compute::CallFunction("min_max", {array}, &options));
 
    // Unpack struct scalar result (a two-field {"min", "max"} scalar)
-   const auto& minmax_scalar = \
-         static_cast<const arrow::StructScalar&>(*minmax_datum.scalar());
-   const auto min_value = minmax_scalar.value[0];
-   const auto max_value = minmax_scalar.value[1];
+   const auto& min_max_scalar = \
+         static_cast<const arrow::StructScalar&>(*min_max_datum.scalar());
+   const auto min_value = min_max_scalar.value[0];
+   const auto max_value = min_max_scalar.value[1];
 
 .. seealso::
    :doc:`Compute API reference <api/compute>`
@@ -136,7 +136,7 @@ Aggregations
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
 | mean                     | Unary      | Numeric            | Scalar Float64        |                                            |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
-| minmax                   | Unary      | Numeric            | Scalar Struct  (1)    | :struct:`MinMaxOptions`                    |
+| min_max                  | Unary      | Numeric            | Scalar Struct  (1)    | :struct:`MinMaxOptions`                    |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
 | sum                      | Unary      | Numeric            | Scalar Numeric (2)    |                                            |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
@@ -248,57 +248,140 @@ For the Kleene logic variants, therefore:
 
 .. _Kleene logic: https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics
 
-String functions
-~~~~~~~~~~~~~~~~
+String predicates
+~~~~~~~~~~~~~~~~~
+
+These functions classify the input string elements according to their character
+contents.  An empty string element emits false in the output.  For ASCII
+variants of the functions (prefixed ``ascii_``), a string element with non-ASCII
+characters emits false in the output.
+
+The first set of functions operates on a character-per-character basis,
+and emit true in the output if the input contains only characters of a
+given class:
+
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| Function name            | Arity      | Input types        | Output type    | Matched character class          |
++==========================+============+====================+================+==================================+
+| ascii_isalnum            | Unary      | String-like        | Boolean        | Alphanumeric ASCII               |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| ascii_isalpha            | Unary      | String-like        | Boolean        | Alphabetic ASCII                 |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| ascii_isdecimal          | Unary      | String-like        | Boolean        | Decimal ASCII \(1)               |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| ascii_islower            | Unary      | String-like        | Boolean        | Lowercase ASCII \(2)             |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| ascii_isprintable        | Unary      | String-like        | Boolean        | Printable ASCII                  |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| ascii_isspace            | Unary      | String-like        | Boolean        | Whitespace ASCII                 |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| ascii_isupper            | Unary      | String-like        | Boolean        | Uppercase ASCII \(2)             |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_isalnum             | Unary      | String-like        | Boolean        | Alphanumeric Unicode             |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_isalpha             | Unary      | String-like        | Boolean        | Alphabetic Unicode               |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_isdecimal           | Unary      | String-like        | Boolean        | Decimal Unicode                  |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_isdigit             | Unary      | String-like        | Boolean        | Unicode digit \(3)               |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_islower             | Unary      | String-like        | Boolean        | Lowercase Unicode \(2)           |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_isnumeric           | Unary      | String-like        | Boolean        | Numeric Unicode \(4)             |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_isprintable         | Unary      | String-like        | Boolean        | Printable Unicode                |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_isspace             | Unary      | String-like        | Boolean        | Whitespace Unicode               |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+| utf8_isupper             | Unary      | String-like        | Boolean        | Uppercase Unicode \(2)           |
++--------------------------+------------+--------------------+----------------+----------------------------------+
+
+* \(1) Also matches all numeric ASCII characters and all ASCII digits.
+
+* \(2) Non-cased characters, such as punctuation, do not match.
+
+* \(3) This is currently the same as ``utf8_isdecimal``.
+
+* \(4) Unlike ``utf8_isdecimal``, non-decimal numeric characters also match.
+
+The second set of functions also consider the character order in a string
+element:
 
 +--------------------------+------------+--------------------+---------------------+---------+
 | Function name            | Arity      | Input types        | Output type         | Notes   |
 +==========================+============+====================+=====================+=========+
-| ascii_length             | Unary      | String-like        | Int32 or Int64      | \(1)    |
+| ascii_istitle            | Unary      | String-like        | Boolean             | \(1)    |
 +--------------------------+------------+--------------------+---------------------+---------+
-| ascii_lower              | Unary      | String-like        | String-like         | \(2)    |
+| utf8_istitle             | Unary      | String-like        | Boolean             | \(1)    |
 +--------------------------+------------+--------------------+---------------------+---------+
-| ascii_upper              | Unary      | String-like        | String-like         | \(2)    |
-+--------------------------+------------+--------------------+---------------------+---------+
-| utf8_lower               | Unary      | String-like        | String-like         | \(3)    |
+
+* \(1) Output is true iff the input string element is title-cased, i.e. any
+  word starts with an uppercase character, followed by lowercase characters.
+  Word boundaries are defined by non-cased characters.
+
+The third set of functions examines string elements on a byte-per-byte basis:
+
 +--------------------------+------------+--------------------+---------------------+---------+
-| utf8_upper               | Unary      | String-like        | String-like         | \(3)    |
+| Function name            | Arity      | Input types        | Output type         | Notes   |
++==========================+============+====================+=====================+=========+
+| string_isascii           | Unary      | String-like        | Boolean             | \(1)    |
 +--------------------------+------------+--------------------+---------------------+---------+
 
-* \(1) Output is the physical length in bytes of each input element.  Output
-  type is Int32 for String, Int64 for LargeString.
+* \(1) Output is true iff the input string element contains only ASCII characters,
+  i.e. only bytes in [0, 127].
 
-* \(2) Each ASCII character in the input is converted to lowercase or
+String transforms
+~~~~~~~~~~~~~~~~~
+
++--------------------------+------------+-------------------------+---------------------+---------+
+| Function name            | Arity      | Input types             | Output type         | Notes   |
++==========================+============+=========================+=====================+=========+
+| ascii_lower              | Unary      | String-like             | String-like         | \(1)    |
++--------------------------+------------+-------------------------+---------------------+---------+
+| ascii_upper              | Unary      | String-like             | String-like         | \(1)    |
++--------------------------+------------+-------------------------+---------------------+---------+
+| binary_length            | Unary      | Binary- or String-like  | Int32 or Int64      | \(2)    |
++--------------------------+------------+-------------------------+---------------------+---------+
+| utf8_lower               | Unary      | String-like             | String-like         | \(3)    |
++--------------------------+------------+-------------------------+---------------------+---------+
+| utf8_upper               | Unary      | String-like             | String-like         | \(3)    |
++--------------------------+------------+-------------------------+---------------------+---------+
+
+
+* \(1) Each ASCII character in the input is converted to lowercase or
   uppercase.  Non-ASCII characters are left untouched.
 
+* \(2) Output is the physical length in bytes of each input element.  Output
+  type is Int32 for Binary / String, Int64 for LargeBinary / LargeString.
+
 * \(3) Each UTF8-encoded character in the input is converted to lowercase or
   uppercase.
 
 Containment tests
 ~~~~~~~~~~~~~~~~~
 
-+--------------------------+------------+------------------------------------+---------------+----------------------------------------+
-| Function name            | Arity      | Input types                        | Output type   | Options class                          |
-+==========================+============+====================================+===============+========================================+
-| binary_contains_exact    | Unary      | String-like                        | Boolean (1)   | :struct:`BinaryContainsExactOptions`   |
-+--------------------------+------------+------------------------------------+---------------+----------------------------------------+
-| isin                     | Unary      | Boolean, Null, Numeric, Temporal,  | Boolean (2)   | :struct:`SetLookupOptions`             |
-|                          |            | Binary- and String-like            |               |                                        |
-+--------------------------+------------+------------------------------------+---------------+----------------------------------------+
-| match                    | Unary      | Boolean, Null, Numeric, Temporal,  | Int32 (3)     | :struct:`SetLookupOptions`             |
-|                          |            | Binary- and String-like            |               |                                        |
-+--------------------------+------------+------------------------------------+---------------+----------------------------------------+
-
-* \(1) Output is true iff :member:`BinaryContainsExactOptions::pattern`
++--------------------+------------+------------------------------------+---------------+----------------------------------------+
+| Function name      | Arity      | Input types                        | Output type   | Options class                          |
++====================+============+====================================+===============+========================================+
+| match_substring    | Unary      | String-like                        | Boolean (1)   | :struct:`MatchSubstringOptions`        |
++--------------------+------------+------------------------------------+---------------+----------------------------------------+
+| index_in           | Unary      | Boolean, Null, Numeric, Temporal,  | Int32 (2)     | :struct:`SetLookupOptions`             |
+|                    |            | Binary- and String-like            |               |                                        |
++--------------------+------------+------------------------------------+---------------+----------------------------------------+
+| is_in              | Unary      | Boolean, Null, Numeric, Temporal,  | Boolean (3)   | :struct:`SetLookupOptions`             |
+|                    |            | Binary- and String-like            |               |                                        |
++--------------------+------------+------------------------------------+---------------+----------------------------------------+
+
+* \(1) Output is true iff :member:`MatchSubstringOptions::pattern`
   is a substring of the corresponding input element.
 
-* \(2) Output is true iff the corresponding input element is equal to one
-  of the elements in :member:`SetLookupOptions::value_set`.
-
-* \(3) Output is the index of the corresponding input element in
+* \(2) Output is the index of the corresponding input element in
   :member:`SetLookupOptions::value_set`, if found there.  Otherwise,
   output is null.
 
+* \(3) Output is true iff the corresponding input element is equal to one
+  of the elements in :member:`SetLookupOptions::value_set`.
+
 Structural transforms
 ~~~~~~~~~~~~~~~~~~~~~
 
@@ -313,7 +396,7 @@ Structural transforms
 +--------------------------+------------+---------------------------------------+---------------------+---------+
 | is_valid                 | Unary      | Any                                   | Boolean             | \(2)    |
 +--------------------------+------------+---------------------------------------+---------------------+---------+
-| list_value_lengths       | Unary      | List-like                             | Int32 or Int64      | \(4)    |
+| list_value_length        | Unary      | List-like                             | Int32 or Int64      | \(4)    |
 +--------------------------+------------+---------------------------------------+---------------------+---------+
 
 * \(1) First input must be an array, second input a scalar of the same type.
@@ -486,9 +569,9 @@ In these functions, nulls are considered greater than any other value
 +-----------------------+------------+-------------------------+-------------------+--------------------------------+-------------+
 | Function name         | Arity      | Input types             | Output type       | Options class                  | Notes       |
 +=======================+============+=========================+===================+================================+=============+
-| partition_indices     | Unary      | Binary- and String-like | UInt64            | :struct:`PartitionOptions`     | \(1) \(3)   |
+| partition_nth_indices | Unary      | Binary- and String-like | UInt64            | :struct:`PartitionNthOptions`  | \(1) \(3)   |
 +-----------------------+------------+-------------------------+-------------------+--------------------------------+-------------+
-| partition_indices     | Unary      | Numeric                 | UInt64            | :struct:`PartitionOptions`     | \(1)        |
+| partition_nth_indices | Unary      | Numeric                 | UInt64            | :struct:`PartitionNthOptions`  | \(1)        |
 +-----------------------+------------+-------------------------+-------------------+--------------------------------+-------------+
 | sort_indices          | Unary      | Binary- and String-like | UInt64            |                                | \(2) \(3)   |
 +-----------------------+------------+-------------------------+-------------------+--------------------------------+-------------+
@@ -496,8 +579,11 @@ In these functions, nulls are considered greater than any other value
 +-----------------------+------------+-------------------------+-------------------+--------------------------------+-------------+
 
 * \(1) The output is an array of indices into the input array, that define
-  a partition around the *N*'th input array element in sorted order.  *N* is
-  given in :member:`PartitionOptions::pivot`.
+  a partial sort such that the *N*'th index points to the *N*'th element
+  in sorted order, and all indices before the *N*'th point to elements
+  less or equal to elements at or after the *N*'th (similar to
+  :func:`std::nth_element`).  *N* is given in
+  :member:`PartitionNthOptions::pivot`.
 
 * \(2) The output is an array of indices into the input array, that define
   a non-stable sort of the input array.
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 5bbad65edd2..b97e347f219 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -260,7 +260,8 @@ cdef _pack_compute_args(object values, vector[CDatum]* out):
         elif isinstance(val, Table):
             out.push_back(CDatum((<Table> val).sp_table))
         else:
-            raise TypeError(type(val))
+            raise TypeError("Got unexpected argument type {} "
+                            "for compute function".format(type(val)))
 
 
 cdef class FunctionRegistry:
@@ -399,16 +400,16 @@ cdef class CastOptions(FunctionOptions):
         self.options.allow_invalid_utf8 = flag
 
 
-cdef class BinaryContainsExactOptions(FunctionOptions):
+cdef class MatchSubstringOptions(FunctionOptions):
     cdef:
-        unique_ptr[CBinaryContainsExactOptions] binary_contains_exact_options
+        unique_ptr[CMatchSubstringOptions] match_substring_options
 
     def __init__(self, pattern):
-        self.binary_contains_exact_options.reset(
-            new CBinaryContainsExactOptions(tobytes(pattern)))
+        self.match_substring_options.reset(
+            new CMatchSubstringOptions(tobytes(pattern)))
 
     cdef const CFunctionOptions* get_options(self) except NULL:
-        return self.binary_contains_exact_options.get()
+        return self.match_substring_options.get()
 
 
 cdef class FilterOptions(FunctionOptions):
diff --git a/python/pyarrow/array.pxi b/python/pyarrow/array.pxi
index 1dcff02d685..3d5dd7d482c 100644
--- a/python/pyarrow/array.pxi
+++ b/python/pyarrow/array.pxi
@@ -1515,7 +1515,7 @@ cdef class BaseListArray(Array):
           1
         ]
         """
-        return _pc().list_value_lengths(self)
+        return _pc().list_value_length(self)
 
 
 cdef class ListArray(BaseListArray):
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index b8e678ffdac..70a0e764de3 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -24,6 +24,7 @@
     call_function,
     TakeOptions
 )
+
 import pyarrow as pa
 import pyarrow._compute as _pc
 
@@ -86,25 +87,30 @@ def cast(arr, target_type, safe=True):
     return call_function("cast", [arr], options)
 
 
+def _decorate_compute_function(func, name, *, arity):
+    func.__arrow_compute_function__ = dict(name=name, arity=arity)
+    return func
+
+
 def _simple_unary_function(name):
     def func(arg):
         return call_function(name, [arg])
-    return func
+    return _decorate_compute_function(func, name, arity=1)
 
 
 def _simple_binary_function(name):
     def func(left, right):
         return call_function(name, [left, right])
-    return func
+    return _decorate_compute_function(func, name, arity=2)
 
 
-ascii_length = _simple_unary_function('ascii_length')
+binary_length = _simple_unary_function('binary_length')
 ascii_upper = _simple_unary_function('ascii_upper')
 ascii_lower = _simple_unary_function('ascii_lower')
 utf8_upper = _simple_unary_function('utf8_upper')
 utf8_lower = _simple_unary_function('utf8_lower')
 
-binary_isascii = _simple_unary_function('binary_isascii')
+string_isascii = _simple_unary_function('string_isascii')
 
 ascii_isalnum = _simple_unary_function('ascii_isalnum')
 utf8_isalnum = _simple_unary_function('utf8_isalnum')
@@ -130,7 +136,7 @@ def func(left, right):
 
 list_flatten = _simple_unary_function('list_flatten')
 list_parent_indices = _simple_unary_function('list_parent_indices')
-list_value_lengths = _simple_unary_function('list_value_lengths')
+list_value_length = _simple_unary_function('list_value_length')
 
 add = _simple_binary_function('add')
 subtract = _simple_binary_function('subtract')
@@ -144,9 +150,9 @@ def func(left, right):
 less_equal = _simple_binary_function('less_equal')
 
 
-def binary_contains_exact(array, pattern):
+def match_substring(array, pattern):
     """
-    Test if pattern is contained within a value of a binary array.
+    Test if substring *pattern* is contained within a value of a string array.
 
     Parameters
     ----------
@@ -158,8 +164,8 @@ def binary_contains_exact(array, pattern):
     -------
     result : pyarrow.Array or pyarrow.ChunkedArray
     """
-    return call_function("binary_contains_exact", [array],
-                         _pc.BinaryContainsExactOptions(pattern))
+    return call_function("match_substring", [array],
+                         _pc.MatchSubstringOptions(pattern))
 
 
 def sum(array):
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index c8e7c5b6263..41b1abe1fb9 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1669,9 +1669,9 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
 
     CFunctionRegistry* GetFunctionRegistry()
 
-    cdef cppclass CBinaryContainsExactOptions \
-            "arrow::compute::BinaryContainsExactOptions"(CFunctionOptions):
-        CBinaryContainsExactOptions(c_string pattern)
+    cdef cppclass CMatchSubstringOptions \
+            "arrow::compute::MatchSubstringOptions"(CFunctionOptions):
+        CMatchSubstringOptions(c_string pattern)
         c_string pattern
 
     cdef cppclass CCastOptions" arrow::compute::CastOptions"(CFunctionOptions):
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index fb3eea282ba..5f8c445162f 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -45,6 +45,11 @@
 ]
 
 
+exported_functions = [
+    func for (name, func) in sorted(pc.__dict__.items())
+    if hasattr(func, '__arrow_compute_function__')]
+
+
 numerical_arrow_types = [
     pa.int8(),
     pa.int16(),
@@ -57,6 +62,21 @@
 ]
 
 
+def test_exported_functions():
+    # Check that all exported concrete functions can be called with
+    # the right number of arguments.
+    # Note that unregistered functions (e.g. with a mismatching name)
+    # will raise KeyError.
+    functions = exported_functions
+    assert len(functions) >= 10
+    for func in functions:
+        args = [None] * func.__arrow_compute_function__['arity']
+        with pytest.raises(TypeError,
+                           match="Got unexpected argument type "
+                                 "<class 'NoneType'> for compute function"):
+            func(*args)
+
+
 @pytest.mark.parametrize('arrow_type', numerical_arrow_types)
 def test_sum_array(arrow_type):
     arr = pa.array([1, 2, 3, 4], type=arrow_type)
@@ -89,9 +109,9 @@ def test_sum_chunked_array(arrow_type):
     assert pc.sum(arr).as_py() is None  # noqa: E711
 
 
-def test_binary_contains_exact():
+def test_match_substring():
     arr = pa.array(["ab", "abc", "ba", None])
-    result = pc.binary_contains_exact(arr, "ab")
+    result = pc.match_substring(arr, "ab")
     expected = pa.array([True, True, False, None])
     assert expected.equals(result)
 
diff --git a/r/R/compute.R b/r/R/compute.R
index f28c53a6b01..f242a58e854 100644
--- a/r/R/compute.R
+++ b/r/R/compute.R
@@ -44,12 +44,12 @@ mean.Scalar <- mean.Array
 
 #' @export
 min.Array <- function(..., na.rm = FALSE) {
-  scalar_aggregate("minmax", ..., na.rm = na.rm)$GetFieldByName("min")
+  scalar_aggregate("min_max", ..., na.rm = na.rm)$GetFieldByName("min")
 }
 
 #' @export
 max.Array <- function(..., na.rm = FALSE) {
-  scalar_aggregate("minmax", ..., na.rm = na.rm)$GetFieldByName("max")
+  scalar_aggregate("min_max", ..., na.rm = na.rm)$GetFieldByName("max")
 }
 
 scalar_aggregate <- function(FUN, ..., na.rm = FALSE) {
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 368521102c1..8d185220dd0 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -160,7 +160,7 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
     return out;
   }
 
-  if (func_name == "minmax") {
+  if (func_name == "min_max") {
     using Options = arrow::compute::MinMaxOptions;
     auto out = std::make_shared<Options>(Options::Defaults());
     out->null_handling = options["na.rm"] ? Options::SKIP : Options::OUTPUT_NULL;

From 8df28707dd722ebdb16305421361c8ceadc73310 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 14 Jul 2020 16:24:00 +0200
Subject: [PATCH 2/3] Hopefully fix CI failure

---
 cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc | 2 --
 cpp/src/arrow/compute/kernels/scalar_string_test.cc     | 4 ----
 cpp/src/arrow/compute/kernels/test_util.h               | 5 +++--
 cpp/src/arrow/compute/kernels/vector_hash_test.cc       | 2 +-
 cpp/src/arrow/compute/kernels/vector_selection_test.cc  | 7 ++-----
 5 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
index e1540d15b1f..bd1a481eefe 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
@@ -253,7 +253,6 @@ TEST_F(TestIsInKernel, IsInBoolean) {
                                {});
 }
 
-using BinaryTypes = ::testing::Types<BinaryType, StringType>;
 TYPED_TEST_SUITE(TestIsInKernelBinary, BinaryTypes);
 
 TYPED_TEST(TestIsInKernelBinary, IsInBinary) {
@@ -596,7 +595,6 @@ TEST_F(TestMatchKernel, MatchBoolean) {
 template <typename Type>
 class TestMatchKernelBinary : public TestMatchKernel {};
 
-using BinaryTypes = ::testing::Types<BinaryType, StringType>;
 TYPED_TEST_SUITE(TestMatchKernelBinary, BinaryTypes);
 
 TYPED_TEST(TestMatchKernelBinary, MatchBinary) {
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 5268eefc53f..0a714f5f6b0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -30,10 +30,6 @@
 namespace arrow {
 namespace compute {
 
-using BinaryTypes =
-    ::testing::Types<BinaryType, LargeBinaryType, StringType, LargeStringType>;
-using StringTypes = ::testing::Types<StringType, LargeStringType>;
-
 // interesting utf8 characters for testing (lower case / upper case):
 //  * ῦ / Υ͂ (3 to 4 code units) (Note, we don't support this yet, utf8proc does not use
 //  SpecialCasing.txt)
diff --git a/cpp/src/arrow/compute/kernels/test_util.h b/cpp/src/arrow/compute/kernels/test_util.h
index 206f1aa4576..b8e176bf34d 100644
--- a/cpp/src/arrow/compute/kernels/test_util.h
+++ b/cpp/src/arrow/compute/kernels/test_util.h
@@ -103,8 +103,9 @@ void CheckScalarUnary(std::string func_name, std::shared_ptr<Scalar> input,
                       std::shared_ptr<Scalar> expected,
                       const FunctionOptions* options = nullptr);
 
-using TestingStringTypes =
-    ::testing::Types<StringType, LargeStringType, BinaryType, LargeBinaryType>;
+using BinaryTypes =
+    ::testing::Types<BinaryType, LargeBinaryType, StringType, LargeStringType>;
+using StringTypes = ::testing::Types<StringType, LargeStringType>;
 
 static constexpr random::SeedType kRandomSeed = 0x0ff1ce;
 
diff --git a/cpp/src/arrow/compute/kernels/vector_hash_test.cc b/cpp/src/arrow/compute/kernels/vector_hash_test.cc
index 7641861b0f1..e451ce61c37 100644
--- a/cpp/src/arrow/compute/kernels/vector_hash_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_hash_test.cc
@@ -359,7 +359,7 @@ class TestHashKernelBinaryTypes : public TestHashKernel {
   }
 };
 
-TYPED_TEST_SUITE(TestHashKernelBinaryTypes, TestingStringTypes);
+TYPED_TEST_SUITE(TestHashKernelBinaryTypes, BinaryTypes);
 
 TYPED_TEST(TestHashKernelBinaryTypes, ZeroChunks) {
   auto type = this->type();
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_test.cc b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
index 47c8d5b7a32..59c311f0115 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
@@ -430,9 +430,6 @@ TEST(TestFilterKernel, NoValidityBitmapButUnknownNullCount) {
   AssertArraysEqual(*expected, *result);
 }
 
-using StringTypes =
-    ::testing::Types<BinaryType, StringType, LargeBinaryType, LargeStringType>;
-
 template <typename TypeClass>
 class TestFilterKernelWithString : public TestFilterKernel<TypeClass> {
  protected:
@@ -464,7 +461,7 @@ class TestFilterKernelWithString : public TestFilterKernel<TypeClass> {
   }
 };
 
-TYPED_TEST_SUITE(TestFilterKernelWithString, StringTypes);
+TYPED_TEST_SUITE(TestFilterKernelWithString, BinaryTypes);
 
 TYPED_TEST(TestFilterKernelWithString, FilterString) {
   this->AssertFilter(R"(["a", "b", "c"])", "[0, 1, 0]", R"(["b"])");
@@ -1028,7 +1025,7 @@ class TestTakeKernelWithString : public TestTakeKernel<TypeClass> {
   }
 };
 
-TYPED_TEST_SUITE(TestTakeKernelWithString, TestingStringTypes);
+TYPED_TEST_SUITE(TestTakeKernelWithString, BinaryTypes);
 
 TYPED_TEST(TestTakeKernelWithString, TakeString) {
   this->AssertTake(R"(["a", "b", "c"])", "[0, 1, 0]", R"(["a", "b", "a"])");

From 762dc8e0a5443f7e0c4a35d47986db434885232c Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 14 Jul 2020 17:02:05 +0200
Subject: [PATCH 3/3] Address review comments

---
 .../arrow/compute/kernels/scalar_validity.cc  |  4 +-
 cpp/src/arrow/compute/kernels/test_util.cc    | 52 ++++++++++++++-----
 cpp/src/arrow/compute/kernels/test_util.h     |  3 ++
 .../arrow/compute/kernels/vector_hash_test.cc |  1 -
 .../compute/kernels/vector_nested_test.cc     | 15 ++----
 5 files changed, 46 insertions(+), 29 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_validity.cc b/cpp/src/arrow/compute/kernels/scalar_validity.cc
index 01366decc51..5d98d1a3d5a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_validity.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_validity.cc
@@ -37,7 +37,7 @@ struct IsValidOperator {
   static void Call(KernelContext* ctx, const ArrayData& arr, ArrayData* out) {
     DCHECK_EQ(out->offset, 0);
     DCHECK_LE(out->length, arr.length);
-    if (arr.null_count != 0 && arr.buffers[0] != nullptr) {
+    if (arr.MayHaveNulls()) {
       // Input has nulls => output is the null (validity) bitmap.
       // To avoid copying the null bitmap, slice from the starting byte offset
       // and set the offset to the remaining bit offset.
@@ -62,7 +62,7 @@ struct IsNullOperator {
   }
 
   static void Call(KernelContext* ctx, const ArrayData& arr, ArrayData* out) {
-    if (arr.null_count != 0 && arr.buffers[0] != nullptr) {
+    if (arr.MayHaveNulls()) {
       // Input has nulls => output is the inverted null (validity) bitmap.
       InvertBitmap(arr.buffers[0]->data(), arr.offset, arr.length,
                    out->buffers[1]->mutable_data(), out->offset);
diff --git a/cpp/src/arrow/compute/kernels/test_util.cc b/cpp/src/arrow/compute/kernels/test_util.cc
index 443585da455..dcc7c2d7478 100644
--- a/cpp/src/arrow/compute/kernels/test_util.cc
+++ b/cpp/src/arrow/compute/kernels/test_util.cc
@@ -31,39 +31,55 @@
 namespace arrow {
 namespace compute {
 
-void CheckScalarUnary(std::string func_name, std::shared_ptr<Array> input,
-                      std::shared_ptr<Array> expected, const FunctionOptions* options) {
+namespace {
+
+void CheckScalarUnaryNonRecursive(const std::string& func_name,
+                                  const std::shared_ptr<Array>& input,
+                                  const std::shared_ptr<Array>& expected,
+                                  const FunctionOptions* options) {
   ASSERT_OK_AND_ASSIGN(Datum out, CallFunction(func_name, {input}, options));
   std::shared_ptr<Array> actual = std::move(out).make_array();
   ASSERT_OK(actual->ValidateFull());
   AssertArraysEqual(*expected, *actual, /*verbose=*/true);
+}
+
+}  // namespace
+
+void CheckScalarUnary(std::string func_name, std::shared_ptr<Array> input,
+                      std::shared_ptr<Array> expected, const FunctionOptions* options) {
+  CheckScalarUnaryNonRecursive(func_name, input, expected, options);
 
-  // Check all the scalars
+  // Check all the input scalars
   for (int64_t i = 0; i < input->length(); ++i) {
     ASSERT_OK_AND_ASSIGN(auto val, input->GetScalar(i));
     ASSERT_OK_AND_ASSIGN(auto ex_val, expected->GetScalar(i));
     CheckScalarUnary(func_name, val, ex_val, options);
   }
 
-  if (auto length = input->length() / 3) {
-    // XXX Is the recursive call intended?
-    CheckScalarUnary(func_name, input->Slice(0, length), expected->Slice(0, length),
-                     options);
+  const auto slice_length = input->length() / 3;
+  // Since it's a scalar function, calling it on a sliced input should
+  // result in the sliced expected output.
+  if (slice_length > 0) {
+    CheckScalarUnaryNonRecursive(func_name, input->Slice(0, slice_length),
+                                 expected->Slice(0, slice_length), options);
 
-    CheckScalarUnary(func_name, input->Slice(length, length),
-                     expected->Slice(length, length), options);
+    CheckScalarUnaryNonRecursive(func_name, input->Slice(slice_length, slice_length),
+                                 expected->Slice(slice_length, slice_length), options);
 
-    CheckScalarUnary(func_name, input->Slice(2 * length), expected->Slice(2 * length),
-                     options);
+    CheckScalarUnaryNonRecursive(func_name, input->Slice(2 * slice_length),
+                                 expected->Slice(2 * slice_length), options);
   }
 
-  if (auto length = input->length() / 3) {
-    ArrayVector input_chunks{input->Slice(0, length), input->Slice(length)},
-        expected_chunks{expected->Slice(0, 2 * length), expected->Slice(2 * length)};
+  // Ditto with a ChunkedArray input
+  if (slice_length > 0) {
+    ArrayVector input_chunks{input->Slice(0, slice_length), input->Slice(slice_length)},
+        expected_chunks{expected->Slice(0, 2 * slice_length),
+                        expected->Slice(2 * slice_length)};
 
     ASSERT_OK_AND_ASSIGN(
         Datum out,
         CallFunction(func_name, {std::make_shared<ChunkedArray>(input_chunks)}, options));
+    ASSERT_OK(out.chunked_array()->ValidateFull());
     AssertDatumsEqual(std::make_shared<ChunkedArray>(expected_chunks), out);
   }
 }
@@ -81,5 +97,13 @@ void CheckScalarUnary(std::string func_name, std::shared_ptr<Scalar> input,
   AssertScalarsEqual(*expected, *out.scalar(), /*verbose=*/true);
 }
 
+void CheckVectorUnary(std::string func_name, Datum input, std::shared_ptr<Array> expected,
+                      const FunctionOptions* options) {
+  ASSERT_OK_AND_ASSIGN(Datum out, CallFunction(func_name, {input}, options));
+  std::shared_ptr<Array> actual = std::move(out).make_array();
+  ASSERT_OK(actual->ValidateFull());
+  AssertArraysEqual(*expected, *actual, /*verbose=*/true);
+}
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/test_util.h b/cpp/src/arrow/compute/kernels/test_util.h
index b8e176bf34d..9786c89e166 100644
--- a/cpp/src/arrow/compute/kernels/test_util.h
+++ b/cpp/src/arrow/compute/kernels/test_util.h
@@ -103,6 +103,9 @@ void CheckScalarUnary(std::string func_name, std::shared_ptr<Scalar> input,
                       std::shared_ptr<Scalar> expected,
                       const FunctionOptions* options = nullptr);
 
+void CheckVectorUnary(std::string func_name, Datum input, std::shared_ptr<Array> expected,
+                      const FunctionOptions* options = nullptr);
+
 using BinaryTypes =
     ::testing::Types<BinaryType, LargeBinaryType, StringType, LargeStringType>;
 using StringTypes = ::testing::Types<StringType, LargeStringType>;
diff --git a/cpp/src/arrow/compute/kernels/vector_hash_test.cc b/cpp/src/arrow/compute/kernels/vector_hash_test.cc
index e451ce61c37..70ed84b09ad 100644
--- a/cpp/src/arrow/compute/kernels/vector_hash_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_hash_test.cc
@@ -655,7 +655,6 @@ TEST_F(TestHashKernel, ZeroLengthDictionaryEncode) {
 
   std::shared_ptr<Array> result = datum_result.make_array();
   const auto& dict_result = checked_cast<const DictionaryArray&>(*result);
-  ASSERT_OK(dict_result.Validate());
   ASSERT_OK(dict_result.ValidateFull());
 }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_nested_test.cc b/cpp/src/arrow/compute/kernels/vector_nested_test.cc
index 0ddcc431ac4..9c40c00bb71 100644
--- a/cpp/src/arrow/compute/kernels/vector_nested_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_nested_test.cc
@@ -29,10 +29,7 @@ TEST(TestVectorNested, ListFlatten) {
   for (auto ty : {list(int32()), large_list(int32())}) {
     auto input = ArrayFromJSON(ty, "[[0, null, 1], null, [2, 3], []]");
     auto expected = ArrayFromJSON(int32(), "[0, null, 1, 2, 3]");
-    ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("list_flatten", {input}));
-    std::shared_ptr<Array> actual = std::move(out).make_array();
-    ASSERT_OK(actual->ValidateFull());
-    AssertArraysEqual(*expected, *actual);
+    CheckVectorUnary("list_flatten", input, expected);
   }
 }
 
@@ -42,10 +39,7 @@ TEST(TestVectorNested, ListParentIndices) {
 
     auto out_ty = ty->id() == Type::LIST ? int32() : int64();
     auto expected = ArrayFromJSON(out_ty, "[0, 0, 0, 2, 2, 4, 4]");
-    ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("list_parent_indices", {input}));
-    std::shared_ptr<Array> actual = std::move(out).make_array();
-    ASSERT_OK(actual->ValidateFull());
-    AssertArraysEqual(*expected, *actual);
+    CheckVectorUnary("list_parent_indices", input, expected);
   }
 
   // Construct a list with non-empty null slots
@@ -54,10 +48,7 @@ TEST(TestVectorNested, ListParentIndices) {
   data->buffers[0] =
       (ArrayFromJSON(boolean(), "[true, false, true, true, true]")->data()->buffers[1]);
   auto expected = ArrayFromJSON(int32(), "[0, 0, 0, 1, 1, 2, 2, 4, 4]");
-  ASSERT_OK_AND_ASSIGN(Datum out, CallFunction("list_parent_indices", {data}));
-  std::shared_ptr<Array> actual = std::move(out).make_array();
-  ASSERT_OK(actual->ValidateFull());
-  AssertArraysEqual(*expected, *actual);
+  CheckVectorUnary("list_parent_indices", data, expected);
 }
 
 }  // namespace compute