From 19583cceba52995d3c4981ddb2c9dd73b8b5fa12 Mon Sep 17 00:00:00 2001
From: Fangchen Li <fangchen.li@outlook.com>
Date: Sat, 11 Jul 2026 11:48:55 -0700
Subject: [PATCH 1/2] GH-50478: [C++][Compute] Support string_view/binary_view
 in scalar string predicate kernels

Add STRING_VIEW/BINARY_VIEW support to the scalar string predicate and
measurement kernels that read a string and emit a fixed-width type:
match_substring(+regex), match_like, starts_with, ends_with,
find_substring(+regex), count_substring(+regex), binary_length,
utf8_length, string_is_ascii, and the ascii_is_*/utf8_is_* classifiers.

The matcher/predicate logic already operates on std::string_view, so the
change feeds view elements into the existing logic: MatchSubstringImpl gets
a per-element ArrayIterator branch for the view layout (the packed-offset
fast path stays for base binary/string), and the applicator-based kernels
only need registration entries plus a StringOffsetType helper mapping views
to Int32 output. Kernels that emit strings/lists are left for a follow-up.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../compute/kernels/scalar_string_ascii.cc    | 120 +++++++++++++---
 .../kernels/scalar_string_benchmark.cc        |  46 ++++++-
 .../compute/kernels/scalar_string_internal.h  |  35 ++++-
 .../compute/kernels/scalar_string_test.cc     | 129 ++++++++++++++++++
 .../compute/kernels/scalar_string_utf8.cc     |   5 +
 docs/source/cpp/compute.rst                   |  11 ++
 6 files changed, 313 insertions(+), 33 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
index d4dda5556b3b..f82ff6749c26 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
@@ -889,6 +889,12 @@ void AddAsciiStringLength(FunctionRegistry* registry) {
             ty);
     DCHECK_OK(func->AddKernel({ty}, int64(), std::move(exec)));
   }
+  // View element length is int32-sized, so both view types emit int32.
+  for (const auto& ty : BinaryViewTypes()) {
+    auto exec = GenerateVarBinaryViewBase<applicator::ScalarUnaryNotNull, Int32Type,
+                                          BinaryLength>(*ty);
+    DCHECK_OK(func->AddKernel({ty}, int32(), std::move(exec)));
+  }
   DCHECK_OK(func->AddKernel({InputType(Type::FIXED_SIZE_BINARY)}, int32(),
                             BinaryLength::FixedSizeExec));
   DCHECK_OK(registry->AddFunction(std::move(func)));
