From 282c6baa43d187e1ad59cb3077e6d7bc814c9f53 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 3 Sep 2021 19:03:22 -0400
Subject: [PATCH 01/84] add kernel executor for string binary functions

---
 .../arrow/compute/kernels/scalar_string.cc    | 219 +++++++++++++++++-
 1 file changed, 208 insertions(+), 11 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 3fce9dd8e4a..80617fc7410 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -346,21 +346,23 @@ struct StringTransformExecBase {
 
   static Status Execute(KernelContext* ctx, StringTransform* transform,
                         const ExecBatch& batch, Datum* out) {
+    if (batch.num_values() != 1) {
+      return Status::Invalid("Invalid arity for unary string transform");
+    }
+
     if (batch[0].kind() == Datum::ARRAY) {
       return ExecArray(ctx, transform, batch[0].array(), out);
+    } else if (batch[0].kind() == Datum::SCALAR) {
+      return ExecScalar(ctx, transform, batch[0].scalar(), out);
     }
-    DCHECK_EQ(batch[0].kind(), Datum::SCALAR);
-    return ExecScalar(ctx, transform, batch[0].scalar(), out);
+    return Status::Invalid("Invalid ExecBatch kind for unary string transform");
   }
 
   static Status ExecArray(KernelContext* ctx, StringTransform* transform,
                           const std::shared_ptr<ArrayData>& data, Datum* out) {
     ArrayType input(data);
-    ArrayData* output = out->mutable_array();
-
     const int64_t input_ncodeunits = input.total_values_length();
     const int64_t input_nstrings = input.length();
-
     const int64_t output_ncodeunits_max =
         transform->MaxCodeunits(input_nstrings, input_ncodeunits);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
@@ -368,6 +370,7 @@ struct StringTransformExecBase {
           "Result might not fit in a 32bit utf8 array, convert to large_utf8");
     }
 
+    ArrayData* output = out->mutable_array();
     ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
     output->buffers[2] = values_buffer;
 
@@ -375,7 +378,6 @@ struct StringTransformExecBase {
     offset_type* output_string_offsets = output->GetMutableValues<offset_type>(1);
     uint8_t* output_str = output->buffers[2]->mutable_data();
     offset_type output_ncodeunits = 0;
-
     output_string_offsets[0] = 0;
     for (int64_t i = 0; i < input_nstrings; i++) {
       if (!input.IsNull(i)) {
@@ -402,16 +404,16 @@ struct StringTransformExecBase {
     if (!input.is_valid) {
       return Status::OK();
     }
-    auto* result = checked_cast<BaseBinaryScalar*>(out->scalar().get());
-    result->is_valid = true;
     const int64_t data_nbytes = static_cast<int64_t>(input.value->size());
-
     const int64_t output_ncodeunits_max = transform->MaxCodeunits(1, data_nbytes);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
           "Result might not fit in a 32bit utf8 array, convert to large_utf8");
     }
+
     ARROW_ASSIGN_OR_RAISE(auto value_buffer, ctx->Allocate(output_ncodeunits_max));
+    auto* result = checked_cast<BaseBinaryScalar*>(out->scalar().get());
+    result->is_valid = true;
     result->value = value_buffer;
     auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
         input.value->data(), data_nbytes, value_buffer->mutable_data()));
@@ -537,6 +539,203 @@ struct FixedSizeBinaryTransformExecWithState
   }
 };
 
+/// Kernel exec generator for binary string transforms.
+/// The first parameter is expected to always be a string type while the second parameter
+/// is generic. It supports executions of the form:
+///   * Scalar, Scalar
+///   * Array, Scalar - scalar is broadcasted and paired with all values of array
+///   * Array, Array - arrays are processed element-wise
+///   * Scalar, Array - not supported by default
+template <typename Type1, typename Type2, typename StringTransform>
+struct StringBinaryTransformExecBase {
+  using offset_type = typename Type1::offset_type;
+  using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
+  using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
+
+  static Status Execute(KernelContext* ctx, StringTransform* transform,
+                        const ExecBatch& batch, Datum* out) {
+    if (batch.num_values() != 2) {
+      return Status::Invalid("Invalid arity for binary string transform");
+    }
+
+    if (batch[0].is_array()) {
+      if (batch[1].is_array()) {
+        return ExecArrayArray(ctx, transform, batch[0].array(), batch[1].array(), out);
+      } else if (batch[1].is_scalar()) {
+        return ExecArrayScalar(ctx, transform, batch[0].array(), batch[1].scalar(), out);
+      }
+    } else if (batch[0].is_scalar()) {
+      if (batch[1].is_array()) {
+        return ExecScalarArray(ctx, transform, batch[0].scalar(), batch[1].array(), out);
+      } else if (batch[1].is_scalar()) {
+        return ExecScalarScalar(ctx, transform, batch[0].scalar(), batch[1].scalar(),
+                                out);
+      }
+    }
+    return Status::Invalid("Invalid ExecBatch kind for binary string transform");
+  }
+
+ private:
+  static Status ExecScalarScalar(KernelContext* ctx, StringTransform* transform,
+                                 const std::shared_ptr<Scalar>& scalar1,
+                                 const std::shared_ptr<Scalar>& scalar2, Datum* out) {
+    const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
+    // TODO(edponce): How to validate inputs? For some kernels, returning null is ok
+    // (ascii_lower) but others not necessarily (concatenate)
+    if (!input1.is_valid) {
+      return Status::OK();
+    }
+
+    auto input_ncodeunits = input1.value->size();
+    auto input_nstrings = 1;
+    auto output_ncodeunits_max =
+        transform->MaxCodeunits(input_nstrings, input_ncodeunits);
+    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
+      return Status::CapacityError(
+          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
+    }
+
+    ARROW_ASSIGN_OR_RAISE(auto value_buffer, ctx->Allocate(output_ncodeunits_max));
+    auto result = checked_cast<BaseBinaryScalar*>(out->scalar().get());
+    result->is_valid = true;
+    result->value = value_buffer;
+    auto output_str = value_buffer->mutable_data();
+
+    auto input1_string = input1.value->data();
+    auto encoded_nbytes =
+        transform->Transform(input1_string, input_ncodeunits, scalar2, output_str);
+    if (encoded_nbytes < 0) {
+      return transform->InvalidStatus();
+    }
+    DCHECK_LE(encoded_nbytes, output_ncodeunits_max);
+    return value_buffer->Resize(encoded_nbytes, /*shrink_to_fit=*/true);
+  }
+
+  static Status ExecArrayScalar(KernelContext* ctx, StringTransform* transform,
+                                const std::shared_ptr<ArrayData>& data1,
+                                const std::shared_ptr<Scalar>& scalar2, Datum* out) {
+    ArrayType1 input1(data1);
+
+    auto input1_ncodeunits = input1.total_values_length();
+    auto input1_nstrings = input1.length();
+    auto output_ncodeunits_max =
+        transform->MaxCodeunits(input1_nstrings, input1_ncodeunits);
+    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
+      return Status::CapacityError(
+          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
+    }
+
+    ArrayData* output = out->mutable_array();
+    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
+    output->buffers[2] = values_buffer;
+
+    // String offsets are preallocated
+    auto output_string_offsets = output->GetMutableValues<offset_type>(1);
+    auto output_str = output->buffers[2]->mutable_data();
+    output_string_offsets[0] = 0;
+
+    offset_type output_ncodeunits = 0;
+    for (int64_t i = 0; i < input1_nstrings; ++i) {
+      if (!input1.IsNull(i)) {
+        offset_type input1_string_ncodeunits;
+        auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
+        auto encoded_nbytes =
+            transform->Transform(input1_string, input1_string_ncodeunits, scalar2,
+                                 output_str + output_ncodeunits);
+        if (encoded_nbytes < 0) {
+          return transform->InvalidStatus();
+        }
+        output_ncodeunits += encoded_nbytes;
+      }
+      output_string_offsets[i + 1] = output_ncodeunits;
+    }
+    DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
+
+    // Trim the codepoint buffer, since we allocated too much
+    return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
+    return Status::OK();
+  }
+
+  static Status ExecScalarArray(KernelContext* ctx, StringTransform* transform,
+                                const std::shared_ptr<Scalar>& scalar1,
+                                const std::shared_ptr<ArrayData>& data2, Datum* out) {
+    return Status::NotImplemented(
+        "Binary string transforms with (scalar, array) inputs are not supported for the "
+        "general case");
+  }
+
+  static Status ExecArrayArray(KernelContext* ctx, StringTransform* transform,
+                               const std::shared_ptr<ArrayData>& data1,
+                               const std::shared_ptr<ArrayData>& data2, Datum* out) {
+    ArrayType1 input1(data1);
+    ArrayType2 input2(data2);
+
+    auto input1_ncodeunits = input1.total_values_length();
+    auto input1_nstrings = input1.length();
+    auto output_ncodeunits_max =
+        transform->MaxCodeunits(input1_nstrings, input1_ncodeunits);
+    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
+      return Status::CapacityError(
+          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
+    }
+
+    ArrayData* output = out->mutable_array();
+    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
+    output->buffers[2] = values_buffer;
+
+    // String offsets are preallocated
+    auto output_string_offsets = output->GetMutableValues<offset_type>(1);
+    auto output_str = output->buffers[2]->mutable_data();
+    output_string_offsets[0] = 0;
+
+    offset_type output_ncodeunits = 0;
+    for (int64_t i = 0; i < input1_nstrings; ++i) {
+      if (!input1.IsNull(i)) {
+        offset_type input1_string_ncodeunits;
+        auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
+        auto scalar2 = *input2.GetScalar(i);
+        auto encoded_nbytes =
+            transform->Transform(input1_string, input1_string_ncodeunits, scalar2,
+                                 output_str + output_ncodeunits);
+        if (encoded_nbytes < 0) {
+          return transform->InvalidStatus();
+        }
+        output_ncodeunits += encoded_nbytes;
+      }
+      output_string_offsets[i + 1] = output_ncodeunits;
+    }
+    DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
+
+    // Trim the codepoint buffer, since we allocated too much
+    return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
+  }
+};
+
+template <typename Type1, typename Type2, typename StringTransform>
+struct StringBinaryTransformExec
+    : public StringBinaryTransformExecBase<Type1, Type2, StringTransform> {
+  using StringBinaryTransformExecBase<Type1, Type2, StringTransform>::Execute;
+
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    StringTransform transform;
+    RETURN_NOT_OK(transform.PreExec(ctx, batch, out));
+    return Execute(ctx, &transform, batch, out);
+  }
+};
+
+template <typename Type1, typename Type2, typename StringTransform>
+struct StringBinaryTransformExecWithState
+    : public StringBinaryTransformExecBase<Type1, Type2, StringTransform> {
+  using State = typename StringTransform::State;
+  using StringBinaryTransformExecBase<Type1, Type2, StringTransform>::Execute;
+
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    StringTransform transform(State::Get(ctx));
+    RETURN_NOT_OK(transform.PreExec(ctx, batch, out));
+    return Execute(ctx, &transform, batch, out);
+  }
+};
+
 #ifdef ARROW_WITH_UTF8PROC
 
 struct FunctionalCaseMappingTransform : public StringTransformBase {
@@ -4430,7 +4629,6 @@ const FunctionDoc utf8_reverse_doc(
      "clusters. Hence, it will not correctly reverse grapheme clusters\n"
      "composed of multiple codepoints."),
     {"strings"});
-
 }  // namespace
 
 void RegisterScalarStringAscii(FunctionRegistry* registry) {
@@ -4454,7 +4652,6 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
                                                    &ascii_rtrim_whitespace_doc);
   MakeUnaryStringBatchKernel<AsciiReverse>("ascii_reverse", registry, &ascii_reverse_doc);
   MakeUnaryStringBatchKernel<Utf8Reverse>("utf8_reverse", registry, &utf8_reverse_doc);
-
   MakeUnaryStringBatchKernelWithState<AsciiCenter>("ascii_center", registry,
                                                    &ascii_center_doc);
   MakeUnaryStringBatchKernelWithState<AsciiLPad>("ascii_lpad", registry, &ascii_lpad_doc);

From b390acd25d73f5b8ece21ad8cf8311d63027de05 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 3 Sep 2021 22:21:42 -0400
Subject: [PATCH 02/84] add comments/notes

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 80617fc7410..dfdfad1c6ea 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -334,9 +334,13 @@ struct StringTransformBase {
     return Status::Invalid("Invalid UTF8 sequence in input");
   }
 
-  // Derived classes should also define this method:
+  // Unary derived classes should define this method:
   //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
   //                     uint8_t* output);
+
+  // Binary derived classes should define this method:
+  //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits, const
+  //   std::shared_ptr<Scalar>& input2, uint8_t* output);
 };
 
 template <typename Type, typename StringTransform>
@@ -546,6 +550,8 @@ struct FixedSizeBinaryTransformExecWithState
 ///   * Array, Scalar - scalar is broadcasted and paired with all values of array
 ///   * Array, Array - arrays are processed element-wise
 ///   * Scalar, Array - not supported by default
+// TODO(edponce): For when second parameter is an array, need to specify a corresponding
+// iterator/visitor.
 template <typename Type1, typename Type2, typename StringTransform>
 struct StringBinaryTransformExecBase {
   using offset_type = typename Type1::offset_type;

From e327e62d73d93d08f0180d4443c34b783f12c92e Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 6 Sep 2021 20:07:30 -0400
Subject: [PATCH 03/84] add second input to MaxCodeunits

---
 .../arrow/compute/kernels/scalar_string.cc    | 57 ++++++++++++-------
 1 file changed, 38 insertions(+), 19 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index dfdfad1c6ea..590947f0102 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -333,14 +333,6 @@ struct StringTransformBase {
   virtual Status InvalidStatus() {
     return Status::Invalid("Invalid UTF8 sequence in input");
   }
-
-  // Unary derived classes should define this method:
-  //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
-  //                     uint8_t* output);
-
-  // Binary derived classes should define this method:
-  //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits, const
-  //   std::shared_ptr<Scalar>& input2, uint8_t* output);
 };
 
 template <typename Type, typename StringTransform>
@@ -427,6 +419,10 @@ struct StringTransformExecBase {
     DCHECK_LE(encoded_nbytes, output_ncodeunits_max);
     return value_buffer->Resize(encoded_nbytes, /*shrink_to_fit=*/true);
   }
+
+  // Unary derived classes should define this method:
+  //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
+  //                     uint8_t* output);
 };
 
 template <typename Type, typename StringTransform>
@@ -543,6 +539,26 @@ struct FixedSizeBinaryTransformExecWithState
   }
 };
 
+struct StringBinaryTransformBase {
+  virtual Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    return Status::OK();
+  }
+
+  // Return the maximum total size of the output in codeunits (i.e. bytes)
+  // given input characteristics.
+  virtual int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits,
+                               const std::shared_ptr<Scalar>& input2) {
+    return input_ncodeunits;
+  }
+
+  // Return the maximum total size of the output in codeunits (i.e. bytes)
+  // given input characteristics.
+  virtual int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits,
+                               const std::shared_ptr<ArrayData>& data2) {
+    return input_ncodeunits;
+  }
+};
+
 /// Kernel exec generator for binary string transforms.
 /// The first parameter is expected to always be a string type while the second parameter
 /// is generic. It supports executions of the form:
@@ -550,8 +566,6 @@ struct FixedSizeBinaryTransformExecWithState
 ///   * Array, Scalar - scalar is broadcasted and paired with all values of array
 ///   * Array, Array - arrays are processed element-wise
 ///   * Scalar, Array - not supported by default
