diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 3a2bcefab0a1..3afa9eab34e9 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -1337,6 +1337,20 @@ auto GenerateTypeAgnosticVarBinaryBase(detail::GetTypeId get_id) {
   }
 }
 
+// Similar to GenerateTypeAgnosticVarBinaryBase, but for binary view types
+template <template <typename...> class Generator, typename... Args>
+auto GenerateTypeAgnosticVarBinaryViewBase(detail::GetTypeId get_id) {
+  using KernelType = decltype(&Generator<BinaryViewType, Args...>::Exec);
+  switch (get_id.id) {
+    case Type::BINARY_VIEW:
+    case Type::STRING_VIEW:
+      return Generator<BinaryViewType, Args...>::Exec;
+    default:
+      ARROW_DCHECK(false);
+      return FailFunctor<KernelType>::Exec;
+  }
+}
+
 // Generate a kernel given a templated functor for base binary types. Generates
 // a single kernel for binary/string and large binary/large string. If your kernel
 // implementation needs access to the specific type at compile time, please use
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
index 8e7b626837fe..e8a034e214d0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
@@ -885,6 +885,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)));
@@ -1198,24 +1204,6 @@ void AddAsciiStringPad(FunctionRegistry* registry) {
 // ----------------------------------------------------------------------
 // Exact pattern detection
 
-using StrToBoolTransformFunc =
-    std::function<void(const void*, const uint8_t*, int64_t, int64_t, uint8_t*)>;
-
-// Apply `transform` to input character data- this function cannot change the
-// length
-template <typename Type>
-void StringBoolTransform(KernelContext* ctx, const ExecSpan& batch,
-                         StrToBoolTransformFunc transform, ExecResult* out) {
-  using offset_type = typename Type::offset_type;
-  const ArraySpan& input = batch[0].array;
-  ArraySpan* out_arr = out->array_span_mutable();
-  if (input.length > 0) {
-    transform(reinterpret_cast<const offset_type*>(input.buffers[1].data) + input.offset,
-              input.buffers[2].data, input.length, out_arr->offset,
-              out_arr->buffers[1].data);
-  }
-}
-
 using MatchSubstringState = OptionsWrapper<MatchSubstringOptions>;
 
 // This is an implementation of the Knuth-Morris-Pratt algorithm
@@ -1333,27 +1321,26 @@ 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))) {
-              bitmap_writer.Set();
-            }
-            bitmap_writer.Next();
+    // Evaluate per element and skip null slots. The matcher may be expensive
+    // (e.g. a regex), so running it on nulls is wasteful; additionally, for the
+    // view types a null slot's header is unvalidated 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.Finish();
+          bitmap_writer.Next();
         },
-        out);
+        [&]() { bitmap_writer.Next(); });
+    bitmap_writer.Finish();
     return Status::OK();
   }
 };
