From ade20b392515097211344ffdb7d41150509c3ead Mon Sep 17 00:00:00 2001
From: Nathan Chung <nathanwjchung@gmail.com>
Date: Tue, 1 Sep 2026 23:50:50 -0500
Subject: [PATCH 1/2] GH-35815: [C++] Provided dictionary support for utf8_trim

What was broken: utf8_trim/utf8_ltrim/utf8_rtrim errored out on dictionary
encoded string input instead of working because the functions only had
kernels that registered for plain and not for dictionary so the dispatch
didn't have anywhere to go. My fix was to add a small ScalarFunction subclass
that unwraps a dictionary to its value type and tries again if no exact type
kernel matches. I registered the three trim functions with this subclass
instead of the default one. To test I added a dictionary input case to the
existing TrimUTF8 test.
---
 .../compute/kernels/scalar_string_internal.h  |  4 +--
 .../compute/kernels/scalar_string_test.cc     |  4 +++
 .../compute/kernels/scalar_string_utf8.cc     | 28 +++++++++++++++++--
 3 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_internal.h b/cpp/src/arrow/compute/kernels/scalar_string_internal.h
index 5c621e8d53f5..4100098ef426 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_internal.h
+++ b/cpp/src/arrow/compute/kernels/scalar_string_internal.h
@@ -166,11 +166,11 @@ void MakeUnaryStringBatchKernel(
   ARROW_DCHECK_OK(registry->AddFunction(std::move(func)));
 }
 
-template <template <typename> class ExecFunctor>
+template <template <typename> class ExecFunctor, typename FunctionType = ScalarFunction>
 void MakeUnaryStringBatchKernelWithState(
     std::string name, FunctionRegistry* registry, FunctionDoc doc,
     MemAllocation::type mem_allocation = MemAllocation::PREALLOCATE) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), std::move(doc));