-// TODO(edponce): For when second parameter is an array, need to specify a corresponding
-// iterator/visitor.
 template <typename Type1, typename Type2, typename StringTransform>
 struct StringBinaryTransformExecBase {
   using offset_type = typename Type1::offset_type;
@@ -585,17 +599,15 @@ struct StringBinaryTransformExecBase {
   static Status ExecScalarScalar(KernelContext* ctx, StringTransform* transform,
                                  const std::shared_ptr<Scalar>& scalar1,
                                  const std::shared_ptr<Scalar>& scalar2, Datum* out) {
-    const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
-    // TODO(edponce): How to validate inputs? For some kernels, returning null is ok
-    // (ascii_lower) but others not necessarily (concatenate)
-    if (!input1.is_valid) {
+    if (!scalar1->is_valid || !scalar2->is_valid) {
       return Status::OK();
     }
 
+    const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
     auto input_ncodeunits = input1.value->size();
     auto input_nstrings = 1;
     auto output_ncodeunits_max =
-        transform->MaxCodeunits(input_nstrings, input_ncodeunits);
+        transform->MaxCodeunits(input_nstrings, input_ncodeunits, scalar2);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
           "Result might not fit in a 32bit utf8 array, convert to large_utf8");
@@ -620,12 +632,15 @@ struct StringBinaryTransformExecBase {
   static Status ExecArrayScalar(KernelContext* ctx, StringTransform* transform,
                                 const std::shared_ptr<ArrayData>& data1,
                                 const std::shared_ptr<Scalar>& scalar2, Datum* out) {
-    ArrayType1 input1(data1);
+    if (!scalar2->is_valid) {
+      return Status::OK();
+    }
 
+    ArrayType1 input1(data1);
     auto input1_ncodeunits = input1.total_values_length();
     auto input1_nstrings = input1.length();
     auto output_ncodeunits_max =
-        transform->MaxCodeunits(input1_nstrings, input1_ncodeunits);
+        transform->MaxCodeunits(input1_nstrings, input1_ncodeunits, scalar2);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
           "Result might not fit in a 32bit utf8 array, convert to large_utf8");
@@ -679,7 +694,7 @@ struct StringBinaryTransformExecBase {
     auto input1_ncodeunits = input1.total_values_length();
     auto input1_nstrings = input1.length();
     auto output_ncodeunits_max =
-        transform->MaxCodeunits(input1_nstrings, input1_ncodeunits);
+        transform->MaxCodeunits(input1_nstrings, input1_ncodeunits, data2);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
           "Result might not fit in a 32bit utf8 array, convert to large_utf8");
@@ -696,7 +711,7 @@ struct StringBinaryTransformExecBase {
 
     offset_type output_ncodeunits = 0;
     for (int64_t i = 0; i < input1_nstrings; ++i) {
-      if (!input1.IsNull(i)) {
+      if (!input1.IsNull(i) || !input2.IsNull(i)) {
         offset_type input1_string_ncodeunits;
         auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
         auto scalar2 = *input2.GetScalar(i);
@@ -715,6 +730,10 @@ struct StringBinaryTransformExecBase {
     // Trim the codepoint buffer, since we allocated too much
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
+
+  // Binary derived classes should define this method:
+  //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits, const
+  //   std::shared_ptr<Scalar>& input2, uint8_t* output);
 };
 
 template <typename Type1, typename Type2, typename StringTransform>

From 91baa30009cb8e53478c970bb34b916a8993ee37 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 6 Sep 2021 20:32:53 -0400
Subject: [PATCH 04/84] add inheritance to have PreExec and InvalidStatus

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 590947f0102..629ff1aa0cb 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -539,11 +539,7 @@ struct FixedSizeBinaryTransformExecWithState
   }
 };
 
-struct StringBinaryTransformBase {
-  virtual Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    return Status::OK();
-  }
-
+struct StringBinaryTransformBase : StringTransformBase {
   // Return the maximum total size of the output in codeunits (i.e. bytes)
   // given input characteristics.
   virtual int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits,

From 673b41342611f842baf82c6d35fcf0a8c4acd3c9 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 27 Aug 2021 12:08:57 -0400
Subject: [PATCH 05/84] add RepeatOptions

---
 cpp/src/arrow/compute/api_scalar.cc |  8 ++++++++
 cpp/src/arrow/compute/api_scalar.h  | 10 ++++++++++
 2 files changed, 18 insertions(+)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index e3fe1bdf73d..0c95db809d5 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -209,6 +209,8 @@ static auto kSplitPatternOptionsType = GetFunctionOptionsType<SplitPatternOption
     DataMember("pattern", &SplitPatternOptions::pattern),
     DataMember("max_splits", &SplitPatternOptions::max_splits),
     DataMember("reverse", &SplitPatternOptions::reverse));
+static auto kRepeatOptionsType =
+    GetFunctionOptionsType<RepeatOptions>(DataMember("repeats", &RepeatOptions::repeats));
 static auto kReplaceSliceOptionsType = GetFunctionOptionsType<ReplaceSliceOptions>(
     DataMember("start", &ReplaceSliceOptions::start),
     DataMember("stop", &ReplaceSliceOptions::stop),
@@ -319,6 +321,11 @@ SplitPatternOptions::SplitPatternOptions(std::string pattern, int64_t max_splits
 SplitPatternOptions::SplitPatternOptions() : SplitPatternOptions("", -1, false) {}
 constexpr char SplitPatternOptions::kTypeName[];
 
+RepeatOptions::RepeatOptions(int64_t repeats)
+    : FunctionOptions(internal::kRepeatOptionsType), repeats(repeats) {}
+RepeatOptions::RepeatOptions() : RepeatOptions(1){};
+constexpr char RepeatOptions::kTypeName[];
+
 ReplaceSliceOptions::ReplaceSliceOptions(int64_t start, int64_t stop,
                                          std::string replacement)
     : FunctionOptions(internal::kReplaceSliceOptionsType),
@@ -440,6 +447,7 @@ void RegisterScalarOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kMatchSubstringOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSplitOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSplitPatternOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kRepeatOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kReplaceSliceOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kReplaceSubstringOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kExtractRegexOptionsType));
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 4bb18b37527..83b3917ef1a 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -166,6 +166,16 @@ class ARROW_EXPORT SplitPatternOptions : public FunctionOptions {
   bool reverse;
 };
 
+class ARROW_EXPORT RepeatOptions : public FunctionOptions {
+ public:
+  explicit RepeatOptions(int64_t repeats);
+  RepeatOptions();
+  constexpr static char const kTypeName[] = "RepeatOptions";
+
+  /// Number of repeats
+  int64_t repeats;
+};
+
 class ARROW_EXPORT ReplaceSliceOptions : public FunctionOptions {
  public:
   explicit ReplaceSliceOptions(int64_t start, int64_t stop, std::string replacement);

From 543174cfa5de7a24f19d248bb5cb80f5741dd548 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 27 Aug 2021 17:58:25 -0400
Subject: [PATCH 06/84] add str repeat kernel

---
 .../arrow/compute/kernels/scalar_string.cc    | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 629ff1aa0cb..79ddc95b1e2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2733,6 +2733,31 @@ void AddSplit(FunctionRegistry* registry) {
 #endif
 }
 
+struct StrRepeatTransform : public StringTransformBase {
+  using Options = RepeatOptions;
+  using State = OptionsWrapper<Options>;
+
+  const Options* options;
+
+  explicit StrRepeatTransform(const Options& options) : options{&options} {}
+
+  int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits) override {
+    return input_ncodeunits * std::max<int64_t>(options->repeats, 0);
+  }
+
+  int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
+                    uint8_t* output) {
+    uint8_t* output_start = output;
+    for (int i = 0; i < options->repeats; ++i) {
+      output = std::copy(input, input + input_string_ncodeunits, output);
+    }
+    return output - output_start;
+  }
+};
+
+template <typename Type>
+using StrRepeat = StringTransformExecWithState<Type, StrRepeatTransform>;
+
 // ----------------------------------------------------------------------
 // Replace substring (plain, regex)
 

From 00be5a0146e60a58b853511e85fd06d41e5702c9 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 27 Aug 2021 18:26:28 -0400
Subject: [PATCH 07/84] add tests

---
 .../compute/kernels/scalar_string_test.cc     | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index be22ef4a7c1..a2987ff32bf 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -17,6 +17,8 @@
 
 #include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -1041,6 +1043,27 @@ TYPED_TEST(TestStringKernels, Utf8Title) {
       R"([null, "", "B", "Aaaz;Zææ&", "Ɑɽɽow", "Ii", "Ⱥ.Ⱥ.Ⱥ..Ⱥ", "Hello, World!", "Foo   Bar;Héhé0Zop", "!%$^.,;"])");
 }
 
+TYPED_TEST(TestStringKernels, StrRepeat) {
+  RepeatOptions options;
+  this->CheckUnary("str_repeat", "[]", this->type(), "[]", &options);
+
+  std::string values(
+      R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+  std::vector<std::pair<int64_t, std::string>> repeats_and_expected_map({
+      {-1, R"(["", null, "", "", "", "", "", "", "", ""])"},
+      {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
+      {1,
+       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
+      {3,
+       R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbb", "ɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
+  });
+
+  for (const auto& pair : repeats_and_expected_map) {
+    options.repeats = pair.first;
+    this->CheckUnary("str_repeat", values, this->type(), pair.second, &options);
+  }
+}
+
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {
   // U+08BE (utf8: 	\xE0\xA2\xBE) is undefined, but utf8proc things it is
   // UTF8PROC_CATEGORY_LO

From cabe6a7d212846e585b5b037b3167a73242ace95 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 27 Aug 2021 18:31:02 -0400
Subject: [PATCH 08/84] update docs

---
 docs/source/cpp/compute.rst        | 80 +++++++++++++++---------------
 docs/source/python/api/compute.rst |  1 +
 2 files changed, 42 insertions(+), 39 deletions(-)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 0a87752e92d..1312edca61b 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -812,45 +812,47 @@ The third set of functions examines string elements on a byte-per-byte basis:
 String transforms
 ~~~~~~~~~~~~~~~~~
 
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| Function name           | Arity | Input types            | Output type            | Options class                     | Notes |
-+=========================+=======+========================+========================+===================================+=======+
-| ascii_capitalize        | Unary | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_lower             | Unary | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_reverse           | Unary | String-like            | String-like            |                                   | \(2)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_swapcase          | Unary | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_title             | Unary | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_upper             | Unary | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| binary_length           | Unary | Binary- or String-like | Int32 or Int64         |                                   | \(3)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| binary_replace_slice    | Unary | Binary- or String-like | Binary- or String-like | :struct:`ReplaceSliceOptions`     | \(4)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| replace_substring       | Unary | Binary- or String-like | Binary- or String-like | :struct:`ReplaceSubstringOptions` | \(5)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| replace_substring_regex | Unary | Binary- or String-like | Binary- or String-like | :struct:`ReplaceSubstringOptions` | \(6)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_capitalize         | Unary | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_length             | Unary | String-like            | Int32 or Int64         |                                   | \(7)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_lower              | Unary | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_replace_slice      | Unary | String-like            | String-like            | :struct:`ReplaceSliceOptions`     | \(4)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_reverse            | Unary | String-like            | String-like            |                                   | \(9)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_swapcase           | Unary | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_title              | Unary | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_upper              | Unary | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+-------+------------------------+------------------------+-----------------------------------+-------+
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| Function name           | Arity  | Input types            | Output type            | Options class                     | Notes |
++=========================+========+========================+========================+===================================+=======+
+| ascii_capitalize        | Unary  | String-like            | String-like            |                                   | \(1)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| ascii_lower             | Unary  | String-like            | String-like            |                                   | \(1)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| ascii_reverse           | Unary  | String-like            | String-like            |                                   | \(2)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| ascii_swapcase          | Unary  | String-like            | String-like            |                                   | \(1)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| ascii_title             | Unary  | String-like            | String-like            |                                   | \(1)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| ascii_upper             | Unary  | String-like            | String-like            |                                   | \(1)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| binary_length           | Unary  | Binary- or String-like | Int32 or Int64         |                                   | \(3)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| binary_replace_slice    | Unary  | String-like            | Binary- or String-like | :struct:`ReplaceSliceOptions`     | \(4)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| replace_substring       | Unary  | String-like            | String-like            | :struct:`ReplaceSubstringOptions` | \(5)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| replace_substring_regex | Unary  | String-like            | String-like            | :struct:`ReplaceSubstringOptions` | \(6)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| str_repeat              | Binary | String-like            | String-like            | :struct:`RepeatOptions`           |       |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| utf8_capitalize         | Unary  | String-like            | String-like            |                                   | \(8)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| utf8_length             | Unary  | String-like            | Int32 or Int64         |                                   | \(7)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| utf8_lower              | Unary  | String-like            | String-like            |                                   | \(8)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| utf8_replace_slice      | Unary  | String-like            | String-like            | :struct:`ReplaceSliceOptions`     | \(4)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| utf8_reverse            | Unary  | String-like            | String-like            |                                   | \(9)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| utf8_swapcase           | Unary  | String-like            | String-like            |                                   | \(8)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| utf8_title              | Unary  | String-like            | String-like            |                                   | \(8)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
+| utf8_upper              | Unary  | String-like            | String-like            |                                   | \(8)  |
++-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
 
 * \(1) Each ASCII character in the input is converted to lowercase or
   uppercase.  Non-ASCII characters are left untouched.
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index 521182f8a41..a56cc9dfce0 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -270,6 +270,7 @@ String Transforms
    binary_replace_slice
    replace_substring
    replace_substring_regex
+   str_repeat
    utf8_capitalize
    utf8_length
    utf8_lower

From 2d4fcb6fdc19f110d389d4311aef4cc14f1cdfd2 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 27 Aug 2021 22:47:32 -0400
Subject: [PATCH 09/84] fix linter error

---
 cpp/src/arrow/compute/api_scalar.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 0c95db809d5..1bfe9bd4a87 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -323,7 +323,7 @@ constexpr char SplitPatternOptions::kTypeName[];
 
 RepeatOptions::RepeatOptions(int64_t repeats)
     : FunctionOptions(internal::kRepeatOptionsType), repeats(repeats) {}
-RepeatOptions::RepeatOptions() : RepeatOptions(1){};
+RepeatOptions::RepeatOptions() : RepeatOptions(1) {}
 constexpr char RepeatOptions::kTypeName[];
 
 ReplaceSliceOptions::ReplaceSliceOptions(int64_t start, int64_t stop,

From dfa931d26417b59ee89cffdfb407b36590d44182 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sat, 28 Aug 2021 03:05:52 -0400
Subject: [PATCH 10/84] add doubling approach and benchmark

---
 .../arrow/compute/kernels/scalar_string.cc    | 20 +++++++++++++++++--
 .../kernels/scalar_string_benchmark.cc        |  6 ++++++
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 79ddc95b1e2..d233501d4b7 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2748,8 +2748,24 @@ struct StrRepeatTransform : public StringTransformBase {
   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
                     uint8_t* output) {
     uint8_t* output_start = output;
-    for (int i = 0; i < options->repeats; ++i) {
-      output = std::copy(input, input + input_string_ncodeunits, output);
+
+    if (options->repeats < 4) {
+      // Naive for-loop
+      for (auto i = 0; i < options->repeats; ++i) {
+        output = std::copy(input, input + input_string_ncodeunits, output);
+      }
+    } else {
+      auto N = options->repeats;
+      auto L = input_string_ncodeunits;
+      auto i = 1;
+      // log(N) approach
+      output = std::copy(input, input + L, output);
+      for (auto iL = L; i <= (N >> 1); i <<= 1, iL <<= 1) {
+        output = std::copy(output_start, output_start + iL, output);
+      }
+      // Epilogue remainder
+      auto rem = (N ^ i) * L;
+      output = std::copy(output_start, output_start + rem, output);
     }
     return output - output_start;
   }
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index ddc3a56f00f..71061f49404 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -77,6 +77,11 @@ static void SplitPattern(benchmark::State& state) {
   UnaryStringBenchmark(state, "split_pattern", &options);
 }
 
+static void StrRepeat(benchmark::State& state) {
+  RepeatOptions options(8);
+  UnaryStringBenchmark(state, "str_repeat", &options);
+}
+
 static void TrimSingleAscii(benchmark::State& state) {
   TrimOptions options("a");
   UnaryStringBenchmark(state, "ascii_trim", &options);
@@ -215,6 +220,7 @@ BENCHMARK(AsciiUpper);
 BENCHMARK(IsAlphaNumericAscii);
 BENCHMARK(MatchSubstring);
 BENCHMARK(SplitPattern);
+BENCHMARK(StrRepeat);
 BENCHMARK(TrimSingleAscii);
 BENCHMARK(TrimManyAscii);
 #ifdef ARROW_WITH_RE2

From d32574d567c5aad14046938599b8977ba48965c0 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sun, 29 Aug 2021 02:16:50 -0400
Subject: [PATCH 11/84] remove naive approach and add check for repeats option

---
 .../arrow/compute/kernels/scalar_string.cc    | 27 +++++++++----------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index d233501d4b7..5d0f2729ee1 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2748,24 +2748,21 @@ struct StrRepeatTransform : public StringTransformBase {
   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
                     uint8_t* output) {
     uint8_t* output_start = output;
-
-    if (options->repeats < 4) {
-      // Naive for-loop
-      for (auto i = 0; i < options->repeats; ++i) {
-        output = std::copy(input, input + input_string_ncodeunits, output);
-      }
-    } else {
-      auto N = options->repeats;
-      auto L = input_string_ncodeunits;
-      auto i = 1;
+    if (options->repeats > 0) {
       // log(N) approach
-      output = std::copy(input, input + L, output);
-      for (auto iL = L; i <= (N >> 1); i <<= 1, iL <<= 1) {
-        output = std::copy(output_start, output_start + iL, output);
+      std::memcpy(output, input, input_string_ncodeunits);
+      output += input_string_ncodeunits;
+      int64_t i = 1;
+      for (int64_t ilen = input_string_ncodeunits; i <= (options->repeats >> 1);
+           i <<= 1, ilen <<= 1) {
+        std::memcpy(output, output_start, ilen);
+        output += ilen;
       }
+
       // Epilogue remainder
-      auto rem = (N ^ i) * L;
-      output = std::copy(output_start, output_start + rem, output);
+      int64_t rem = (options->repeats ^ i) * input_string_ncodeunits;
+      std::memcpy(output, output_start, rem);
+      output += rem;
     }
     return output - output_start;
   }

From 8daa01f102c941dc148fda1a0302f1bfa46563b4 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sun, 29 Aug 2021 21:49:57 -0400
Subject: [PATCH 12/84] add support for array of repeats

---
 cpp/src/arrow/compute/api_scalar.cc           | 11 ++--
 cpp/src/arrow/compute/api_scalar.h            |  6 +-
 .../arrow/compute/kernels/scalar_string.cc    | 62 ++++++++++++++++---
 .../compute/kernels/scalar_string_test.cc     | 18 +++++-
 4 files changed, 81 insertions(+), 16 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 1bfe9bd4a87..41e4d146dc5 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -209,8 +209,9 @@ static auto kSplitPatternOptionsType = GetFunctionOptionsType<SplitPatternOption
     DataMember("pattern", &SplitPatternOptions::pattern),
     DataMember("max_splits", &SplitPatternOptions::max_splits),
     DataMember("reverse", &SplitPatternOptions::reverse));
-static auto kRepeatOptionsType =
-    GetFunctionOptionsType<RepeatOptions>(DataMember("repeats", &RepeatOptions::repeats));
+static auto kRepeatOptionsType = GetFunctionOptionsType<RepeatOptions>(
+    DataMember("nrepeats", &RepeatOptions::nrepeats),
+    DataMember("repeats", &RepeatOptions::repeats));
 static auto kReplaceSliceOptionsType = GetFunctionOptionsType<ReplaceSliceOptions>(
     DataMember("start", &ReplaceSliceOptions::start),
     DataMember("stop", &ReplaceSliceOptions::stop),
@@ -321,8 +322,10 @@ SplitPatternOptions::SplitPatternOptions(std::string pattern, int64_t max_splits
 SplitPatternOptions::SplitPatternOptions() : SplitPatternOptions("", -1, false) {}
 constexpr char SplitPatternOptions::kTypeName[];
 
-RepeatOptions::RepeatOptions(int64_t repeats)
-    : FunctionOptions(internal::kRepeatOptionsType), repeats(repeats) {}
+RepeatOptions::RepeatOptions(int64_t nrepeats)
+    : FunctionOptions(internal::kRepeatOptionsType), nrepeats(nrepeats), repeats({}) {}
+RepeatOptions::RepeatOptions(std::vector<int64_t> repeats)
+    : FunctionOptions(internal::kRepeatOptionsType), nrepeats(0), repeats(repeats) {}
 RepeatOptions::RepeatOptions() : RepeatOptions(1) {}
 constexpr char RepeatOptions::kTypeName[];
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 83b3917ef1a..86dd1c43c2a 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -168,12 +168,14 @@ class ARROW_EXPORT SplitPatternOptions : public FunctionOptions {
 
 class ARROW_EXPORT RepeatOptions : public FunctionOptions {
  public:
-  explicit RepeatOptions(int64_t repeats);
+  explicit RepeatOptions(int64_t nrepeats);
+  explicit RepeatOptions(std::vector<int64_t> repeats);
   RepeatOptions();
   constexpr static char const kTypeName[] = "RepeatOptions";
 
   /// Number of repeats
-  int64_t repeats;
+  int64_t nrepeats;
+  std::vector<int64_t> repeats;
 };
 
 class ARROW_EXPORT ReplaceSliceOptions : public FunctionOptions {
diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 5d0f2729ee1..ebe0d0293c0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2733,34 +2733,78 @@ void AddSplit(FunctionRegistry* registry) {
 #endif
 }
 
+template <typename Type>
 struct StrRepeatTransform : public StringTransformBase {
   using Options = RepeatOptions;
   using State = OptionsWrapper<Options>;
+  using ArrayType = typename TypeTraits<Type>::ArrayType;
 
   const Options* options;
+  std::function<int64_t(const uint8_t*, int64_t, uint8_t*)> Transform;
+  std::vector<int64_t>::const_iterator it;
+
+  explicit StrRepeatTransform(const Options& options) : options{&options} {
+    if (this->options->repeats.size()) {
+      // NOTE: This is an incorrect hack to iterate through the repeat values because for
+      // null entries, Transform() is not invoked and thus the iterator does not moves.
+      it = this->options->repeats.begin();
+      Transform = [&](const uint8_t* input, int64_t input_string_ncodeunits,
+                      uint8_t* output) {
+        auto nrepeats = *it++;
+        if (it == this->options->repeats.end()) {
+          it = this->options->repeats.begin();
+        }
+        return this->Transform_(input, input_string_ncodeunits, output, nrepeats);
+      };
+    } else {
+      Transform = [&](const uint8_t* input, int64_t input_string_ncodeunits,
+                      uint8_t* output) {
+        return this->Transform_(input, input_string_ncodeunits, output,
+                                this->options->nrepeats);
+      };
+    }
+  }
 
-  explicit StrRepeatTransform(const Options& options) : options{&options} {}
+  Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
+    if (options->repeats.size() && batch[0].kind() == Datum::ARRAY) {
+      ArrayType input(batch[0].array());
+      if (static_cast<int64_t>(options->repeats.size()) !=
+          static_cast<int64_t>(input.length())) {
+        return Status::Invalid(
+            "Number of repeats and input strings are differ in length");
+      }
+    }
+    return Status::OK();
+  }
 
   int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits) override {
-    return input_ncodeunits * std::max<int64_t>(options->repeats, 0);
+    // NOTE: Ideally, we would like to sum the values that correspond to non-null entries
+    // along with each inputs' size but this requires traversing the data twice. The upper
+    // limit is to assume that all strings are repeated the max number of times.
+    auto max_nrepeats =
+        options->repeats.size()
+            ? *std::max_element(options->repeats.begin(), options->repeats.end())
+            : options->nrepeats;
+    return input_ncodeunits * std::max<int64_t>(max_nrepeats, 0);
   }
 
-  int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
-                    uint8_t* output) {
+ private:
+  int64_t Transform_(const uint8_t* input, int64_t input_string_ncodeunits,
+                     uint8_t* output, const int64_t nrepeats) {
     uint8_t* output_start = output;
-    if (options->repeats > 0) {
-      // log(N) approach
+    if (nrepeats > 0) {
+      // log2(repeats) approach
       std::memcpy(output, input, input_string_ncodeunits);
       output += input_string_ncodeunits;
       int64_t i = 1;
-      for (int64_t ilen = input_string_ncodeunits; i <= (options->repeats >> 1);
+      for (int64_t ilen = input_string_ncodeunits; i <= (nrepeats >> 1);
            i <<= 1, ilen <<= 1) {
         std::memcpy(output, output_start, ilen);
         output += ilen;
       }
 
       // Epilogue remainder
-      int64_t rem = (options->repeats ^ i) * input_string_ncodeunits;
+      int64_t rem = (nrepeats ^ i) * input_string_ncodeunits;
       std::memcpy(output, output_start, rem);
       output += rem;
     }
@@ -2769,7 +2813,7 @@ struct StrRepeatTransform : public StringTransformBase {
 };
 
 template <typename Type>
-using StrRepeat = StringTransformExecWithState<Type, StrRepeatTransform>;
+using StrRepeat = StringTransformExecWithState<Type, StrRepeatTransform<Type>>;
 
 // ----------------------------------------------------------------------
 // Replace substring (plain, regex)
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index a2987ff32bf..a2c7bab1c94 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1059,11 +1059,27 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
   });
 
   for (const auto& pair : repeats_and_expected_map) {
-    options.repeats = pair.first;
+    options.nrepeats = pair.first;
     this->CheckUnary("str_repeat", values, this->type(), pair.second, &options);
   }
 }
 
+TYPED_TEST(TestStringKernels, StrRepeats) {
+  RepeatOptions options{{-1, 2, 4, 2, 0, 1, 3, 2, 3}};
+  std::string values(
+      R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+
+  std::string expected(
+      R"(["", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])");
+  this->CheckUnary("str_repeat", values, this->type(), expected, &options);
+
+  // Test invalid data: len(repeats) != len(inputs)
+  options.repeats.pop_back();
+  auto invalid_input = ArrayFromJSON(this->type(), "[\"b\"]");
+  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("differ in length"),
+                                  CallFunction("str_repeat", {invalid_input}, &options));
+}
+
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {
   // U+08BE (utf8: 	\xE0\xA2\xBE) is undefined, but utf8proc things it is
   // UTF8PROC_CATEGORY_LO

From 2e226482869434b7742b5c54f630519e94a503f7 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 30 Aug 2021 02:59:44 -0400
Subject: [PATCH 13/84] add RepeatOptions to PyArrow

---
 python/pyarrow/_compute.pyx          | 10 ++++++++++
 python/pyarrow/compute.py            |  1 +
 python/pyarrow/tests/test_compute.py |  1 +
 3 files changed, 12 insertions(+)

diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index d62c9c0ee85..217738ac3a2 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1161,6 +1161,16 @@ class VarianceOptions(_VarianceOptions):
         self._set_options(ddof, skip_nulls, min_count)
 
 
+cdef class _RepeatOptions(FunctionOptions):
+    def _set_options(self, repeats):
+        self.wrapped.reset(new CRepeatOptions(repeats))
+
+
+class RepeatOptions(_RepeatOptions):
+    def __init__(self, repeats):
+        self._set_options(repeats)
+
+
 cdef class _SplitOptions(FunctionOptions):
     def _set_options(self, max_splits, reverse):
         self.wrapped.reset(new CSplitOptions(max_splits, reverse))
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 6e3bd7fcab3..ccaa90accca 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -47,6 +47,7 @@
     PadOptions,
     PartitionNthOptions,
     QuantileOptions,
+    RepeatOptions,
     ReplaceSliceOptions,
     ReplaceSubstringOptions,
     RoundOptions,
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index be2da31b9d1..5d87ae5c9ff 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -131,6 +131,7 @@ def test_option_class_equality():
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
         pc.QuantileOptions(),
+        pc.RepeatOptions(1),
         pc.ReplaceSliceOptions(0, 1, "a"),
         pc.ReplaceSubstringOptions("a", "b"),
         pc.RoundOptions(2, "towards_infinity"),

From 8e394c6e6eb1ecd4b9982fea6d5d7629a7ca95e5 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 30 Aug 2021 03:03:55 -0400
Subject: [PATCH 14/84] add R bindings

---
 r/R/dplyr-functions.R | 4 ++++
 r/R/expression.R      | 1 +
 r/src/compute.cpp     | 6 ++++++
 3 files changed, 11 insertions(+)

diff --git a/r/R/dplyr-functions.R b/r/R/dplyr-functions.R
index 717cdae9662..bd51a6ca431 100644
--- a/r/R/dplyr-functions.R
+++ b/r/R/dplyr-functions.R
@@ -409,6 +409,10 @@ nse_funcs$substr <- function(x, start, stop) {
   )
 }
 
+nse_funcs$str_repeat <- function(x, repeats) {
+  Expression$create("str_repeat", x, options = list(repeats = repeats))
+}
+
 nse_funcs$substring <- function(text, first, last) {
   nse_funcs$substr(x = text, start = first, stop = last)
 }
diff --git a/r/R/expression.R b/r/R/expression.R
index b1b6635f538..28750928d9f 100644
--- a/r/R/expression.R
+++ b/r/R/expression.R
@@ -49,6 +49,7 @@
   # nchar is defined in dplyr-functions.R
   "str_length" = "utf8_length",
   # str_pad is defined in dplyr-functions.R
+  # str_repeat is defined in dplyr-functions.R
   # str_sub is defined in dplyr-functions.R
   # str_to_lower is defined in dplyr-functions.R
   # str_to_title is defined in dplyr-functions.R
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 0f0ef2f7dd1..309c5888c5c 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -345,6 +345,7 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
                                      cpp11::as_cpp<uint32_t>(options["week_start"]));
   }
 
+<<<<<<< 6fa024b0ea28d5d97efeb6b8cee073ed1f930041
   if (func_name == "iso_week") {
     return std::make_shared<arrow::compute::WeekOptions>(
         arrow::compute::WeekOptions::ISODefaults());
@@ -373,6 +374,11 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
                                      first_week_is_fully_in_year);
   }
 
+  if (func_name == "str_repeat") {
+    using Options = arrow::compute::RepeatOptions;
+    return std::make_shared<Options>(cpp11::as_cpp<std::vector<int>>(options["repeats"]));
+  }
+
   if (func_name == "strptime") {
     using Options = arrow::compute::StrptimeOptions;
     return std::make_shared<Options>(

From 8f3c977096b33e56c4e1a5d2ef8183d7d503ed6d Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 30 Aug 2021 05:07:04 -0400
Subject: [PATCH 15/84] set repeats to std::vector<int>

---
 cpp/src/arrow/compute/api_scalar.cc           |  9 ++--
 cpp/src/arrow/compute/api_scalar.h            | 10 +++--
 .../arrow/compute/kernels/scalar_string.cc    | 41 +++++++------------
 .../kernels/scalar_string_benchmark.cc        |  2 +-
 .../compute/kernels/scalar_string_test.cc     |  2 +-
 5 files changed, 26 insertions(+), 38 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 41e4d146dc5..01efd57f33f 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -210,7 +210,6 @@ static auto kSplitPatternOptionsType = GetFunctionOptionsType<SplitPatternOption
     DataMember("max_splits", &SplitPatternOptions::max_splits),
     DataMember("reverse", &SplitPatternOptions::reverse));
 static auto kRepeatOptionsType = GetFunctionOptionsType<RepeatOptions>(
-    DataMember("nrepeats", &RepeatOptions::nrepeats),
     DataMember("repeats", &RepeatOptions::repeats));
 static auto kReplaceSliceOptionsType = GetFunctionOptionsType<ReplaceSliceOptions>(
     DataMember("start", &ReplaceSliceOptions::start),
@@ -322,11 +321,9 @@ SplitPatternOptions::SplitPatternOptions(std::string pattern, int64_t max_splits
 SplitPatternOptions::SplitPatternOptions() : SplitPatternOptions("", -1, false) {}
 constexpr char SplitPatternOptions::kTypeName[];
 
-RepeatOptions::RepeatOptions(int64_t nrepeats)
-    : FunctionOptions(internal::kRepeatOptionsType), nrepeats(nrepeats), repeats({}) {}
-RepeatOptions::RepeatOptions(std::vector<int64_t> repeats)
-    : FunctionOptions(internal::kRepeatOptionsType), nrepeats(0), repeats(repeats) {}
-RepeatOptions::RepeatOptions() : RepeatOptions(1) {}
+RepeatOptions::RepeatOptions(std::vector<int> repeats)
+    : FunctionOptions(internal::kRepeatOptionsType), repeats(repeats) {}
+RepeatOptions::RepeatOptions() : RepeatOptions({1}) {}
 constexpr char RepeatOptions::kTypeName[];
 
 ReplaceSliceOptions::ReplaceSliceOptions(int64_t start, int64_t stop,
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 86dd1c43c2a..989dc0c4c53 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -168,14 +168,16 @@ class ARROW_EXPORT SplitPatternOptions : public FunctionOptions {
 
 class ARROW_EXPORT RepeatOptions : public FunctionOptions {
  public:
-  explicit RepeatOptions(int64_t nrepeats);
-  explicit RepeatOptions(std::vector<int64_t> repeats);
+  // NOTE: Use 'int' instead of 'int64_t' because R-cpp11 does not supports
+  // 'r_vector<int64_t>'.
+  explicit RepeatOptions(std::vector<int> repeats);
   RepeatOptions();
   constexpr static char const kTypeName[] = "RepeatOptions";
 
   /// Number of repeats
-  int64_t nrepeats;
-  std::vector<int64_t> repeats;
+  /// A single value is applied to all inputs, otherwise repeats are apply to
+  /// corresponding input based on order.
+  std::vector<int> repeats;
 };
 
 class ARROW_EXPORT ReplaceSliceOptions : public FunctionOptions {
diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index ebe0d0293c0..145f6791e81 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2741,32 +2741,24 @@ struct StrRepeatTransform : public StringTransformBase {
 
   const Options* options;
   std::function<int64_t(const uint8_t*, int64_t, uint8_t*)> Transform;
-  std::vector<int64_t>::const_iterator it;
+  std::vector<int>::const_iterator it;
 
   explicit StrRepeatTransform(const Options& options) : options{&options} {
-    if (this->options->repeats.size()) {
-      // NOTE: This is an incorrect hack to iterate through the repeat values because for
-      // null entries, Transform() is not invoked and thus the iterator does not moves.
-      it = this->options->repeats.begin();
-      Transform = [&](const uint8_t* input, int64_t input_string_ncodeunits,
-                      uint8_t* output) {
-        auto nrepeats = *it++;
-        if (it == this->options->repeats.end()) {
-          it = this->options->repeats.begin();
-        }
-        return this->Transform_(input, input_string_ncodeunits, output, nrepeats);
-      };
-    } else {
-      Transform = [&](const uint8_t* input, int64_t input_string_ncodeunits,
-                      uint8_t* output) {
-        return this->Transform_(input, input_string_ncodeunits, output,
-                                this->options->nrepeats);
-      };
-    }
+    // NOTE: This is an incorrect hack to iterate through the repeat values because for
+    // null entries, Transform() is not invoked and thus the iterator does not moves.
+    it = this->options->repeats.begin();
+    Transform = [&](const uint8_t* input, int64_t input_string_ncodeunits,
+                    uint8_t* output) {
+      auto nrepeats = *it++;
+      if (it == this->options->repeats.end()) {
+        it = this->options->repeats.begin();
+      }
+      return this->Transform_(input, input_string_ncodeunits, output, nrepeats);
+    };
   }
 
   Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
-    if (options->repeats.size() && batch[0].kind() == Datum::ARRAY) {
+    if ((options->repeats.size() > 1) && (batch[0].kind() == Datum::ARRAY)) {
       ArrayType input(batch[0].array());
       if (static_cast<int64_t>(options->repeats.size()) !=
           static_cast<int64_t>(input.length())) {
@@ -2781,11 +2773,8 @@ struct StrRepeatTransform : public StringTransformBase {
     // NOTE: Ideally, we would like to sum the values that correspond to non-null entries
     // along with each inputs' size but this requires traversing the data twice. The upper
     // limit is to assume that all strings are repeated the max number of times.
-    auto max_nrepeats =
-        options->repeats.size()
-            ? *std::max_element(options->repeats.begin(), options->repeats.end())
-            : options->nrepeats;
-    return input_ncodeunits * std::max<int64_t>(max_nrepeats, 0);
+    auto max_repeat = *std::max_element(options->repeats.begin(), options->repeats.end());
+    return input_ncodeunits * std::max<int64_t>(max_repeat, 0);
   }
 
  private:
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index 71061f49404..77471f218fb 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -78,7 +78,7 @@ static void SplitPattern(benchmark::State& state) {
 }
 
 static void StrRepeat(benchmark::State& state) {
-  RepeatOptions options(8);
+  RepeatOptions options({8});
   UnaryStringBenchmark(state, "str_repeat", &options);
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index a2c7bab1c94..c679ce1052c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1059,7 +1059,7 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
   });
 
   for (const auto& pair : repeats_and_expected_map) {
-    options.nrepeats = pair.first;
+    options.repeats = {pair.first};
     this->CheckUnary("str_repeat", values, this->type(), pair.second, &options);
   }
 }

From f89576906aaa85e9873c6cc7abc92cae76c6c410 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 30 Aug 2021 05:14:46 -0400
Subject: [PATCH 16/84] update pyarrow bindings and tests

---
 python/pyarrow/_compute.pyx          |  6 ++++++
 python/pyarrow/includes/libarrow.pxd |  5 +++++
 python/pyarrow/tests/test_compute.py | 31 ++++++++++++++++++++++++++++
 3 files changed, 42 insertions(+)

diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 217738ac3a2..c3ac4755326 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -31,6 +31,10 @@ import pyarrow.lib as lib
 import numpy as np
 
 
+def is_iterable(obj):
+    return hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes))
+
+
 cdef wrap_scalar_function(const shared_ptr[CFunction]& sp_func):
     """
     Wrap a C++ scalar Function in a ScalarFunction object.
@@ -1168,6 +1172,8 @@ cdef class _RepeatOptions(FunctionOptions):
 
 class RepeatOptions(_RepeatOptions):
     def __init__(self, repeats):
+        if not is_iterable(repeats):
+            repeats = [repeats]
         self._set_options(repeats)
 
 
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 6d187eaa8c6..fd915d91375 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1904,6 +1904,11 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         int64_t width
         c_string padding
 
+    cdef cppclass CRepeatOptions \
+            "arrow::compute::RepeatOptions"(CFunctionOptions):
+        CRepeatOptions(vector[int] repeats)
+        vector[int] repeats
+
     cdef cppclass CSliceOptions \
             "arrow::compute::SliceOptions"(CFunctionOptions):
         CSliceOptions(int64_t start, int64_t stop, int64_t step)
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 5d87ae5c9ff..4d9ec082c62 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -2237,3 +2237,34 @@ def test_count_distinct_options():
     assert pc.count_distinct(arr, mode='only_valid').as_py() == 3
     assert pc.count_distinct(arr, mode='only_null').as_py() == 1
     assert pc.count_distinct(arr, mode='all').as_py() == 4
+
+
+def test_str_repeat():
+    # Test with single value for number of repeats
+    values = ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"]
+    repeat_and_expected_map = {
+        -1: ["", None, "", "", "", "", ""],
+        0: ["", None, "", "", "", "", ""],
+        1: ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"],
+        2: ["æÆ&æÆ&", None, "", "bb", "ɑɽⱤoWɑɽⱤoW", "ıIıI", "$. 3$. 3"],
+    }
+    for repeat, expected in repeat_and_expected_map.items():
+        options = pc.RepeatOptions(repeat)
+        result = pc.str_repeat(values, options=options)
+        assert result.equals(pa.array(expected))
+
+    # Test with multiple values for number of repeats
+    values = ["a", "b"]
+    repeat_and_expected_map = {
+        (-1, 2): ["", "bb"],
+        (3,): ["aaa", "bbb"],
+        (0, 0): ["", ""],
+    }
+    for repeat, expected in repeat_and_expected_map.items():
+        options = pc.RepeatOptions(repeat)
+        result = pc.str_repeat(values, options=options)
+        assert result.equals(pa.array(expected))
+
+    # Test with invalid number of values and repeats
+    with pytest.raises(ValueError, match="differ in length"):
+        pc.str_repeat(["a", "b"], repeats=[1, 2, 3])

From 512d5b8517550ff1334d5d5d429b4a697f9122c4 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 30 Aug 2021 05:16:07 -0400
Subject: [PATCH 17/84] fix lint error

---
 cpp/src/arrow/compute/api_scalar.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 01efd57f33f..c613e6d3e0d 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -209,8 +209,8 @@ static auto kSplitPatternOptionsType = GetFunctionOptionsType<SplitPatternOption
     DataMember("pattern", &SplitPatternOptions::pattern),
     DataMember("max_splits", &SplitPatternOptions::max_splits),
     DataMember("reverse", &SplitPatternOptions::reverse));
-static auto kRepeatOptionsType = GetFunctionOptionsType<RepeatOptions>(
-    DataMember("repeats", &RepeatOptions::repeats));
+static auto kRepeatOptionsType =
+    GetFunctionOptionsType<RepeatOptions>(DataMember("repeats", &RepeatOptions::repeats));
 static auto kReplaceSliceOptionsType = GetFunctionOptionsType<ReplaceSliceOptions>(
     DataMember("start", &ReplaceSliceOptions::start),
     DataMember("stop", &ReplaceSliceOptions::stop),

From e2744ccbb0e9c0e3fc7fdcb2f01063981db90017 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 30 Aug 2021 05:18:43 -0400
Subject: [PATCH 18/84] fix typo

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 145f6791e81..ff1b475adc4 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2763,7 +2763,7 @@ struct StrRepeatTransform : public StringTransformBase {
       if (static_cast<int64_t>(options->repeats.size()) !=
           static_cast<int64_t>(input.length())) {
         return Status::Invalid(
-            "Number of repeats and input strings are differ in length");
+            "Number of repeats and input strings differ in length");
       }
     }
     return Status::OK();

From 81afdafd7820b1d4b0ba599944e4ae4cc8c24a8f Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 3 Sep 2021 22:46:23 -0400
Subject: [PATCH 19/84] remove RepeatOptions

---
 cpp/src/arrow/compute/api_scalar.cc              |  8 --------
 cpp/src/arrow/compute/api_scalar.h               | 14 --------------
 .../arrow/compute/kernels/scalar_string_test.cc  | 13 +++++--------
 python/pyarrow/_compute.pyx                      | 16 ----------------
 python/pyarrow/tests/test_compute.py             |  8 +++-----
 r/R/dplyr-functions.R                            |  4 ----
 r/R/expression.R                                 |  1 -
 7 files changed, 8 insertions(+), 56 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index c613e6d3e0d..e3fe1bdf73d 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -209,8 +209,6 @@ static auto kSplitPatternOptionsType = GetFunctionOptionsType<SplitPatternOption
     DataMember("pattern", &SplitPatternOptions::pattern),
     DataMember("max_splits", &SplitPatternOptions::max_splits),
     DataMember("reverse", &SplitPatternOptions::reverse));
-static auto kRepeatOptionsType =
-    GetFunctionOptionsType<RepeatOptions>(DataMember("repeats", &RepeatOptions::repeats));
 static auto kReplaceSliceOptionsType = GetFunctionOptionsType<ReplaceSliceOptions>(
     DataMember("start", &ReplaceSliceOptions::start),
     DataMember("stop", &ReplaceSliceOptions::stop),
@@ -321,11 +319,6 @@ SplitPatternOptions::SplitPatternOptions(std::string pattern, int64_t max_splits
 SplitPatternOptions::SplitPatternOptions() : SplitPatternOptions("", -1, false) {}
 constexpr char SplitPatternOptions::kTypeName[];
 
-RepeatOptions::RepeatOptions(std::vector<int> repeats)
-    : FunctionOptions(internal::kRepeatOptionsType), repeats(repeats) {}
-RepeatOptions::RepeatOptions() : RepeatOptions({1}) {}
-constexpr char RepeatOptions::kTypeName[];
-
 ReplaceSliceOptions::ReplaceSliceOptions(int64_t start, int64_t stop,
                                          std::string replacement)
     : FunctionOptions(internal::kReplaceSliceOptionsType),
@@ -447,7 +440,6 @@ void RegisterScalarOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kMatchSubstringOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSplitOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSplitPatternOptionsType));
-  DCHECK_OK(registry->AddFunctionOptionsType(kRepeatOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kReplaceSliceOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kReplaceSubstringOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kExtractRegexOptionsType));
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 989dc0c4c53..4bb18b37527 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -166,20 +166,6 @@ class ARROW_EXPORT SplitPatternOptions : public FunctionOptions {
   bool reverse;
 };
 
-class ARROW_EXPORT RepeatOptions : public FunctionOptions {
- public:
-  // NOTE: Use 'int' instead of 'int64_t' because R-cpp11 does not supports
-  // 'r_vector<int64_t>'.
-  explicit RepeatOptions(std::vector<int> repeats);
-  RepeatOptions();
-  constexpr static char const kTypeName[] = "RepeatOptions";
-
-  /// Number of repeats
-  /// A single value is applied to all inputs, otherwise repeats are apply to
-  /// corresponding input based on order.
-  std::vector<int> repeats;
-};
-
 class ARROW_EXPORT ReplaceSliceOptions : public FunctionOptions {
  public:
   explicit ReplaceSliceOptions(int64_t start, int64_t stop, std::string replacement);
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index c679ce1052c..de662991c7f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1044,8 +1044,7 @@ TYPED_TEST(TestStringKernels, Utf8Title) {
 }
 
 TYPED_TEST(TestStringKernels, StrRepeat) {
-  RepeatOptions options;
-  this->CheckUnary("str_repeat", "[]", this->type(), "[]", &options);
+  this->CheckUnary("str_repeat", "[]", this->type(), "[]");
 
   std::string values(
       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
@@ -1059,25 +1058,23 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
   });
 
   for (const auto& pair : repeats_and_expected_map) {
-    options.repeats = {pair.first};
-    this->CheckUnary("str_repeat", values, this->type(), pair.second, &options);
+    this->CheckUnary("str_repeat", values, this->type(), pair.second);
   }
 }
 
 TYPED_TEST(TestStringKernels, StrRepeats) {
-  RepeatOptions options{{-1, 2, 4, 2, 0, 1, 3, 2, 3}};
+  std::vector<int> repeats{-1, 2, 4, 2, 0, 1, 3, 2, 3};
   std::string values(
       R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
 
   std::string expected(
       R"(["", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])");
-  this->CheckUnary("str_repeat", values, this->type(), expected, &options);
+  this->CheckUnary("str_repeat", values, this->type(), expected);
 
   // Test invalid data: len(repeats) != len(inputs)
-  options.repeats.pop_back();
   auto invalid_input = ArrayFromJSON(this->type(), "[\"b\"]");
   EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("differ in length"),
-                                  CallFunction("str_repeat", {invalid_input}, &options));
+                                  CallFunction("str_repeat", {invalid_input, repeats}));
 }
 
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index c3ac4755326..d62c9c0ee85 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -31,10 +31,6 @@ import pyarrow.lib as lib
 import numpy as np
 
 
-def is_iterable(obj):
-    return hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes))
-
-
 cdef wrap_scalar_function(const shared_ptr[CFunction]& sp_func):
     """
     Wrap a C++ scalar Function in a ScalarFunction object.
@@ -1165,18 +1161,6 @@ class VarianceOptions(_VarianceOptions):
         self._set_options(ddof, skip_nulls, min_count)
 
 
-cdef class _RepeatOptions(FunctionOptions):
-    def _set_options(self, repeats):
-        self.wrapped.reset(new CRepeatOptions(repeats))
-
-
-class RepeatOptions(_RepeatOptions):
-    def __init__(self, repeats):
-        if not is_iterable(repeats):
-            repeats = [repeats]
-        self._set_options(repeats)
-
-
 cdef class _SplitOptions(FunctionOptions):
     def _set_options(self, max_splits, reverse):
         self.wrapped.reset(new CSplitOptions(max_splits, reverse))
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 4d9ec082c62..0997f1f845b 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -2249,8 +2249,7 @@ def test_str_repeat():
         2: ["æÆ&æÆ&", None, "", "bb", "ɑɽⱤoWɑɽⱤoW", "ıIıI", "$. 3$. 3"],
     }
     for repeat, expected in repeat_and_expected_map.items():
-        options = pc.RepeatOptions(repeat)
-        result = pc.str_repeat(values, options=options)
+        result = pc.str_repeat(values, repeat, options=options)
         assert result.equals(pa.array(expected))
 
     # Test with multiple values for number of repeats
@@ -2261,10 +2260,9 @@ def test_str_repeat():
         (0, 0): ["", ""],
     }
     for repeat, expected in repeat_and_expected_map.items():
-        options = pc.RepeatOptions(repeat)
-        result = pc.str_repeat(values, options=options)
+        result = pc.str_repeat(values, repeat, options=options)
         assert result.equals(pa.array(expected))
 
     # Test with invalid number of values and repeats
     with pytest.raises(ValueError, match="differ in length"):
-        pc.str_repeat(["a", "b"], repeats=[1, 2, 3])
+        pc.str_repeat(["a", "b"], [1, 2, 3])
diff --git a/r/R/dplyr-functions.R b/r/R/dplyr-functions.R
index bd51a6ca431..717cdae9662 100644
--- a/r/R/dplyr-functions.R
+++ b/r/R/dplyr-functions.R
@@ -409,10 +409,6 @@ nse_funcs$substr <- function(x, start, stop) {
   )
 }
 
-nse_funcs$str_repeat <- function(x, repeats) {
-  Expression$create("str_repeat", x, options = list(repeats = repeats))
-}
-
 nse_funcs$substring <- function(text, first, last) {
   nse_funcs$substr(x = text, start = first, stop = last)
 }
diff --git a/r/R/expression.R b/r/R/expression.R
index 28750928d9f..b1b6635f538 100644
--- a/r/R/expression.R
+++ b/r/R/expression.R
@@ -49,7 +49,6 @@
   # nchar is defined in dplyr-functions.R
   "str_length" = "utf8_length",
   # str_pad is defined in dplyr-functions.R
-  # str_repeat is defined in dplyr-functions.R
   # str_sub is defined in dplyr-functions.R
   # str_to_lower is defined in dplyr-functions.R
   # str_to_title is defined in dplyr-functions.R

From b652a07bd279dfa9bd639f8b03e755aa2f17a44c Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sat, 4 Sep 2021 00:19:34 -0400
Subject: [PATCH 20/84] update kernel to conform to StringBinaryTransformExec

---
 .../arrow/compute/kernels/scalar_string.cc    | 109 +++++++++++-------
 .../compute/kernels/scalar_string_test.cc     |  46 +++++---
 2 files changed, 99 insertions(+), 56 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index ff1b475adc4..d0c06fa1cb5 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2733,61 +2733,60 @@ void AddSplit(FunctionRegistry* registry) {
 #endif
 }
 
-template <typename Type>
+template <typename Type1, typename Type2>
 struct StrRepeatTransform : public StringTransformBase {
-  using Options = RepeatOptions;
-  using State = OptionsWrapper<Options>;
-  using ArrayType = typename TypeTraits<Type>::ArrayType;
-
-  const Options* options;
-  std::function<int64_t(const uint8_t*, int64_t, uint8_t*)> Transform;
-  std::vector<int>::const_iterator it;
-
-  explicit StrRepeatTransform(const Options& options) : options{&options} {
-    // NOTE: This is an incorrect hack to iterate through the repeat values because for
-    // null entries, Transform() is not invoked and thus the iterator does not moves.
-    it = this->options->repeats.begin();
-    Transform = [&](const uint8_t* input, int64_t input_string_ncodeunits,
-                    uint8_t* output) {
-      auto nrepeats = *it++;
-      if (it == this->options->repeats.end()) {
-        it = this->options->repeats.begin();
-      }
-      return this->Transform_(input, input_string_ncodeunits, output, nrepeats);
-    };
-  }
+  using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
+  using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
+  int64_t max_nrepeats = 0;
 
   Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
-    if ((options->repeats.size() > 1) && (batch[0].kind() == Datum::ARRAY)) {
-      ArrayType input(batch[0].array());
-      if (static_cast<int64_t>(options->repeats.size()) !=
-          static_cast<int64_t>(input.length())) {
-        return Status::Invalid(
-            "Number of repeats and input strings differ in length");
+    // Since repeat values are validated here, might as well get the maximum repeat value
+    // into a data member and use it for MaxCodeunits().
+    if (batch[1].is_scalar()) {
+      max_nrepeats = static_cast<int64_t>(
+          checked_cast<const NumericScalar<Type2>&>(*batch[1].scalar()).value);
+    }
+
+    if (batch[0].is_array() && batch[1].is_array()) {
+      // TODO(edponce): Is it possible to not convert to ArrayType for these checks and
+      // finding max?
+      ArrayType1 array1(batch[0].array());
+      ArrayType2 array2(batch[1].array());
+      if (array1.length() != array2.length()) {
+        return Status::Invalid("Number of input strings and repetitions differ in length");
       }
+
+      // Note: Ideally, we would like to calculate the exact output size by iterating over
+      // all input strings and summing each length multiplied by the corresponding repeat
+      // value, but this requires traversing the data twice (now and during transform).
+      // The upper limit is to assume that all strings are repeated the max number of
+      // times.
+      max_nrepeats =
+          static_cast<int64_t>(**std::max_element(array2.begin(), array2.end()));
+    }
+
+    if (max_nrepeats < 0) {
+      return Status::Invalid("Invalid string repetition value, has to be non-negative");
     }
     return Status::OK();
   }
 
-  int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits) override {
-    // NOTE: Ideally, we would like to sum the values that correspond to non-null entries
-    // along with each inputs' size but this requires traversing the data twice. The upper
-    // limit is to assume that all strings are repeated the max number of times.
-    auto max_repeat = *std::max_element(options->repeats.begin(), options->repeats.end());
-    return input_ncodeunits * std::max<int64_t>(max_repeat, 0);
+  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits) override {
+    return input_ncodeunits * max_nrepeats;
   }
 
- private:
-  int64_t Transform_(const uint8_t* input, int64_t input_string_ncodeunits,
-                     uint8_t* output, const int64_t nrepeats) {
+  int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
+                     const std::shared_ptr<Scalar>& input2, uint8_t* output) {
+    auto nrepeats =
+        static_cast<int64_t>(checked_cast<const NumericScalar<Type2>&>(*input2).value);
     uint8_t* output_start = output;
     if (nrepeats > 0) {
       // log2(repeats) approach
       std::memcpy(output, input, input_string_ncodeunits);
       output += input_string_ncodeunits;
       int64_t i = 1;
-      for (int64_t ilen = input_string_ncodeunits; i <= (nrepeats >> 1);
-           i <<= 1, ilen <<= 1) {
+      for (int64_t ilen = input_string_ncodeunits; i <= (nrepeats / 2);
+           i *= 2, ilen *= 2) {
         std::memcpy(output, output_start, ilen);
         output += ilen;
       }
@@ -2801,8 +2800,30 @@ struct StrRepeatTransform : public StringTransformBase {
   }
 };
 
-template <typename Type>
-using StrRepeat = StringTransformExecWithState<Type, StrRepeatTransform<Type>>;
+template <typename Type1, typename Type2>
+using StrRepeat =
+    StringBinaryTransformExec<Type1, Type2, StrRepeatTransform<Type1, Type2>>;
+
+template <template <typename...> class ExecFunctor>
+void MakeStrRepeatBatchKernel(std::string name, FunctionRegistry* registry,
+                              const FunctionDoc* doc) {
+  auto func = std::make_shared<ScalarFunction>(name, Arity::Binary(), doc);
+  {
+    for (const auto& ty : IntTypes()) {
+      auto exec = GenerateInteger<ExecFunctor, StringType>(ty);
+      ScalarKernel kernel{{utf8(), ty}, utf8(), exec};
+      DCHECK_OK(func->AddKernel(std::move(kernel)));
+    }
+  }
+  {
+    for (const auto& ty : IntTypes()) {
+      auto exec = GenerateInteger<ExecFunctor, LargeStringType>(ty);
+      ScalarKernel kernel{{large_utf8(), ty}, large_utf8(), exec};
+      DCHECK_OK(func->AddKernel(std::move(kernel)));
+    }
+  }
+  DCHECK_OK(registry->AddFunction(std::move(func)));
+}
 
 // ----------------------------------------------------------------------
 // Replace substring (plain, regex)
@@ -4721,6 +4742,11 @@ const FunctionDoc utf8_reverse_doc(
      "clusters. Hence, it will not correctly reverse grapheme clusters\n"
      "composed of multiple codepoints."),
     {"strings"});
+
+const FunctionDoc str_repeat_doc(
+    "Repeat a string a given number of times",
+    ("For each string in `strings`, return a replicated version."),
+    {"strings", "repeats"});
 }  // namespace
 
 void RegisterScalarStringAscii(FunctionRegistry* registry) {
@@ -4823,6 +4849,7 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   AddSplit(registry);
   AddStrptime(registry);
   AddBinaryJoin(registry);
+  MakeStrRepeatBatchKernel<StrRepeat>("str_repeat", registry, &str_repeat_doc);
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index de662991c7f..76fa034dc9a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1046,8 +1046,7 @@ TYPED_TEST(TestStringKernels, Utf8Title) {
 TYPED_TEST(TestStringKernels, StrRepeat) {
   this->CheckUnary("str_repeat", "[]", this->type(), "[]");
 
-  std::string values(
-      R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+  auto values = ArrayFromJSON(this->type(), R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
   std::vector<std::pair<int64_t, std::string>> repeats_and_expected_map({
       {-1, R"(["", null, "", "", "", "", "", "", "", ""])"},
       {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
@@ -1058,23 +1057,40 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
   });
 
   for (const auto& pair : repeats_and_expected_map) {
-    this->CheckUnary("str_repeat", values, this->type(), pair.second);
+    auto repeat = pair.first;
+    auto expected = pair.second;
+    if (repeat >= 0) {
+      this->CheckVarArgs("str_repeat", {values, Datum(repeat)}, this->type(), expected);
+    } else {
+      EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("non-negative"),
+                                    CallFunction("str_repeat", {values, Datum(repeat)}));
+    }
   }
 }
 
 TYPED_TEST(TestStringKernels, StrRepeats) {
-  std::vector<int> repeats{-1, 2, 4, 2, 0, 1, 3, 2, 3};
-  std::string values(
-      R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
-
-  std::string expected(
-      R"(["", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])");
-  this->CheckUnary("str_repeat", values, this->type(), expected);
-
-  // Test invalid data: len(repeats) != len(inputs)
-  auto invalid_input = ArrayFromJSON(this->type(), "[\"b\"]");
-  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("differ in length"),
-                                  CallFunction("str_repeat", {invalid_input, repeats}));
+  {
+    auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3])");
+    auto values = ArrayFromJSON(this->type(), R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+    std::string expected = R"(["aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
+    this->CheckVarArgs("str_repeat", {values, repeats}, this->type(), expected);
+  }
+  {
+    // Invalid case: len(repeats) != len(strings)
+    // TODO(edponce): ExecBatchIterator (compute/exec.cc) triggers error:
+    //   Actual: "Invalid: Array arguments must all be the same length"
+    // auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3])");
+    // auto values = ArrayFromJSON(this->type(), R"(["b"])");
+    // EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("differ in length"),
+    //                                 CallFunction("str_repeat", {values, repeats}));
+  }
+  {
+    // Invalid case: len(repeats) != len(strings)
+    auto repeats = ArrayFromJSON(int64(), R"([-1])");
+    auto values = ArrayFromJSON(this->type(), R"(["b"])");
+    EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("non-negative"),
+                                    CallFunction("str_repeat", {values, repeats}));
+  }
 }
 
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {

From a527b08e04a0b49c15e191a0572daf7a57f7249a Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sat, 4 Sep 2021 00:21:35 -0400
Subject: [PATCH 21/84] fix lint errors

---
 .../arrow/compute/kernels/scalar_string.cc    |  5 +--
 .../compute/kernels/scalar_string_test.cc     | 33 +++++++++++--------
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index d0c06fa1cb5..eee00c26008 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2753,7 +2753,8 @@ struct StrRepeatTransform : public StringTransformBase {
       ArrayType1 array1(batch[0].array());
       ArrayType2 array2(batch[1].array());
       if (array1.length() != array2.length()) {
-        return Status::Invalid("Number of input strings and repetitions differ in length");
+        return Status::Invalid(
+            "Number of input strings and repetitions differ in length");
       }
 
       // Note: Ideally, we would like to calculate the exact output size by iterating over
@@ -2776,7 +2777,7 @@ struct StrRepeatTransform : public StringTransformBase {
   }
 
   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
-                     const std::shared_ptr<Scalar>& input2, uint8_t* output) {
+                    const std::shared_ptr<Scalar>& input2, uint8_t* output) {
     auto nrepeats =
         static_cast<int64_t>(checked_cast<const NumericScalar<Type2>&>(*input2).value);
     uint8_t* output_start = output;
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 76fa034dc9a..58760c1c205 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1046,7 +1046,9 @@ TYPED_TEST(TestStringKernels, Utf8Title) {
 TYPED_TEST(TestStringKernels, StrRepeat) {
   this->CheckUnary("str_repeat", "[]", this->type(), "[]");
 
-  auto values = ArrayFromJSON(this->type(), R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+  auto values = ArrayFromJSON(
+      this->type(),
+      R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
   std::vector<std::pair<int64_t, std::string>> repeats_and_expected_map({
       {-1, R"(["", null, "", "", "", "", "", "", "", ""])"},
       {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
@@ -1062,8 +1064,9 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
     if (repeat >= 0) {
       this->CheckVarArgs("str_repeat", {values, Datum(repeat)}, this->type(), expected);
     } else {
-      EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("non-negative"),
-                                    CallFunction("str_repeat", {values, Datum(repeat)}));
+      EXPECT_RAISES_WITH_MESSAGE_THAT(
+          Invalid, testing::HasSubstr("non-negative"),
+          CallFunction("str_repeat", {values, Datum(repeat)}));
     }
   }
 }
@@ -1071,20 +1074,22 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
 TYPED_TEST(TestStringKernels, StrRepeats) {
   {
     auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3])");
-    auto values = ArrayFromJSON(this->type(), R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
-    std::string expected = R"(["aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
+    auto values = ArrayFromJSON(
+        this->type(),
+        R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+    std::string expected =
+        R"(["aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
     this->CheckVarArgs("str_repeat", {values, repeats}, this->type(), expected);
   }
   {
-    // Invalid case: len(repeats) != len(strings)
-    // TODO(edponce): ExecBatchIterator (compute/exec.cc) triggers error:
-    //   Actual: "Invalid: Array arguments must all be the same length"
-    // auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3])");
-    // auto values = ArrayFromJSON(this->type(), R"(["b"])");
-    // EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("differ in length"),
-    //                                 CallFunction("str_repeat", {values, repeats}));
-  }
-  {
+      // Invalid case: len(repeats) != len(strings)
+      // TODO(edponce): ExecBatchIterator (compute/exec.cc) triggers error:
+      //   Actual: "Invalid: Array arguments must all be the same length"
+      // auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3])");
+      // auto values = ArrayFromJSON(this->type(), R"(["b"])");
+      // EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("differ in length"),
+      //                                 CallFunction("str_repeat", {values, repeats}));
+  } {
     // Invalid case: len(repeats) != len(strings)
     auto repeats = ArrayFromJSON(int64(), R"([-1])");
     auto values = ArrayFromJSON(this->type(), R"(["b"])");

From 71739296fc120ea986c82d149b9210c42972bc4e Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sun, 5 Sep 2021 23:59:21 -0400
Subject: [PATCH 22/84] remove benchmark case

---
 cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index 77471f218fb..ee4a492ca48 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -77,11 +77,6 @@ static void SplitPattern(benchmark::State& state) {
   UnaryStringBenchmark(state, "split_pattern", &options);
 }
 
-static void StrRepeat(benchmark::State& state) {
-  RepeatOptions options({8});
-  UnaryStringBenchmark(state, "str_repeat", &options);
-}
-
 static void TrimSingleAscii(benchmark::State& state) {
   TrimOptions options("a");
   UnaryStringBenchmark(state, "ascii_trim", &options);

From 86ed8d36496d2cd73270e399feeb58aaa4ca2406 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 6 Sep 2021 00:39:11 -0400
Subject: [PATCH 23/84] cast output of string transform

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index eee00c26008..cb5bc29df92 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -616,8 +616,8 @@ struct StringBinaryTransformExecBase {
     auto output_str = value_buffer->mutable_data();
 
     auto input1_string = input1.value->data();
-    auto encoded_nbytes =
-        transform->Transform(input1_string, input_ncodeunits, scalar2, output_str);
+    auto encoded_nbytes = static_cast<offset_type>(
+        transform->Transform(input1_string, input_ncodeunits, scalar2, output_str));
     if (encoded_nbytes < 0) {
       return transform->InvalidStatus();
     }

From 0a7cea0933facd51652aa08af353cfc634e96977 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 6 Sep 2021 13:36:14 -0400
Subject: [PATCH 24/84] remove StrRepeat benchmark

---
 cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index ee4a492ca48..ddc3a56f00f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -215,7 +215,6 @@ BENCHMARK(AsciiUpper);
 BENCHMARK(IsAlphaNumericAscii);
 BENCHMARK(MatchSubstring);
 BENCHMARK(SplitPattern);
-BENCHMARK(StrRepeat);
 BENCHMARK(TrimSingleAscii);
 BENCHMARK(TrimManyAscii);
 #ifdef ARROW_WITH_RE2

From faf161242b2006dda8331a621a01070050d22b58 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 6 Sep 2021 19:37:46 -0400
Subject: [PATCH 25/84] use Unbox to get scalar C values

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index cb5bc29df92..38e73998fba 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2743,8 +2743,7 @@ struct StrRepeatTransform : public StringTransformBase {
     // Since repeat values are validated here, might as well get the maximum repeat value
     // into a data member and use it for MaxCodeunits().
     if (batch[1].is_scalar()) {
-      max_nrepeats = static_cast<int64_t>(
-          checked_cast<const NumericScalar<Type2>&>(*batch[1].scalar()).value);
+      max_nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*batch[1].scalar()));
     }
 
     if (batch[0].is_array() && batch[1].is_array()) {
@@ -2778,8 +2777,7 @@ struct StrRepeatTransform : public StringTransformBase {
 
   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
                     const std::shared_ptr<Scalar>& input2, uint8_t* output) {
-    auto nrepeats =
-        static_cast<int64_t>(checked_cast<const NumericScalar<Type2>&>(*input2).value);
+    auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*input2));
     uint8_t* output_start = output;
     if (nrepeats > 0) {
       // log2(repeats) approach

From b508d89bdf00d9086d837f3594638f66eb01fd9d Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 6 Sep 2021 20:52:47 -0400
Subject: [PATCH 26/84] updates based on StringBinaryTransform updates

---
 .../arrow/compute/kernels/scalar_string.cc    | 48 +++++++++++--------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 38e73998fba..ed2e73aee45 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2734,44 +2734,50 @@ void AddSplit(FunctionRegistry* registry) {
 }
 
 template <typename Type1, typename Type2>
-struct StrRepeatTransform : public StringTransformBase {
+struct StrRepeatTransform : public StringBinaryTransformBase {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
-  int64_t max_nrepeats = 0;
 
   Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
-    // Since repeat values are validated here, might as well get the maximum repeat value
-    // into a data member and use it for MaxCodeunits().
+    // TODO(edponce): Does it makes sense to validate repetition values here or make it a silent no-op? When it is an array, it should not be validated here because it would require iterating through all values.
     if (batch[1].is_scalar()) {
-      max_nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*batch[1].scalar()));
+      auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*batch[1].scalar()));
+      if (nrepeats < 0) {
+        return Status::Invalid("Invalid string repetition value, has to be non-negative");
+      }
+    } else {
+      ArrayType2 array2(batch[1].array());
+      for (int i = 0; i < array2.length(); ++i) {
+        auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(**array2.GetScalar(i)));
+        if (nrepeats < 0) {
+          return Status::Invalid("Invalid string repetition value, has to be non-negative");
+        }
+      }
     }
-
     if (batch[0].is_array() && batch[1].is_array()) {
-      // TODO(edponce): Is it possible to not convert to ArrayType for these checks and
-      // finding max?
       ArrayType1 array1(batch[0].array());
       ArrayType2 array2(batch[1].array());
       if (array1.length() != array2.length()) {
         return Status::Invalid(
             "Number of input strings and repetitions differ in length");
       }
-
-      // Note: Ideally, we would like to calculate the exact output size by iterating over
-      // all input strings and summing each length multiplied by the corresponding repeat
-      // value, but this requires traversing the data twice (now and during transform).
-      // The upper limit is to assume that all strings are repeated the max number of
-      // times.
-      max_nrepeats =
-          static_cast<int64_t>(**std::max_element(array2.begin(), array2.end()));
-    }
-
-    if (max_nrepeats < 0) {
-      return Status::Invalid("Invalid string repetition value, has to be non-negative");
     }
     return Status::OK();
   }
 
-  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits) override {
+  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits, const std::shared_ptr<Scalar>& input2) override {
+    auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*input2));
+    return input_ncodeunits * nrepeats;
+  }
+
+  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits, const std::shared_ptr<ArrayData>& data2) override {
+    ArrayType2 array2(data2);
+    // Note: Ideally, we would like to calculate the exact output size by iterating over
+    // all input strings and summing each length multiplied by the corresponding repeat
+    // value, but this requires traversing the data twice (now and during transform).
+    // The upper limit is to assume that all strings are repeated the max number of
+    // times.
+    auto max_nrepeats = static_cast<int64_t>(**std::max_element(array2.begin(), array2.end()));
     return input_ncodeunits * max_nrepeats;
   }
 

From 4998c0815e2648c1355809a73ef1961dbd48bb88 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 6 Sep 2021 20:54:03 -0400
Subject: [PATCH 27/84] fix lint errors

---
 .../arrow/compute/kernels/scalar_string.cc    | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index ed2e73aee45..20322d343ee 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2739,7 +2739,9 @@ struct StrRepeatTransform : public StringBinaryTransformBase {
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
   Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
-    // TODO(edponce): Does it makes sense to validate repetition values here or make it a silent no-op? When it is an array, it should not be validated here because it would require iterating through all values.
+    // TODO(edponce): Does it makes sense to validate repetition values here or make it a
+    // silent no-op? When it is an array, it should not be validated here because it would
+    // require iterating through all values.
     if (batch[1].is_scalar()) {
       auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*batch[1].scalar()));
       if (nrepeats < 0) {
@@ -2748,9 +2750,11 @@ struct StrRepeatTransform : public StringBinaryTransformBase {
     } else {
       ArrayType2 array2(batch[1].array());
       for (int i = 0; i < array2.length(); ++i) {
-        auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(**array2.GetScalar(i)));
+        auto nrepeats =
+            static_cast<int64_t>(UnboxScalar<Type2>::Unbox(**array2.GetScalar(i)));
         if (nrepeats < 0) {
-          return Status::Invalid("Invalid string repetition value, has to be non-negative");
+          return Status::Invalid(
+              "Invalid string repetition value, has to be non-negative");
         }
       }
     }
@@ -2765,19 +2769,22 @@ struct StrRepeatTransform : public StringBinaryTransformBase {
     return Status::OK();
   }
 
-  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits, const std::shared_ptr<Scalar>& input2) override {
+  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits,
+                       const std::shared_ptr<Scalar>& input2) override {
     auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*input2));
     return input_ncodeunits * nrepeats;
   }
 
-  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits, const std::shared_ptr<ArrayData>& data2) override {
+  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits,
+                       const std::shared_ptr<ArrayData>& data2) override {
     ArrayType2 array2(data2);
     // Note: Ideally, we would like to calculate the exact output size by iterating over
     // all input strings and summing each length multiplied by the corresponding repeat
     // value, but this requires traversing the data twice (now and during transform).
     // The upper limit is to assume that all strings are repeated the max number of
     // times.
-    auto max_nrepeats = static_cast<int64_t>(**std::max_element(array2.begin(), array2.end()));
+    auto max_nrepeats =
+        static_cast<int64_t>(**std::max_element(array2.begin(), array2.end()));
     return input_ncodeunits * max_nrepeats;
   }
 

From 56269385c140d1a09548e608a79e023cb7665966 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 9 Sep 2021 00:26:00 -0400
Subject: [PATCH 28/84] remove checks for repeats and array length, update
 tests

---
 .../arrow/compute/kernels/scalar_string.cc    | 46 +++----------------
 .../compute/kernels/scalar_string_test.cc     | 43 ++++-------------
 python/pyarrow/compute.py                     |  1 -
 python/pyarrow/includes/libarrow.pxd          |  5 --
 python/pyarrow/tests/test_compute.py          | 35 +++++++-------
 5 files changed, 33 insertions(+), 97 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 20322d343ee..8091fb1c856 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2738,54 +2738,23 @@ struct StrRepeatTransform : public StringBinaryTransformBase {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
-  Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
-    // TODO(edponce): Does it makes sense to validate repetition values here or make it a
-    // silent no-op? When it is an array, it should not be validated here because it would
-    // require iterating through all values.
-    if (batch[1].is_scalar()) {
-      auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*batch[1].scalar()));
-      if (nrepeats < 0) {
-        return Status::Invalid("Invalid string repetition value, has to be non-negative");
-      }
-    } else {
-      ArrayType2 array2(batch[1].array());
-      for (int i = 0; i < array2.length(); ++i) {
-        auto nrepeats =
-            static_cast<int64_t>(UnboxScalar<Type2>::Unbox(**array2.GetScalar(i)));
-        if (nrepeats < 0) {
-          return Status::Invalid(
-              "Invalid string repetition value, has to be non-negative");
-        }
-      }
-    }
-    if (batch[0].is_array() && batch[1].is_array()) {
-      ArrayType1 array1(batch[0].array());
-      ArrayType2 array2(batch[1].array());
-      if (array1.length() != array2.length()) {
-        return Status::Invalid(
-            "Number of input strings and repetitions differ in length");
-      }
-    }
-    return Status::OK();
-  }
-
   int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits,
                        const std::shared_ptr<Scalar>& input2) override {
     auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*input2));
-    return input_ncodeunits * nrepeats;
+    return std::max(input_ncodeunits * nrepeats, int64_t(0));
   }
 
   int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits,
                        const std::shared_ptr<ArrayData>& data2) override {
     ArrayType2 array2(data2);
-    // Note: Ideally, we would like to calculate the exact output size by iterating over
-    // all input strings and summing each length multiplied by the corresponding repeat
+    // Ideally, we would like to calculate the exact output size by iterating over
+    // all strings offsets and summing each length multiplied by the corresponding repeat
     // value, but this requires traversing the data twice (now and during transform).
     // The upper limit is to assume that all strings are repeated the max number of
-    // times.
+    // times knowing that a resize operation is performed at end of execution.
     auto max_nrepeats =
         static_cast<int64_t>(**std::max_element(array2.begin(), array2.end()));
-    return input_ncodeunits * max_nrepeats;
+    return std::max(input_ncodeunits * max_nrepeats, int64_t(0));
   }
 
   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
@@ -2793,7 +2762,7 @@ struct StrRepeatTransform : public StringBinaryTransformBase {
     auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*input2));
     uint8_t* output_start = output;
     if (nrepeats > 0) {
-      // log2(repeats) approach
+      // log2(k) approach
       std::memcpy(output, input, input_string_ncodeunits);
       output += input_string_ncodeunits;
       int64_t i = 1;
@@ -4756,8 +4725,7 @@ const FunctionDoc utf8_reverse_doc(
     {"strings"});
 
 const FunctionDoc str_repeat_doc(
-    "Repeat a string a given number of times",
-    ("For each string in `strings`, return a replicated version."),
+    "Repeat a string", ("For each string in `strings`, return a replicated version."),
     {"strings", "repeats"});
 }  // namespace
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 58760c1c205..9bece3503d9 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1056,46 +1056,23 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
        R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
       {3,
        R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbb", "ɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
-  });
+  }};
 
-  for (const auto& pair : repeats_and_expected_map) {
+  for (const auto& pair : repeats_and_expected) {
     auto repeat = pair.first;
     auto expected = pair.second;
-    if (repeat >= 0) {
-      this->CheckVarArgs("str_repeat", {values, Datum(repeat)}, this->type(), expected);
-    } else {
-      EXPECT_RAISES_WITH_MESSAGE_THAT(
-          Invalid, testing::HasSubstr("non-negative"),
-          CallFunction("str_repeat", {values, Datum(repeat)}));
-    }
+    this->CheckVarArgs("str_repeat", {values, Datum(repeat)}, this->type(), expected);
   }
 }
 
 TYPED_TEST(TestStringKernels, StrRepeats) {
-  {
-    auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3])");
-    auto values = ArrayFromJSON(
-        this->type(),
-        R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
-    std::string expected =
-        R"(["aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
-    this->CheckVarArgs("str_repeat", {values, repeats}, this->type(), expected);
-  }
-  {
-      // Invalid case: len(repeats) != len(strings)
-      // TODO(edponce): ExecBatchIterator (compute/exec.cc) triggers error:
-      //   Actual: "Invalid: Array arguments must all be the same length"
-      // auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3])");
-      // auto values = ArrayFromJSON(this->type(), R"(["b"])");
-      // EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("differ in length"),
-      //                                 CallFunction("str_repeat", {values, repeats}));
-  } {
-    // Invalid case: len(repeats) != len(strings)
-    auto repeats = ArrayFromJSON(int64(), R"([-1])");
-    auto values = ArrayFromJSON(this->type(), R"(["b"])");
-    EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, testing::HasSubstr("non-negative"),
-                                    CallFunction("str_repeat", {values, repeats}));
-  }
+  auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3, -1])");
+  auto values = ArrayFromJSON(
+      this->type(),
+      R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow", "one"])");
+  std::string expected =
+      R"(["aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow", ""])";
+  this->CheckVarArgs("str_repeat", {values, repeats}, this->type(), expected);
 }
 
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index ccaa90accca..6e3bd7fcab3 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -47,7 +47,6 @@
     PadOptions,
     PartitionNthOptions,
     QuantileOptions,
-    RepeatOptions,
     ReplaceSliceOptions,
     ReplaceSubstringOptions,
     RoundOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index fd915d91375..6d187eaa8c6 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1904,11 +1904,6 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         int64_t width
         c_string padding
 
-    cdef cppclass CRepeatOptions \
-            "arrow::compute::RepeatOptions"(CFunctionOptions):
-        CRepeatOptions(vector[int] repeats)
-        vector[int] repeats
-
     cdef cppclass CSliceOptions \
             "arrow::compute::SliceOptions"(CFunctionOptions):
         CSliceOptions(int64_t start, int64_t stop, int64_t step)
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 0997f1f845b..bfae5054cf6 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -2242,27 +2242,24 @@ def test_count_distinct_options():
 def test_str_repeat():
     # Test with single value for number of repeats
     values = ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"]
-    repeat_and_expected_map = {
-        -1: ["", None, "", "", "", "", ""],
-        0: ["", None, "", "", "", "", ""],
-        1: ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"],
-        2: ["æÆ&æÆ&", None, "", "bb", "ɑɽⱤoWɑɽⱤoW", "ıIıI", "$. 3$. 3"],
-    }
-    for repeat, expected in repeat_and_expected_map.items():
-        result = pc.str_repeat(values, repeat, options=options)
+    repeat_and_expected = [
+        [-1, ["", None, "", "", "", "", ""]],
+        [0, ["", None, "", "", "", "", ""]],
+        [1, ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"]],
+        [2, ["æÆ&æÆ&", None, "", "bb", "ɑɽⱤoWɑɽⱤoW", "ıIıI", "$. 3$. 3"]],
+    ]
+    for repeat, expected in repeat_and_expected:
+        result = pc.str_repeat(values, repeat)
         assert result.equals(pa.array(expected))
 
     # Test with multiple values for number of repeats
     values = ["a", "b"]
-    repeat_and_expected_map = {
-        (-1, 2): ["", "bb"],
-        (3,): ["aaa", "bbb"],
-        (0, 0): ["", ""],
-    }
-    for repeat, expected in repeat_and_expected_map.items():
-        result = pc.str_repeat(values, repeat, options=options)
+    repeat_and_expected = [
+        [[-3, 2], ["", "bb"]],
+        [[0, 2], ["", "bb"]],
+        [3, ["aaa", "bbb"]],
+        [[0, 0], ["", ""]],
+    ]
+    for repeat, expected in repeat_and_expected:
+        result = pc.str_repeat(values, repeat)
         assert result.equals(pa.array(expected))
-
-    # Test with invalid number of values and repeats
-    with pytest.raises(ValueError, match="differ in length"):
-        pc.str_repeat(["a", "b"], [1, 2, 3])

From d4d2df151c79c135a382974d4d88eca3714e2e81 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 9 Sep 2021 00:47:49 -0400
Subject: [PATCH 29/84] add cast to transform output

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 8091fb1c856..5c6b00b4a5b 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -656,9 +656,9 @@ struct StringBinaryTransformExecBase {
       if (!input1.IsNull(i)) {
         offset_type input1_string_ncodeunits;
         auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
-        auto encoded_nbytes =
+        auto encoded_nbytes = static_cast<offset_type>(
             transform->Transform(input1_string, input1_string_ncodeunits, scalar2,
-                                 output_str + output_ncodeunits);
+                                 output_str + output_ncodeunits));
         if (encoded_nbytes < 0) {
           return transform->InvalidStatus();
         }
@@ -711,9 +711,9 @@ struct StringBinaryTransformExecBase {
         offset_type input1_string_ncodeunits;
         auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
         auto scalar2 = *input2.GetScalar(i);
-        auto encoded_nbytes =
+        auto encoded_nbytes = static_cast<offset_type>(
             transform->Transform(input1_string, input1_string_ncodeunits, scalar2,
-                                 output_str + output_ncodeunits);
+                                 output_str + output_ncodeunits));
         if (encoded_nbytes < 0) {
           return transform->InvalidStatus();
         }

From 830be80efcdab2e1f1cfa81c9f68a3767273ba42 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 9 Sep 2021 00:56:03 -0400
Subject: [PATCH 30/84] remove RepeatOptions from docs

---
 docs/source/cpp/compute.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 1312edca61b..af447f989cf 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -835,7 +835,7 @@ String transforms
 +-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
 | replace_substring_regex | Unary  | String-like            | String-like            | :struct:`ReplaceSubstringOptions` | \(6)  |
 +-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| str_repeat              | Binary | String-like            | String-like            | :struct:`RepeatOptions`           |       |
+| str_repeat              | Binary | String-like            | String-like            |                                   |       |
 +-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
 | utf8_capitalize         | Unary  | String-like            | String-like            |                                   | \(8)  |
 +-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+

From 0e7bb2fa0c521572f046917c73551ada4e3ef98f Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 9 Sep 2021 01:21:05 -0400
Subject: [PATCH 31/84] remove RepeatOptions from R bindings

---
 r/src/compute.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 309c5888c5c..433d0597fa1 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -345,7 +345,6 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
                                      cpp11::as_cpp<uint32_t>(options["week_start"]));
   }
 
-<<<<<<< 6fa024b0ea28d5d97efeb6b8cee073ed1f930041
   if (func_name == "iso_week") {
     return std::make_shared<arrow::compute::WeekOptions>(
         arrow::compute::WeekOptions::ISODefaults());

From fdad773f43e3fe0383a143320b4594b24929b7eb Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 9 Sep 2021 01:26:40 -0400
Subject: [PATCH 32/84] remove inheritance from StringTransformBase

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 5c6b00b4a5b..9fa5bd39600 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -539,7 +539,11 @@ struct FixedSizeBinaryTransformExecWithState
   }
 };
 
-struct StringBinaryTransformBase : StringTransformBase {
+struct StringBinaryTransformBase {
+  virtual Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    return Status::OK();
+  }
+
   // Return the maximum total size of the output in codeunits (i.e. bytes)
   // given input characteristics.
   virtual int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits,
@@ -553,6 +557,10 @@ struct StringBinaryTransformBase : StringTransformBase {
                                const std::shared_ptr<ArrayData>& data2) {
     return input_ncodeunits;
   }
+
+  virtual Status InvalidStatus() {
+    return Status::Invalid("Invalid UTF8 sequence in input");
+  }
 };
 
 /// Kernel exec generator for binary string transforms.
@@ -591,7 +599,6 @@ struct StringBinaryTransformExecBase {
     return Status::Invalid("Invalid ExecBatch kind for binary string transform");
   }
 
- private:
   static Status ExecScalarScalar(KernelContext* ctx, StringTransform* transform,
                                  const std::shared_ptr<Scalar>& scalar1,
                                  const std::shared_ptr<Scalar>& scalar2, Datum* out) {

From c70fb6e5bd386e83e6c7cfbcddf5eeeb86e688a9 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 10 Sep 2021 17:10:54 -0400
Subject: [PATCH 33/84] (WIP) resolving reviewer comments

---
 .../arrow/compute/kernels/scalar_string.cc    | 79 ++++++++++++----
 .../compute/kernels/scalar_string_test.cc     | 36 ++++----
 docs/source/cpp/compute.rst                   | 90 ++++++++++---------
 3 files changed, 121 insertions(+), 84 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 9fa5bd39600..f8e9fe9f59c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -547,29 +547,20 @@ struct StringBinaryTransformBase {
   // Return the maximum total size of the output in codeunits (i.e. bytes)
   // given input characteristics.
   virtual int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits,
-                               const std::shared_ptr<Scalar>& input2) {
-    return input_ncodeunits;
-  }
+                               const std::shared_ptr<Scalar>& input2) = 0;
 
   // Return the maximum total size of the output in codeunits (i.e. bytes)
   // given input characteristics.
   virtual int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits,
-                               const std::shared_ptr<ArrayData>& data2) {
-    return input_ncodeunits;
-  }
+                               const std::shared_ptr<ArrayData>& data2) = 0;
 
   virtual Status InvalidStatus() {
     return Status::Invalid("Invalid UTF8 sequence in input");
   }
 };
 