@@ -1645,6 +1632,13 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    for (const auto& ty : BinaryViewTypes()) {
+      auto exec =
+          GenerateTypeAgnosticVarBinaryViewBase<MatchSubstring, PlainSubstringMatcher>(
+              ty);
+      DCHECK_OK(
+          func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
+    }
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
   {
@@ -1656,6 +1650,13 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    for (const auto& ty : BinaryViewTypes()) {
+      auto exec =
+          GenerateTypeAgnosticVarBinaryViewBase<MatchSubstring, PlainStartsWithMatcher>(
+              ty);
+      DCHECK_OK(
+          func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
+    }
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
   {
@@ -1667,6 +1668,12 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    for (const auto& ty : BinaryViewTypes()) {
+      auto exec =
+          GenerateTypeAgnosticVarBinaryViewBase<MatchSubstring, PlainEndsWithMatcher>(ty);
+      DCHECK_OK(
+          func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
+    }
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
 #ifdef ARROW_WITH_RE2
@@ -1679,6 +1686,13 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    for (const auto& ty : BinaryViewTypes()) {
+      auto exec =
+          GenerateTypeAgnosticVarBinaryViewBase<MatchSubstring, RegexSubstringMatcher>(
+              ty);
+      DCHECK_OK(
+          func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
+    }
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
   {
@@ -1689,6 +1703,11 @@ void AddAsciiStringMatchSubstring(FunctionRegistry* registry) {
       DCHECK_OK(
           func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
     }
+    for (const auto& ty : BinaryViewTypes()) {
+      auto exec = GenerateTypeAgnosticVarBinaryViewBase<MatchLike>(ty);
+      DCHECK_OK(
+          func->AddKernel({ty}, boolean(), std::move(exec), MatchSubstringState::Init));
+    }
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
 #endif
@@ -1697,6 +1716,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_;
 
@@ -1743,7 +1773,9 @@ struct FindSubstringRegex {
 
 template <typename InputPhysicalType>
 struct FindSubstringExec {
-  using OffsetType = typename TypeTraits<InputPhysicalType>::OffsetType;
+  // StringOffsetType maps the view types (which have no TypeTraits::OffsetType)
+  // to int32; for the other physical types it forwards to TypeTraits::OffsetType.
+  using OffsetType = typename StringOffsetType<InputPhysicalType>::type;
 
   static_assert(!is_string_or_string_view(InputPhysicalType::type_id),
                 "should only codegen on physical types");
@@ -1779,7 +1811,7 @@ const FunctionDoc find_substring_doc(
 #ifdef ARROW_WITH_RE2
 template <typename InputPhysicalType>
 struct FindSubstringRegexExec {
-  using OffsetType = typename TypeTraits<InputPhysicalType>::OffsetType;
+  using OffsetType = typename StringOffsetType<InputPhysicalType>::type;
 
   static_assert(!is_string_or_string_view(InputPhysicalType::type_id),
                 "should only codegen on physical types");
@@ -1813,6 +1845,12 @@ void AddAsciiStringFindSubstring(FunctionRegistry* registry) {
                                 GenerateTypeAgnosticVarBinaryBase<FindSubstringExec>(ty),
                                 MatchSubstringState::Init));
     }
+    // View element length is int32-sized, so both view types emit int32.
+    for (const auto& ty : BinaryViewTypes()) {
+      DCHECK_OK(func->AddKernel(
+          {ty}, int32(), GenerateTypeAgnosticVarBinaryViewBase<FindSubstringExec>(ty),
+          MatchSubstringState::Init));
+    }
     DCHECK_OK(func->AddKernel({InputType(Type::FIXED_SIZE_BINARY)}, int32(),
                               FindSubstringExec<FixedSizeBinaryType>::Exec,
                               MatchSubstringState::Init));
@@ -1829,6 +1867,12 @@ void AddAsciiStringFindSubstring(FunctionRegistry* registry) {
                           GenerateTypeAgnosticVarBinaryBase<FindSubstringRegexExec>(ty),
                           MatchSubstringState::Init));
     }
+    for (const auto& ty : BinaryViewTypes()) {
+      DCHECK_OK(func->AddKernel(
+          {ty}, int32(),
+          GenerateTypeAgnosticVarBinaryViewBase<FindSubstringRegexExec>(ty),
+          MatchSubstringState::Init));
+    }
     DCHECK_OK(func->AddKernel({InputType(Type::FIXED_SIZE_BINARY)}, int32(),
                               FindSubstringRegexExec<FixedSizeBinaryType>::Exec,
                               MatchSubstringState::Init));
@@ -1902,7 +1946,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);
     const bool is_utf8 = is_string_or_string_view(batch[0].type()->id());
@@ -1916,7 +1960,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) {
@@ -1963,6 +2007,11 @@ void AddAsciiStringCountSubstring(FunctionRegistry* registry) {
                                 GenerateTypeAgnosticVarBinaryBase<CountSubstringExec>(ty),
                                 MatchSubstringState::Init));
     }
+    for (const auto& ty : BinaryViewTypes()) {
+      DCHECK_OK(func->AddKernel(
+          {ty}, int32(), GenerateTypeAgnosticVarBinaryViewBase<CountSubstringExec>(ty),
+          MatchSubstringState::Init));
+    }
     DCHECK_OK(func->AddKernel({InputType(Type::FIXED_SIZE_BINARY)}, int32(),
                               CountSubstringExec<FixedSizeBinaryType>::Exec,
                               MatchSubstringState::Init));
@@ -1979,6 +2028,12 @@ void AddAsciiStringCountSubstring(FunctionRegistry* registry) {
                           GenerateTypeAgnosticVarBinaryBase<CountSubstringRegexExec>(ty),
                           MatchSubstringState::Init));
     }
+    for (const auto& ty : BinaryViewTypes()) {
+      DCHECK_OK(func->AddKernel(
+          {ty}, int32(),
+          GenerateTypeAgnosticVarBinaryViewBase<CountSubstringRegexExec>(ty),
+          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_internal.h b/cpp/src/arrow/compute/kernels/scalar_string_internal.h
index 5c621e8d53f5..ffcbbe226232 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_internal.h
+++ b/cpp/src/arrow/compute/kernels/scalar_string_internal.h
@@ -230,14 +230,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;
   }
 };
@@ -250,6 +269,10 @@ void AddUnaryStringPredicate(std::string name, FunctionRegistry* registry,
     auto exec = GenerateTypeAgnosticVarBinaryBase<StringPredicateFunctor, Predicate>(ty);
     ARROW_DCHECK_OK(func->AddKernel({ty}, boolean(), std::move(exec)));
   }
+  ARROW_DCHECK_OK(func->AddKernel(
+      {utf8_view()}, boolean(),
+      GenerateTypeAgnosticVarBinaryViewBase<StringPredicateFunctor, Predicate>(
+          utf8_view())));
   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 74650c1d76c5..e775d4d0d687 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 <limits>
 #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"
@@ -31,6 +34,7 @@
 #include "arrow/type.h"
 #include "arrow/type_fwd.h"
 #include "arrow/type_traits.h"
+#include "arrow/util/binary_view_util.h"
 #include "arrow/util/config.h"
 #include "arrow/util/type_traits.h"
 #include "arrow/util/value_parsing.h"
@@ -2870,4 +2874,152 @@ 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);
+  }
+}
+
+// Both view types share the BinaryViewType kernel, but ignore_case folding depends
+// on the logical input type: utf8_view folds UTF-8 characters (É matches é), while
+// binary_view matches byte-wise as Latin-1, where the UTF-8 bytes of É and é are
+// not case variants of each other.
+TEST(TestStringViewPredicates, MatchSubstringIgnoreCase) {
+  MatchSubstringOptions options{"aé(", /*ignore_case=*/true};
+  const char* input = R"(["abc", "aEb", "baÉ(", "aé(", "ae(", "Aé("])";
+  CheckScalarUnary("match_substring", utf8_view(), input, boolean(),
+                   "[false, false, true, true, false, true]", &options);
+  CheckScalarUnary("match_substring", binary_view(), input, boolean(),
+                   "[false, false, false, true, false, true]", &options);
+}
+#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 an out-of-line header pointing at a nonexistent buffer>]
+// 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");
+  views[1].ref.size = 64;  // > kInlineSize, so decoding would follow buffer_index
+  views[1].ref.buffer_index = std::numeric_limits<int32_t>::max();
+  views[1].ref.offset = std::numeric_limits<int32_t>::max();
+  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);
+
+  // find/count/length reach nulls through the applicator path instead; assert the
+  // same invariant on a numeric-output kernel.
+  ASSERT_OK_AND_ASSIGN(Datum found, CallFunction("find_substring", {arr}, &contains));
+  AssertDatumsEqual(Datum(ArrayFromJSON(int32(), "[0, null]")), found);
+  ASSERT_OK_AND_ASSIGN(Datum length, CallFunction("utf8_length", {arr}));
+  AssertDatumsEqual(Datum(ArrayFromJSON(int32(), "[2, null]")), length);
+}
+
 }  // 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 6d4525c28696..ca4ddc1c9fc4 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
@@ -698,6 +698,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 15d426dca6c6..1b6f39b41c2a 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -906,6 +906,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:
@@ -1035,6 +1038,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.
 
@@ -1063,6 +1067,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
@@ -1244,6 +1249,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 |
 +=======================+=======+===================================+================+=================================+=======+