+  auto func = std::make_shared<FunctionType>(name, Arity::Unary(), std::move(doc));
   {
     using t32 = ExecFunctor<StringType>;
     ScalarKernel kernel{{utf8()}, utf8(), t32::Exec, t32::State::Init};
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 4969beada682..baa8941a3646 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -2471,6 +2471,10 @@ TYPED_TEST(TestStringKernels, TrimUTF8) {
                    "[\"zȺz矢ba\", null, \"\", \"zȺz\"]", &options);
   this->CheckUnary("utf8_rtrim", "[\"azȺz矢ba\", null, \"bab\", \"zȺz\"]", this->type(),
                    "[\"azȺz矢\", null, \"\", \"zȺz\"]", &options);
+  this->CheckUnary("utf8_trim",
+                   ArrayFromJSON(dictionary(int32(), this->type()),
+                                 R"(["azȺz矢ba", null, "bab", "zȺz"])"),
+                   this->type(), R"(["zȺz矢", null, "", "zȺz"])", &options);
 
   options = TrimOptions{"ȺA"};
   this->CheckUnary("utf8_trim", "[\"ȺȺfoo矢ȺAȺ\", null, \"barȺAȺ\", \"ȺAȺfooȺAȺ矢barA\"]",
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
index 582d559dde2e..af69c7ca8ef7 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_utf8.cc
@@ -881,10 +881,32 @@ const FunctionDoc utf8_rtrim_whitespace_doc(
 
 #endif  // ARROW_WITH_UTF8PROC
 
+// Trim functions additionally dispatch dictionary-encoded inputs to the kernel
+// for their value type (the dictionary is then decoded via Cast() before Exec
+// runs), matching CompareFunction/ScalarCTypeToInt64Function elsewhere.
+struct UnaryStringWithDictionaryFunction : public ScalarFunction {
+  using ScalarFunction::ScalarFunction;
+
+  Result<const Kernel*> DispatchBest(std::vector<TypeHolder>* types) const override {
+    RETURN_NOT_OK(CheckArity(types->size()));
+
+    using arrow::compute::detail::DispatchExactImpl;
+    if (auto kernel = DispatchExactImpl(this, *types)) return kernel;
+
+    EnsureDictionaryDecoded(types);
+
+    if (auto kernel = DispatchExactImpl(this, *types)) return kernel;
+    return arrow::compute::detail::NoMatchingKernel(this, *types);
+  }
+};
+
 void AddUtf8StringTrim(FunctionRegistry* registry) {
-  MakeUnaryStringBatchKernelWithState<UTF8Trim>("utf8_trim", registry, utf8_trim_doc);
-  MakeUnaryStringBatchKernelWithState<UTF8LTrim>("utf8_ltrim", registry, utf8_ltrim_doc);
-  MakeUnaryStringBatchKernelWithState<UTF8RTrim>("utf8_rtrim", registry, utf8_rtrim_doc);
+  MakeUnaryStringBatchKernelWithState<UTF8Trim, UnaryStringWithDictionaryFunction>(
+      "utf8_trim", registry, utf8_trim_doc);
+  MakeUnaryStringBatchKernelWithState<UTF8LTrim, UnaryStringWithDictionaryFunction>(
+      "utf8_ltrim", registry, utf8_ltrim_doc);
+  MakeUnaryStringBatchKernelWithState<UTF8RTrim, UnaryStringWithDictionaryFunction>(
+      "utf8_rtrim", registry, utf8_rtrim_doc);
 #ifdef ARROW_WITH_UTF8PROC
   MakeUnaryStringBatchKernel<UTF8TrimWhitespace>("utf8_trim_whitespace", registry,
                                                  utf8_trim_whitespace_doc);

From 791897a1357b6f4652b1a42af136188c5c4c447c Mon Sep 17 00:00:00 2001
From: Nathan Chung <nathanwjchung@gmail.com>
Date: Wed, 2 Sep 2026 00:16:29 -0500
Subject: [PATCH 2/2] Add ltrim/rtrim dictionary test coverage per Copilot
 review

Responding to Copilot's automated review on PR #51134. I added ltrim/rtrim
dictionary cases and switched all three to int64 indices. Verified through
arrow-compute-scalar-type-test with 253/253 tests still passing and the
pre-commit being clean.
---
 cpp/src/arrow/compute/kernels/scalar_string_test.cc | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index baa8941a3646..a7f105d2d6b6 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -2472,9 +2472,17 @@ TYPED_TEST(TestStringKernels, TrimUTF8) {
   this->CheckUnary("utf8_rtrim", "[\"azȺz矢ba\", null, \"bab\", \"zȺz\"]", this->type(),
                    "[\"azȺz矢\", null, \"\", \"zȺz\"]", &options);
   this->CheckUnary("utf8_trim",
-                   ArrayFromJSON(dictionary(int32(), this->type()),
+                   ArrayFromJSON(dictionary(int64(), this->type()),
                                  R"(["azȺz矢ba", null, "bab", "zȺz"])"),
                    this->type(), R"(["zȺz矢", null, "", "zȺz"])", &options);
+  this->CheckUnary("utf8_ltrim",
+                   ArrayFromJSON(dictionary(int64(), this->type()),
+                                 R"(["azȺz矢ba", null, "bab", "zȺz"])"),
+                   this->type(), R"(["zȺz矢ba", null, "", "zȺz"])", &options);
+  this->CheckUnary("utf8_rtrim",
+                   ArrayFromJSON(dictionary(int64(), this->type()),
+                                 R"(["azȺz矢ba", null, "bab", "zȺz"])"),
+                   this->type(), R"(["azȺz矢", null, "", "zȺz"])", &options);
 
   options = TrimOptions{"ȺA"};
   this->CheckUnary("utf8_trim", "[\"ȺȺfoo矢ȺAȺ\", null, \"barȺAȺ\", \"ȺAȺfooȺAȺ矢barA\"]",