@@ -1337,27 +1343,47 @@ struct RegexSubstringMatcher {
 
 template <typename Type, typename Matcher>
 struct MatchSubstringImpl {
-  using offset_type = typename Type::offset_type;
-
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out,
                      const Matcher* matcher) {
-    StringBoolTransform<Type>(
-        ctx, batch,
-        [&matcher](const void* raw_offsets, const uint8_t* data, int64_t length,
-                   int64_t output_offset, uint8_t* output) {
-          const offset_type* offsets = reinterpret_cast<const offset_type*>(raw_offsets);
-          FirstTimeBitmapWriter bitmap_writer(output, output_offset, length);
-          for (int64_t i = 0; i < length; ++i) {
-            const char* current_data = reinterpret_cast<const char*>(data + offsets[i]);
-            int64_t current_length = offsets[i + 1] - offsets[i];
-            if (matcher->Match(std::string_view(current_data, current_length))) {
+    if constexpr (is_binary_view_like_type<Type>::value) {
+      // Views have no packed offset buffer, so evaluate per element. Null slots are
+      // skipped: a view's null header is not validated and may carry a bogus
+      // buffer_index/offset that decoding would dereference.
+      const ArraySpan& input = batch[0].array;
+      ArraySpan* out_arr = out->array_span_mutable();
+      FirstTimeBitmapWriter bitmap_writer(out_arr->buffers[1].data, out_arr->offset,
+                                          input.length);
+      VisitArrayValuesInline<Type>(
+          input,
+          [&](std::string_view val) {
+            if (matcher->Match(val)) {
               bitmap_writer.Set();
             }
             bitmap_writer.Next();
-          }
-          bitmap_writer.Finish();
-        },
-        out);
+          },
+          [&]() { bitmap_writer.Next(); });
+      bitmap_writer.Finish();
+    } else {
+      using offset_type = typename Type::offset_type;
+      StringBoolTransform<Type>(
+          ctx, batch,
+          [&matcher](const void* raw_offsets, const uint8_t* data, int64_t length,
+                     int64_t output_offset, uint8_t* output) {
+            const offset_type* offsets =
+                reinterpret_cast<const offset_type*>(raw_offsets);
+            FirstTimeBitmapWriter bitmap_writer(output, output_offset, length);
+            for (int64_t i = 0; i < length; ++i) {
+              const char* current_data = reinterpret_cast<const char*>(data + offsets[i]);
+              int64_t current_length = offsets[i + 1] - offsets[i];
+              if (matcher->Match(std::string_view(current_data, current_length))) {
+                bitmap_writer.Set();
+              }
+              bitmap_writer.Next();
+            }
+            bitmap_writer.Finish();
+          },
+          out);
+    }
     return Status::OK();
   }
 };
@@ -1611,6 +1637,19 @@ const FunctionDoc match_like_doc(
     {"strings"}, "MatchSubstringOptions", /*options_required=*/true);
 #endif
 
+// Register the view kernels for a match-substring-style predicate. Registered per
+// view type (not via GenerateVarBinaryViewBase) so utf8_view -> StringViewType keeps
+// the is_utf8 distinction used by ignore_case/regex folding.
+template <template <typename...> class ExecTemplate, typename... Matcher>
+void AddMatchSubstringViewKernels(ScalarFunction* func) {
+  DCHECK_OK(func->AddKernel({binary_view()}, boolean(),
+                            ExecTemplate<BinaryViewType, Matcher...>::Exec,
+                            MatchSubstringState::Init));
+  DCHECK_OK(func->AddKernel({utf8_view()}, boolean(),
+                            ExecTemplate<StringViewType, Matcher...>::Exec,
+                            MatchSubstringState::Init));
+}
+
 void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
   {
     auto func = std::make_shared<ScalarFunction>("match_substring", Arity::Unary(),
@@ -1620,6 +1659,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    AddMatchSubstringViewKernels<MatchSubstring, PlainSubstringMatcher>(func.get());
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
   {
@@ -1631,6 +1671,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    AddMatchSubstringViewKernels<MatchSubstring, PlainStartsWithMatcher>(func.get());
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
   {
@@ -1641,6 +1682,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    AddMatchSubstringViewKernels<MatchSubstring, PlainEndsWithMatcher>(func.get());
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
 #ifdef ARROW_WITH_RE2
@@ -1652,6 +1694,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    AddMatchSubstringViewKernels<MatchSubstring, RegexSubstringMatcher>(func.get());
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
   {
@@ -1662,6 +1705,7 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    AddMatchSubstringViewKernels<MatchLike>(func.get());
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
 #endif
@@ -1670,6 +1714,17 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
 // ----------------------------------------------------------------------
 // Substring find - lfind/index/etc.
 
+// The output offset type for find/count kernels. Like TypeTraits<T>::OffsetType,
+// but also defined for the view types, whose per-element length is int32-sized.
+template <typename T, typename Enable = void>
+struct StringOffsetType {
+  using type = typename TypeTraits<T>::OffsetType;
+};
+template <typename T>
+struct StringOffsetType<T, enable_if_binary_view_like<T>> {
+  using type = Int32Type;
+};
+
 struct FindSubstring {
   const PlainSubstringMatcher matcher_;
 
@@ -1716,7 +1771,7 @@ struct FindSubstringRegex {
 
 template <typename InputType>
 struct FindSubstringExec {
-  using OffsetType = typename TypeTraits<InputType>::OffsetType;
+  using OffsetType = typename StringOffsetType<InputType>::type;
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const MatchSubstringOptions& options = MatchSubstringState::Get(ctx);
     if (options.ignore_case) {
@@ -1746,7 +1801,7 @@ const FunctionDoc find_substring_doc(
 #ifdef ARROW_WITH_RE2
 template <typename InputType>
 struct FindSubstringRegexExec {
-  using OffsetType = typename TypeTraits<InputType>::OffsetType;
+  using OffsetType = typename StringOffsetType<InputType>::type;
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const MatchSubstringOptions& options = MatchSubstringState::Get(ctx);
     ARROW_ASSIGN_OR_RAISE(auto matcher, FindSubstringRegex::Make(options, false));
@@ -1774,6 +1829,13 @@ void AddAsciiStringFindSubstring(FunctionRegistry* registry) {
                                 GenerateVarBinaryToVarBinary<FindSubstringExec>(ty),
                                 MatchSubstringState::Init));
     }
+    // Per view type to keep the is_utf8 distinction; view length fits int32.
+    DCHECK_OK(func->AddKernel({binary_view()}, int32(),
+                              FindSubstringExec<BinaryViewType>::Exec,
+                              MatchSubstringState::Init));
+    DCHECK_OK(func->AddKernel({utf8_view()}, int32(),
+                              FindSubstringExec<StringViewType>::Exec,
+                              MatchSubstringState::Init));
     DCHECK_OK(func->AddKernel({InputType(Type::FIXED_SIZE_BINARY)}, int32(),
                               FindSubstringExec<FixedSizeBinaryType>::Exec,
                               MatchSubstringState::Init));
@@ -1789,6 +1851,12 @@ void AddAsciiStringFindSubstring(FunctionRegistry* registry) {
                                 GenerateVarBinaryToVarBinary<FindSubstringRegexExec>(ty),
                                 MatchSubstringState::Init));
     }
+    DCHECK_OK(func->AddKernel({binary_view()}, int32(),
+                              FindSubstringRegexExec<BinaryViewType>::Exec,
+                              MatchSubstringState::Init));
+    DCHECK_OK(func->AddKernel({utf8_view()}, int32(),
+                              FindSubstringRegexExec<StringViewType>::Exec,
+                              MatchSubstringState::Init));
     DCHECK_OK(func->AddKernel({InputType(Type::FIXED_SIZE_BINARY)}, int32(),
                               FindSubstringRegexExec<FixedSizeBinaryType>::Exec,
                               MatchSubstringState::Init));
@@ -1862,7 +1930,7 @@ struct CountSubstringRegex {
 
 template <typename InputType>
 struct CountSubstringRegexExec {
-  using OffsetType = typename TypeTraits<InputType>::OffsetType;
+  using OffsetType = typename StringOffsetType<InputType>::type;
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const MatchSubstringOptions& options = MatchSubstringState::Get(ctx);
     ARROW_ASSIGN_OR_RAISE(
@@ -1876,7 +1944,7 @@ struct CountSubstringRegexExec {
 
 template <typename InputType>
 struct CountSubstringExec {
-  using OffsetType = typename TypeTraits<InputType>::OffsetType;
+  using OffsetType = typename StringOffsetType<InputType>::type;
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const MatchSubstringOptions& options = MatchSubstringState::Get(ctx);
     if (options.ignore_case) {
@@ -1923,6 +1991,12 @@ void AddAsciiStringCountSubstring(FunctionRegistry* registry) {
                                 GenerateVarBinaryToVarBinary<CountSubstringExec>(ty),
                                 MatchSubstringState::Init));
     }
+    DCHECK_OK(func->AddKernel({binary_view()}, int32(),
+                              CountSubstringExec<BinaryViewType>::Exec,
+                              MatchSubstringState::Init));
+    DCHECK_OK(func->AddKernel({utf8_view()}, int32(),
+                              CountSubstringExec<StringViewType>::Exec,
+                              MatchSubstringState::Init));
     DCHECK_OK(func->AddKernel({InputType(Type::FIXED_SIZE_BINARY)}, int32(),
                               CountSubstringExec<FixedSizeBinaryType>::Exec,
                               MatchSubstringState::Init));
@@ -1938,6 +2012,12 @@ void AddAsciiStringCountSubstring(FunctionRegistry* registry) {
                                 GenerateVarBinaryToVarBinary<CountSubstringRegexExec>(ty),
                                 MatchSubstringState::Init));
     }
+    DCHECK_OK(func->AddKernel({binary_view()}, int32(),
+                              CountSubstringRegexExec<BinaryViewType>::Exec,
+                              MatchSubstringState::Init));
+    DCHECK_OK(func->AddKernel({utf8_view()}, int32(),
+                              CountSubstringRegexExec<StringViewType>::Exec,
+                              MatchSubstringState::Init));
     DCHECK_OK(func->AddKernel({InputType(Type::FIXED_SIZE_BINARY)}, int32(),
                               CountSubstringRegexExec<FixedSizeBinaryType>::Exec,
                               MatchSubstringState::Init));
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index a2cfbd059743..5384d0b16065 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -22,6 +22,7 @@
 #include "arrow/array.h"
 #include "arrow/chunked_array.h"
 #include "arrow/compute/api_scalar.h"
+#include "arrow/compute/cast.h"
 #include "arrow/compute/exec.h"
 #include "arrow/datum.h"
 #include "arrow/testing/gtest_util.h"
@@ -39,17 +40,26 @@ namespace compute {
 
 constexpr auto kSeed = 0x94378165;
 
-static void UnaryStringBenchmark(benchmark::State& state, const std::string& func_name,
-                                 const FunctionOptions* options = nullptr) {
+// Shared dataset for the string benchmarks: ~1M only-ASCII values.
+static std::shared_ptr<Array> MakeBenchmarkStrings() {
   const int64_t array_length = 1 << 20;
   const int64_t value_min_size = 0;
   const int64_t value_max_size = 32;
   const double null_probability = 0.01;
   random::RandomArrayGenerator rng(kSeed);
+  return rng.String(array_length, value_min_size, value_max_size, null_probability);
+}
 
-  // NOTE: this produces only-Ascii data
-  auto values =
-      rng.String(array_length, value_min_size, value_max_size, null_probability);
+static void UnaryStringBenchmark(benchmark::State& state, const std::string& func_name,
+                                 const FunctionOptions* options = nullptr,
+                                 const std::shared_ptr<DataType>& input_type = utf8()) {
+  std::shared_ptr<Array> values = MakeBenchmarkStrings();
+  const int64_t array_length = values->length();
+  // Report throughput based on the raw string bytes, before any conversion.
+  const int64_t data_nbytes = values->data()->buffers[2]->size();
+  if (input_type->id() != Type::STRING) {
+    values = Cast(*values, input_type).ValueOrDie();
+  }
   // Make sure lookup tables are initialized before measuring
   ABORT_NOT_OK(CallFunction(func_name, {values}, options));
 
@@ -57,7 +67,7 @@ static void UnaryStringBenchmark(benchmark::State& state, const std::string& fun
     ABORT_NOT_OK(CallFunction(func_name, {values}, options));
   }
   state.SetItemsProcessed(state.iterations() * array_length);
-  state.SetBytesProcessed(state.iterations() * values->data()->buffers[2]->size());
+  state.SetBytesProcessed(state.iterations() * data_nbytes);
 }
 
 static void AsciiLower(benchmark::State& state) {
@@ -77,6 +87,28 @@ static void MatchSubstring(benchmark::State& state) {
   UnaryStringBenchmark(state, "match_substring", &options);
 }
 
+// Predicate run directly on a string_view array (the path added by this PR).
+static void MatchSubstringView(benchmark::State& state) {
+  MatchSubstringOptions options("abac");
+  UnaryStringBenchmark(state, "match_substring", &options, utf8_view());
+}
+
+// Baseline: the pre-PR workaround of casting the view column to utf8 first. The
+// gap vs. MatchSubstringView is the cast that direct view support avoids.
+static void MatchSubstringViewCast(benchmark::State& state) {
+  std::shared_ptr<Array> utf8_values = MakeBenchmarkStrings();
+  const int64_t array_length = utf8_values->length();
+  const int64_t data_nbytes = utf8_values->data()->buffers[2]->size();
+  std::shared_ptr<Array> view_values = Cast(*utf8_values, utf8_view()).ValueOrDie();
+  MatchSubstringOptions options("abac");
+  for (auto _ : state) {
+    ASSIGN_OR_ABORT(auto casted, Cast(*view_values, utf8()));
+    ABORT_NOT_OK(CallFunction("match_substring", {casted}, &options));
+  }
+  state.SetItemsProcessed(state.iterations() * array_length);
+  state.SetBytesProcessed(state.iterations() * data_nbytes);
+}
+
 static void SplitPattern(benchmark::State& state) {
   SplitPatternOptions options("a");
   UnaryStringBenchmark(state, "split_pattern", &options);
@@ -242,6 +274,8 @@ BENCHMARK(AsciiLower);
 BENCHMARK(AsciiUpper);
 BENCHMARK(IsAlphaNumericAscii);
 BENCHMARK(MatchSubstring);
+BENCHMARK(MatchSubstringView);
+BENCHMARK(MatchSubstringViewCast);
 BENCHMARK(SplitPattern);
 BENCHMARK(TrimSingleAscii);
 BENCHMARK(TrimManyAscii);
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_internal.h b/cpp/src/arrow/compute/kernels/scalar_string_internal.h
index 664f6b4c0b0f..2ec0295918fd 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_internal.h
+++ b/cpp/src/arrow/compute/kernels/scalar_string_internal.h
@@ -220,14 +220,33 @@ struct StringPredicateFunctor {
     Status st = Status::OK();
     EnsureUtf8LookupTablesFilled();
     const ArraySpan& input = batch[0].array;
-    ArrayIterator<Type> input_it(input);
     ArraySpan* out_arr = out->array_span_mutable();
-    ::arrow::internal::GenerateBitsUnrolled(
-        out_arr->buffers[1].data, out_arr->offset, input.length, [&]() -> bool {
-          std::string_view val = input_it();
-          return Predicate::Call(ctx, reinterpret_cast<const uint8_t*>(val.data()),
-                                 val.size(), &st);
-        });
+    if constexpr (is_binary_view_like_type<Type>::value) {
+      // Skip null slots: a view's null header is not validated and may carry a
+      // bogus buffer_index/offset that decoding would dereference. (The base
+      // binary/string path below can safely read null slots.)
+      FirstTimeBitmapWriter writer(out_arr->buffers[1].data, out_arr->offset,
+                                   input.length);
+      VisitArrayValuesInline<Type>(
+          input,
+          [&](std::string_view val) {
+            if (Predicate::Call(ctx, reinterpret_cast<const uint8_t*>(val.data()),
+                                val.size(), &st)) {
+              writer.Set();
+            }
+            writer.Next();
+          },
+          [&]() { writer.Next(); });
+      writer.Finish();
+    } else {
+      ArrayIterator<Type> input_it(input);
+      ::arrow::internal::GenerateBitsUnrolled(
+          out_arr->buffers[1].data, out_arr->offset, input.length, [&]() -> bool {
+            std::string_view val = input_it();
+            return Predicate::Call(ctx, reinterpret_cast<const uint8_t*>(val.data()),
+                                   val.size(), &st);
+          });
+    }
     return st;
   }
 };
@@ -240,6 +259,8 @@ void AddUnaryStringPredicate(std::string name, FunctionRegistry* registry,
     auto exec = GenerateVarBinaryToVarBinary<StringPredicateFunctor, Predicate>(ty);
     ARROW_DCHECK_OK(func->AddKernel({ty}, boolean(), std::move(exec)));
   }
+  ARROW_DCHECK_OK(func->AddKernel(
+      {utf8_view()}, boolean(), StringPredicateFunctor<StringViewType, Predicate>::Exec));
   ARROW_DCHECK_OK(registry->AddFunction(std::move(func)));
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index b279f991f6ea..e5a22df998fa 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cstring>
 #include <memory>
 #include <string>
 #include <utility>
@@ -23,6 +24,8 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "arrow/array/util.h"
+#include "arrow/buffer.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/exec.h"
 #include "arrow/compute/kernels/codegen_internal.h"
@@ -30,6 +33,7 @@
 #include "arrow/testing/gtest_util.h"
 #include "arrow/type.h"
 #include "arrow/type_fwd.h"
+#include "arrow/util/binary_view_util.h"
 #include "arrow/util/config.h"
 #include "arrow/util/value_parsing.h"
 
@@ -2690,4 +2694,129 @@ TEST(TestStringKernels, UnicodeLibraryAssumptions) {
 }
 #endif
 
+// ----------------------------------------------------------------------
+// View type support for scalar string predicate/measurement kernels.
+
+// Mixes empty, inlined (<= 12 bytes), out-of-line (> 12 bytes), and null values
+// to cover the view layout.
+constexpr auto kViewInput =
+    R"(["", "cat", null, "the quick brown fox", "concatenation", "a cat sat", "CAT"])";
+
+TEST(TestStringViewPredicates, MatchSubstring) {
+  MatchSubstringOptions options{"cat"};
+  for (const auto& ty : {binary_view(), utf8_view()}) {
+    CheckScalarUnary("match_substring", ty, kViewInput, boolean(),
+                     "[false, true, null, false, true, true, false]", &options);
+  }
+}
+
+TEST(TestStringViewPredicates, StartsWithEndsWith) {
+  MatchSubstringOptions starts{"c"};
+  MatchSubstringOptions ends{"t"};
+  for (const auto& ty : {binary_view(), utf8_view()}) {
+    CheckScalarUnary("starts_with", ty, kViewInput, boolean(),
+                     "[false, true, null, false, true, false, false]", &starts);
+    CheckScalarUnary("ends_with", ty, kViewInput, boolean(),
+                     "[false, true, null, false, false, true, false]", &ends);
+  }
+}
+
+TEST(TestStringViewPredicates, FindSubstring) {
+  MatchSubstringOptions options{"cat"};
+  for (const auto& ty : {binary_view(), utf8_view()}) {
+    CheckScalarUnary("find_substring", ty, kViewInput, int32(),
+                     "[-1, 0, null, -1, 3, 2, -1]", &options);
+  }
+}
+
+TEST(TestStringViewPredicates, CountSubstring) {
+  MatchSubstringOptions options{"cat"};
+  for (const auto& ty : {binary_view(), utf8_view()}) {
+    CheckScalarUnary("count_substring", ty, kViewInput, int32(),
+                     "[0, 1, null, 0, 1, 1, 0]", &options);
+  }
+}
+
+TEST(TestStringViewPredicates, BinaryLength) {
+  for (const auto& ty : {binary_view(), utf8_view()}) {
+    CheckScalarUnary("binary_length", ty, kViewInput, int32(),
+                     "[0, 3, null, 19, 13, 9, 3]");
+  }
+}
+
+#ifdef ARROW_WITH_RE2
+TEST(TestStringViewPredicates, MatchSubstringRegex) {
+  MatchSubstringOptions options{"a+"};
+  const auto* input = R"(["", "cat", null, "aaa banana", "concatenation"])";
+  for (const auto& ty : {binary_view(), utf8_view()}) {
+    CheckScalarUnary("match_substring_regex", ty, input, boolean(),
+                     "[false, true, null, true, true]", &options);
+    CheckScalarUnary("find_substring_regex", ty, input, int32(), "[-1, 1, null, 0, 4]",
+                     &options);
+    CheckScalarUnary("count_substring_regex", ty, input, int32(), "[0, 1, null, 4, 2]",
+                     &options);
+  }
+}
+
+TEST(TestStringViewPredicates, MatchLike) {
+  MatchSubstringOptions contains{"%cat%"};
+  MatchSubstringOptions prefix{"c%"};
+  const auto* input = R"(["cat", "concatenation", null, "dog", "a cat sat"])";
+  for (const auto& ty : {binary_view(), utf8_view()}) {
+    CheckScalarUnary("match_like", ty, input, boolean(),
+                     "[true, true, null, false, true]", &contains);
+    CheckScalarUnary("match_like", ty, input, boolean(),
+                     "[true, true, null, false, false]", &prefix);
+  }
+}
+#endif
+
+TEST(TestStringViewPredicates, Utf8Length) {
+  CheckScalarUnary("utf8_length", utf8_view(),
+                   R"(["", "café", null, "a long ascii string here", "ÀÉÎ"])", int32(),
+                   "[0, 4, null, 24, 3]");
+}
+
+TEST(TestStringViewPredicates, StringIsAscii) {
+  CheckScalarUnary("string_is_ascii", utf8_view(),
+                   R"(["", "café", null, "a long ascii string here", "ÀÉÎ"])", boolean(),
+                   "[true, false, null, true, false]");
+}
+
+TEST(TestStringViewPredicates, AsciiClassification) {
+  // Exercises the shared AddUnaryStringPredicate view kernel via the ascii path.
+  CheckScalarUnary("ascii_is_alpha", utf8_view(), R"(["cat", "cat123", "", null, "CAT"])",
+                   boolean(), "[true, false, false, null, true]");
+}
+
+#ifdef ARROW_WITH_UTF8PROC
+TEST(TestStringViewPredicates, Utf8Classification) {
+  // Exercises the shared AddUnaryStringPredicate view kernel via the utf8 path.
+  CheckScalarUnary("utf8_is_alpha", utf8_view(), R"(["cat", "café", "cat123", "", null])",
+                   boolean(), "[true, true, false, false, null]");
+}
+#endif  // ARROW_WITH_UTF8PROC
+
+// A validation-passing view array may hold arbitrary bytes in a null slot's
+// header, because ValidateBinaryView skips null slots. The view kernels must not
+// decode those, or they would dereference a bogus buffer_index/offset. Craft
+// ["ok", <null slot with a 0xFF header>] and confirm the kernels ignore the null.
+TEST(TestStringViewPredicates, NullSlotWithUnvalidatedHeader) {
+  auto good = ArrayFromJSON(utf8_view(), R"(["ok", null])");
+  std::vector<BinaryViewType::c_type> views(2);
+  views[0] = util::ToInlineBinaryView("ok");
+  std::memset(&views[1], 0xFF, sizeof(BinaryViewType::c_type));
+  auto data = std::make_shared<ArrayData>(*good->data());
+  data->buffers[1] = Buffer::FromVector(std::move(views));
+  auto arr = MakeArray(data);
+  ASSERT_OK(arr->ValidateFull());  // still valid: the null slot is not checked
+
+  auto expected = ArrayFromJSON(boolean(), "[true, null]");
+  MatchSubstringOptions contains{"o"};
+  ASSERT_OK_AND_ASSIGN(Datum matched, CallFunction("match_substring", {arr}, &contains));
+  AssertDatumsEqual(Datum(expected), matched);
+  ASSERT_OK_AND_ASSIGN(Datum ascii, CallFunction("string_is_ascii", {arr}));
+  AssertDatumsEqual(Datum(expected), ascii);
+}
+
 }  // namespace arrow::compute
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
index fd340bba6242..dceba066e8a2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
@@ -688,6 +688,11 @@ void AddUtf8StringLength(FunctionRegistry* registry) {
         applicator::ScalarUnaryNotNull<Int64Type, LargeStringType, Utf8Length>::Exec;
     DCHECK_OK(func->AddKernel({large_utf8()}, int64(), std::move(exec)));
   }
+  {
+    auto exec =
+        applicator::ScalarUnaryNotNull<Int32Type, StringViewType, Utf8Length>::Exec;
+    DCHECK_OK(func->AddKernel({utf8_view()}, int32(), std::move(exec)));
+  }
   DCHECK_OK(registry->AddFunction(std::move(func)));
 }
 
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 1e067c52188d..cb3fa0647129 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -883,6 +883,9 @@ 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.
 
+In addition to String-like input, all predicates in this section also accept
+``StringView`` (``utf8_view``) input.
+
 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:
@@ -1012,6 +1015,7 @@ String transforms
 
 * \(3) Output is the physical length in bytes of each input element.  Output
   type is Int32 for Binary/String, Int64 for LargeBinary/LargeString.
+  ``BinaryView`` and ``StringView`` input is also accepted, with Int32 output.
 
 * \(4) Repeat the input binary string a given number of times.
 
@@ -1040,6 +1044,7 @@ String transforms
 
 * \(10) Output is the number of characters (not bytes) of each input element.
   Output type is Int32 for String, Int64 for LargeString.
+  ``StringView`` (``utf8_view``) input is also accepted, with Int32 output.
 
 * \(11) Each UTF8-encoded code unit is written in reverse order to the output.
   If the input is not valid UTF8, then the output is undefined (but the size of output
@@ -1221,6 +1226,12 @@ in reverse order.
 Containment tests
 ~~~~~~~~~~~~~~~~~
 
+The substring/pattern kernels (``count_substring``, ``count_substring_regex``,
+``ends_with``, ``find_substring``, ``find_substring_regex``, ``match_like``,
+``match_substring``, ``match_substring_regex``, and ``starts_with``) also accept
+``BinaryView`` and ``StringView`` input, with the same output types as for the
+corresponding non-view Binary/String types.
+
 +-----------------------+-------+-----------------------------------+----------------+---------------------------------+-------+
 | Function name         | Arity | Input types                       | Output type    | Options class                   | Notes |
 +=======================+=======+===================================+================+=================================+=======+

From 8082d3120cbc7bb663b17d36bacb735c31faa88e Mon Sep 17 00:00:00 2001
From: Fangchen Li <fangchen.li@outlook.com>
Date: Mon, 13 Jul 2026 21:39:54 -0700
Subject: [PATCH 2/2] GH-50478: [C++][Compute] Add utf8_view ignore_case test
 guarding UTF-8/Latin1 distinction

Add a match_substring ignore_case=true case on utf8_view with non-ASCII
input (uppercase E-acute) mirroring the existing MatchSubstringIgnoreCase
coverage. utf8_view is registered as StringViewType rather than the generic
BinaryViewType dispatch, so case folding spans the full Unicode range; this
test fails if that distinction is ever lost. Requested in review by
zanmato1984.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 cpp/src/arrow/compute/kernels/scalar_string_test.cc | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index e5a22df998fa..33b2c21d3d65 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -2769,6 +2769,16 @@ TEST(TestStringViewPredicates, MatchLike) {
                      "[true, true, null, false, false]", &prefix);
   }
 }
+
+// utf8_view registers as StringViewType, so ignore_case folds the full Unicode
+// range (É matches é), not just ASCII. This would fail if utf8_view were
+// dispatched through the generic BinaryViewType path and lost that distinction.
+TEST(TestStringViewPredicates, MatchSubstringIgnoreCase) {
+  MatchSubstringOptions options{"aé(", /*ignore_case=*/true};
+  CheckScalarUnary("match_substring", utf8_view(),
+                   R"(["abc", "aEb", "baÉ(", "aé(", "ae(", "Aé("])", boolean(),
+                   "[false, false, true, true, false, true]", &options);
+}
 #endif
 
 TEST(TestStringViewPredicates, Utf8Length) {