-/// Kernel exec generator for binary string transforms.
-/// The first parameter is expected to always be a string type while the second parameter
-/// is generic. It supports executions of the form:
-///   * Scalar, Scalar
-///   * Array, Scalar - scalar is broadcasted and paired with all values of array
-///   * Array, Array - arrays are processed element-wise
-///   * Scalar, Array - not supported by default
+/// Kernel exec generator for binary string transforms.  The first parameter is expected
+/// to always be a string type while the second parameter is generic.
 template <typename Type1, typename Type2, typename StringTransform>
 struct StringBinaryTransformExecBase {
   using offset_type = typename Type1::offset_type;
@@ -677,15 +668,60 @@ struct StringBinaryTransformExecBase {
 
     // Trim the codepoint buffer, since we allocated too much
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
-    return Status::OK();
   }
 
   static Status ExecScalarArray(KernelContext* ctx, StringTransform* transform,
                                 const std::shared_ptr<Scalar>& scalar1,
                                 const std::shared_ptr<ArrayData>& data2, Datum* out) {
-    return Status::NotImplemented(
-        "Binary string transforms with (scalar, array) inputs are not supported for the "
-        "general case");
+    if (!scalar1->is_valid) {
+      return Status::OK();
+    }
+
+    return Status::OK();
+    // ArrayType2 input2(data2);
+    //
+    // const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
+    // auto input1_ncodeunits = input1.value->size();
+    // auto input1_nstrings = 1;
+    // auto output_ncodeunits_max =
+    //     transform->MaxCodeunits(input1_nstrings, input1_ncodeunits, data2);
+    // if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
+    //   return Status::CapacityError(
+    //       "Result might not fit in a 32bit utf8 array, convert to large_utf8");
+    // }
+    //
+    // ArrayData* output = out->mutable_array();
+    // ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
+    // output->buffers[2] = values_buffer;
+    //
+    //
+    //
+    //
+    //
+    // // String offsets are preallocated
+    // auto output_string_offsets = output->GetMutableValues<offset_type>(1);
+    // auto output_str = output->buffers[2]->mutable_data();
+    // output_string_offsets[0] = 0;
+    //
+    // offset_type output_ncodeunits = 0;
+    // for (int64_t i = 0; i < input1_nstrings; ++i) {
+    //   if (!input1.IsNull(i)) {
+    //     offset_type input1_string_ncodeunits;
+    //     auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
+    //     auto encoded_nbytes = static_cast<offset_type>(
+    //         transform->Transform(input1_string, input1_string_ncodeunits, scalar2,
+    //                              output_str + output_ncodeunits));
+    //     if (encoded_nbytes < 0) {
+    //       return transform->InvalidStatus();
+    //     }
+    //     output_ncodeunits += encoded_nbytes;
+    //   }
+    //   output_string_offsets[i + 1] = output_ncodeunits;
+    // }
+    // DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
+    //
+    // // Trim the codepoint buffer, since we allocated too much
+    // return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
 
   static Status ExecArrayArray(KernelContext* ctx, StringTransform* transform,
@@ -2768,8 +2804,13 @@ struct StrRepeatTransform : public StringBinaryTransformBase {
                     const std::shared_ptr<Scalar>& input2, uint8_t* output) {
     auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*input2));
     uint8_t* output_start = output;
-    if (nrepeats > 0) {
-      // log2(k) approach
+    if (nrepeats < 4) {
+      for (int64_t i = 0; i < nrepeats; ++i) {
+        std::memcpy(output, input, input_string_ncodeunits);
+        output += input_string_ncodeunits;
+      }
+    } else {
+      // Repeated doubling of string
       std::memcpy(output, input, input_string_ncodeunits);
       output += input_string_ncodeunits;
       int64_t i = 1;
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 9bece3503d9..ca01773d5b0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -28,6 +28,7 @@
 #endif
 
 #include "arrow/compute/api_scalar.h"
+#include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/test_util.h"
 #include "arrow/testing/gtest_util.h"
 
@@ -53,19 +54,6 @@ class BaseTestStringKernels : public ::testing::Test {
     CheckScalarUnary(func_name, type(), json_input, out_ty, json_expected, options);
   }
 
-  void CheckUnary(std::string func_name, const std::shared_ptr<Array>& input,
-                  std::shared_ptr<DataType> out_ty, std::string json_expected,
-                  const FunctionOptions* options = nullptr) {
-    CheckScalar(func_name, {Datum(input)}, Datum(ArrayFromJSON(out_ty, json_expected)),
-                options);
-  }
-
-  void CheckUnary(std::string func_name, const std::shared_ptr<Array>& input,
-                  const std::shared_ptr<Array>& expected,
-                  const FunctionOptions* options = nullptr) {
-    CheckScalar(func_name, {Datum(input)}, Datum(expected), options);
-  }
-
   void CheckBinaryScalar(std::string func_name, std::string json_left_input,
                          std::string json_right_scalar, std::shared_ptr<DataType> out_ty,
                          std::string json_expected,
@@ -1061,18 +1049,24 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
   for (const auto& pair : repeats_and_expected) {
     auto repeat = pair.first;
     auto expected = pair.second;
-    this->CheckVarArgs("str_repeat", {values, Datum(repeat)}, this->type(), expected);
+    auto repeat_types = (repeat < 0) ? internal::SignedIntTypes() : internal::IntTypes();
+    for (const auto& ty : repeat_types) {
+      this->CheckVarArgs("str_repeat", {values, Datum(*arrow::MakeScalar(ty, repeat))},
+                         this->type(), expected);
+    }
   }
 }
 
 TYPED_TEST(TestStringKernels, StrRepeats) {
-  auto repeats = ArrayFromJSON(int64(), R"([1, 2, 4, 2, 0, 1, 3, 2, 3, -1])");
-  auto values = ArrayFromJSON(
-      this->type(),
-      R"(["aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow", "one"])");
-  std::string expected =
-      R"(["aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow", ""])";
-  this->CheckVarArgs("str_repeat", {values, repeats}, this->type(), expected);
+  for (const auto& ty : internal::SignedIntTypes()) {
+    auto repeats = ArrayFromJSON(ty, R"([100, 1, 2, 4, 2, 0, 1, 3, 2, 3, -1])");
+    auto values = ArrayFromJSON(
+        this->type(),
+        R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow", "one"])");
+    std::string expected =
+        R"([null, "aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow", ""])";
+    this->CheckVarArgs("str_repeat", {values, repeats}, this->type(), expected);
+  }
 }
 
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index af447f989cf..266e0f82bad 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -812,47 +812,47 @@ The third set of functions examines string elements on a byte-per-byte basis:
 String transforms
 ~~~~~~~~~~~~~~~~~
 
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| Function name           | Arity  | Input types            | Output type            | Options class                     | Notes |
-+=========================+========+========================+========================+===================================+=======+
-| ascii_capitalize        | Unary  | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_lower             | Unary  | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_reverse           | Unary  | String-like            | String-like            |                                   | \(2)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_swapcase          | Unary  | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_title             | Unary  | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| ascii_upper             | Unary  | String-like            | String-like            |                                   | \(1)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| binary_length           | Unary  | Binary- or String-like | Int32 or Int64         |                                   | \(3)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| binary_replace_slice    | Unary  | String-like            | Binary- or String-like | :struct:`ReplaceSliceOptions`     | \(4)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| replace_substring       | Unary  | String-like            | String-like            | :struct:`ReplaceSubstringOptions` | \(5)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| replace_substring_regex | Unary  | String-like            | String-like            | :struct:`ReplaceSubstringOptions` | \(6)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| str_repeat              | Binary | String-like            | String-like            |                                   |       |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_capitalize         | Unary  | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_length             | Unary  | String-like            | Int32 or Int64         |                                   | \(7)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_lower              | Unary  | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_replace_slice      | Unary  | String-like            | String-like            | :struct:`ReplaceSliceOptions`     | \(4)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_reverse            | Unary  | String-like            | String-like            |                                   | \(9)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_swapcase           | Unary  | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_title              | Unary  | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
-| utf8_upper              | Unary  | String-like            | String-like            |                                   | \(8)  |
-+-------------------------+--------+------------------------+------------------------+-----------------------------------+-------+
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| Function name           | Arity  | Input types                           | Output type            | Options class                     | Notes |
++=========================+========+=======================================+========================+===================================+=======+
+| ascii_capitalize        | Unary  | String-like                           | String-like            |                                   | \(1)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_lower             | Unary  | String-like                           | String-like            |                                   | \(1)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_reverse           | Unary  | String-like                           | String-like            |                                   | \(2)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_swapcase          | Unary  | String-like                           | String-like            |                                   | \(1)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_title             | Unary  | String-like                           | String-like            |                                   | \(1)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_upper             | Unary  | String-like                           | String-like            |                                   | \(1)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| binary_length           | Unary  | Binary- or String-like                | Int32 or Int64         |                                   | \(3)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| binary_replace_slice    | Unary  | String-like                           | Binary- or String-like | :struct:`ReplaceSliceOptions`     | \(4)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| replace_substring       | Unary  | String-like                           | String-like            | :struct:`ReplaceSubstringOptions` | \(5)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| replace_substring_regex | Unary  | String-like                           | String-like            | :struct:`ReplaceSubstringOptions` | \(6)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| str_repeat              | Binary | String-like (Arg 0); Integral (Arg 1) | String-like            |                                   | \(7)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_capitalize         | Unary  | String-like                           | String-like            |                                   | \(9)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_length             | Unary  | String-like                           | Int32 or Int64         |                                   | \(8)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_lower              | Unary  | String-like                           | String-like            |                                   | \(9)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_replace_slice      | Unary  | String-like                           | String-like            | :struct:`ReplaceSliceOptions`     | \(5)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_reverse            | Unary  | String-like                           | String-like            |                                   | \(10) |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_swapcase           | Unary  | String-like                           | String-like            |                                   | \(9)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_title              | Unary  | String-like                           | String-like            |                                   | \(9)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_upper              | Unary  | String-like                           | String-like            |                                   | \(9)  |
++-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
 
 * \(1) Each ASCII character in the input is converted to lowercase or
   uppercase.  Non-ASCII characters are left untouched.
@@ -881,13 +881,15 @@ String transforms
   maximum number of replacements made, counting from the left. Note that if the
   pattern contains groups, backreferencing can be used.
 
-* \(7) Output is the number of characters (not bytes) of each input element.
+* \(7) Repeat the input string a given number of times.
+
+* \(8) Output is the number of characters (not bytes) of each input element.
   Output type is Int32 for String, Int64 for LargeString.
 
-* \(8) Each UTF8-encoded character in the input is converted to lowercase or
+* \(9) Each UTF8-encoded character in the input is converted to lowercase or
   uppercase.
 
-* \(9) Each UTF8-encoded code unit is written in reverse order to the output.
+* \(10) 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
   buffers will be preserved).
 

From 662722aeaf6e38090884f28cd9dce0e901ffd759 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sun, 12 Sep 2021 21:01:27 -0400
Subject: [PATCH 34/84] remove tests with invalid repeats (negative)

---
 cpp/src/arrow/compute/kernels/scalar_string_test.cc | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index ca01773d5b0..c880ae63101 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1038,7 +1038,6 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
       this->type(),
       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
   std::vector<std::pair<int64_t, std::string>> repeats_and_expected_map({
-      {-1, R"(["", null, "", "", "", "", "", "", "", ""])"},
       {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
       {1,
        R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
@@ -1059,12 +1058,12 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
 
 TYPED_TEST(TestStringKernels, StrRepeats) {
   for (const auto& ty : internal::SignedIntTypes()) {
-    auto repeats = ArrayFromJSON(ty, R"([100, 1, 2, 4, 2, 0, 1, 3, 2, 3, -1])");
+    auto repeats = ArrayFromJSON(ty, R"([100, 1, 2, 4, 2, 0, 1, 3, 2, 3])");
     auto values = ArrayFromJSON(
         this->type(),
-        R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow", "one"])");
+        R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
     std::string expected =
-        R"([null, "aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow", ""])";
+        R"([null, "aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
     this->CheckVarArgs("str_repeat", {values, repeats}, this->type(), expected);
   }
 }

From 3b4cbc596166cd2858006612484f348c371d9564 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sun, 12 Sep 2021 21:02:21 -0400
Subject: [PATCH 35/84] update string binary infrastructure

---
 .../arrow/compute/kernels/scalar_string.cc    | 251 +++++++++++-------
 1 file changed, 149 insertions(+), 102 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index f8e9fe9f59c..bdf8a92b955 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -420,7 +420,7 @@ struct StringTransformExecBase {
     return value_buffer->Resize(encoded_nbytes, /*shrink_to_fit=*/true);
   }
 
-  // Unary derived classes should define this method:
+  // StringTransform type should define this method:
   //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
   //                     uint8_t* output);
 };
@@ -544,26 +544,53 @@ struct StringBinaryTransformBase {
     return Status::OK();
   }
 
-  // Return the maximum total size of the output in codeunits (i.e. bytes)
-  // given input characteristics.
-  virtual int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits,
-                               const std::shared_ptr<Scalar>& input2) = 0;
-
-  // Return the maximum total size of the output in codeunits (i.e. bytes)
-  // given input characteristics.
-  virtual int64_t MaxCodeunits(int64_t ninputs, int64_t input_ncodeunits,
-                               const std::shared_ptr<ArrayData>& data2) = 0;
-
-  virtual Status InvalidStatus() {
+  virtual Status InvalidStatus() const {
     return Status::Invalid("Invalid UTF8 sequence in input");
   }
+
+  // Not all combinations of input shapes are meaningful to string binary transforms, so
+  // these flags serve as toggles for enabling/disabling the corresponding ones. These
+  // flags should be set in the PreExec() method.
+  bool EnableScalarScalar = true;
+  bool EnableScalarArray = true;
+  bool EnableArrayScalar = true;
+  bool EnableArrayArray = true;
+
+  // Derived classes need to define all the MaxCodeunits methods even if they are not used
+  // due to disabling the corresponding "EnableXXX" flag. Unfortunately, these methods
+  // cannot be virtual predefined in this base class because C++ does not supports
+  // creating vtables from templetized methods. using ViewType2 = typename
+  // GetViewType<Type2>::T; using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
+  // using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
+
+  // Return the maximum total size of the output in codeunits (i.e. bytes)
+  // given input characteristics for Scalar-Scalar, Scalar-Array, Array-Scalar, and
+  // Array-Array inputs. int64_t MaxCodeunits(const int64_t input1_ncodeunits, const
+  // ViewType2 value2) const { return 0; }
+  //
+  // int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2& input2) const
+  // { return 0; }
+  //
+  // int64_t MaxCodeunits(const ArrayType1& input1, const ViewType2 value2) const { return
+  // 0; }
+  //
+  // int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) const {
+  // return 0; }
 };
 
 /// Kernel exec generator for binary string transforms.  The first parameter is expected
 /// to always be a string type while the second parameter is generic.
+// TODO(edponce): This approach currently does not works for FixedSizeBinaryArray:
+//   * because its GetValue() does not return the string size. To circumvent, we could use
+//   GetView() on first input (always a util::string_view) and get its length via
+//   str.length() method.
+// TODO(edponce): Refactor common parts out and make use VisitorArrayValuesInline from
+// codegen_internal.h (assuming LogicalValue always matches the type returned by GetView()
+// which seems the case).
 template <typename Type1, typename Type2, typename StringTransform>
 struct StringBinaryTransformExecBase {
   using offset_type = typename Type1::offset_type;
+  using ViewType2 = typename GetViewType<Type2>::T;
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
@@ -573,18 +600,28 @@ struct StringBinaryTransformExecBase {
       return Status::Invalid("Invalid arity for binary string transform");
     }
 
-    if (batch[0].is_array()) {
-      if (batch[1].is_array()) {
-        return ExecArrayArray(ctx, transform, batch[0].array(), batch[1].array(), out);
-      } else if (batch[1].is_scalar()) {
-        return ExecArrayScalar(ctx, transform, batch[0].array(), batch[1].scalar(), out);
+    if (batch[0].is_scalar()) {
+      if (batch[1].is_scalar()) {
+        if (transform->EnableScalarScalar) {
+          return ExecScalarScalar(ctx, transform, batch[0].scalar(), batch[1].scalar(),
+                                  out);
+        }
+      } else if (batch[1].is_array()) {
+        if (transform->EnableScalarArray) {
+          return ExecScalarArray(ctx, transform, batch[0].scalar(), batch[1].array(),
+                                 out);
+        }
       }
-    } else if (batch[0].is_scalar()) {
+    } else if (batch[0].is_array()) {
       if (batch[1].is_array()) {
-        return ExecScalarArray(ctx, transform, batch[0].scalar(), batch[1].array(), out);
+        if (transform->EnableArrayArray) {
+          return ExecArrayArray(ctx, transform, batch[0].array(), batch[1].array(), out);
+        }
       } else if (batch[1].is_scalar()) {
-        return ExecScalarScalar(ctx, transform, batch[0].scalar(), batch[1].scalar(),
-                                out);
+        if (transform->EnableArrayScalar) {
+          return ExecArrayScalar(ctx, transform, batch[0].array(), batch[1].scalar(),
+                                 out);
+        }
       }
     }
     return Status::Invalid("Invalid ExecBatch kind for binary string transform");
@@ -598,10 +635,9 @@ struct StringBinaryTransformExecBase {
     }
 
     const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
+    auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
     auto input_ncodeunits = input1.value->size();
-    auto input_nstrings = 1;
-    auto output_ncodeunits_max =
-        transform->MaxCodeunits(input_nstrings, input_ncodeunits, scalar2);
+    auto output_ncodeunits_max = transform->MaxCodeunits(input_ncodeunits, value2);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
           "Result might not fit in a 32bit utf8 array, convert to large_utf8");
@@ -615,7 +651,7 @@ struct StringBinaryTransformExecBase {
 
     auto input1_string = input1.value->data();
     auto encoded_nbytes = static_cast<offset_type>(
-        transform->Transform(input1_string, input_ncodeunits, scalar2, output_str));
+        transform->Transform(input1_string, input_ncodeunits, value2, output_str));
     if (encoded_nbytes < 0) {
       return transform->InvalidStatus();
     }
@@ -631,10 +667,8 @@ struct StringBinaryTransformExecBase {
     }
 
     ArrayType1 input1(data1);
-    auto input1_ncodeunits = input1.total_values_length();
-    auto input1_nstrings = input1.length();
-    auto output_ncodeunits_max =
-        transform->MaxCodeunits(input1_nstrings, input1_ncodeunits, scalar2);
+    auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
+    auto output_ncodeunits_max = transform->MaxCodeunits(input1, value2);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
           "Result might not fit in a 32bit utf8 array, convert to large_utf8");
@@ -649,13 +683,14 @@ struct StringBinaryTransformExecBase {
     auto output_str = output->buffers[2]->mutable_data();
     output_string_offsets[0] = 0;
 
+    auto input1_nstrings = input1.length();
     offset_type output_ncodeunits = 0;
     for (int64_t i = 0; i < input1_nstrings; ++i) {
       if (!input1.IsNull(i)) {
         offset_type input1_string_ncodeunits;
         auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
         auto encoded_nbytes = static_cast<offset_type>(
-            transform->Transform(input1_string, input1_string_ncodeunits, scalar2,
+            transform->Transform(input1_string, input1_string_ncodeunits, value2,
                                  output_str + output_ncodeunits));
         if (encoded_nbytes < 0) {
           return transform->InvalidStatus();
@@ -677,51 +712,47 @@ struct StringBinaryTransformExecBase {
       return Status::OK();
     }
 
-    return Status::OK();
-    // ArrayType2 input2(data2);
-    //
-    // const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
-    // auto input1_ncodeunits = input1.value->size();
-    // auto input1_nstrings = 1;
-    // auto output_ncodeunits_max =
-    //     transform->MaxCodeunits(input1_nstrings, input1_ncodeunits, data2);
-    // if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
-    //   return Status::CapacityError(
-    //       "Result might not fit in a 32bit utf8 array, convert to large_utf8");
-    // }
-    //
-    // ArrayData* output = out->mutable_array();
-    // ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
-    // output->buffers[2] = values_buffer;
-    //
-    //
-    //
-    //
-    //
-    // // String offsets are preallocated
-    // auto output_string_offsets = output->GetMutableValues<offset_type>(1);
-    // auto output_str = output->buffers[2]->mutable_data();
-    // output_string_offsets[0] = 0;
-    //
-    // offset_type output_ncodeunits = 0;
-    // for (int64_t i = 0; i < input1_nstrings; ++i) {
-    //   if (!input1.IsNull(i)) {
-    //     offset_type input1_string_ncodeunits;
-    //     auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
-    //     auto encoded_nbytes = static_cast<offset_type>(
-    //         transform->Transform(input1_string, input1_string_ncodeunits, scalar2,
-    //                              output_str + output_ncodeunits));
-    //     if (encoded_nbytes < 0) {
-    //       return transform->InvalidStatus();
-    //     }
-    //     output_ncodeunits += encoded_nbytes;
-    //   }
-    //   output_string_offsets[i + 1] = output_ncodeunits;
-    // }
-    // DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
-    //
-    // // Trim the codepoint buffer, since we allocated too much
-    // return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
+    const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
+    auto input1_string = input1.value->data();
+    auto input1_ncodeunits = input1.value->size();
+
+    ArrayType2 input2(data2);
+    auto input2_nvalues = input2.length();
+
+    auto output_ncodeunits_max = transform->MaxCodeunits(input1_ncodeunits, input2);
+    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
+      return Status::CapacityError(
+          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
+    }
+
+    ArrayData* output = out->mutable_array();
+    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
+    output->buffers[2] = values_buffer;
+
+    // String offsets are preallocated
+    // TODO(edponce): Check that string offsets have been preallocated
+    // because the input string is a Scalar.
+    auto output_string_offsets = output->GetMutableValues<offset_type>(1);
+    auto output_str = output->buffers[2]->mutable_data();
+    output_string_offsets[0] = 0;
+
+    offset_type output_ncodeunits = 0;
+    for (int64_t i = 0; i < input2_nvalues; ++i) {
+      if (!input2.IsNull(i)) {
+        auto value2 = input2.GetView(i);
+        auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
+            input1_string, input1_ncodeunits, value2, output_str + output_ncodeunits));
+        if (encoded_nbytes < 0) {
+          return transform->InvalidStatus();
+        }
+        output_ncodeunits += encoded_nbytes;
+      }
+      output_string_offsets[i + 1] = output_ncodeunits;
+    }
+    DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
+
+    // Trim the codepoint buffer, since we allocated too much
+    return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
 
   static Status ExecArrayArray(KernelContext* ctx, StringTransform* transform,
@@ -730,10 +761,8 @@ struct StringBinaryTransformExecBase {
     ArrayType1 input1(data1);
     ArrayType2 input2(data2);
 
-    auto input1_ncodeunits = input1.total_values_length();
     auto input1_nstrings = input1.length();
-    auto output_ncodeunits_max =
-        transform->MaxCodeunits(input1_nstrings, input1_ncodeunits, data2);
+    auto output_ncodeunits_max = transform->MaxCodeunits(input1, input2);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
           "Result might not fit in a 32bit utf8 array, convert to large_utf8");
@@ -753,9 +782,9 @@ struct StringBinaryTransformExecBase {
       if (!input1.IsNull(i) || !input2.IsNull(i)) {
         offset_type input1_string_ncodeunits;
         auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
-        auto scalar2 = *input2.GetScalar(i);
+        auto value2 = input2.GetView(i);
         auto encoded_nbytes = static_cast<offset_type>(
-            transform->Transform(input1_string, input1_string_ncodeunits, scalar2,
+            transform->Transform(input1_string, input1_string_ncodeunits, value2,
                                  output_str + output_ncodeunits));
         if (encoded_nbytes < 0) {
           return transform->InvalidStatus();
@@ -770,9 +799,9 @@ struct StringBinaryTransformExecBase {
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
 
-  // Binary derived classes should define this method:
-  //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits, const
-  //   std::shared_ptr<Scalar>& input2, uint8_t* output);
+  // StringTransform type should define this method:
+  //   int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
+  //   const ViewType2 value2, uint8_t* output) const;
 };
 
 template <typename Type1, typename Type2, typename StringTransform>
@@ -815,7 +844,7 @@ struct FunctionalCaseMappingTransform : public StringTransformBase {
     // in bytes is actually only at max 3/2 (as covered by the unittest).
     // Note that rounding down the 3/2 is ok, since only codepoints encoded by
     // two code units (even) can grow to 3 code units.
-    return static_cast<int64_t>(input_ncodeunits) * 3 / 2;
+    return input_ncodeunits * 3 / 2;
   }
 };
 
@@ -2781,28 +2810,46 @@ struct StrRepeatTransform : public StringBinaryTransformBase {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
-  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits,
-                       const std::shared_ptr<Scalar>& input2) override {
-    auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*input2));
-    return std::max(input_ncodeunits * nrepeats, int64_t(0));
+  // TODO(edponce): Should we validate nrepeats (it will fail when trying to allocate
+  // output data)? It is not an option, so do other compute functions validate their
+  // inputs or let them fail when they fail?
+
+  // TODO(edponce): This is just an example of how to disable function arguments of
+  // specific input shapes. Status PreExec(KernelContext* ctx, const ExecBatch& batch,
+  // Datum* out) override {
+  //   EnableScalarArray = false;
+  //   return StringBinaryTransformBase::PreExec(ctx, batch, out);
+  // }
+  //
+  // int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2& input2) const
+  // { return 0; }
+
+  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const int64_t nrepeats) const {
+    return input1_ncodeunits * nrepeats;
   }
 
-  int64_t MaxCodeunits(int64_t inputs, int64_t input_ncodeunits,
-                       const std::shared_ptr<ArrayData>& data2) override {
-    ArrayType2 array2(data2);
-    // Ideally, we would like to calculate the exact output size by iterating over
-    // all strings offsets and summing each length multiplied by the corresponding repeat
-    // value, but this requires traversing the data twice (now and during transform).
-    // The upper limit is to assume that all strings are repeated the max number of
-    // times knowing that a resize operation is performed at end of execution.
-    auto max_nrepeats =
-        static_cast<int64_t>(**std::max_element(array2.begin(), array2.end()));
-    return std::max(input_ncodeunits * max_nrepeats, int64_t(0));
+  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2& input2) const {
+    int64_t total_nrepeats = 0;
+    for (int64_t i = 0; i < input2.length(); ++i) {
+      total_nrepeats += input2.GetView(i);
+    }
+    return input1_ncodeunits * total_nrepeats;
   }
 
-  int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
-                    const std::shared_ptr<Scalar>& input2, uint8_t* output) {
-    auto nrepeats = static_cast<int64_t>(UnboxScalar<Type2>::Unbox(*input2));
+  int64_t MaxCodeunits(const ArrayType1& input1, const int64_t nrepeats) const {
+    return input1.total_values_length() * nrepeats;
+  }
+
+  int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) const {
+    int64_t total_codeunits = 0;
+    for (int64_t i = 0; i < input2.length(); ++i) {
+      total_codeunits += input1.GetView(i).length() * input2.GetView(i);
+    }
+    return total_codeunits;
+  }
+
+  int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
+                    const int64_t nrepeats, uint8_t* output) {
     uint8_t* output_start = output;
     if (nrepeats < 4) {
       for (int64_t i = 0; i < nrepeats; ++i) {

From e418b3f9fd74e98be2285ad0161436b17c16206f Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sun, 12 Sep 2021 21:45:10 -0400
Subject: [PATCH 36/84] remove invalid tests (negative repeats)

---
 python/pyarrow/tests/test_compute.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index bfae5054cf6..40763b5de2f 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -2243,7 +2243,6 @@ def test_str_repeat():
     # Test with single value for number of repeats
     values = ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"]
     repeat_and_expected = [
-        [-1, ["", None, "", "", "", "", ""]],
         [0, ["", None, "", "", "", "", ""]],
         [1, ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"]],
         [2, ["æÆ&æÆ&", None, "", "bb", "ɑɽⱤoWɑɽⱤoW", "ıIıI", "$. 3$. 3"]],
@@ -2255,7 +2254,7 @@ def test_str_repeat():
     # Test with multiple values for number of repeats
     values = ["a", "b"]
     repeat_and_expected = [
-        [[-3, 2], ["", "bb"]],
+        [[5, 2], ["aaaaa", "bb"]],
         [[0, 2], ["", "bb"]],
         [3, ["aaa", "bbb"]],
         [[0, 0], ["", ""]],

From e5e43bdc6bfc940b385b99ac9acbd0820efc5548 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sun, 12 Sep 2021 22:13:01 -0400
Subject: [PATCH 37/84] add <vector> and remove support for negative repeats

---
 cpp/src/arrow/compute/kernels/scalar_string_test.cc | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index c880ae63101..de6cd9680d8 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1048,8 +1048,7 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
   for (const auto& pair : repeats_and_expected) {
     auto repeat = pair.first;
     auto expected = pair.second;
-    auto repeat_types = (repeat < 0) ? internal::SignedIntTypes() : internal::IntTypes();
-    for (const auto& ty : repeat_types) {
+    for (const auto& ty : internal::IntTypes()) {
       this->CheckVarArgs("str_repeat", {values, Datum(*arrow::MakeScalar(ty, repeat))},
                          this->type(), expected);
     }
@@ -1057,7 +1056,7 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
 }
 
 TYPED_TEST(TestStringKernels, StrRepeats) {
-  for (const auto& ty : internal::SignedIntTypes()) {
+  for (const auto& ty : internal::IntTypes()) {
     auto repeats = ArrayFromJSON(ty, R"([100, 1, 2, 4, 2, 0, 1, 3, 2, 3])");
     auto values = ArrayFromJSON(
         this->type(),

From bb2e6d32065746de1d3eb722fee6c18b09390bc2 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sun, 12 Sep 2021 23:06:30 -0400
Subject: [PATCH 38/84] still getting undefined ref for XTypes()

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index 09681b2763b..da8ea5b2d7c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -20,6 +20,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include <gtest/gtest.h>
 

From 4d47a5dfa5752224860cbac561f9e2b9370e6221 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 20 Sep 2021 17:03:22 -0400
Subject: [PATCH 39/84] add virtual destructor as per ARROW-13670

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index bdf8a92b955..629ddbee0a7 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -540,6 +540,8 @@ struct FixedSizeBinaryTransformExecWithState
 };
 
 struct StringBinaryTransformBase {
+  virtual ~StringBinaryTransformBase() = default;
+
   virtual Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     return Status::OK();
   }

From d20fcd84b67769a6406b78857bf6e94d5ac5709e Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 27 Sep 2021 11:13:27 -0400
Subject: [PATCH 40/84] rename to long form (string_repeat) and fix test

---
 cpp/src/arrow/compute/kernels/scalar_string.cc    | 12 ++++++------
 .../arrow/compute/kernels/scalar_string_test.cc   | 15 +++++++--------
 python/pyarrow/tests/test_compute.py              |  7 +++----
 3 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 629ddbee0a7..be15c7ee53a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2808,7 +2808,7 @@ void AddSplit(FunctionRegistry* registry) {
 }
 
 template <typename Type1, typename Type2>
-struct StrRepeatTransform : public StringBinaryTransformBase {
+struct StringRepeatTransform : public StringBinaryTransformBase {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
@@ -2879,11 +2879,11 @@ struct StrRepeatTransform : public StringBinaryTransformBase {
 };
 
 template <typename Type1, typename Type2>
-using StrRepeat =
-    StringBinaryTransformExec<Type1, Type2, StrRepeatTransform<Type1, Type2>>;
+using StringRepeat =
+    StringBinaryTransformExec<Type1, Type2, StringRepeatTransform<Type1, Type2>>;
 
 template <template <typename...> class ExecFunctor>
-void MakeStrRepeatBatchKernel(std::string name, FunctionRegistry* registry,
+void MakeStringRepeatBatchKernel(std::string name, FunctionRegistry* registry,
                               const FunctionDoc* doc) {
   auto func = std::make_shared<ScalarFunction>(name, Arity::Binary(), doc);
   {
@@ -4821,7 +4821,7 @@ const FunctionDoc utf8_reverse_doc(
      "composed of multiple codepoints."),
     {"strings"});
 
-const FunctionDoc str_repeat_doc(
+const FunctionDoc string_repeat_doc(
     "Repeat a string", ("For each string in `strings`, return a replicated version."),
     {"strings", "repeats"});
 }  // namespace
@@ -4926,7 +4926,7 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   AddSplit(registry);
   AddStrptime(registry);
   AddBinaryJoin(registry);
-  MakeStrRepeatBatchKernel<StrRepeat>("str_repeat", registry, &str_repeat_doc);
+  MakeStringRepeatBatchKernel<StringRepeat>("string_repeat", registry, &string_repeat_doc);
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index de6cd9680d8..f3b907fa197 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -31,6 +31,7 @@
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/test_util.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/type.h"
 
 namespace arrow {
 namespace compute {
@@ -1031,9 +1032,7 @@ TYPED_TEST(TestStringKernels, Utf8Title) {
       R"([null, "", "B", "Aaaz;Zææ&", "Ɑɽɽow", "Ii", "Ⱥ.Ⱥ.Ⱥ..Ⱥ", "Hello, World!", "Foo   Bar;Héhé0Zop", "!%$^.,;"])");
 }
 
-TYPED_TEST(TestStringKernels, StrRepeat) {
-  this->CheckUnary("str_repeat", "[]", this->type(), "[]");
-
+TYPED_TEST(TestStringKernels, StringRepeat) {
   auto values = ArrayFromJSON(
       this->type(),
       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
@@ -1048,22 +1047,22 @@ TYPED_TEST(TestStringKernels, StrRepeat) {
   for (const auto& pair : repeats_and_expected) {
     auto repeat = pair.first;
     auto expected = pair.second;
-    for (const auto& ty : internal::IntTypes()) {
-      this->CheckVarArgs("str_repeat", {values, Datum(*arrow::MakeScalar(ty, repeat))},
+    for (const auto& ty : IntTypes()) {
+      this->CheckVarArgs("string_repeat", {values, Datum(*arrow::MakeScalar(ty, repeat))},
                          this->type(), expected);
     }
   }
 }
 
-TYPED_TEST(TestStringKernels, StrRepeats) {
-  for (const auto& ty : internal::IntTypes()) {
+TYPED_TEST(TestStringKernels, StringRepeats) {
+  for (const auto& ty : IntTypes()) {
     auto repeats = ArrayFromJSON(ty, R"([100, 1, 2, 4, 2, 0, 1, 3, 2, 3])");
     auto values = ArrayFromJSON(
         this->type(),
         R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
     std::string expected =
         R"([null, "aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
-    this->CheckVarArgs("str_repeat", {values, repeats}, this->type(), expected);
+    this->CheckVarArgs("string_repeat", {values, repeats}, this->type(), expected);
   }
 }
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 40763b5de2f..d1d25a39355 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -131,7 +131,6 @@ def test_option_class_equality():
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
         pc.QuantileOptions(),
-        pc.RepeatOptions(1),
         pc.ReplaceSliceOptions(0, 1, "a"),
         pc.ReplaceSubstringOptions("a", "b"),
         pc.RoundOptions(2, "towards_infinity"),
@@ -2239,7 +2238,7 @@ def test_count_distinct_options():
     assert pc.count_distinct(arr, mode='all').as_py() == 4
 
 
-def test_str_repeat():
+def test_string_repeat():
     # Test with single value for number of repeats
     values = ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"]
     repeat_and_expected = [
@@ -2248,7 +2247,7 @@ def test_str_repeat():
         [2, ["æÆ&æÆ&", None, "", "bb", "ɑɽⱤoWɑɽⱤoW", "ıIıI", "$. 3$. 3"]],
     ]
     for repeat, expected in repeat_and_expected:
-        result = pc.str_repeat(values, repeat)
+        result = pc.string_repeat(values, repeat)
         assert result.equals(pa.array(expected))
 
     # Test with multiple values for number of repeats
@@ -2260,5 +2259,5 @@ def test_str_repeat():
         [[0, 0], ["", ""]],
     ]
     for repeat, expected in repeat_and_expected:
-        result = pc.str_repeat(values, repeat)
+        result = pc.string_repeat(values, repeat)
         assert result.equals(pa.array(expected))

From 60f0a234967b84501c38cdacad7b735328882c31 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 18 Oct 2021 15:27:57 -0400
Subject: [PATCH 41/84] update kernel registration and StringTransformBase
 virtual methods

---
 .../arrow/compute/kernels/scalar_string.cc    | 135 ++++++++++--------
 1 file changed, 77 insertions(+), 58 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index be15c7ee53a..d55854e4f0a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -31,7 +31,6 @@
 #include "arrow/array/builder_binary.h"
 #include "arrow/array/builder_nested.h"
 #include "arrow/buffer_builder.h"
-
 #include "arrow/builder.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
@@ -539,45 +538,61 @@ struct FixedSizeBinaryTransformExecWithState
   }
 };
 
+template <typename Type1, typename Type2>
 struct StringBinaryTransformBase {
-  virtual ~StringBinaryTransformBase() = default;
-
-  virtual Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    return Status::OK();
-  }
-
-  virtual Status InvalidStatus() const {
-    return Status::Invalid("Invalid UTF8 sequence in input");
-  }
+  using ViewType2 = typename GetViewType<Type2>::T;
+  using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
+  using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
   // Not all combinations of input shapes are meaningful to string binary transforms, so
   // these flags serve as toggles for enabling/disabling the corresponding ones. These
   // flags should be set in the PreExec() method.
+  //
+  // This is an example of a StringTransform that disables argument shapes with mixed
+  // scalar/array.
+  //
+  // template <typename Type1, typename Type2>
+  // struct MyStringTransform : public StringBinaryTransformBase<Type1, Type2> {
+  //   Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) override {
+  //     EnableScalarArray = false;
+  //     EnableArrayScalar = false;
+  //     return StringBinaryTransformBase::PreExec(ctx, batch, out);
+  //   }
+  //   ...
+  // };
   bool EnableScalarScalar = true;
   bool EnableScalarArray = true;
   bool EnableArrayScalar = true;
   bool EnableArrayArray = true;
 
-  // Derived classes need to define all the MaxCodeunits methods even if they are not used
-  // due to disabling the corresponding "EnableXXX" flag. Unfortunately, these methods
-  // cannot be virtual predefined in this base class because C++ does not supports
-  // creating vtables from templetized methods. using ViewType2 = typename
-  // GetViewType<Type2>::T; using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
-  // using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
+  virtual ~StringBinaryTransformBase() = default;
+
+  virtual Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    return Status::OK();
+  }
+
+  virtual Status InvalidStatus() {
+    return Status::Invalid("Invalid UTF8 sequence in input");
+  }
 
   // Return the maximum total size of the output in codeunits (i.e. bytes)
   // given input characteristics for Scalar-Scalar, Scalar-Array, Array-Scalar, and
-  // Array-Array inputs. int64_t MaxCodeunits(const int64_t input1_ncodeunits, const
-  // ViewType2 value2) const { return 0; }
-  //
-  // int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2& input2) const
-  // { return 0; }
-  //
-  // int64_t MaxCodeunits(const ArrayType1& input1, const ViewType2 value2) const { return
-  // 0; }
-  //
-  // int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) const {
-  // return 0; }
+  // Array-Array inputs.
+  virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ViewType2) {
+    return input1_ncodeunits;
+  }
+
+  virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2&) {
+    return input1_ncodeunits;
+  }
+
+  virtual int64_t MaxCodeunits(const ArrayType1& input1, const ViewType2) {
+    return input1.total_values_length();
+  }
+
+  virtual int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2&) {
+    return input1.total_values_length();
+  }
 };
 
 /// Kernel exec generator for binary string transforms.  The first parameter is expected
@@ -2808,7 +2823,7 @@ void AddSplit(FunctionRegistry* registry) {
 }
 
 template <typename Type1, typename Type2>
-struct StringRepeatTransform : public StringBinaryTransformBase {
+struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
@@ -2816,21 +2831,12 @@ struct StringRepeatTransform : public StringBinaryTransformBase {
   // output data)? It is not an option, so do other compute functions validate their
   // inputs or let them fail when they fail?
 
-  // TODO(edponce): This is just an example of how to disable function arguments of
-  // specific input shapes. Status PreExec(KernelContext* ctx, const ExecBatch& batch,
-  // Datum* out) override {
-  //   EnableScalarArray = false;
-  //   return StringBinaryTransformBase::PreExec(ctx, batch, out);
-  // }
-  //
-  // int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2& input2) const
-  // { return 0; }
-
-  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const int64_t nrepeats) const {
+  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const int64_t nrepeats) override {
     return input1_ncodeunits * nrepeats;
   }
 
-  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2& input2) const {
+  int64_t MaxCodeunits(const int64_t input1_ncodeunits,
+                       const ArrayType2& input2) override {
     int64_t total_nrepeats = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
       total_nrepeats += input2.GetView(i);
@@ -2838,11 +2844,11 @@ struct StringRepeatTransform : public StringBinaryTransformBase {
     return input1_ncodeunits * total_nrepeats;
   }
 
-  int64_t MaxCodeunits(const ArrayType1& input1, const int64_t nrepeats) const {
+  int64_t MaxCodeunits(const ArrayType1& input1, const int64_t nrepeats) override {
     return input1.total_values_length() * nrepeats;
   }
 
-  int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) const {
+  int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) override {
     int64_t total_codeunits = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
       total_codeunits += input1.GetView(i).length() * input2.GetView(i);
@@ -2882,23 +2888,36 @@ template <typename Type1, typename Type2>
 using StringRepeat =
     StringBinaryTransformExec<Type1, Type2, StringRepeatTransform<Type1, Type2>>;
 
-template <template <typename...> class ExecFunctor>
-void MakeStringRepeatBatchKernel(std::string name, FunctionRegistry* registry,
-                              const FunctionDoc* doc) {
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Binary(), doc);
-  {
-    for (const auto& ty : IntTypes()) {
-      auto exec = GenerateInteger<ExecFunctor, StringType>(ty);
-      ScalarKernel kernel{{utf8(), ty}, utf8(), exec};
-      DCHECK_OK(func->AddKernel(std::move(kernel)));
+/// An ScalarFunction that promotes integer arguments to Int64.
+struct ScalarUpcastToInt64Function : public ScalarFunction {
+  using ScalarFunction::ScalarFunction;
+
+  Result<const Kernel*> DispatchBest(std::vector<ValueDescr>* values) const override {
+    RETURN_NOT_OK(CheckArity(*values));
+
+    using arrow::compute::detail::DispatchExactImpl;
+    if (auto kernel = DispatchExactImpl(this, *values)) return kernel;
+
+    EnsureDictionaryDecoded(values);
+
+    for (auto& descr : *values) {
+      if (is_integer(descr.type->id())) {
+        descr.type = int64();
+      }
     }
+
+    if (auto kernel = DispatchExactImpl(this, *values)) return kernel;
+    return arrow::compute::detail::NoMatchingKernel(this, *values);
   }
-  {
-    for (const auto& ty : IntTypes()) {
-      auto exec = GenerateInteger<ExecFunctor, LargeStringType>(ty);
-      ScalarKernel kernel{{large_utf8(), ty}, large_utf8(), exec};
-      DCHECK_OK(func->AddKernel(std::move(kernel)));
-    }
+};
+
+void AddStringRepeat(std::string name, FunctionRegistry* registry,
+                     const FunctionDoc* doc) {
+  auto func = std::make_shared<ScalarUpcastToInt64Function>(name, Arity::Binary(), doc);
+  for (const auto& ty : BaseBinaryTypes()) {
+    auto exec = GenerateVarBinaryToVarBinary<StringRepeat, Int64Type>(ty);
+    ScalarKernel kernel{{ty, int64()}, ty, exec};
+    DCHECK_OK(func->AddKernel(std::move(kernel)));
   }
   DCHECK_OK(registry->AddFunction(std::move(func)));
 }
@@ -4926,7 +4945,7 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   AddSplit(registry);
   AddStrptime(registry);
   AddBinaryJoin(registry);
-  MakeStringRepeatBatchKernel<StringRepeat>("string_repeat", registry, &string_repeat_doc);
+  AddStringRepeat("string_repeat", registry, &string_repeat_doc);
 }
 
 }  // namespace internal

From 00204f3aa678532b45d1831ca30575bdc605e4c0 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 18 Oct 2021 15:57:06 -0400
Subject: [PATCH 42/84] support negative repeat counts

---
 .../arrow/compute/kernels/scalar_string.cc    | 13 ++--
 .../compute/kernels/scalar_string_test.cc     | 61 ++++++++++++++-----
 2 files changed, 53 insertions(+), 21 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index d55854e4f0a..dbca6a25e42 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2829,10 +2829,13 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
 
   // TODO(edponce): Should we validate nrepeats (it will fail when trying to allocate
   // output data)? It is not an option, so do other compute functions validate their
-  // inputs or let them fail when they fail?
+  // inputs or let them fail when they fail? Or should inputs be validated in PreExec,
+  // but then need to validate methods (Scalar/Array)?
+  //
+  // Current approach returns empty string if nrepeats is negative.
 
   int64_t MaxCodeunits(const int64_t input1_ncodeunits, const int64_t nrepeats) override {
-    return input1_ncodeunits * nrepeats;
+    return std::max(input1_ncodeunits * nrepeats, (int64_t)0);
   }
 
   int64_t MaxCodeunits(const int64_t input1_ncodeunits,
@@ -2841,11 +2844,11 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     for (int64_t i = 0; i < input2.length(); ++i) {
       total_nrepeats += input2.GetView(i);
     }
-    return input1_ncodeunits * total_nrepeats;
+    return std::max(input1_ncodeunits * total_nrepeats, (int64_t)0);
   }
 
   int64_t MaxCodeunits(const ArrayType1& input1, const int64_t nrepeats) override {
-    return input1.total_values_length() * nrepeats;
+    return std::max(input1.total_values_length() * nrepeats, (int64_t)0);
   }
 
   int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) override {
@@ -2853,7 +2856,7 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     for (int64_t i = 0; i < input2.length(); ++i) {
       total_codeunits += input1.GetView(i).length() * input2.GetView(i);
     }
-    return total_codeunits;
+    return std::max(total_codeunits, (int64_t)0);
   }
 
   int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index f3b907fa197..ffe1c8d6623 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1036,32 +1036,61 @@ TYPED_TEST(TestStringKernels, StringRepeat) {
   auto values = ArrayFromJSON(
       this->type(),
       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
-  std::vector<std::pair<int64_t, std::string>> repeats_and_expected_map({
-      {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
-      {1,
-       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
-      {3,
-       R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbb", "ɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
-  }};
-
-  for (const auto& pair : repeats_and_expected) {
-    auto repeat = pair.first;
-    auto expected = pair.second;
-    for (const auto& ty : IntTypes()) {
-      this->CheckVarArgs("string_repeat", {values, Datum(*arrow::MakeScalar(ty, repeat))},
-                         this->type(), expected);
+  {
+    std::vector<std::pair<int64_t, std::string>> repeats_and_expected{{
+        {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
+        {1,
+         R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
+        {4,
+         R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbbb", "ɑɽⱤoWɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
+    }};
+
+    for (const auto& pair : repeats_and_expected) {
+      auto repeat = pair.first;
+      auto expected = pair.second;
+      for (const auto& ty : IntTypes()) {
+        this->CheckVarArgs("string_repeat",
+                           {values, Datum(*arrow::MakeScalar(ty, repeat))}, this->type(),
+                           expected);
+      }
+    }
+  }
+  {
+    // Negative repeat count
+    std::vector<std::pair<int, std::string>> repeats_and_expected{{
+        {-1, R"(["", null, "", "", "", "", "", "", "", ""])"},
+        {-4, R"(["", null, "", "", "", "", "", "", "", ""])"},
+    }};
+
+    for (const auto& pair : repeats_and_expected) {
+      auto repeat = pair.first;
+      auto expected = pair.second;
+      for (const auto& ty : SignedIntTypes()) {
+        this->CheckVarArgs("string_repeat",
+                           {values, Datum(*arrow::MakeScalar(ty, repeat))}, this->type(),
+                           expected);
+      }
     }
   }
 }
 
 TYPED_TEST(TestStringKernels, StringRepeats) {
   for (const auto& ty : IntTypes()) {
-    auto repeats = ArrayFromJSON(ty, R"([100, 1, 2, 4, 2, 0, 1, 3, 2, 3])");
+    auto repeats = ArrayFromJSON(ty, R"([100, 1, 2, 5, 2, 0, 1, 3, 2, 3])");
     auto values = ArrayFromJSON(
         this->type(),
         R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
     std::string expected =
-        R"([null, "aAazZæÆ&", "", "bbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
+        R"([null, "aAazZæÆ&", "", "bbbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
+    this->CheckVarArgs("string_repeat", {values, repeats}, this->type(), expected);
+  }
+
+  for (const auto& ty : SignedIntTypes()) {
+    auto repeats = ArrayFromJSON(ty, R"([-100, -1, -2, -5, -2, -1, -3, -2, -3])");
+    auto values = ArrayFromJSON(
+        this->type(),
+        R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+    std::string expected = R"([null, "", "", "", "", "", "", "", ""])";
     this->CheckVarArgs("string_repeat", {values, repeats}, this->type(), expected);
   }
 }

From e35926d02acecdca875ec85337b1e7b36269400b Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 18 Oct 2021 17:25:46 -0400
Subject: [PATCH 43/84] add transform wrappers for simple/doubling repeat
 implementations

---
 .../arrow/compute/kernels/scalar_string.cc    | 75 ++++++++++++-------
 1 file changed, 48 insertions(+), 27 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index dbca6a25e42..731d74fe80c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2827,13 +2827,6 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
-  // TODO(edponce): Should we validate nrepeats (it will fail when trying to allocate
-  // output data)? It is not an option, so do other compute functions validate their
-  // inputs or let them fail when they fail? Or should inputs be validated in PreExec,
-  // but then need to validate methods (Scalar/Array)?
-  //
-  // Current approach returns empty string if nrepeats is negative.
-
   int64_t MaxCodeunits(const int64_t input1_ncodeunits, const int64_t nrepeats) override {
     return std::max(input1_ncodeunits * nrepeats, (int64_t)0);
   }
@@ -2859,32 +2852,60 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return std::max(total_codeunits, (int64_t)0);
   }
 
-  int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
-                    const int64_t nrepeats, uint8_t* output) {
+  std::function<int64_t(const uint8_t*, const int64_t, const int64_t, uint8_t*)>
+      Transform;
+
+  static int64_t TransformSimple(const uint8_t* input,
+                                 const int64_t input_string_ncodeunits,
+                                 const int64_t nrepeats, uint8_t* output) {
     uint8_t* output_start = output;
-    if (nrepeats < 4) {
-      for (int64_t i = 0; i < nrepeats; ++i) {
-        std::memcpy(output, input, input_string_ncodeunits);
-        output += input_string_ncodeunits;
-      }
-    } else {
-      // Repeated doubling of string
+    for (int64_t i = 0; i < nrepeats; ++i) {
       std::memcpy(output, input, input_string_ncodeunits);
       output += input_string_ncodeunits;
-      int64_t i = 1;
-      for (int64_t ilen = input_string_ncodeunits; i <= (nrepeats / 2);
-           i *= 2, ilen *= 2) {
-        std::memcpy(output, output_start, ilen);
-        output += ilen;
-      }
-
-      // Epilogue remainder
-      int64_t rem = (nrepeats ^ i) * input_string_ncodeunits;
-      std::memcpy(output, output_start, rem);
-      output += rem;
     }
     return output - output_start;
   }
+
+  static int64_t TransformDoubling(const uint8_t* input,
+                                   const int64_t input_string_ncodeunits,
+                                   const int64_t nrepeats, uint8_t* output) {
+    uint8_t* output_start = output;
+    // Repeated doubling of string
+    std::memcpy(output, input, input_string_ncodeunits);
+    output += input_string_ncodeunits;
+    int64_t i = 1;
+    for (int64_t ilen = input_string_ncodeunits; i <= (nrepeats / 2); i *= 2, ilen *= 2) {
+      std::memcpy(output, output_start, ilen);
+      output += ilen;
+    }
+
+    // Epilogue remainder
+    int64_t rem = (nrepeats ^ i) * input_string_ncodeunits;
+    std::memcpy(output, output_start, rem);
+    output += rem;
+    return output - output_start;
+  }
+
+  static int64_t TransformWrapper(const uint8_t* input,
+                                  const int64_t input_string_ncodeunits,
+                                  const int64_t nrepeats, uint8_t* output) {
+    auto transform = (nrepeats < 4) ? TransformSimple : TransformDoubling;
+    return transform(input, input_string_ncodeunits, nrepeats, output);
+  }
+
+  // For input shape ArrayScalar, we cache the repeat implementation to use
+  // based on repeat count. Otherwise, use TransformWrapper which checks repeat
+  // count for each pair of processing values.
+  Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
+    if (batch[0].is_array() && batch[1].is_scalar()) {
+      auto scalar = batch[1].scalar();
+      auto nrepeats = UnboxScalar<Type2>::Unbox(*scalar);
+      Transform = (nrepeats < 4) ? TransformSimple : TransformDoubling;
+    } else {
+      Transform = TransformWrapper;
+    }
+    return Status::OK();
+  }
 };
 
 template <typename Type1, typename Type2>

From 1df1c714a8b1ef5d9f21d44621938d41343e4b05 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 18 Oct 2021 20:47:38 -0400
Subject: [PATCH 44/84] support FixedSizeBinary, remove static_casts, and
 update comments

---
 .../arrow/compute/kernels/scalar_string.cc    | 81 ++++++++++---------
 1 file changed, 44 insertions(+), 37 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 731d74fe80c..d3ae4cea6a2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -334,6 +334,12 @@ struct StringTransformBase {
   }
 };
 
+/// Kernel exec generator for unary string transforms. Types of template
+/// parameter StringTransform need to define a transform method with the
+/// following signature:
+///
+/// int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
+///                   uint8_t* output);
 template <typename Type, typename StringTransform>
 struct StringTransformExecBase {
   using offset_type = typename Type::offset_type;
@@ -373,7 +379,7 @@ struct StringTransformExecBase {
     offset_type* output_string_offsets = output->GetMutableValues<offset_type>(1);
     uint8_t* output_str = output->buffers[2]->mutable_data();
     offset_type output_ncodeunits = 0;
-    output_string_offsets[0] = 0;
+    output_string_offsets[0] = output_ncodeunits;
     for (int64_t i = 0; i < input_nstrings; i++) {
       if (!input.IsNull(i)) {
         offset_type input_string_ncodeunits;
@@ -418,10 +424,6 @@ struct StringTransformExecBase {
     DCHECK_LE(encoded_nbytes, output_ncodeunits_max);
     return value_buffer->Resize(encoded_nbytes, /*shrink_to_fit=*/true);
   }
-
-  // StringTransform type should define this method:
-  //   int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
-  //                     uint8_t* output);
 };
 
 template <typename Type, typename StringTransform>
@@ -595,12 +597,14 @@ struct StringBinaryTransformBase {
   }
 };
 
-/// Kernel exec generator for binary string transforms.  The first parameter is expected
-/// to always be a string type while the second parameter is generic.
-// TODO(edponce): This approach currently does not works for FixedSizeBinaryArray:
-//   * because its GetValue() does not return the string size. To circumvent, we could use
-//   GetView() on first input (always a util::string_view) and get its length via
-//   str.length() method.
+/// Kernel exec generator for binary (two parameters) string transforms.
+/// The first parameter is expected to always be a Binary/StringType while the
+/// second parameter is generic. Types of template parameter StringTransform
+/// need to define a transform method with the following signature:
+///
+/// int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
+///                   const ViewType2 value2, uint8_t* output);
+
 // TODO(edponce): Refactor common parts out and make use VisitorArrayValuesInline from
 // codegen_internal.h (assuming LogicalValue always matches the type returned by GetView()
 // which seems the case).
@@ -667,12 +671,14 @@ struct StringBinaryTransformExecBase {
     auto output_str = value_buffer->mutable_data();
 
     auto input1_string = input1.value->data();
-    auto encoded_nbytes = static_cast<offset_type>(
-        transform->Transform(input1_string, input_ncodeunits, value2, output_str));
+    offset_type encoded_nbytes =
+        transform->Transform(input1_string, input_ncodeunits, value2, output_str);
     if (encoded_nbytes < 0) {
       return transform->InvalidStatus();
     }
     DCHECK_LE(encoded_nbytes, output_ncodeunits_max);
+
+    // Trim the codepoint buffer, since we allocated too much
     return value_buffer->Resize(encoded_nbytes, /*shrink_to_fit=*/true);
   }
 
@@ -698,17 +704,20 @@ struct StringBinaryTransformExecBase {
     // String offsets are preallocated
     auto output_string_offsets = output->GetMutableValues<offset_type>(1);
     auto output_str = output->buffers[2]->mutable_data();
-    output_string_offsets[0] = 0;
-
-    auto input1_nstrings = input1.length();
     offset_type output_ncodeunits = 0;
-    for (int64_t i = 0; i < input1_nstrings; ++i) {
+    output_string_offsets[0] = output_ncodeunits;
+    for (int64_t i = 0; i < input1.length(); ++i) {
       if (!input1.IsNull(i)) {
-        offset_type input1_string_ncodeunits;
-        auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
-        auto encoded_nbytes = static_cast<offset_type>(
+        // NB: Using GetValue() for first input does not provides support
+        // for FixedSizeBinaryArray because its GetValue() method does not
+        // returns the string size. Instead, we use GetView() which returns a
+        // string_view and get its length via str.length() method.
+        auto input1_string_view = input1.GetView(i);
+        offset_type input1_string_ncodeunits = input1_string_view.length();
+        auto input1_string = reinterpret_cast<const uint8_t*>(input1_string_view.data());
+        offset_type encoded_nbytes =
             transform->Transform(input1_string, input1_string_ncodeunits, value2,
-                                 output_str + output_ncodeunits));
+                                 output_str + output_ncodeunits);
         if (encoded_nbytes < 0) {
           return transform->InvalidStatus();
         }
@@ -751,14 +760,13 @@ struct StringBinaryTransformExecBase {
     // because the input string is a Scalar.
     auto output_string_offsets = output->GetMutableValues<offset_type>(1);
     auto output_str = output->buffers[2]->mutable_data();
-    output_string_offsets[0] = 0;
-
     offset_type output_ncodeunits = 0;
+    output_string_offsets[0] = output_ncodeunits;
     for (int64_t i = 0; i < input2_nvalues; ++i) {
       if (!input2.IsNull(i)) {
         auto value2 = input2.GetView(i);
-        auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
-            input1_string, input1_ncodeunits, value2, output_str + output_ncodeunits));
+        offset_type encoded_nbytes = transform->Transform(
+            input1_string, input1_ncodeunits, value2, output_str + output_ncodeunits);
         if (encoded_nbytes < 0) {
           return transform->InvalidStatus();
         }
@@ -778,7 +786,6 @@ struct StringBinaryTransformExecBase {
     ArrayType1 input1(data1);
     ArrayType2 input2(data2);
 
-    auto input1_nstrings = input1.length();
     auto output_ncodeunits_max = transform->MaxCodeunits(input1, input2);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
@@ -792,17 +799,21 @@ struct StringBinaryTransformExecBase {
     // String offsets are preallocated
     auto output_string_offsets = output->GetMutableValues<offset_type>(1);
     auto output_str = output->buffers[2]->mutable_data();
-    output_string_offsets[0] = 0;
-
     offset_type output_ncodeunits = 0;
-    for (int64_t i = 0; i < input1_nstrings; ++i) {
+    output_string_offsets[0] = output_ncodeunits;
+    for (int64_t i = 0; i < input1.length(); ++i) {
       if (!input1.IsNull(i) || !input2.IsNull(i)) {
-        offset_type input1_string_ncodeunits;
-        auto input1_string = input1.GetValue(i, &input1_string_ncodeunits);
+        // NB: Using GetValue() for first input does not provides support
+        // for FixedSizeBinaryArray because its GetValue() method does not
+        // returns the string size. Instead, we use GetView() which returns a
+        // string_view and get its length via str.length() method.
+        auto input1_string_view = input1.GetView(i);
+        offset_type input1_string_ncodeunits = input1_string_view.length();
+        auto input1_string = reinterpret_cast<const uint8_t*>(input1_string_view.data());
         auto value2 = input2.GetView(i);
-        auto encoded_nbytes = static_cast<offset_type>(
+        offset_type encoded_nbytes =
             transform->Transform(input1_string, input1_string_ncodeunits, value2,
-                                 output_str + output_ncodeunits));
+                                 output_str + output_ncodeunits);
         if (encoded_nbytes < 0) {
           return transform->InvalidStatus();
         }
@@ -815,10 +826,6 @@ struct StringBinaryTransformExecBase {
     // Trim the codepoint buffer, since we allocated too much
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
-
-  // StringTransform type should define this method:
-  //   int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
-  //   const ViewType2 value2, uint8_t* output) const;
 };
 
 template <typename Type1, typename Type2, typename StringTransform>

From 2a38b36a2ff0d69155e3282ff11622559223c4ab Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 01:48:24 -0400
Subject: [PATCH 45/84] use visitor for ArrayScalar exec

---
 .../arrow/compute/kernels/scalar_string.cc    | 67 +++++++++----------
 1 file changed, 33 insertions(+), 34 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index d3ae4cea6a2..d057dd64f05 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -689,45 +689,47 @@ struct StringBinaryTransformExecBase {
       return Status::OK();
     }
 
-    ArrayType1 input1(data1);
+    // Calculate/check max number of output codeunits
     auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
-    auto output_ncodeunits_max = transform->MaxCodeunits(input1, value2);
-    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
+    auto max_output_ncodeunits =
+        transform->MaxCodeunits(static_cast<ArrayType1>(data1), value2);
+    if (max_output_ncodeunits > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
-          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
+          "Result might not fit in requested binary/string array. If possible, convert "
+          "to a large binary/string.");
     }
 
-    ArrayData* output = out->mutable_array();
-    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
+    // Allocate output strings
+    const auto output = out->mutable_array();
+    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(max_output_ncodeunits));
     output->buffers[2] = values_buffer;
+    const auto output_string = output->buffers[2]->mutable_data();
 
     // String offsets are preallocated
-    auto output_string_offsets = output->GetMutableValues<offset_type>(1);
-    auto output_str = output->buffers[2]->mutable_data();
+    auto output_offsets = output->GetMutableValues<offset_type>(1);
+    output_offsets[0] = 0;
     offset_type output_ncodeunits = 0;
-    output_string_offsets[0] = output_ncodeunits;
-    for (int64_t i = 0; i < input1.length(); ++i) {
-      if (!input1.IsNull(i)) {
-        // NB: Using GetValue() for first input does not provides support
-        // for FixedSizeBinaryArray because its GetValue() method does not
-        // returns the string size. Instead, we use GetView() which returns a
-        // string_view and get its length via str.length() method.
-        auto input1_string_view = input1.GetView(i);
-        offset_type input1_string_ncodeunits = input1_string_view.length();
-        auto input1_string = reinterpret_cast<const uint8_t*>(input1_string_view.data());
-        offset_type encoded_nbytes =
-            transform->Transform(input1_string, input1_string_ncodeunits, value2,
-                                 output_str + output_ncodeunits);
-        if (encoded_nbytes < 0) {
-          return transform->InvalidStatus();
-        }
-        output_ncodeunits += encoded_nbytes;
-      }
-      output_string_offsets[i + 1] = output_ncodeunits;
-    }
-    DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
 
-    // Trim the codepoint buffer, since we allocated too much
+    ARROW_RETURN_NOT_OK(arrow::internal::ArrayDataInlineVisitor<Type1>::VisitStatus(
+        *data1,
+        [&](util::string_view input_string_view) {
+          auto input_ncodeunits = static_cast<offset_type>(input_string_view.length());
+          auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
+          auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
+              input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
+          if (encoded_nbytes < 0) {
+            return transform->InvalidStatus();
+          }
+          output_ncodeunits += encoded_nbytes;
+          *(++output_offsets) = output_ncodeunits;
+          return Status::OK();
+        },
+        [&]() {
+          *(++output_offsets) = output_ncodeunits;
+          return Status::OK();
+        }));
+    DCHECK_LE(output_ncodeunits, max_output_ncodeunits);
+
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
 
@@ -743,7 +745,6 @@ struct StringBinaryTransformExecBase {
     auto input1_ncodeunits = input1.value->size();
 
     ArrayType2 input2(data2);
-    auto input2_nvalues = input2.length();
 
     auto output_ncodeunits_max = transform->MaxCodeunits(input1_ncodeunits, input2);
     if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
@@ -756,13 +757,11 @@ struct StringBinaryTransformExecBase {
     output->buffers[2] = values_buffer;
 
     // String offsets are preallocated
-    // TODO(edponce): Check that string offsets have been preallocated
-    // because the input string is a Scalar.
     auto output_string_offsets = output->GetMutableValues<offset_type>(1);
     auto output_str = output->buffers[2]->mutable_data();
     offset_type output_ncodeunits = 0;
     output_string_offsets[0] = output_ncodeunits;
-    for (int64_t i = 0; i < input2_nvalues; ++i) {
+    for (int64_t i = 0; i < input2.length(); ++i) {
       if (!input2.IsNull(i)) {
         auto value2 = input2.GetView(i);
         offset_type encoded_nbytes = transform->Transform(

From a2b50446909037a61e2cdc8f25fdccd1a54fa677 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 05:04:24 -0400
Subject: [PATCH 46/84] refactor StringBinaryTransformExecBase with visitors

---
 .../arrow/compute/kernels/scalar_string.cc    | 223 ++++++++++--------
 cpp/src/arrow/util/bit_block_counter.h        |  48 ++++
 2 files changed, 174 insertions(+), 97 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index d057dd64f05..9bad4786149 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -395,7 +395,7 @@ struct StringTransformExecBase {
     }
     DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
 
-    // Trim the codepoint buffer, since we allocated too much
+    // Trim the codepoint buffer, since we may have allocated too much
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
 
@@ -604,10 +604,6 @@ struct StringBinaryTransformBase {
 ///
 /// int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
 ///                   const ViewType2 value2, uint8_t* output);
-
-// TODO(edponce): Refactor common parts out and make use VisitorArrayValuesInline from
-// codegen_internal.h (assuming LogicalValue always matches the type returned by GetView()
-// which seems the case).
 template <typename Type1, typename Type2, typename StringTransform>
 struct StringBinaryTransformExecBase {
   using offset_type = typename Type1::offset_type;
@@ -654,31 +650,31 @@ struct StringBinaryTransformExecBase {
     if (!scalar1->is_valid || !scalar2->is_valid) {
       return Status::OK();
     }
+    const auto& binary_scalar1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
+    const auto input_string = binary_scalar1.value->data();
+    const auto input_ncodeunits = binary_scalar1.value->size();
+    const auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
 
-    const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
-    auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
-    auto input_ncodeunits = input1.value->size();
-    auto output_ncodeunits_max = transform->MaxCodeunits(input_ncodeunits, value2);
-    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
-      return Status::CapacityError(
-          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
-    }
+    // Calculate max number of output codeunits
+    const auto max_output_ncodeunits = transform->MaxCodeunits(input_ncodeunits, value2);
+    RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
-    ARROW_ASSIGN_OR_RAISE(auto value_buffer, ctx->Allocate(output_ncodeunits_max));
-    auto result = checked_cast<BaseBinaryScalar*>(out->scalar().get());
-    result->is_valid = true;
-    result->value = value_buffer;
-    auto output_str = value_buffer->mutable_data();
+    // Allocate output string
+    const auto output = checked_cast<BaseBinaryScalar*>(out->scalar().get());
+    output->is_valid = true;
+    ARROW_ASSIGN_OR_RAISE(auto value_buffer, ctx->Allocate(max_output_ncodeunits));
+    output->value = value_buffer;
+    auto output_string = output->value->mutable_data();
 
-    auto input1_string = input1.value->data();
-    offset_type encoded_nbytes =
-        transform->Transform(input1_string, input_ncodeunits, value2, output_str);
+    // Apply transform
+    auto encoded_nbytes = static_cast<offset_type>(
+        transform->Transform(input_string, input_ncodeunits, value2, output_string));
     if (encoded_nbytes < 0) {
       return transform->InvalidStatus();
     }
-    DCHECK_LE(encoded_nbytes, output_ncodeunits_max);
+    DCHECK_LE(encoded_nbytes, max_output_ncodeunits);
 
-    // Trim the codepoint buffer, since we allocated too much
+    // Trim the codepoint buffer, since we may have allocated too much
     return value_buffer->Resize(encoded_nbytes, /*shrink_to_fit=*/true);
   }
 
@@ -688,16 +684,12 @@ struct StringBinaryTransformExecBase {
     if (!scalar2->is_valid) {
       return Status::OK();
     }
+    const ArrayType1 array1(data1);
+    const auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
 
-    // Calculate/check max number of output codeunits
-    auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
-    auto max_output_ncodeunits =
-        transform->MaxCodeunits(static_cast<ArrayType1>(data1), value2);
-    if (max_output_ncodeunits > std::numeric_limits<offset_type>::max()) {
-      return Status::CapacityError(
-          "Result might not fit in requested binary/string array. If possible, convert "
-          "to a large binary/string.");
-    }
+    // Calculate max number of output codeunits
+    const auto max_output_ncodeunits = transform->MaxCodeunits(array1, value2);
+    RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
     const auto output = out->mutable_array();
@@ -710,7 +702,8 @@ struct StringBinaryTransformExecBase {
     output_offsets[0] = 0;
     offset_type output_ncodeunits = 0;
 
-    ARROW_RETURN_NOT_OK(arrow::internal::ArrayDataInlineVisitor<Type1>::VisitStatus(
+    // Apply transform
+    ARROW_RETURN_NOT_OK(VisitArrayDataInline<Type1>(
         *data1,
         [&](util::string_view input_string_view) {
           auto input_ncodeunits = static_cast<offset_type>(input_string_view.length());
@@ -730,6 +723,7 @@ struct StringBinaryTransformExecBase {
         }));
     DCHECK_LE(output_ncodeunits, max_output_ncodeunits);
 
+    // Trim the codepoint buffer, since we may have allocated too much
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
 
@@ -739,92 +733,127 @@ struct StringBinaryTransformExecBase {
     if (!scalar1->is_valid) {
       return Status::OK();
     }
+    const auto& binary_scalar1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
+    const auto input_string = binary_scalar1.value->data();
+    const auto input_ncodeunits = binary_scalar1.value->size();
+    const ArrayType2 array2(data2);
 
-    const auto& input1 = checked_cast<const BaseBinaryScalar&>(*scalar1);
-    auto input1_string = input1.value->data();
-    auto input1_ncodeunits = input1.value->size();
-
-    ArrayType2 input2(data2);
-
-    auto output_ncodeunits_max = transform->MaxCodeunits(input1_ncodeunits, input2);
-    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
-      return Status::CapacityError(
-          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
-    }
+    // Calculate max number of output codeunits
+    const auto max_output_ncodeunits = transform->MaxCodeunits(input_ncodeunits, array2);
+    RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
-    ArrayData* output = out->mutable_array();
-    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
+    // Allocate output strings
+    const auto output = out->mutable_array();
+    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(max_output_ncodeunits));
     output->buffers[2] = values_buffer;
+    const auto output_string = output->buffers[2]->mutable_data();
 
     // String offsets are preallocated
-    auto output_string_offsets = output->GetMutableValues<offset_type>(1);
-    auto output_str = output->buffers[2]->mutable_data();
+    auto output_offsets = output->GetMutableValues<offset_type>(1);
+    output_offsets[0] = 0;
     offset_type output_ncodeunits = 0;
-    output_string_offsets[0] = output_ncodeunits;
-    for (int64_t i = 0; i < input2.length(); ++i) {
-      if (!input2.IsNull(i)) {
-        auto value2 = input2.GetView(i);
-        offset_type encoded_nbytes = transform->Transform(
-            input1_string, input1_ncodeunits, value2, output_str + output_ncodeunits);
-        if (encoded_nbytes < 0) {
-          return transform->InvalidStatus();
-        }
-        output_ncodeunits += encoded_nbytes;
-      }
-      output_string_offsets[i + 1] = output_ncodeunits;
-    }
-    DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
 
-    // Trim the codepoint buffer, since we allocated too much
+    // XXX C++11 does not supports generic lambdas, so we cannot iterate
+    // through the unknown-typed Array in a generic way. C++14 provides support
+    // for generic lambdas.
+    // ARROW_RETURN_NOT_OK(VisitArrayDataInline<Type1>(
+    //     *data2,
+    //     [&](auto value2) {
+    //       auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
+    //           input_string, input_ncodeunits, value2, output_string +
+    //           output_ncodeunits));
+    //       if (encoded_nbytes < 0) {
+    //         return transform->InvalidStatus();
+    //       }
+    //       output_ncodeunits += encoded_nbytes;
+    //       *(++output_offsets) = output_ncodeunits;
+    //       return Status::OK();
+    //     },
+    //     [&]() {
+    //       *(++output_offsets) = output_ncodeunits;
+    //       return Status::OK();
+    //     }));
+
+    // Apply transform
+    ARROW_RETURN_NOT_OK(arrow::internal::VisitBitBlocks(
+        data2->buffers[0], data2->offset, data2->length,
+        [&](int64_t i) {
+          auto value2 = array2.GetView(i);
+          auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
+              input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
+          if (encoded_nbytes < 0) {
+            return transform->InvalidStatus();
+          }
+          output_ncodeunits += encoded_nbytes;
+          *(++output_offsets) = output_ncodeunits;
+          return Status::OK();
+        },
+        [&]() {
+          *(++output_offsets) = output_ncodeunits;
+          return Status::OK();
+        }));
+    DCHECK_LE(output_ncodeunits, max_output_ncodeunits);
+
+    // Trim the codepoint buffer, since we may have allocated too much
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
 
   static Status ExecArrayArray(KernelContext* ctx, StringTransform* transform,
                                const std::shared_ptr<ArrayData>& data1,
                                const std::shared_ptr<ArrayData>& data2, Datum* out) {
-    ArrayType1 input1(data1);
-    ArrayType2 input2(data2);
+    const ArrayType1 array1(data1);
+    const ArrayType2 array2(data2);
 
-    auto output_ncodeunits_max = transform->MaxCodeunits(input1, input2);
-    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
-      return Status::CapacityError(
-          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
-    }
+    // Calculate max number of output codeunits
+    const auto max_output_ncodeunits = transform->MaxCodeunits(array1, array2);
+    RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
-    ArrayData* output = out->mutable_array();
-    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
+    // Allocate output strings
+    const auto output = out->mutable_array();
+    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(max_output_ncodeunits));
     output->buffers[2] = values_buffer;
+    const auto output_string = output->buffers[2]->mutable_data();
 
     // String offsets are preallocated
-    auto output_string_offsets = output->GetMutableValues<offset_type>(1);
-    auto output_str = output->buffers[2]->mutable_data();
+    auto output_offsets = output->GetMutableValues<offset_type>(1);
+    output_offsets[0] = 0;
     offset_type output_ncodeunits = 0;
-    output_string_offsets[0] = output_ncodeunits;
-    for (int64_t i = 0; i < input1.length(); ++i) {
-      if (!input1.IsNull(i) || !input2.IsNull(i)) {
-        // NB: Using GetValue() for first input does not provides support
-        // for FixedSizeBinaryArray because its GetValue() method does not
-        // returns the string size. Instead, we use GetView() which returns a
-        // string_view and get its length via str.length() method.
-        auto input1_string_view = input1.GetView(i);
-        offset_type input1_string_ncodeunits = input1_string_view.length();
-        auto input1_string = reinterpret_cast<const uint8_t*>(input1_string_view.data());
-        auto value2 = input2.GetView(i);
-        offset_type encoded_nbytes =
-            transform->Transform(input1_string, input1_string_ncodeunits, value2,
-                                 output_str + output_ncodeunits);
-        if (encoded_nbytes < 0) {
-          return transform->InvalidStatus();
-        }
-        output_ncodeunits += encoded_nbytes;
-      }
-      output_string_offsets[i + 1] = output_ncodeunits;
-    }
-    DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
 
-    // Trim the codepoint buffer, since we allocated too much
+    // Apply transform
+    ARROW_RETURN_NOT_OK(arrow::internal::VisitTwoBitBlocks(
+        data1->buffers[0], data1->offset, data2->buffers[0], data2->offset, data1->length,
+        [&](int64_t i) {
+          auto input_string_view = array1.GetView(i);
+          offset_type input_ncodeunits = input_string_view.length();
+          auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
+          auto value2 = array2.GetView(i);
+          auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
+              input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
+          if (encoded_nbytes < 0) {
+            return transform->InvalidStatus();
+          }
+          output_ncodeunits += encoded_nbytes;
+          *(++output_offsets) = output_ncodeunits;
+          return Status::OK();
+        },
+        [&]() {
+          *(++output_offsets) = output_ncodeunits;
+          return Status::OK();
+        }));
+    DCHECK_LE(output_ncodeunits, max_output_ncodeunits);
+
+    // Trim the codepoint buffer, since we may have allocated too much
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
   }
+
+  static Status CheckOutputCapacity(int64_t ncodeunits) {
+    if (ncodeunits > std::numeric_limits<offset_type>::max()) {
+      return Status::CapacityError(
+          "Result might not fit in requested binary/string array. If possible, convert "
+          "to a large binary/string.");
+    }
+    return Status::OK();
+  }
 };
 
 template <typename Type1, typename Type2, typename StringTransform>
diff --git a/cpp/src/arrow/util/bit_block_counter.h b/cpp/src/arrow/util/bit_block_counter.h
index 46079903605..9d3a75a5a31 100644
--- a/cpp/src/arrow/util/bit_block_counter.h
+++ b/cpp/src/arrow/util/bit_block_counter.h
@@ -491,6 +491,54 @@ static void VisitBitBlocksVoid(const std::shared_ptr<Buffer>& bitmap_buf, int64_
   }
 }
 
+template <typename VisitNotNull, typename VisitNull>
+static Status VisitTwoBitBlocks(const std::shared_ptr<Buffer>& left_bitmap_buf,
+                                int64_t left_offset,
+                                const std::shared_ptr<Buffer>& right_bitmap_buf,
+                                int64_t right_offset, int64_t length,
+                                VisitNotNull&& visit_not_null, VisitNull&& visit_null) {
+  if (left_bitmap_buf == NULLPTR || right_bitmap_buf == NULLPTR) {
+    // At most one bitmap is present
+    if (left_bitmap_buf == NULLPTR) {
+      return VisitBitBlocks(right_bitmap_buf, right_offset, length,
+                            std::forward<VisitNotNull>(visit_not_null),
+                            std::forward<VisitNull>(visit_null));
+    } else {
+      return VisitBitBlocks(left_bitmap_buf, left_offset, length,
+                            std::forward<VisitNotNull>(visit_not_null),
+                            std::forward<VisitNull>(visit_null));
+    }
+  }
+  // Both bitmaps are present
+  const uint8_t* left_bitmap = left_bitmap_buf->data();
+  const uint8_t* right_bitmap = right_bitmap_buf->data();
+  BinaryBitBlockCounter bit_counter(left_bitmap, left_offset, right_bitmap, right_offset,
+                                    length);
+  int64_t position = 0;
+  while (position < length) {
+    BitBlockCount block = bit_counter.NextAndWord();
+    if (block.AllSet()) {
+      for (int64_t i = 0; i < block.length; ++i, ++position) {
+        ARROW_RETURN_NOT_OK(visit_not_null(position));
+      }
+    } else if (block.NoneSet()) {
+      for (int64_t i = 0; i < block.length; ++i, ++position) {
+        ARROW_RETURN_NOT_OK(visit_null());
+      }
+    } else {
+      for (int64_t i = 0; i < block.length; ++i, ++position) {
+        if (BitUtil::GetBit(left_bitmap, left_offset + position) &&
+            BitUtil::GetBit(right_bitmap, right_offset + position)) {
+          ARROW_RETURN_NOT_OK(visit_not_null(position));
+        } else {
+          ARROW_RETURN_NOT_OK(visit_null());
+        }
+      }
+    }
+  }
+  return Status::OK();
+}
+
 template <typename VisitNotNull, typename VisitNull>
 static void VisitTwoBitBlocksVoid(const std::shared_ptr<Buffer>& left_bitmap_buf,
                                   int64_t left_offset,

From ac56168ce56f7c3a37f1cea649b4ae691f1fc514 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 05:37:50 -0400
Subject: [PATCH 47/84] update docs

---
 docs/source/cpp/compute.rst        | 84 +++++++++++++++---------------
 docs/source/python/api/compute.rst |  2 +-
 2 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 266e0f82bad..513988861ad 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -812,47 +812,47 @@ The third set of functions examines string elements on a byte-per-byte basis:
 String transforms
 ~~~~~~~~~~~~~~~~~
 
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| Function name           | Arity  | Input types                           | Output type            | Options class                     | Notes |
-+=========================+========+=======================================+========================+===================================+=======+
-| ascii_capitalize        | Unary  | String-like                           | String-like            |                                   | \(1)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| ascii_lower             | Unary  | String-like                           | String-like            |                                   | \(1)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| ascii_reverse           | Unary  | String-like                           | String-like            |                                   | \(2)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| ascii_swapcase          | Unary  | String-like                           | String-like            |                                   | \(1)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| ascii_title             | Unary  | String-like                           | String-like            |                                   | \(1)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| ascii_upper             | Unary  | String-like                           | String-like            |                                   | \(1)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| binary_length           | Unary  | Binary- or String-like                | Int32 or Int64         |                                   | \(3)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| binary_replace_slice    | Unary  | String-like                           | Binary- or String-like | :struct:`ReplaceSliceOptions`     | \(4)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| replace_substring       | Unary  | String-like                           | String-like            | :struct:`ReplaceSubstringOptions` | \(5)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| replace_substring_regex | Unary  | String-like                           | String-like            | :struct:`ReplaceSubstringOptions` | \(6)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| str_repeat              | Binary | String-like (Arg 0); Integral (Arg 1) | String-like            |                                   | \(7)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_capitalize         | Unary  | String-like                           | String-like            |                                   | \(9)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_length             | Unary  | String-like                           | Int32 or Int64         |                                   | \(8)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_lower              | Unary  | String-like                           | String-like            |                                   | \(9)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_replace_slice      | Unary  | String-like                           | String-like            | :struct:`ReplaceSliceOptions`     | \(5)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_reverse            | Unary  | String-like                           | String-like            |                                   | \(10) |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_swapcase           | Unary  | String-like                           | String-like            |                                   | \(9)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_title              | Unary  | String-like                           | String-like            |                                   | \(9)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_upper              | Unary  | String-like                           | String-like            |                                   | \(9)  |
-+-------------------------+--------+---------------------------------------+------------------------+-----------------------------------+-------+
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| Function name           | Arity  | Input types                             | Output type            | Options class                     | Notes |
++=========================+========+=========================================+========================+===================================+=======+
+| ascii_capitalize        | Unary  | String-like                             | String-like            |                                   | \(1)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_lower             | Unary  | String-like                             | String-like            |                                   | \(1)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_reverse           | Unary  | String-like                             | String-like            |                                   | \(2)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_swapcase          | Unary  | String-like                             | String-like            |                                   | \(1)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_title             | Unary  | String-like                             | String-like            |                                   | \(1)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| ascii_upper             | Unary  | String-like                             | String-like            |                                   | \(1)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| binary_length           | Unary  | Binary- or String-like                  | Int32 or Int64         |                                   | \(3)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| binary_replace_slice    | Unary  | String-like                             | Binary- or String-like | :struct:`ReplaceSliceOptions`     | \(4)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| replace_substring       | Unary  | String-like                             | String-like            | :struct:`ReplaceSubstringOptions` | \(5)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| replace_substring_regex | Unary  | String-like                             | String-like            | :struct:`ReplaceSubstringOptions` | \(6)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| string_repeat           | Binary | Binary/String (Arg 0); Integral (Arg 1) | Binary- or String-like |                                   | \(7)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_capitalize         | Unary  | String-like                             | String-like            |                                   | \(9)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_length             | Unary  | String-like                             | Int32 or Int64         |                                   | \(8)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_lower              | Unary  | String-like                             | String-like            |                                   | \(9)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_replace_slice      | Unary  | String-like                             | String-like            | :struct:`ReplaceSliceOptions`     | \(5)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_reverse            | Unary  | String-like                             | String-like            |                                   | \(10) |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_swapcase           | Unary  | String-like                             | String-like            |                                   | \(9)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_title              | Unary  | String-like                             | String-like            |                                   | \(9)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
+| utf8_upper              | Unary  | String-like                             | String-like            |                                   | \(9)  |
++-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
 
 * \(1) Each ASCII character in the input is converted to lowercase or
   uppercase.  Non-ASCII characters are left untouched.
@@ -881,7 +881,7 @@ String transforms
   maximum number of replacements made, counting from the left. Note that if the
   pattern contains groups, backreferencing can be used.
 
-* \(7) Repeat the input string a given number of times.
+* \(7) Repeat the input binary sequence or string a given number of times.
 
 * \(8) Output is the number of characters (not bytes) of each input element.
   Output type is Int32 for String, Int64 for LargeString.
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index a56cc9dfce0..e9e261b9cdf 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -270,7 +270,7 @@ String Transforms
    binary_replace_slice
    replace_substring
    replace_substring_regex
-   str_repeat
+   string_repeat
    utf8_capitalize
    utf8_length
    utf8_lower

From 54e6d3745b6b810b9dc8544c750c04328e701145 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 16:02:07 -0400
Subject: [PATCH 48/84] support numeric types for repeat count and rename to
 num_repeat

---
 .../arrow/compute/kernels/scalar_string.cc    | 57 ++++++++++---------
 .../compute/kernels/scalar_string_test.cc     | 54 +++++++++++++-----
 2 files changed, 69 insertions(+), 42 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 9bad4786149..280eeedc5b4 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2862,21 +2862,22 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
-  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const int64_t nrepeats) override {
-    return std::max(input1_ncodeunits * nrepeats, (int64_t)0);
+  int64_t MaxCodeunits(const int64_t input1_ncodeunits,
+                       const int64_t num_repeats) override {
+    return std::max(input1_ncodeunits * num_repeats, (int64_t)0);
   }
 
   int64_t MaxCodeunits(const int64_t input1_ncodeunits,
                        const ArrayType2& input2) override {
-    int64_t total_nrepeats = 0;
+    int64_t total_num_repeats = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
-      total_nrepeats += input2.GetView(i);
+      total_num_repeats += input2.GetView(i);
     }
-    return std::max(input1_ncodeunits * total_nrepeats, (int64_t)0);
+    return std::max(input1_ncodeunits * total_num_repeats, (int64_t)0);
   }
 
-  int64_t MaxCodeunits(const ArrayType1& input1, const int64_t nrepeats) override {
-    return std::max(input1.total_values_length() * nrepeats, (int64_t)0);
+  int64_t MaxCodeunits(const ArrayType1& input1, const int64_t num_repeats) override {
+    return std::max(input1.total_values_length() * num_repeats, (int64_t)0);
   }
 
   int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) override {
@@ -2892,9 +2893,9 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
 
   static int64_t TransformSimple(const uint8_t* input,
                                  const int64_t input_string_ncodeunits,
-                                 const int64_t nrepeats, uint8_t* output) {
+                                 const int64_t num_repeats, uint8_t* output) {
     uint8_t* output_start = output;
-    for (int64_t i = 0; i < nrepeats; ++i) {
+    for (int64_t i = 0; i < num_repeats; ++i) {
       std::memcpy(output, input, input_string_ncodeunits);
       output += input_string_ncodeunits;
     }
@@ -2903,19 +2904,20 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
 
   static int64_t TransformDoubling(const uint8_t* input,
                                    const int64_t input_string_ncodeunits,
-                                   const int64_t nrepeats, uint8_t* output) {
+                                   const int64_t num_repeats, uint8_t* output) {
     uint8_t* output_start = output;
     // Repeated doubling of string
     std::memcpy(output, input, input_string_ncodeunits);
     output += input_string_ncodeunits;
     int64_t i = 1;
-    for (int64_t ilen = input_string_ncodeunits; i <= (nrepeats / 2); i *= 2, ilen *= 2) {
+    for (int64_t ilen = input_string_ncodeunits; i <= (num_repeats / 2);
+         i *= 2, ilen *= 2) {
       std::memcpy(output, output_start, ilen);
       output += ilen;
     }
 
     // Epilogue remainder
-    int64_t rem = (nrepeats ^ i) * input_string_ncodeunits;
+    int64_t rem = (num_repeats ^ i) * input_string_ncodeunits;
     std::memcpy(output, output_start, rem);
     output += rem;
     return output - output_start;
@@ -2923,9 +2925,9 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
 
   static int64_t TransformWrapper(const uint8_t* input,
                                   const int64_t input_string_ncodeunits,
-                                  const int64_t nrepeats, uint8_t* output) {
-    auto transform = (nrepeats < 4) ? TransformSimple : TransformDoubling;
-    return transform(input, input_string_ncodeunits, nrepeats, output);
+                                  const int64_t num_repeats, uint8_t* output) {
+    auto transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
+    return transform(input, input_string_ncodeunits, num_repeats, output);
   }
 
   // For input shape ArrayScalar, we cache the repeat implementation to use
@@ -2934,8 +2936,8 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
     if (batch[0].is_array() && batch[1].is_scalar()) {
       auto scalar = batch[1].scalar();
-      auto nrepeats = UnboxScalar<Type2>::Unbox(*scalar);
-      Transform = (nrepeats < 4) ? TransformSimple : TransformDoubling;
+      auto num_repeats = UnboxScalar<Type2>::Unbox(*scalar);
+      Transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
     } else {
       Transform = TransformWrapper;
     }
@@ -2948,7 +2950,7 @@ using StringRepeat =
     StringBinaryTransformExec<Type1, Type2, StringRepeatTransform<Type1, Type2>>;
 
 /// An ScalarFunction that promotes integer arguments to Int64.
-struct ScalarUpcastToInt64Function : public ScalarFunction {
+struct ScalarCTypeToInt64Function : public ScalarFunction {
   using ScalarFunction::ScalarFunction;
 
   Result<const Kernel*> DispatchBest(std::vector<ValueDescr>* values) const override {
@@ -2960,7 +2962,8 @@ struct ScalarUpcastToInt64Function : public ScalarFunction {
     EnsureDictionaryDecoded(values);
 
     for (auto& descr : *values) {
-      if (is_integer(descr.type->id())) {
+      if (is_integer(descr.type->id()) || is_floating(descr.type->id()) ||
+          descr.type->id() == Type::BOOL) {
         descr.type = int64();
       }
     }
@@ -2970,9 +2973,13 @@ struct ScalarUpcastToInt64Function : public ScalarFunction {
   }
 };
 
-void AddStringRepeat(std::string name, FunctionRegistry* registry,
-                     const FunctionDoc* doc) {
-  auto func = std::make_shared<ScalarUpcastToInt64Function>(name, Arity::Binary(), doc);
+const FunctionDoc string_repeat_doc(
+    "Repeat a string", ("For each string in `strings`, return a replicated version."),
+    {"strings", "repeats"});
+
+void AddStringRepeat(FunctionRegistry* registry) {
+  auto func = std::make_shared<ScalarCTypeToInt64Function>(
+      "string_repeat", Arity::Binary(), &string_repeat_doc);
   for (const auto& ty : BaseBinaryTypes()) {
     auto exec = GenerateVarBinaryToVarBinary<StringRepeat, Int64Type>(ty);
     ScalarKernel kernel{{ty, int64()}, ty, exec};
@@ -4898,10 +4905,6 @@ const FunctionDoc utf8_reverse_doc(
      "clusters. Hence, it will not correctly reverse grapheme clusters\n"
      "composed of multiple codepoints."),
     {"strings"});
-
-const FunctionDoc string_repeat_doc(
-    "Repeat a string", ("For each string in `strings`, return a replicated version."),
-    {"strings", "repeats"});
 }  // namespace
 
 void RegisterScalarStringAscii(FunctionRegistry* registry) {
@@ -5004,7 +5007,7 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   AddSplit(registry);
   AddStrptime(registry);
   AddBinaryJoin(registry);
-  AddStringRepeat("string_repeat", registry, &string_repeat_doc);
+  AddStringRepeat(registry);
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index ffe1c8d6623..5ffd12f6f03 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1045,53 +1045,77 @@ TYPED_TEST(TestStringKernels, StringRepeat) {
          R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbbb", "ɑɽⱤoWɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
     }};
 
-    for (const auto& pair : repeats_and_expected) {
-      auto repeat = pair.first;
+    for (const auto& pair : nrepeats_and_expected) {
+      auto num_repeat = pair.first;
       auto expected = pair.second;
-      for (const auto& ty : IntTypes()) {
+      for (const auto& ty : NumericTypes()) {
         this->CheckVarArgs("string_repeat",
-                           {values, Datum(*arrow::MakeScalar(ty, repeat))}, this->type(),
-                           expected);
+                           {values, Datum(*arrow::MakeScalar(ty, num_repeat))},
+                           this->type(), expected);
       }
     }
   }
   {
     // Negative repeat count
-    std::vector<std::pair<int, std::string>> repeats_and_expected{{
+    std::vector<std::pair<int, std::string>> nrepeats_and_expected{{
         {-1, R"(["", null, "", "", "", "", "", "", "", ""])"},
         {-4, R"(["", null, "", "", "", "", "", "", "", ""])"},
     }};
 
-    for (const auto& pair : repeats_and_expected) {
-      auto repeat = pair.first;
+    for (const auto& pair : nrepeats_and_expected) {
+      auto num_repeat = pair.first;
       auto expected = pair.second;
       for (const auto& ty : SignedIntTypes()) {
         this->CheckVarArgs("string_repeat",
-                           {values, Datum(*arrow::MakeScalar(ty, repeat))}, this->type(),
-                           expected);
+                           {values, Datum(*arrow::MakeScalar(ty, num_repeat))},
+                           this->type(), expected);
       }
     }
   }
+  // {
+  //   // Truncated floating point repeat count
+  //   std::vector<std::pair<double, std::string>> nrepeats_and_expected{{
+  //       {0.9, R"(["", null, "", "", "", "", "", "", "", ""])"},
+  //       {1.8,
+  //        R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$.
+  //        A3", "!ɑⱤⱤow"])"},
+  //       {4.4,
+  //        R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbbb",
+  //        "ɑɽⱤoWɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO,
+  //        WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3$. A3",
+  //        "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
+  //   }};
+  //
+  //   for (const auto& pair : nrepeats_and_expected) {
+  //     auto num_repeat = pair.first;
+  //     auto expected = pair.second;
+  //     for (const auto& ty : FloatingPointTypes()) {
+  //       this->CheckVarArgs("string_repeat",
+  //                          {values, Datum(*arrow::MakeScalar(ty, num_repeat))},
+  //                          this->type(), expected);
+  //     }
+  //   }
+  // }
 }
 
 TYPED_TEST(TestStringKernels, StringRepeats) {
-  for (const auto& ty : IntTypes()) {
-    auto repeats = ArrayFromJSON(ty, R"([100, 1, 2, 5, 2, 0, 1, 3, 2, 3])");
+  for (const auto& ty : NumericTypes()) {
+    auto num_repeats = ArrayFromJSON(ty, R"([100, 1, 2, 5, 2, 0, 1, 3, 2, 3])");
     auto values = ArrayFromJSON(
         this->type(),
         R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
     std::string expected =
         R"([null, "aAazZæÆ&", "", "bbbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
-    this->CheckVarArgs("string_repeat", {values, repeats}, this->type(), expected);
+    this->CheckVarArgs("string_repeat", {values, num_repeats}, this->type(), expected);
   }
 
   for (const auto& ty : SignedIntTypes()) {
-    auto repeats = ArrayFromJSON(ty, R"([-100, -1, -2, -5, -2, -1, -3, -2, -3])");
+    auto num_repeats = ArrayFromJSON(ty, R"([-100, -1, -2, -5, -2, -1, -3, -2, -3])");
     auto values = ArrayFromJSON(
         this->type(),
         R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
     std::string expected = R"([null, "", "", "", "", "", "", "", ""])";
-    this->CheckVarArgs("string_repeat", {values, repeats}, this->type(), expected);
+    this->CheckVarArgs("string_repeat", {values, num_repeats}, this->type(), expected);
   }
 }
 

From 871a7f6bb10f523eced59dbefd05a42a4fee0f67 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 16:06:00 -0400
Subject: [PATCH 49/84] add R binding and tests

---
 r/R/dplyr-functions.R                      |  7 +++++++
 r/R/expression.R                           |  1 +
 r/tests/testthat/test-dplyr-funcs-string.R | 18 ++++++++++++++++++
 3 files changed, 26 insertions(+)

diff --git a/r/R/dplyr-functions.R b/r/R/dplyr-functions.R
index 717cdae9662..93483381f05 100644
--- a/r/R/dplyr-functions.R
+++ b/r/R/dplyr-functions.R
@@ -334,6 +334,13 @@ arrow_string_join_function <- function(null_handling, null_replacement = NULL) {
   }
 }
 
+nse_funcs$strrep <- function(string, times) {
+  if (times < 0) {
+    stop("`times` must be a non-negative integer", call. = FALSE)
+  }
+  Expression$create("string_repeat", string, times)
+}
+
 # Currently, Arrow does not supports a locale option for string case conversion
 # functions, contrast to stringr's API, so the 'locale' argument is only valid
 # for stringr's default value ("en"). The following are string functions that
diff --git a/r/R/expression.R b/r/R/expression.R
index b1b6635f538..b714e7d533c 100644
--- a/r/R/expression.R
+++ b/r/R/expression.R
@@ -101,6 +101,7 @@
   "%%" = "divide_checked",
   "^" = "power_checked",
   "%in%" = "is_in_meta_binary"
+  # strrep is defined in dplyr-functions.R
 )
 
 .array_function_map <- c(.unary_function_map, .binary_function_map)
diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 5e092f4e335..4d605ec08d1 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -467,6 +467,24 @@ test_that("strsplit and str_split", {
   )
 })
 
+test_that("strrep", {
+  df <- tibble(x = c("foo1", "B a R\n", "!apACHe aRroW!"))
+  for (times in 0:8) {
+    expect_dplyr_equal(
+      input %>%
+        transmute(x = strrep(x, times)) %>%
+        collect(),
+      df
+    )
+  }
+
+  expect_error(
+    nse_funcs$strrep("Apache Arrow", -1),
+    "`times` must be a non-negative integer",
+    fixed = TRUE
+  )
+})
+
 test_that("str_to_lower, str_to_upper, and str_to_title", {
   df <- tibble(x = c("foo1", " \tB a R\n", "!apACHe aRroW!"))
   compare_dplyr_binding(

From 9ce73196de60c4de819a80f4d0295ed5525b25d4 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 16:06:47 -0400
Subject: [PATCH 50/84] delete old FunctionOptions from R binding

---
 r/src/compute.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 433d0597fa1..0f0ef2f7dd1 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -373,11 +373,6 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
                                      first_week_is_fully_in_year);
   }
 
-  if (func_name == "str_repeat") {
-    using Options = arrow::compute::RepeatOptions;
-    return std::make_shared<Options>(cpp11::as_cpp<std::vector<int>>(options["repeats"]));
-  }
-
   if (func_name == "strptime") {
     using Options = arrow::compute::StrptimeOptions;
     return std::make_shared<Options>(

From 38cc27e202533c2870c9bbd9524af5184ca3a27d Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 16:19:28 -0400
Subject: [PATCH 51/84] delete pyarrow test

---
 python/pyarrow/tests/test_compute.py | 25 -------------------------
 1 file changed, 25 deletions(-)

diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index d1d25a39355..be2da31b9d1 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -2236,28 +2236,3 @@ def test_count_distinct_options():
     assert pc.count_distinct(arr, mode='only_valid').as_py() == 3
     assert pc.count_distinct(arr, mode='only_null').as_py() == 1
     assert pc.count_distinct(arr, mode='all').as_py() == 4
-
-
-def test_string_repeat():
-    # Test with single value for number of repeats
-    values = ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"]
-    repeat_and_expected = [
-        [0, ["", None, "", "", "", "", ""]],
-        [1, ["æÆ&", None, "", "b", "ɑɽⱤoW", "ıI", "$. 3"]],
-        [2, ["æÆ&æÆ&", None, "", "bb", "ɑɽⱤoWɑɽⱤoW", "ıIıI", "$. 3$. 3"]],
-    ]
-    for repeat, expected in repeat_and_expected:
-        result = pc.string_repeat(values, repeat)
-        assert result.equals(pa.array(expected))
-
-    # Test with multiple values for number of repeats
-    values = ["a", "b"]
-    repeat_and_expected = [
-        [[5, 2], ["aaaaa", "bb"]],
-        [[0, 2], ["", "bb"]],
-        [3, ["aaa", "bbb"]],
-        [[0, 0], ["", ""]],
-    ]
-    for repeat, expected in repeat_and_expected:
-        result = pc.string_repeat(values, repeat)
-        assert result.equals(pa.array(expected))

From 609f0556f3ca32bd15bf5802c16cf05df80866a7 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 16:52:08 -0400
Subject: [PATCH 52/84] remove comment on generic lambdas in C++14

---
 .../arrow/compute/kernels/scalar_string.cc    | 21 -------------------
 1 file changed, 21 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 280eeedc5b4..95c413b9b6a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -753,27 +753,6 @@ struct StringBinaryTransformExecBase {
     output_offsets[0] = 0;
     offset_type output_ncodeunits = 0;
 
-    // XXX C++11 does not supports generic lambdas, so we cannot iterate
-    // through the unknown-typed Array in a generic way. C++14 provides support
-    // for generic lambdas.
-    // ARROW_RETURN_NOT_OK(VisitArrayDataInline<Type1>(
-    //     *data2,
-    //     [&](auto value2) {
-    //       auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
-    //           input_string, input_ncodeunits, value2, output_string +
-    //           output_ncodeunits));
-    //       if (encoded_nbytes < 0) {
-    //         return transform->InvalidStatus();
-    //       }
-    //       output_ncodeunits += encoded_nbytes;
-    //       *(++output_offsets) = output_ncodeunits;
-    //       return Status::OK();
-    //     },
-    //     [&]() {
-    //       *(++output_offsets) = output_ncodeunits;
-    //       return Status::OK();
-    //     }));
-
     // Apply transform
     ARROW_RETURN_NOT_OK(arrow::internal::VisitBitBlocks(
         data2->buffers[0], data2->offset, data2->length,

From d0c61300e352331ffc6eff3a8b86db2c4293ce58 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 16:52:27 -0400
Subject: [PATCH 53/84] add boolean test

---
 .../compute/kernels/scalar_string_test.cc     | 23 ++++++++++++-------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 5ffd12f6f03..8efc2861f6e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -55,14 +55,6 @@ class BaseTestStringKernels : public ::testing::Test {
     CheckScalarUnary(func_name, type(), json_input, out_ty, json_expected, options);
   }
 
-  void CheckBinaryScalar(std::string func_name, std::string json_left_input,
-                         std::string json_right_scalar, std::shared_ptr<DataType> out_ty,
-                         std::string json_expected,
-                         const FunctionOptions* options = nullptr) {
-    CheckScalarBinaryScalar(func_name, type(), json_left_input, json_right_scalar, out_ty,
-                            json_expected, options);
-  }
-
   void CheckVarArgsScalar(std::string func_name, std::string json_input,
                           std::shared_ptr<DataType> out_ty, std::string json_expected,
                           const FunctionOptions* options = nullptr) {
@@ -1096,6 +1088,21 @@ TYPED_TEST(TestStringKernels, StringRepeat) {
   //     }
   //   }
   // }
+  {
+    std::vector<std::pair<bool, std::string>> nrepeats_and_expected{{
+        {false, R"(["", null, "", "", "", "", "", "", "", ""])"},
+        {true,
+         R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
+    }};
+
+    for (const auto& pair : nrepeats_and_expected) {
+      auto num_repeat = pair.first;
+      auto expected = pair.second;
+      this->CheckVarArgs("string_repeat",
+                         {values, Datum(*arrow::MakeScalar(boolean(), num_repeat))},
+                         this->type(), expected);
+    }
+  }
 }
 
 TYPED_TEST(TestStringKernels, StringRepeats) {

From 092a335f63f6b9d003d3eb7463a247fcb3bc30da Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 21:32:27 -0400
Subject: [PATCH 54/84] remove implicit casting for repeat count and add
 validation check for Scalar

---
 .../arrow/compute/kernels/scalar_string.cc    |  69 ++++++-----
 .../compute/kernels/scalar_string_test.cc     | 111 +++++-------------
 2 files changed, 65 insertions(+), 115 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 95c413b9b6a..1b512ccfe56 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2836,6 +2836,29 @@ void AddSplit(FunctionRegistry* registry) {
 #endif
 }
 
+/// An ScalarFunction that promotes integer arguments to Int64.
+struct ScalarCTypeToInt64Function : public ScalarFunction {
+  using ScalarFunction::ScalarFunction;
+
+  Result<const Kernel*> DispatchBest(std::vector<ValueDescr>* values) const override {
+    RETURN_NOT_OK(CheckArity(*values));
+
+    using arrow::compute::detail::DispatchExactImpl;
+    if (auto kernel = DispatchExactImpl(this, *values)) return kernel;
+
+    EnsureDictionaryDecoded(values);
+
+    for (auto& descr : *values) {
+      if (is_integer(descr.type->id())) {
+        descr.type = int64();
+      }
+    }
+
+    if (auto kernel = DispatchExactImpl(this, *values)) return kernel;
+    return arrow::compute::detail::NoMatchingKernel(this, *values);
+  }
+};
+
 template <typename Type1, typename Type2>
 struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
@@ -2843,7 +2866,7 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
 
   int64_t MaxCodeunits(const int64_t input1_ncodeunits,
                        const int64_t num_repeats) override {
-    return std::max(input1_ncodeunits * num_repeats, (int64_t)0);
+    return input1_ncodeunits * num_repeats;
   }
 
   int64_t MaxCodeunits(const int64_t input1_ncodeunits,
@@ -2852,11 +2875,11 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     for (int64_t i = 0; i < input2.length(); ++i) {
       total_num_repeats += input2.GetView(i);
     }
-    return std::max(input1_ncodeunits * total_num_repeats, (int64_t)0);
+    return input1_ncodeunits * total_num_repeats;
   }
 
   int64_t MaxCodeunits(const ArrayType1& input1, const int64_t num_repeats) override {
-    return std::max(input1.total_values_length() * num_repeats, (int64_t)0);
+    return input1.total_values_length() * num_repeats;
   }
 
   int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) override {
@@ -2864,7 +2887,7 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     for (int64_t i = 0; i < input2.length(); ++i) {
       total_codeunits += input1.GetView(i).length() * input2.GetView(i);
     }
-    return std::max(total_codeunits, (int64_t)0);
+    return total_codeunits;
   }
 
   std::function<int64_t(const uint8_t*, const int64_t, const int64_t, uint8_t*)>
@@ -2909,13 +2932,19 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return transform(input, input_string_ncodeunits, num_repeats, output);
   }
 
-  // For input shape ArrayScalar, we cache the repeat implementation to use
-  // based on repeat count. Otherwise, use TransformWrapper which checks repeat
-  // count for each pair of processing values.
   Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
-    if (batch[0].is_array() && batch[1].is_scalar()) {
+    // For cases with a scalar repeat count, select the best implementation once
+    // before execution. Otherwise, use TransformWrapper to select implementation
+    // when processing each value.
+    if (batch[1].is_scalar()) {
       auto scalar = batch[1].scalar();
       auto num_repeats = UnboxScalar<Type2>::Unbox(*scalar);
+      // Validate repeat count. For array shape, repeat count is not explicitly
+      // validated as an optimization. The output buffer allocation should fail
+      // via MaxCodeunits.
+      if (num_repeats < 0) {
+        return Status::Invalid("Repeat count must be a non-negative integer");
+      }
       Transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
     } else {
       Transform = TransformWrapper;
@@ -2928,30 +2957,6 @@ template <typename Type1, typename Type2>
 using StringRepeat =
     StringBinaryTransformExec<Type1, Type2, StringRepeatTransform<Type1, Type2>>;
 
-/// An ScalarFunction that promotes integer arguments to Int64.
-struct ScalarCTypeToInt64Function : public ScalarFunction {
-  using ScalarFunction::ScalarFunction;
-
-  Result<const Kernel*> DispatchBest(std::vector<ValueDescr>* values) const override {
-    RETURN_NOT_OK(CheckArity(*values));
-
-    using arrow::compute::detail::DispatchExactImpl;
-    if (auto kernel = DispatchExactImpl(this, *values)) return kernel;
-
-    EnsureDictionaryDecoded(values);
-
-    for (auto& descr : *values) {
-      if (is_integer(descr.type->id()) || is_floating(descr.type->id()) ||
-          descr.type->id() == Type::BOOL) {
-        descr.type = int64();
-      }
-    }
-
-    if (auto kernel = DispatchExactImpl(this, *values)) return kernel;
-    return arrow::compute::detail::NoMatchingKernel(this, *values);
-  }
-};
-
 const FunctionDoc string_repeat_doc(
     "Repeat a string", ("For each string in `strings`, return a replicated version."),
     {"strings", "repeats"});
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 8efc2861f6e..13d846adeec 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1028,102 +1028,47 @@ TYPED_TEST(TestStringKernels, StringRepeat) {
   auto values = ArrayFromJSON(
       this->type(),
       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
-  {
-    std::vector<std::pair<int64_t, std::string>> repeats_and_expected{{
-        {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
-        {1,
-         R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
-        {4,
-         R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbbb", "ɑɽⱤoWɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
-    }};
-
-    for (const auto& pair : nrepeats_and_expected) {
-      auto num_repeat = pair.first;
-      auto expected = pair.second;
-      for (const auto& ty : NumericTypes()) {
-        this->CheckVarArgs("string_repeat",
-                           {values, Datum(*arrow::MakeScalar(ty, num_repeat))},
-                           this->type(), expected);
-      }
-    }
-  }
-  {
-    // Negative repeat count
-    std::vector<std::pair<int, std::string>> nrepeats_and_expected{{
-        {-1, R"(["", null, "", "", "", "", "", "", "", ""])"},
-        {-4, R"(["", null, "", "", "", "", "", "", "", ""])"},
-    }};
-
-    for (const auto& pair : nrepeats_and_expected) {
-      auto num_repeat = pair.first;
-      auto expected = pair.second;
-      for (const auto& ty : SignedIntTypes()) {
-        this->CheckVarArgs("string_repeat",
-                           {values, Datum(*arrow::MakeScalar(ty, num_repeat))},
-                           this->type(), expected);
-      }
-    }
-  }
-  // {
-  //   // Truncated floating point repeat count
-  //   std::vector<std::pair<double, std::string>> nrepeats_and_expected{{
-  //       {0.9, R"(["", null, "", "", "", "", "", "", "", ""])"},
-  //       {1.8,
-  //        R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$.
-  //        A3", "!ɑⱤⱤow"])"},
-  //       {4.4,
-  //        R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbbb",
-  //        "ɑɽⱤoWɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO,
-  //        WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3$. A3",
-  //        "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
-  //   }};
-  //
-  //   for (const auto& pair : nrepeats_and_expected) {
-  //     auto num_repeat = pair.first;
-  //     auto expected = pair.second;
-  //     for (const auto& ty : FloatingPointTypes()) {
-  //       this->CheckVarArgs("string_repeat",
-  //                          {values, Datum(*arrow::MakeScalar(ty, num_repeat))},
-  //                          this->type(), expected);
-  //     }
-  //   }
-  // }
-  {
-    std::vector<std::pair<bool, std::string>> nrepeats_and_expected{{
-        {false, R"(["", null, "", "", "", "", "", "", "", ""])"},
-        {true,
-         R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
-    }};
-
-    for (const auto& pair : nrepeats_and_expected) {
-      auto num_repeat = pair.first;
-      auto expected = pair.second;
+  std::vector<std::pair<int, std::string>> nrepeats_and_expected{{
+      {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
+      {1,
+       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
+      {4,
+       R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbbb", "ɑɽⱤoWɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
+  }};
+
+  for (const auto& pair : nrepeats_and_expected) {
+    auto num_repeat = pair.first;
+    auto expected = pair.second;
+    for (const auto& ty : IntTypes()) {
       this->CheckVarArgs("string_repeat",
-                         {values, Datum(*arrow::MakeScalar(boolean(), num_repeat))},
+                         {values, Datum(*arrow::MakeScalar(ty, num_repeat))},
                          this->type(), expected);
     }
   }
+
+  // Negative repeat count
+  auto num_repeat = *arrow::MakeScalar(int64(), -1);
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, ::testing::HasSubstr("Repeat count must be a non-negative integer"),
+      CallFunction("string_repeat", {values, num_repeat}));
 }
 
 TYPED_TEST(TestStringKernels, StringRepeats) {
-  for (const auto& ty : NumericTypes()) {
+  auto values = ArrayFromJSON(
+      this->type(),
+      R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+  for (const auto& ty : IntTypes()) {
     auto num_repeats = ArrayFromJSON(ty, R"([100, 1, 2, 5, 2, 0, 1, 3, 2, 3])");
-    auto values = ArrayFromJSON(
-        this->type(),
-        R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
     std::string expected =
         R"([null, "aAazZæÆ&", "", "bbbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
     this->CheckVarArgs("string_repeat", {values, num_repeats}, this->type(), expected);
   }
 
-  for (const auto& ty : SignedIntTypes()) {
-    auto num_repeats = ArrayFromJSON(ty, R"([-100, -1, -2, -5, -2, -1, -3, -2, -3])");
-    auto values = ArrayFromJSON(
-        this->type(),
-        R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
-    std::string expected = R"([null, "", "", "", "", "", "", "", ""])";
-    this->CheckVarArgs("string_repeat", {values, num_repeats}, this->type(), expected);
-  }
+  // Negative repeat count
+  auto num_repeats = ArrayFromJSON(int64(), R"([100, -1, 2, -5, 2, -1, 3, -2, 3, -100])");
+  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid,
+                                  ::testing::HasSubstr("Invalid: Negative buffer resize"),
+                                  CallFunction("string_repeat", {values, num_repeats}));
 }
 
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {

From 34c366ef742a7af5343349fb80247e1ea0638c24 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 19 Oct 2021 21:53:15 -0400
Subject: [PATCH 55/84] update R binding, remove validation

---
 cpp/src/arrow/compute/kernels/scalar_string_test.cc | 13 +++++++++++++
 r/R/dplyr-functions.R                               |  7 -------
 r/R/expression.R                                    |  4 ++--
 r/tests/testthat/test-dplyr-funcs-string.R          |  6 +++---
 4 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 13d846adeec..e2ec30839d2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -55,6 +55,19 @@ class BaseTestStringKernels : public ::testing::Test {
     CheckScalarUnary(func_name, type(), json_input, out_ty, json_expected, options);
   }
 
+  void CheckUnary(std::string func_name, const std::shared_ptr<Array>& input,
+                  std::shared_ptr<DataType> out_ty, std::string json_expected,
+                  const FunctionOptions* options = nullptr) {
+    CheckScalar(func_name, {Datum(input)}, Datum(ArrayFromJSON(out_ty, json_expected)),
+                options);
+  }
+
+  void CheckUnary(std::string func_name, const std::shared_ptr<Array>& input,
+                  const std::shared_ptr<Array>& expected,
+                  const FunctionOptions* options = nullptr) {
+    CheckScalar(func_name, {Datum(input)}, Datum(expected), options);
+  }
+
   void CheckVarArgsScalar(std::string func_name, std::string json_input,
                           std::shared_ptr<DataType> out_ty, std::string json_expected,
                           const FunctionOptions* options = nullptr) {
diff --git a/r/R/dplyr-functions.R b/r/R/dplyr-functions.R
index 93483381f05..717cdae9662 100644
--- a/r/R/dplyr-functions.R
+++ b/r/R/dplyr-functions.R
@@ -334,13 +334,6 @@ arrow_string_join_function <- function(null_handling, null_replacement = NULL) {
   }
 }
 
-nse_funcs$strrep <- function(string, times) {
-  if (times < 0) {
-    stop("`times` must be a non-negative integer", call. = FALSE)
-  }
-  Expression$create("string_repeat", string, times)
-}
-
 # Currently, Arrow does not supports a locale option for string case conversion
 # functions, contrast to stringr's API, so the 'locale' argument is only valid
 # for stringr's default value ("en"). The following are string functions that
diff --git a/r/R/expression.R b/r/R/expression.R
index b714e7d533c..5eb3d182da8 100644
--- a/r/R/expression.R
+++ b/r/R/expression.R
@@ -100,8 +100,8 @@
   # use `%/%` above.
   "%%" = "divide_checked",
   "^" = "power_checked",
-  "%in%" = "is_in_meta_binary"
-  # strrep is defined in dplyr-functions.R
+  "%in%" = "is_in_meta_binary",
+  "strrep" = "string_repeat"
 )
 
 .array_function_map <- c(.unary_function_map, .binary_function_map)
diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 4d605ec08d1..e0ee758c872 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -469,7 +469,7 @@ test_that("strsplit and str_split", {
 
 test_that("strrep", {
   df <- tibble(x = c("foo1", "B a R\n", "!apACHe aRroW!"))
-  for (times in 0:8) {
+  for (times in 0:8L) {
     expect_dplyr_equal(
       input %>%
         transmute(x = strrep(x, times)) %>%
@@ -479,8 +479,8 @@ test_that("strrep", {
   }
 
   expect_error(
-    nse_funcs$strrep("Apache Arrow", -1),
-    "`times` must be a non-negative integer",
+    nse_funcs$strrep("Apache Arrow", -1L),
+    "Repeat count must be a non-negative integer",
     fixed = TRUE
   )
 })

From 0da3c47f970a3f8f20714d688690e88153e8643c Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 26 Oct 2021 18:30:22 -0400
Subject: [PATCH 56/84] rebase and add more invalid tests (negative and float
 repeat count)

---
 .../compute/kernels/scalar_string_test.cc     | 24 +++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index e2ec30839d2..9ca4c51bf74 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1060,10 +1060,20 @@ TYPED_TEST(TestStringKernels, StringRepeat) {
   }
 
   // Negative repeat count
-  auto num_repeat = *arrow::MakeScalar(int64(), -1);
-  EXPECT_RAISES_WITH_MESSAGE_THAT(
-      Invalid, ::testing::HasSubstr("Repeat count must be a non-negative integer"),
-      CallFunction("string_repeat", {values, num_repeat}));
+  for (auto num_repeat_ : {-1, -2, -5}) {
+    auto num_repeat = *arrow::MakeScalar(int64(), num_repeat_);
+    EXPECT_RAISES_WITH_MESSAGE_THAT(
+        Invalid, ::testing::HasSubstr("Repeat count must be a non-negative integer"),
+        CallFunction("string_repeat", {values, num_repeat}));
+  }
+
+  // Floating-point repeat count
+  for (auto num_repeat_ : {0.0, 1.2, -1.3}) {
+    auto num_repeat = *arrow::MakeScalar(float64(), num_repeat_);
+    EXPECT_RAISES_WITH_MESSAGE_THAT(
+        NotImplemented, ::testing::HasSubstr("has no kernel matching input types"),
+        CallFunction("string_repeat", {values, num_repeat}));
+  }
 }
 
 TYPED_TEST(TestStringKernels, StringRepeats) {
@@ -1082,6 +1092,12 @@ TYPED_TEST(TestStringKernels, StringRepeats) {
   EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid,
                                   ::testing::HasSubstr("Invalid: Negative buffer resize"),
                                   CallFunction("string_repeat", {values, num_repeats}));
+
+  // Floating-point repeat count
+  num_repeats = ArrayFromJSON(float64(), R"([0.0, 1.2, -1.3])");
+  EXPECT_RAISES_WITH_MESSAGE_THAT(NotImplemented,
+                                  ::testing::HasSubstr("has no kernel matching input types"),
+                                  CallFunction("string_repeat", {values, num_repeats}));
 }
 
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {

From e95fcfd8987dbbc8d6701e144950a070982212c0 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 27 Oct 2021 12:06:56 -0400
Subject: [PATCH 57/84] fix lint errors

---
 cpp/src/arrow/compute/kernels/scalar_string_test.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 9ca4c51bf74..1d4f13eb14f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1095,9 +1095,9 @@ TYPED_TEST(TestStringKernels, StringRepeats) {
 
   // Floating-point repeat count
   num_repeats = ArrayFromJSON(float64(), R"([0.0, 1.2, -1.3])");
-  EXPECT_RAISES_WITH_MESSAGE_THAT(NotImplemented,
-                                  ::testing::HasSubstr("has no kernel matching input types"),
-                                  CallFunction("string_repeat", {values, num_repeats}));
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      NotImplemented, ::testing::HasSubstr("has no kernel matching input types"),
+      CallFunction("string_repeat", {values, num_repeats}));
 }
 
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {

From f5d18c5f2633350364890cfcf970e1a2763e36bb Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 27 Oct 2021 12:08:47 -0400
Subject: [PATCH 58/84] remove invalid redundant strrep test from R

---
 r/tests/testthat/test-dplyr-funcs-string.R | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index e0ee758c872..c7b56284de0 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -477,12 +477,6 @@ test_that("strrep", {
       df
     )
   }
-
-  expect_error(
-    nse_funcs$strrep("Apache Arrow", -1L),
-    "Repeat count must be a non-negative integer",
-    fixed = TRUE
-  )
 })
 
 test_that("str_to_lower, str_to_upper, and str_to_title", {

From a2b1c1570658020db4ddc4870747ba2c173a2ab9 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 27 Oct 2021 18:25:09 -0400
Subject: [PATCH 59/84] update comments and fix RETURN_NOT_OK

---
 .../arrow/compute/kernels/scalar_string.cc    | 32 ++++++++-----------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 1b512ccfe56..c42b80a2f7f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -347,10 +347,6 @@ struct StringTransformExecBase {
 
   static Status Execute(KernelContext* ctx, StringTransform* transform,
                         const ExecBatch& batch, Datum* out) {
-    if (batch.num_values() != 1) {
-      return Status::Invalid("Invalid arity for unary string transform");
-    }
-
     if (batch[0].kind() == Datum::ARRAY) {
       return ExecArray(ctx, transform, batch[0].array(), out);
     } else if (batch[0].kind() == Datum::SCALAR) {
@@ -546,12 +542,12 @@ struct StringBinaryTransformBase {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
-  // Not all combinations of input shapes are meaningful to string binary transforms, so
-  // these flags serve as toggles for enabling/disabling the corresponding ones. These
-  // flags should be set in the PreExec() method.
+  // Not all combinations of input shapes are meaningful to string binary
+  // transforms, so these flags serve as control toggles for enabling/disabling
+  // the corresponding ones. These flags should be set in the PreExec() method.
   //
-  // This is an example of a StringTransform that disables argument shapes with mixed
-  // scalar/array.
+  // This is an example of a StringTransform that disables argument shapes with
+  // mixed scalar/array.
   //
   // template <typename Type1, typename Type2>
   // struct MyStringTransform : public StringBinaryTransformBase<Type1, Type2> {
@@ -578,20 +574,24 @@ struct StringBinaryTransformBase {
   }
 
   // Return the maximum total size of the output in codeunits (i.e. bytes)
-  // given input characteristics for Scalar-Scalar, Scalar-Array, Array-Scalar, and
-  // Array-Array inputs.
+  // given input characteristics for different input shapes.
+  //
+  // Scalar-Scalar
   virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ViewType2) {
     return input1_ncodeunits;
   }
 
+  // Scalar-Array
   virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2&) {
     return input1_ncodeunits;
   }
 
+  // Array-Scalar
   virtual int64_t MaxCodeunits(const ArrayType1& input1, const ViewType2) {
     return input1.total_values_length();
   }
 
+  // Array-Array
   virtual int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2&) {
     return input1.total_values_length();
   }
@@ -613,10 +613,6 @@ struct StringBinaryTransformExecBase {
 
   static Status Execute(KernelContext* ctx, StringTransform* transform,
                         const ExecBatch& batch, Datum* out) {
-    if (batch.num_values() != 2) {
-      return Status::Invalid("Invalid arity for binary string transform");
-    }
-
     if (batch[0].is_scalar()) {
       if (batch[1].is_scalar()) {
         if (transform->EnableScalarScalar) {
@@ -703,7 +699,7 @@ struct StringBinaryTransformExecBase {
     offset_type output_ncodeunits = 0;
 
     // Apply transform
-    ARROW_RETURN_NOT_OK(VisitArrayDataInline<Type1>(
+    RETURN_NOT_OK(VisitArrayDataInline<Type1>(
         *data1,
         [&](util::string_view input_string_view) {
           auto input_ncodeunits = static_cast<offset_type>(input_string_view.length());
@@ -754,7 +750,7 @@ struct StringBinaryTransformExecBase {
     offset_type output_ncodeunits = 0;
 
     // Apply transform
-    ARROW_RETURN_NOT_OK(arrow::internal::VisitBitBlocks(
+    RETURN_NOT_OK(arrow::internal::VisitBitBlocks(
         data2->buffers[0], data2->offset, data2->length,
         [&](int64_t i) {
           auto value2 = array2.GetView(i);
@@ -799,7 +795,7 @@ struct StringBinaryTransformExecBase {
     offset_type output_ncodeunits = 0;
 
     // Apply transform
-    ARROW_RETURN_NOT_OK(arrow::internal::VisitTwoBitBlocks(
+    RETURN_NOT_OK(arrow::internal::VisitTwoBitBlocks(
         data1->buffers[0], data1->offset, data2->buffers[0], data2->offset, data1->length,
         [&](int64_t i) {
           auto input_string_view = array1.GetView(i);

From a994c2199f7a1aa556bd309faaf10d973ecade6a Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 27 Oct 2021 18:57:30 -0400
Subject: [PATCH 60/84] add Status data member to StringTransformBase and
 checks for invalid repeat count

---
 .../arrow/compute/kernels/scalar_string.cc    | 76 ++++++++++++-------
 .../compute/kernels/scalar_string_test.cc     |  6 +-
 2 files changed, 53 insertions(+), 29 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index c42b80a2f7f..a55e1b4173a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -542,27 +542,6 @@ struct StringBinaryTransformBase {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
-  // Not all combinations of input shapes are meaningful to string binary
-  // transforms, so these flags serve as control toggles for enabling/disabling
-  // the corresponding ones. These flags should be set in the PreExec() method.
-  //
-  // This is an example of a StringTransform that disables argument shapes with
-  // mixed scalar/array.
-  //
-  // template <typename Type1, typename Type2>
-  // struct MyStringTransform : public StringBinaryTransformBase<Type1, Type2> {
-  //   Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) override {
-  //     EnableScalarArray = false;
-  //     EnableArrayScalar = false;
-  //     return StringBinaryTransformBase::PreExec(ctx, batch, out);
-  //   }
-  //   ...
-  // };
-  bool EnableScalarScalar = true;
-  bool EnableScalarArray = true;
-  bool EnableArrayScalar = true;
-  bool EnableArrayArray = true;
-
   virtual ~StringBinaryTransformBase() = default;
 
   virtual Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
@@ -595,6 +574,34 @@ struct StringBinaryTransformBase {
   virtual int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2&) {
     return input1.total_values_length();
   }
+
+  // Not all combinations of input shapes are meaningful to string binary
+  // transforms, so these flags serve as control toggles for enabling/disabling
+  // the corresponding ones. These flags should be set in the PreExec() method.
+  //
+  // This is an example of a StringTransform that disables argument shapes with
+  // mixed scalar/array.
+  //
+  // template <typename Type1, typename Type2>
+  // struct MyStringTransform : public StringBinaryTransformBase<Type1, Type2> {
+  //   Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) override {
+  //     EnableScalarArray = false;
+  //     EnableArrayScalar = false;
+  //     return StringBinaryTransformBase::PreExec(ctx, batch, out);
+  //   }
+  //   ...
+  // };
+  bool EnableScalarScalar = true;
+  bool EnableScalarArray = true;
+  bool EnableArrayScalar = true;
+  bool EnableArrayArray = true;
+
+  // Tracks status of transform in StringBinaryTransformExecBase.
+  // The purpose of this transform status is to provide a means to report/detect
+  // errors in functions that do not provide a mechanism to return a Status
+  // value but can still detect errors. This status is checked automatically
+  // after MaxCodeunits() and Transform() operations.
+  Status st = Status::OK();
 };
 
 /// Kernel exec generator for binary (two parameters) string transforms.
@@ -653,6 +660,7 @@ struct StringBinaryTransformExecBase {
 
     // Calculate max number of output codeunits
     const auto max_output_ncodeunits = transform->MaxCodeunits(input_ncodeunits, value2);
+    RETURN_NOT_OK(transform->st);
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output string
@@ -665,6 +673,7 @@ struct StringBinaryTransformExecBase {
     // Apply transform
     auto encoded_nbytes = static_cast<offset_type>(
         transform->Transform(input_string, input_ncodeunits, value2, output_string));
+    RETURN_NOT_OK(transform->st);
     if (encoded_nbytes < 0) {
       return transform->InvalidStatus();
     }
@@ -685,6 +694,7 @@ struct StringBinaryTransformExecBase {
 
     // Calculate max number of output codeunits
     const auto max_output_ncodeunits = transform->MaxCodeunits(array1, value2);
+    RETURN_NOT_OK(transform->st);
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -706,6 +716,7 @@ struct StringBinaryTransformExecBase {
           auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
           auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
               input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
+          RETURN_NOT_OK(transform->st);
           if (encoded_nbytes < 0) {
             return transform->InvalidStatus();
           }
@@ -736,6 +747,7 @@ struct StringBinaryTransformExecBase {
 
     // Calculate max number of output codeunits
     const auto max_output_ncodeunits = transform->MaxCodeunits(input_ncodeunits, array2);
+    RETURN_NOT_OK(transform->st);
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -756,6 +768,7 @@ struct StringBinaryTransformExecBase {
           auto value2 = array2.GetView(i);
           auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
               input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
+          RETURN_NOT_OK(transform->st);
           if (encoded_nbytes < 0) {
             return transform->InvalidStatus();
           }
@@ -781,6 +794,7 @@ struct StringBinaryTransformExecBase {
 
     // Calculate max number of output codeunits
     const auto max_output_ncodeunits = transform->MaxCodeunits(array1, array2);
+    RETURN_NOT_OK(transform->st);
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -804,6 +818,7 @@ struct StringBinaryTransformExecBase {
           auto value2 = array2.GetView(i);
           auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
               input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
+          RETURN_NOT_OK(transform->st);
           if (encoded_nbytes < 0) {
             return transform->InvalidStatus();
           }
@@ -2869,7 +2884,12 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
                        const ArrayType2& input2) override {
     int64_t total_num_repeats = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
-      total_num_repeats += input2.GetView(i);
+      auto num_repeats = input2.GetView(i);
+      if (num_repeats < 0) {
+        this->st = Status::Invalid("Repeat count must be a non-negative integer");
+        return num_repeats;
+      }
+      total_num_repeats += num_repeats;
     }
     return input1_ncodeunits * total_num_repeats;
   }
@@ -2881,7 +2901,12 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) override {
     int64_t total_codeunits = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
-      total_codeunits += input1.GetView(i).length() * input2.GetView(i);
+      auto num_repeats = input2.GetView(i);
+      if (num_repeats < 0) {
+        this->st = Status::Invalid("Repeat count must be a non-negative integer");
+        return num_repeats;
+      }
+      total_codeunits += input1.GetView(i).length() * num_repeats;
     }
     return total_codeunits;
   }
@@ -2935,9 +2960,8 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     if (batch[1].is_scalar()) {
       auto scalar = batch[1].scalar();
       auto num_repeats = UnboxScalar<Type2>::Unbox(*scalar);
-      // Validate repeat count. For array shape, repeat count is not explicitly
-      // validated as an optimization. The output buffer allocation should fail
-      // via MaxCodeunits.
+      // Validate repeat count here to resolve error early as possible.
+      // For array shape, repeat count is validated in MaxCodeunits().
       if (num_repeats < 0) {
         return Status::Invalid("Repeat count must be a non-negative integer");
       }
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 1d4f13eb14f..f4f1f083d37 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1089,9 +1089,9 @@ TYPED_TEST(TestStringKernels, StringRepeats) {
 
   // Negative repeat count
   auto num_repeats = ArrayFromJSON(int64(), R"([100, -1, 2, -5, 2, -1, 3, -2, 3, -100])");
-  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid,
-                                  ::testing::HasSubstr("Invalid: Negative buffer resize"),
-                                  CallFunction("string_repeat", {values, num_repeats}));
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, ::testing::HasSubstr("Repeat count must be a non-negative integer"),
+      CallFunction("string_repeat", {values, num_repeats}));
 
   // Floating-point repeat count
   num_repeats = ArrayFromJSON(float64(), R"([0.0, 1.2, -1.3])");

From 156ae799348fdaa4f3427c70c2e3cc68409c233a Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Sat, 30 Oct 2021 02:41:50 -0400
Subject: [PATCH 61/84] improve comments, add Status as a parameter, and minor
 consistency changes

---
 .../arrow/compute/kernels/scalar_string.cc    | 192 +++++++++++-------
 1 file changed, 115 insertions(+), 77 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index a55e1b4173a..8b9a2851189 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -19,6 +19,7 @@
 #include <cctype>
 #include <iterator>
 #include <string>
+#include <typeinfo>
 
 #ifdef ARROW_WITH_UTF8PROC
 #include <utf8proc.h>
@@ -329,7 +330,7 @@ struct StringTransformBase {
     return input_ncodeunits;
   }
 
-  virtual Status InvalidStatus() {
+  virtual Status InvalidInputSequence() {
     return Status::Invalid("Invalid UTF8 sequence in input");
   }
 };
@@ -340,6 +341,14 @@ struct StringTransformBase {
 ///
 /// int64_t Transform(const uint8_t* input, int64_t input_string_ncodeunits,
 ///                   uint8_t* output);
+///
+/// where
+///   * `input` is the input sequence (binary or string)
+///   * `input_string_ncodeunits` is the length of input sequence in codeunits
+///   * `output` is the output sequence (binary or string)
+///
+/// and returns the number of codeunits of the `output` sequence or a negative
+/// value if an invalid input sequence is detected.
 template <typename Type, typename StringTransform>
 struct StringTransformExecBase {
   using offset_type = typename Type::offset_type;
@@ -352,7 +361,9 @@ struct StringTransformExecBase {
     } else if (batch[0].kind() == Datum::SCALAR) {
       return ExecScalar(ctx, transform, batch[0].scalar(), out);
     }
-    return Status::Invalid("Invalid ExecBatch kind for unary string transform");
+    return Status::Invalid("Invalid operand for unary string transform", " (",
+                           batch[0].ToString(),
+                           "). Only Array/Scalar kinds are supported.");
   }
 
   static Status ExecArray(KernelContext* ctx, StringTransform* transform,
@@ -360,15 +371,12 @@ struct StringTransformExecBase {
     ArrayType input(data);
     const int64_t input_ncodeunits = input.total_values_length();
     const int64_t input_nstrings = input.length();
-    const int64_t output_ncodeunits_max =
+    const int64_t max_output_ncodeunits =
         transform->MaxCodeunits(input_nstrings, input_ncodeunits);
-    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
-      return Status::CapacityError(
-          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
-    }
+    RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     ArrayData* output = out->mutable_array();
-    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(output_ncodeunits_max));
+    ARROW_ASSIGN_OR_RAISE(auto values_buffer, ctx->Allocate(max_output_ncodeunits));
     output->buffers[2] = values_buffer;
 
     // String offsets are preallocated
@@ -383,13 +391,13 @@ struct StringTransformExecBase {
         auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
             input_string, input_string_ncodeunits, output_str + output_ncodeunits));
         if (encoded_nbytes < 0) {
-          return transform->InvalidStatus();
+          return transform->InvalidInputSequence();
         }
         output_ncodeunits += encoded_nbytes;
       }
       output_string_offsets[i + 1] = output_ncodeunits;
     }
-    DCHECK_LE(output_ncodeunits, output_ncodeunits_max);
+    DCHECK_LE(output_ncodeunits, max_output_ncodeunits);
 
     // Trim the codepoint buffer, since we may have allocated too much
     return values_buffer->Resize(output_ncodeunits, /*shrink_to_fit=*/true);
@@ -402,24 +410,29 @@ struct StringTransformExecBase {
       return Status::OK();
     }
     const int64_t data_nbytes = static_cast<int64_t>(input.value->size());
-    const int64_t output_ncodeunits_max = transform->MaxCodeunits(1, data_nbytes);
-    if (output_ncodeunits_max > std::numeric_limits<offset_type>::max()) {
-      return Status::CapacityError(
-          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
-    }
+    const int64_t max_output_ncodeunits = transform->MaxCodeunits(1, data_nbytes);
+    RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
-    ARROW_ASSIGN_OR_RAISE(auto value_buffer, ctx->Allocate(output_ncodeunits_max));
+    ARROW_ASSIGN_OR_RAISE(auto value_buffer, ctx->Allocate(max_output_ncodeunits));
     auto* result = checked_cast<BaseBinaryScalar*>(out->scalar().get());
     result->is_valid = true;
     result->value = value_buffer;
     auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
         input.value->data(), data_nbytes, value_buffer->mutable_data()));
     if (encoded_nbytes < 0) {
-      return transform->InvalidStatus();
+      return transform->InvalidInputSequence();
     }
-    DCHECK_LE(encoded_nbytes, output_ncodeunits_max);
+    DCHECK_LE(encoded_nbytes, max_output_ncodeunits);
     return value_buffer->Resize(encoded_nbytes, /*shrink_to_fit=*/true);
   }
+
+  static Status CheckOutputCapacity(int64_t ncodeunits) {
+    if (ncodeunits > std::numeric_limits<offset_type>::max()) {
+      return Status::CapacityError(
+          "Result might not fit in a 32bit utf8 array, convert to large_utf8");
+    }
+    return Status::OK();
+  }
 };
 
 template <typename Type, typename StringTransform>
@@ -477,7 +490,7 @@ struct FixedSizeBinaryTransformExecBase {
         auto encoded_nbytes = static_cast<int32_t>(
             transform->Transform(input_string, input_width, output_str));
         if (encoded_nbytes != output_width) {
-          return transform->InvalidStatus();
+          return transform->InvalidInputSequence();
         }
       } else {
         std::memset(output_str, 0x00, output_width);
@@ -504,7 +517,7 @@ struct FixedSizeBinaryTransformExecBase {
     auto encoded_nbytes = static_cast<int32_t>(transform->Transform(
         input.value->data(), data_nbytes, value_buffer->mutable_data()));
     if (encoded_nbytes != out_width) {
-      return transform->InvalidStatus();
+      return transform->InvalidInputSequence();
     }
 
     result->is_valid = true;
@@ -548,30 +561,33 @@ struct StringBinaryTransformBase {
     return Status::OK();
   }
 
-  virtual Status InvalidStatus() {
+  virtual Status InvalidInputSequence() {
     return Status::Invalid("Invalid UTF8 sequence in input");
   }
 
   // Return the maximum total size of the output in codeunits (i.e. bytes)
   // given input characteristics for different input shapes.
-  //
+  // The Status parameter should only be set if an error needs to be signaled.
+
   // Scalar-Scalar
-  virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ViewType2) {
+  virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ViewType2,
+                               Status*) {
     return input1_ncodeunits;
   }
 
   // Scalar-Array
-  virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2&) {
+  virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2&,
+                               Status*) {
     return input1_ncodeunits;
   }
 
   // Array-Scalar
-  virtual int64_t MaxCodeunits(const ArrayType1& input1, const ViewType2) {
+  virtual int64_t MaxCodeunits(const ArrayType1& input1, const ViewType2, Status*) {
     return input1.total_values_length();
   }
 
   // Array-Array
-  virtual int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2&) {
+  virtual int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2&, Status*) {
     return input1.total_values_length();
   }
 
@@ -579,8 +595,8 @@ struct StringBinaryTransformBase {
   // transforms, so these flags serve as control toggles for enabling/disabling
   // the corresponding ones. These flags should be set in the PreExec() method.
   //
-  // This is an example of a StringTransform that disables argument shapes with
-  // mixed scalar/array.
+  // This is an example of a StringTransform that disables support for arguments
+  // with mixed Scalar/Array shapes.
   //
   // template <typename Type1, typename Type2>
   // struct MyStringTransform : public StringBinaryTransformBase<Type1, Type2> {
@@ -595,13 +611,6 @@ struct StringBinaryTransformBase {
   bool EnableScalarArray = true;
   bool EnableArrayScalar = true;
   bool EnableArrayArray = true;
-
-  // Tracks status of transform in StringBinaryTransformExecBase.
-  // The purpose of this transform status is to provide a means to report/detect
-  // errors in functions that do not provide a mechanism to return a Status
-  // value but can still detect errors. This status is checked automatically
-  // after MaxCodeunits() and Transform() operations.
-  Status st = Status::OK();
 };
 
 /// Kernel exec generator for binary (two parameters) string transforms.
@@ -610,7 +619,17 @@ struct StringBinaryTransformBase {
 /// need to define a transform method with the following signature:
 ///
 /// int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
-///                   const ViewType2 value2, uint8_t* output);
+///                   const ViewType2 value2, uint8_t* output, Status* st);
+///
+/// where
+///   * `input` - input sequence (binary or string)
+///   * `input_string_ncodeunits` - length of input sequence in codeunits
+///   * `value2` - second argument to the string transform
+///   * `output` - output sequence (binary or string)
+///   * `st` - Status code, only set if transform needs to signal an error
+///
+/// and returns the number of codeunits of the `output` sequence or a negative
+/// value if an invalid input sequence is detected.
 template <typename Type1, typename Type2, typename StringTransform>
 struct StringBinaryTransformExecBase {
   using offset_type = typename Type1::offset_type;
@@ -644,7 +663,9 @@ struct StringBinaryTransformExecBase {
         }
       }
     }
-    return Status::Invalid("Invalid ExecBatch kind for binary string transform");
+    return Status::Invalid("Invalid combination of operands for binary string transform",
+                           " (", batch[0].ToString(), ", ", batch[1].ToString(),
+                           "). Only Array/Scalar kinds are supported.");
   }
 
   static Status ExecScalarScalar(KernelContext* ctx, StringTransform* transform,
@@ -657,10 +678,12 @@ struct StringBinaryTransformExecBase {
     const auto input_string = binary_scalar1.value->data();
     const auto input_ncodeunits = binary_scalar1.value->size();
     const auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
+    Status st = Status::OK();
 
     // Calculate max number of output codeunits
-    const auto max_output_ncodeunits = transform->MaxCodeunits(input_ncodeunits, value2);
-    RETURN_NOT_OK(transform->st);
+    const auto max_output_ncodeunits =
+        transform->MaxCodeunits(input_ncodeunits, value2, &st);
+    RETURN_NOT_OK(st);
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output string
@@ -672,10 +695,10 @@ struct StringBinaryTransformExecBase {
 
     // Apply transform
     auto encoded_nbytes = static_cast<offset_type>(
-        transform->Transform(input_string, input_ncodeunits, value2, output_string));
-    RETURN_NOT_OK(transform->st);
+        transform->Transform(input_string, input_ncodeunits, value2, output_string, &st));
+    RETURN_NOT_OK(st);
     if (encoded_nbytes < 0) {
-      return transform->InvalidStatus();
+      return transform->InvalidInputSequence();
     }
     DCHECK_LE(encoded_nbytes, max_output_ncodeunits);
 
@@ -691,10 +714,11 @@ struct StringBinaryTransformExecBase {
     }
     const ArrayType1 array1(data1);
     const auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
+    Status st = Status::OK();
 
     // Calculate max number of output codeunits
-    const auto max_output_ncodeunits = transform->MaxCodeunits(array1, value2);
-    RETURN_NOT_OK(transform->st);
+    const auto max_output_ncodeunits = transform->MaxCodeunits(array1, value2, &st);
+    RETURN_NOT_OK(st);
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -714,11 +738,12 @@ struct StringBinaryTransformExecBase {
         [&](util::string_view input_string_view) {
           auto input_ncodeunits = static_cast<offset_type>(input_string_view.length());
           auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
-          auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
-              input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
-          RETURN_NOT_OK(transform->st);
+          auto encoded_nbytes = static_cast<offset_type>(
+              transform->Transform(input_string, input_ncodeunits, value2,
+                                   output_string + output_ncodeunits, &st));
+          RETURN_NOT_OK(st);
           if (encoded_nbytes < 0) {
-            return transform->InvalidStatus();
+            return transform->InvalidInputSequence();
           }
           output_ncodeunits += encoded_nbytes;
           *(++output_offsets) = output_ncodeunits;
@@ -744,10 +769,12 @@ struct StringBinaryTransformExecBase {
     const auto input_string = binary_scalar1.value->data();
     const auto input_ncodeunits = binary_scalar1.value->size();
     const ArrayType2 array2(data2);
+    Status st = Status::OK();
 
     // Calculate max number of output codeunits
-    const auto max_output_ncodeunits = transform->MaxCodeunits(input_ncodeunits, array2);
-    RETURN_NOT_OK(transform->st);
+    const auto max_output_ncodeunits =
+        transform->MaxCodeunits(input_ncodeunits, array2, &st);
+    RETURN_NOT_OK(st);
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -766,11 +793,12 @@ struct StringBinaryTransformExecBase {
         data2->buffers[0], data2->offset, data2->length,
         [&](int64_t i) {
           auto value2 = array2.GetView(i);
-          auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
-              input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
-          RETURN_NOT_OK(transform->st);
+          auto encoded_nbytes = static_cast<offset_type>(
+              transform->Transform(input_string, input_ncodeunits, value2,
+                                   output_string + output_ncodeunits, &st));
+          RETURN_NOT_OK(st);
           if (encoded_nbytes < 0) {
-            return transform->InvalidStatus();
+            return transform->InvalidInputSequence();
           }
           output_ncodeunits += encoded_nbytes;
           *(++output_offsets) = output_ncodeunits;
@@ -791,10 +819,11 @@ struct StringBinaryTransformExecBase {
                                const std::shared_ptr<ArrayData>& data2, Datum* out) {
     const ArrayType1 array1(data1);
     const ArrayType2 array2(data2);
+    Status st = Status::OK();
 
     // Calculate max number of output codeunits
-    const auto max_output_ncodeunits = transform->MaxCodeunits(array1, array2);
-    RETURN_NOT_OK(transform->st);
+    const auto max_output_ncodeunits = transform->MaxCodeunits(array1, array2, &st);
+    RETURN_NOT_OK(st);
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -813,14 +842,15 @@ struct StringBinaryTransformExecBase {
         data1->buffers[0], data1->offset, data2->buffers[0], data2->offset, data1->length,
         [&](int64_t i) {
           auto input_string_view = array1.GetView(i);
-          offset_type input_ncodeunits = input_string_view.length();
+          auto input_ncodeunits = static_cast<offset_type>(input_string_view.length());
           auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
           auto value2 = array2.GetView(i);
-          auto encoded_nbytes = static_cast<offset_type>(transform->Transform(
-              input_string, input_ncodeunits, value2, output_string + output_ncodeunits));
-          RETURN_NOT_OK(transform->st);
+          auto encoded_nbytes = static_cast<offset_type>(
+              transform->Transform(input_string, input_ncodeunits, value2,
+                                   output_string + output_ncodeunits, &st));
+          RETURN_NOT_OK(st);
           if (encoded_nbytes < 0) {
-            return transform->InvalidStatus();
+            return transform->InvalidInputSequence();
           }
           output_ncodeunits += encoded_nbytes;
           *(++output_offsets) = output_ncodeunits;
@@ -1020,7 +1050,7 @@ struct AsciiReverseTransform : public StringTransformBase {
     return utf8_char_found ? kTransformError : input_string_ncodeunits;
   }
 
-  Status InvalidStatus() override {
+  Status InvalidInputSequence() override {
     return Status::Invalid("Non-ASCII sequence in input");
   }
 };
@@ -2875,18 +2905,18 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
-  int64_t MaxCodeunits(const int64_t input1_ncodeunits,
-                       const int64_t num_repeats) override {
+  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const int64_t num_repeats,
+                       Status*) override {
     return input1_ncodeunits * num_repeats;
   }
 
-  int64_t MaxCodeunits(const int64_t input1_ncodeunits,
-                       const ArrayType2& input2) override {
+  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2& input2,
+                       Status* st) override {
     int64_t total_num_repeats = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
       auto num_repeats = input2.GetView(i);
       if (num_repeats < 0) {
-        this->st = Status::Invalid("Repeat count must be a non-negative integer");
+        *st = InvalidRepeatCount();
         return num_repeats;
       }
       total_num_repeats += num_repeats;
@@ -2894,16 +2924,18 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return input1_ncodeunits * total_num_repeats;
   }
 
-  int64_t MaxCodeunits(const ArrayType1& input1, const int64_t num_repeats) override {
+  int64_t MaxCodeunits(const ArrayType1& input1, const int64_t num_repeats,
+                       Status*) override {
     return input1.total_values_length() * num_repeats;
   }
 
-  int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2) override {
+  int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2,
+                       Status* st) override {
     int64_t total_codeunits = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
       auto num_repeats = input2.GetView(i);
       if (num_repeats < 0) {
-        this->st = Status::Invalid("Repeat count must be a non-negative integer");
+        *st = InvalidRepeatCount();
         return num_repeats;
       }
       total_codeunits += input1.GetView(i).length() * num_repeats;
@@ -2911,12 +2943,12 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return total_codeunits;
   }
 
-  std::function<int64_t(const uint8_t*, const int64_t, const int64_t, uint8_t*)>
+  std::function<int64_t(const uint8_t*, const int64_t, const int64_t, uint8_t*, Status*)>
       Transform;
 
   static int64_t TransformSimple(const uint8_t* input,
                                  const int64_t input_string_ncodeunits,
-                                 const int64_t num_repeats, uint8_t* output) {
+                                 const int64_t num_repeats, uint8_t* output, Status*) {
     uint8_t* output_start = output;
     for (int64_t i = 0; i < num_repeats; ++i) {
       std::memcpy(output, input, input_string_ncodeunits);
@@ -2927,7 +2959,7 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
 
   static int64_t TransformDoubling(const uint8_t* input,
                                    const int64_t input_string_ncodeunits,
-                                   const int64_t num_repeats, uint8_t* output) {
+                                   const int64_t num_repeats, uint8_t* output, Status*) {
     uint8_t* output_start = output;
     // Repeated doubling of string
     std::memcpy(output, input, input_string_ncodeunits);
@@ -2948,9 +2980,10 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
 
   static int64_t TransformWrapper(const uint8_t* input,
                                   const int64_t input_string_ncodeunits,
-                                  const int64_t num_repeats, uint8_t* output) {
+                                  const int64_t num_repeats, uint8_t* output,
+                                  Status* st) {
     auto transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
-    return transform(input, input_string_ncodeunits, num_repeats, output);
+    return transform(input, input_string_ncodeunits, num_repeats, output, st);
   }
 
   Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
@@ -2960,10 +2993,11 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     if (batch[1].is_scalar()) {
       auto scalar = batch[1].scalar();
       auto num_repeats = UnboxScalar<Type2>::Unbox(*scalar);
-      // Validate repeat count here to resolve error early as possible.
+      // Validate repeat count to resolve error early as possible since the
+      // value is used for selecting transform implementation.
       // For array shape, repeat count is validated in MaxCodeunits().
       if (num_repeats < 0) {
-        return Status::Invalid("Repeat count must be a non-negative integer");
+        return InvalidRepeatCount();
       }
       Transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
     } else {
@@ -2971,6 +3005,10 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     }
     return Status::OK();
   }
+
+  static Status InvalidRepeatCount() {
+    return Status::Invalid("Repeat count must be a non-negative integer");
+  }
 };
 
 template <typename Type1, typename Type2>

From 454bd49b718c2ee683781050f884b24d0e8b8db5 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 1 Nov 2021 12:02:33 -0400
Subject: [PATCH 62/84] wrap long lines and rename tests

---
 .../compute/kernels/scalar_string_test.cc     | 30 +++++++++++--------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index f4f1f083d37..69bb909641c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1037,16 +1037,18 @@ TYPED_TEST(TestStringKernels, Utf8Title) {
       R"([null, "", "B", "Aaaz;Zææ&", "Ɑɽɽow", "Ii", "Ⱥ.Ⱥ.Ⱥ..Ⱥ", "Hello, World!", "Foo   Bar;Héhé0Zop", "!%$^.,;"])");
 }
 
-TYPED_TEST(TestStringKernels, StringRepeat) {
-  auto values = ArrayFromJSON(
-      this->type(),
-      R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+TYPED_TEST(TestStringKernels, StringRepeatWithScalarRepeat) {
+  auto values = ArrayFromJSON(this->type(),
+                              R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI",
+                                  "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
   std::vector<std::pair<int, std::string>> nrepeats_and_expected{{
       {0, R"(["", null, "", "", "", "", "", "", "", ""])"},
-      {1,
-       R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])"},
-      {4,
-       R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbbb", "ɑɽⱤoWɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
+      {1, R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!",
+              "$. A3", "!ɑⱤⱤow"])"},
+      {4, R"(["aAazZæÆ&aAazZæÆ&aAazZæÆ&aAazZæÆ&", null, "", "bbbb",
+              "ɑɽⱤoWɑɽⱤoWɑɽⱤoWɑɽⱤoW", "ıIıIıIıI", "ⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺⱥⱥⱥȺ",
+              "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!",
+              "$. A3$. A3$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])"},
   }};
 
   for (const auto& pair : nrepeats_and_expected) {
@@ -1076,14 +1078,16 @@ TYPED_TEST(TestStringKernels, StringRepeat) {
   }
 }
 
-TYPED_TEST(TestStringKernels, StringRepeats) {
-  auto values = ArrayFromJSON(
-      this->type(),
-      R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI", "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
+TYPED_TEST(TestStringKernels, StringRepeatWithArrayRepeat) {
+  auto values = ArrayFromJSON(this->type(),
+                              R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI",
+                                  "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
   for (const auto& ty : IntTypes()) {
     auto num_repeats = ArrayFromJSON(ty, R"([100, 1, 2, 5, 2, 0, 1, 3, 2, 3])");
     std::string expected =
-        R"([null, "aAazZæÆ&", "", "bbbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ", "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3", "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
+        R"([null, "aAazZæÆ&", "", "bbbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ",
+            "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3",
+            "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
     this->CheckVarArgs("string_repeat", {values, num_repeats}, this->type(), expected);
   }
 

From 72ec626483069225c640b92e09bd2f613225abd2 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 1 Nov 2021 20:01:00 -0400
Subject: [PATCH 63/84] add Result return types and minor changes

---
 .../arrow/compute/kernels/scalar_string.cc    | 181 ++++++++----------
 1 file changed, 85 insertions(+), 96 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 8b9a2851189..3cf11cec290 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -19,7 +19,6 @@
 #include <cctype>
 #include <iterator>
 #include <string>
-#include <typeinfo>
 
 #ifdef ARROW_WITH_UTF8PROC
 #include <utf8proc.h>
@@ -36,6 +35,7 @@
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/string.h"
 #include "arrow/util/utf8.h"
 #include "arrow/util/value_parsing.h"
 #include "arrow/visitor_inline.h"
@@ -358,12 +358,9 @@ struct StringTransformExecBase {
                         const ExecBatch& batch, Datum* out) {
     if (batch[0].kind() == Datum::ARRAY) {
       return ExecArray(ctx, transform, batch[0].array(), out);
-    } else if (batch[0].kind() == Datum::SCALAR) {
-      return ExecScalar(ctx, transform, batch[0].scalar(), out);
     }
-    return Status::Invalid("Invalid operand for unary string transform", " (",
-                           batch[0].ToString(),
-                           "). Only Array/Scalar kinds are supported.");
+    DCHECK_EQ(batch[0].kind(), Datum::SCALAR);
+    return ExecScalar(ctx, transform, batch[0].scalar(), out);
   }
 
   static Status ExecArray(KernelContext* ctx, StringTransform* transform,
@@ -570,24 +567,23 @@ struct StringBinaryTransformBase {
   // The Status parameter should only be set if an error needs to be signaled.
 
   // Scalar-Scalar
-  virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ViewType2,
-                               Status*) {
+  virtual Result<int64_t> MaxCodeunits(const int64_t input1_ncodeunits, const ViewType2) {
     return input1_ncodeunits;
   }
 
   // Scalar-Array
-  virtual int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2&,
-                               Status*) {
+  virtual Result<int64_t> MaxCodeunits(const int64_t input1_ncodeunits,
+                                       const ArrayType2&) {
     return input1_ncodeunits;
   }
 
   // Array-Scalar
-  virtual int64_t MaxCodeunits(const ArrayType1& input1, const ViewType2, Status*) {
+  virtual Result<int64_t> MaxCodeunits(const ArrayType1& input1, const ViewType2) {
     return input1.total_values_length();
   }
 
   // Array-Array
-  virtual int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2&, Status*) {
+  virtual Result<int64_t> MaxCodeunits(const ArrayType1& input1, const ArrayType2&) {
     return input1.total_values_length();
   }
 
@@ -601,16 +597,16 @@ struct StringBinaryTransformBase {
   // template <typename Type1, typename Type2>
   // struct MyStringTransform : public StringBinaryTransformBase<Type1, Type2> {
   //   Status PreExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) override {
-  //     EnableScalarArray = false;
-  //     EnableArrayScalar = false;
+  //     enable_scalar_array_ = false;
+  //     enable_array_scalar_ = false;
   //     return StringBinaryTransformBase::PreExec(ctx, batch, out);
   //   }
   //   ...
   // };
-  bool EnableScalarScalar = true;
-  bool EnableScalarArray = true;
-  bool EnableArrayScalar = true;
-  bool EnableArrayArray = true;
+  bool enable_scalar_scalar_ = true;
+  bool enable_scalar_array_ = true;
+  bool enable_array_scalar_ = true;
+  bool enable_array_array_ = true;
 };
 
 /// Kernel exec generator for binary (two parameters) string transforms.
@@ -618,8 +614,9 @@ struct StringBinaryTransformBase {
 /// second parameter is generic. Types of template parameter StringTransform
 /// need to define a transform method with the following signature:
 ///
-/// int64_t Transform(const uint8_t* input, const int64_t input_string_ncodeunits,
-///                   const ViewType2 value2, uint8_t* output, Status* st);
+/// Result<int64_t> Transform(
+///    const uint8_t* input, const int64_t input_string_ncodeunits,
+///    const ViewType2 value2, uint8_t* output);
 ///
 /// where
 ///   * `input` - input sequence (binary or string)
@@ -641,31 +638,37 @@ struct StringBinaryTransformExecBase {
                         const ExecBatch& batch, Datum* out) {
     if (batch[0].is_scalar()) {
       if (batch[1].is_scalar()) {
-        if (transform->EnableScalarScalar) {
+        if (transform->enable_scalar_scalar_) {
           return ExecScalarScalar(ctx, transform, batch[0].scalar(), batch[1].scalar(),
                                   out);
         }
       } else if (batch[1].is_array()) {
-        if (transform->EnableScalarArray) {
+        if (transform->enable_scalar_array_) {
           return ExecScalarArray(ctx, transform, batch[0].scalar(), batch[1].array(),
                                  out);
         }
       }
     } else if (batch[0].is_array()) {
-      if (batch[1].is_array()) {
-        if (transform->EnableArrayArray) {
-          return ExecArrayArray(ctx, transform, batch[0].array(), batch[1].array(), out);
-        }
-      } else if (batch[1].is_scalar()) {
-        if (transform->EnableArrayScalar) {
+      if (batch[1].is_scalar()) {
+        if (transform->enable_array_scalar_) {
           return ExecArrayScalar(ctx, transform, batch[0].array(), batch[1].scalar(),
                                  out);
         }
+      } else if (batch[1].is_array()) {
+        if (transform->enable_array_array_) {
+          return ExecArrayArray(ctx, transform, batch[0].array(), batch[1].array(), out);
+        }
       }
     }
-    return Status::Invalid("Invalid combination of operands for binary string transform",
-                           " (", batch[0].ToString(), ", ", batch[1].ToString(),
-                           "). Only Array/Scalar kinds are supported.");
+
+    if (!(transform->enable_scalar_scalar_ && transform->enable_scalar_array_ &&
+          transform->enable_array_scalar_ && transform->enable_array_array_)) {
+      return Status::Invalid(
+          "Binary string transform has no combination of operand kinds enabled.");
+    }
+
+    return Status::TypeError("Invalid combination of operands (", batch[0].ToString(),
+                             ", ", batch[1].ToString(), ") for binary string transform.");
   }
 
   static Status ExecScalarScalar(KernelContext* ctx, StringTransform* transform,
@@ -678,12 +681,10 @@ struct StringBinaryTransformExecBase {
     const auto input_string = binary_scalar1.value->data();
     const auto input_ncodeunits = binary_scalar1.value->size();
     const auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
-    Status st = Status::OK();
 
     // Calculate max number of output codeunits
-    const auto max_output_ncodeunits =
-        transform->MaxCodeunits(input_ncodeunits, value2, &st);
-    RETURN_NOT_OK(st);
+    ARROW_ASSIGN_OR_RAISE(const auto max_output_ncodeunits,
+                          transform->MaxCodeunits(input_ncodeunits, value2));
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output string
@@ -694,9 +695,9 @@ struct StringBinaryTransformExecBase {
     auto output_string = output->value->mutable_data();
 
     // Apply transform
-    auto encoded_nbytes = static_cast<offset_type>(
-        transform->Transform(input_string, input_ncodeunits, value2, output_string, &st));
-    RETURN_NOT_OK(st);
+    ARROW_ASSIGN_OR_RAISE(
+        offset_type encoded_nbytes,
+        transform->Transform(input_string, input_ncodeunits, value2, output_string));
     if (encoded_nbytes < 0) {
       return transform->InvalidInputSequence();
     }
@@ -714,11 +715,10 @@ struct StringBinaryTransformExecBase {
     }
     const ArrayType1 array1(data1);
     const auto value2 = UnboxScalar<Type2>::Unbox(*scalar2);
-    Status st = Status::OK();
 
     // Calculate max number of output codeunits
-    const auto max_output_ncodeunits = transform->MaxCodeunits(array1, value2, &st);
-    RETURN_NOT_OK(st);
+    ARROW_ASSIGN_OR_RAISE(const auto max_output_ncodeunits,
+                          transform->MaxCodeunits(array1, value2));
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -738,10 +738,10 @@ struct StringBinaryTransformExecBase {
         [&](util::string_view input_string_view) {
           auto input_ncodeunits = static_cast<offset_type>(input_string_view.length());
           auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
-          auto encoded_nbytes = static_cast<offset_type>(
+          ARROW_ASSIGN_OR_RAISE(
+              offset_type encoded_nbytes,
               transform->Transform(input_string, input_ncodeunits, value2,
-                                   output_string + output_ncodeunits, &st));
-          RETURN_NOT_OK(st);
+                                   output_string + output_ncodeunits));
           if (encoded_nbytes < 0) {
             return transform->InvalidInputSequence();
           }
@@ -769,12 +769,10 @@ struct StringBinaryTransformExecBase {
     const auto input_string = binary_scalar1.value->data();
     const auto input_ncodeunits = binary_scalar1.value->size();
     const ArrayType2 array2(data2);
-    Status st = Status::OK();
 
     // Calculate max number of output codeunits
-    const auto max_output_ncodeunits =
-        transform->MaxCodeunits(input_ncodeunits, array2, &st);
-    RETURN_NOT_OK(st);
+    ARROW_ASSIGN_OR_RAISE(const auto max_output_ncodeunits,
+                          transform->MaxCodeunits(input_ncodeunits, array2));
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -793,10 +791,10 @@ struct StringBinaryTransformExecBase {
         data2->buffers[0], data2->offset, data2->length,
         [&](int64_t i) {
           auto value2 = array2.GetView(i);
-          auto encoded_nbytes = static_cast<offset_type>(
+          ARROW_ASSIGN_OR_RAISE(
+              offset_type encoded_nbytes,
               transform->Transform(input_string, input_ncodeunits, value2,
-                                   output_string + output_ncodeunits, &st));
-          RETURN_NOT_OK(st);
+                                   output_string + output_ncodeunits));
           if (encoded_nbytes < 0) {
             return transform->InvalidInputSequence();
           }
@@ -819,11 +817,10 @@ struct StringBinaryTransformExecBase {
                                const std::shared_ptr<ArrayData>& data2, Datum* out) {
     const ArrayType1 array1(data1);
     const ArrayType2 array2(data2);
-    Status st = Status::OK();
 
     // Calculate max number of output codeunits
-    const auto max_output_ncodeunits = transform->MaxCodeunits(array1, array2, &st);
-    RETURN_NOT_OK(st);
+    ARROW_ASSIGN_OR_RAISE(const auto max_output_ncodeunits,
+                          transform->MaxCodeunits(array1, array2));
     RETURN_NOT_OK(CheckOutputCapacity(max_output_ncodeunits));
 
     // Allocate output strings
@@ -845,10 +842,10 @@ struct StringBinaryTransformExecBase {
           auto input_ncodeunits = static_cast<offset_type>(input_string_view.length());
           auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
           auto value2 = array2.GetView(i);
-          auto encoded_nbytes = static_cast<offset_type>(
+          ARROW_ASSIGN_OR_RAISE(
+              offset_type encoded_nbytes,
               transform->Transform(input_string, input_ncodeunits, value2,
-                                   output_string + output_ncodeunits, &st));
-          RETURN_NOT_OK(st);
+                                   output_string + output_ncodeunits));
           if (encoded_nbytes < 0) {
             return transform->InvalidInputSequence();
           }
@@ -869,8 +866,8 @@ struct StringBinaryTransformExecBase {
   static Status CheckOutputCapacity(int64_t ncodeunits) {
     if (ncodeunits > std::numeric_limits<offset_type>::max()) {
       return Status::CapacityError(
-          "Result might not fit in requested binary/string array. If possible, convert "
-          "to a large binary/string.");
+          "Result might not fit in requested binary/string array. "
+          "If possible, convert to a large binary/string.");
     }
     return Status::OK();
   }
@@ -2905,50 +2902,46 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
-  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const int64_t num_repeats,
-                       Status*) override {
+  Result<int64_t> MaxCodeunits(const int64_t input1_ncodeunits,
+                               const int64_t num_repeats) override {
+    ARROW_RETURN_NOT_OK(ValidateRepeatCount(num_repeats));
     return input1_ncodeunits * num_repeats;
   }
 
-  int64_t MaxCodeunits(const int64_t input1_ncodeunits, const ArrayType2& input2,
-                       Status* st) override {
+  Result<int64_t> MaxCodeunits(const int64_t input1_ncodeunits,
+                               const ArrayType2& input2) override {
     int64_t total_num_repeats = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
       auto num_repeats = input2.GetView(i);
-      if (num_repeats < 0) {
-        *st = InvalidRepeatCount();
-        return num_repeats;
-      }
+      ARROW_RETURN_NOT_OK(ValidateRepeatCount(num_repeats));
       total_num_repeats += num_repeats;
     }
     return input1_ncodeunits * total_num_repeats;
   }
 
-  int64_t MaxCodeunits(const ArrayType1& input1, const int64_t num_repeats,
-                       Status*) override {
+  Result<int64_t> MaxCodeunits(const ArrayType1& input1,
+                               const int64_t num_repeats) override {
+    ARROW_RETURN_NOT_OK(ValidateRepeatCount(num_repeats));
     return input1.total_values_length() * num_repeats;
   }
 
-  int64_t MaxCodeunits(const ArrayType1& input1, const ArrayType2& input2,
-                       Status* st) override {
+  Result<int64_t> MaxCodeunits(const ArrayType1& input1,
+                               const ArrayType2& input2) override {
     int64_t total_codeunits = 0;
     for (int64_t i = 0; i < input2.length(); ++i) {
       auto num_repeats = input2.GetView(i);
-      if (num_repeats < 0) {
-        *st = InvalidRepeatCount();
-        return num_repeats;
-      }
+      ARROW_RETURN_NOT_OK(ValidateRepeatCount(num_repeats));
       total_codeunits += input1.GetView(i).length() * num_repeats;
     }
     return total_codeunits;
   }
 
-  std::function<int64_t(const uint8_t*, const int64_t, const int64_t, uint8_t*, Status*)>
+  std::function<Result<int64_t>(const uint8_t*, const int64_t, const int64_t, uint8_t*)>
       Transform;
 
-  static int64_t TransformSimple(const uint8_t* input,
-                                 const int64_t input_string_ncodeunits,
-                                 const int64_t num_repeats, uint8_t* output, Status*) {
+  static Result<int64_t> TransformSimple(const uint8_t* input,
+                                         const int64_t input_string_ncodeunits,
+                                         const int64_t num_repeats, uint8_t* output) {
     uint8_t* output_start = output;
     for (int64_t i = 0; i < num_repeats; ++i) {
       std::memcpy(output, input, input_string_ncodeunits);
@@ -2957,9 +2950,9 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return output - output_start;
   }
 
-  static int64_t TransformDoubling(const uint8_t* input,
-                                   const int64_t input_string_ncodeunits,
-                                   const int64_t num_repeats, uint8_t* output, Status*) {
+  static Result<int64_t> TransformDoubling(const uint8_t* input,
+                                           const int64_t input_string_ncodeunits,
+                                           const int64_t num_repeats, uint8_t* output) {
     uint8_t* output_start = output;
     // Repeated doubling of string
     std::memcpy(output, input, input_string_ncodeunits);
@@ -2978,12 +2971,11 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return output - output_start;
   }
 
-  static int64_t TransformWrapper(const uint8_t* input,
-                                  const int64_t input_string_ncodeunits,
-                                  const int64_t num_repeats, uint8_t* output,
-                                  Status* st) {
+  static Result<int64_t> TransformWrapper(const uint8_t* input,
+                                          const int64_t input_string_ncodeunits,
+                                          const int64_t num_repeats, uint8_t* output) {
     auto transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
-    return transform(input, input_string_ncodeunits, num_repeats, output, st);
+    return transform(input, input_string_ncodeunits, num_repeats, output);
   }
 
   Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
@@ -2993,12 +2985,6 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     if (batch[1].is_scalar()) {
       auto scalar = batch[1].scalar();
       auto num_repeats = UnboxScalar<Type2>::Unbox(*scalar);
-      // Validate repeat count to resolve error early as possible since the
-      // value is used for selecting transform implementation.
-      // For array shape, repeat count is validated in MaxCodeunits().
-      if (num_repeats < 0) {
-        return InvalidRepeatCount();
-      }
       Transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
     } else {
       Transform = TransformWrapper;
@@ -3006,8 +2992,11 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return Status::OK();
   }
 
-  static Status InvalidRepeatCount() {
-    return Status::Invalid("Repeat count must be a non-negative integer");
+  static Status ValidateRepeatCount(const int64_t num_repeats) {
+    if (num_repeats < 0) {
+      return Status::Invalid("Repeat count must be a non-negative integer");
+    }
+    return Status::OK();
   }
 };
 
@@ -3017,7 +3006,7 @@ using StringRepeat =
 
 const FunctionDoc string_repeat_doc(
     "Repeat a string", ("For each string in `strings`, return a replicated version."),
-    {"strings", "repeats"});
+    {"strings", "num_repeats"});
 
 void AddStringRepeat(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarCTypeToInt64Function>(

From df17787b6226521dae1e062d02fdaebabd5b5213 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 1 Nov 2021 23:02:43 -0400
Subject: [PATCH 64/84] add StringRepeat benchmark

---
 .../kernels/scalar_string_benchmark.cc        | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index ddc3a56f00f..9242ed2004b 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -210,6 +210,30 @@ static void BinaryJoinElementWiseArrayArray(benchmark::State& state) {
   });
 }
 
+static void StringRepeat(benchmark::State& state) {
+  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;
+  const int64_t repeat_min_size = 0;
+  const int64_t repeat_max_size = 8;
+  random::RandomArrayGenerator rng(kSeed);
+
+  // NOTE: this produces only-Ascii data
+  auto values =
+      rng.String(array_length, value_min_size, value_max_size, null_probability);
+  auto repeats =
+      rng.Int64(array_length, repeat_min_size, repeat_max_size, 0);
+  // Make sure lookup tables are initialized before measuring
+  ABORT_NOT_OK(CallFunction("string_repeat", {values, repeats}));
+
+  for (auto _ : state) {
+    ABORT_NOT_OK(CallFunction("string_repeat", {values, repeats}));
+  }
+  state.SetItemsProcessed(state.iterations() * array_length);
+  state.SetBytesProcessed(state.iterations() * values->data()->buffers[2]->size());
+}
+
 BENCHMARK(AsciiLower);
 BENCHMARK(AsciiUpper);
 BENCHMARK(IsAlphaNumericAscii);
@@ -236,5 +260,7 @@ BENCHMARK(BinaryJoinArrayArray);
 BENCHMARK(BinaryJoinElementWiseArrayScalar)->RangeMultiplier(8)->Range(2, 128);
 BENCHMARK(BinaryJoinElementWiseArrayArray)->RangeMultiplier(8)->Range(2, 128);
 
+BENCHMARK(StringRepeat);
+
 }  // namespace compute
 }  // namespace arrow

From eade790b63f88dbe1f0573c54d3b8d6ebf1451e1 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 1 Nov 2021 23:03:13 -0400
Subject: [PATCH 65/84] remove std::function indirection

---
 .../arrow/compute/kernels/scalar_string.cc    | 38 ++++++-------------
 1 file changed, 11 insertions(+), 27 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 3cf11cec290..264785dd8d7 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2936,12 +2936,9 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return total_codeunits;
   }
 
-  std::function<Result<int64_t>(const uint8_t*, const int64_t, const int64_t, uint8_t*)>
-      Transform;
-
-  static Result<int64_t> TransformSimple(const uint8_t* input,
-                                         const int64_t input_string_ncodeunits,
-                                         const int64_t num_repeats, uint8_t* output) {
+  static Result<int64_t> TransformSimpleLoop(const uint8_t* input,
+                                             const int64_t input_string_ncodeunits,
+                                             const int64_t num_repeats, uint8_t* output) {
     uint8_t* output_start = output;
     for (int64_t i = 0; i < num_repeats; ++i) {
       std::memcpy(output, input, input_string_ncodeunits);
@@ -2950,9 +2947,10 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return output - output_start;
   }
 
-  static Result<int64_t> TransformDoubling(const uint8_t* input,
-                                           const int64_t input_string_ncodeunits,
-                                           const int64_t num_repeats, uint8_t* output) {
+  static Result<int64_t> TransformDoublingString(const uint8_t* input,
+                                                 const int64_t input_string_ncodeunits,
+                                                 const int64_t num_repeats,
+                                                 uint8_t* output) {
     uint8_t* output_start = output;
     // Repeated doubling of string
     std::memcpy(output, input, input_string_ncodeunits);
@@ -2971,27 +2969,13 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
     return output - output_start;
   }
 
-  static Result<int64_t> TransformWrapper(const uint8_t* input,
-                                          const int64_t input_string_ncodeunits,
-                                          const int64_t num_repeats, uint8_t* output) {
-    auto transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
+  static Result<int64_t> Transform(const uint8_t* input,
+                                   const int64_t input_string_ncodeunits,
+                                   const int64_t num_repeats, uint8_t* output) {
+    auto transform = (num_repeats < 4) ? TransformSimpleLoop : TransformDoublingString;
     return transform(input, input_string_ncodeunits, num_repeats, output);
   }
 
-  Status PreExec(KernelContext*, const ExecBatch& batch, Datum*) override {
-    // For cases with a scalar repeat count, select the best implementation once
-    // before execution. Otherwise, use TransformWrapper to select implementation
-    // when processing each value.
-    if (batch[1].is_scalar()) {
-      auto scalar = batch[1].scalar();
-      auto num_repeats = UnboxScalar<Type2>::Unbox(*scalar);
-      Transform = (num_repeats < 4) ? TransformSimple : TransformDoubling;
-    } else {
-      Transform = TransformWrapper;
-    }
-    return Status::OK();
-  }
-
   static Status ValidateRepeatCount(const int64_t num_repeats) {
     if (num_repeats < 0) {
       return Status::Invalid("Repeat count must be a non-negative integer");

From 8de20dcdc5f8667ad378ae973d646f3542d86f76 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 1 Nov 2021 23:30:06 -0400
Subject: [PATCH 66/84] add static_cast to Transform return value

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 264785dd8d7..b1500a8388c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -696,8 +696,9 @@ struct StringBinaryTransformExecBase {
 
     // Apply transform
     ARROW_ASSIGN_OR_RAISE(
-        offset_type encoded_nbytes,
+        auto encoded_nbytes_,
         transform->Transform(input_string, input_ncodeunits, value2, output_string));
+    auto encoded_nbytes = static_cast<offset_type>(encoded_nbytes_);
     if (encoded_nbytes < 0) {
       return transform->InvalidInputSequence();
     }
@@ -739,9 +740,10 @@ struct StringBinaryTransformExecBase {
           auto input_ncodeunits = static_cast<offset_type>(input_string_view.length());
           auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
           ARROW_ASSIGN_OR_RAISE(
-              offset_type encoded_nbytes,
+              auto encoded_nbytes_,
               transform->Transform(input_string, input_ncodeunits, value2,
                                    output_string + output_ncodeunits));
+          auto encoded_nbytes = static_cast<offset_type>(encoded_nbytes_);
           if (encoded_nbytes < 0) {
             return transform->InvalidInputSequence();
           }
@@ -792,9 +794,10 @@ struct StringBinaryTransformExecBase {
         [&](int64_t i) {
           auto value2 = array2.GetView(i);
           ARROW_ASSIGN_OR_RAISE(
-              offset_type encoded_nbytes,
+              auto encoded_nbytes_,
               transform->Transform(input_string, input_ncodeunits, value2,
                                    output_string + output_ncodeunits));
+          auto encoded_nbytes = static_cast<offset_type>(encoded_nbytes_);
           if (encoded_nbytes < 0) {
             return transform->InvalidInputSequence();
           }
@@ -843,9 +846,10 @@ struct StringBinaryTransformExecBase {
           auto input_string = reinterpret_cast<const uint8_t*>(input_string_view.data());
           auto value2 = array2.GetView(i);
           ARROW_ASSIGN_OR_RAISE(
-              offset_type encoded_nbytes,
+              auto encoded_nbytes_,
               transform->Transform(input_string, input_ncodeunits, value2,
                                    output_string + output_ncodeunits));
+          auto encoded_nbytes = static_cast<offset_type>(encoded_nbytes_);
           if (encoded_nbytes < 0) {
             return transform->InvalidInputSequence();
           }

From 9e288940679e76a0fe865b067292b0f72079eb4c Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 1 Nov 2021 23:47:36 -0400
Subject: [PATCH 67/84] update R test

---
 r/tests/testthat/test-dplyr-funcs-string.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index c7b56284de0..35c3d9e7ca2 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -468,7 +468,7 @@ test_that("strsplit and str_split", {
 })
 
 test_that("strrep", {
-  df <- tibble(x = c("foo1", "B a R\n", "!apACHe aRroW!"))
+  df <- tibble(x = c("foo1", " \tB a R\n", "!apACHe aRroW!"))
   for (times in 0:8L) {
     expect_dplyr_equal(
       input %>%

From 7c0673dfc6cc43a8526f1b33872973e837a496bb Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 2 Nov 2021 01:42:19 -0400
Subject: [PATCH 68/84] fix lint error

---
 cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index 9242ed2004b..584d8dbaba7 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -222,8 +222,7 @@ static void StringRepeat(benchmark::State& state) {
   // NOTE: this produces only-Ascii data
   auto values =
       rng.String(array_length, value_min_size, value_max_size, null_probability);
-  auto repeats =
-      rng.Int64(array_length, repeat_min_size, repeat_max_size, 0);
+  auto repeats = rng.Int64(array_length, repeat_min_size, repeat_max_size, 0);
   // Make sure lookup tables are initialized before measuring
   ABORT_NOT_OK(CallFunction("string_repeat", {values, repeats}));
 

From f441b154cc53d470f55dcbd2e4be5964772d35ca Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 2 Nov 2021 11:50:51 -0400
Subject: [PATCH 69/84] revert include statement

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
index da8ea5b2d7c..09681b2763b 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic_test.cc
@@ -20,7 +20,6 @@
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include <gtest/gtest.h>
 

From 225cc68d54a64312a5a6be880c3e61c3f0d931a8 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 2 Nov 2021 14:53:10 -0400
Subject: [PATCH 70/84] change xor to subtraction and rename var in doubling
 approach

---
 cpp/src/arrow/compute/kernels/scalar_string.cc | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index b1500a8388c..3670db3ca3d 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2957,17 +2957,18 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
                                                  uint8_t* output) {
     uint8_t* output_start = output;
     // Repeated doubling of string
+    // NB: This implementation expects `num_repeats > 0`.
     std::memcpy(output, input, input_string_ncodeunits);
     output += input_string_ncodeunits;
-    int64_t i = 1;
-    for (int64_t ilen = input_string_ncodeunits; i <= (num_repeats / 2);
-         i *= 2, ilen *= 2) {
+    int64_t irep = 1;
+    for (int64_t ilen = input_string_ncodeunits; irep <= (num_repeats / 2);
+         irep *= 2, ilen *= 2) {
       std::memcpy(output, output_start, ilen);
       output += ilen;
     }
 
     // Epilogue remainder
-    int64_t rem = (num_repeats ^ i) * input_string_ncodeunits;
+    int64_t rem = (num_repeats - irep) * input_string_ncodeunits;
     std::memcpy(output, output_start, rem);
     output += rem;
     return output - output_start;

From 62969b3c6c790a529c03fdb2d92da24e2fac588c Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 2 Nov 2021 15:25:52 -0400
Subject: [PATCH 71/84] rename function to binary_repeat

---
 .../arrow/compute/kernels/scalar_string.cc    | 19 +++++-----
 .../compute/kernels/scalar_string_test.cc     | 16 ++++----
 docs/source/cpp/compute.rst                   | 38 +++++++++----------
 docs/source/python/api/compute.rst            |  2 +-
 4 files changed, 38 insertions(+), 37 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index 3670db3ca3d..09e189bc562 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -2902,7 +2902,7 @@ struct ScalarCTypeToInt64Function : public ScalarFunction {
 };
 
 template <typename Type1, typename Type2>
-struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
+struct BinaryRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
   using ArrayType1 = typename TypeTraits<Type1>::ArrayType;
   using ArrayType2 = typename TypeTraits<Type2>::ArrayType;
 
@@ -2990,18 +2990,19 @@ struct StringRepeatTransform : public StringBinaryTransformBase<Type1, Type2> {
 };
 
 template <typename Type1, typename Type2>
-using StringRepeat =
-    StringBinaryTransformExec<Type1, Type2, StringRepeatTransform<Type1, Type2>>;
+using BinaryRepeat =
+    StringBinaryTransformExec<Type1, Type2, BinaryRepeatTransform<Type1, Type2>>;
 
-const FunctionDoc string_repeat_doc(
-    "Repeat a string", ("For each string in `strings`, return a replicated version."),
+const FunctionDoc binary_repeat_doc(
+    "Repeat a binary string",
+    ("For each binary string in `strings`, return a replicated version."),
     {"strings", "num_repeats"});
 
-void AddStringRepeat(FunctionRegistry* registry) {
+void AddBinaryRepeat(FunctionRegistry* registry) {
   auto func = std::make_shared<ScalarCTypeToInt64Function>(
-      "string_repeat", Arity::Binary(), &string_repeat_doc);
+      "binary_repeat", Arity::Binary(), &binary_repeat_doc);
   for (const auto& ty : BaseBinaryTypes()) {
-    auto exec = GenerateVarBinaryToVarBinary<StringRepeat, Int64Type>(ty);
+    auto exec = GenerateVarBinaryToVarBinary<BinaryRepeat, Int64Type>(ty);
     ScalarKernel kernel{{ty, int64()}, ty, exec};
     DCHECK_OK(func->AddKernel(std::move(kernel)));
   }
@@ -5027,7 +5028,7 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   AddSplit(registry);
   AddStrptime(registry);
   AddBinaryJoin(registry);
-  AddStringRepeat(registry);
+  AddBinaryRepeat(registry);
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 69bb909641c..48d7d198749 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1037,7 +1037,7 @@ TYPED_TEST(TestStringKernels, Utf8Title) {
       R"([null, "", "B", "Aaaz;Zææ&", "Ɑɽɽow", "Ii", "Ⱥ.Ⱥ.Ⱥ..Ⱥ", "Hello, World!", "Foo   Bar;Héhé0Zop", "!%$^.,;"])");
 }
 
-TYPED_TEST(TestStringKernels, StringRepeatWithScalarRepeat) {
+TYPED_TEST(TestStringKernels, BinaryRepeatWithScalarRepeat) {
   auto values = ArrayFromJSON(this->type(),
                               R"(["aAazZæÆ&", null, "", "b", "ɑɽⱤoW", "ıI",
                                   "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
@@ -1055,7 +1055,7 @@ TYPED_TEST(TestStringKernels, StringRepeatWithScalarRepeat) {
     auto num_repeat = pair.first;
     auto expected = pair.second;
     for (const auto& ty : IntTypes()) {
-      this->CheckVarArgs("string_repeat",
+      this->CheckVarArgs("binary_repeat",
                          {values, Datum(*arrow::MakeScalar(ty, num_repeat))},
                          this->type(), expected);
     }
@@ -1066,7 +1066,7 @@ TYPED_TEST(TestStringKernels, StringRepeatWithScalarRepeat) {
     auto num_repeat = *arrow::MakeScalar(int64(), num_repeat_);
     EXPECT_RAISES_WITH_MESSAGE_THAT(
         Invalid, ::testing::HasSubstr("Repeat count must be a non-negative integer"),
-        CallFunction("string_repeat", {values, num_repeat}));
+        CallFunction("binary_repeat", {values, num_repeat}));
   }
 
   // Floating-point repeat count
@@ -1074,11 +1074,11 @@ TYPED_TEST(TestStringKernels, StringRepeatWithScalarRepeat) {
     auto num_repeat = *arrow::MakeScalar(float64(), num_repeat_);
     EXPECT_RAISES_WITH_MESSAGE_THAT(
         NotImplemented, ::testing::HasSubstr("has no kernel matching input types"),
-        CallFunction("string_repeat", {values, num_repeat}));
+        CallFunction("binary_repeat", {values, num_repeat}));
   }
 }
 
-TYPED_TEST(TestStringKernels, StringRepeatWithArrayRepeat) {
+TYPED_TEST(TestStringKernels, BinaryRepeatWithArrayRepeat) {
   auto values = ArrayFromJSON(this->type(),
                               R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI",
                                   "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
@@ -1088,20 +1088,20 @@ TYPED_TEST(TestStringKernels, StringRepeatWithArrayRepeat) {
         R"([null, "aAazZæÆ&", "", "bbbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ",
             "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3",
             "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
-    this->CheckVarArgs("string_repeat", {values, num_repeats}, this->type(), expected);
+    this->CheckVarArgs("binary_repeat", {values, num_repeats}, this->type(), expected);
   }
 
   // Negative repeat count
   auto num_repeats = ArrayFromJSON(int64(), R"([100, -1, 2, -5, 2, -1, 3, -2, 3, -100])");
   EXPECT_RAISES_WITH_MESSAGE_THAT(
       Invalid, ::testing::HasSubstr("Repeat count must be a non-negative integer"),
-      CallFunction("string_repeat", {values, num_repeats}));
+      CallFunction("binary_repeat", {values, num_repeats}));
 
   // Floating-point repeat count
   num_repeats = ArrayFromJSON(float64(), R"([0.0, 1.2, -1.3])");
   EXPECT_RAISES_WITH_MESSAGE_THAT(
       NotImplemented, ::testing::HasSubstr("has no kernel matching input types"),
-      CallFunction("string_repeat", {values, num_repeats}));
+      CallFunction("binary_repeat", {values, num_repeats}));
 }
 
 TYPED_TEST(TestStringKernels, IsAlphaNumericUnicode) {
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 513988861ad..34b1f3448da 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -829,29 +829,29 @@ String transforms
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
 | binary_length           | Unary  | Binary- or String-like                  | Int32 or Int64         |                                   | \(3)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| binary_replace_slice    | Unary  | String-like                             | Binary- or String-like | :struct:`ReplaceSliceOptions`     | \(4)  |
+| binary_repeat           | Binary | Binary/String (Arg 0); Integral (Arg 1) | Binary- or String-like |                                   | \(4)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| replace_substring       | Unary  | String-like                             | String-like            | :struct:`ReplaceSubstringOptions` | \(5)  |
+| binary_replace_slice    | Unary  | String-like                             | Binary- or String-like | :struct:`ReplaceSliceOptions`     | \(5)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| replace_substring_regex | Unary  | String-like                             | String-like            | :struct:`ReplaceSubstringOptions` | \(6)  |
+| replace_substring       | Unary  | String-like                             | String-like            | :struct:`ReplaceSubstringOptions` | \(6)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| string_repeat           | Binary | Binary/String (Arg 0); Integral (Arg 1) | Binary- or String-like |                                   | \(7)  |
+| replace_substring_regex | Unary  | String-like                             | String-like            | :struct:`ReplaceSubstringOptions` | \(7)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_capitalize         | Unary  | String-like                             | String-like            |                                   | \(9)  |
+| utf8_capitalize         | Unary  | String-like                             | String-like            |                                   | \(8)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_length             | Unary  | String-like                             | Int32 or Int64         |                                   | \(8)  |
+| utf8_length             | Unary  | String-like                             | Int32 or Int64         |                                   | \(9)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_lower              | Unary  | String-like                             | String-like            |                                   | \(9)  |
+| utf8_lower              | Unary  | String-like                             | String-like            |                                   | \(8)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_replace_slice      | Unary  | String-like                             | String-like            | :struct:`ReplaceSliceOptions`     | \(5)  |
+| utf8_replace_slice      | Unary  | String-like                             | String-like            | :struct:`ReplaceSliceOptions`     | \(6)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
 | utf8_reverse            | Unary  | String-like                             | String-like            |                                   | \(10) |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_swapcase           | Unary  | String-like                             | String-like            |                                   | \(9)  |
+| utf8_swapcase           | Unary  | String-like                             | String-like            |                                   | \(8)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_title              | Unary  | String-like                             | String-like            |                                   | \(9)  |
+| utf8_title              | Unary  | String-like                             | String-like            |                                   | \(8)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
-| utf8_upper              | Unary  | String-like                             | String-like            |                                   | \(9)  |
+| utf8_upper              | Unary  | String-like                             | String-like            |                                   | \(8)  |
 +-------------------------+--------+-----------------------------------------+------------------------+-----------------------------------+-------+
 
 * \(1) Each ASCII character in the input is converted to lowercase or
@@ -863,32 +863,32 @@ 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.
 
-* \(4) Replace the slice of the substring from :member:`ReplaceSliceOptions::start`
+* \(4) Repeat the input binary string a given number of times.
+
+* \(5) Replace the slice of the substring from :member:`ReplaceSliceOptions::start`
   (inclusive) to :member:`ReplaceSliceOptions::stop` (exclusive) by
   :member:`ReplaceSubstringOptions::replacement`. The binary kernel measures the
   slice in bytes, while the UTF8 kernel measures the slice in codeunits.
 
-* \(5) Replace non-overlapping substrings that match to
+* \(6) Replace non-overlapping substrings that match to
   :member:`ReplaceSubstringOptions::pattern` by
   :member:`ReplaceSubstringOptions::replacement`. If
   :member:`ReplaceSubstringOptions::max_replacements` != -1, it determines the
   maximum number of replacements made, counting from the left.
 
-* \(6) Replace non-overlapping substrings that match to the regular expression
+* \(7) Replace non-overlapping substrings that match to the regular expression
   :member:`ReplaceSubstringOptions::pattern` by
   :member:`ReplaceSubstringOptions::replacement`, using the Google RE2 library. If
   :member:`ReplaceSubstringOptions::max_replacements` != -1, it determines the
   maximum number of replacements made, counting from the left. Note that if the
   pattern contains groups, backreferencing can be used.
 
-* \(7) Repeat the input binary sequence or string a given number of times.
+* \(8) Each UTF8-encoded character in the input is converted to lowercase or
+  uppercase.
 
-* \(8) Output is the number of characters (not bytes) of each input element.
+* \(9) Output is the number of characters (not bytes) of each input element.
   Output type is Int32 for String, Int64 for LargeString.
 
-* \(9) Each UTF8-encoded character in the input is converted to lowercase or
-  uppercase.
-
 * \(10) 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
   buffers will be preserved).
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index e9e261b9cdf..225d853718f 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -267,10 +267,10 @@ String Transforms
    ascii_title
    ascii_upper
    binary_length
+   binary_repeat
    binary_replace_slice
    replace_substring
    replace_substring_regex
-   string_repeat
    utf8_capitalize
    utf8_length
    utf8_lower

From 6ec68ae145b1343eaf7e5c814fa31ea1f43d4c2a Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 2 Nov 2021 15:36:44 -0400
Subject: [PATCH 72/84] update function name in benchmark

---
 .../arrow/compute/kernels/scalar_string_benchmark.cc   | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
index 584d8dbaba7..0977ea7806c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_benchmark.cc
@@ -210,7 +210,7 @@ static void BinaryJoinElementWiseArrayArray(benchmark::State& state) {
   });
 }
 
-static void StringRepeat(benchmark::State& state) {
+static void BinaryRepeat(benchmark::State& state) {
   const int64_t array_length = 1 << 20;
   const int64_t value_min_size = 0;
   const int64_t value_max_size = 32;
@@ -222,12 +222,12 @@ static void StringRepeat(benchmark::State& state) {
   // NOTE: this produces only-Ascii data
   auto values =
       rng.String(array_length, value_min_size, value_max_size, null_probability);
-  auto repeats = rng.Int64(array_length, repeat_min_size, repeat_max_size, 0);
+  auto num_repeats = rng.Int64(array_length, repeat_min_size, repeat_max_size, 0);
   // Make sure lookup tables are initialized before measuring
-  ABORT_NOT_OK(CallFunction("string_repeat", {values, repeats}));
+  ABORT_NOT_OK(CallFunction("binary_repeat", {values, num_repeats}));
 
   for (auto _ : state) {
-    ABORT_NOT_OK(CallFunction("string_repeat", {values, repeats}));
+    ABORT_NOT_OK(CallFunction("binary_repeat", {values, num_repeats}));
   }
   state.SetItemsProcessed(state.iterations() * array_length);
   state.SetBytesProcessed(state.iterations() * values->data()->buffers[2]->size());
@@ -259,7 +259,7 @@ BENCHMARK(BinaryJoinArrayArray);
 BENCHMARK(BinaryJoinElementWiseArrayScalar)->RangeMultiplier(8)->Range(2, 128);
 BENCHMARK(BinaryJoinElementWiseArrayArray)->RangeMultiplier(8)->Range(2, 128);
 
-BENCHMARK(StringRepeat);
+BENCHMARK(BinaryRepeat);
 
 }  // namespace compute
 }  // namespace arrow

From 9dbc42158619ca81661ab46b1aaa1dfbeb1772ed Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 2 Nov 2021 16:33:10 -0400
Subject: [PATCH 73/84] fix R func name error

---
 r/tests/testthat/test-dplyr-funcs-string.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 35c3d9e7ca2..44eb5636876 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -470,7 +470,7 @@ test_that("strsplit and str_split", {
 test_that("strrep", {
   df <- tibble(x = c("foo1", " \tB a R\n", "!apACHe aRroW!"))
   for (times in 0:8L) {
-    expect_dplyr_equal(
+    compare_dplyr_binding(
       input %>%
         transmute(x = strrep(x, times)) %>%
         collect(),

From 73a6cfc0641915d22d92247d3b7cf1d27a263da5 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 2 Nov 2021 17:34:31 -0400
Subject: [PATCH 74/84] R changes: input -> .input, transmute -> mutate

---
 r/tests/testthat/test-dplyr-funcs-string.R | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 44eb5636876..0f0707aa7ad 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -471,8 +471,8 @@ test_that("strrep", {
   df <- tibble(x = c("foo1", " \tB a R\n", "!apACHe aRroW!"))
   for (times in 0:8L) {
     compare_dplyr_binding(
-      input %>%
-        transmute(x = strrep(x, times)) %>%
+      .input %>%
+        mutate(x = strrep(x, times)) %>%
         collect(),
       df
     )

From a28f25de3d33db8e19023740d1b30fb0a7fa81f7 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Tue, 2 Nov 2021 18:28:12 -0400
Subject: [PATCH 75/84] update function name in R expressions

---
 r/R/expression.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/R/expression.R b/r/R/expression.R
index 5eb3d182da8..b6f3ccb0c45 100644
--- a/r/R/expression.R
+++ b/r/R/expression.R
@@ -101,7 +101,7 @@
   "%%" = "divide_checked",
   "^" = "power_checked",
   "%in%" = "is_in_meta_binary",
-  "strrep" = "string_repeat"
+  "strrep" = "binary_repeat"
 )
 
 .array_function_map <- c(.unary_function_map, .binary_function_map)

From 9ea2d4d2f5d5d949ebc85ab9c4ebd35559a6d8b7 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 05:46:38 -0400
Subject: [PATCH 76/84] add R str_dup binding and test

---
 r/R/expression.R                           | 3 ++-
 r/tests/testthat/test-dplyr-funcs-string.R | 9 ++++++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/r/R/expression.R b/r/R/expression.R
index b6f3ccb0c45..9c2554f9e05 100644
--- a/r/R/expression.R
+++ b/r/R/expression.R
@@ -101,7 +101,8 @@
   "%%" = "divide_checked",
   "^" = "power_checked",
   "%in%" = "is_in_meta_binary",
-  "strrep" = "binary_repeat"
+  "strrep" = "binary_repeat",
+  "str_dup" = "binary_repeat"
 )
 
 .array_function_map <- c(.unary_function_map, .binary_function_map)
diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 0f0707aa7ad..87733512ab4 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -469,13 +469,20 @@ test_that("strsplit and str_split", {
 
 test_that("strrep", {
   df <- tibble(x = c("foo1", " \tB a R\n", "!apACHe aRroW!"))
-  for (times in 0:8L) {
+  for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
         mutate(x = strrep(x, times)) %>%
         collect(),
       df
     )
+
+    compare_dplyr_binding(
+      .input %>%
+        mutate(x = str_dup(x, times)) %>%
+        collect(),
+      df
+    )
   }
 })
 

From eb72d63c3aea78901ffb4e83718eeb0914325272 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 11:44:39 -0400
Subject: [PATCH 77/84] use different vars in R tests

---
 r/tests/testthat/test-dplyr-funcs-string.R | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 87733512ab4..767ad4714db 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -472,14 +472,14 @@ test_that("strrep", {
   for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
-        mutate(x = strrep(x, times)) %>%
+        mutate(y = strrep(x, times)) %>%
         collect(),
       df
     )
 
     compare_dplyr_binding(
       .input %>%
-        mutate(x = str_dup(x, times)) %>%
+        mutate(z = str_dup(x, times)) %>%
         collect(),
       df
     )

From 6aabb4f794d3746365c35d9e8fe2f7b0754bf4b0 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 11:51:56 -0400
Subject: [PATCH 78/84] add test with num_repeat=null

---
 cpp/src/arrow/compute/kernels/scalar_string_test.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 48d7d198749..4551e8c61e5 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -1083,10 +1083,10 @@ TYPED_TEST(TestStringKernels, BinaryRepeatWithArrayRepeat) {
                               R"([null, "aAazZæÆ&", "", "b", "ɑɽⱤoW", "ıI",
                                   "ⱥⱥⱥȺ", "hEllO, WoRld!", "$. A3", "!ɑⱤⱤow"])");
   for (const auto& ty : IntTypes()) {
-    auto num_repeats = ArrayFromJSON(ty, R"([100, 1, 2, 5, 2, 0, 1, 3, 2, 3])");
+    auto num_repeats = ArrayFromJSON(ty, R"([100, 1, 2, 5, 2, 0, 1, 3, null, 3])");
     std::string expected =
         R"([null, "aAazZæÆ&", "", "bbbbb", "ɑɽⱤoWɑɽⱤoW", "", "ⱥⱥⱥȺ",
-            "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", "$. A3$. A3",
+            "hEllO, WoRld!hEllO, WoRld!hEllO, WoRld!", null,
             "!ɑⱤⱤow!ɑⱤⱤow!ɑⱤⱤow"])";
     this->CheckVarArgs("binary_repeat", {values, num_repeats}, this->type(), expected);
   }

From cc47c65971fef4308b705ec34c179babc1857e5e Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 13:00:12 -0400
Subject: [PATCH 79/84] use transmute instead of mutate?

---
 r/tests/testthat/test-dplyr-funcs-string.R | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 767ad4714db..e845e2998c7 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -472,14 +472,14 @@ test_that("strrep", {
   for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
-        mutate(y = strrep(x, times)) %>%
+        transmute(x = strrep(x, times)) %>%
         collect(),
       df
     )
 
     compare_dplyr_binding(
       .input %>%
-        mutate(z = str_dup(x, times)) %>%
+        transmute(x = str_dup(x, times)) %>%
         collect(),
       df
     )

From 6bce7c2050cd36958c262ec91d84be877a88c1be Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 13:34:25 -0400
Subject: [PATCH 80/84] add str_dup to test title and revert to mutate()

---
 r/tests/testthat/test-dplyr-funcs-string.R | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index e845e2998c7..7caeac3d735 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -467,19 +467,19 @@ test_that("strsplit and str_split", {
   )
 })
 
-test_that("strrep", {
+test_that("strrep and str_dup", {
   df <- tibble(x = c("foo1", " \tB a R\n", "!apACHe aRroW!"))
   for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
-        transmute(x = strrep(x, times)) %>%
+        mutate(x = strrep(x, times)) %>%
         collect(),
       df
     )
 
     compare_dplyr_binding(
       .input %>%
-        transmute(x = str_dup(x, times)) %>%
+        mutate(x = str_dup(x, times)) %>%
         collect(),
       df
     )

From c555bd80d9250215b9eed7ca7775d0f1eaae424a Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 15:12:15 -0400
Subject: [PATCH 81/84] add L to number range

---
 r/tests/testthat/test-dplyr-funcs-string.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 7caeac3d735..45fda5ee56f 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -469,7 +469,7 @@ test_that("strsplit and str_split", {
 
 test_that("strrep and str_dup", {
   df <- tibble(x = c("foo1", " \tB a R\n", "!apACHe aRroW!"))
-  for (times in 0:8) {
+  for (times in 0:8L) {
     compare_dplyr_binding(
       .input %>%
         mutate(x = strrep(x, times)) %>%

From 29df2654f8a5c8ebc913462de57483ee775e74fe Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 15:30:09 -0400
Subject: [PATCH 82/84] split tests

---
 r/tests/testthat/test-dplyr-funcs-string.R | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 45fda5ee56f..b7e4acea1bd 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -469,14 +469,16 @@ test_that("strsplit and str_split", {
 
 test_that("strrep and str_dup", {
   df <- tibble(x = c("foo1", " \tB a R\n", "!apACHe aRroW!"))
-  for (times in 0:8L) {
+  for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
         mutate(x = strrep(x, times)) %>%
         collect(),
       df
     )
+  }
 
+  for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
         mutate(x = str_dup(x, times)) %>%

From c5e83a99087208d521c261cd8b3062eb25876161 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 15:58:08 -0400
Subject: [PATCH 83/84] use different var names

---
 r/tests/testthat/test-dplyr-funcs-string.R | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index b7e4acea1bd..d91a7160dde 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -472,16 +472,14 @@ test_that("strrep and str_dup", {
   for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
-        mutate(x = strrep(x, times)) %>%
+        mutate(x1 = strrep(x, times)) %>%
         collect(),
       df
     )
-  }
 
-  for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
-        mutate(x = str_dup(x, times)) %>%
+        mutate(x2 = str_dup(x, times)) %>%
         collect(),
       df
     )

From 97a15ad3603b31e41b8a615bd5d5a4af90272fd9 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Wed, 3 Nov 2021 17:00:35 -0400
Subject: [PATCH 84/84] rename R func str_dup

---
 r/R/type.R                                 | 4 ++--
 r/tests/testthat/test-dplyr-funcs-string.R | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/r/R/type.R b/r/R/type.R
index 4ef7cefb56e..afa9a094af1 100644
--- a/r/R/type.R
+++ b/r/R/type.R
@@ -481,12 +481,12 @@ canonical_type_str <- function(type_str) {
 }
 
 # vctrs support -----------------------------------------------------------
-str_dup <- function(x, times) {
+duplicate_string <- function(x, times) {
   paste0(rep(x, times = times), collapse = "")
 }
 
 indent <- function(x, n) {
-  pad <- str_dup(" ", n)
+  pad <- duplicate_string(" ", n)
   sapply(x, gsub, pattern = "(\n+)", replacement = paste0("\\1", pad))
 }
 
diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index d91a7160dde..7caeac3d735 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -472,14 +472,14 @@ test_that("strrep and str_dup", {
   for (times in 0:8) {
     compare_dplyr_binding(
       .input %>%
-        mutate(x1 = strrep(x, times)) %>%
+        mutate(x = strrep(x, times)) %>%
         collect(),
       df
     )
 
     compare_dplyr_binding(
       .input %>%
-        mutate(x2 = str_dup(x, times)) %>%
+        mutate(x = str_dup(x, times)) %>%
         collect(),
       df
     )