From cd6550b9c8e88b1570a6ad0e2142f38e9ef2f11e Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 17 Feb 2022 11:12:13 -0500
Subject: [PATCH 01/67] Creating new kernel for cumulative sum

---
 .../compute/kernels/vector_cumulative_sum.cc  | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
new file mode 100644
index 00000000000..9add6c7d2bd
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/array/array_base.h"
+#include "arrow/compute/kernels/common.h"
+#include "arrow/result.h"
+#include "arrow/visit_type_inline.h"
+
+namespace arrow {
+namespace compute {
+namespace internal {
+namespace {
+
+Status CumulativeSum(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+  const ArrayData& array = *batch[0].array();
+  ArrayData* output = out->array().get();
+  output->length = array.length;
+  
+  return Status::OK();
+}
+
+void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
+
+}
+
+}
+
+}  // namespace internal
+}  // namespace compute
+}  // namespace arrow
\ No newline at end of file

From 067f846b1cc12b67e596a3823ff158e690fc7043 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 24 Feb 2022 21:28:55 -0500
Subject: [PATCH 02/67] Now made a scalar function; Created struct to hold exec
 and kernel signature generation

---
 .../compute/kernels/scalar_cumulative_sum.cc  | 88 +++++++++++++++++++
 .../compute/kernels/vector_cumulative_sum.cc  | 44 ----------
 2 files changed, 88 insertions(+), 44 deletions(-)
 create mode 100644 cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
 delete mode 100644 cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc

diff --git a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
new file mode 100644
index 00000000000..cbd8ed3c416
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
@@ -0,0 +1,88 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/array/array_base.h"
+#include "arrow/compute/kernels/common.h"
+#include "arrow/result.h"
+#include "arrow/visit_type_inline.h"
+
+namespace arrow {
+namespace compute {
+namespace internal {
+namespace {
+
+template <typename Type>
+struct CumulativeSumFunctor {
+  Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    using CType = TypeTraits<Type>::CType;
+    
+    const ArrayData& array = *batch[0].array();
+    auto data = array.GetValues<CType*>(1, array.offset);
+
+    const NumericScalar& start = checked_cast<const NumericScalar&>(*batch[1].scalar());
+    CType sum = start.value;
+
+    ArrayData* output = out->array().get();
+    CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
+    output->length = array.length;
+
+    for(size_t i = array.offset; i < array.length; ++i) {
+      sum += data[i];
+      out_values[i] = sum;
+    }
+    
+    return Status::OK();
+  }
+
+  static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
+    return KernelSignature::Make(
+        {InputType::Array(get_id.id), InputType::Scalar(get_id.id), OutputType(FirstType));
+  }
+};
+
+const FunctionDoc cumulative_sum_doc(
+    "Compute the cumulative sum of an array",
+    ("Return an array containing the result of the cumulative sum\n"
+     "computed over the input array"),
+    {"values", "starting sum"});
+
+void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
+
+  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
+    ScalarKernel kernel;
+    kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
+    kernel.signature = CumulativeSumFunctor<NumberType>::GetSignature(get_id.id);
+    kernel.exec = std::move(exec);
+    DCHECK_OK(func->AddKernel(std::move(kernel)));
+  };
+
+  auto cumulative_sum =
+      std::make_shared<ScalarFunction>("cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
+  
+  for(auto ty : NumericTypes()) {
+    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSumFunctor>(ty));
+  }
+
+  DCHECK_OK(registry->AddFunction(std::move(flatten)));
+  
+}
+
+}
+
+}  // namespace internal
+}  // namespace compute
+}  // namespace arrow
\ No newline at end of file
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
deleted file mode 100644
index 9add6c7d2bd..00000000000
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include "arrow/array/array_base.h"
-#include "arrow/compute/kernels/common.h"
-#include "arrow/result.h"
-#include "arrow/visit_type_inline.h"
-
-namespace arrow {
-namespace compute {
-namespace internal {
-namespace {
-
-Status CumulativeSum(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-  const ArrayData& array = *batch[0].array();
-  ArrayData* output = out->array().get();
-  output->length = array.length;
-  
-  return Status::OK();
-}
-
-void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-
-}
-
-}
-
-}  // namespace internal
-}  // namespace compute
-}  // namespace arrow
\ No newline at end of file

From a747cb45884a1524e41d86abaf18f5a65dcfebc7 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 1 Mar 2022 23:13:12 -0500
Subject: [PATCH 03/67] Changed handle chunked arrays and arrays with null
 indicies

---
 .../compute/kernels/scalar_cumulative_sum.cc  | 119 +++++++++++++-----
 1 file changed, 89 insertions(+), 30 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
index cbd8ed3c416..d02194b5dc6 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
@@ -25,44 +25,103 @@ namespace compute {
 namespace internal {
 namespace {
 
+template <typename CType>
+CType CumulativeSum(std::shared_ptr<Array>& input, ArrayData* output, CType start) {
+  CType sum = start;
+  CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
+  CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
+  for (size_t i = input->offset; i < input->length; ++i) {
+    if (input->IsValid(i)) {
+      sum += data[i];
+      out_values[i] = sum;
+    }
+  }
+
+  return sum;
+}
+
 template <typename Type>
 struct CumulativeSumFunctor {
+  using CType = TypeTraits<Type>::CType;
+
   Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    using CType = TypeTraits<Type>::CType;
-    
-    const ArrayData& array = *batch[0].array();
-    auto data = array.GetValues<CType*>(1, array.offset);
+    const NumericScalar& start_scalar =
+        checked_cast<const NumericScalar&>(*batch[1].scalar());
+    CType start = start_scalar.value;
 
-    const NumericScalar& start = checked_cast<const NumericScalar&>(*batch[1].scalar());
-    CType sum = start.value;
+    switch (batch[0].kind()) {
+      case Datum::ARRAY:
+        std::shared_ptr<Array> input = batch[0].make_array();
+        ArrayData* output = out->array().get();
 
-    ArrayData* output = out->array().get();
-    CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
-    output->length = array.length;
+        output->length = input->data()->length;
+        *output->type = std::move(input->type());
+        uint8_t* out_bitmap = output->buffers[0]->mutable_data();
+        int64_t out_offset = input->offset();
 
-    for(size_t i = array.offset; i < array.length; ++i) {
-      sum += data[i];
-      out_values[i] = sum;
+        if (input->data()->MayHaveNulls()) {
+          arrow::internal::CopyBitmap(input->null_bitmap_data(), input->offset(),
+                                      input->length(), out_bitmap, out_offset);
+          output->null_count = input->null_count();
+        } else {
+          bit_util::SetBitsTo(out_bitmap, out_offset, input->length(), true);
+          output->null_count = 0;
+        }
+
+        CumulativeSum(input, output, start);
+        return Status::OK();
+      case Datum::CHUNKED_ARRAY:
+        const auto& input = batch[0].chunked_array();
+
+        ArrayVector out_chunks;
+        for (const auto& chunk : input->chunks()) {
+          auto out_chunk = std::make_shared<ArrayData>(
+              chunk->type(), chunk->length(), chunk->null_count(), chunk->offset());
+
+          uint8_t* out_chunk_bitmap = out_chunk->buffers[0]->mutable_data();
+          if (chunk->data()->MayHaveNulls()) {
+            arrow::internal::CopyBitmap(chunk->null_bitmap_data(), chunk->offset(),
+                                        chunk->length(), out_chunk_bitmap,
+                                        out_chunk->offset());
+            out_chunk->null_count = chunk->null_count();
+          } else {
+            bit_util::SetBitsTo(out_chunk_bitmap, out_chunk->offset(), chunk->length(),
+                                true);
+            out_chunk->null_count = 0;
+          }
+
+          CType last_value = CumulativeSum(chunk, out_chunk, start);
+          start = last_value;
+          out_chunks.push_back(MakeArray(std::move(out_chunk)));
+        }
+
+        *out->chunked_array() = ChunkedArray(out_chunks, input->type());
+        return Status::OK();
+      default:
+        return Status::NotImplemented(
+            "Unsupported input type for function 'cumulative_sum': ",
+            batch[0].ToString());
     }
-    
-    return Status::OK();
   }
 
   static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
     return KernelSignature::Make(
-        {InputType::Array(get_id.id), InputType::Scalar(get_id.id), OutputType(FirstType));
+        {InputType::Array(get_id.id), InputType::Scalar(get_id.id)},
+        OutputType(FirstType));
   }
 };
 
 const FunctionDoc cumulative_sum_doc(
-    "Compute the cumulative sum of an array",
-    ("Return an array containing the result of the cumulative sum\n"
-     "computed over the input array"),
-    {"values", "starting sum"});
+    "Compute the cumulative sum over an array of numbers",
+    ("`values` must be an array of numeric type values.\n"
+     "`start` is a single value of the same type.\n"
+     "Return an array which is the cumulative sum computed over `values`\n"
+     "`start` is an optional starting sum of computation."),
+    {"values", "start"});
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-
-  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
+  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec,
+                        std::shared_ptr<ScalarFunction> func) {
     ScalarKernel kernel;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = CumulativeSumFunctor<NumberType>::GetSignature(get_id.id);
@@ -70,19 +129,19 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     DCHECK_OK(func->AddKernel(std::move(kernel)));
   };
 
-  auto cumulative_sum =
-      std::make_shared<ScalarFunction>("cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
-  
-  for(auto ty : NumericTypes()) {
-    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSumFunctor>(ty));
+  auto cumulative_sum = std::make_shared<ScalarFunction>(
+      "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
+
+  for (auto ty : NumericTypes()) {
+    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSumFunctor>(ty),
+               cumulative_sum);
   }
 
-  DCHECK_OK(registry->AddFunction(std::move(flatten)));
-  
+  DCHECK_OK(registry->AddFunction(std::move(cumulative_sum)));
 }
 
-}
+}  // namespace
 
 }  // namespace internal
 }  // namespace compute
-}  // namespace arrow
\ No newline at end of file
+}  // namespace arrow

From 30984e1a0f3e5271f1508ba16548f9b5a6d8f76f Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 3 Mar 2022 23:56:42 -0500
Subject: [PATCH 04/67] Changed to vector function, starting creation
 corresponding test, included suggested changes

---
 ...lative_sum.cc => vector_cumulative_sum.cc} | 81 +++++++++++--------
 .../kernels/vector_cumulative_sum_test.cc     | 54 +++++++++++++
 cpp/src/arrow/compute/registry.cc             |  1 +
 cpp/src/arrow/compute/registry_internal.h     |  1 +
 4 files changed, 103 insertions(+), 34 deletions(-)
 rename cpp/src/arrow/compute/kernels/{scalar_cumulative_sum.cc => vector_cumulative_sum.cc} (70%)
 create mode 100644 cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc

diff --git a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
similarity index 70%
rename from cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
rename to cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index d02194b5dc6..cff80f886c0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include "arrow/array/array_base.h"
+#include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/result.h"
 #include "arrow/visit_type_inline.h"
@@ -23,30 +24,34 @@
 namespace arrow {
 namespace compute {
 namespace internal {
-namespace {
-
-template <typename CType>
-CType CumulativeSum(std::shared_ptr<Array>& input, ArrayData* output, CType start) {
-  CType sum = start;
-  CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
-  CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
-  for (size_t i = input->offset; i < input->length; ++i) {
-    if (input->IsValid(i)) {
-      sum += data[i];
-      out_values[i] = sum;
-    }
-  }
-
-  return sum;
-}
 
 template <typename Type>
-struct CumulativeSumFunctor {
+struct CumulativeSum {
   using CType = TypeTraits<Type>::CType;
+  using ScalarType = TypeTraits<Type>::ScalarType;
+
+  CType Sum(ExecContext* ctx, std::shared_ptr<Array>& input, ArrayData* output,
+            CType start) {
+    CType sum = start;
+    CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
+    CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
+    ArithmeticOptions options;
+    for (size_t i = input->offset; i < input->length; ++i) {
+      if (input->IsValid(i)) {
+        Datum value_datum(data[i]);
+        Datum sum_datum(sum);
+        auto result = Add(value_datum, sum_datum, options, ctx);
+        ScalarType result_scalar = result.ValueOrDie().scalar_as();
+        sum = result_scalar.value;
+        out_values[i] = sum;
+      }
+    }
+
+    return sum;
+  }
 
   Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const NumericScalar& start_scalar =
-        checked_cast<const NumericScalar&>(*batch[1].scalar());
+    const ScalarType& start_scalar = checked_cast<const ScalarType&>(*batch[1].scalar());
     CType start = start_scalar.value;
 
     switch (batch[0].kind()) {
@@ -68,7 +73,7 @@ struct CumulativeSumFunctor {
           output->null_count = 0;
         }
 
-        CumulativeSum(input, output, start);
+        Sum(ctx->exec_context(), input, output, start);
         return Status::OK();
       case Datum::CHUNKED_ARRAY:
         const auto& input = batch[0].chunked_array();
@@ -90,7 +95,7 @@ struct CumulativeSumFunctor {
             out_chunk->null_count = 0;
           }
 
-          CType last_value = CumulativeSum(chunk, out_chunk, start);
+          CType last_value = Sum(ctx->exec_context(), chunk, out_chunk, start);
           start = last_value;
           out_chunks.push_back(MakeArray(std::move(out_chunk)));
         }
@@ -115,33 +120,41 @@ const FunctionDoc cumulative_sum_doc(
     "Compute the cumulative sum over an array of numbers",
     ("`values` must be an array of numeric type values.\n"
      "`start` is a single value of the same type.\n"
-     "Return an array which is the cumulative sum computed over `values`\n"
+     "Return an array which is the cumulative sum computed over `values.`\n"
+     "Null entries remain in place but are not used in calucating sum.\n"
      "`start` is an optional starting sum of computation."),
     {"values", "start"});
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec,
-                        std::shared_ptr<ScalarFunction> func) {
-    ScalarKernel kernel;
+  auto cumulative_sum = std::make_shared<VectorFunction>(
+      "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
+
+  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
+    VectorKernel kernel;
+    kernel.can_execute_chunkwise = true;
+    kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = CumulativeSumFunctor<NumberType>::GetSignature(get_id.id);
+    kernel.signature = CumulativeSum<NumberType>::GetSignature(get_id.id);
     kernel.exec = std::move(exec);
-    DCHECK_OK(func->AddKernel(std::move(kernel)));
+    DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   };
 
-  auto cumulative_sum = std::make_shared<ScalarFunction>(
-      "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
-
   for (auto ty : NumericTypes()) {
-    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSumFunctor>(ty),
-               cumulative_sum);
+    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
   }
 
+  for (auto ty : TemporalTypes()) {
+    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
+  }
+
+  add_kernel(Type::DURATION,
+             GenerateTypeAgnosticPrimitive<CumulativeSum>(Type::DURATION));
+  add_kernel(Type::INTERVAL_MONTHS,
+             GenerateTypeAgnosticPrimitive<CumulativeSum>(Type::INTERVAL_MONTHS));
+
   DCHECK_OK(registry->AddFunction(std::move(cumulative_sum)));
 }
 
-}  // namespace
-
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
new file mode 100644
index 00000000000..dfeb492cb70
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -0,0 +1,54 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <locale>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "arrow/array.h"
+#include "arrow/array/builder_decimal.h"
+#include "arrow/buffer.h"
+#include "arrow/chunked_array.h"
+#include "arrow/status.h"
+#include "arrow/testing/util.h"
+#include "arrow/type.h"
+#include "arrow/type_fwd.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/checked_cast.h"
+#include "arrow/util/decimal.h"
+
+#include "arrow/compute/api.h"
+#include "arrow/compute/kernels/test_util.h"
+
+#include "arrow/ipc/json_simple.h"
+
+namespace arrow {
+namespace compute {
+
+class TestBaseCumulativeSum : public ::testing::Test {}
+
+}  // namespace compute
+}  // namespace arrow
diff --git a/cpp/src/arrow/compute/registry.cc b/cpp/src/arrow/compute/registry.cc
index 8ab83a72e5e..7e1975d3b68 100644
--- a/cpp/src/arrow/compute/registry.cc
+++ b/cpp/src/arrow/compute/registry.cc
@@ -174,6 +174,7 @@ static std::unique_ptr<FunctionRegistry> CreateBuiltInRegistry() {
 
   // Vector functions
   RegisterVectorArraySort(registry.get());
+  RegisterVectorCumulativeSum(registry.get());
   RegisterVectorHash(registry.get());
   RegisterVectorNested(registry.get());
   RegisterVectorReplace(registry.get());
diff --git a/cpp/src/arrow/compute/registry_internal.h b/cpp/src/arrow/compute/registry_internal.h
index 35f7b079529..38f81e98889 100644
--- a/cpp/src/arrow/compute/registry_internal.h
+++ b/cpp/src/arrow/compute/registry_internal.h
@@ -43,6 +43,7 @@ void RegisterScalarOptions(FunctionRegistry* registry);
 
 // Vector functions
 void RegisterVectorArraySort(FunctionRegistry* registry);
+void RegisterVectorCumulativeSum(FunctionRegistry* registry);
 void RegisterVectorHash(FunctionRegistry* registry);
 void RegisterVectorNested(FunctionRegistry* registry);
 void RegisterVectorReplace(FunctionRegistry* registry);

From 59fad235b9fa4f9c8384f82cd9f75ca6858d3077 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 8 Mar 2022 23:57:56 -0500
Subject: [PATCH 05/67] Starting value is now part of options; working more
 adding new test

---
 cpp/src/arrow/compute/api_vector.cc           | 23 +++++++++++++++++++
 cpp/src/arrow/compute/api_vector.h            | 21 +++++++++++++++++
 cpp/src/arrow/compute/kernels/CMakeLists.txt  |  1 +
 .../compute/kernels/vector_cumulative_sum.cc  |  9 ++++----
 docs/source/python/api/compute.rst            |  2 ++
 python/pyarrow/_compute.pyx                   | 20 ++++++++++++++++
 python/pyarrow/includes/libarrow.pxd          |  5 ++++
 python/pyarrow/tests/test_compute.py          |  1 +
 8 files changed, 77 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index a5cb61d6b55..c624ec0d942 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -135,6 +135,8 @@ static auto kPartitionNthOptionsType = GetFunctionOptionsType<PartitionNthOption
 static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
+static auto kCumulativeSumOptionsType = GetFunctionOptionsType<CumulativeSumOptions>(
+    DataMember("start", &CumulativeSumOptions::start));
 }  // namespace
 }  // namespace internal
 
@@ -176,6 +178,10 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
+CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start)
+    : FunctionOptions(internal::kCumulativeSumOptionsType), start(std::move(start)) {}
+constexpr char CumulativeSumOptions::kTypeName[];
+
 namespace internal {
 void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kFilterOptionsType));
@@ -185,6 +191,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kSortOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPartitionNthOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSelectKOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kCumulativeSumOptionsType));
 }
 }  // namespace internal
 
@@ -325,6 +332,22 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
   return out.make_array();
 }
 
+Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
+                                             CumulativeSumOptions& options,
+                                             ExecContext* ctx) {
+  ARROW_ASSIGN_OR_RAISE(Datum out,
+                        CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
+  return out.make_array();
+}
+
+Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
+                                             CumulativeSumOptions& options,
+                                             ExecContext* ctx) {
+  ARROW_ASSIGN_OR_RAISE(
+      Datum out, CallFunction("cumulative_sum", {Datum(chunked_array)}, &options, ctx));
+  return out.make_array();
+}
+
 // ----------------------------------------------------------------------
 // Deprecated functions
 
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 9e53cfcf640..02cd0764469 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -188,6 +188,17 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
   NullPlacement null_placement;
 };
 
+/// \brief Options for cumulative sum function
+class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
+ public:
+  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start);
+  CumulativeSumOptions() : CumulativeSumOptions(std::make_shared<NullScalar>()) {}
+  static constexpr char const kTypeName[] = "CumulativeSumOptions";
+
+  /// Optional starting value for sum computation
+  std::shared_ptr<Scalar> start;
+};
+
 /// @}
 
 /// \brief Filter with a boolean selection filter
@@ -522,6 +533,16 @@ Result<Datum> DictionaryEncode(
     const DictionaryEncodeOptions& options = DictionaryEncodeOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
+ARROW_EXPORT
+Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
+                                             CumulativeSumOptions& options,
+                                             ExecContext* ctx = NULLPTR);
+
+ARROW_EXPORT
+Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
+                                             CumulativeSumOptions& options,
+                                             ExecContext* ctx = NULLPTR);
+
 // ----------------------------------------------------------------------
 // Deprecated functions
 
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 93a02cdb1f1..7659a5b5490 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -47,6 +47,7 @@ add_arrow_benchmark(scalar_string_benchmark PREFIX "arrow-compute")
 
 add_arrow_compute_test(vector_test
                        SOURCES
+                       vector_cumulative_sum_test.cc
                        vector_hash_test.cc
                        vector_nested_test.cc
                        vector_replace_test.cc
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index cff80f886c0..b3528c754d8 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -51,8 +51,8 @@ struct CumulativeSum {
   }
 
   Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const ScalarType& start_scalar = checked_cast<const ScalarType&>(*batch[1].scalar());
-    CType start = start_scalar.value;
+    const auto& options = OptionsWrapper<CumulativeSumOptions<CType>>::Get(ctx);
+    CType start = checked_cast<const ScalarType&>(options.start).value;
 
     switch (batch[0].kind()) {
       case Datum::ARRAY:
@@ -110,9 +110,7 @@ struct CumulativeSum {
   }
 
   static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
-    return KernelSignature::Make(
-        {InputType::Array(get_id.id), InputType::Scalar(get_id.id)},
-        OutputType(FirstType));
+    return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
   }
 };
 
@@ -136,6 +134,7 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = CumulativeSum<NumberType>::GetSignature(get_id.id);
     kernel.exec = std::move(exec);
+    kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   };
 
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index 579c4dad808..df43bd5e8e0 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -479,6 +479,7 @@ Structural Transforms
 .. autosummary::
    :toctree: ../generated/
 
+   cumulative_sum
    fill_null_backward
    fill_null_forward
    list_element
@@ -501,6 +502,7 @@ Compute Options
    CastOptions
    CountOptions
    CountOptions
+   CumulativeSumOptions
    DayOfWeekOptions
    DictionaryEncodeOptions
    ElementWiseAggregateOptions
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 2f18ab99866..75bd819d52f 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1736,6 +1736,26 @@ class PartitionNthOptions(_PartitionNthOptions):
         self._set_options(pivot, null_placement)
 
 
+cdef class _CumulativeSumOptions(FunctionOptions):
+    def _set_options(self, start):
+        self.wrapped.reset(new CCumulativeSumOptions(
+            pyarrow_unwrap_scalar(start)))
+
+
+class CumulativeSumOptions(_CumulativeSumOptions):
+    """
+    Options for `cumulative_sum` function.
+
+    Parameters
+    ----------
+    start : Scalar
+        Optional starting value for sum computation
+    """
+
+    def __init__(self, start):
+        self._set_options(start)
+
+
 cdef class _ArraySortOptions(FunctionOptions):
     def _set_options(self, order, null_placement):
         self.wrapped.reset(new CArraySortOptions(
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 6246a15fcff..6b370515399 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2243,6 +2243,11 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         int64_t pivot
         CNullPlacement null_placement
 
+    cdef cppclass CCumulativeSumOptions \
+            "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
+        CCumulativeSumOptions(shared_ptr[CScalar] start)
+        shared_ptr[CScalar] start
+
     cdef cppclass CArraySortOptions \
             "arrow::compute::ArraySortOptions"(CFunctionOptions):
         CArraySortOptions(CSortOrder, CNullPlacement)
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 46d302c214c..12791a9caea 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -147,6 +147,7 @@ def test_option_class_equality():
         pc.NullOptions(),
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
+        pc.CumulativeSumOptions(pa.scalar(0)),
         pc.QuantileOptions(),
         pc.RandomOptions(10),
         pc.ReplaceSliceOptions(0, 1, "a"),

From 93644f874f395542d26f83922f30b7cd3ed4d026 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 9 Mar 2022 12:22:19 -0500
Subject: [PATCH 06/67] Minor changes to cumulative sum kernel

---
 cpp/src/arrow/compute/api_vector.h            |  2 +-
 .../compute/kernels/vector_cumulative_sum.cc  | 38 ++++++++++---------
 2 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 02cd0764469..d2d825d91fb 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -192,7 +192,7 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
   explicit CumulativeSumOptions(std::shared_ptr<Scalar> start);
-  CumulativeSumOptions() : CumulativeSumOptions(std::make_shared<NullScalar>()) {}
+  CumulativeSumOptions() : CumulativeSumOptions(nullptr) {}
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
 
   /// Optional starting value for sum computation
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index b3528c754d8..03a987d9be7 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -16,7 +16,7 @@
 // under the License.
 
 #include "arrow/array/array_base.h"
-#include "arrow/compute/api_scalar.h"
+#include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/result.h"
 #include "arrow/visit_type_inline.h"
@@ -52,7 +52,16 @@ struct CumulativeSum {
 
   Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<CumulativeSumOptions<CType>>::Get(ctx);
-    CType start = checked_cast<const ScalarType&>(options.start).value;
+    std::shared_ptr<Scalar>& start_scalar = options.start;
+    CType start = 0;
+    if (start_scalar) {
+      if (start_scalar->is_valid()) {
+        if (start_scalar->type()->id() != TypeTraits<Type>::type_singleton()->id()) {
+          return Status::Invalid("Types of array values and starting value do not match.");
+        }
+        start = UnboxScalar<Type>::Unbox(*start_scalar);
+      }
+    }
 
     switch (batch[0].kind()) {
       case Datum::ARRAY:
@@ -127,30 +136,23 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto cumulative_sum = std::make_shared<VectorFunction>(
       "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
 
-  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
+  std::vector<detail::GetTypeId> types;
+  types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
+  types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
+  types.push_back(Type::DURATION);
+  types.push_back(Type::INTERVAL_MONTHS);
+
+  for (auto ty : types) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = true;
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = CumulativeSum<NumberType>::GetSignature(get_id.id);
-    kernel.exec = std::move(exec);
+    kernel.signature = CumulativeSum<NumberType>::GetSignature(ty.id);
+    kernel.exec = std::move(GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
-  };
-
-  for (auto ty : NumericTypes()) {
-    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
-  }
-
-  for (auto ty : TemporalTypes()) {
-    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
   }
 
-  add_kernel(Type::DURATION,
-             GenerateTypeAgnosticPrimitive<CumulativeSum>(Type::DURATION));
-  add_kernel(Type::INTERVAL_MONTHS,
-             GenerateTypeAgnosticPrimitive<CumulativeSum>(Type::INTERVAL_MONTHS));
-
   DCHECK_OK(registry->AddFunction(std::move(cumulative_sum)));
 }
 

From dd45c3daf02c55c0fe9d85b4af4674211cb2ac6d Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 18 Mar 2022 14:48:07 -0400
Subject: [PATCH 07/67] Added option for skipping nulls

---
 cpp/src/arrow/CMakeLists.txt                  |  1 +
 cpp/src/arrow/compute/api_vector.cc           | 22 +++++--
 cpp/src/arrow/compute/api_vector.h            | 15 +++--
 .../compute/kernels/vector_cumulative_sum.cc  | 63 ++++++++++++-------
 .../kernels/vector_cumulative_sum_test.cc     | 19 +++++-
 python/pyarrow/_compute.pyx                   | 10 +--
 python/pyarrow/includes/libarrow.pxd          |  3 +-
 python/pyarrow/tests/test_compute.py          |  2 +-
 8 files changed, 98 insertions(+), 37 deletions(-)

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index e9e826097b3..de67503ad0c 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -436,6 +436,7 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_validity.cc
        compute/kernels/util_internal.cc
        compute/kernels/vector_array_sort.cc
+       compute/kernels/vector_cumulative_sum.cc
        compute/kernels/vector_hash.cc
        compute/kernels/vector_nested.cc
        compute/kernels/vector_replace.cc
diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index c624ec0d942..261bb3a2dd1 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -136,7 +136,8 @@ static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
 static auto kCumulativeSumOptionsType = GetFunctionOptionsType<CumulativeSumOptions>(
-    DataMember("start", &CumulativeSumOptions::start));
+    DataMember("start", &CumulativeSumOptions::start),
+    DataMember("skip_nulls", &CumulativeSumOptions::skip_nulls));
 }  // namespace
 }  // namespace internal
 
@@ -178,8 +179,19 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start)
-    : FunctionOptions(internal::kCumulativeSumOptionsType), start(std::move(start)) {}
+CumulativeSumOptions::CumulativeSumOptions(uint64_t start, bool skip_nulls)
+    : CumulativeSumOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
+
+CumulativeSumOptions::CumulativeSumOptions(int64_t start, bool skip_nulls)
+    : CumulativeSumOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
+
+CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls)
+    : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
+
+CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
+    : FunctionOptions(internal::kCumulativeSumOptionsType),
+      start(std::move(start)),
+      skip_nulls(skip_nulls) {}
 constexpr char CumulativeSumOptions::kTypeName[];
 
 namespace internal {
@@ -333,7 +345,7 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
 }
 
 Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
-                                             CumulativeSumOptions& options,
+                                             const CumulativeSumOptions& options,
                                              ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(Datum out,
                         CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
@@ -341,7 +353,7 @@ Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
 }
 
 Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
-                                             CumulativeSumOptions& options,
+                                             const CumulativeSumOptions& options,
                                              ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(
       Datum out, CallFunction("cumulative_sum", {Datum(chunked_array)}, &options, ctx));
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index d2d825d91fb..74bd9893b00 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,12 +191,19 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start);
-  CumulativeSumOptions() : CumulativeSumOptions(nullptr) {}
+  explicit CumulativeSumOptions(uint64_t start = 0, bool skip_nulls = false);
+  explicit CumulativeSumOptions(int64_t start = 0, bool skip_nulls = false);
+  explicit CumulativeSumOptions(double start = 0, bool skip_nulls = false);
+  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = nullptr,
+                                bool skip_nulls = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
+  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(nullptr); }
 
   /// Optional starting value for sum computation
   std::shared_ptr<Scalar> start;
+
+  /// When false, propagates the first null/NaN encountered
+  bool skip_nulls = false;
 };
 
 /// @}
@@ -535,12 +542,12 @@ Result<Datum> DictionaryEncode(
 
 ARROW_EXPORT
 Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
-                                             CumulativeSumOptions& options,
+                                             const CumulativeSumOptions& options,
                                              ExecContext* ctx = NULLPTR);
 
 ARROW_EXPORT
 Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
-                                             CumulativeSumOptions& options,
+                                             const CumulativeSumOptions& options,
                                              ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index 03a987d9be7..fc74a3b412c 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include "arrow/array/array_base.h"
+#include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/result.h"
@@ -25,23 +26,37 @@ namespace arrow {
 namespace compute {
 namespace internal {
 
+namespace {
+
+std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
+  return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
+}
+
+}  // namespace
+
 template <typename Type>
 struct CumulativeSum {
-  using CType = TypeTraits<Type>::CType;
-  using ScalarType = TypeTraits<Type>::ScalarType;
+  using CType = typename TypeTraits<Type>::CType;
+  using ScalarType = typename TypeTraits<Type>::ScalarType;
 
   CType Sum(ExecContext* ctx, std::shared_ptr<Array>& input, ArrayData* output,
-            CType start) {
+            CType start, bool skip_nulls) {
     CType sum = start;
     CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
     CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
     ArithmeticOptions options;
-    for (size_t i = input->offset; i < input->length; ++i) {
-      if (input->IsValid(i)) {
+    bool set_null = false;
+    for (size_t i = input->offset; i < input->length(); ++i) {
+      if (set_null) {
+        out_values[i] = NULL;
+      } else if (input->IsNull(i) && !skip_nulls) {
+        out_values[i] = NULL;
+        set_null = true;
+      } else {
         Datum value_datum(data[i]);
         Datum sum_datum(sum);
         auto result = Add(value_datum, sum_datum, options, ctx);
-        ScalarType result_scalar = result.ValueOrDie().scalar_as();
+        ScalarType result_scalar = result.ValueOrDie().scalar_as<ScalarType>();
         sum = result_scalar.value;
         out_values[i] = sum;
       }
@@ -50,14 +65,17 @@ struct CumulativeSum {
     return sum;
   }
 
-  Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const auto& options = OptionsWrapper<CumulativeSumOptions<CType>>::Get(ctx);
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    const auto& options = OptionsWrapper<CumulativeSumOptions>::Get(ctx);
     std::shared_ptr<Scalar>& start_scalar = options.start;
+    bool skip_nulls = options.skip_nulls;
+
     CType start = 0;
     if (start_scalar) {
       if (start_scalar->is_valid()) {
         if (start_scalar->type()->id() != TypeTraits<Type>::type_singleton()->id()) {
-          return Status::Invalid("Types of array values and starting value do not match.");
+          return Status::Invalid(
+              "Types of array values and starting value do not match.");
         }
         start = UnboxScalar<Type>::Unbox(*start_scalar);
       }
@@ -82,8 +100,9 @@ struct CumulativeSum {
           output->null_count = 0;
         }
 
-        Sum(ctx->exec_context(), input, output, start);
+        Sum(ctx->exec_context(), input, output, start, skip_nulls);
         return Status::OK();
+        break;
       case Datum::CHUNKED_ARRAY:
         const auto& input = batch[0].chunked_array();
 
@@ -104,23 +123,21 @@ struct CumulativeSum {
             out_chunk->null_count = 0;
           }
 
-          CType last_value = Sum(ctx->exec_context(), chunk, out_chunk, start);
+          CType last_value =
+              Sum(ctx->exec_context(), chunk, out_chunk, start, skip_nulls);
           start = last_value;
           out_chunks.push_back(MakeArray(std::move(out_chunk)));
         }
 
         *out->chunked_array() = ChunkedArray(out_chunks, input->type());
         return Status::OK();
+        break;
       default:
         return Status::NotImplemented(
             "Unsupported input type for function 'cumulative_sum': ",
             batch[0].ToString());
     }
   }
-
-  static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
-    return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
-  }
 };
 
 const FunctionDoc cumulative_sum_doc(
@@ -136,18 +153,22 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto cumulative_sum = std::make_shared<VectorFunction>(
       "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
 
-  std::vector<detail::GetTypeId> types;
-  types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
+  std::vector<std::shared_ptr<DataType>> types;
+  types.insert(types.end(), IntTypes().begin(), IntTypes().end());
+  types.insert(types.end(), FloatingPointTypes().begin(), IntTypes().end());
   types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
-  types.push_back(Type::DURATION);
-  types.push_back(Type::INTERVAL_MONTHS);
+  types.push_back(duration(TimeUnit::SECOND));
+  types.push_back(duration(TimeUnit::MILLI));
+  types.push_back(duration(TimeUnit::MICRO));
+  types.push_back(duration(TimeUnit::NANO));
+  types.push_back(month_interval());
 
   for (auto ty : types) {
     VectorKernel kernel;
-    kernel.can_execute_chunkwise = true;
+    kernel.can_execute_chunkwise = false;
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = CumulativeSum<NumberType>::GetSignature(ty.id);
+    kernel.signature = GetSignature(ty->id());
     kernel.exec = std::move(GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
index dfeb492cb70..825ff83174d 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -32,6 +32,7 @@
 #include "arrow/array/builder_decimal.h"
 #include "arrow/buffer.h"
 #include "arrow/chunked_array.h"
+#include "arrow/compute/api_vector.h"
 #include "arrow/status.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
@@ -48,7 +49,23 @@
 namespace arrow {
 namespace compute {
 
-class TestBaseCumulativeSum : public ::testing::Test {}
+template <typename Type>
+class TestBaseCumulativeSum : public ::testing::Test {
+  using CType = TypeTraits<Type>::CType;
+
+  void AssertValidCumulativeSum(const Array& input, CumulativeSumOptions options) {
+    ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
+  }
+};
+
+template <typename T>
+class TestIntegerCumulativeSum : public TestBaseCumulativeSum<T> {};
+
+template <typename T>
+class TestFloatingPointCumulativeSum : public TestBaseCumulativeSum<T> {};
+
+template <typename T>
+class TestTemporalCumulativeSum : public TestBaseCumulativeSum<T> {};
 
 }  // namespace compute
 }  // namespace arrow
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 75bd819d52f..dc9cd9dd372 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1737,9 +1737,9 @@ class PartitionNthOptions(_PartitionNthOptions):
 
 
 cdef class _CumulativeSumOptions(FunctionOptions):
-    def _set_options(self, start):
+    def _set_options(self, start, skip_nulls):
         self.wrapped.reset(new CCumulativeSumOptions(
-            pyarrow_unwrap_scalar(start)))
+            pyarrow_unwrap_scalar(start), skip_nulls))
 
 
 class CumulativeSumOptions(_CumulativeSumOptions):
@@ -1750,10 +1750,12 @@ class CumulativeSumOptions(_CumulativeSumOptions):
     ----------
     start : Scalar
         Optional starting value for sum computation
+    skip_nulls : bool
+        When false, propagates the first null/NaN encountered
     """
 
-    def __init__(self, start):
-        self._set_options(start)
+    def __init__(self, start=0, skip_nulls=false):
+        self._set_options(start, skip_nulls)
 
 
 cdef class _ArraySortOptions(FunctionOptions):
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 6b370515399..33c46e56b70 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2245,8 +2245,9 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
 
     cdef cppclass CCumulativeSumOptions \
             "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
-        CCumulativeSumOptions(shared_ptr[CScalar] start)
+        CCumulativeSumOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
         shared_ptr[CScalar] start
+        c_bool skip_nulls
 
     cdef cppclass CArraySortOptions \
             "arrow::compute::ArraySortOptions"(CFunctionOptions):
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 12791a9caea..14ca2355484 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -147,7 +147,7 @@ def test_option_class_equality():
         pc.NullOptions(),
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
-        pc.CumulativeSumOptions(pa.scalar(0)),
+        pc.CumulativeSumOptions(start=0, skip_nulls=False),
         pc.QuantileOptions(),
         pc.RandomOptions(10),
         pc.ReplaceSliceOptions(0, 1, "a"),

From 236d56bd7b5424f745f427de90d645dc5cf4af2a Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 22 Mar 2022 17:09:37 -0400
Subject: [PATCH 08/67] Fixed some errors; reworking addition for cumulative
 sum

---
 cpp/src/arrow/compute/api_vector.h            |  8 ++--
 .../compute/kernels/vector_cumulative_sum.cc  | 46 +++++++++++++++----
 .../kernels/vector_cumulative_sum_test.cc     | 35 ++++++++++----
 3 files changed, 67 insertions(+), 22 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 74bd9893b00..5742871fd64 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,13 +191,13 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  explicit CumulativeSumOptions(uint64_t start = 0, bool skip_nulls = false);
-  explicit CumulativeSumOptions(int64_t start = 0, bool skip_nulls = false);
-  explicit CumulativeSumOptions(double start = 0, bool skip_nulls = false);
+  explicit CumulativeSumOptions(uint64_t start, bool skip_nulls = false);
+  explicit CumulativeSumOptions(int64_t start, bool skip_nulls = false);
+  explicit CumulativeSumOptions(double start, bool skip_nulls = false);
   explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = nullptr,
                                 bool skip_nulls = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
-  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(nullptr); }
+  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
 
   /// Optional starting value for sum computation
   std::shared_ptr<Scalar> start;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index fc74a3b412c..1df2bcf95e4 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -28,6 +28,31 @@ namespace internal {
 
 namespace {
 
+struct Add {
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                                    Status*) {
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                            Arg1 right, Status*) {
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                          Arg1 right, Status*) {
+    return arrow::internal::SafeSignedAdd(left, right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + right;
+  }
+};
+
 std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
   return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
 }
@@ -46,18 +71,19 @@ struct CumulativeSum {
     CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
     ArithmeticOptions options;
     bool set_null = false;
-    for (size_t i = input->offset; i < input->length(); ++i) {
+    for (size_t i = input->offset(); i < input->length(); ++i) {
       if (set_null) {
         out_values[i] = NULL;
       } else if (input->IsNull(i) && !skip_nulls) {
         out_values[i] = NULL;
         set_null = true;
       } else {
-        Datum value_datum(data[i]);
-        Datum sum_datum(sum);
-        auto result = Add(value_datum, sum_datum, options, ctx);
-        ScalarType result_scalar = result.ValueOrDie().scalar_as<ScalarType>();
-        sum = result_scalar.value;
+        // Datum value_datum(data[i]);
+        // Datum sum_datum(sum);
+        // auto result = Add(value_datum, sum_datum, options, ctx);
+        // sum = result_scalar.value;
+
+        sum = Add::Call(data[i], sum);
         out_values[i] = sum;
       }
     }
@@ -82,7 +108,7 @@ struct CumulativeSum {
     }
 
     switch (batch[0].kind()) {
-      case Datum::ARRAY:
+      case Datum::ARRAY: {
         std::shared_ptr<Array> input = batch[0].make_array();
         ArrayData* output = out->array().get();
 
@@ -102,8 +128,8 @@ struct CumulativeSum {
 
         Sum(ctx->exec_context(), input, output, start, skip_nulls);
         return Status::OK();
-        break;
-      case Datum::CHUNKED_ARRAY:
+      }
+      case Datum::CHUNKED_ARRAY: {
         const auto& input = batch[0].chunked_array();
 
         ArrayVector out_chunks;
@@ -131,7 +157,7 @@ struct CumulativeSum {
 
         *out->chunked_array() = ChunkedArray(out_chunks, input->type());
         return Status::OK();
-        break;
+      }
       default:
         return Status::NotImplemented(
             "Unsupported input type for function 'cumulative_sum': ",
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
index 825ff83174d..8ad10be1da2 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -49,23 +49,42 @@
 namespace arrow {
 namespace compute {
 
+using IntegralTypes = testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type,
+                                     Int8Type, Int16Type, Int32Type, Int64Type>;
+
+using FloatingTypes = testing::Types<FloatType, DoubleType>;
+
+using TimeTypes = testing::Types<Date32Type, Date64Type, Time32Type, Time64Type,
+                                 TimestampType, DurationType, MonthIntervalType>;
+
 template <typename Type>
-class TestBaseCumulativeSum : public ::testing::Test {
+class TestCumulativeSum : public ::testing::Test {
   using CType = TypeTraits<Type>::CType;
 
-  void AssertValidCumulativeSum(const Array& input, CumulativeSumOptions options) {
+ protected:
+  CumulativeSumOptions no_start_no_skip_nulls();
+  CumulativeSumOptions has_start_no_skip_nulls(10);
+  CumulativeSumOptions no_start_skip_nulls(0, true);
+  CumulativeSumOptions has_start_skip_nulls(10, true);
+
+  void SetUp() override {}
+
+  void AssertValidCumulativeSum(const Array& expected, const Array& input,
+                                const CumulativeSumOptions options) {
     ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
+    AssertArraysEqual(expected, *result, false, EqualOptions::Defaults());
   }
 };
 
-template <typename T>
-class TestIntegerCumulativeSum : public TestBaseCumulativeSum<T> {};
+TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralTypes);
+TYPED_TEST_SUITE(TestCumulativeSumFloating, FloatingTypes);
+TYPED_TEST_SUITE(TestCumulativeSumTemporal, TimeTypes);
 
-template <typename T>
-class TestFloatingPointCumulativeSum : public TestBaseCumulativeSum<T> {};
+TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {}
+TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
+TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
+TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
 
-template <typename T>
-class TestTemporalCumulativeSum : public TestBaseCumulativeSum<T> {};
 
 }  // namespace compute
 }  // namespace arrow

From 19a9d05bad0d25f4951ea15c4e90a6ccf817393e Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 23 Mar 2022 14:29:17 -0400
Subject: [PATCH 09/67] Creating separate header for addition kernels

---
 .../kernels/base_arithmetic_internal.h        | 103 ++++++++++++++++++
 .../compute/kernels/scalar_arithmetic.cc      |  82 +-------------
 .../compute/kernels/vector_cumulative_sum.cc  |  26 +++++
 3 files changed, 130 insertions(+), 81 deletions(-)
 create mode 100644 cpp/src/arrow/compute/kernels/base_arithmetic_internal.h

diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
new file mode 100644
index 00000000000..899f26cd126
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#include "arrow/compute/api_scalar.h"
+#include "arrow/compute/kernels/common.h"
+#include "arrow/compute/kernels/util_internal.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/decimal.h"
+#include "arrow/util/int_util_internal.h"
+#include "arrow/util/macros.h"
+
+namespace arrow {
+
+using internal::AddWithOverflow;
+
+namespace compute {
+namespace internal {
+
+struct Add {
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                                    Status*) {
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                            Arg1 right, Status*) {
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                          Arg1 right, Status*) {
+    return arrow::internal::SafeSignedAdd(left, right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + right;
+  }
+};
+
+struct AddChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                          Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + right;
+  }
+};
+
+template <int64_t multiple>
+struct AddTimeDuration {
+  template <typename T, typename Arg0, typename Arg1>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
+    T result =
+        arrow::internal::SafeSignedAdd(static_cast<T>(left), static_cast<T>(right));
+    if (result < 0 || multiple <= result) {
+      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
+                            multiple, ") s");
+    }
+    return result;
+  }
+};
+
+template <int64_t multiple>
+struct AddTimeDurationChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(
+            AddWithOverflow(static_cast<T>(left), static_cast<T>(right), &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    if (result < 0 || multiple <= result) {
+      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
+                            multiple, ") s");
+    }
+    return result;
+  }
+};
+
+}  // namespace internal
+}  // namespace compute
+}  // namespace arrow
+
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index bfafb6fcc19..150cd3ead96 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -25,6 +25,7 @@
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/util_internal.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/decimal.h"
@@ -114,56 +115,6 @@ struct AbsoluteValueChecked {
   }
 };
 
-struct Add {
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                            Arg1 right, Status*) {
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                          Arg1 right, Status*) {
-    return arrow::internal::SafeSignedAdd(left, right);
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + right;
-  }
-};
-
-struct AddChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + right;
-  }
-};
-
 struct Subtract {
   template <typename T, typename Arg0, typename Arg1>
   static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
@@ -240,37 +191,6 @@ struct SubtractCheckedDate32 {
   }
 };
 
-template <int64_t multiple>
-struct AddTimeDuration {
-  template <typename T, typename Arg0, typename Arg1>
-  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
-    T result =
-        arrow::internal::SafeSignedAdd(static_cast<T>(left), static_cast<T>(right));
-    if (result < 0 || multiple <= result) {
-      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
-                            multiple, ") s");
-    }
-    return result;
-  }
-};
-
-template <int64_t multiple>
-struct AddTimeDurationChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(
-            AddWithOverflow(static_cast<T>(left), static_cast<T>(right), &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    if (result < 0 || multiple <= result) {
-      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
-                            multiple, ") s");
-    }
-    return result;
-  }
-};
-
 template <int64_t multiple>
 struct SubtractTimeDuration {
   template <typename T, typename Arg0, typename Arg1>
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index 1df2bcf95e4..bed009fbf88 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -19,6 +19,7 @@
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/common.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/result.h"
 #include "arrow/visit_type_inline.h"
 
@@ -28,6 +29,7 @@ namespace internal {
 
 namespace {
 
+
 struct Add {
   template <typename T, typename Arg0, typename Arg1>
   static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
@@ -53,6 +55,30 @@ struct Add {
   }
 };
 
+struct AddChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                          Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + right;
+  }
+};
 std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
   return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
 }

From 2c3722f10f0362c75c783199af241b3c1b1f95ad Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 24 Mar 2022 00:00:37 -0400
Subject: [PATCH 10/67] Creation of CumulativeMeta, simplification of
 CumulativeSum, and moving add kernel to new internal file

---
 .../arrow/compute/kernels/codegen_internal.h  |  31 +++
 .../compute/kernels/scalar_arithmetic.cc      |  32 ---
 .../compute/kernels/vector_cumulative_sum.cc  | 184 ++++--------------
 3 files changed, 65 insertions(+), 182 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index ff7b9161fe3..8eb5cba5d39 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -1134,6 +1134,37 @@ ArrayKernelExec GeneratePhysicalInteger(detail::GetTypeId get_id) {
   }
 }
 
+template <template <typename... Args> class KernelGenerator, typename Op>
+ArrayKernelExec ArithmeticExecFromOp(detail::GetTypeId get_id) {
+  switch (get_id.id) {
+    case Type::INT8:
+      return KernelGenerator<Int8Type, Int8Type, Op>::Exec;
+    case Type::UINT8:
+      return KernelGenerator<UInt8Type, UInt8Type, Op>::Exec;
+    case Type::INT16:
+      return KernelGenerator<Int16Type, Int16Type, Op>::Exec;
+    case Type::UINT16:
+      return KernelGenerator<UInt16Type, UInt16Type, Op>::Exec;
+    case Type::INT32:
+      return KernelGenerator<Int32Type, Int32Type, Op>::Exec;
+    case Type::UINT32:
+      return KernelGenerator<UInt32Type, UInt32Type, Op>::Exec;
+    case Type::DURATION:
+    case Type::INT64:
+    case Type::TIMESTAMP:
+      return KernelGenerator<Int64Type, Int64Type, Op>::Exec;
+    case Type::UINT64:
+      return KernelGenerator<UInt64Type, UInt64Type, Op>::Exec;
+    case Type::FLOAT:
+      return KernelGenerator<FloatType, FloatType, Op>::Exec;
+    case Type::DOUBLE:
+      return KernelGenerator<DoubleType, DoubleType, Op>::Exec;
+    default:
+      DCHECK(false);
+      return ExecFail;
+  }
+}
+
 template <template <typename... Args> class Generator, typename... Args>
 ArrayKernelExec GeneratePhysicalNumeric(detail::GetTypeId get_id) {
   switch (get_id.id) {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 150cd3ead96..26143f3749e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1500,38 +1500,6 @@ struct Trunc {
   }
 };
 
-// Generate a kernel given an arithmetic functor
-template <template <typename... Args> class KernelGenerator, typename Op>
-ArrayKernelExec ArithmeticExecFromOp(detail::GetTypeId get_id) {
-  switch (get_id.id) {
-    case Type::INT8:
-      return KernelGenerator<Int8Type, Int8Type, Op>::Exec;
-    case Type::UINT8:
-      return KernelGenerator<UInt8Type, UInt8Type, Op>::Exec;
-    case Type::INT16:
-      return KernelGenerator<Int16Type, Int16Type, Op>::Exec;
-    case Type::UINT16:
-      return KernelGenerator<UInt16Type, UInt16Type, Op>::Exec;
-    case Type::INT32:
-      return KernelGenerator<Int32Type, Int32Type, Op>::Exec;
-    case Type::UINT32:
-      return KernelGenerator<UInt32Type, UInt32Type, Op>::Exec;
-    case Type::INT64:
-    case Type::DURATION:
-    case Type::TIMESTAMP:
-      return KernelGenerator<Int64Type, Int64Type, Op>::Exec;
-    case Type::UINT64:
-      return KernelGenerator<UInt64Type, UInt64Type, Op>::Exec;
-    case Type::FLOAT:
-      return KernelGenerator<FloatType, FloatType, Op>::Exec;
-    case Type::DOUBLE:
-      return KernelGenerator<DoubleType, DoubleType, Op>::Exec;
-    default:
-      DCHECK(false);
-      return ExecFail;
-  }
-}
-
 // Generate a kernel given a bitwise arithmetic functor. Assumes the
 // functor treats all integer types of equal width identically
 template <template <typename... Args> class KernelGenerator, typename Op>
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index bed009fbf88..cccfbbd895e 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -18,6 +18,7 @@
 #include "arrow/array/array_base.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
+#include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/result.h"
@@ -29,166 +30,56 @@ namespace internal {
 
 namespace {
 
-
-struct Add {
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                            Arg1 right, Status*) {
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                          Arg1 right, Status*) {
-    return arrow::internal::SafeSignedAdd(left, right);
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + right;
-  }
-};
-
-struct AddChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + right;
-  }
-};
 std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
   return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
 }
 
 }  // namespace
 
-template <typename Type>
-struct CumulativeSum {
-  using CType = typename TypeTraits<Type>::CType;
-  using ScalarType = typename TypeTraits<Type>::ScalarType;
-
-  CType Sum(ExecContext* ctx, std::shared_ptr<Array>& input, ArrayData* output,
-            CType start, bool skip_nulls) {
-    CType sum = start;
-    CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
-    CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
-    ArithmeticOptions options;
-    bool set_null = false;
-    for (size_t i = input->offset(); i < input->length(); ++i) {
-      if (set_null) {
-        out_values[i] = NULL;
-      } else if (input->IsNull(i) && !skip_nulls) {
-        out_values[i] = NULL;
-        set_null = true;
-      } else {
-        // Datum value_datum(data[i]);
-        // Datum sum_datum(sum);
-        // auto result = Add(value_datum, sum_datum, options, ctx);
-        // sum = result_scalar.value;
-
-        sum = Add::Call(data[i], sum);
-        out_values[i] = sum;
-      }
-    }
-
-    return sum;
-  }
-
+template <typename OutType, typename ArgType, typename Op>
+struct CumulativeMeta {
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<CumulativeSumOptions>::Get(ctx);
-    std::shared_ptr<Scalar>& start_scalar = options.start;
+    auto start = UnboxScalar<ArgType>::Unbox(*options.start);
     bool skip_nulls = options.skip_nulls;
 
-    CType start = 0;
-    if (start_scalar) {
-      if (start_scalar->is_valid()) {
-        if (start_scalar->type()->id() != TypeTraits<Type>::type_singleton()->id()) {
-          return Status::Invalid(
-              "Types of array values and starting value do not match.");
-        }
-        start = UnboxScalar<Type>::Unbox(*start_scalar);
-      }
-    }
-
     switch (batch[0].kind()) {
       case Datum::ARRAY: {
-        std::shared_ptr<Array> input = batch[0].make_array();
-        ArrayData* output = out->array().get();
-
-        output->length = input->data()->length;
-        *output->type = std::move(input->type());
-        uint8_t* out_bitmap = output->buffers[0]->mutable_data();
-        int64_t out_offset = input->offset();
-
-        if (input->data()->MayHaveNulls()) {
-          arrow::internal::CopyBitmap(input->null_bitmap_data(), input->offset(),
-                                      input->length(), out_bitmap, out_offset);
-          output->null_count = input->null_count();
-        } else {
-          bit_util::SetBitsTo(out_bitmap, out_offset, input->length(), true);
-          output->null_count = 0;
-        }
-
-        Sum(ctx->exec_context(), input, output, start, skip_nulls);
-        return Status::OK();
+        return Op::template Call(ctx, *batch[0].array(), start, out);
       }
       case Datum::CHUNKED_ARRAY: {
         const auto& input = batch[0].chunked_array();
 
-        ArrayVector out_chunks;
         for (const auto& chunk : input->chunks()) {
-          auto out_chunk = std::make_shared<ArrayData>(
-              chunk->type(), chunk->length(), chunk->null_count(), chunk->offset());
-
-          uint8_t* out_chunk_bitmap = out_chunk->buffers[0]->mutable_data();
-          if (chunk->data()->MayHaveNulls()) {
-            arrow::internal::CopyBitmap(chunk->null_bitmap_data(), chunk->offset(),
-                                        chunk->length(), out_chunk_bitmap,
-                                        out_chunk->offset());
-            out_chunk->null_count = chunk->null_count();
-          } else {
-            bit_util::SetBitsTo(out_chunk_bitmap, out_chunk->offset(), chunk->length(),
-                                true);
-            out_chunk->null_count = 0;
-          }
-
-          CType last_value =
-              Sum(ctx->exec_context(), chunk, out_chunk, start, skip_nulls);
-          start = last_value;
-          out_chunks.push_back(MakeArray(std::move(out_chunk)));
+          RETURN_NOT_OK(Op::template Call(ctx, chunk->data(), start, out));
         }
-
-        *out->chunked_array() = ChunkedArray(out_chunks, input->type());
-        return Status::OK();
       }
       default:
         return Status::NotImplemented(
-            "Unsupported input type for function 'cumulative_sum': ",
+            "Unsupported input type for function 'cumulative_<operator>': ",
             batch[0].ToString());
     }
+
+    return Status::OK();
+  }
+};
+
+template <typename OutType, typename ArgType>
+struct CumulativeSum {
+
+  using OutValue = typename GetOutputType<OutType>::T;
+  using ArgValue = typename GetViewType<ArgType>::T;
+
+  static Status Call(KernelContext* ctx, const ArrayData& arg0, const ArgValue& sum,
+                            Datum* out) {
+    Status st = Status::OK();
+    ArrayIterator<ArgType> arg0_it(arg0);
+    RETURN_NOT_OK(OutputAdapter<OutType>::Write(ctx, out, [&]() -> OutValue {
+      sum = Add::template Call<OutValue, ArgValue, ArgValue>(ctx, arg0_it(), sum,
+                                                               &st);
+      return sum;
+    }));
+    return st;
   }
 };
 
@@ -203,25 +94,18 @@ const FunctionDoc cumulative_sum_doc(
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto cumulative_sum = std::make_shared<VectorFunction>(
-      "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
+      "cumulative_sum", Arity::Unary(), &cumulative_sum_doc);
 
   std::vector<std::shared_ptr<DataType>> types;
-  types.insert(types.end(), IntTypes().begin(), IntTypes().end());
-  types.insert(types.end(), FloatingPointTypes().begin(), IntTypes().end());
-  types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
-  types.push_back(duration(TimeUnit::SECOND));
-  types.push_back(duration(TimeUnit::MILLI));
-  types.push_back(duration(TimeUnit::MICRO));
-  types.push_back(duration(TimeUnit::NANO));
-  types.push_back(month_interval());
-
-  for (auto ty : types) {
+  types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
+
+  for (const auto& ty : NumericTypes()) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = false;
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = GetSignature(ty->id());
-    kernel.exec = std::move(GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
+    kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
+    kernel.exec = std::move(ArithmeticExecFromOp<CumulativeMeta, CumulativeSum>(ty));
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }

From 73f7a3237a8ec722ce8f34e54975f54745948a3a Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 24 Mar 2022 14:55:36 -0400
Subject: [PATCH 11/67] Removed CumulativeSum completely; now defined by use of
 Add operator

---
 .../compute/kernels/vector_cumulative_sum.cc  |  43 ++---
 .../kernels/vector_cumulative_sum_test.cc     | 180 +++++++++---------
 python/pyarrow/_compute.pyx                   |   2 +-
 3 files changed, 105 insertions(+), 120 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index cccfbbd895e..cb695a07133 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -28,16 +28,11 @@ namespace arrow {
 namespace compute {
 namespace internal {
 
-namespace {
-
-std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
-  return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
-}
-
-}  // namespace
-
 template <typename OutType, typename ArgType, typename Op>
-struct CumulativeMeta {
+struct CumulativeGeneric {
+  using OutValue = typename GetOutputType<OutType>::T;
+  using ArgValue = typename GetViewType<ArgType>::T;
+
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<CumulativeSumOptions>::Get(ctx);
     auto start = UnboxScalar<ArgType>::Unbox(*options.start);
@@ -45,13 +40,13 @@ struct CumulativeMeta {
 
     switch (batch[0].kind()) {
       case Datum::ARRAY: {
-        return Op::template Call(ctx, *batch[0].array(), start, out);
+        return Call(ctx, *batch[0].array(), start, out, skip_nulls);
       }
       case Datum::CHUNKED_ARRAY: {
         const auto& input = batch[0].chunked_array();
 
         for (const auto& chunk : input->chunks()) {
-          RETURN_NOT_OK(Op::template Call(ctx, chunk->data(), start, out));
+          RETURN_NOT_OK(Call(ctx, *chunk->data(), start, out, skip_nulls));
         }
       }
       default:
@@ -62,22 +57,15 @@ struct CumulativeMeta {
 
     return Status::OK();
   }
-};
-
-template <typename OutType, typename ArgType>
-struct CumulativeSum {
-
-  using OutValue = typename GetOutputType<OutType>::T;
-  using ArgValue = typename GetViewType<ArgType>::T;
 
-  static Status Call(KernelContext* ctx, const ArrayData& arg0, const ArgValue& sum,
-                            Datum* out) {
+  static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
+                            Datum* out, bool skip_nulls) {
     Status st = Status::OK();
     ArrayIterator<ArgType> arg0_it(arg0);
-    RETURN_NOT_OK(OutputAdapter<OutType>::Write(ctx, out, [&]() -> OutValue {
-      sum = Add::template Call<OutValue, ArgValue, ArgValue>(ctx, arg0_it(), sum,
+    RETURN_NOT_OK(applicator::OutputAdapter<OutType>::Write(ctx, out, [&]() -> OutValue {
+      partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, arg0_it(), partial_scan,
                                                                &st);
-      return sum;
+      return partial_scan;
     }));
     return st;
   }
@@ -86,11 +74,8 @@ struct CumulativeSum {
 const FunctionDoc cumulative_sum_doc(
     "Compute the cumulative sum over an array of numbers",
     ("`values` must be an array of numeric type values.\n"
-     "`start` is a single value of the same type.\n"
-     "Return an array which is the cumulative sum computed over `values.`\n"
-     "Null entries remain in place but are not used in calucating sum.\n"
-     "`start` is an optional starting sum of computation."),
-    {"values", "start"});
+     "Return an array which is the cumulative sum computed over `values.`"),
+    {"values"});
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto cumulative_sum = std::make_shared<VectorFunction>(
@@ -105,7 +90,7 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec = std::move(ArithmeticExecFromOp<CumulativeMeta, CumulativeSum>(ty));
+    kernel.exec = std::move(ArithmeticExecFromOp<CumulativeGeneric, Add>(ty));
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
index 8ad10be1da2..605cbb5e442 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -1,90 +1,90 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include <algorithm>
-#include <cstdint>
-#include <cstdio>
-#include <functional>
-#include <locale>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <gtest/gtest.h>
-
-#include "arrow/array.h"
-#include "arrow/array/builder_decimal.h"
-#include "arrow/buffer.h"
-#include "arrow/chunked_array.h"
-#include "arrow/compute/api_vector.h"
-#include "arrow/status.h"
-#include "arrow/testing/util.h"
-#include "arrow/type.h"
-#include "arrow/type_fwd.h"
-#include "arrow/type_traits.h"
-#include "arrow/util/checked_cast.h"
-#include "arrow/util/decimal.h"
-
-#include "arrow/compute/api.h"
-#include "arrow/compute/kernels/test_util.h"
-
-#include "arrow/ipc/json_simple.h"
-
-namespace arrow {
-namespace compute {
-
-using IntegralTypes = testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type,
-                                     Int8Type, Int16Type, Int32Type, Int64Type>;
-
-using FloatingTypes = testing::Types<FloatType, DoubleType>;
-
-using TimeTypes = testing::Types<Date32Type, Date64Type, Time32Type, Time64Type,
-                                 TimestampType, DurationType, MonthIntervalType>;
-
-template <typename Type>
-class TestCumulativeSum : public ::testing::Test {
-  using CType = TypeTraits<Type>::CType;
-
- protected:
-  CumulativeSumOptions no_start_no_skip_nulls();
-  CumulativeSumOptions has_start_no_skip_nulls(10);
-  CumulativeSumOptions no_start_skip_nulls(0, true);
-  CumulativeSumOptions has_start_skip_nulls(10, true);
-
-  void SetUp() override {}
-
-  void AssertValidCumulativeSum(const Array& expected, const Array& input,
-                                const CumulativeSumOptions options) {
-    ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
-    AssertArraysEqual(expected, *result, false, EqualOptions::Defaults());
-  }
-};
-
-TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralTypes);
-TYPED_TEST_SUITE(TestCumulativeSumFloating, FloatingTypes);
-TYPED_TEST_SUITE(TestCumulativeSumTemporal, TimeTypes);
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {}
-TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
-TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
-TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
-
-
-}  // namespace compute
-}  // namespace arrow
+// // Licensed to the Apache Software Foundation (ASF) under one
+// // or more contributor license agreements.  See the NOTICE file
+// // distributed with this work for additional information
+// // regarding copyright ownership.  The ASF licenses this file
+// // to you under the Apache License, Version 2.0 (the
+// // "License"); you may not use this file except in compliance
+// // with the License.  You may obtain a copy of the License at
+// //
+// //   http://www.apache.org/licenses/LICENSE-2.0
+// //
+// // Unless required by applicable law or agreed to in writing,
+// // software distributed under the License is distributed on an
+// // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// // KIND, either express or implied.  See the License for the
+// // specific language governing permissions and limitations
+// // under the License.
+
+// #include <algorithm>
+// #include <cstdint>
+// #include <cstdio>
+// #include <functional>
+// #include <locale>
+// #include <memory>
+// #include <stdexcept>
+// #include <string>
+// #include <utility>
+// #include <vector>
+
+// #include <gtest/gtest.h>
+
+// #include "arrow/array.h"
+// #include "arrow/array/builder_decimal.h"
+// #include "arrow/buffer.h"
+// #include "arrow/chunked_array.h"
+// #include "arrow/compute/api_vector.h"
+// #include "arrow/status.h"
+// #include "arrow/testing/util.h"
+// #include "arrow/type.h"
+// #include "arrow/type_fwd.h"
+// #include "arrow/type_traits.h"
+// #include "arrow/util/checked_cast.h"
+// #include "arrow/util/decimal.h"
+
+// #include "arrow/compute/api.h"
+// #include "arrow/compute/kernels/test_util.h"
+
+// #include "arrow/ipc/json_simple.h"
+
+// namespace arrow {
+// namespace compute {
+
+// using IntegralTypes = testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type,
+//                                      Int8Type, Int16Type, Int32Type, Int64Type>;
+
+// using FloatingTypes = testing::Types<FloatType, DoubleType>;
+
+// using TimeTypes = testing::Types<Date32Type, Date64Type, Time32Type, Time64Type,
+//                                  TimestampType, DurationType, MonthIntervalType>;
+
+// template <typename Type>
+// class TestCumulativeSum : public ::testing::Test {
+//   using CType = TypeTraits<Type>::CType;
+
+//  protected:
+//   CumulativeSumOptions no_start_no_skip_nulls();
+//   CumulativeSumOptions has_start_no_skip_nulls(10);
+//   CumulativeSumOptions no_start_skip_nulls(0, true);
+//   CumulativeSumOptions has_start_skip_nulls(10, true);
+
+//   void SetUp() override {}
+
+//   void AssertValidCumulativeSum(const Array& expected, const Array& input,
+//                                 const CumulativeSumOptions options) {
+//     ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
+//     AssertArraysEqual(expected, *result, false, EqualOptions::Defaults());
+//   }
+// };
+
+// TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumFloating, FloatingTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumTemporal, TimeTypes);
+
+// TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {}
+// TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
+// TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
+// TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
+
+
+// }  // namespace compute
+// }  // namespace arrow
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index dc9cd9dd372..9378e92d2e2 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1754,7 +1754,7 @@ class CumulativeSumOptions(_CumulativeSumOptions):
         When false, propagates the first null/NaN encountered
     """
 
-    def __init__(self, start=0, skip_nulls=false):
+    def __init__(self, start=0, skip_nulls=False):
         self._set_options(start, skip_nulls)
 
 

From 9ff405e69bb634cb46813a521dd6144d6149aa08 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 24 Mar 2022 17:08:56 -0400
Subject: [PATCH 12/67] minor changes and initial tests

---
 cpp/src/arrow/compute/api_vector.cc           |  16 +-
 cpp/src/arrow/compute/api_vector.h            |  17 +-
 .../compute/kernels/vector_cumulative_sum.cc  |  10 +-
 .../kernels/vector_cumulative_sum_test.cc     | 177 +++++++++---------
 python/pyarrow/compute.py                     |   1 +
 python/pyarrow/includes/libarrow.pxd          |   1 +
 6 files changed, 113 insertions(+), 109 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 261bb3a2dd1..f27e91a3b5f 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -179,14 +179,14 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-CumulativeSumOptions::CumulativeSumOptions(uint64_t start, bool skip_nulls)
-    : CumulativeSumOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
-
-CumulativeSumOptions::CumulativeSumOptions(int64_t start, bool skip_nulls)
-    : CumulativeSumOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
-
-CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls)
-    : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
+// CumulativeSumOptions::CumulativeSumOptions(uint64_t start, bool skip_nulls)
+//     : CumulativeSumOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
+//
+// CumulativeSumOptions::CumulativeSumOptions(int64_t start, bool skip_nulls)
+//     : CumulativeSumOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
+//
+// CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls)
+//     : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
 
 CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
     : FunctionOptions(internal::kCumulativeSumOptionsType),
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 5742871fd64..26c1f9765e9 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,10 +191,10 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  explicit CumulativeSumOptions(uint64_t start, bool skip_nulls = false);
-  explicit CumulativeSumOptions(int64_t start, bool skip_nulls = false);
-  explicit CumulativeSumOptions(double start, bool skip_nulls = false);
-  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = nullptr,
+  // explicit CumulativeSumOptions(uint64_t start, bool skip_nulls = false);
+  // explicit CumulativeSumOptions(int64_t start, bool skip_nulls = false);
+  // explicit CumulativeSumOptions(double start, bool skip_nulls = false);
+  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<UInt8Type>>(0),
                                 bool skip_nulls = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
   static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
@@ -541,14 +541,7 @@ Result<Datum> DictionaryEncode(
     ExecContext* ctx = NULLPTR);
 
 ARROW_EXPORT
-Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
-                                             const CumulativeSumOptions& options,
-                                             ExecContext* ctx = NULLPTR);
-
-ARROW_EXPORT
-Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
-                                             const CumulativeSumOptions& options,
-                                             ExecContext* ctx = NULLPTR);
+Result<Datum> CumulativeSum(const Datum& values, const CumulativeSumOptions& options = CumulativeSumOptions::Defaults(), ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
 // Deprecated functions
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index cb695a07133..a847c1054f2 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -71,15 +71,17 @@ struct CumulativeGeneric {
   }
 };
 
-const FunctionDoc cumulative_sum_doc(
+const FunctionDoc cumulative_sum_doc{
     "Compute the cumulative sum over an array of numbers",
     ("`values` must be an array of numeric type values.\n"
      "Return an array which is the cumulative sum computed over `values.`"),
-    {"values"});
+    {"values"},
+    "CumulativeSumOptions"};
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
+  auto options = CumulativeSumOptions::Defaults();
   auto cumulative_sum = std::make_shared<VectorFunction>(
-      "cumulative_sum", Arity::Unary(), &cumulative_sum_doc);
+      "cumulative_sum", Arity::Unary(), &cumulative_sum_doc, &options);
 
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
@@ -90,7 +92,7 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec = std::move(ArithmeticExecFromOp<CumulativeGeneric, Add>(ty));
+    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Add>(ty);
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
index 605cbb5e442..f2e9e621804 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -1,90 +1,97 @@
-// // Licensed to the Apache Software Foundation (ASF) under one
-// // or more contributor license agreements.  See the NOTICE file
-// // distributed with this work for additional information
-// // regarding copyright ownership.  The ASF licenses this file
-// // to you under the Apache License, Version 2.0 (the
-// // "License"); you may not use this file except in compliance
-// // with the License.  You may obtain a copy of the License at
-// //
-// //   http://www.apache.org/licenses/LICENSE-2.0
-// //
-// // Unless required by applicable law or agreed to in writing,
-// // software distributed under the License is distributed on an
-// // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// // KIND, either express or implied.  See the License for the
-// // specific language governing permissions and limitations
-// // under the License.
-
-// #include <algorithm>
-// #include <cstdint>
-// #include <cstdio>
-// #include <functional>
-// #include <locale>
-// #include <memory>
-// #include <stdexcept>
-// #include <string>
-// #include <utility>
-// #include <vector>
-
-// #include <gtest/gtest.h>
-
-// #include "arrow/array.h"
-// #include "arrow/array/builder_decimal.h"
-// #include "arrow/buffer.h"
-// #include "arrow/chunked_array.h"
-// #include "arrow/compute/api_vector.h"
-// #include "arrow/status.h"
-// #include "arrow/testing/util.h"
-// #include "arrow/type.h"
-// #include "arrow/type_fwd.h"
-// #include "arrow/type_traits.h"
-// #include "arrow/util/checked_cast.h"
-// #include "arrow/util/decimal.h"
-
-// #include "arrow/compute/api.h"
-// #include "arrow/compute/kernels/test_util.h"
-
-// #include "arrow/ipc/json_simple.h"
-
-// namespace arrow {
-// namespace compute {
-
-// using IntegralTypes = testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type,
-//                                      Int8Type, Int16Type, Int32Type, Int64Type>;
-
-// using FloatingTypes = testing::Types<FloatType, DoubleType>;
-
-// using TimeTypes = testing::Types<Date32Type, Date64Type, Time32Type, Time64Type,
-//                                  TimestampType, DurationType, MonthIntervalType>;
-
-// template <typename Type>
-// class TestCumulativeSum : public ::testing::Test {
-//   using CType = TypeTraits<Type>::CType;
-
-//  protected:
-//   CumulativeSumOptions no_start_no_skip_nulls();
-//   CumulativeSumOptions has_start_no_skip_nulls(10);
-//   CumulativeSumOptions no_start_skip_nulls(0, true);
-//   CumulativeSumOptions has_start_skip_nulls(10, true);
-
-//   void SetUp() override {}
-
-//   void AssertValidCumulativeSum(const Array& expected, const Array& input,
-//                                 const CumulativeSumOptions options) {
-//     ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
-//     AssertArraysEqual(expected, *result, false, EqualOptions::Defaults());
-//   }
-// };
-
-// TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumFloating, FloatingTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumTemporal, TimeTypes);
-
-// TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {}
+// Licensed to the Apache Software Foundation (ASF) under one // or more contributor license agreements.  See the NOTICE file // distributed with this work for additional information // regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <locale>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "arrow/array.h"
+#include "arrow/array/builder_decimal.h"
+#include "arrow/buffer.h"
+#include "arrow/chunked_array.h"
+#include "arrow/compute/api_vector.h"
+#include "arrow/status.h"
+#include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
+#include "arrow/testing/util.h"
+#include "arrow/type.h"
+#include "arrow/type_fwd.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/checked_cast.h"
+#include "arrow/util/decimal.h"
+
+#include "arrow/compute/api.h"
+#include "arrow/compute/kernels/test_util.h"
+
+#include "arrow/ipc/json_simple.h"
+
+namespace arrow {
+namespace compute {
+
+using DurationTypes = testing::Types<DurationType, MonthIntervalType>;
+
+template <typename T>
+class TestCumulativeSum : public ::testing::Test {
+ public:
+  using ArrowType = T;
+  // using CType = TypeTraits<Type>::CType;
+
+ protected:
+  static std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
+  }
+
+  void SetUp() override {}
+
+  void Assert(const std::shared_ptr<Array>& expected, const std::shared_ptr<Array>& input,
+                                const CumulativeSumOptions& options) {
+    ASSERT_OK_AND_ASSIGN(auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
+    AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
+  }
+};
+
+template <typename T>
+class TestCumulativeSumIntegral : public TestCumulativeSum<T> {};
+
+TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralArrowTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumFloating, RealArrowTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumTemporal, TemporalArrowTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumDecimal, DecimalArrowTypes);
+
+TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeSumOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+  // CumulativeSumOptions options;
+
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4]");
+  this->Assert(expected, values, options);
+}
+
 // TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
 // TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
 // TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
 
 
-// }  // namespace compute
-// }  // namespace arrow
+}  // namespace compute
+}  // namespace arrow
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 0da61dcec0a..37bf90548bc 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -33,6 +33,7 @@
     AssumeTimezoneOptions,
     CastOptions,
     CountOptions,
+    CumulativeSumOptions,
     DayOfWeekOptions,
     DictionaryEncodeOptions,
     ElementWiseAggregateOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 33c46e56b70..13e16d4585b 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2245,6 +2245,7 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
 
     cdef cppclass CCumulativeSumOptions \
             "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
+        CCumulativeSumOptions(int64_t start)
         CCumulativeSumOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
         shared_ptr[CScalar] start
         c_bool skip_nulls

From 4b42c8f62aea15bef20e54eabbd33326d08950d3 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 25 Mar 2022 16:17:27 -0400
Subject: [PATCH 13/67] Refactoring, added optionstype to CumulativeGeneric
 template, and handling skip_nulls

---
 cpp/src/arrow/CMakeLists.txt                  |  2 +-
 cpp/src/arrow/compute/api_vector.cc           | 40 +++++-------
 cpp/src/arrow/compute/api_vector.h            | 19 +++---
 cpp/src/arrow/compute/kernels/CMakeLists.txt  |  2 +-
 .../arrow/compute/kernels/codegen_internal.h  | 22 +++----
 ...lative_sum.cc => vector_cumulative_ops.cc} | 65 +++++++++++++++----
 ..._test.cc => vector_cumulative_ops_test.cc} | 10 +--
 docs/source/python/api/compute.rst            |  2 +-
 python/pyarrow/_compute.pyx                   |  6 +-
 python/pyarrow/compute.py                     |  2 +-
 python/pyarrow/includes/libarrow.pxd          |  8 +--
 python/pyarrow/tests/test_compute.py          |  2 +-
 12 files changed, 106 insertions(+), 74 deletions(-)
 rename cpp/src/arrow/compute/kernels/{vector_cumulative_sum.cc => vector_cumulative_ops.cc} (62%)
 rename cpp/src/arrow/compute/kernels/{vector_cumulative_sum_test.cc => vector_cumulative_ops_test.cc} (90%)

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index de67503ad0c..f3bce5f4d67 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -436,7 +436,7 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_validity.cc
        compute/kernels/util_internal.cc
        compute/kernels/vector_array_sort.cc
-       compute/kernels/vector_cumulative_sum.cc
+       compute/kernels/vector_cumulative_ops.cc
        compute/kernels/vector_hash.cc
        compute/kernels/vector_nested.cc
        compute/kernels/vector_replace.cc
diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index f27e91a3b5f..6714f71ca04 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -135,9 +135,9 @@ static auto kPartitionNthOptionsType = GetFunctionOptionsType<PartitionNthOption
 static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
-static auto kCumulativeSumOptionsType = GetFunctionOptionsType<CumulativeSumOptions>(
-    DataMember("start", &CumulativeSumOptions::start),
-    DataMember("skip_nulls", &CumulativeSumOptions::skip_nulls));
+static auto kCumulativeGenericOptionsType = GetFunctionOptionsType<CumulativeGenericOptions>(
+    DataMember("start", &CumulativeGenericOptions::start),
+    DataMember("skip_nulls", &CumulativeGenericOptions::skip_nulls));
 }  // namespace
 }  // namespace internal
 
@@ -179,20 +179,20 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-// CumulativeSumOptions::CumulativeSumOptions(uint64_t start, bool skip_nulls)
-//     : CumulativeSumOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
+// CumulativeGenericOptions::CumulativeGenericOptions(uint64_t start, bool skip_nulls)
+//     : CumulativeGenericOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
 //
-// CumulativeSumOptions::CumulativeSumOptions(int64_t start, bool skip_nulls)
-//     : CumulativeSumOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
+// CumulativeGenericOptions::CumulativeGenericOptions(int64_t start, bool skip_nulls)
+//     : CumulativeGenericOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
 //
-// CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls)
-//     : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
+// CumulativeGenericOptions::CumulativeGenericOptions(double start, bool skip_nulls)
+//     : CumulativeGenericOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
 
-CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
-    : FunctionOptions(internal::kCumulativeSumOptionsType),
+CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
+    : FunctionOptions(internal::kCumulativeGenericOptionsType),
       start(std::move(start)),
       skip_nulls(skip_nulls) {}
-constexpr char CumulativeSumOptions::kTypeName[];
+constexpr char CumulativeGenericOptions::kTypeName[];
 
 namespace internal {
 void RegisterVectorOptions(FunctionRegistry* registry) {
@@ -203,7 +203,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kSortOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPartitionNthOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSelectKOptionsType));
-  DCHECK_OK(registry->AddFunctionOptionsType(kCumulativeSumOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kCumulativeGenericOptionsType));
 }
 }  // namespace internal
 
@@ -344,22 +344,14 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
   return out.make_array();
 }
 
-Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
-                                             const CumulativeSumOptions& options,
-                                             ExecContext* ctx) {
+Result<Datum> CumulativeSum(const Datum& values,
+                            const CumulativeGenericOptions& options,
+                            ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(Datum out,
                         CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
   return out.make_array();
 }
 
-Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
-                                             const CumulativeSumOptions& options,
-                                             ExecContext* ctx) {
-  ARROW_ASSIGN_OR_RAISE(
-      Datum out, CallFunction("cumulative_sum", {Datum(chunked_array)}, &options, ctx));
-  return out.make_array();
-}
-
 // ----------------------------------------------------------------------
 // Deprecated functions
 
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 26c1f9765e9..e55424fb3b1 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -189,15 +189,16 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 };
 
 /// \brief Options for cumulative sum function
-class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
+class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
  public:
-  // explicit CumulativeSumOptions(uint64_t start, bool skip_nulls = false);
-  // explicit CumulativeSumOptions(int64_t start, bool skip_nulls = false);
-  // explicit CumulativeSumOptions(double start, bool skip_nulls = false);
-  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<UInt8Type>>(0),
+  // explicit CumulativeGenericOptions(uint64_t start, bool skip_nulls = false);
+  // explicit CumulativeGenericOptions(int64_t start, bool skip_nulls = false);
+  // explicit CumulativeGenericOptions(double start, bool skip_nulls = false);
+  explicit CumulativeGenericOptions(
+      std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
                                 bool skip_nulls = false);
-  static constexpr char const kTypeName[] = "CumulativeSumOptions";
-  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
+  static constexpr char const kTypeName[] = "CumulativeGenericOptions";
+  static CumulativeGenericOptions Defaults() { return CumulativeGenericOptions(); }
 
   /// Optional starting value for sum computation
   std::shared_ptr<Scalar> start;
@@ -541,7 +542,9 @@ Result<Datum> DictionaryEncode(
     ExecContext* ctx = NULLPTR);
 
 ARROW_EXPORT
-Result<Datum> CumulativeSum(const Datum& values, const CumulativeSumOptions& options = CumulativeSumOptions::Defaults(), ExecContext* ctx = NULLPTR);
+Result<Datum> CumulativeSum(const Datum& values,
+                            const CumulativeGenericOptions& options = CumulativeGenericOptions::Defaults(),
+                            ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
 // Deprecated functions
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 7659a5b5490..a3f14a58a63 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -47,7 +47,7 @@ add_arrow_benchmark(scalar_string_benchmark PREFIX "arrow-compute")
 
 add_arrow_compute_test(vector_test
                        SOURCES
-                       vector_cumulative_sum_test.cc
+                       vector_cumulative_ops_test.cc
                        vector_hash_test.cc
                        vector_nested_test.cc
                        vector_replace_test.cc
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 8eb5cba5d39..333f4835aa6 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -1134,31 +1134,31 @@ ArrayKernelExec GeneratePhysicalInteger(detail::GetTypeId get_id) {
   }
 }
 
-template <template <typename... Args> class KernelGenerator, typename Op>
+template <template <typename...> class KernelGenerator, typename Op, typename... Args>
 ArrayKernelExec ArithmeticExecFromOp(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
-      return KernelGenerator<Int8Type, Int8Type, Op>::Exec;
+      return KernelGenerator<Int8Type, Int8Type, Op, Args...>::Exec;
     case Type::UINT8:
-      return KernelGenerator<UInt8Type, UInt8Type, Op>::Exec;
+      return KernelGenerator<UInt8Type, UInt8Type, Op, Args...>::Exec;
     case Type::INT16:
-      return KernelGenerator<Int16Type, Int16Type, Op>::Exec;
+      return KernelGenerator<Int16Type, Int16Type, Op, Args...>::Exec;
     case Type::UINT16:
-      return KernelGenerator<UInt16Type, UInt16Type, Op>::Exec;
+      return KernelGenerator<UInt16Type, UInt16Type, Op, Args...>::Exec;
     case Type::INT32:
-      return KernelGenerator<Int32Type, Int32Type, Op>::Exec;
+      return KernelGenerator<Int32Type, Int32Type, Op, Args...>::Exec;
     case Type::UINT32:
-      return KernelGenerator<UInt32Type, UInt32Type, Op>::Exec;
+      return KernelGenerator<UInt32Type, UInt32Type, Op, Args...>::Exec;
     case Type::DURATION:
     case Type::INT64:
     case Type::TIMESTAMP:
-      return KernelGenerator<Int64Type, Int64Type, Op>::Exec;
+      return KernelGenerator<Int64Type, Int64Type, Op, Args...>::Exec;
     case Type::UINT64:
-      return KernelGenerator<UInt64Type, UInt64Type, Op>::Exec;
+      return KernelGenerator<UInt64Type, UInt64Type, Op, Args...>::Exec;
     case Type::FLOAT:
-      return KernelGenerator<FloatType, FloatType, Op>::Exec;
+      return KernelGenerator<FloatType, FloatType, Op, Args...>::Exec;
     case Type::DOUBLE:
-      return KernelGenerator<DoubleType, DoubleType, Op>::Exec;
+      return KernelGenerator<DoubleType, DoubleType, Op, Args...>::Exec;
     default:
       DCHECK(false);
       return ExecFail;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
similarity index 62%
rename from cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
rename to cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index a847c1054f2..5d83deb2c83 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -23,18 +23,20 @@
 #include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/result.h"
 #include "arrow/visit_type_inline.h"
+#include "arrow/util/bit_util.h"
 
 namespace arrow {
 namespace compute {
 namespace internal {
 
-template <typename OutType, typename ArgType, typename Op>
+template <typename OutType, typename ArgType, typename Op, typename OptionsType>
 struct CumulativeGeneric {
   using OutValue = typename GetOutputType<OutType>::T;
   using ArgValue = typename GetViewType<ArgType>::T;
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const auto& options = OptionsWrapper<CumulativeSumOptions>::Get(ctx);
+    const auto& options = OptionsWrapper<OptionsType>::Get(ctx);
+    // auto start = (options.start) ? UnboxScalar<ArgType>::Unbox(*options.start) : checked_cast<ArgValue>(0);
     auto start = UnboxScalar<ArgType>::Unbox(*options.start);
     bool skip_nulls = options.skip_nulls;
 
@@ -61,12 +63,51 @@ struct CumulativeGeneric {
   static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
                             Datum* out, bool skip_nulls) {
     Status st = Status::OK();
-    ArrayIterator<ArgType> arg0_it(arg0);
-    RETURN_NOT_OK(applicator::OutputAdapter<OutType>::Write(ctx, out, [&]() -> OutValue {
-      partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, arg0_it(), partial_scan,
-                                                               &st);
-      return partial_scan;
-    }));
+    ArrayData* out_arr = out->mutable_array();
+    auto out_data = out_arr->GetMutableValues<OutValue>(1);
+
+    if (skip_nulls) {
+      VisitArrayValuesInline<ArgType>(
+          arg0,
+          [&](ArgValue v) {
+            partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v,
+                                                                          partial_scan, &st);
+            *out_data++ = partial_scan;
+          },
+          [&]() {
+            // null
+            *out_data++ = OutValue{};
+          });
+    } else {
+      bool encounted_null = false;
+      auto start_null_idx = arg0.offset;
+
+      VisitArrayValuesInline<ArgType>(
+          arg0,
+          [&](ArgValue v) {
+            if (encounted_null) {
+              *out_data++ = OutValue{};
+            } else {
+              partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v,
+                                                                            partial_scan, &st);    
+              *out_data++ = partial_scan;
+              ++start_null_idx;
+            }
+          },
+          [&]() {
+            // null
+            *out_data++ = OutValue{};
+            if (!encounted_null) {
+              ++start_null_idx;
+              encounted_null = true;
+            }
+          });
+
+      auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
+      auto null_length = arg0.length - (start_null_idx - arg0.offset);
+      arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
+    }
+
     return st;
   }
 };
@@ -76,10 +117,10 @@ const FunctionDoc cumulative_sum_doc{
     ("`values` must be an array of numeric type values.\n"
      "Return an array which is the cumulative sum computed over `values.`"),
     {"values"},
-    "CumulativeSumOptions"};
+    "CumulativeGenericOptions"};
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-  auto options = CumulativeSumOptions::Defaults();
+  auto options = CumulativeGenericOptions::Defaults();
   auto cumulative_sum = std::make_shared<VectorFunction>(
       "cumulative_sum", Arity::Unary(), &cumulative_sum_doc, &options);
 
@@ -92,8 +133,8 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Add>(ty);
-    kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
+    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Add, CumulativeGenericOptions>(ty);
+    kernel.init = OptionsWrapper<CumulativeGenericOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
similarity index 90%
rename from cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
rename to cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index f2e9e621804..2eeb92eb44f 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -34,10 +34,6 @@
 #include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
-#include "arrow/type_fwd.h"
-#include "arrow/type_traits.h"
-#include "arrow/util/checked_cast.h"
-#include "arrow/util/decimal.h"
 
 #include "arrow/compute/api.h"
 #include "arrow/compute/kernels/test_util.h"
@@ -63,7 +59,7 @@ class TestCumulativeSum : public ::testing::Test {
   void SetUp() override {}
 
   void Assert(const std::shared_ptr<Array>& expected, const std::shared_ptr<Array>& input,
-                                const CumulativeSumOptions& options) {
+                                const CumulativeGenericOptions& options) {
     ASSERT_OK_AND_ASSIGN(auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
     AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
   }
@@ -80,8 +76,8 @@ TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralArrowTypes);
 TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {
   using ArrowType = typename TestFixture::ArrowType;
 
-  CumulativeSumOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-  // CumulativeSumOptions options;
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+  // CumulativeGenericOptions options;
 
   auto values = ArrayFromJSON(this->type_singleton(), "[1, 3]");
   auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4]");
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index df43bd5e8e0..664a3f76633 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -502,7 +502,7 @@ Compute Options
    CastOptions
    CountOptions
    CountOptions
-   CumulativeSumOptions
+   CumulativeGenericOptions
    DayOfWeekOptions
    DictionaryEncodeOptions
    ElementWiseAggregateOptions
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 9378e92d2e2..fedace2f563 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1736,13 +1736,13 @@ class PartitionNthOptions(_PartitionNthOptions):
         self._set_options(pivot, null_placement)
 
 
-cdef class _CumulativeSumOptions(FunctionOptions):
+cdef class _CumulativeGenericOptions(FunctionOptions):
     def _set_options(self, start, skip_nulls):
-        self.wrapped.reset(new CCumulativeSumOptions(
+        self.wrapped.reset(new CCumulativeGenericOptions(
             pyarrow_unwrap_scalar(start), skip_nulls))
 
 
-class CumulativeSumOptions(_CumulativeSumOptions):
+class CumulativeGenericOptions(_CumulativeGenericOptions):
     """
     Options for `cumulative_sum` function.
 
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 37bf90548bc..2091de4b368 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -33,7 +33,7 @@
     AssumeTimezoneOptions,
     CastOptions,
     CountOptions,
-    CumulativeSumOptions,
+    CumulativeGenericOptions,
     DayOfWeekOptions,
     DictionaryEncodeOptions,
     ElementWiseAggregateOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 13e16d4585b..2a3314fa395 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2243,10 +2243,10 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         int64_t pivot
         CNullPlacement null_placement
 
-    cdef cppclass CCumulativeSumOptions \
-            "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
-        CCumulativeSumOptions(int64_t start)
-        CCumulativeSumOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
+    cdef cppclass CCumulativeGenericOptions \
+            "arrow::compute::CumulativeGenericOptions"(CFunctionOptions):
+        CCumulativeGenericOptions(int64_t start)
+        CCumulativeGenericOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
         shared_ptr[CScalar] start
         c_bool skip_nulls
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 14ca2355484..e98591d5248 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -147,7 +147,7 @@ def test_option_class_equality():
         pc.NullOptions(),
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
-        pc.CumulativeSumOptions(start=0, skip_nulls=False),
+        pc.CumulativeGenericOptions(start=0, skip_nulls=False),
         pc.QuantileOptions(),
         pc.RandomOptions(10),
         pc.ReplaceSliceOptions(0, 1, "a"),

From e318bec76fc3be6cc1d675c7c012056ae7023c81 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Sat, 26 Mar 2022 23:27:33 -0400
Subject: [PATCH 14/67] Linting

---
 cpp/src/arrow/compute/api_vector.cc           | 13 ++++----
 cpp/src/arrow/compute/api_vector.h            |  9 ++---
 .../kernels/base_arithmetic_internal.h        |  1 -
 .../compute/kernels/scalar_arithmetic.cc      |  2 +-
 .../compute/kernels/vector_cumulative_ops.cc  | 27 +++++++--------
 .../kernels/vector_cumulative_ops_test.cc     | 33 ++++++++++++++++---
 6 files changed, 54 insertions(+), 31 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 6714f71ca04..6717670e9b5 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -135,9 +135,10 @@ static auto kPartitionNthOptionsType = GetFunctionOptionsType<PartitionNthOption
 static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
-static auto kCumulativeGenericOptionsType = GetFunctionOptionsType<CumulativeGenericOptions>(
-    DataMember("start", &CumulativeGenericOptions::start),
-    DataMember("skip_nulls", &CumulativeGenericOptions::skip_nulls));
+static auto kCumulativeGenericOptionsType =
+    GetFunctionOptionsType<CumulativeGenericOptions>(
+        DataMember("start", &CumulativeGenericOptions::start),
+        DataMember("skip_nulls", &CumulativeGenericOptions::skip_nulls));
 }  // namespace
 }  // namespace internal
 
@@ -188,7 +189,8 @@ constexpr char SelectKOptions::kTypeName[];
 // CumulativeGenericOptions::CumulativeGenericOptions(double start, bool skip_nulls)
 //     : CumulativeGenericOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
 
-CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
+CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start,
+                                                   bool skip_nulls)
     : FunctionOptions(internal::kCumulativeGenericOptionsType),
       start(std::move(start)),
       skip_nulls(skip_nulls) {}
@@ -344,8 +346,7 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
   return out.make_array();
 }
 
-Result<Datum> CumulativeSum(const Datum& values,
-                            const CumulativeGenericOptions& options,
+Result<Datum> CumulativeSum(const Datum& values, const CumulativeGenericOptions& options,
                             ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(Datum out,
                         CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index e55424fb3b1..db00edda15f 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -196,7 +196,7 @@ class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
   // explicit CumulativeGenericOptions(double start, bool skip_nulls = false);
   explicit CumulativeGenericOptions(
       std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
-                                bool skip_nulls = false);
+      bool skip_nulls = false);
   static constexpr char const kTypeName[] = "CumulativeGenericOptions";
   static CumulativeGenericOptions Defaults() { return CumulativeGenericOptions(); }
 
@@ -542,9 +542,10 @@ Result<Datum> DictionaryEncode(
     ExecContext* ctx = NULLPTR);
 
 ARROW_EXPORT
-Result<Datum> CumulativeSum(const Datum& values,
-                            const CumulativeGenericOptions& options = CumulativeGenericOptions::Defaults(),
-                            ExecContext* ctx = NULLPTR);
+Result<Datum> CumulativeSum(
+    const Datum& values,
+    const CumulativeGenericOptions& options = CumulativeGenericOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
 // Deprecated functions
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index 899f26cd126..f29ed013b9a 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -100,4 +100,3 @@ struct AddTimeDurationChecked {
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
-
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 26143f3749e..125af57a114 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -23,9 +23,9 @@
 
 #include "arrow/compare.h"
 #include "arrow/compute/api_scalar.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/util_internal.h"
-#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/decimal.h"
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 5d83deb2c83..a29a50f8849 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -18,12 +18,12 @@
 #include "arrow/array/array_base.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common.h"
-#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/result.h"
-#include "arrow/visit_type_inline.h"
 #include "arrow/util/bit_util.h"
+#include "arrow/visit_type_inline.h"
 
 namespace arrow {
 namespace compute {
@@ -36,7 +36,6 @@ struct CumulativeGeneric {
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<OptionsType>::Get(ctx);
-    // auto start = (options.start) ? UnboxScalar<ArgType>::Unbox(*options.start) : checked_cast<ArgValue>(0);
     auto start = UnboxScalar<ArgType>::Unbox(*options.start);
     bool skip_nulls = options.skip_nulls;
 
@@ -61,7 +60,7 @@ struct CumulativeGeneric {
   }
 
   static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
-                            Datum* out, bool skip_nulls) {
+                     Datum* out, bool skip_nulls) {
     Status st = Status::OK();
     ArrayData* out_arr = out->mutable_array();
     auto out_data = out_arr->GetMutableValues<OutValue>(1);
@@ -70,8 +69,8 @@ struct CumulativeGeneric {
       VisitArrayValuesInline<ArgType>(
           arg0,
           [&](ArgValue v) {
-            partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v,
-                                                                          partial_scan, &st);
+            partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
+                ctx, v, partial_scan, &st);
             *out_data++ = partial_scan;
           },
           [&]() {
@@ -88,8 +87,8 @@ struct CumulativeGeneric {
             if (encounted_null) {
               *out_data++ = OutValue{};
             } else {
-              partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v,
-                                                                            partial_scan, &st);    
+              partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
+                  ctx, v, partial_scan, &st);
               *out_data++ = partial_scan;
               ++start_null_idx;
             }
@@ -97,10 +96,7 @@ struct CumulativeGeneric {
           [&]() {
             // null
             *out_data++ = OutValue{};
-            if (!encounted_null) {
-              ++start_null_idx;
-              encounted_null = true;
-            }
+            encounted_null = true;
           });
 
       auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
@@ -121,8 +117,8 @@ const FunctionDoc cumulative_sum_doc{
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto options = CumulativeGenericOptions::Defaults();
-  auto cumulative_sum = std::make_shared<VectorFunction>(
-      "cumulative_sum", Arity::Unary(), &cumulative_sum_doc, &options);
+  auto cumulative_sum = std::make_shared<VectorFunction>("cumulative_sum", Arity::Unary(),
+                                                         &cumulative_sum_doc, &options);
 
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
@@ -133,7 +129,8 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Add, CumulativeGenericOptions>(ty);
+    kernel.exec =
+        ArithmeticExecFromOp<CumulativeGeneric, Add, CumulativeGenericOptions>(ty);
     kernel.init = OptionsWrapper<CumulativeGenericOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 2eeb92eb44f..d347895e3c7 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -1,4 +1,7 @@
-// Licensed to the Apache Software Foundation (ASF) under one // or more contributor license agreements.  See the NOTICE file // distributed with this work for additional information // regarding copyright ownership.  The ASF licenses this file
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
@@ -59,8 +62,9 @@ class TestCumulativeSum : public ::testing::Test {
   void SetUp() override {}
 
   void Assert(const std::shared_ptr<Array>& expected, const std::shared_ptr<Array>& input,
-                                const CumulativeGenericOptions& options) {
-    ASSERT_OK_AND_ASSIGN(auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
+              const CumulativeGenericOptions& options) {
+    ASSERT_OK_AND_ASSIGN(
+        auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
     AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
   }
 };
@@ -84,10 +88,31 @@ TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {
   this->Assert(expected, values, options);
 }
 
+TYPED_TEST(TestCumulativeSumIntegral, HasNullsNoSkipNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), false};
+  // CumulativeGenericOptions options;
+
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 5]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4, null, null]");
+  this->Assert(expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasNullsSkipNull) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
+  // CumulativeGenericOptions options;
+
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 5]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4, null, 9]");
+  this->Assert(expected, values, options);
+}
+
 // TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
 // TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
 // TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
 
-
 }  // namespace compute
 }  // namespace arrow

From 940c0c22fa109c054e3719ef6fb660c8dcdc92da Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 30 Mar 2022 14:08:15 -0400
Subject: [PATCH 15/67] Adding Tests for floating and temporal types

---
 cpp/src/arrow/compute/api_vector.h            |   3 -
 .../kernels/base_arithmetic_internal.h        |  17 +
 .../kernels/vector_cumulative_ops_test.cc     | 498 ++++++++++++++++--
 3 files changed, 483 insertions(+), 35 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index db00edda15f..e426ad19b19 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,9 +191,6 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
  public:
-  // explicit CumulativeGenericOptions(uint64_t start, bool skip_nulls = false);
-  // explicit CumulativeGenericOptions(int64_t start, bool skip_nulls = false);
-  // explicit CumulativeGenericOptions(double start, bool skip_nulls = false);
   explicit CumulativeGenericOptions(
       std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
       bool skip_nulls = false);
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index f29ed013b9a..e17fbb99f2d 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -1,3 +1,20 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
 #pragma once
 
 #include "arrow/compute/api_scalar.h"
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index d347895e3c7..55614ef32f7 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -37,6 +37,7 @@
 #include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
+#include "arrow/type_fwd.h"
 
 #include "arrow/compute/api.h"
 #include "arrow/compute/kernels/test_util.h"
@@ -48,71 +49,504 @@ namespace compute {
 
 using DurationTypes = testing::Types<DurationType, MonthIntervalType>;
 
+class TestCumulativeOp : public ::testing::Test {
+ protected:
+  void Assert(const std::string func, const std::shared_ptr<Array>& expected,
+              const std::shared_ptr<Array>& input,
+              const CumulativeGenericOptions& options) {
+    ASSERT_OK_AND_ASSIGN(auto result,
+                         CallFunction(func, {Datum(input)}, &options, nullptr));
+
+    AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
+  }
+};
+
 template <typename T>
-class TestCumulativeSum : public ::testing::Test {
+class TestCumulativeSumIntegral : public TestCumulativeOp {
  public:
-  using ArrowType = T;
-  // using CType = TypeTraits<Type>::CType;
+ using ArrowType = T;
 
  protected:
-  static std::shared_ptr<DataType> type_singleton() {
+  std::shared_ptr<DataType> type_singleton() {
     return TypeTraits<ArrowType>::type_singleton();
   }
+};
 
-  void SetUp() override {}
+template <typename T>
+class TestCumulativeSumFloating : public TestCumulativeOp {
+ public:
+ using ArrowType = T;
 
-  void Assert(const std::shared_ptr<Array>& expected, const std::shared_ptr<Array>& input,
-              const CumulativeGenericOptions& options) {
-    ASSERT_OK_AND_ASSIGN(
-        auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
-    AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
+ protected:
+  std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
   }
 };
 
-template <typename T>
-class TestCumulativeSumIntegral : public TestCumulativeSum<T> {};
+class TestCumulativeSumTemporal : public TestCumulativeOp {
+ protected:
+  void Assert(std::shared_ptr<DataType>& type, std::string& values, std::string& expected,
+              CumulativeGenericOptions& options) {
+    auto values_array = ArrayFromJSON(type, values);
+    auto expected_array = ArrayFromJSON(type, expected);
+    TestCumulativeOp::Assert("cumulative_sum", values_array, expected_array, options);
+  }
+};
 
 TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralArrowTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumFloating, RealArrowTypes);
+TYPED_TEST_SUITE(TestCumulativeSumFloating, RealArrowTypes);
 // TYPED_TEST_SUITE(TestCumulativeSumTemporal, TemporalArrowTypes);
 // TYPED_TEST_SUITE(TestCumulativeSumDecimal, DecimalArrowTypes);
 
-TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {
+TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, null, null, null]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, NoStartDoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, NoStartDoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 7, null, 13]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected =
+      ArrayFromJSON(this->type_singleton(), "[11, 13, null, null, null, null]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasStartDoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasStartDoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, null, 17, null, 23]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, NoStartNoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, NoStartNoSkipHasNulls) {
   using ArrowType = typename TestFixture::ArrowType;
 
   CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-  // CumulativeGenericOptions options;
 
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4]");
-  this->Assert(expected, values, options);
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, null, null, null]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
 }
 
-TYPED_TEST(TestCumulativeSumIntegral, HasNullsNoSkipNulls) {
+TYPED_TEST(TestCumulativeSumFloating, NoStartDoSkipNoNulls) {
   using ArrowType = typename TestFixture::ArrowType;
 
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), false};
-  // CumulativeGenericOptions options;
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
 
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 5]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4, null, null]");
-  this->Assert(expected, values, options);
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
 }
 
-TYPED_TEST(TestCumulativeSumIntegral, HasNullsSkipNull) {
+TYPED_TEST(TestCumulativeSumFloating, NoStartDoSkipHasNulls) {
   using ArrowType = typename TestFixture::ArrowType;
 
   CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-  // CumulativeGenericOptions options;
 
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 5]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4, null, 9]");
-  this->Assert(expected, values, options);
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 7, null, 13]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, HasStartNoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, HasStartNoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected =
+      ArrayFromJSON(this->type_singleton(), "[11, 13, null, null, null, null]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, HasStartDoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, HasStartDoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, null, 17, null, 23]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TEST_F(TestCumulativeSumTemporal, NoStartNoSkipNoNulls) {
+  auto empty = "[]";
+  auto time_values = "[1, 2, 3, 4, 5, 6]";
+  auto time_expected = "[1, 3, 6, 10, 15, 21]";
+  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+  auto date_expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0)};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0)};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0)};
+
+  this->Assert(date32(), empty, empty, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), empty, empty, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, NoStartNoSkipHasNulls) {
+  auto one_null = "[null]";
+  auto three_nulls = "[null, null, null]";
+  auto time_values = "[1, 2, null, 4, null, 6]";
+  auto time_expected = "[1, 3, null, null, null, null]";
+  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
+  auto date_expected = "[0, 86400000, null, null, null, null]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0)};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0)};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0)};
+
+  this->Assert(date32(), one_null, one_null, date_options);
+  this->Assert(date32(), three_nulls, three_nulls, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), one_null, one_null, date_options);
+  this->Assert(date64(), three_nulls, three_nulls, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, NoStartDoSkipNoNulls) {
+  auto empty = "[]";
+  auto time_values = "[1, 2, 3, 4, 5, 6]";
+  auto time_expected = "[1, 3, 6, 10, 15, 21]";
+  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+  auto date_expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0), true};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0), true};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0), true};
+
+  this->Assert(date32(), empty, empty, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), empty, empty, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, NoStartDoSkipHasNulls) {
+  auto one_null = "[null]";
+  auto three_nulls = "[null, null, null]";
+  auto time_values = "[1, 2, null, 4, null, 6]";
+  auto time_expected = "[1, 3, null, 7, null, 13]";
+  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
+  auto date_expected = "[0, 86400000, null, 345600000, null, 777600000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0), true};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0), true};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0), true};
+
+  this->Assert(date32(), one_null, one_null, date_options);
+  this->Assert(date32(), three_nulls, three_nulls, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), one_null, one_null, date_options);
+  this->Assert(date64(), three_nulls, three_nulls, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, HasStartNoSkipNoNulls) {
+  auto empty = "[]";
+  auto time_values = "[1, 2, 3, 4, 5, 6]";
+  auto time_expected = "[11, 13, 16, 20, 25, 31]";
+  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+  auto date_expected = "[86400000, 172800000, 345600000, 604800000, 950400000, 1382400000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000)};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10)};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10)};
+
+  this->Assert(date32(), empty, empty, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), empty, empty, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, HasStartNoSkipHasNulls) {
+  auto one_null = "[null]";
+  auto three_nulls = "[null, null, null]";
+  auto time_values = "[1, 2, null, 4, null, 6]";
+  auto time_expected = "[11, 13, null, null, null, null]";
+  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
+  auto date_expected = "[86400000, 172800000, null, null, null, null]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000)};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10)};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10)};
+
+  this->Assert(date32(), one_null, one_null, date_options);
+  this->Assert(date32(), three_nulls, three_nulls, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), one_null, one_null, date_options);
+  this->Assert(date64(), three_nulls, three_nulls, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
 }
 
-// TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
-// TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
-// TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
+TEST_F(TestCumulativeSumTemporal, HasStartDoSkipNoNulls) {
+  auto empty = "[]";
+  auto time_values = "[1, 2, 3, 4, 5, 6]";
+  auto time_expected = "[11, 13, 16, 20, 25, 31]";
+  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+  auto date_expected = "[86400000, 172800000, 345600000, 604800000, 950400000, 1382400000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000), true};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10), true};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10), true};
+
+  this->Assert(date32(), empty, empty, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), empty, empty, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, HasStartDoSkipHasNulls) {
+  auto one_null = "[null]";
+  auto three_nulls = "[null, null, null]";
+  auto time_values = "[1, 2, null, 4, null, 6]";
+  auto time_expected = "[11, 13, null, 17, null, 23]";
+  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
+  auto date_expected = "[86400000, 172800000, null, 429000000, null, 861000000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000), true};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10), true};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10), true};
+
+  this->Assert(date32(), one_null, one_null, date_options);
+  this->Assert(date32(), three_nulls, three_nulls, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), one_null, one_null, date_options);
+  this->Assert(date64(), three_nulls, three_nulls, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
 
 }  // namespace compute
 }  // namespace arrow

From 5802d01f1e6c41a0a585e1b1d850103005de5822 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 31 Mar 2022 18:15:29 -0400
Subject: [PATCH 16/67] Simplified CumulateSum tests

---
 .../compute/kernels/vector_cumulative_ops.cc  |  52 +-
 .../kernels/vector_cumulative_ops_test.cc     | 630 +++++-------------
 2 files changed, 194 insertions(+), 488 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index a29a50f8849..a4e9ab15952 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -65,42 +65,31 @@ struct CumulativeGeneric {
     ArrayData* out_arr = out->mutable_array();
     auto out_data = out_arr->GetMutableValues<OutValue>(1);
 
-    if (skip_nulls) {
-      VisitArrayValuesInline<ArgType>(
-          arg0,
-          [&](ArgValue v) {
+    bool encounted_null = false;
+    auto start_null_idx = arg0.offset;
+
+    VisitArrayValuesInline<ArgType>(
+        arg0,
+        [&](ArgValue v) {
+          if (!skip_nulls && encounted_null) {
+            *out_data++ = OutValue{};
+          } else {
             partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
                 ctx, v, partial_scan, &st);
             *out_data++ = partial_scan;
-          },
-          [&]() {
-            // null
-            *out_data++ = OutValue{};
-          });
-    } else {
-      bool encounted_null = false;
-      auto start_null_idx = arg0.offset;
-
-      VisitArrayValuesInline<ArgType>(
-          arg0,
-          [&](ArgValue v) {
-            if (encounted_null) {
-              *out_data++ = OutValue{};
-            } else {
-              partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
-                  ctx, v, partial_scan, &st);
-              *out_data++ = partial_scan;
-              ++start_null_idx;
-            }
-          },
-          [&]() {
-            // null
-            *out_data++ = OutValue{};
-            encounted_null = true;
-          });
-
+            ++start_null_idx;
+          }
+        },
+        [&]() {
+          // null
+          *out_data++ = OutValue{};
+          encounted_null = true;
+        });
+
+    if (!skip_nulls) {
       auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
       auto null_length = arg0.length - (start_null_idx - arg0.offset);
+      out_arr->SetNullCount(null_length);
       arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
     }
 
@@ -122,6 +111,7 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
 
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
+  types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
 
   for (const auto& ty : NumericTypes()) {
     VectorKernel kernel;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 55614ef32f7..2b7b05f1f51 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -31,9 +31,6 @@
 #include "arrow/array.h"
 #include "arrow/array/builder_decimal.h"
 #include "arrow/buffer.h"
-#include "arrow/chunked_array.h"
-#include "arrow/compute/api_vector.h"
-#include "arrow/status.h"
 #include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
@@ -47,12 +44,29 @@
 namespace arrow {
 namespace compute {
 
-using DurationTypes = testing::Types<DurationType, MonthIntervalType>;
+using CumulativeTypes =
+    testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int8Type, Int16Type,
+                   Int32Type, Int64Type, FloatType, DoubleType>;
 
+//  Date32Type, Date64Type, Time32Type, Time64Type,
+//  TimestampType, DurationType, MonthIntervalType>;
+
+template <typename T>
 class TestCumulativeOp : public ::testing::Test {
+ public:
+  using ArrowType = T;
+  using ArrowScalar = typename TypeTraits<T>::ScalarType;
+  using CType = typename TypeTraits<T>::CType;
+
  protected:
-  void Assert(const std::string func, const std::shared_ptr<Array>& expected,
-              const std::shared_ptr<Array>& input,
+  std::shared_ptr<DataType> type_singleton() { return default_type_instance<T>(); }
+
+  std::shared_ptr<Array> array(const std::string& value) {
+    return ArrayFromJSON(type_singleton(), value);
+  }
+
+  void Assert(const std::string func, const std::shared_ptr<Array>& input,
+              const std::shared_ptr<Array>& expected,
               const CumulativeGenericOptions& options) {
     ASSERT_OK_AND_ASSIGN(auto result,
                          CallFunction(func, {Datum(input)}, &options, nullptr));
@@ -62,490 +76,192 @@ class TestCumulativeOp : public ::testing::Test {
 };
 
 template <typename T>
-class TestCumulativeSumIntegral : public TestCumulativeOp {
+class TestCumulativeSum : public TestCumulativeOp<T> {
  public:
- using ArrowType = T;
+  using ArrowType = typename TestCumulativeOp<T>::ArrowType;
+  using ArrowScalar = typename TestCumulativeOp<T>::ArrowScalar;
+  using CType = typename TestCumulativeOp<T>::CType;
 
  protected:
-  std::shared_ptr<DataType> type_singleton() {
-    return TypeTraits<ArrowType>::type_singleton();
+  template <typename U = T>
+  enable_if_parameter_free<U, CumulativeGenericOptions> generate_options(
+      CType start = 0, bool skip_nulls = false) {
+    return CumulativeGenericOptions(std::make_shared<ArrowScalar>(start), skip_nulls);
   }
-};
-
-template <typename T>
-class TestCumulativeSumFloating : public TestCumulativeOp {
- public:
- using ArrowType = T;
 
- protected:
-  std::shared_ptr<DataType> type_singleton() {
-    return TypeTraits<ArrowType>::type_singleton();
+  template <typename U = T>
+  enable_if_t<is_time_type<U>::value || is_timestamp_type<U>::value,
+              CumulativeGenericOptions>
+  generate_options(CType start = 0, bool skip_nulls = false) {
+    TimeUnit::type unit;
+    switch (ArrowType::type_id) {
+      case Type::TIME64:
+        unit = TimeUnit::NANO;
+        break;
+      default:
+        unit = TimeUnit::SECOND;
+        break;
+    }
+    return CumulativeGenericOptions(std::make_shared<ArrowScalar>(start, unit),
+                                    skip_nulls);
   }
-};
 
-class TestCumulativeSumTemporal : public TestCumulativeOp {
- protected:
-  void Assert(std::shared_ptr<DataType>& type, std::string& values, std::string& expected,
-              CumulativeGenericOptions& options) {
-    auto values_array = ArrayFromJSON(type, values);
-    auto expected_array = ArrayFromJSON(type, expected);
-    TestCumulativeOp::Assert("cumulative_sum", values_array, expected_array, options);
+  void Assert(const std::string& values, const std::string& expected,
+              const CumulativeGenericOptions& options) {
+    auto values_arr = TestCumulativeOp<T>::array(values);
+    auto expected_arr = TestCumulativeOp<T>::array(expected);
+    TestCumulativeOp<T>::Assert("cumulative_sum", values_arr, expected_arr, options);
   }
 };
 
-TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralArrowTypes);
-TYPED_TEST_SUITE(TestCumulativeSumFloating, RealArrowTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumTemporal, TemporalArrowTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumDecimal, DecimalArrowTypes);
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, null, null, null]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartDoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartDoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 7, null, 13]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected =
-      ArrayFromJSON(this->type_singleton(), "[11, 13, null, null, null, null]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, HasStartDoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, HasStartDoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, null, 17, null, 23]");
+TYPED_TEST_SUITE(TestCumulativeSum, CumulativeTypes);
 
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, NoStartNoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, NoStartNoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, null, null, null]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, NoStartDoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, NoStartDoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 7, null, 13]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, HasStartNoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, HasStartNoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected =
-      ArrayFromJSON(this->type_singleton(), "[11, 13, null, null, null, null]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, HasStartDoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, HasStartDoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, null, 17, null, 23]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TEST_F(TestCumulativeSumTemporal, NoStartNoSkipNoNulls) {
+TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
+  CumulativeGenericOptions options = this->generate_options();
   auto empty = "[]";
-  auto time_values = "[1, 2, 3, 4, 5, 6]";
-  auto time_expected = "[1, 3, 6, 10, 15, 21]";
-  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-  auto date_expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0)};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0)};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0)};
-
-  this->Assert(date32(), empty, empty, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), empty, empty, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(empty, empty, options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+    auto expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
+    this->Assert(values, expected, options);
+  } else {
+    auto values = "[1, 2, 3, 4, 5, 6]";
+    auto expected = "[1, 3, 6, 10, 15, 21]";
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, NoStartNoSkipHasNulls) {
+TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
+  CumulativeGenericOptions options = this->generate_options();
   auto one_null = "[null]";
-  auto three_nulls = "[null, null, null]";
-  auto time_values = "[1, 2, null, 4, null, 6]";
-  auto time_expected = "[1, 3, null, null, null, null]";
-  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
-  auto date_expected = "[0, 86400000, null, null, null, null]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0)};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0)};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0)};
-
-  this->Assert(date32(), one_null, one_null, date_options);
-  this->Assert(date32(), three_nulls, three_nulls, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), one_null, one_null, date_options);
-  this->Assert(date64(), three_nulls, three_nulls, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  auto three_null = "[null, null, null]";
+  this->Assert(one_null, one_null, options);
+  this->Assert(three_null, three_null, options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    auto values = "[0, 86400000, null, 259200000, null, 432000000]";
+    auto expected = "[0, 86400000, null, null, null, null]";
+    this->Assert(values, expected, options);
+  } else {
+    auto values = "[1, 2, null, 4, null, 6]";
+    auto expected = "[1, 3, null, null, null, null]";
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, NoStartDoSkipNoNulls) {
+TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
+  CumulativeGenericOptions options = this->generate_options(0, true);
   auto empty = "[]";
-  auto time_values = "[1, 2, 3, 4, 5, 6]";
-  auto time_expected = "[1, 3, 6, 10, 15, 21]";
-  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-  auto date_expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0), true};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0), true};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0), true};
-
-  this->Assert(date32(), empty, empty, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), empty, empty, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(empty, empty, options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+    auto expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
+    this->Assert(values, expected, options);
+  } else {
+    auto values = "[1, 2, 3, 4, 5, 6]";
+    auto expected = "[1, 3, 6, 10, 15, 21]";
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, NoStartDoSkipHasNulls) {
+TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
+  CumulativeGenericOptions options = this->generate_options(0, true);
   auto one_null = "[null]";
-  auto three_nulls = "[null, null, null]";
-  auto time_values = "[1, 2, null, 4, null, 6]";
-  auto time_expected = "[1, 3, null, 7, null, 13]";
-  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
-  auto date_expected = "[0, 86400000, null, 345600000, null, 777600000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0), true};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0), true};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0), true};
-
-  this->Assert(date32(), one_null, one_null, date_options);
-  this->Assert(date32(), three_nulls, three_nulls, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), one_null, one_null, date_options);
-  this->Assert(date64(), three_nulls, three_nulls, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  auto three_null = "[null, null, null]";
+  this->Assert(one_null, one_null, options);
+  this->Assert(three_null, three_null, options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    auto values = "[0, 86400000, null, 259200000, null, 432000000]";
+    auto expected = "[0, 86400000, null, 345600000, null, 777600000]";
+    this->Assert(values, expected, options);
+  } else {
+    auto values = "[1, 2, null, 4, null, 6]";
+    auto expected = "[1, 3, null, 7, null, 13]";
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, HasStartNoSkipNoNulls) {
+TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
   auto empty = "[]";
-  auto time_values = "[1, 2, 3, 4, 5, 6]";
-  auto time_expected = "[11, 13, 16, 20, 25, 31]";
-  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-  auto date_expected = "[86400000, 172800000, 345600000, 604800000, 950400000, 1382400000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000)};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10)};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10)};
-
-  this->Assert(date32(), empty, empty, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), empty, empty, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    // CumulativeGenericOptions options = this->generate_options(86400000);
+    // auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+    // auto expected = "[86400000, 172800000, 345600000, 604800000, 950400000,
+    // 1382400000]";
+    // this->Assert(empty, empty, options);
+    // this->Assert(values, expected, options);
+  } else {
+    CumulativeGenericOptions options = this->generate_options(10);
+    auto values = "[1, 2, 3, 4, 5, 6]";
+    auto expected = "[11, 13, 16, 20, 25, 31]";
+    this->Assert(empty, empty, options);
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, HasStartNoSkipHasNulls) {
+TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
   auto one_null = "[null]";
-  auto three_nulls = "[null, null, null]";
-  auto time_values = "[1, 2, null, 4, null, 6]";
-  auto time_expected = "[11, 13, null, null, null, null]";
-  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
-  auto date_expected = "[86400000, 172800000, null, null, null, null]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000)};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10)};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10)};
-
-  this->Assert(date32(), one_null, one_null, date_options);
-  this->Assert(date32(), three_nulls, three_nulls, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), one_null, one_null, date_options);
-  this->Assert(date64(), three_nulls, three_nulls, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  auto three_null = "[null, null, null]";
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    // CumulativeGenericOptions options = this->generate_options(86400000);
+    // auto values = "[0, 86400000, null, 259200000, null, 432000000]";
+    // auto expected = "[86400000, 172800000, null, null, null, null]";
+    // this->Assert(one_null, one_null, options);
+    // this->Assert(three_null, three_null, options);
+    // this->Assert(values, expected, options);
+  } else {
+    CumulativeGenericOptions options = this->generate_options(10);
+    auto values = "[1, 2, null, 4, null, 6]";
+    auto expected = "[11, 13, null, null, null, null]";
+    this->Assert(one_null, one_null, options);
+    this->Assert(three_null, three_null, options);
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, HasStartDoSkipNoNulls) {
+TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
   auto empty = "[]";
-  auto time_values = "[1, 2, 3, 4, 5, 6]";
-  auto time_expected = "[11, 13, 16, 20, 25, 31]";
-  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-  auto date_expected = "[86400000, 172800000, 345600000, 604800000, 950400000, 1382400000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000), true};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10), true};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10), true};
-
-  this->Assert(date32(), empty, empty, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), empty, empty, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    // CumulativeGenericOptions options = this->generate_options(86400000, true);
+    // auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+    // auto expected = "[86400000, 172800000, 345600000, 604800000, 950400000,
+    // 1382400000]";
+    // this->Assert(empty, empty, options);
+    // this->Assert(values, expected, options);
+  } else {
+    CumulativeGenericOptions options = this->generate_options(10, true);
+    auto values = "[1, 2, 3, 4, 5, 6]";
+    auto expected = "[11, 13, 16, 20, 25, 31]";
+    this->Assert(empty, empty, options);
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, HasStartDoSkipHasNulls) {
+TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
   auto one_null = "[null]";
-  auto three_nulls = "[null, null, null]";
-  auto time_values = "[1, 2, null, 4, null, 6]";
-  auto time_expected = "[11, 13, null, 17, null, 23]";
-  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
-  auto date_expected = "[86400000, 172800000, null, 429000000, null, 861000000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000), true};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10), true};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10), true};
-
-  this->Assert(date32(), one_null, one_null, date_options);
-  this->Assert(date32(), three_nulls, three_nulls, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), one_null, one_null, date_options);
-  this->Assert(date64(), three_nulls, three_nulls, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  auto three_null = "[null, null, null]";
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    // CumulativeGenericOptions options = this->generate_options(86400000, true);
+    // auto values = "[0, 86400000, null, 259200000, null, 432000000]";
+    // auto expected = "[86400000, 172800000, null, 432000000, null, 864000000]";
+    // this->Assert(one_null, one_null, options);
+    // this->Assert(three_null, three_null, options);
+    // this->Assert(values, expected, options);
+  } else {
+    CumulativeGenericOptions options = this->generate_options(10, true);
+    auto values = "[1, 2, null, 4, null, 6]";
+    auto expected = "[11, 13, null, 17, null, 23]";
+    this->Assert(one_null, one_null, options);
+    this->Assert(three_null, three_null, options);
+    this->Assert(values, expected, options);
+  }
 }
 
 }  // namespace compute

From a4a7d37723787ccaddbc08fbcd2070c53336d84e Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 1 Apr 2022 16:20:06 -0400
Subject: [PATCH 17/67] Added "Checked" version for overflow detection

---
 cpp/src/arrow/compute/api_vector.cc           |  19 +--
 cpp/src/arrow/compute/api_vector.h            |   5 +-
 .../compute/kernels/vector_cumulative_ops.cc  |  43 +++--
 .../kernels/vector_cumulative_ops_test.cc     | 158 ++++++------------
 4 files changed, 90 insertions(+), 135 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 6717670e9b5..27b1a5e520a 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -180,20 +180,12 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-// CumulativeGenericOptions::CumulativeGenericOptions(uint64_t start, bool skip_nulls)
-//     : CumulativeGenericOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
-//
-// CumulativeGenericOptions::CumulativeGenericOptions(int64_t start, bool skip_nulls)
-//     : CumulativeGenericOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
-//
-// CumulativeGenericOptions::CumulativeGenericOptions(double start, bool skip_nulls)
-//     : CumulativeGenericOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
-
 CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start,
-                                                   bool skip_nulls)
+                                                   bool skip_nulls, bool check_overflow)
     : FunctionOptions(internal::kCumulativeGenericOptionsType),
       start(std::move(start)),
-      skip_nulls(skip_nulls) {}
+      skip_nulls(skip_nulls),
+      check_overflow(check_overflow) {}
 constexpr char CumulativeGenericOptions::kTypeName[];
 
 namespace internal {
@@ -348,9 +340,8 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
 
 Result<Datum> CumulativeSum(const Datum& values, const CumulativeGenericOptions& options,
                             ExecContext* ctx) {
-  ARROW_ASSIGN_OR_RAISE(Datum out,
-                        CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
-  return out.make_array();
+  auto func_name = (options.check_overflow) ? "cumulative_sum_checked" : "cumulative_sum";
+  return CallFunction(func_name, {Datum(values)}, &options, ctx);
 }
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index e426ad19b19..86e39ac818d 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -193,7 +193,7 @@ class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
  public:
   explicit CumulativeGenericOptions(
       std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
-      bool skip_nulls = false);
+      bool skip_nulls = false, bool checked_overflow = false);
   static constexpr char const kTypeName[] = "CumulativeGenericOptions";
   static CumulativeGenericOptions Defaults() { return CumulativeGenericOptions(); }
 
@@ -202,6 +202,9 @@ class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
 
   /// When false, propagates the first null/NaN encountered
   bool skip_nulls = false;
+
+  /// When true, returns an Invalid Status when overflow is detected
+  bool check_overflow = false;
 };
 
 /// @}
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index a4e9ab15952..d914fff4e10 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -100,32 +100,51 @@ struct CumulativeGeneric {
 const FunctionDoc cumulative_sum_doc{
     "Compute the cumulative sum over an array of numbers",
     ("`values` must be an array of numeric type values.\n"
-     "Return an array which is the cumulative sum computed over `values.`"),
+     "Return an array which is the cumulative sum computed over `values`.\n"
+     "Results will wrap around on integer overflow.\n"
+     "Use function \"cumulative_sum_checked\" if you want overflow\n"
+     "to return an error."),
     {"values"},
     "CumulativeGenericOptions"};
 
-void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-  auto options = CumulativeGenericOptions::Defaults();
-  auto cumulative_sum = std::make_shared<VectorFunction>("cumulative_sum", Arity::Unary(),
-                                                         &cumulative_sum_doc, &options);
+const FunctionDoc cumulative_sum_checked_doc{
+    "Compute the cumulative sum over an array of numbers",
+    ("`values` must be an array of numeric type values.\n"
+     "Return an array which is the cumulative sum computed over `values`.\n"
+     "This function returns an error on overflow. For a variant that\n"
+     "doesn't fail on overflow, use function \"cumulative_sum\"."),
+    {"values"},
+    "CumulativeGenericOptions"};
+
+template <typename Op, typename OptionsType>
+void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string func_name,
+                                  const FunctionDoc* doc) {
+  auto options = OptionsType::Defaults();
+  auto cumulative_func =
+      std::make_shared<VectorFunction>(func_name, Arity::Unary(), doc, &options);
 
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
-  types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
 
-  for (const auto& ty : NumericTypes()) {
+  for (const auto& ty : types) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = false;
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec =
-        ArithmeticExecFromOp<CumulativeGeneric, Add, CumulativeGenericOptions>(ty);
-    kernel.init = OptionsWrapper<CumulativeGenericOptions>::Init;
-    DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
+    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Op, OptionsType>(ty);
+    kernel.init = OptionsWrapper<OptionsType>::Init;
+    DCHECK_OK(cumulative_func->AddKernel(std::move(kernel)));
   }
 
-  DCHECK_OK(registry->AddFunction(std::move(cumulative_sum)));
+  DCHECK_OK(registry->AddFunction(std::move(cumulative_func)));
+}
+
+void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
+  MakeVectorCumulativeFunction<Add, CumulativeGenericOptions>(registry, "cumulative_sum",
+                                                              &cumulative_sum_doc);
+  MakeVectorCumulativeFunction<AddChecked, CumulativeGenericOptions>(
+      registry, "cumulative_sum_checked", &cumulative_sum_checked_doc);
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 2b7b05f1f51..c74b28e52b1 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -48,9 +48,6 @@ using CumulativeTypes =
     testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int8Type, Int16Type,
                    Int32Type, Int64Type, FloatType, DoubleType>;
 
-//  Date32Type, Date64Type, Time32Type, Time64Type,
-//  TimestampType, DurationType, MonthIntervalType>;
-
 template <typename T>
 class TestCumulativeOp : public ::testing::Test {
  public:
@@ -65,14 +62,27 @@ class TestCumulativeOp : public ::testing::Test {
     return ArrayFromJSON(type_singleton(), value);
   }
 
-  void Assert(const std::string func, const std::shared_ptr<Array>& input,
-              const std::shared_ptr<Array>& expected,
-              const CumulativeGenericOptions& options) {
+  template <typename V = T>
+  enable_if_t<!is_floating_type<V>::value, void> Assert(
+      const std::string func, const std::shared_ptr<Array>& input,
+      const std::shared_ptr<Array>& expected, const CumulativeGenericOptions& options) {
     ASSERT_OK_AND_ASSIGN(auto result,
                          CallFunction(func, {Datum(input)}, &options, nullptr));
 
     AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
   }
+
+  template <typename V = T>
+  enable_if_floating_point<V> Assert(const std::string func,
+                                     const std::shared_ptr<Array>& input,
+                                     const std::shared_ptr<Array>& expected,
+                                     const CumulativeGenericOptions& options) {
+    ASSERT_OK_AND_ASSIGN(auto result,
+                         CallFunction(func, {Datum(input)}, &options, nullptr));
+
+    AssertArraysApproxEqual(*expected, *result.make_array(), false,
+                            EqualOptions::Defaults());
+  }
 };
 
 template <typename T>
@@ -119,149 +129,81 @@ TYPED_TEST_SUITE(TestCumulativeSum, CumulativeTypes);
 TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
   CumulativeGenericOptions options = this->generate_options();
   auto empty = "[]";
+  auto values = "[1, 2, 3, 4, 5, 6]";
+  auto expected = "[1, 3, 6, 10, 15, 21]";
   this->Assert(empty, empty, options);
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-    auto expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
-    this->Assert(values, expected, options);
-  } else {
-    auto values = "[1, 2, 3, 4, 5, 6]";
-    auto expected = "[1, 3, 6, 10, 15, 21]";
-    this->Assert(values, expected, options);
-  }
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
   CumulativeGenericOptions options = this->generate_options();
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
+  auto values = "[1, 2, null, 4, null, 6]";
+  auto expected = "[1, 3, null, null, null, null]";
   this->Assert(one_null, one_null, options);
   this->Assert(three_null, three_null, options);
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    auto values = "[0, 86400000, null, 259200000, null, 432000000]";
-    auto expected = "[0, 86400000, null, null, null, null]";
-    this->Assert(values, expected, options);
-  } else {
-    auto values = "[1, 2, null, 4, null, 6]";
-    auto expected = "[1, 3, null, null, null, null]";
-    this->Assert(values, expected, options);
-  }
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
   CumulativeGenericOptions options = this->generate_options(0, true);
   auto empty = "[]";
+  auto values = "[1, 2, 3, 4, 5, 6]";
+  auto expected = "[1, 3, 6, 10, 15, 21]";
   this->Assert(empty, empty, options);
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-    auto expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
-    this->Assert(values, expected, options);
-  } else {
-    auto values = "[1, 2, 3, 4, 5, 6]";
-    auto expected = "[1, 3, 6, 10, 15, 21]";
-    this->Assert(values, expected, options);
-  }
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
   CumulativeGenericOptions options = this->generate_options(0, true);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
+  auto values = "[1, 2, null, 4, null, 6]";
+  auto expected = "[1, 3, null, 7, null, 13]";
   this->Assert(one_null, one_null, options);
   this->Assert(three_null, three_null, options);
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    auto values = "[0, 86400000, null, 259200000, null, 432000000]";
-    auto expected = "[0, 86400000, null, 345600000, null, 777600000]";
-    this->Assert(values, expected, options);
-  } else {
-    auto values = "[1, 2, null, 4, null, 6]";
-    auto expected = "[1, 3, null, 7, null, 13]";
-    this->Assert(values, expected, options);
-  }
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
+  CumulativeGenericOptions options = this->generate_options(10);
   auto empty = "[]";
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    // CumulativeGenericOptions options = this->generate_options(86400000);
-    // auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-    // auto expected = "[86400000, 172800000, 345600000, 604800000, 950400000,
-    // 1382400000]";
-    // this->Assert(empty, empty, options);
-    // this->Assert(values, expected, options);
-  } else {
-    CumulativeGenericOptions options = this->generate_options(10);
-    auto values = "[1, 2, 3, 4, 5, 6]";
-    auto expected = "[11, 13, 16, 20, 25, 31]";
-    this->Assert(empty, empty, options);
-    this->Assert(values, expected, options);
-  }
+  auto values = "[1, 2, 3, 4, 5, 6]";
+  auto expected = "[11, 13, 16, 20, 25, 31]";
+  this->Assert(empty, empty, options);
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
+  CumulativeGenericOptions options = this->generate_options(10);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    // CumulativeGenericOptions options = this->generate_options(86400000);
-    // auto values = "[0, 86400000, null, 259200000, null, 432000000]";
-    // auto expected = "[86400000, 172800000, null, null, null, null]";
-    // this->Assert(one_null, one_null, options);
-    // this->Assert(three_null, three_null, options);
-    // this->Assert(values, expected, options);
-  } else {
-    CumulativeGenericOptions options = this->generate_options(10);
-    auto values = "[1, 2, null, 4, null, 6]";
-    auto expected = "[11, 13, null, null, null, null]";
-    this->Assert(one_null, one_null, options);
-    this->Assert(three_null, three_null, options);
-    this->Assert(values, expected, options);
-  }
+  auto values = "[1, 2, null, 4, null, 6]";
+  auto expected = "[11, 13, null, null, null, null]";
+  this->Assert(one_null, one_null, options);
+  this->Assert(three_null, three_null, options);
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
+  CumulativeGenericOptions options = this->generate_options(10, true);
   auto empty = "[]";
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    // CumulativeGenericOptions options = this->generate_options(86400000, true);
-    // auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-    // auto expected = "[86400000, 172800000, 345600000, 604800000, 950400000,
-    // 1382400000]";
-    // this->Assert(empty, empty, options);
-    // this->Assert(values, expected, options);
-  } else {
-    CumulativeGenericOptions options = this->generate_options(10, true);
-    auto values = "[1, 2, 3, 4, 5, 6]";
-    auto expected = "[11, 13, 16, 20, 25, 31]";
-    this->Assert(empty, empty, options);
-    this->Assert(values, expected, options);
-  }
+  auto values = "[1, 2, 3, 4, 5, 6]";
+  auto expected = "[11, 13, 16, 20, 25, 31]";
+  this->Assert(empty, empty, options);
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
+  CumulativeGenericOptions options = this->generate_options(10, true);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    // CumulativeGenericOptions options = this->generate_options(86400000, true);
-    // auto values = "[0, 86400000, null, 259200000, null, 432000000]";
-    // auto expected = "[86400000, 172800000, null, 432000000, null, 864000000]";
-    // this->Assert(one_null, one_null, options);
-    // this->Assert(three_null, three_null, options);
-    // this->Assert(values, expected, options);
-  } else {
-    CumulativeGenericOptions options = this->generate_options(10, true);
-    auto values = "[1, 2, null, 4, null, 6]";
-    auto expected = "[11, 13, null, 17, null, 23]";
-    this->Assert(one_null, one_null, options);
-    this->Assert(three_null, three_null, options);
-    this->Assert(values, expected, options);
-  }
+  auto values = "[1, 2, null, 4, null, 6]";
+  auto expected = "[11, 13, null, 17, null, 23]";
+  this->Assert(one_null, one_null, options);
+  this->Assert(three_null, three_null, options);
+  this->Assert(values, expected, options);
 }
 
 }  // namespace compute

From 4501d7f290489cc9149cd17d5457d163659e35d4 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 17 Feb 2022 11:12:13 -0500
Subject: [PATCH 18/67] Creating new kernel for cumulative sum

---
 .../compute/kernels/vector_cumulative_sum.cc  | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
new file mode 100644
index 00000000000..9add6c7d2bd
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/array/array_base.h"
+#include "arrow/compute/kernels/common.h"
+#include "arrow/result.h"
+#include "arrow/visit_type_inline.h"
+
+namespace arrow {
+namespace compute {
+namespace internal {
+namespace {
+
+Status CumulativeSum(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+  const ArrayData& array = *batch[0].array();
+  ArrayData* output = out->array().get();
+  output->length = array.length;
+  
+  return Status::OK();
+}
+
+void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
+
+}
+
+}
+
+}  // namespace internal
+}  // namespace compute
+}  // namespace arrow
\ No newline at end of file

From 634273ed6680a4fd9e059c819d5ec5d72f8b0624 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 24 Feb 2022 21:28:55 -0500
Subject: [PATCH 19/67] Now made a scalar function; Created struct to hold exec
 and kernel signature generation

---
 .../compute/kernels/scalar_cumulative_sum.cc  | 88 +++++++++++++++++++
 .../compute/kernels/vector_cumulative_sum.cc  | 44 ----------
 2 files changed, 88 insertions(+), 44 deletions(-)
 create mode 100644 cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
 delete mode 100644 cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc

diff --git a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
new file mode 100644
index 00000000000..cbd8ed3c416
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
@@ -0,0 +1,88 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/array/array_base.h"
+#include "arrow/compute/kernels/common.h"
+#include "arrow/result.h"
+#include "arrow/visit_type_inline.h"
+
+namespace arrow {
+namespace compute {
+namespace internal {
+namespace {
+
+template <typename Type>
+struct CumulativeSumFunctor {
+  Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    using CType = TypeTraits<Type>::CType;
+    
+    const ArrayData& array = *batch[0].array();
+    auto data = array.GetValues<CType*>(1, array.offset);
+
+    const NumericScalar& start = checked_cast<const NumericScalar&>(*batch[1].scalar());
+    CType sum = start.value;
+
+    ArrayData* output = out->array().get();
+    CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
+    output->length = array.length;
+
+    for(size_t i = array.offset; i < array.length; ++i) {
+      sum += data[i];
+      out_values[i] = sum;
+    }
+    
+    return Status::OK();
+  }
+
+  static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
+    return KernelSignature::Make(
+        {InputType::Array(get_id.id), InputType::Scalar(get_id.id), OutputType(FirstType));
+  }
+};
+
+const FunctionDoc cumulative_sum_doc(
+    "Compute the cumulative sum of an array",
+    ("Return an array containing the result of the cumulative sum\n"
+     "computed over the input array"),
+    {"values", "starting sum"});
+
+void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
+
+  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
+    ScalarKernel kernel;
+    kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
+    kernel.signature = CumulativeSumFunctor<NumberType>::GetSignature(get_id.id);
+    kernel.exec = std::move(exec);
+    DCHECK_OK(func->AddKernel(std::move(kernel)));
+  };
+
+  auto cumulative_sum =
+      std::make_shared<ScalarFunction>("cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
+  
+  for(auto ty : NumericTypes()) {
+    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSumFunctor>(ty));
+  }
+
+  DCHECK_OK(registry->AddFunction(std::move(flatten)));
+  
+}
+
+}
+
+}  // namespace internal
+}  // namespace compute
+}  // namespace arrow
\ No newline at end of file
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
deleted file mode 100644
index 9add6c7d2bd..00000000000
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include "arrow/array/array_base.h"
-#include "arrow/compute/kernels/common.h"
-#include "arrow/result.h"
-#include "arrow/visit_type_inline.h"
-
-namespace arrow {
-namespace compute {
-namespace internal {
-namespace {
-
-Status CumulativeSum(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-  const ArrayData& array = *batch[0].array();
-  ArrayData* output = out->array().get();
-  output->length = array.length;
-  
-  return Status::OK();
-}
-
-void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-
-}
-
-}
-
-}  // namespace internal
-}  // namespace compute
-}  // namespace arrow
\ No newline at end of file

From fc388d7f14c1e3870aeb26caf34d2e91c29c143b Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 1 Mar 2022 23:13:12 -0500
Subject: [PATCH 20/67] Changed handle chunked arrays and arrays with null
 indicies

---
 .../compute/kernels/scalar_cumulative_sum.cc  | 119 +++++++++++++-----
 1 file changed, 89 insertions(+), 30 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
index cbd8ed3c416..d02194b5dc6 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
@@ -25,44 +25,103 @@ namespace compute {
 namespace internal {
 namespace {
 
+template <typename CType>
+CType CumulativeSum(std::shared_ptr<Array>& input, ArrayData* output, CType start) {
+  CType sum = start;
+  CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
+  CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
+  for (size_t i = input->offset; i < input->length; ++i) {
+    if (input->IsValid(i)) {
+      sum += data[i];
+      out_values[i] = sum;
+    }
+  }
+
+  return sum;
+}
+
 template <typename Type>
 struct CumulativeSumFunctor {
+  using CType = TypeTraits<Type>::CType;
+
   Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    using CType = TypeTraits<Type>::CType;
-    
-    const ArrayData& array = *batch[0].array();
-    auto data = array.GetValues<CType*>(1, array.offset);
+    const NumericScalar& start_scalar =
+        checked_cast<const NumericScalar&>(*batch[1].scalar());
+    CType start = start_scalar.value;
 
-    const NumericScalar& start = checked_cast<const NumericScalar&>(*batch[1].scalar());
-    CType sum = start.value;
+    switch (batch[0].kind()) {
+      case Datum::ARRAY:
+        std::shared_ptr<Array> input = batch[0].make_array();
+        ArrayData* output = out->array().get();
 
-    ArrayData* output = out->array().get();
-    CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
-    output->length = array.length;
+        output->length = input->data()->length;
+        *output->type = std::move(input->type());
+        uint8_t* out_bitmap = output->buffers[0]->mutable_data();
+        int64_t out_offset = input->offset();
 
-    for(size_t i = array.offset; i < array.length; ++i) {
-      sum += data[i];
-      out_values[i] = sum;
+        if (input->data()->MayHaveNulls()) {
+          arrow::internal::CopyBitmap(input->null_bitmap_data(), input->offset(),
+                                      input->length(), out_bitmap, out_offset);
+          output->null_count = input->null_count();
+        } else {
+          bit_util::SetBitsTo(out_bitmap, out_offset, input->length(), true);
+          output->null_count = 0;
+        }
+
+        CumulativeSum(input, output, start);
+        return Status::OK();
+      case Datum::CHUNKED_ARRAY:
+        const auto& input = batch[0].chunked_array();
+
+        ArrayVector out_chunks;
+        for (const auto& chunk : input->chunks()) {
+          auto out_chunk = std::make_shared<ArrayData>(
+              chunk->type(), chunk->length(), chunk->null_count(), chunk->offset());
+
+          uint8_t* out_chunk_bitmap = out_chunk->buffers[0]->mutable_data();
+          if (chunk->data()->MayHaveNulls()) {
+            arrow::internal::CopyBitmap(chunk->null_bitmap_data(), chunk->offset(),
+                                        chunk->length(), out_chunk_bitmap,
+                                        out_chunk->offset());
+            out_chunk->null_count = chunk->null_count();
+          } else {
+            bit_util::SetBitsTo(out_chunk_bitmap, out_chunk->offset(), chunk->length(),
+                                true);
+            out_chunk->null_count = 0;
+          }
+
+          CType last_value = CumulativeSum(chunk, out_chunk, start);
+          start = last_value;
+          out_chunks.push_back(MakeArray(std::move(out_chunk)));
+        }
+
+        *out->chunked_array() = ChunkedArray(out_chunks, input->type());
+        return Status::OK();
+      default:
+        return Status::NotImplemented(
+            "Unsupported input type for function 'cumulative_sum': ",
+            batch[0].ToString());
     }
-    
-    return Status::OK();
   }
 
   static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
     return KernelSignature::Make(
-        {InputType::Array(get_id.id), InputType::Scalar(get_id.id), OutputType(FirstType));
+        {InputType::Array(get_id.id), InputType::Scalar(get_id.id)},
+        OutputType(FirstType));
   }
 };
 
 const FunctionDoc cumulative_sum_doc(
-    "Compute the cumulative sum of an array",
-    ("Return an array containing the result of the cumulative sum\n"
-     "computed over the input array"),
-    {"values", "starting sum"});
+    "Compute the cumulative sum over an array of numbers",
+    ("`values` must be an array of numeric type values.\n"
+     "`start` is a single value of the same type.\n"
+     "Return an array which is the cumulative sum computed over `values`\n"
+     "`start` is an optional starting sum of computation."),
+    {"values", "start"});
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-
-  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
+  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec,
+                        std::shared_ptr<ScalarFunction> func) {
     ScalarKernel kernel;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = CumulativeSumFunctor<NumberType>::GetSignature(get_id.id);
@@ -70,19 +129,19 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     DCHECK_OK(func->AddKernel(std::move(kernel)));
   };
 
-  auto cumulative_sum =
-      std::make_shared<ScalarFunction>("cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
-  
-  for(auto ty : NumericTypes()) {
-    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSumFunctor>(ty));
+  auto cumulative_sum = std::make_shared<ScalarFunction>(
+      "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
+
+  for (auto ty : NumericTypes()) {
+    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSumFunctor>(ty),
+               cumulative_sum);
   }
 
-  DCHECK_OK(registry->AddFunction(std::move(flatten)));
-  
+  DCHECK_OK(registry->AddFunction(std::move(cumulative_sum)));
 }
 
-}
+}  // namespace
 
 }  // namespace internal
 }  // namespace compute
-}  // namespace arrow
\ No newline at end of file
+}  // namespace arrow

From df3e6aea2835659e6f868fadfea5bab7994ffb1f Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 3 Mar 2022 23:56:42 -0500
Subject: [PATCH 21/67] Changed to vector function, starting creation
 corresponding test, included suggested changes

---
 ...lative_sum.cc => vector_cumulative_sum.cc} | 81 +++++++++++--------
 .../kernels/vector_cumulative_sum_test.cc     | 54 +++++++++++++
 cpp/src/arrow/compute/registry.cc             |  1 +
 cpp/src/arrow/compute/registry_internal.h     |  1 +
 4 files changed, 103 insertions(+), 34 deletions(-)
 rename cpp/src/arrow/compute/kernels/{scalar_cumulative_sum.cc => vector_cumulative_sum.cc} (70%)
 create mode 100644 cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc

diff --git a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
similarity index 70%
rename from cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
rename to cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index d02194b5dc6..cff80f886c0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include "arrow/array/array_base.h"
+#include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/result.h"
 #include "arrow/visit_type_inline.h"
@@ -23,30 +24,34 @@
 namespace arrow {
 namespace compute {
 namespace internal {
-namespace {
-
-template <typename CType>
-CType CumulativeSum(std::shared_ptr<Array>& input, ArrayData* output, CType start) {
-  CType sum = start;
-  CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
-  CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
-  for (size_t i = input->offset; i < input->length; ++i) {
-    if (input->IsValid(i)) {
-      sum += data[i];
-      out_values[i] = sum;
-    }
-  }
-
-  return sum;
-}
 
 template <typename Type>
-struct CumulativeSumFunctor {
+struct CumulativeSum {
   using CType = TypeTraits<Type>::CType;
+  using ScalarType = TypeTraits<Type>::ScalarType;
+
+  CType Sum(ExecContext* ctx, std::shared_ptr<Array>& input, ArrayData* output,
+            CType start) {
+    CType sum = start;
+    CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
+    CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
+    ArithmeticOptions options;
+    for (size_t i = input->offset; i < input->length; ++i) {
+      if (input->IsValid(i)) {
+        Datum value_datum(data[i]);
+        Datum sum_datum(sum);
+        auto result = Add(value_datum, sum_datum, options, ctx);
+        ScalarType result_scalar = result.ValueOrDie().scalar_as();
+        sum = result_scalar.value;
+        out_values[i] = sum;
+      }
+    }
+
+    return sum;
+  }
 
   Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const NumericScalar& start_scalar =
-        checked_cast<const NumericScalar&>(*batch[1].scalar());
+    const ScalarType& start_scalar = checked_cast<const ScalarType&>(*batch[1].scalar());
     CType start = start_scalar.value;
 
     switch (batch[0].kind()) {
@@ -68,7 +73,7 @@ struct CumulativeSumFunctor {
           output->null_count = 0;
         }
 
-        CumulativeSum(input, output, start);
+        Sum(ctx->exec_context(), input, output, start);
         return Status::OK();
       case Datum::CHUNKED_ARRAY:
         const auto& input = batch[0].chunked_array();
@@ -90,7 +95,7 @@ struct CumulativeSumFunctor {
             out_chunk->null_count = 0;
           }
 
-          CType last_value = CumulativeSum(chunk, out_chunk, start);
+          CType last_value = Sum(ctx->exec_context(), chunk, out_chunk, start);
           start = last_value;
           out_chunks.push_back(MakeArray(std::move(out_chunk)));
         }
@@ -115,33 +120,41 @@ const FunctionDoc cumulative_sum_doc(
     "Compute the cumulative sum over an array of numbers",
     ("`values` must be an array of numeric type values.\n"
      "`start` is a single value of the same type.\n"
-     "Return an array which is the cumulative sum computed over `values`\n"
+     "Return an array which is the cumulative sum computed over `values.`\n"
+     "Null entries remain in place but are not used in calucating sum.\n"
      "`start` is an optional starting sum of computation."),
     {"values", "start"});
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec,
-                        std::shared_ptr<ScalarFunction> func) {
-    ScalarKernel kernel;
+  auto cumulative_sum = std::make_shared<VectorFunction>(
+      "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
+
+  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
+    VectorKernel kernel;
+    kernel.can_execute_chunkwise = true;
+    kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = CumulativeSumFunctor<NumberType>::GetSignature(get_id.id);
+    kernel.signature = CumulativeSum<NumberType>::GetSignature(get_id.id);
     kernel.exec = std::move(exec);
-    DCHECK_OK(func->AddKernel(std::move(kernel)));
+    DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   };
 
-  auto cumulative_sum = std::make_shared<ScalarFunction>(
-      "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
-
   for (auto ty : NumericTypes()) {
-    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSumFunctor>(ty),
-               cumulative_sum);
+    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
   }
 
+  for (auto ty : TemporalTypes()) {
+    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
+  }
+
+  add_kernel(Type::DURATION,
+             GenerateTypeAgnosticPrimitive<CumulativeSum>(Type::DURATION));
+  add_kernel(Type::INTERVAL_MONTHS,
+             GenerateTypeAgnosticPrimitive<CumulativeSum>(Type::INTERVAL_MONTHS));
+
   DCHECK_OK(registry->AddFunction(std::move(cumulative_sum)));
 }
 
-}  // namespace
-
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
new file mode 100644
index 00000000000..dfeb492cb70
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -0,0 +1,54 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <locale>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "arrow/array.h"
+#include "arrow/array/builder_decimal.h"
+#include "arrow/buffer.h"
+#include "arrow/chunked_array.h"
+#include "arrow/status.h"
+#include "arrow/testing/util.h"
+#include "arrow/type.h"
+#include "arrow/type_fwd.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/checked_cast.h"
+#include "arrow/util/decimal.h"
+
+#include "arrow/compute/api.h"
+#include "arrow/compute/kernels/test_util.h"
+
+#include "arrow/ipc/json_simple.h"
+
+namespace arrow {
+namespace compute {
+
+class TestBaseCumulativeSum : public ::testing::Test {}
+
+}  // namespace compute
+}  // namespace arrow
diff --git a/cpp/src/arrow/compute/registry.cc b/cpp/src/arrow/compute/registry.cc
index 8ab83a72e5e..7e1975d3b68 100644
--- a/cpp/src/arrow/compute/registry.cc
+++ b/cpp/src/arrow/compute/registry.cc
@@ -174,6 +174,7 @@ static std::unique_ptr<FunctionRegistry> CreateBuiltInRegistry() {
 
   // Vector functions
   RegisterVectorArraySort(registry.get());
+  RegisterVectorCumulativeSum(registry.get());
   RegisterVectorHash(registry.get());
   RegisterVectorNested(registry.get());
   RegisterVectorReplace(registry.get());
diff --git a/cpp/src/arrow/compute/registry_internal.h b/cpp/src/arrow/compute/registry_internal.h
index 35f7b079529..38f81e98889 100644
--- a/cpp/src/arrow/compute/registry_internal.h
+++ b/cpp/src/arrow/compute/registry_internal.h
@@ -43,6 +43,7 @@ void RegisterScalarOptions(FunctionRegistry* registry);
 
 // Vector functions
 void RegisterVectorArraySort(FunctionRegistry* registry);
+void RegisterVectorCumulativeSum(FunctionRegistry* registry);
 void RegisterVectorHash(FunctionRegistry* registry);
 void RegisterVectorNested(FunctionRegistry* registry);
 void RegisterVectorReplace(FunctionRegistry* registry);

From 6f42a0f1bc82c2ed238e44fc61d3e67ef9cacfc5 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 8 Mar 2022 23:57:56 -0500
Subject: [PATCH 22/67] Starting value is now part of options; working more
 adding new test

---
 cpp/src/arrow/compute/api_vector.cc           | 23 +++++++++++++++++++
 cpp/src/arrow/compute/api_vector.h            | 21 +++++++++++++++++
 cpp/src/arrow/compute/kernels/CMakeLists.txt  |  1 +
 .../compute/kernels/vector_cumulative_sum.cc  |  9 ++++----
 docs/source/python/api/compute.rst            |  2 ++
 python/pyarrow/_compute.pyx                   | 20 ++++++++++++++++
 python/pyarrow/includes/libarrow.pxd          |  5 ++++
 python/pyarrow/tests/test_compute.py          |  1 +
 8 files changed, 77 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index a5cb61d6b55..c624ec0d942 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -135,6 +135,8 @@ static auto kPartitionNthOptionsType = GetFunctionOptionsType<PartitionNthOption
 static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
+static auto kCumulativeSumOptionsType = GetFunctionOptionsType<CumulativeSumOptions>(
+    DataMember("start", &CumulativeSumOptions::start));
 }  // namespace
 }  // namespace internal
 
@@ -176,6 +178,10 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
+CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start)
+    : FunctionOptions(internal::kCumulativeSumOptionsType), start(std::move(start)) {}
+constexpr char CumulativeSumOptions::kTypeName[];
+
 namespace internal {
 void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kFilterOptionsType));
@@ -185,6 +191,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kSortOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPartitionNthOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSelectKOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kCumulativeSumOptionsType));
 }
 }  // namespace internal
 
@@ -325,6 +332,22 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
   return out.make_array();
 }
 
+Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
+                                             CumulativeSumOptions& options,
+                                             ExecContext* ctx) {
+  ARROW_ASSIGN_OR_RAISE(Datum out,
+                        CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
+  return out.make_array();
+}
+
+Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
+                                             CumulativeSumOptions& options,
+                                             ExecContext* ctx) {
+  ARROW_ASSIGN_OR_RAISE(
+      Datum out, CallFunction("cumulative_sum", {Datum(chunked_array)}, &options, ctx));
+  return out.make_array();
+}
+
 // ----------------------------------------------------------------------
 // Deprecated functions
 
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 9e53cfcf640..02cd0764469 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -188,6 +188,17 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
   NullPlacement null_placement;
 };
 
+/// \brief Options for cumulative sum function
+class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
+ public:
+  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start);
+  CumulativeSumOptions() : CumulativeSumOptions(std::make_shared<NullScalar>()) {}
+  static constexpr char const kTypeName[] = "CumulativeSumOptions";
+
+  /// Optional starting value for sum computation
+  std::shared_ptr<Scalar> start;
+};
+
 /// @}
 
 /// \brief Filter with a boolean selection filter
@@ -522,6 +533,16 @@ Result<Datum> DictionaryEncode(
     const DictionaryEncodeOptions& options = DictionaryEncodeOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
+ARROW_EXPORT
+Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
+                                             CumulativeSumOptions& options,
+                                             ExecContext* ctx = NULLPTR);
+
+ARROW_EXPORT
+Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
+                                             CumulativeSumOptions& options,
+                                             ExecContext* ctx = NULLPTR);
+
 // ----------------------------------------------------------------------
 // Deprecated functions
 
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 93a02cdb1f1..7659a5b5490 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -47,6 +47,7 @@ add_arrow_benchmark(scalar_string_benchmark PREFIX "arrow-compute")
 
 add_arrow_compute_test(vector_test
                        SOURCES
+                       vector_cumulative_sum_test.cc
                        vector_hash_test.cc
                        vector_nested_test.cc
                        vector_replace_test.cc
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index cff80f886c0..b3528c754d8 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -51,8 +51,8 @@ struct CumulativeSum {
   }
 
   Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const ScalarType& start_scalar = checked_cast<const ScalarType&>(*batch[1].scalar());
-    CType start = start_scalar.value;
+    const auto& options = OptionsWrapper<CumulativeSumOptions<CType>>::Get(ctx);
+    CType start = checked_cast<const ScalarType&>(options.start).value;
 
     switch (batch[0].kind()) {
       case Datum::ARRAY:
@@ -110,9 +110,7 @@ struct CumulativeSum {
   }
 
   static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
-    return KernelSignature::Make(
-        {InputType::Array(get_id.id), InputType::Scalar(get_id.id)},
-        OutputType(FirstType));
+    return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
   }
 };
 
@@ -136,6 +134,7 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = CumulativeSum<NumberType>::GetSignature(get_id.id);
     kernel.exec = std::move(exec);
+    kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   };
 
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index 579c4dad808..df43bd5e8e0 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -479,6 +479,7 @@ Structural Transforms
 .. autosummary::
    :toctree: ../generated/
 
+   cumulative_sum
    fill_null_backward
    fill_null_forward
    list_element
@@ -501,6 +502,7 @@ Compute Options
    CastOptions
    CountOptions
    CountOptions
+   CumulativeSumOptions
    DayOfWeekOptions
    DictionaryEncodeOptions
    ElementWiseAggregateOptions
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 2f18ab99866..75bd819d52f 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1736,6 +1736,26 @@ class PartitionNthOptions(_PartitionNthOptions):
         self._set_options(pivot, null_placement)
 
 
+cdef class _CumulativeSumOptions(FunctionOptions):
+    def _set_options(self, start):
+        self.wrapped.reset(new CCumulativeSumOptions(
+            pyarrow_unwrap_scalar(start)))
+
+
+class CumulativeSumOptions(_CumulativeSumOptions):
+    """
+    Options for `cumulative_sum` function.
+
+    Parameters
+    ----------
+    start : Scalar
+        Optional starting value for sum computation
+    """
+
+    def __init__(self, start):
+        self._set_options(start)
+
+
 cdef class _ArraySortOptions(FunctionOptions):
     def _set_options(self, order, null_placement):
         self.wrapped.reset(new CArraySortOptions(
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 6246a15fcff..6b370515399 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2243,6 +2243,11 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         int64_t pivot
         CNullPlacement null_placement
 
+    cdef cppclass CCumulativeSumOptions \
+            "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
+        CCumulativeSumOptions(shared_ptr[CScalar] start)
+        shared_ptr[CScalar] start
+
     cdef cppclass CArraySortOptions \
             "arrow::compute::ArraySortOptions"(CFunctionOptions):
         CArraySortOptions(CSortOrder, CNullPlacement)
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 46d302c214c..12791a9caea 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -147,6 +147,7 @@ def test_option_class_equality():
         pc.NullOptions(),
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
+        pc.CumulativeSumOptions(pa.scalar(0)),
         pc.QuantileOptions(),
         pc.RandomOptions(10),
         pc.ReplaceSliceOptions(0, 1, "a"),

From 56f2d78b408c1ca5e4a1e01b7430ed1673a907ef Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 9 Mar 2022 12:22:19 -0500
Subject: [PATCH 23/67] Minor changes to cumulative sum kernel

---
 cpp/src/arrow/compute/api_vector.h            |  2 +-
 .../compute/kernels/vector_cumulative_sum.cc  | 38 ++++++++++---------
 2 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 02cd0764469..d2d825d91fb 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -192,7 +192,7 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
   explicit CumulativeSumOptions(std::shared_ptr<Scalar> start);
-  CumulativeSumOptions() : CumulativeSumOptions(std::make_shared<NullScalar>()) {}
+  CumulativeSumOptions() : CumulativeSumOptions(nullptr) {}
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
 
   /// Optional starting value for sum computation
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index b3528c754d8..03a987d9be7 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -16,7 +16,7 @@
 // under the License.
 
 #include "arrow/array/array_base.h"
-#include "arrow/compute/api_scalar.h"
+#include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/result.h"
 #include "arrow/visit_type_inline.h"
@@ -52,7 +52,16 @@ struct CumulativeSum {
 
   Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<CumulativeSumOptions<CType>>::Get(ctx);
-    CType start = checked_cast<const ScalarType&>(options.start).value;
+    std::shared_ptr<Scalar>& start_scalar = options.start;
+    CType start = 0;
+    if (start_scalar) {
+      if (start_scalar->is_valid()) {
+        if (start_scalar->type()->id() != TypeTraits<Type>::type_singleton()->id()) {
+          return Status::Invalid("Types of array values and starting value do not match.");
+        }
+        start = UnboxScalar<Type>::Unbox(*start_scalar);
+      }
+    }
 
     switch (batch[0].kind()) {
       case Datum::ARRAY:
@@ -127,30 +136,23 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto cumulative_sum = std::make_shared<VectorFunction>(
       "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
 
-  auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
+  std::vector<detail::GetTypeId> types;
+  types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
+  types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
+  types.push_back(Type::DURATION);
+  types.push_back(Type::INTERVAL_MONTHS);
+
+  for (auto ty : types) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = true;
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = CumulativeSum<NumberType>::GetSignature(get_id.id);
-    kernel.exec = std::move(exec);
+    kernel.signature = CumulativeSum<NumberType>::GetSignature(ty.id);
+    kernel.exec = std::move(GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
-  };
-
-  for (auto ty : NumericTypes()) {
-    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
-  }
-
-  for (auto ty : TemporalTypes()) {
-    add_kernel(ty, GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
   }
 
-  add_kernel(Type::DURATION,
-             GenerateTypeAgnosticPrimitive<CumulativeSum>(Type::DURATION));
-  add_kernel(Type::INTERVAL_MONTHS,
-             GenerateTypeAgnosticPrimitive<CumulativeSum>(Type::INTERVAL_MONTHS));
-
   DCHECK_OK(registry->AddFunction(std::move(cumulative_sum)));
 }
 

From 1ceebce126c3a0dfdf00fe58334ab9f7cc123baa Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 18 Mar 2022 14:48:07 -0400
Subject: [PATCH 24/67] Added option for skipping nulls

---
 cpp/src/arrow/CMakeLists.txt                  |  1 +
 cpp/src/arrow/compute/api_vector.cc           | 22 +++++--
 cpp/src/arrow/compute/api_vector.h            | 15 +++--
 .../compute/kernels/vector_cumulative_sum.cc  | 63 ++++++++++++-------
 .../kernels/vector_cumulative_sum_test.cc     | 19 +++++-
 python/pyarrow/_compute.pyx                   | 10 +--
 python/pyarrow/includes/libarrow.pxd          |  3 +-
 python/pyarrow/tests/test_compute.py          |  2 +-
 8 files changed, 98 insertions(+), 37 deletions(-)

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index e9e826097b3..de67503ad0c 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -436,6 +436,7 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_validity.cc
        compute/kernels/util_internal.cc
        compute/kernels/vector_array_sort.cc
+       compute/kernels/vector_cumulative_sum.cc
        compute/kernels/vector_hash.cc
        compute/kernels/vector_nested.cc
        compute/kernels/vector_replace.cc
diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index c624ec0d942..261bb3a2dd1 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -136,7 +136,8 @@ static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
 static auto kCumulativeSumOptionsType = GetFunctionOptionsType<CumulativeSumOptions>(
-    DataMember("start", &CumulativeSumOptions::start));
+    DataMember("start", &CumulativeSumOptions::start),
+    DataMember("skip_nulls", &CumulativeSumOptions::skip_nulls));
 }  // namespace
 }  // namespace internal
 
@@ -178,8 +179,19 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start)
-    : FunctionOptions(internal::kCumulativeSumOptionsType), start(std::move(start)) {}
+CumulativeSumOptions::CumulativeSumOptions(uint64_t start, bool skip_nulls)
+    : CumulativeSumOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
+
+CumulativeSumOptions::CumulativeSumOptions(int64_t start, bool skip_nulls)
+    : CumulativeSumOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
+
+CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls)
+    : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
+
+CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
+    : FunctionOptions(internal::kCumulativeSumOptionsType),
+      start(std::move(start)),
+      skip_nulls(skip_nulls) {}
 constexpr char CumulativeSumOptions::kTypeName[];
 
 namespace internal {
@@ -333,7 +345,7 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
 }
 
 Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
-                                             CumulativeSumOptions& options,
+                                             const CumulativeSumOptions& options,
                                              ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(Datum out,
                         CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
@@ -341,7 +353,7 @@ Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
 }
 
 Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
-                                             CumulativeSumOptions& options,
+                                             const CumulativeSumOptions& options,
                                              ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(
       Datum out, CallFunction("cumulative_sum", {Datum(chunked_array)}, &options, ctx));
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index d2d825d91fb..74bd9893b00 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,12 +191,19 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start);
-  CumulativeSumOptions() : CumulativeSumOptions(nullptr) {}
+  explicit CumulativeSumOptions(uint64_t start = 0, bool skip_nulls = false);
+  explicit CumulativeSumOptions(int64_t start = 0, bool skip_nulls = false);
+  explicit CumulativeSumOptions(double start = 0, bool skip_nulls = false);
+  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = nullptr,
+                                bool skip_nulls = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
+  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(nullptr); }
 
   /// Optional starting value for sum computation
   std::shared_ptr<Scalar> start;
+
+  /// When false, propagates the first null/NaN encountered
+  bool skip_nulls = false;
 };
 
 /// @}
@@ -535,12 +542,12 @@ Result<Datum> DictionaryEncode(
 
 ARROW_EXPORT
 Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
-                                             CumulativeSumOptions& options,
+                                             const CumulativeSumOptions& options,
                                              ExecContext* ctx = NULLPTR);
 
 ARROW_EXPORT
 Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
-                                             CumulativeSumOptions& options,
+                                             const CumulativeSumOptions& options,
                                              ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index 03a987d9be7..fc74a3b412c 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include "arrow/array/array_base.h"
+#include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/result.h"
@@ -25,23 +26,37 @@ namespace arrow {
 namespace compute {
 namespace internal {
 
+namespace {
+
+std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
+  return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
+}
+
+}  // namespace
+
 template <typename Type>
 struct CumulativeSum {
-  using CType = TypeTraits<Type>::CType;
-  using ScalarType = TypeTraits<Type>::ScalarType;
+  using CType = typename TypeTraits<Type>::CType;
+  using ScalarType = typename TypeTraits<Type>::ScalarType;
 
   CType Sum(ExecContext* ctx, std::shared_ptr<Array>& input, ArrayData* output,
-            CType start) {
+            CType start, bool skip_nulls) {
     CType sum = start;
     CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
     CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
     ArithmeticOptions options;
-    for (size_t i = input->offset; i < input->length; ++i) {
-      if (input->IsValid(i)) {
+    bool set_null = false;
+    for (size_t i = input->offset; i < input->length(); ++i) {
+      if (set_null) {
+        out_values[i] = NULL;
+      } else if (input->IsNull(i) && !skip_nulls) {
+        out_values[i] = NULL;
+        set_null = true;
+      } else {
         Datum value_datum(data[i]);
         Datum sum_datum(sum);
         auto result = Add(value_datum, sum_datum, options, ctx);
-        ScalarType result_scalar = result.ValueOrDie().scalar_as();
+        ScalarType result_scalar = result.ValueOrDie().scalar_as<ScalarType>();
         sum = result_scalar.value;
         out_values[i] = sum;
       }
@@ -50,14 +65,17 @@ struct CumulativeSum {
     return sum;
   }
 
-  Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const auto& options = OptionsWrapper<CumulativeSumOptions<CType>>::Get(ctx);
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    const auto& options = OptionsWrapper<CumulativeSumOptions>::Get(ctx);
     std::shared_ptr<Scalar>& start_scalar = options.start;
+    bool skip_nulls = options.skip_nulls;
+
     CType start = 0;
     if (start_scalar) {
       if (start_scalar->is_valid()) {
         if (start_scalar->type()->id() != TypeTraits<Type>::type_singleton()->id()) {
-          return Status::Invalid("Types of array values and starting value do not match.");
+          return Status::Invalid(
+              "Types of array values and starting value do not match.");
         }
         start = UnboxScalar<Type>::Unbox(*start_scalar);
       }
@@ -82,8 +100,9 @@ struct CumulativeSum {
           output->null_count = 0;
         }
 
-        Sum(ctx->exec_context(), input, output, start);
+        Sum(ctx->exec_context(), input, output, start, skip_nulls);
         return Status::OK();
+        break;
       case Datum::CHUNKED_ARRAY:
         const auto& input = batch[0].chunked_array();
 
@@ -104,23 +123,21 @@ struct CumulativeSum {
             out_chunk->null_count = 0;
           }
 
-          CType last_value = Sum(ctx->exec_context(), chunk, out_chunk, start);
+          CType last_value =
+              Sum(ctx->exec_context(), chunk, out_chunk, start, skip_nulls);
           start = last_value;
           out_chunks.push_back(MakeArray(std::move(out_chunk)));
         }
 
         *out->chunked_array() = ChunkedArray(out_chunks, input->type());
         return Status::OK();
+        break;
       default:
         return Status::NotImplemented(
             "Unsupported input type for function 'cumulative_sum': ",
             batch[0].ToString());
     }
   }
-
-  static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
-    return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
-  }
 };
 
 const FunctionDoc cumulative_sum_doc(
@@ -136,18 +153,22 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto cumulative_sum = std::make_shared<VectorFunction>(
       "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
 
-  std::vector<detail::GetTypeId> types;
-  types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
+  std::vector<std::shared_ptr<DataType>> types;
+  types.insert(types.end(), IntTypes().begin(), IntTypes().end());
+  types.insert(types.end(), FloatingPointTypes().begin(), IntTypes().end());
   types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
-  types.push_back(Type::DURATION);
-  types.push_back(Type::INTERVAL_MONTHS);
+  types.push_back(duration(TimeUnit::SECOND));
+  types.push_back(duration(TimeUnit::MILLI));
+  types.push_back(duration(TimeUnit::MICRO));
+  types.push_back(duration(TimeUnit::NANO));
+  types.push_back(month_interval());
 
   for (auto ty : types) {
     VectorKernel kernel;
-    kernel.can_execute_chunkwise = true;
+    kernel.can_execute_chunkwise = false;
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = CumulativeSum<NumberType>::GetSignature(ty.id);
+    kernel.signature = GetSignature(ty->id());
     kernel.exec = std::move(GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
index dfeb492cb70..825ff83174d 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -32,6 +32,7 @@
 #include "arrow/array/builder_decimal.h"
 #include "arrow/buffer.h"
 #include "arrow/chunked_array.h"
+#include "arrow/compute/api_vector.h"
 #include "arrow/status.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
@@ -48,7 +49,23 @@
 namespace arrow {
 namespace compute {
 
-class TestBaseCumulativeSum : public ::testing::Test {}
+template <typename Type>
+class TestBaseCumulativeSum : public ::testing::Test {
+  using CType = TypeTraits<Type>::CType;
+
+  void AssertValidCumulativeSum(const Array& input, CumulativeSumOptions options) {
+    ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
+  }
+};
+
+template <typename T>
+class TestIntegerCumulativeSum : public TestBaseCumulativeSum<T> {};
+
+template <typename T>
+class TestFloatingPointCumulativeSum : public TestBaseCumulativeSum<T> {};
+
+template <typename T>
+class TestTemporalCumulativeSum : public TestBaseCumulativeSum<T> {};
 
 }  // namespace compute
 }  // namespace arrow
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 75bd819d52f..dc9cd9dd372 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1737,9 +1737,9 @@ class PartitionNthOptions(_PartitionNthOptions):
 
 
 cdef class _CumulativeSumOptions(FunctionOptions):
-    def _set_options(self, start):
+    def _set_options(self, start, skip_nulls):
         self.wrapped.reset(new CCumulativeSumOptions(
-            pyarrow_unwrap_scalar(start)))
+            pyarrow_unwrap_scalar(start), skip_nulls))
 
 
 class CumulativeSumOptions(_CumulativeSumOptions):
@@ -1750,10 +1750,12 @@ class CumulativeSumOptions(_CumulativeSumOptions):
     ----------
     start : Scalar
         Optional starting value for sum computation
+    skip_nulls : bool
+        When false, propagates the first null/NaN encountered
     """
 
-    def __init__(self, start):
-        self._set_options(start)
+    def __init__(self, start=0, skip_nulls=false):
+        self._set_options(start, skip_nulls)
 
 
 cdef class _ArraySortOptions(FunctionOptions):
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 6b370515399..33c46e56b70 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2245,8 +2245,9 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
 
     cdef cppclass CCumulativeSumOptions \
             "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
-        CCumulativeSumOptions(shared_ptr[CScalar] start)
+        CCumulativeSumOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
         shared_ptr[CScalar] start
+        c_bool skip_nulls
 
     cdef cppclass CArraySortOptions \
             "arrow::compute::ArraySortOptions"(CFunctionOptions):
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 12791a9caea..14ca2355484 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -147,7 +147,7 @@ def test_option_class_equality():
         pc.NullOptions(),
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
-        pc.CumulativeSumOptions(pa.scalar(0)),
+        pc.CumulativeSumOptions(start=0, skip_nulls=False),
         pc.QuantileOptions(),
         pc.RandomOptions(10),
         pc.ReplaceSliceOptions(0, 1, "a"),

From 0a9e1c99773fa2c23d3cf58fa7e060e315fd1424 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 22 Mar 2022 17:09:37 -0400
Subject: [PATCH 25/67] Fixed some errors; reworking addition for cumulative
 sum

---
 cpp/src/arrow/compute/api_vector.h            |  8 ++--
 .../compute/kernels/vector_cumulative_sum.cc  | 46 +++++++++++++++----
 .../kernels/vector_cumulative_sum_test.cc     | 35 ++++++++++----
 3 files changed, 67 insertions(+), 22 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 74bd9893b00..5742871fd64 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,13 +191,13 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  explicit CumulativeSumOptions(uint64_t start = 0, bool skip_nulls = false);
-  explicit CumulativeSumOptions(int64_t start = 0, bool skip_nulls = false);
-  explicit CumulativeSumOptions(double start = 0, bool skip_nulls = false);
+  explicit CumulativeSumOptions(uint64_t start, bool skip_nulls = false);
+  explicit CumulativeSumOptions(int64_t start, bool skip_nulls = false);
+  explicit CumulativeSumOptions(double start, bool skip_nulls = false);
   explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = nullptr,
                                 bool skip_nulls = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
-  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(nullptr); }
+  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
 
   /// Optional starting value for sum computation
   std::shared_ptr<Scalar> start;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index fc74a3b412c..1df2bcf95e4 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -28,6 +28,31 @@ namespace internal {
 
 namespace {
 
+struct Add {
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                                    Status*) {
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                            Arg1 right, Status*) {
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                          Arg1 right, Status*) {
+    return arrow::internal::SafeSignedAdd(left, right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + right;
+  }
+};
+
 std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
   return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
 }
@@ -46,18 +71,19 @@ struct CumulativeSum {
     CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
     ArithmeticOptions options;
     bool set_null = false;
-    for (size_t i = input->offset; i < input->length(); ++i) {
+    for (size_t i = input->offset(); i < input->length(); ++i) {
       if (set_null) {
         out_values[i] = NULL;
       } else if (input->IsNull(i) && !skip_nulls) {
         out_values[i] = NULL;
         set_null = true;
       } else {
-        Datum value_datum(data[i]);
-        Datum sum_datum(sum);
-        auto result = Add(value_datum, sum_datum, options, ctx);
-        ScalarType result_scalar = result.ValueOrDie().scalar_as<ScalarType>();
-        sum = result_scalar.value;
+        // Datum value_datum(data[i]);
+        // Datum sum_datum(sum);
+        // auto result = Add(value_datum, sum_datum, options, ctx);
+        // sum = result_scalar.value;
+
+        sum = Add::Call(data[i], sum);
         out_values[i] = sum;
       }
     }
@@ -82,7 +108,7 @@ struct CumulativeSum {
     }
 
     switch (batch[0].kind()) {
-      case Datum::ARRAY:
+      case Datum::ARRAY: {
         std::shared_ptr<Array> input = batch[0].make_array();
         ArrayData* output = out->array().get();
 
@@ -102,8 +128,8 @@ struct CumulativeSum {
 
         Sum(ctx->exec_context(), input, output, start, skip_nulls);
         return Status::OK();
-        break;
-      case Datum::CHUNKED_ARRAY:
+      }
+      case Datum::CHUNKED_ARRAY: {
         const auto& input = batch[0].chunked_array();
 
         ArrayVector out_chunks;
@@ -131,7 +157,7 @@ struct CumulativeSum {
 
         *out->chunked_array() = ChunkedArray(out_chunks, input->type());
         return Status::OK();
-        break;
+      }
       default:
         return Status::NotImplemented(
             "Unsupported input type for function 'cumulative_sum': ",
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
index 825ff83174d..8ad10be1da2 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -49,23 +49,42 @@
 namespace arrow {
 namespace compute {
 
+using IntegralTypes = testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type,
+                                     Int8Type, Int16Type, Int32Type, Int64Type>;
+
+using FloatingTypes = testing::Types<FloatType, DoubleType>;
+
+using TimeTypes = testing::Types<Date32Type, Date64Type, Time32Type, Time64Type,
+                                 TimestampType, DurationType, MonthIntervalType>;
+
 template <typename Type>
-class TestBaseCumulativeSum : public ::testing::Test {
+class TestCumulativeSum : public ::testing::Test {
   using CType = TypeTraits<Type>::CType;
 
-  void AssertValidCumulativeSum(const Array& input, CumulativeSumOptions options) {
+ protected:
+  CumulativeSumOptions no_start_no_skip_nulls();
+  CumulativeSumOptions has_start_no_skip_nulls(10);
+  CumulativeSumOptions no_start_skip_nulls(0, true);
+  CumulativeSumOptions has_start_skip_nulls(10, true);
+
+  void SetUp() override {}
+
+  void AssertValidCumulativeSum(const Array& expected, const Array& input,
+                                const CumulativeSumOptions options) {
     ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
+    AssertArraysEqual(expected, *result, false, EqualOptions::Defaults());
   }
 };
 
-template <typename T>
-class TestIntegerCumulativeSum : public TestBaseCumulativeSum<T> {};
+TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralTypes);
+TYPED_TEST_SUITE(TestCumulativeSumFloating, FloatingTypes);
+TYPED_TEST_SUITE(TestCumulativeSumTemporal, TimeTypes);
 
-template <typename T>
-class TestFloatingPointCumulativeSum : public TestBaseCumulativeSum<T> {};
+TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {}
+TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
+TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
+TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
 
-template <typename T>
-class TestTemporalCumulativeSum : public TestBaseCumulativeSum<T> {};
 
 }  // namespace compute
 }  // namespace arrow

From 5d7d2ea4d0c554d59e22669706a087e97ca43bf1 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 23 Mar 2022 14:29:17 -0400
Subject: [PATCH 26/67] Creating separate header for addition kernels

---
 .../kernels/base_arithmetic_internal.h        | 103 ++++++++++++++++++
 .../compute/kernels/scalar_arithmetic.cc      |  82 +-------------
 .../compute/kernels/vector_cumulative_sum.cc  |  26 +++++
 3 files changed, 130 insertions(+), 81 deletions(-)
 create mode 100644 cpp/src/arrow/compute/kernels/base_arithmetic_internal.h

diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
new file mode 100644
index 00000000000..899f26cd126
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#include "arrow/compute/api_scalar.h"
+#include "arrow/compute/kernels/common.h"
+#include "arrow/compute/kernels/util_internal.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/decimal.h"
+#include "arrow/util/int_util_internal.h"
+#include "arrow/util/macros.h"
+
+namespace arrow {
+
+using internal::AddWithOverflow;
+
+namespace compute {
+namespace internal {
+
+struct Add {
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                                    Status*) {
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                            Arg1 right, Status*) {
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                          Arg1 right, Status*) {
+    return arrow::internal::SafeSignedAdd(left, right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + right;
+  }
+};
+
+struct AddChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                          Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + right;
+  }
+};
+
+template <int64_t multiple>
+struct AddTimeDuration {
+  template <typename T, typename Arg0, typename Arg1>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
+    T result =
+        arrow::internal::SafeSignedAdd(static_cast<T>(left), static_cast<T>(right));
+    if (result < 0 || multiple <= result) {
+      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
+                            multiple, ") s");
+    }
+    return result;
+  }
+};
+
+template <int64_t multiple>
+struct AddTimeDurationChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(
+            AddWithOverflow(static_cast<T>(left), static_cast<T>(right), &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    if (result < 0 || multiple <= result) {
+      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
+                            multiple, ") s");
+    }
+    return result;
+  }
+};
+
+}  // namespace internal
+}  // namespace compute
+}  // namespace arrow
+
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index bfafb6fcc19..150cd3ead96 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -25,6 +25,7 @@
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/util_internal.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/decimal.h"
@@ -114,56 +115,6 @@ struct AbsoluteValueChecked {
   }
 };
 
-struct Add {
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                            Arg1 right, Status*) {
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                          Arg1 right, Status*) {
-    return arrow::internal::SafeSignedAdd(left, right);
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + right;
-  }
-};
-
-struct AddChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + right;
-  }
-};
-
 struct Subtract {
   template <typename T, typename Arg0, typename Arg1>
   static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
@@ -240,37 +191,6 @@ struct SubtractCheckedDate32 {
   }
 };
 
-template <int64_t multiple>
-struct AddTimeDuration {
-  template <typename T, typename Arg0, typename Arg1>
-  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
-    T result =
-        arrow::internal::SafeSignedAdd(static_cast<T>(left), static_cast<T>(right));
-    if (result < 0 || multiple <= result) {
-      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
-                            multiple, ") s");
-    }
-    return result;
-  }
-};
-
-template <int64_t multiple>
-struct AddTimeDurationChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(
-            AddWithOverflow(static_cast<T>(left), static_cast<T>(right), &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    if (result < 0 || multiple <= result) {
-      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
-                            multiple, ") s");
-    }
-    return result;
-  }
-};
-
 template <int64_t multiple>
 struct SubtractTimeDuration {
   template <typename T, typename Arg0, typename Arg1>
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index 1df2bcf95e4..bed009fbf88 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -19,6 +19,7 @@
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/common.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/result.h"
 #include "arrow/visit_type_inline.h"
 
@@ -28,6 +29,7 @@ namespace internal {
 
 namespace {
 
+
 struct Add {
   template <typename T, typename Arg0, typename Arg1>
   static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
@@ -53,6 +55,30 @@ struct Add {
   }
 };
 
+struct AddChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                          Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return left + right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + right;
+  }
+};
 std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
   return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
 }

From 671659aae4e9fc0525de93094ceda496f2d3d5d7 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 24 Mar 2022 00:00:37 -0400
Subject: [PATCH 27/67] Creation of CumulativeMeta, simplification of
 CumulativeSum, and moving add kernel to new internal file

---
 .../arrow/compute/kernels/codegen_internal.h  |  31 +++
 .../compute/kernels/scalar_arithmetic.cc      |  32 ---
 .../compute/kernels/vector_cumulative_sum.cc  | 184 ++++--------------
 3 files changed, 65 insertions(+), 182 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index ff7b9161fe3..8eb5cba5d39 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -1134,6 +1134,37 @@ ArrayKernelExec GeneratePhysicalInteger(detail::GetTypeId get_id) {
   }
 }
 
+template <template <typename... Args> class KernelGenerator, typename Op>
+ArrayKernelExec ArithmeticExecFromOp(detail::GetTypeId get_id) {
+  switch (get_id.id) {
+    case Type::INT8:
+      return KernelGenerator<Int8Type, Int8Type, Op>::Exec;
+    case Type::UINT8:
+      return KernelGenerator<UInt8Type, UInt8Type, Op>::Exec;
+    case Type::INT16:
+      return KernelGenerator<Int16Type, Int16Type, Op>::Exec;
+    case Type::UINT16:
+      return KernelGenerator<UInt16Type, UInt16Type, Op>::Exec;
+    case Type::INT32:
+      return KernelGenerator<Int32Type, Int32Type, Op>::Exec;
+    case Type::UINT32:
+      return KernelGenerator<UInt32Type, UInt32Type, Op>::Exec;
+    case Type::DURATION:
+    case Type::INT64:
+    case Type::TIMESTAMP:
+      return KernelGenerator<Int64Type, Int64Type, Op>::Exec;
+    case Type::UINT64:
+      return KernelGenerator<UInt64Type, UInt64Type, Op>::Exec;
+    case Type::FLOAT:
+      return KernelGenerator<FloatType, FloatType, Op>::Exec;
+    case Type::DOUBLE:
+      return KernelGenerator<DoubleType, DoubleType, Op>::Exec;
+    default:
+      DCHECK(false);
+      return ExecFail;
+  }
+}
+
 template <template <typename... Args> class Generator, typename... Args>
 ArrayKernelExec GeneratePhysicalNumeric(detail::GetTypeId get_id) {
   switch (get_id.id) {
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 150cd3ead96..26143f3749e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -1500,38 +1500,6 @@ struct Trunc {
   }
 };
 
-// Generate a kernel given an arithmetic functor
-template <template <typename... Args> class KernelGenerator, typename Op>
-ArrayKernelExec ArithmeticExecFromOp(detail::GetTypeId get_id) {
-  switch (get_id.id) {
-    case Type::INT8:
-      return KernelGenerator<Int8Type, Int8Type, Op>::Exec;
-    case Type::UINT8:
-      return KernelGenerator<UInt8Type, UInt8Type, Op>::Exec;
-    case Type::INT16:
-      return KernelGenerator<Int16Type, Int16Type, Op>::Exec;
-    case Type::UINT16:
-      return KernelGenerator<UInt16Type, UInt16Type, Op>::Exec;
-    case Type::INT32:
-      return KernelGenerator<Int32Type, Int32Type, Op>::Exec;
-    case Type::UINT32:
-      return KernelGenerator<UInt32Type, UInt32Type, Op>::Exec;
-    case Type::INT64:
-    case Type::DURATION:
-    case Type::TIMESTAMP:
-      return KernelGenerator<Int64Type, Int64Type, Op>::Exec;
-    case Type::UINT64:
-      return KernelGenerator<UInt64Type, UInt64Type, Op>::Exec;
-    case Type::FLOAT:
-      return KernelGenerator<FloatType, FloatType, Op>::Exec;
-    case Type::DOUBLE:
-      return KernelGenerator<DoubleType, DoubleType, Op>::Exec;
-    default:
-      DCHECK(false);
-      return ExecFail;
-  }
-}
-
 // Generate a kernel given a bitwise arithmetic functor. Assumes the
 // functor treats all integer types of equal width identically
 template <template <typename... Args> class KernelGenerator, typename Op>
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index bed009fbf88..cccfbbd895e 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -18,6 +18,7 @@
 #include "arrow/array/array_base.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
+#include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/result.h"
@@ -29,166 +30,56 @@ namespace internal {
 
 namespace {
 
-
-struct Add {
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                            Arg1 right, Status*) {
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                          Arg1 right, Status*) {
-    return arrow::internal::SafeSignedAdd(left, right);
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + right;
-  }
-};
-
-struct AddChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(AddWithOverflow(left, right, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return left + right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + right;
-  }
-};
 std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
   return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
 }
 
 }  // namespace
 
-template <typename Type>
-struct CumulativeSum {
-  using CType = typename TypeTraits<Type>::CType;
-  using ScalarType = typename TypeTraits<Type>::ScalarType;
-
-  CType Sum(ExecContext* ctx, std::shared_ptr<Array>& input, ArrayData* output,
-            CType start, bool skip_nulls) {
-    CType sum = start;
-    CType* data = checked_cast<CType*>(input->data()->buffers[1]->data());
-    CType* out_values = checked_cast<CType*>(output->buffers[1]->mutable_data());
-    ArithmeticOptions options;
-    bool set_null = false;
-    for (size_t i = input->offset(); i < input->length(); ++i) {
-      if (set_null) {
-        out_values[i] = NULL;
-      } else if (input->IsNull(i) && !skip_nulls) {
-        out_values[i] = NULL;
-        set_null = true;
-      } else {
-        // Datum value_datum(data[i]);
-        // Datum sum_datum(sum);
-        // auto result = Add(value_datum, sum_datum, options, ctx);
-        // sum = result_scalar.value;
-
-        sum = Add::Call(data[i], sum);
-        out_values[i] = sum;
-      }
-    }
-
-    return sum;
-  }
-
+template <typename OutType, typename ArgType, typename Op>
+struct CumulativeMeta {
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<CumulativeSumOptions>::Get(ctx);
-    std::shared_ptr<Scalar>& start_scalar = options.start;
+    auto start = UnboxScalar<ArgType>::Unbox(*options.start);
     bool skip_nulls = options.skip_nulls;
 
-    CType start = 0;
-    if (start_scalar) {
-      if (start_scalar->is_valid()) {
-        if (start_scalar->type()->id() != TypeTraits<Type>::type_singleton()->id()) {
-          return Status::Invalid(
-              "Types of array values and starting value do not match.");
-        }
-        start = UnboxScalar<Type>::Unbox(*start_scalar);
-      }
-    }
-
     switch (batch[0].kind()) {
       case Datum::ARRAY: {
-        std::shared_ptr<Array> input = batch[0].make_array();
-        ArrayData* output = out->array().get();
-
-        output->length = input->data()->length;
-        *output->type = std::move(input->type());
-        uint8_t* out_bitmap = output->buffers[0]->mutable_data();
-        int64_t out_offset = input->offset();
-
-        if (input->data()->MayHaveNulls()) {
-          arrow::internal::CopyBitmap(input->null_bitmap_data(), input->offset(),
-                                      input->length(), out_bitmap, out_offset);
-          output->null_count = input->null_count();
-        } else {
-          bit_util::SetBitsTo(out_bitmap, out_offset, input->length(), true);
-          output->null_count = 0;
-        }
-
-        Sum(ctx->exec_context(), input, output, start, skip_nulls);
-        return Status::OK();
+        return Op::template Call(ctx, *batch[0].array(), start, out);
       }
       case Datum::CHUNKED_ARRAY: {
         const auto& input = batch[0].chunked_array();
 
-        ArrayVector out_chunks;
         for (const auto& chunk : input->chunks()) {
-          auto out_chunk = std::make_shared<ArrayData>(
-              chunk->type(), chunk->length(), chunk->null_count(), chunk->offset());
-
-          uint8_t* out_chunk_bitmap = out_chunk->buffers[0]->mutable_data();
-          if (chunk->data()->MayHaveNulls()) {
-            arrow::internal::CopyBitmap(chunk->null_bitmap_data(), chunk->offset(),
-                                        chunk->length(), out_chunk_bitmap,
-                                        out_chunk->offset());
-            out_chunk->null_count = chunk->null_count();
-          } else {
-            bit_util::SetBitsTo(out_chunk_bitmap, out_chunk->offset(), chunk->length(),
-                                true);
-            out_chunk->null_count = 0;
-          }
-
-          CType last_value =
-              Sum(ctx->exec_context(), chunk, out_chunk, start, skip_nulls);
-          start = last_value;
-          out_chunks.push_back(MakeArray(std::move(out_chunk)));
+          RETURN_NOT_OK(Op::template Call(ctx, chunk->data(), start, out));
         }
-
-        *out->chunked_array() = ChunkedArray(out_chunks, input->type());
-        return Status::OK();
       }
       default:
         return Status::NotImplemented(
-            "Unsupported input type for function 'cumulative_sum': ",
+            "Unsupported input type for function 'cumulative_<operator>': ",
             batch[0].ToString());
     }
+
+    return Status::OK();
+  }
+};
+
+template <typename OutType, typename ArgType>
+struct CumulativeSum {
+
+  using OutValue = typename GetOutputType<OutType>::T;
+  using ArgValue = typename GetViewType<ArgType>::T;
+
+  static Status Call(KernelContext* ctx, const ArrayData& arg0, const ArgValue& sum,
+                            Datum* out) {
+    Status st = Status::OK();
+    ArrayIterator<ArgType> arg0_it(arg0);
+    RETURN_NOT_OK(OutputAdapter<OutType>::Write(ctx, out, [&]() -> OutValue {
+      sum = Add::template Call<OutValue, ArgValue, ArgValue>(ctx, arg0_it(), sum,
+                                                               &st);
+      return sum;
+    }));
+    return st;
   }
 };
 
@@ -203,25 +94,18 @@ const FunctionDoc cumulative_sum_doc(
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto cumulative_sum = std::make_shared<VectorFunction>(
-      "cumulative_sum", Arity::Binary(), &cumulative_sum_doc);
+      "cumulative_sum", Arity::Unary(), &cumulative_sum_doc);
 
   std::vector<std::shared_ptr<DataType>> types;
-  types.insert(types.end(), IntTypes().begin(), IntTypes().end());
-  types.insert(types.end(), FloatingPointTypes().begin(), IntTypes().end());
-  types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
-  types.push_back(duration(TimeUnit::SECOND));
-  types.push_back(duration(TimeUnit::MILLI));
-  types.push_back(duration(TimeUnit::MICRO));
-  types.push_back(duration(TimeUnit::NANO));
-  types.push_back(month_interval());
-
-  for (auto ty : types) {
+  types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
+
+  for (const auto& ty : NumericTypes()) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = false;
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = GetSignature(ty->id());
-    kernel.exec = std::move(GenerateTypeAgnosticPrimitive<CumulativeSum>(ty));
+    kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
+    kernel.exec = std::move(ArithmeticExecFromOp<CumulativeMeta, CumulativeSum>(ty));
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }

From a07d7a110f7fb43614a9bb68d0be5f48f2ed7148 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 24 Mar 2022 14:55:36 -0400
Subject: [PATCH 28/67] Removed CumulativeSum completely; now defined by use of
 Add operator

---
 .../compute/kernels/vector_cumulative_sum.cc  |  43 ++---
 .../kernels/vector_cumulative_sum_test.cc     | 180 +++++++++---------
 python/pyarrow/_compute.pyx                   |   2 +-
 3 files changed, 105 insertions(+), 120 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index cccfbbd895e..cb695a07133 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -28,16 +28,11 @@ namespace arrow {
 namespace compute {
 namespace internal {
 
-namespace {
-
-std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
-  return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
-}
-
-}  // namespace
-
 template <typename OutType, typename ArgType, typename Op>
-struct CumulativeMeta {
+struct CumulativeGeneric {
+  using OutValue = typename GetOutputType<OutType>::T;
+  using ArgValue = typename GetViewType<ArgType>::T;
+
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<CumulativeSumOptions>::Get(ctx);
     auto start = UnboxScalar<ArgType>::Unbox(*options.start);
@@ -45,13 +40,13 @@ struct CumulativeMeta {
 
     switch (batch[0].kind()) {
       case Datum::ARRAY: {
-        return Op::template Call(ctx, *batch[0].array(), start, out);
+        return Call(ctx, *batch[0].array(), start, out, skip_nulls);
       }
       case Datum::CHUNKED_ARRAY: {
         const auto& input = batch[0].chunked_array();
 
         for (const auto& chunk : input->chunks()) {
-          RETURN_NOT_OK(Op::template Call(ctx, chunk->data(), start, out));
+          RETURN_NOT_OK(Call(ctx, *chunk->data(), start, out, skip_nulls));
         }
       }
       default:
@@ -62,22 +57,15 @@ struct CumulativeMeta {
 
     return Status::OK();
   }
-};
-
-template <typename OutType, typename ArgType>
-struct CumulativeSum {
-
-  using OutValue = typename GetOutputType<OutType>::T;
-  using ArgValue = typename GetViewType<ArgType>::T;
 
-  static Status Call(KernelContext* ctx, const ArrayData& arg0, const ArgValue& sum,
-                            Datum* out) {
+  static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
+                            Datum* out, bool skip_nulls) {
     Status st = Status::OK();
     ArrayIterator<ArgType> arg0_it(arg0);
-    RETURN_NOT_OK(OutputAdapter<OutType>::Write(ctx, out, [&]() -> OutValue {
-      sum = Add::template Call<OutValue, ArgValue, ArgValue>(ctx, arg0_it(), sum,
+    RETURN_NOT_OK(applicator::OutputAdapter<OutType>::Write(ctx, out, [&]() -> OutValue {
+      partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, arg0_it(), partial_scan,
                                                                &st);
-      return sum;
+      return partial_scan;
     }));
     return st;
   }
@@ -86,11 +74,8 @@ struct CumulativeSum {
 const FunctionDoc cumulative_sum_doc(
     "Compute the cumulative sum over an array of numbers",
     ("`values` must be an array of numeric type values.\n"
-     "`start` is a single value of the same type.\n"
-     "Return an array which is the cumulative sum computed over `values.`\n"
-     "Null entries remain in place but are not used in calucating sum.\n"
-     "`start` is an optional starting sum of computation."),
-    {"values", "start"});
+     "Return an array which is the cumulative sum computed over `values.`"),
+    {"values"});
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto cumulative_sum = std::make_shared<VectorFunction>(
@@ -105,7 +90,7 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec = std::move(ArithmeticExecFromOp<CumulativeMeta, CumulativeSum>(ty));
+    kernel.exec = std::move(ArithmeticExecFromOp<CumulativeGeneric, Add>(ty));
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
index 8ad10be1da2..605cbb5e442 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -1,90 +1,90 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include <algorithm>
-#include <cstdint>
-#include <cstdio>
-#include <functional>
-#include <locale>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <gtest/gtest.h>
-
-#include "arrow/array.h"
-#include "arrow/array/builder_decimal.h"
-#include "arrow/buffer.h"
-#include "arrow/chunked_array.h"
-#include "arrow/compute/api_vector.h"
-#include "arrow/status.h"
-#include "arrow/testing/util.h"
-#include "arrow/type.h"
-#include "arrow/type_fwd.h"
-#include "arrow/type_traits.h"
-#include "arrow/util/checked_cast.h"
-#include "arrow/util/decimal.h"
-
-#include "arrow/compute/api.h"
-#include "arrow/compute/kernels/test_util.h"
-
-#include "arrow/ipc/json_simple.h"
-
-namespace arrow {
-namespace compute {
-
-using IntegralTypes = testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type,
-                                     Int8Type, Int16Type, Int32Type, Int64Type>;
-
-using FloatingTypes = testing::Types<FloatType, DoubleType>;
-
-using TimeTypes = testing::Types<Date32Type, Date64Type, Time32Type, Time64Type,
-                                 TimestampType, DurationType, MonthIntervalType>;
-
-template <typename Type>
-class TestCumulativeSum : public ::testing::Test {
-  using CType = TypeTraits<Type>::CType;
-
- protected:
-  CumulativeSumOptions no_start_no_skip_nulls();
-  CumulativeSumOptions has_start_no_skip_nulls(10);
-  CumulativeSumOptions no_start_skip_nulls(0, true);
-  CumulativeSumOptions has_start_skip_nulls(10, true);
-
-  void SetUp() override {}
-
-  void AssertValidCumulativeSum(const Array& expected, const Array& input,
-                                const CumulativeSumOptions options) {
-    ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
-    AssertArraysEqual(expected, *result, false, EqualOptions::Defaults());
-  }
-};
-
-TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralTypes);
-TYPED_TEST_SUITE(TestCumulativeSumFloating, FloatingTypes);
-TYPED_TEST_SUITE(TestCumulativeSumTemporal, TimeTypes);
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {}
-TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
-TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
-TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
-
-
-}  // namespace compute
-}  // namespace arrow
+// // Licensed to the Apache Software Foundation (ASF) under one
+// // or more contributor license agreements.  See the NOTICE file
+// // distributed with this work for additional information
+// // regarding copyright ownership.  The ASF licenses this file
+// // to you under the Apache License, Version 2.0 (the
+// // "License"); you may not use this file except in compliance
+// // with the License.  You may obtain a copy of the License at
+// //
+// //   http://www.apache.org/licenses/LICENSE-2.0
+// //
+// // Unless required by applicable law or agreed to in writing,
+// // software distributed under the License is distributed on an
+// // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// // KIND, either express or implied.  See the License for the
+// // specific language governing permissions and limitations
+// // under the License.
+
+// #include <algorithm>
+// #include <cstdint>
+// #include <cstdio>
+// #include <functional>
+// #include <locale>
+// #include <memory>
+// #include <stdexcept>
+// #include <string>
+// #include <utility>
+// #include <vector>
+
+// #include <gtest/gtest.h>
+
+// #include "arrow/array.h"
+// #include "arrow/array/builder_decimal.h"
+// #include "arrow/buffer.h"
+// #include "arrow/chunked_array.h"
+// #include "arrow/compute/api_vector.h"
+// #include "arrow/status.h"
+// #include "arrow/testing/util.h"
+// #include "arrow/type.h"
+// #include "arrow/type_fwd.h"
+// #include "arrow/type_traits.h"
+// #include "arrow/util/checked_cast.h"
+// #include "arrow/util/decimal.h"
+
+// #include "arrow/compute/api.h"
+// #include "arrow/compute/kernels/test_util.h"
+
+// #include "arrow/ipc/json_simple.h"
+
+// namespace arrow {
+// namespace compute {
+
+// using IntegralTypes = testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type,
+//                                      Int8Type, Int16Type, Int32Type, Int64Type>;
+
+// using FloatingTypes = testing::Types<FloatType, DoubleType>;
+
+// using TimeTypes = testing::Types<Date32Type, Date64Type, Time32Type, Time64Type,
+//                                  TimestampType, DurationType, MonthIntervalType>;
+
+// template <typename Type>
+// class TestCumulativeSum : public ::testing::Test {
+//   using CType = TypeTraits<Type>::CType;
+
+//  protected:
+//   CumulativeSumOptions no_start_no_skip_nulls();
+//   CumulativeSumOptions has_start_no_skip_nulls(10);
+//   CumulativeSumOptions no_start_skip_nulls(0, true);
+//   CumulativeSumOptions has_start_skip_nulls(10, true);
+
+//   void SetUp() override {}
+
+//   void AssertValidCumulativeSum(const Array& expected, const Array& input,
+//                                 const CumulativeSumOptions options) {
+//     ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
+//     AssertArraysEqual(expected, *result, false, EqualOptions::Defaults());
+//   }
+// };
+
+// TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumFloating, FloatingTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumTemporal, TimeTypes);
+
+// TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {}
+// TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
+// TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
+// TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
+
+
+// }  // namespace compute
+// }  // namespace arrow
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index dc9cd9dd372..9378e92d2e2 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1754,7 +1754,7 @@ class CumulativeSumOptions(_CumulativeSumOptions):
         When false, propagates the first null/NaN encountered
     """
 
-    def __init__(self, start=0, skip_nulls=false):
+    def __init__(self, start=0, skip_nulls=False):
         self._set_options(start, skip_nulls)
 
 

From 1086c0babb217d5f4cb580276995362daf7d917c Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Thu, 24 Mar 2022 17:08:56 -0400
Subject: [PATCH 29/67] minor changes and initial tests

---
 cpp/src/arrow/compute/api_vector.cc           |  16 +-
 cpp/src/arrow/compute/api_vector.h            |  17 +-
 .../compute/kernels/vector_cumulative_sum.cc  |  10 +-
 .../kernels/vector_cumulative_sum_test.cc     | 177 +++++++++---------
 python/pyarrow/compute.py                     |   1 +
 python/pyarrow/includes/libarrow.pxd          |   1 +
 6 files changed, 113 insertions(+), 109 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 261bb3a2dd1..f27e91a3b5f 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -179,14 +179,14 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-CumulativeSumOptions::CumulativeSumOptions(uint64_t start, bool skip_nulls)
-    : CumulativeSumOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
-
-CumulativeSumOptions::CumulativeSumOptions(int64_t start, bool skip_nulls)
-    : CumulativeSumOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
-
-CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls)
-    : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
+// CumulativeSumOptions::CumulativeSumOptions(uint64_t start, bool skip_nulls)
+//     : CumulativeSumOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
+//
+// CumulativeSumOptions::CumulativeSumOptions(int64_t start, bool skip_nulls)
+//     : CumulativeSumOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
+//
+// CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls)
+//     : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
 
 CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
     : FunctionOptions(internal::kCumulativeSumOptionsType),
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 5742871fd64..26c1f9765e9 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,10 +191,10 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  explicit CumulativeSumOptions(uint64_t start, bool skip_nulls = false);
-  explicit CumulativeSumOptions(int64_t start, bool skip_nulls = false);
-  explicit CumulativeSumOptions(double start, bool skip_nulls = false);
-  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = nullptr,
+  // explicit CumulativeSumOptions(uint64_t start, bool skip_nulls = false);
+  // explicit CumulativeSumOptions(int64_t start, bool skip_nulls = false);
+  // explicit CumulativeSumOptions(double start, bool skip_nulls = false);
+  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<UInt8Type>>(0),
                                 bool skip_nulls = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
   static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
@@ -541,14 +541,7 @@ Result<Datum> DictionaryEncode(
     ExecContext* ctx = NULLPTR);
 
 ARROW_EXPORT
-Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
-                                             const CumulativeSumOptions& options,
-                                             ExecContext* ctx = NULLPTR);
-
-ARROW_EXPORT
-Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
-                                             const CumulativeSumOptions& options,
-                                             ExecContext* ctx = NULLPTR);
+Result<Datum> CumulativeSum(const Datum& values, const CumulativeSumOptions& options = CumulativeSumOptions::Defaults(), ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
 // Deprecated functions
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
index cb695a07133..a847c1054f2 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
@@ -71,15 +71,17 @@ struct CumulativeGeneric {
   }
 };
 
-const FunctionDoc cumulative_sum_doc(
+const FunctionDoc cumulative_sum_doc{
     "Compute the cumulative sum over an array of numbers",
     ("`values` must be an array of numeric type values.\n"
      "Return an array which is the cumulative sum computed over `values.`"),
-    {"values"});
+    {"values"},
+    "CumulativeSumOptions"};
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
+  auto options = CumulativeSumOptions::Defaults();
   auto cumulative_sum = std::make_shared<VectorFunction>(
-      "cumulative_sum", Arity::Unary(), &cumulative_sum_doc);
+      "cumulative_sum", Arity::Unary(), &cumulative_sum_doc, &options);
 
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
@@ -90,7 +92,7 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec = std::move(ArithmeticExecFromOp<CumulativeGeneric, Add>(ty));
+    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Add>(ty);
     kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
index 605cbb5e442..f2e9e621804 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
@@ -1,90 +1,97 @@
-// // Licensed to the Apache Software Foundation (ASF) under one
-// // or more contributor license agreements.  See the NOTICE file
-// // distributed with this work for additional information
-// // regarding copyright ownership.  The ASF licenses this file
-// // to you under the Apache License, Version 2.0 (the
-// // "License"); you may not use this file except in compliance
-// // with the License.  You may obtain a copy of the License at
-// //
-// //   http://www.apache.org/licenses/LICENSE-2.0
-// //
-// // Unless required by applicable law or agreed to in writing,
-// // software distributed under the License is distributed on an
-// // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// // KIND, either express or implied.  See the License for the
-// // specific language governing permissions and limitations
-// // under the License.
-
-// #include <algorithm>
-// #include <cstdint>
-// #include <cstdio>
-// #include <functional>
-// #include <locale>
-// #include <memory>
-// #include <stdexcept>
-// #include <string>
-// #include <utility>
-// #include <vector>
-
-// #include <gtest/gtest.h>
-
-// #include "arrow/array.h"
-// #include "arrow/array/builder_decimal.h"
-// #include "arrow/buffer.h"
-// #include "arrow/chunked_array.h"
-// #include "arrow/compute/api_vector.h"
-// #include "arrow/status.h"
-// #include "arrow/testing/util.h"
-// #include "arrow/type.h"
-// #include "arrow/type_fwd.h"
-// #include "arrow/type_traits.h"
-// #include "arrow/util/checked_cast.h"
-// #include "arrow/util/decimal.h"
-
-// #include "arrow/compute/api.h"
-// #include "arrow/compute/kernels/test_util.h"
-
-// #include "arrow/ipc/json_simple.h"
-
-// namespace arrow {
-// namespace compute {
-
-// using IntegralTypes = testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type,
-//                                      Int8Type, Int16Type, Int32Type, Int64Type>;
-
-// using FloatingTypes = testing::Types<FloatType, DoubleType>;
-
-// using TimeTypes = testing::Types<Date32Type, Date64Type, Time32Type, Time64Type,
-//                                  TimestampType, DurationType, MonthIntervalType>;
-
-// template <typename Type>
-// class TestCumulativeSum : public ::testing::Test {
-//   using CType = TypeTraits<Type>::CType;
-
-//  protected:
-//   CumulativeSumOptions no_start_no_skip_nulls();
-//   CumulativeSumOptions has_start_no_skip_nulls(10);
-//   CumulativeSumOptions no_start_skip_nulls(0, true);
-//   CumulativeSumOptions has_start_skip_nulls(10, true);
-
-//   void SetUp() override {}
-
-//   void AssertValidCumulativeSum(const Array& expected, const Array& input,
-//                                 const CumulativeSumOptions options) {
-//     ASSERT_OK_AND_ASSIGN(auto result, CumulativeSum(input, options, nullptr));
-//     AssertArraysEqual(expected, *result, false, EqualOptions::Defaults());
-//   }
-// };
-
-// TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumFloating, FloatingTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumTemporal, TimeTypes);
-
-// TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {}
+// Licensed to the Apache Software Foundation (ASF) under one // or more contributor license agreements.  See the NOTICE file // distributed with this work for additional information // regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <locale>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "arrow/array.h"
+#include "arrow/array/builder_decimal.h"
+#include "arrow/buffer.h"
+#include "arrow/chunked_array.h"
+#include "arrow/compute/api_vector.h"
+#include "arrow/status.h"
+#include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
+#include "arrow/testing/util.h"
+#include "arrow/type.h"
+#include "arrow/type_fwd.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/checked_cast.h"
+#include "arrow/util/decimal.h"
+
+#include "arrow/compute/api.h"
+#include "arrow/compute/kernels/test_util.h"
+
+#include "arrow/ipc/json_simple.h"
+
+namespace arrow {
+namespace compute {
+
+using DurationTypes = testing::Types<DurationType, MonthIntervalType>;
+
+template <typename T>
+class TestCumulativeSum : public ::testing::Test {
+ public:
+  using ArrowType = T;
+  // using CType = TypeTraits<Type>::CType;
+
+ protected:
+  static std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
+  }
+
+  void SetUp() override {}
+
+  void Assert(const std::shared_ptr<Array>& expected, const std::shared_ptr<Array>& input,
+                                const CumulativeSumOptions& options) {
+    ASSERT_OK_AND_ASSIGN(auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
+    AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
+  }
+};
+
+template <typename T>
+class TestCumulativeSumIntegral : public TestCumulativeSum<T> {};
+
+TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralArrowTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumFloating, RealArrowTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumTemporal, TemporalArrowTypes);
+// TYPED_TEST_SUITE(TestCumulativeSumDecimal, DecimalArrowTypes);
+
+TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeSumOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+  // CumulativeSumOptions options;
+
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4]");
+  this->Assert(expected, values, options);
+}
+
 // TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
 // TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
 // TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
 
 
-// }  // namespace compute
-// }  // namespace arrow
+}  // namespace compute
+}  // namespace arrow
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 0da61dcec0a..37bf90548bc 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -33,6 +33,7 @@
     AssumeTimezoneOptions,
     CastOptions,
     CountOptions,
+    CumulativeSumOptions,
     DayOfWeekOptions,
     DictionaryEncodeOptions,
     ElementWiseAggregateOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 33c46e56b70..13e16d4585b 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2245,6 +2245,7 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
 
     cdef cppclass CCumulativeSumOptions \
             "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
+        CCumulativeSumOptions(int64_t start)
         CCumulativeSumOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
         shared_ptr[CScalar] start
         c_bool skip_nulls

From 9615188842b60e704ecbca1bb5b50f19346ddb0b Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 25 Mar 2022 16:17:27 -0400
Subject: [PATCH 30/67] Refactoring, added optionstype to CumulativeGeneric
 template, and handling skip_nulls

---
 cpp/src/arrow/CMakeLists.txt                  |  2 +-
 cpp/src/arrow/compute/api_vector.cc           | 40 +++++-------
 cpp/src/arrow/compute/api_vector.h            | 19 +++---
 cpp/src/arrow/compute/kernels/CMakeLists.txt  |  2 +-
 .../arrow/compute/kernels/codegen_internal.h  | 22 +++----
 ...lative_sum.cc => vector_cumulative_ops.cc} | 65 +++++++++++++++----
 ..._test.cc => vector_cumulative_ops_test.cc} | 10 +--
 docs/source/python/api/compute.rst            |  2 +-
 python/pyarrow/_compute.pyx                   |  6 +-
 python/pyarrow/compute.py                     |  2 +-
 python/pyarrow/includes/libarrow.pxd          |  8 +--
 python/pyarrow/tests/test_compute.py          |  2 +-
 12 files changed, 106 insertions(+), 74 deletions(-)
 rename cpp/src/arrow/compute/kernels/{vector_cumulative_sum.cc => vector_cumulative_ops.cc} (62%)
 rename cpp/src/arrow/compute/kernels/{vector_cumulative_sum_test.cc => vector_cumulative_ops_test.cc} (90%)

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index de67503ad0c..f3bce5f4d67 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -436,7 +436,7 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_validity.cc
        compute/kernels/util_internal.cc
        compute/kernels/vector_array_sort.cc
-       compute/kernels/vector_cumulative_sum.cc
+       compute/kernels/vector_cumulative_ops.cc
        compute/kernels/vector_hash.cc
        compute/kernels/vector_nested.cc
        compute/kernels/vector_replace.cc
diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index f27e91a3b5f..6714f71ca04 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -135,9 +135,9 @@ static auto kPartitionNthOptionsType = GetFunctionOptionsType<PartitionNthOption
 static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
-static auto kCumulativeSumOptionsType = GetFunctionOptionsType<CumulativeSumOptions>(
-    DataMember("start", &CumulativeSumOptions::start),
-    DataMember("skip_nulls", &CumulativeSumOptions::skip_nulls));
+static auto kCumulativeGenericOptionsType = GetFunctionOptionsType<CumulativeGenericOptions>(
+    DataMember("start", &CumulativeGenericOptions::start),
+    DataMember("skip_nulls", &CumulativeGenericOptions::skip_nulls));
 }  // namespace
 }  // namespace internal
 
@@ -179,20 +179,20 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-// CumulativeSumOptions::CumulativeSumOptions(uint64_t start, bool skip_nulls)
-//     : CumulativeSumOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
+// CumulativeGenericOptions::CumulativeGenericOptions(uint64_t start, bool skip_nulls)
+//     : CumulativeGenericOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
 //
-// CumulativeSumOptions::CumulativeSumOptions(int64_t start, bool skip_nulls)
-//     : CumulativeSumOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
+// CumulativeGenericOptions::CumulativeGenericOptions(int64_t start, bool skip_nulls)
+//     : CumulativeGenericOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
 //
-// CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls)
-//     : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
+// CumulativeGenericOptions::CumulativeGenericOptions(double start, bool skip_nulls)
+//     : CumulativeGenericOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
 
-CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
-    : FunctionOptions(internal::kCumulativeSumOptionsType),
+CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
+    : FunctionOptions(internal::kCumulativeGenericOptionsType),
       start(std::move(start)),
       skip_nulls(skip_nulls) {}
-constexpr char CumulativeSumOptions::kTypeName[];
+constexpr char CumulativeGenericOptions::kTypeName[];
 
 namespace internal {
 void RegisterVectorOptions(FunctionRegistry* registry) {
@@ -203,7 +203,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kSortOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPartitionNthOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSelectKOptionsType));
-  DCHECK_OK(registry->AddFunctionOptionsType(kCumulativeSumOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kCumulativeGenericOptionsType));
 }
 }  // namespace internal
 
@@ -344,22 +344,14 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
   return out.make_array();
 }
 
-Result<std::shared_ptr<Array>> CumulativeSum(const Array& values,
-                                             const CumulativeSumOptions& options,
-                                             ExecContext* ctx) {
+Result<Datum> CumulativeSum(const Datum& values,
+                            const CumulativeGenericOptions& options,
+                            ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(Datum out,
                         CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
   return out.make_array();
 }
 
-Result<std::shared_ptr<Array>> CumulativeSum(const ChunkedArray& chunked_array,
-                                             const CumulativeSumOptions& options,
-                                             ExecContext* ctx) {
-  ARROW_ASSIGN_OR_RAISE(
-      Datum out, CallFunction("cumulative_sum", {Datum(chunked_array)}, &options, ctx));
-  return out.make_array();
-}
-
 // ----------------------------------------------------------------------
 // Deprecated functions
 
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 26c1f9765e9..e55424fb3b1 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -189,15 +189,16 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 };
 
 /// \brief Options for cumulative sum function
-class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
+class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
  public:
-  // explicit CumulativeSumOptions(uint64_t start, bool skip_nulls = false);
-  // explicit CumulativeSumOptions(int64_t start, bool skip_nulls = false);
-  // explicit CumulativeSumOptions(double start, bool skip_nulls = false);
-  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<UInt8Type>>(0),
+  // explicit CumulativeGenericOptions(uint64_t start, bool skip_nulls = false);
+  // explicit CumulativeGenericOptions(int64_t start, bool skip_nulls = false);
+  // explicit CumulativeGenericOptions(double start, bool skip_nulls = false);
+  explicit CumulativeGenericOptions(
+      std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
                                 bool skip_nulls = false);
-  static constexpr char const kTypeName[] = "CumulativeSumOptions";
-  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
+  static constexpr char const kTypeName[] = "CumulativeGenericOptions";
+  static CumulativeGenericOptions Defaults() { return CumulativeGenericOptions(); }
 
   /// Optional starting value for sum computation
   std::shared_ptr<Scalar> start;
@@ -541,7 +542,9 @@ Result<Datum> DictionaryEncode(
     ExecContext* ctx = NULLPTR);
 
 ARROW_EXPORT
-Result<Datum> CumulativeSum(const Datum& values, const CumulativeSumOptions& options = CumulativeSumOptions::Defaults(), ExecContext* ctx = NULLPTR);
+Result<Datum> CumulativeSum(const Datum& values,
+                            const CumulativeGenericOptions& options = CumulativeGenericOptions::Defaults(),
+                            ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
 // Deprecated functions
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 7659a5b5490..a3f14a58a63 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -47,7 +47,7 @@ add_arrow_benchmark(scalar_string_benchmark PREFIX "arrow-compute")
 
 add_arrow_compute_test(vector_test
                        SOURCES
-                       vector_cumulative_sum_test.cc
+                       vector_cumulative_ops_test.cc
                        vector_hash_test.cc
                        vector_nested_test.cc
                        vector_replace_test.cc
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 8eb5cba5d39..333f4835aa6 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -1134,31 +1134,31 @@ ArrayKernelExec GeneratePhysicalInteger(detail::GetTypeId get_id) {
   }
 }
 
-template <template <typename... Args> class KernelGenerator, typename Op>
+template <template <typename...> class KernelGenerator, typename Op, typename... Args>
 ArrayKernelExec ArithmeticExecFromOp(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
-      return KernelGenerator<Int8Type, Int8Type, Op>::Exec;
+      return KernelGenerator<Int8Type, Int8Type, Op, Args...>::Exec;
     case Type::UINT8:
-      return KernelGenerator<UInt8Type, UInt8Type, Op>::Exec;
+      return KernelGenerator<UInt8Type, UInt8Type, Op, Args...>::Exec;
     case Type::INT16:
-      return KernelGenerator<Int16Type, Int16Type, Op>::Exec;
+      return KernelGenerator<Int16Type, Int16Type, Op, Args...>::Exec;
     case Type::UINT16:
-      return KernelGenerator<UInt16Type, UInt16Type, Op>::Exec;
+      return KernelGenerator<UInt16Type, UInt16Type, Op, Args...>::Exec;
     case Type::INT32:
-      return KernelGenerator<Int32Type, Int32Type, Op>::Exec;
+      return KernelGenerator<Int32Type, Int32Type, Op, Args...>::Exec;
     case Type::UINT32:
-      return KernelGenerator<UInt32Type, UInt32Type, Op>::Exec;
+      return KernelGenerator<UInt32Type, UInt32Type, Op, Args...>::Exec;
     case Type::DURATION:
     case Type::INT64:
     case Type::TIMESTAMP:
-      return KernelGenerator<Int64Type, Int64Type, Op>::Exec;
+      return KernelGenerator<Int64Type, Int64Type, Op, Args...>::Exec;
     case Type::UINT64:
-      return KernelGenerator<UInt64Type, UInt64Type, Op>::Exec;
+      return KernelGenerator<UInt64Type, UInt64Type, Op, Args...>::Exec;
     case Type::FLOAT:
-      return KernelGenerator<FloatType, FloatType, Op>::Exec;
+      return KernelGenerator<FloatType, FloatType, Op, Args...>::Exec;
     case Type::DOUBLE:
-      return KernelGenerator<DoubleType, DoubleType, Op>::Exec;
+      return KernelGenerator<DoubleType, DoubleType, Op, Args...>::Exec;
     default:
       DCHECK(false);
       return ExecFail;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
similarity index 62%
rename from cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
rename to cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index a847c1054f2..5d83deb2c83 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -23,18 +23,20 @@
 #include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/result.h"
 #include "arrow/visit_type_inline.h"
+#include "arrow/util/bit_util.h"
 
 namespace arrow {
 namespace compute {
 namespace internal {
 
-template <typename OutType, typename ArgType, typename Op>
+template <typename OutType, typename ArgType, typename Op, typename OptionsType>
 struct CumulativeGeneric {
   using OutValue = typename GetOutputType<OutType>::T;
   using ArgValue = typename GetViewType<ArgType>::T;
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const auto& options = OptionsWrapper<CumulativeSumOptions>::Get(ctx);
+    const auto& options = OptionsWrapper<OptionsType>::Get(ctx);
+    // auto start = (options.start) ? UnboxScalar<ArgType>::Unbox(*options.start) : checked_cast<ArgValue>(0);
     auto start = UnboxScalar<ArgType>::Unbox(*options.start);
     bool skip_nulls = options.skip_nulls;
 
@@ -61,12 +63,51 @@ struct CumulativeGeneric {
   static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
                             Datum* out, bool skip_nulls) {
     Status st = Status::OK();
-    ArrayIterator<ArgType> arg0_it(arg0);
-    RETURN_NOT_OK(applicator::OutputAdapter<OutType>::Write(ctx, out, [&]() -> OutValue {
-      partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, arg0_it(), partial_scan,
-                                                               &st);
-      return partial_scan;
-    }));
+    ArrayData* out_arr = out->mutable_array();
+    auto out_data = out_arr->GetMutableValues<OutValue>(1);
+
+    if (skip_nulls) {
+      VisitArrayValuesInline<ArgType>(
+          arg0,
+          [&](ArgValue v) {
+            partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v,
+                                                                          partial_scan, &st);
+            *out_data++ = partial_scan;
+          },
+          [&]() {
+            // null
+            *out_data++ = OutValue{};
+          });
+    } else {
+      bool encounted_null = false;
+      auto start_null_idx = arg0.offset;
+
+      VisitArrayValuesInline<ArgType>(
+          arg0,
+          [&](ArgValue v) {
+            if (encounted_null) {
+              *out_data++ = OutValue{};
+            } else {
+              partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v,
+                                                                            partial_scan, &st);    
+              *out_data++ = partial_scan;
+              ++start_null_idx;
+            }
+          },
+          [&]() {
+            // null
+            *out_data++ = OutValue{};
+            if (!encounted_null) {
+              ++start_null_idx;
+              encounted_null = true;
+            }
+          });
+
+      auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
+      auto null_length = arg0.length - (start_null_idx - arg0.offset);
+      arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
+    }
+
     return st;
   }
 };
@@ -76,10 +117,10 @@ const FunctionDoc cumulative_sum_doc{
     ("`values` must be an array of numeric type values.\n"
      "Return an array which is the cumulative sum computed over `values.`"),
     {"values"},
-    "CumulativeSumOptions"};
+    "CumulativeGenericOptions"};
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-  auto options = CumulativeSumOptions::Defaults();
+  auto options = CumulativeGenericOptions::Defaults();
   auto cumulative_sum = std::make_shared<VectorFunction>(
       "cumulative_sum", Arity::Unary(), &cumulative_sum_doc, &options);
 
@@ -92,8 +133,8 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Add>(ty);
-    kernel.init = OptionsWrapper<CumulativeSumOptions>::Init;
+    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Add, CumulativeGenericOptions>(ty);
+    kernel.init = OptionsWrapper<CumulativeGenericOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
similarity index 90%
rename from cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
rename to cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index f2e9e621804..2eeb92eb44f 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_sum_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -34,10 +34,6 @@
 #include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
-#include "arrow/type_fwd.h"
-#include "arrow/type_traits.h"
-#include "arrow/util/checked_cast.h"
-#include "arrow/util/decimal.h"
 
 #include "arrow/compute/api.h"
 #include "arrow/compute/kernels/test_util.h"
@@ -63,7 +59,7 @@ class TestCumulativeSum : public ::testing::Test {
   void SetUp() override {}
 
   void Assert(const std::shared_ptr<Array>& expected, const std::shared_ptr<Array>& input,
-                                const CumulativeSumOptions& options) {
+                                const CumulativeGenericOptions& options) {
     ASSERT_OK_AND_ASSIGN(auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
     AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
   }
@@ -80,8 +76,8 @@ TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralArrowTypes);
 TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {
   using ArrowType = typename TestFixture::ArrowType;
 
-  CumulativeSumOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-  // CumulativeSumOptions options;
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+  // CumulativeGenericOptions options;
 
   auto values = ArrayFromJSON(this->type_singleton(), "[1, 3]");
   auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4]");
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index df43bd5e8e0..664a3f76633 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -502,7 +502,7 @@ Compute Options
    CastOptions
    CountOptions
    CountOptions
-   CumulativeSumOptions
+   CumulativeGenericOptions
    DayOfWeekOptions
    DictionaryEncodeOptions
    ElementWiseAggregateOptions
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 9378e92d2e2..fedace2f563 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1736,13 +1736,13 @@ class PartitionNthOptions(_PartitionNthOptions):
         self._set_options(pivot, null_placement)
 
 
-cdef class _CumulativeSumOptions(FunctionOptions):
+cdef class _CumulativeGenericOptions(FunctionOptions):
     def _set_options(self, start, skip_nulls):
-        self.wrapped.reset(new CCumulativeSumOptions(
+        self.wrapped.reset(new CCumulativeGenericOptions(
             pyarrow_unwrap_scalar(start), skip_nulls))
 
 
-class CumulativeSumOptions(_CumulativeSumOptions):
+class CumulativeGenericOptions(_CumulativeGenericOptions):
     """
     Options for `cumulative_sum` function.
 
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 37bf90548bc..2091de4b368 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -33,7 +33,7 @@
     AssumeTimezoneOptions,
     CastOptions,
     CountOptions,
-    CumulativeSumOptions,
+    CumulativeGenericOptions,
     DayOfWeekOptions,
     DictionaryEncodeOptions,
     ElementWiseAggregateOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 13e16d4585b..2a3314fa395 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2243,10 +2243,10 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         int64_t pivot
         CNullPlacement null_placement
 
-    cdef cppclass CCumulativeSumOptions \
-            "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
-        CCumulativeSumOptions(int64_t start)
-        CCumulativeSumOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
+    cdef cppclass CCumulativeGenericOptions \
+            "arrow::compute::CumulativeGenericOptions"(CFunctionOptions):
+        CCumulativeGenericOptions(int64_t start)
+        CCumulativeGenericOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
         shared_ptr[CScalar] start
         c_bool skip_nulls
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 14ca2355484..e98591d5248 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -147,7 +147,7 @@ def test_option_class_equality():
         pc.NullOptions(),
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
-        pc.CumulativeSumOptions(start=0, skip_nulls=False),
+        pc.CumulativeGenericOptions(start=0, skip_nulls=False),
         pc.QuantileOptions(),
         pc.RandomOptions(10),
         pc.ReplaceSliceOptions(0, 1, "a"),

From 05c799dbe0fc13f74a3af788b6b9239ed05eb4d7 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Sat, 26 Mar 2022 23:27:33 -0400
Subject: [PATCH 31/67] Linting

---
 cpp/src/arrow/compute/api_vector.cc           | 13 ++++----
 cpp/src/arrow/compute/api_vector.h            |  9 ++---
 .../kernels/base_arithmetic_internal.h        |  1 -
 .../compute/kernels/scalar_arithmetic.cc      |  2 +-
 .../compute/kernels/vector_cumulative_ops.cc  | 27 +++++++--------
 .../kernels/vector_cumulative_ops_test.cc     | 33 ++++++++++++++++---
 6 files changed, 54 insertions(+), 31 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 6714f71ca04..6717670e9b5 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -135,9 +135,10 @@ static auto kPartitionNthOptionsType = GetFunctionOptionsType<PartitionNthOption
 static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
-static auto kCumulativeGenericOptionsType = GetFunctionOptionsType<CumulativeGenericOptions>(
-    DataMember("start", &CumulativeGenericOptions::start),
-    DataMember("skip_nulls", &CumulativeGenericOptions::skip_nulls));
+static auto kCumulativeGenericOptionsType =
+    GetFunctionOptionsType<CumulativeGenericOptions>(
+        DataMember("start", &CumulativeGenericOptions::start),
+        DataMember("skip_nulls", &CumulativeGenericOptions::skip_nulls));
 }  // namespace
 }  // namespace internal
 
@@ -188,7 +189,8 @@ constexpr char SelectKOptions::kTypeName[];
 // CumulativeGenericOptions::CumulativeGenericOptions(double start, bool skip_nulls)
 //     : CumulativeGenericOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
 
-CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start, bool skip_nulls)
+CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start,
+                                                   bool skip_nulls)
     : FunctionOptions(internal::kCumulativeGenericOptionsType),
       start(std::move(start)),
       skip_nulls(skip_nulls) {}
@@ -344,8 +346,7 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
   return out.make_array();
 }
 
-Result<Datum> CumulativeSum(const Datum& values,
-                            const CumulativeGenericOptions& options,
+Result<Datum> CumulativeSum(const Datum& values, const CumulativeGenericOptions& options,
                             ExecContext* ctx) {
   ARROW_ASSIGN_OR_RAISE(Datum out,
                         CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index e55424fb3b1..db00edda15f 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -196,7 +196,7 @@ class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
   // explicit CumulativeGenericOptions(double start, bool skip_nulls = false);
   explicit CumulativeGenericOptions(
       std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
-                                bool skip_nulls = false);
+      bool skip_nulls = false);
   static constexpr char const kTypeName[] = "CumulativeGenericOptions";
   static CumulativeGenericOptions Defaults() { return CumulativeGenericOptions(); }
 
@@ -542,9 +542,10 @@ Result<Datum> DictionaryEncode(
     ExecContext* ctx = NULLPTR);
 
 ARROW_EXPORT
-Result<Datum> CumulativeSum(const Datum& values,
-                            const CumulativeGenericOptions& options = CumulativeGenericOptions::Defaults(),
-                            ExecContext* ctx = NULLPTR);
+Result<Datum> CumulativeSum(
+    const Datum& values,
+    const CumulativeGenericOptions& options = CumulativeGenericOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
 // Deprecated functions
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index 899f26cd126..f29ed013b9a 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -100,4 +100,3 @@ struct AddTimeDurationChecked {
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
-
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 26143f3749e..125af57a114 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -23,9 +23,9 @@
 
 #include "arrow/compare.h"
 #include "arrow/compute/api_scalar.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/util_internal.h"
-#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/decimal.h"
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 5d83deb2c83..a29a50f8849 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -18,12 +18,12 @@
 #include "arrow/array/array_base.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common.h"
-#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/result.h"
-#include "arrow/visit_type_inline.h"
 #include "arrow/util/bit_util.h"
+#include "arrow/visit_type_inline.h"
 
 namespace arrow {
 namespace compute {
@@ -36,7 +36,6 @@ struct CumulativeGeneric {
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<OptionsType>::Get(ctx);
-    // auto start = (options.start) ? UnboxScalar<ArgType>::Unbox(*options.start) : checked_cast<ArgValue>(0);
     auto start = UnboxScalar<ArgType>::Unbox(*options.start);
     bool skip_nulls = options.skip_nulls;
 
@@ -61,7 +60,7 @@ struct CumulativeGeneric {
   }
 
   static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
-                            Datum* out, bool skip_nulls) {
+                     Datum* out, bool skip_nulls) {
     Status st = Status::OK();
     ArrayData* out_arr = out->mutable_array();
     auto out_data = out_arr->GetMutableValues<OutValue>(1);
@@ -70,8 +69,8 @@ struct CumulativeGeneric {
       VisitArrayValuesInline<ArgType>(
           arg0,
           [&](ArgValue v) {
-            partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v,
-                                                                          partial_scan, &st);
+            partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
+                ctx, v, partial_scan, &st);
             *out_data++ = partial_scan;
           },
           [&]() {
@@ -88,8 +87,8 @@ struct CumulativeGeneric {
             if (encounted_null) {
               *out_data++ = OutValue{};
             } else {
-              partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v,
-                                                                            partial_scan, &st);    
+              partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
+                  ctx, v, partial_scan, &st);
               *out_data++ = partial_scan;
               ++start_null_idx;
             }
@@ -97,10 +96,7 @@ struct CumulativeGeneric {
           [&]() {
             // null
             *out_data++ = OutValue{};
-            if (!encounted_null) {
-              ++start_null_idx;
-              encounted_null = true;
-            }
+            encounted_null = true;
           });
 
       auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
@@ -121,8 +117,8 @@ const FunctionDoc cumulative_sum_doc{
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   auto options = CumulativeGenericOptions::Defaults();
-  auto cumulative_sum = std::make_shared<VectorFunction>(
-      "cumulative_sum", Arity::Unary(), &cumulative_sum_doc, &options);
+  auto cumulative_sum = std::make_shared<VectorFunction>("cumulative_sum", Arity::Unary(),
+                                                         &cumulative_sum_doc, &options);
 
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
@@ -133,7 +129,8 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Add, CumulativeGenericOptions>(ty);
+    kernel.exec =
+        ArithmeticExecFromOp<CumulativeGeneric, Add, CumulativeGenericOptions>(ty);
     kernel.init = OptionsWrapper<CumulativeGenericOptions>::Init;
     DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
   }
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 2eeb92eb44f..d347895e3c7 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -1,4 +1,7 @@
-// Licensed to the Apache Software Foundation (ASF) under one // or more contributor license agreements.  See the NOTICE file // distributed with this work for additional information // regarding copyright ownership.  The ASF licenses this file
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
@@ -59,8 +62,9 @@ class TestCumulativeSum : public ::testing::Test {
   void SetUp() override {}
 
   void Assert(const std::shared_ptr<Array>& expected, const std::shared_ptr<Array>& input,
-                                const CumulativeGenericOptions& options) {
-    ASSERT_OK_AND_ASSIGN(auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
+              const CumulativeGenericOptions& options) {
+    ASSERT_OK_AND_ASSIGN(
+        auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
     AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
   }
 };
@@ -84,10 +88,31 @@ TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {
   this->Assert(expected, values, options);
 }
 
+TYPED_TEST(TestCumulativeSumIntegral, HasNullsNoSkipNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), false};
+  // CumulativeGenericOptions options;
+
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 5]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4, null, null]");
+  this->Assert(expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasNullsSkipNull) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
+  // CumulativeGenericOptions options;
+
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 5]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4, null, 9]");
+  this->Assert(expected, values, options);
+}
+
 // TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
 // TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
 // TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
 
-
 }  // namespace compute
 }  // namespace arrow

From aa27d96dc76e58fde8e1d32669b59aefe4a877e4 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 30 Mar 2022 14:08:15 -0400
Subject: [PATCH 32/67] Adding Tests for floating and temporal types

---
 cpp/src/arrow/compute/api_vector.h            |   3 -
 .../kernels/base_arithmetic_internal.h        |  17 +
 .../kernels/vector_cumulative_ops_test.cc     | 498 ++++++++++++++++--
 3 files changed, 483 insertions(+), 35 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index db00edda15f..e426ad19b19 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,9 +191,6 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
  public:
-  // explicit CumulativeGenericOptions(uint64_t start, bool skip_nulls = false);
-  // explicit CumulativeGenericOptions(int64_t start, bool skip_nulls = false);
-  // explicit CumulativeGenericOptions(double start, bool skip_nulls = false);
   explicit CumulativeGenericOptions(
       std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
       bool skip_nulls = false);
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index f29ed013b9a..e17fbb99f2d 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -1,3 +1,20 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
 #pragma once
 
 #include "arrow/compute/api_scalar.h"
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index d347895e3c7..55614ef32f7 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -37,6 +37,7 @@
 #include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
+#include "arrow/type_fwd.h"
 
 #include "arrow/compute/api.h"
 #include "arrow/compute/kernels/test_util.h"
@@ -48,71 +49,504 @@ namespace compute {
 
 using DurationTypes = testing::Types<DurationType, MonthIntervalType>;
 
+class TestCumulativeOp : public ::testing::Test {
+ protected:
+  void Assert(const std::string func, const std::shared_ptr<Array>& expected,
+              const std::shared_ptr<Array>& input,
+              const CumulativeGenericOptions& options) {
+    ASSERT_OK_AND_ASSIGN(auto result,
+                         CallFunction(func, {Datum(input)}, &options, nullptr));
+
+    AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
+  }
+};
+
 template <typename T>
-class TestCumulativeSum : public ::testing::Test {
+class TestCumulativeSumIntegral : public TestCumulativeOp {
  public:
-  using ArrowType = T;
-  // using CType = TypeTraits<Type>::CType;
+ using ArrowType = T;
 
  protected:
-  static std::shared_ptr<DataType> type_singleton() {
+  std::shared_ptr<DataType> type_singleton() {
     return TypeTraits<ArrowType>::type_singleton();
   }
+};
 
-  void SetUp() override {}
+template <typename T>
+class TestCumulativeSumFloating : public TestCumulativeOp {
+ public:
+ using ArrowType = T;
 
-  void Assert(const std::shared_ptr<Array>& expected, const std::shared_ptr<Array>& input,
-              const CumulativeGenericOptions& options) {
-    ASSERT_OK_AND_ASSIGN(
-        auto result, CallFunction("cumulative_sum", {Datum(input)}, &options, nullptr));
-    AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
+ protected:
+  std::shared_ptr<DataType> type_singleton() {
+    return TypeTraits<ArrowType>::type_singleton();
   }
 };
 
-template <typename T>
-class TestCumulativeSumIntegral : public TestCumulativeSum<T> {};
+class TestCumulativeSumTemporal : public TestCumulativeOp {
+ protected:
+  void Assert(std::shared_ptr<DataType>& type, std::string& values, std::string& expected,
+              CumulativeGenericOptions& options) {
+    auto values_array = ArrayFromJSON(type, values);
+    auto expected_array = ArrayFromJSON(type, expected);
+    TestCumulativeOp::Assert("cumulative_sum", values_array, expected_array, options);
+  }
+};
 
 TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralArrowTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumFloating, RealArrowTypes);
+TYPED_TEST_SUITE(TestCumulativeSumFloating, RealArrowTypes);
 // TYPED_TEST_SUITE(TestCumulativeSumTemporal, TemporalArrowTypes);
 // TYPED_TEST_SUITE(TestCumulativeSumDecimal, DecimalArrowTypes);
 
-TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNulls) {
+TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, null, null, null]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, NoStartDoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, NoStartDoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 7, null, 13]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected =
+      ArrayFromJSON(this->type_singleton(), "[11, 13, null, null, null, null]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasStartDoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumIntegral, HasStartDoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, null, 17, null, 23]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, NoStartNoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, NoStartNoSkipHasNulls) {
   using ArrowType = typename TestFixture::ArrowType;
 
   CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-  // CumulativeGenericOptions options;
 
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4]");
-  this->Assert(expected, values, options);
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, null, null, null]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
 }
 
-TYPED_TEST(TestCumulativeSumIntegral, HasNullsNoSkipNulls) {
+TYPED_TEST(TestCumulativeSumFloating, NoStartDoSkipNoNulls) {
   using ArrowType = typename TestFixture::ArrowType;
 
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), false};
-  // CumulativeGenericOptions options;
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
 
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 5]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4, null, null]");
-  this->Assert(expected, values, options);
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
 }
 
-TYPED_TEST(TestCumulativeSumIntegral, HasNullsSkipNull) {
+TYPED_TEST(TestCumulativeSumFloating, NoStartDoSkipHasNulls) {
   using ArrowType = typename TestFixture::ArrowType;
 
   CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-  // CumulativeGenericOptions options;
 
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 5]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 4, null, 9]");
-  this->Assert(expected, values, options);
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 7, null, 13]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, HasStartNoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, HasStartNoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected =
+      ArrayFromJSON(this->type_singleton(), "[11, 13, null, null, null, null]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, HasStartDoSkipNoNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
+
+  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
+
+  this->Assert("cumulative_sum", empty, empty, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TYPED_TEST(TestCumulativeSumFloating, HasStartDoSkipHasNulls) {
+  using ArrowType = typename TestFixture::ArrowType;
+
+  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
+
+  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
+  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
+  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
+  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, null, 17, null, 23]");
+
+  this->Assert("cumulative_sum", one_null, one_null, options);
+  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
+  this->Assert("cumulative_sum", expected, values, options);
+}
+
+TEST_F(TestCumulativeSumTemporal, NoStartNoSkipNoNulls) {
+  auto empty = "[]";
+  auto time_values = "[1, 2, 3, 4, 5, 6]";
+  auto time_expected = "[1, 3, 6, 10, 15, 21]";
+  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+  auto date_expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0)};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0)};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0)};
+
+  this->Assert(date32(), empty, empty, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), empty, empty, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, NoStartNoSkipHasNulls) {
+  auto one_null = "[null]";
+  auto three_nulls = "[null, null, null]";
+  auto time_values = "[1, 2, null, 4, null, 6]";
+  auto time_expected = "[1, 3, null, null, null, null]";
+  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
+  auto date_expected = "[0, 86400000, null, null, null, null]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0)};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0)};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0)};
+
+  this->Assert(date32(), one_null, one_null, date_options);
+  this->Assert(date32(), three_nulls, three_nulls, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), one_null, one_null, date_options);
+  this->Assert(date64(), three_nulls, three_nulls, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, NoStartDoSkipNoNulls) {
+  auto empty = "[]";
+  auto time_values = "[1, 2, 3, 4, 5, 6]";
+  auto time_expected = "[1, 3, 6, 10, 15, 21]";
+  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+  auto date_expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0), true};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0), true};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0), true};
+
+  this->Assert(date32(), empty, empty, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), empty, empty, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, NoStartDoSkipHasNulls) {
+  auto one_null = "[null]";
+  auto three_nulls = "[null, null, null]";
+  auto time_values = "[1, 2, null, 4, null, 6]";
+  auto time_expected = "[1, 3, null, 7, null, 13]";
+  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
+  auto date_expected = "[0, 86400000, null, 345600000, null, 777600000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0), true};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0), true};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0), true};
+
+  this->Assert(date32(), one_null, one_null, date_options);
+  this->Assert(date32(), three_nulls, three_nulls, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), one_null, one_null, date_options);
+  this->Assert(date64(), three_nulls, three_nulls, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, HasStartNoSkipNoNulls) {
+  auto empty = "[]";
+  auto time_values = "[1, 2, 3, 4, 5, 6]";
+  auto time_expected = "[11, 13, 16, 20, 25, 31]";
+  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+  auto date_expected = "[86400000, 172800000, 345600000, 604800000, 950400000, 1382400000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000)};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10)};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10)};
+
+  this->Assert(date32(), empty, empty, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), empty, empty, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, HasStartNoSkipHasNulls) {
+  auto one_null = "[null]";
+  auto three_nulls = "[null, null, null]";
+  auto time_values = "[1, 2, null, 4, null, 6]";
+  auto time_expected = "[11, 13, null, null, null, null]";
+  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
+  auto date_expected = "[86400000, 172800000, null, null, null, null]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000)};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10)};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10)};
+
+  this->Assert(date32(), one_null, one_null, date_options);
+  this->Assert(date32(), three_nulls, three_nulls, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), one_null, one_null, date_options);
+  this->Assert(date64(), three_nulls, three_nulls, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
 }
 
-// TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNulls) {}
-// TYPED_TEST(TestCumulativeSumIntegral, NoStartSkipNulls) {}
-// TYPED_TEST(TestCumulativeSumIntegral, HasStartSkipNulls) {}
+TEST_F(TestCumulativeSumTemporal, HasStartDoSkipNoNulls) {
+  auto empty = "[]";
+  auto time_values = "[1, 2, 3, 4, 5, 6]";
+  auto time_expected = "[11, 13, 16, 20, 25, 31]";
+  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+  auto date_expected = "[86400000, 172800000, 345600000, 604800000, 950400000, 1382400000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000), true};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10), true};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10), true};
+
+  this->Assert(date32(), empty, empty, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), empty, empty, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
+
+TEST_F(TestCumulativeSumTemporal, HasStartDoSkipHasNulls) {
+  auto one_null = "[null]";
+  auto three_nulls = "[null, null, null]";
+  auto time_values = "[1, 2, null, 4, null, 6]";
+  auto time_expected = "[11, 13, null, 17, null, 23]";
+  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
+  auto date_expected = "[86400000, 172800000, null, 429000000, null, 861000000]";
+
+  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000), true};
+  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10), true};
+  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10), true};
+
+  this->Assert(date32(), one_null, one_null, date_options);
+  this->Assert(date32(), three_nulls, three_nulls, date_options);
+  this->Assert(date32(), date_values, date_expected, date_options);
+  this->Assert(date64(), one_null, one_null, date_options);
+  this->Assert(date64(), three_nulls, three_nulls, date_options);
+  this->Assert(date64(), date_values, date_expected, date_options);
+
+  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
+  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+}
 
 }  // namespace compute
 }  // namespace arrow

From f3218af445c8e43dab8b18d643a82b232cac3e68 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 31 Mar 2022 18:15:29 -0400
Subject: [PATCH 33/67] Simplified CumulateSum tests

---
 .../compute/kernels/vector_cumulative_ops.cc  |  52 +-
 .../kernels/vector_cumulative_ops_test.cc     | 630 +++++-------------
 2 files changed, 194 insertions(+), 488 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index a29a50f8849..a4e9ab15952 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -65,42 +65,31 @@ struct CumulativeGeneric {
     ArrayData* out_arr = out->mutable_array();
     auto out_data = out_arr->GetMutableValues<OutValue>(1);
 
-    if (skip_nulls) {
-      VisitArrayValuesInline<ArgType>(
-          arg0,
-          [&](ArgValue v) {
+    bool encounted_null = false;
+    auto start_null_idx = arg0.offset;
+
+    VisitArrayValuesInline<ArgType>(
+        arg0,
+        [&](ArgValue v) {
+          if (!skip_nulls && encounted_null) {
+            *out_data++ = OutValue{};
+          } else {
             partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
                 ctx, v, partial_scan, &st);
             *out_data++ = partial_scan;
-          },
-          [&]() {
-            // null
-            *out_data++ = OutValue{};
-          });
-    } else {
-      bool encounted_null = false;
-      auto start_null_idx = arg0.offset;
-
-      VisitArrayValuesInline<ArgType>(
-          arg0,
-          [&](ArgValue v) {
-            if (encounted_null) {
-              *out_data++ = OutValue{};
-            } else {
-              partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
-                  ctx, v, partial_scan, &st);
-              *out_data++ = partial_scan;
-              ++start_null_idx;
-            }
-          },
-          [&]() {
-            // null
-            *out_data++ = OutValue{};
-            encounted_null = true;
-          });
-
+            ++start_null_idx;
+          }
+        },
+        [&]() {
+          // null
+          *out_data++ = OutValue{};
+          encounted_null = true;
+        });
+
+    if (!skip_nulls) {
       auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
       auto null_length = arg0.length - (start_null_idx - arg0.offset);
+      out_arr->SetNullCount(null_length);
       arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
     }
 
@@ -122,6 +111,7 @@ void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
 
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
+  types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
 
   for (const auto& ty : NumericTypes()) {
     VectorKernel kernel;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 55614ef32f7..2b7b05f1f51 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -31,9 +31,6 @@
 #include "arrow/array.h"
 #include "arrow/array/builder_decimal.h"
 #include "arrow/buffer.h"
-#include "arrow/chunked_array.h"
-#include "arrow/compute/api_vector.h"
-#include "arrow/status.h"
 #include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
@@ -47,12 +44,29 @@
 namespace arrow {
 namespace compute {
 
-using DurationTypes = testing::Types<DurationType, MonthIntervalType>;
+using CumulativeTypes =
+    testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int8Type, Int16Type,
+                   Int32Type, Int64Type, FloatType, DoubleType>;
 
+//  Date32Type, Date64Type, Time32Type, Time64Type,
+//  TimestampType, DurationType, MonthIntervalType>;
+
+template <typename T>
 class TestCumulativeOp : public ::testing::Test {
+ public:
+  using ArrowType = T;
+  using ArrowScalar = typename TypeTraits<T>::ScalarType;
+  using CType = typename TypeTraits<T>::CType;
+
  protected:
-  void Assert(const std::string func, const std::shared_ptr<Array>& expected,
-              const std::shared_ptr<Array>& input,
+  std::shared_ptr<DataType> type_singleton() { return default_type_instance<T>(); }
+
+  std::shared_ptr<Array> array(const std::string& value) {
+    return ArrayFromJSON(type_singleton(), value);
+  }
+
+  void Assert(const std::string func, const std::shared_ptr<Array>& input,
+              const std::shared_ptr<Array>& expected,
               const CumulativeGenericOptions& options) {
     ASSERT_OK_AND_ASSIGN(auto result,
                          CallFunction(func, {Datum(input)}, &options, nullptr));
@@ -62,490 +76,192 @@ class TestCumulativeOp : public ::testing::Test {
 };
 
 template <typename T>
-class TestCumulativeSumIntegral : public TestCumulativeOp {
+class TestCumulativeSum : public TestCumulativeOp<T> {
  public:
- using ArrowType = T;
+  using ArrowType = typename TestCumulativeOp<T>::ArrowType;
+  using ArrowScalar = typename TestCumulativeOp<T>::ArrowScalar;
+  using CType = typename TestCumulativeOp<T>::CType;
 
  protected:
-  std::shared_ptr<DataType> type_singleton() {
-    return TypeTraits<ArrowType>::type_singleton();
+  template <typename U = T>
+  enable_if_parameter_free<U, CumulativeGenericOptions> generate_options(
+      CType start = 0, bool skip_nulls = false) {
+    return CumulativeGenericOptions(std::make_shared<ArrowScalar>(start), skip_nulls);
   }
-};
-
-template <typename T>
-class TestCumulativeSumFloating : public TestCumulativeOp {
- public:
- using ArrowType = T;
 
- protected:
-  std::shared_ptr<DataType> type_singleton() {
-    return TypeTraits<ArrowType>::type_singleton();
+  template <typename U = T>
+  enable_if_t<is_time_type<U>::value || is_timestamp_type<U>::value,
+              CumulativeGenericOptions>
+  generate_options(CType start = 0, bool skip_nulls = false) {
+    TimeUnit::type unit;
+    switch (ArrowType::type_id) {
+      case Type::TIME64:
+        unit = TimeUnit::NANO;
+        break;
+      default:
+        unit = TimeUnit::SECOND;
+        break;
+    }
+    return CumulativeGenericOptions(std::make_shared<ArrowScalar>(start, unit),
+                                    skip_nulls);
   }
-};
 
-class TestCumulativeSumTemporal : public TestCumulativeOp {
- protected:
-  void Assert(std::shared_ptr<DataType>& type, std::string& values, std::string& expected,
-              CumulativeGenericOptions& options) {
-    auto values_array = ArrayFromJSON(type, values);
-    auto expected_array = ArrayFromJSON(type, expected);
-    TestCumulativeOp::Assert("cumulative_sum", values_array, expected_array, options);
+  void Assert(const std::string& values, const std::string& expected,
+              const CumulativeGenericOptions& options) {
+    auto values_arr = TestCumulativeOp<T>::array(values);
+    auto expected_arr = TestCumulativeOp<T>::array(expected);
+    TestCumulativeOp<T>::Assert("cumulative_sum", values_arr, expected_arr, options);
   }
 };
 
-TYPED_TEST_SUITE(TestCumulativeSumIntegral, IntegralArrowTypes);
-TYPED_TEST_SUITE(TestCumulativeSumFloating, RealArrowTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumTemporal, TemporalArrowTypes);
-// TYPED_TEST_SUITE(TestCumulativeSumDecimal, DecimalArrowTypes);
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartNoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, null, null, null]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartDoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, NoStartDoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 7, null, 13]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, HasStartNoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected =
-      ArrayFromJSON(this->type_singleton(), "[11, 13, null, null, null, null]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, HasStartDoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumIntegral, HasStartDoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, null, 17, null, 23]");
+TYPED_TEST_SUITE(TestCumulativeSum, CumulativeTypes);
 
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, NoStartNoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, NoStartNoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0)};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, null, null, null]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, NoStartDoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, 6, 10, 15, 21]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, NoStartDoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(0), true};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[1, 3, null, 7, null, 13]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, HasStartNoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, HasStartNoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10)};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected =
-      ArrayFromJSON(this->type_singleton(), "[11, 13, null, null, null, null]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, HasStartDoSkipNoNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
-
-  auto empty = ArrayFromJSON(this->type_singleton(), "[]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, 3, 4, 5, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, 16, 20, 25, 31]");
-
-  this->Assert("cumulative_sum", empty, empty, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TYPED_TEST(TestCumulativeSumFloating, HasStartDoSkipHasNulls) {
-  using ArrowType = typename TestFixture::ArrowType;
-
-  CumulativeGenericOptions options{std::make_shared<NumericScalar<ArrowType>>(10), true};
-
-  auto one_null = ArrayFromJSON(this->type_singleton(), "[null]");
-  auto multiple_nulls = ArrayFromJSON(this->type_singleton(), "[null, null, null]");
-  auto values = ArrayFromJSON(this->type_singleton(), "[1, 2, null, 4, null, 6]");
-  auto expected = ArrayFromJSON(this->type_singleton(), "[11, 13, null, 17, null, 23]");
-
-  this->Assert("cumulative_sum", one_null, one_null, options);
-  this->Assert("cumulative_sum", multiple_nulls, multiple_nulls, options);
-  this->Assert("cumulative_sum", expected, values, options);
-}
-
-TEST_F(TestCumulativeSumTemporal, NoStartNoSkipNoNulls) {
+TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
+  CumulativeGenericOptions options = this->generate_options();
   auto empty = "[]";
-  auto time_values = "[1, 2, 3, 4, 5, 6]";
-  auto time_expected = "[1, 3, 6, 10, 15, 21]";
-  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-  auto date_expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0)};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0)};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0)};
-
-  this->Assert(date32(), empty, empty, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), empty, empty, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(empty, empty, options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+    auto expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
+    this->Assert(values, expected, options);
+  } else {
+    auto values = "[1, 2, 3, 4, 5, 6]";
+    auto expected = "[1, 3, 6, 10, 15, 21]";
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, NoStartNoSkipHasNulls) {
+TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
+  CumulativeGenericOptions options = this->generate_options();
   auto one_null = "[null]";
-  auto three_nulls = "[null, null, null]";
-  auto time_values = "[1, 2, null, 4, null, 6]";
-  auto time_expected = "[1, 3, null, null, null, null]";
-  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
-  auto date_expected = "[0, 86400000, null, null, null, null]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0)};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0)};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0)};
-
-  this->Assert(date32(), one_null, one_null, date_options);
-  this->Assert(date32(), three_nulls, three_nulls, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), one_null, one_null, date_options);
-  this->Assert(date64(), three_nulls, three_nulls, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  auto three_null = "[null, null, null]";
+  this->Assert(one_null, one_null, options);
+  this->Assert(three_null, three_null, options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    auto values = "[0, 86400000, null, 259200000, null, 432000000]";
+    auto expected = "[0, 86400000, null, null, null, null]";
+    this->Assert(values, expected, options);
+  } else {
+    auto values = "[1, 2, null, 4, null, 6]";
+    auto expected = "[1, 3, null, null, null, null]";
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, NoStartDoSkipNoNulls) {
+TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
+  CumulativeGenericOptions options = this->generate_options(0, true);
   auto empty = "[]";
-  auto time_values = "[1, 2, 3, 4, 5, 6]";
-  auto time_expected = "[1, 3, 6, 10, 15, 21]";
-  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-  auto date_expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0), true};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0), true};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0), true};
-
-  this->Assert(date32(), empty, empty, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), empty, empty, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  this->Assert(empty, empty, options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+    auto expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
+    this->Assert(values, expected, options);
+  } else {
+    auto values = "[1, 2, 3, 4, 5, 6]";
+    auto expected = "[1, 3, 6, 10, 15, 21]";
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, NoStartDoSkipHasNulls) {
+TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
+  CumulativeGenericOptions options = this->generate_options(0, true);
   auto one_null = "[null]";
-  auto three_nulls = "[null, null, null]";
-  auto time_values = "[1, 2, null, 4, null, 6]";
-  auto time_expected = "[1, 3, null, 7, null, 13]";
-  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
-  auto date_expected = "[0, 86400000, null, 345600000, null, 777600000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(0), true};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)0), true};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)0), true};
-
-  this->Assert(date32(), one_null, one_null, date_options);
-  this->Assert(date32(), three_nulls, three_nulls, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), one_null, one_null, date_options);
-  this->Assert(date64(), three_nulls, three_nulls, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  auto three_null = "[null, null, null]";
+  this->Assert(one_null, one_null, options);
+  this->Assert(three_null, three_null, options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    auto values = "[0, 86400000, null, 259200000, null, 432000000]";
+    auto expected = "[0, 86400000, null, 345600000, null, 777600000]";
+    this->Assert(values, expected, options);
+  } else {
+    auto values = "[1, 2, null, 4, null, 6]";
+    auto expected = "[1, 3, null, 7, null, 13]";
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, HasStartNoSkipNoNulls) {
+TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
   auto empty = "[]";
-  auto time_values = "[1, 2, 3, 4, 5, 6]";
-  auto time_expected = "[11, 13, 16, 20, 25, 31]";
-  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-  auto date_expected = "[86400000, 172800000, 345600000, 604800000, 950400000, 1382400000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000)};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10)};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10)};
-
-  this->Assert(date32(), empty, empty, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), empty, empty, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    // CumulativeGenericOptions options = this->generate_options(86400000);
+    // auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+    // auto expected = "[86400000, 172800000, 345600000, 604800000, 950400000,
+    // 1382400000]";
+    // this->Assert(empty, empty, options);
+    // this->Assert(values, expected, options);
+  } else {
+    CumulativeGenericOptions options = this->generate_options(10);
+    auto values = "[1, 2, 3, 4, 5, 6]";
+    auto expected = "[11, 13, 16, 20, 25, 31]";
+    this->Assert(empty, empty, options);
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, HasStartNoSkipHasNulls) {
+TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
   auto one_null = "[null]";
-  auto three_nulls = "[null, null, null]";
-  auto time_values = "[1, 2, null, 4, null, 6]";
-  auto time_expected = "[11, 13, null, null, null, null]";
-  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
-  auto date_expected = "[86400000, 172800000, null, null, null, null]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000)};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10)};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10)};
-
-  this->Assert(date32(), one_null, one_null, date_options);
-  this->Assert(date32(), three_nulls, three_nulls, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), one_null, one_null, date_options);
-  this->Assert(date64(), three_nulls, three_nulls, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  auto three_null = "[null, null, null]";
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    // CumulativeGenericOptions options = this->generate_options(86400000);
+    // auto values = "[0, 86400000, null, 259200000, null, 432000000]";
+    // auto expected = "[86400000, 172800000, null, null, null, null]";
+    // this->Assert(one_null, one_null, options);
+    // this->Assert(three_null, three_null, options);
+    // this->Assert(values, expected, options);
+  } else {
+    CumulativeGenericOptions options = this->generate_options(10);
+    auto values = "[1, 2, null, 4, null, 6]";
+    auto expected = "[11, 13, null, null, null, null]";
+    this->Assert(one_null, one_null, options);
+    this->Assert(three_null, three_null, options);
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, HasStartDoSkipNoNulls) {
+TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
   auto empty = "[]";
-  auto time_values = "[1, 2, 3, 4, 5, 6]";
-  auto time_expected = "[11, 13, 16, 20, 25, 31]";
-  auto date_values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-  auto date_expected = "[86400000, 172800000, 345600000, 604800000, 950400000, 1382400000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000), true};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10), true};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10), true};
-
-  this->Assert(date32(), empty, empty, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), empty, empty, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), empty, empty, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    // CumulativeGenericOptions options = this->generate_options(86400000, true);
+    // auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
+    // auto expected = "[86400000, 172800000, 345600000, 604800000, 950400000,
+    // 1382400000]";
+    // this->Assert(empty, empty, options);
+    // this->Assert(values, expected, options);
+  } else {
+    CumulativeGenericOptions options = this->generate_options(10, true);
+    auto values = "[1, 2, 3, 4, 5, 6]";
+    auto expected = "[11, 13, 16, 20, 25, 31]";
+    this->Assert(empty, empty, options);
+    this->Assert(values, expected, options);
+  }
 }
 
-TEST_F(TestCumulativeSumTemporal, HasStartDoSkipHasNulls) {
+TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
   auto one_null = "[null]";
-  auto three_nulls = "[null, null, null]";
-  auto time_values = "[1, 2, null, 4, null, 6]";
-  auto time_expected = "[11, 13, null, 17, null, 23]";
-  auto date_values = "[0, 86400000, null, 256200000, null, 432000000]";
-  auto date_expected = "[86400000, 172800000, null, 429000000, null, 861000000]";
-
-  CumulativeGenericOptions date_options{std::make_shared<DateScalar>(86400000), true};
-  CumulativeGenericOptions time_options{std::make_shared<TimeScalar>((TimeUnit::type)10), true};
-  CumulativeGenericOptions timestamp_options{std::make_shared<TimestampScalar>((TimeUnit::type)10), true};
-
-  this->Assert(date32(), one_null, one_null, date_options);
-  this->Assert(date32(), three_nulls, three_nulls, date_options);
-  this->Assert(date32(), date_values, date_expected, date_options);
-  this->Assert(date64(), one_null, one_null, date_options);
-  this->Assert(date64(), three_nulls, three_nulls, date_options);
-  this->Assert(date64(), date_values, date_expected, date_options);
-
-  this->Assert(time32((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time32((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time32((TimeUnit::type)0), time_values, time_expected, time_options);
-  this->Assert(time64((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(time64((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(time64((TimeUnit::type)0), time_values, time_expected, time_options);
-
-  this->Assert(timestamp((TimeUnit::type)0), one_null, one_null, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), three_nulls, three_nulls, time_options);
-  this->Assert(timestamp((TimeUnit::type)0), time_values, time_expected, time_options);
+  auto three_null = "[null, null, null]";
+
+  if (this->type_singleton()->id() == Type::DATE64) {
+    // CumulativeGenericOptions options = this->generate_options(86400000, true);
+    // auto values = "[0, 86400000, null, 259200000, null, 432000000]";
+    // auto expected = "[86400000, 172800000, null, 432000000, null, 864000000]";
+    // this->Assert(one_null, one_null, options);
+    // this->Assert(three_null, three_null, options);
+    // this->Assert(values, expected, options);
+  } else {
+    CumulativeGenericOptions options = this->generate_options(10, true);
+    auto values = "[1, 2, null, 4, null, 6]";
+    auto expected = "[11, 13, null, 17, null, 23]";
+    this->Assert(one_null, one_null, options);
+    this->Assert(three_null, three_null, options);
+    this->Assert(values, expected, options);
+  }
 }
 
 }  // namespace compute

From cfe8fc4c94bb8c0fc5ac14d9ec5df3165f7f837d Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 1 Apr 2022 16:20:06 -0400
Subject: [PATCH 34/67] Added "Checked" version for overflow detection

---
 cpp/src/arrow/compute/api_vector.cc           |  19 +--
 cpp/src/arrow/compute/api_vector.h            |   5 +-
 .../compute/kernels/vector_cumulative_ops.cc  |  43 +++--
 .../kernels/vector_cumulative_ops_test.cc     | 158 ++++++------------
 4 files changed, 90 insertions(+), 135 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 6717670e9b5..27b1a5e520a 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -180,20 +180,12 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-// CumulativeGenericOptions::CumulativeGenericOptions(uint64_t start, bool skip_nulls)
-//     : CumulativeGenericOptions(std::make_shared<UInt64Scalar>(start), skip_nulls) {}
-//
-// CumulativeGenericOptions::CumulativeGenericOptions(int64_t start, bool skip_nulls)
-//     : CumulativeGenericOptions(std::make_shared<Int64Scalar>(start), skip_nulls) {}
-//
-// CumulativeGenericOptions::CumulativeGenericOptions(double start, bool skip_nulls)
-//     : CumulativeGenericOptions(std::make_shared<DoubleScalar>(start), skip_nulls) {}
-
 CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start,
-                                                   bool skip_nulls)
+                                                   bool skip_nulls, bool check_overflow)
     : FunctionOptions(internal::kCumulativeGenericOptionsType),
       start(std::move(start)),
-      skip_nulls(skip_nulls) {}
+      skip_nulls(skip_nulls),
+      check_overflow(check_overflow) {}
 constexpr char CumulativeGenericOptions::kTypeName[];
 
 namespace internal {
@@ -348,9 +340,8 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
 
 Result<Datum> CumulativeSum(const Datum& values, const CumulativeGenericOptions& options,
                             ExecContext* ctx) {
-  ARROW_ASSIGN_OR_RAISE(Datum out,
-                        CallFunction("cumulative_sum", {Datum(values)}, &options, ctx));
-  return out.make_array();
+  auto func_name = (options.check_overflow) ? "cumulative_sum_checked" : "cumulative_sum";
+  return CallFunction(func_name, {Datum(values)}, &options, ctx);
 }
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index e426ad19b19..86e39ac818d 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -193,7 +193,7 @@ class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
  public:
   explicit CumulativeGenericOptions(
       std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
-      bool skip_nulls = false);
+      bool skip_nulls = false, bool checked_overflow = false);
   static constexpr char const kTypeName[] = "CumulativeGenericOptions";
   static CumulativeGenericOptions Defaults() { return CumulativeGenericOptions(); }
 
@@ -202,6 +202,9 @@ class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
 
   /// When false, propagates the first null/NaN encountered
   bool skip_nulls = false;
+
+  /// When true, returns an Invalid Status when overflow is detected
+  bool check_overflow = false;
 };
 
 /// @}
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index a4e9ab15952..d914fff4e10 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -100,32 +100,51 @@ struct CumulativeGeneric {
 const FunctionDoc cumulative_sum_doc{
     "Compute the cumulative sum over an array of numbers",
     ("`values` must be an array of numeric type values.\n"
-     "Return an array which is the cumulative sum computed over `values.`"),
+     "Return an array which is the cumulative sum computed over `values`.\n"
+     "Results will wrap around on integer overflow.\n"
+     "Use function \"cumulative_sum_checked\" if you want overflow\n"
+     "to return an error."),
     {"values"},
     "CumulativeGenericOptions"};
 
-void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-  auto options = CumulativeGenericOptions::Defaults();
-  auto cumulative_sum = std::make_shared<VectorFunction>("cumulative_sum", Arity::Unary(),
-                                                         &cumulative_sum_doc, &options);
+const FunctionDoc cumulative_sum_checked_doc{
+    "Compute the cumulative sum over an array of numbers",
+    ("`values` must be an array of numeric type values.\n"
+     "Return an array which is the cumulative sum computed over `values`.\n"
+     "This function returns an error on overflow. For a variant that\n"
+     "doesn't fail on overflow, use function \"cumulative_sum\"."),
+    {"values"},
+    "CumulativeGenericOptions"};
+
+template <typename Op, typename OptionsType>
+void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string func_name,
+                                  const FunctionDoc* doc) {
+  auto options = OptionsType::Defaults();
+  auto cumulative_func =
+      std::make_shared<VectorFunction>(func_name, Arity::Unary(), doc, &options);
 
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
-  types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
 
-  for (const auto& ty : NumericTypes()) {
+  for (const auto& ty : types) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = false;
     kernel.null_handling = NullHandling::type::INTERSECTION;
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
-    kernel.exec =
-        ArithmeticExecFromOp<CumulativeGeneric, Add, CumulativeGenericOptions>(ty);
-    kernel.init = OptionsWrapper<CumulativeGenericOptions>::Init;
-    DCHECK_OK(cumulative_sum->AddKernel(std::move(kernel)));
+    kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Op, OptionsType>(ty);
+    kernel.init = OptionsWrapper<OptionsType>::Init;
+    DCHECK_OK(cumulative_func->AddKernel(std::move(kernel)));
   }
 
-  DCHECK_OK(registry->AddFunction(std::move(cumulative_sum)));
+  DCHECK_OK(registry->AddFunction(std::move(cumulative_func)));
+}
+
+void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
+  MakeVectorCumulativeFunction<Add, CumulativeGenericOptions>(registry, "cumulative_sum",
+                                                              &cumulative_sum_doc);
+  MakeVectorCumulativeFunction<AddChecked, CumulativeGenericOptions>(
+      registry, "cumulative_sum_checked", &cumulative_sum_checked_doc);
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 2b7b05f1f51..c74b28e52b1 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -48,9 +48,6 @@ using CumulativeTypes =
     testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int8Type, Int16Type,
                    Int32Type, Int64Type, FloatType, DoubleType>;
 
-//  Date32Type, Date64Type, Time32Type, Time64Type,
-//  TimestampType, DurationType, MonthIntervalType>;
-
 template <typename T>
 class TestCumulativeOp : public ::testing::Test {
  public:
@@ -65,14 +62,27 @@ class TestCumulativeOp : public ::testing::Test {
     return ArrayFromJSON(type_singleton(), value);
   }
 
-  void Assert(const std::string func, const std::shared_ptr<Array>& input,
-              const std::shared_ptr<Array>& expected,
-              const CumulativeGenericOptions& options) {
+  template <typename V = T>
+  enable_if_t<!is_floating_type<V>::value, void> Assert(
+      const std::string func, const std::shared_ptr<Array>& input,
+      const std::shared_ptr<Array>& expected, const CumulativeGenericOptions& options) {
     ASSERT_OK_AND_ASSIGN(auto result,
                          CallFunction(func, {Datum(input)}, &options, nullptr));
 
     AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
   }
+
+  template <typename V = T>
+  enable_if_floating_point<V> Assert(const std::string func,
+                                     const std::shared_ptr<Array>& input,
+                                     const std::shared_ptr<Array>& expected,
+                                     const CumulativeGenericOptions& options) {
+    ASSERT_OK_AND_ASSIGN(auto result,
+                         CallFunction(func, {Datum(input)}, &options, nullptr));
+
+    AssertArraysApproxEqual(*expected, *result.make_array(), false,
+                            EqualOptions::Defaults());
+  }
 };
 
 template <typename T>
@@ -119,149 +129,81 @@ TYPED_TEST_SUITE(TestCumulativeSum, CumulativeTypes);
 TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
   CumulativeGenericOptions options = this->generate_options();
   auto empty = "[]";
+  auto values = "[1, 2, 3, 4, 5, 6]";
+  auto expected = "[1, 3, 6, 10, 15, 21]";
   this->Assert(empty, empty, options);
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-    auto expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
-    this->Assert(values, expected, options);
-  } else {
-    auto values = "[1, 2, 3, 4, 5, 6]";
-    auto expected = "[1, 3, 6, 10, 15, 21]";
-    this->Assert(values, expected, options);
-  }
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
   CumulativeGenericOptions options = this->generate_options();
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
+  auto values = "[1, 2, null, 4, null, 6]";
+  auto expected = "[1, 3, null, null, null, null]";
   this->Assert(one_null, one_null, options);
   this->Assert(three_null, three_null, options);
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    auto values = "[0, 86400000, null, 259200000, null, 432000000]";
-    auto expected = "[0, 86400000, null, null, null, null]";
-    this->Assert(values, expected, options);
-  } else {
-    auto values = "[1, 2, null, 4, null, 6]";
-    auto expected = "[1, 3, null, null, null, null]";
-    this->Assert(values, expected, options);
-  }
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
   CumulativeGenericOptions options = this->generate_options(0, true);
   auto empty = "[]";
+  auto values = "[1, 2, 3, 4, 5, 6]";
+  auto expected = "[1, 3, 6, 10, 15, 21]";
   this->Assert(empty, empty, options);
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-    auto expected = "[0, 86400000, 259200000, 518400000, 864000000, 1296000000]";
-    this->Assert(values, expected, options);
-  } else {
-    auto values = "[1, 2, 3, 4, 5, 6]";
-    auto expected = "[1, 3, 6, 10, 15, 21]";
-    this->Assert(values, expected, options);
-  }
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
   CumulativeGenericOptions options = this->generate_options(0, true);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
+  auto values = "[1, 2, null, 4, null, 6]";
+  auto expected = "[1, 3, null, 7, null, 13]";
   this->Assert(one_null, one_null, options);
   this->Assert(three_null, three_null, options);
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    auto values = "[0, 86400000, null, 259200000, null, 432000000]";
-    auto expected = "[0, 86400000, null, 345600000, null, 777600000]";
-    this->Assert(values, expected, options);
-  } else {
-    auto values = "[1, 2, null, 4, null, 6]";
-    auto expected = "[1, 3, null, 7, null, 13]";
-    this->Assert(values, expected, options);
-  }
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
+  CumulativeGenericOptions options = this->generate_options(10);
   auto empty = "[]";
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    // CumulativeGenericOptions options = this->generate_options(86400000);
-    // auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-    // auto expected = "[86400000, 172800000, 345600000, 604800000, 950400000,
-    // 1382400000]";
-    // this->Assert(empty, empty, options);
-    // this->Assert(values, expected, options);
-  } else {
-    CumulativeGenericOptions options = this->generate_options(10);
-    auto values = "[1, 2, 3, 4, 5, 6]";
-    auto expected = "[11, 13, 16, 20, 25, 31]";
-    this->Assert(empty, empty, options);
-    this->Assert(values, expected, options);
-  }
+  auto values = "[1, 2, 3, 4, 5, 6]";
+  auto expected = "[11, 13, 16, 20, 25, 31]";
+  this->Assert(empty, empty, options);
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
+  CumulativeGenericOptions options = this->generate_options(10);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    // CumulativeGenericOptions options = this->generate_options(86400000);
-    // auto values = "[0, 86400000, null, 259200000, null, 432000000]";
-    // auto expected = "[86400000, 172800000, null, null, null, null]";
-    // this->Assert(one_null, one_null, options);
-    // this->Assert(three_null, three_null, options);
-    // this->Assert(values, expected, options);
-  } else {
-    CumulativeGenericOptions options = this->generate_options(10);
-    auto values = "[1, 2, null, 4, null, 6]";
-    auto expected = "[11, 13, null, null, null, null]";
-    this->Assert(one_null, one_null, options);
-    this->Assert(three_null, three_null, options);
-    this->Assert(values, expected, options);
-  }
+  auto values = "[1, 2, null, 4, null, 6]";
+  auto expected = "[11, 13, null, null, null, null]";
+  this->Assert(one_null, one_null, options);
+  this->Assert(three_null, three_null, options);
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
+  CumulativeGenericOptions options = this->generate_options(10, true);
   auto empty = "[]";
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    // CumulativeGenericOptions options = this->generate_options(86400000, true);
-    // auto values = "[0, 86400000, 172800000, 259200000, 345600000, 432000000]";
-    // auto expected = "[86400000, 172800000, 345600000, 604800000, 950400000,
-    // 1382400000]";
-    // this->Assert(empty, empty, options);
-    // this->Assert(values, expected, options);
-  } else {
-    CumulativeGenericOptions options = this->generate_options(10, true);
-    auto values = "[1, 2, 3, 4, 5, 6]";
-    auto expected = "[11, 13, 16, 20, 25, 31]";
-    this->Assert(empty, empty, options);
-    this->Assert(values, expected, options);
-  }
+  auto values = "[1, 2, 3, 4, 5, 6]";
+  auto expected = "[11, 13, 16, 20, 25, 31]";
+  this->Assert(empty, empty, options);
+  this->Assert(values, expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
+  CumulativeGenericOptions options = this->generate_options(10, true);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
-
-  if (this->type_singleton()->id() == Type::DATE64) {
-    // CumulativeGenericOptions options = this->generate_options(86400000, true);
-    // auto values = "[0, 86400000, null, 259200000, null, 432000000]";
-    // auto expected = "[86400000, 172800000, null, 432000000, null, 864000000]";
-    // this->Assert(one_null, one_null, options);
-    // this->Assert(three_null, three_null, options);
-    // this->Assert(values, expected, options);
-  } else {
-    CumulativeGenericOptions options = this->generate_options(10, true);
-    auto values = "[1, 2, null, 4, null, 6]";
-    auto expected = "[11, 13, null, 17, null, 23]";
-    this->Assert(one_null, one_null, options);
-    this->Assert(three_null, three_null, options);
-    this->Assert(values, expected, options);
-  }
+  auto values = "[1, 2, null, 4, null, 6]";
+  auto expected = "[11, 13, null, 17, null, 23]";
+  this->Assert(one_null, one_null, options);
+  this->Assert(three_null, three_null, options);
+  this->Assert(values, expected, options);
 }
 
 }  // namespace compute

From bd9f1b7a68ff710379daa6f874e5f5a65a2ff151 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Fri, 1 Apr 2022 23:48:47 -0400
Subject: [PATCH 35/67] IWYU

---
 .../compute/kernels/vector_cumulative_ops_test.cc | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index c74b28e52b1..7b0b93f0e21 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -15,32 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <algorithm>
 #include <cstdint>
-#include <cstdio>
-#include <functional>
-#include <locale>
 #include <memory>
-#include <stdexcept>
 #include <string>
-#include <utility>
-#include <vector>
 
 #include <gtest/gtest.h>
 
 #include "arrow/array.h"
 #include "arrow/array/builder_decimal.h"
 #include "arrow/buffer.h"
+#include "arrow/compute/api.h"
+#include "arrow/compute/kernels/test_util.h"
+#include "arrow/ipc/json_simple.h"
 #include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
 #include "arrow/type_fwd.h"
 
-#include "arrow/compute/api.h"
-#include "arrow/compute/kernels/test_util.h"
-
-#include "arrow/ipc/json_simple.h"
-
 namespace arrow {
 namespace compute {
 

From 25894782d32cff5faa577e06776d537b727c21df Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 4 Apr 2022 02:31:44 -0400
Subject: [PATCH 36/67] general reorganization/fixes

---
 cpp/src/arrow/compute/api_vector.cc           | 23 +++--
 cpp/src/arrow/compute/api_vector.h            | 24 +++--
 .../compute/kernels/vector_cumulative_ops.cc  | 25 +++--
 .../kernels/vector_cumulative_ops_test.cc     | 99 +++++++++----------
 python/pyarrow/_compute.pyx                   | 21 ++--
 python/pyarrow/compute.py                     |  2 +-
 python/pyarrow/includes/libarrow.pxd          |  7 +-
 python/pyarrow/tests/test_compute.py          |  2 +-
 8 files changed, 103 insertions(+), 100 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 27b1a5e520a..0e6cee8ed28 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -135,10 +135,10 @@ static auto kPartitionNthOptionsType = GetFunctionOptionsType<PartitionNthOption
 static auto kSelectKOptionsType = GetFunctionOptionsType<SelectKOptions>(
     DataMember("k", &SelectKOptions::k),
     DataMember("sort_keys", &SelectKOptions::sort_keys));
-static auto kCumulativeGenericOptionsType =
-    GetFunctionOptionsType<CumulativeGenericOptions>(
-        DataMember("start", &CumulativeGenericOptions::start),
-        DataMember("skip_nulls", &CumulativeGenericOptions::skip_nulls));
+static auto kCumulativeSumOptionsType = GetFunctionOptionsType<CumulativeSumOptions>(
+    DataMember("start", &CumulativeSumOptions::start),
+    DataMember("skip_nulls", &CumulativeSumOptions::skip_nulls),
+    DataMember("check_overflow", &CumulativeSumOptions::check_overflow));
 }  // namespace
 }  // namespace internal
 
@@ -180,13 +180,13 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
-CumulativeGenericOptions::CumulativeGenericOptions(std::shared_ptr<Scalar> start,
-                                                   bool skip_nulls, bool check_overflow)
-    : FunctionOptions(internal::kCumulativeGenericOptionsType),
+CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls,
+                                           bool check_overflow)
+    : FunctionOptions(internal::kCumulativeSumOptionsType),
       start(std::move(start)),
       skip_nulls(skip_nulls),
       check_overflow(check_overflow) {}
-constexpr char CumulativeGenericOptions::kTypeName[];
+constexpr char CumulativeSumOptions::kTypeName[];
 
 namespace internal {
 void RegisterVectorOptions(FunctionRegistry* registry) {
@@ -197,7 +197,7 @@ void RegisterVectorOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kSortOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPartitionNthOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSelectKOptionsType));
-  DCHECK_OK(registry->AddFunctionOptionsType(kCumulativeGenericOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kCumulativeSumOptionsType));
 }
 }  // namespace internal
 
@@ -338,7 +338,10 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
   return out.make_array();
 }
 
-Result<Datum> CumulativeSum(const Datum& values, const CumulativeGenericOptions& options,
+// ----------------------------------------------------------------------
+// Cumulative functions
+
+Result<Datum> CumulativeSum(const Datum& values, const CumulativeSumOptions& options,
                             ExecContext* ctx) {
   auto func_name = (options.check_overflow) ? "cumulative_sum_checked" : "cumulative_sum";
   return CallFunction(func_name, {Datum(values)}, &options, ctx);
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 86e39ac818d..7d94a88501e 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -189,18 +189,22 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 };
 
 /// \brief Options for cumulative sum function
-class ARROW_EXPORT CumulativeGenericOptions : public FunctionOptions {
+class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  explicit CumulativeGenericOptions(
-      std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int8Type>>(0),
-      bool skip_nulls = false, bool checked_overflow = false);
-  static constexpr char const kTypeName[] = "CumulativeGenericOptions";
-  static CumulativeGenericOptions Defaults() { return CumulativeGenericOptions(); }
-
-  /// Optional starting value for sum computation
+  // Default `start` value is of type Int8 to allow type casting and compatibility rules
+  // to use the type of the function values.
+  explicit CumulativeSumOptions(
+      std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int64Type>>(0),
+      bool skip_nulls = false, bool check_overflow = false);
+  static constexpr char const kTypeName[] = "CumulativeSumOptions";
+  static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
+
+  /// Optional starting value for cumulative operation computation
   std::shared_ptr<Scalar> start;
 
-  /// When false, propagates the first null/NaN encountered
+  /// If true, nulls in the input are ignored and produce a corresponding null output.
+  /// When false, the first null/NaN encountered is propagated through the remaining
+  /// output.
   bool skip_nulls = false;
 
   /// When true, returns an Invalid Status when overflow is detected
@@ -544,7 +548,7 @@ Result<Datum> DictionaryEncode(
 ARROW_EXPORT
 Result<Datum> CumulativeSum(
     const Datum& values,
-    const CumulativeGenericOptions& options = CumulativeGenericOptions::Defaults(),
+    const CumulativeSumOptions& options = CumulativeSumOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index d914fff4e10..5e870763cd3 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -105,7 +105,7 @@ const FunctionDoc cumulative_sum_doc{
      "Use function \"cumulative_sum_checked\" if you want overflow\n"
      "to return an error."),
     {"values"},
-    "CumulativeGenericOptions"};
+    "CumulativeSumOptions"};
 
 const FunctionDoc cumulative_sum_checked_doc{
     "Compute the cumulative sum over an array of numbers",
@@ -114,19 +114,16 @@ const FunctionDoc cumulative_sum_checked_doc{
      "This function returns an error on overflow. For a variant that\n"
      "doesn't fail on overflow, use function \"cumulative_sum\"."),
     {"values"},
-    "CumulativeGenericOptions"};
+    "CumulativeSumOptions"};
 
 template <typename Op, typename OptionsType>
 void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string func_name,
                                   const FunctionDoc* doc) {
-  auto options = OptionsType::Defaults();
-  auto cumulative_func =
-      std::make_shared<VectorFunction>(func_name, Arity::Unary(), doc, &options);
+  static const OptionsType kDefaultOptions = OptionsType::Defaults();
+  auto func =
+      std::make_shared<VectorFunction>(func_name, Arity::Unary(), doc, &kDefaultOptions);
 
-  std::vector<std::shared_ptr<DataType>> types;
-  types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
-
-  for (const auto& ty : types) {
+  for (const auto& ty : NumericTypes()) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = false;
     kernel.null_handling = NullHandling::type::INTERSECTION;
@@ -134,16 +131,16 @@ void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
     kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Op, OptionsType>(ty);
     kernel.init = OptionsWrapper<OptionsType>::Init;
-    DCHECK_OK(cumulative_func->AddKernel(std::move(kernel)));
+    DCHECK_OK(func->AddKernel(std::move(kernel)));
   }
 
-  DCHECK_OK(registry->AddFunction(std::move(cumulative_func)));
+  DCHECK_OK(registry->AddFunction(std::move(func)));
 }
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-  MakeVectorCumulativeFunction<Add, CumulativeGenericOptions>(registry, "cumulative_sum",
-                                                              &cumulative_sum_doc);
-  MakeVectorCumulativeFunction<AddChecked, CumulativeGenericOptions>(
+  MakeVectorCumulativeFunction<Add, CumulativeSumOptions>(registry, "cumulative_sum",
+                                                          &cumulative_sum_doc);
+  MakeVectorCumulativeFunction<AddChecked, CumulativeSumOptions>(
       registry, "cumulative_sum_checked", &cumulative_sum_checked_doc);
 }
 
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 7b0b93f0e21..54f14244e43 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -23,23 +23,16 @@
 
 #include "arrow/array.h"
 #include "arrow/array/builder_decimal.h"
-#include "arrow/buffer.h"
-#include "arrow/compute/api.h"
+#include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/test_util.h"
 #include "arrow/ipc/json_simple.h"
-#include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
+#include "arrow/testing/gtest_util.h"
 #include "arrow/testing/util.h"
-#include "arrow/type.h"
-#include "arrow/type_fwd.h"
 
 namespace arrow {
 namespace compute {
 
-using CumulativeTypes =
-    testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int8Type, Int16Type,
-                   Int32Type, Int64Type, FloatType, DoubleType>;
-
-template <typename T>
+template <typename T, typename OptionsType>
 class TestCumulativeOp : public ::testing::Test {
  public:
   using ArrowType = T;
@@ -56,9 +49,8 @@ class TestCumulativeOp : public ::testing::Test {
   template <typename V = T>
   enable_if_t<!is_floating_type<V>::value, void> Assert(
       const std::string func, const std::shared_ptr<Array>& input,
-      const std::shared_ptr<Array>& expected, const CumulativeGenericOptions& options) {
-    ASSERT_OK_AND_ASSIGN(auto result,
-                         CallFunction(func, {Datum(input)}, &options, nullptr));
+      const std::shared_ptr<Array>& expected, const OptionsType& options) {
+    ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
 
     AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
   }
@@ -67,9 +59,8 @@ class TestCumulativeOp : public ::testing::Test {
   enable_if_floating_point<V> Assert(const std::string func,
                                      const std::shared_ptr<Array>& input,
                                      const std::shared_ptr<Array>& expected,
-                                     const CumulativeGenericOptions& options) {
-    ASSERT_OK_AND_ASSIGN(auto result,
-                         CallFunction(func, {Datum(input)}, &options, nullptr));
+                                     const OptionsType& options) {
+    ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
 
     AssertArraysApproxEqual(*expected, *result.make_array(), false,
                             EqualOptions::Defaults());
@@ -77,48 +68,50 @@ class TestCumulativeOp : public ::testing::Test {
 };
 
 template <typename T>
-class TestCumulativeSum : public TestCumulativeOp<T> {
+class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
  public:
-  using ArrowType = typename TestCumulativeOp<T>::ArrowType;
-  using ArrowScalar = typename TestCumulativeOp<T>::ArrowScalar;
-  using CType = typename TestCumulativeOp<T>::CType;
+  using OptionsType = CumulativeSumOptions;
+  using ArrowType = typename TestCumulativeOp<T, OptionsType>::ArrowType;
+  using ArrowScalar = typename TestCumulativeOp<T, OptionsType>::ArrowScalar;
+  using CType = typename TestCumulativeOp<T, OptionsType>::CType;
 
  protected:
-  template <typename U = T>
-  enable_if_parameter_free<U, CumulativeGenericOptions> generate_options(
-      CType start = 0, bool skip_nulls = false) {
-    return CumulativeGenericOptions(std::make_shared<ArrowScalar>(start), skip_nulls);
+  OptionsType generate_options(CType start = 0, bool skip_nulls = false,
+                               bool check_overflow = false) {
+    return OptionsType(std::make_shared<ArrowScalar>(start), skip_nulls, check_overflow);
   }
 
-  template <typename U = T>
-  enable_if_t<is_time_type<U>::value || is_timestamp_type<U>::value,
-              CumulativeGenericOptions>
-  generate_options(CType start = 0, bool skip_nulls = false) {
-    TimeUnit::type unit;
-    switch (ArrowType::type_id) {
-      case Type::TIME64:
-        unit = TimeUnit::NANO;
-        break;
-      default:
-        unit = TimeUnit::SECOND;
-        break;
-    }
-    return CumulativeGenericOptions(std::make_shared<ArrowScalar>(start, unit),
-                                    skip_nulls);
-  }
+  // enable_if_t<is_time_type<T>::value || is_timestamp_type<T>::value,
+  //             OptionsType>
+  // generate_time_options(CType start = 0, bool skip_nulls = false, bool check_overflow =
+  // false) {
+  //   TimeUnit::type unit;
+  //   switch (ArrowType::type_id) {
+  //     case Type::TIME64:
+  //       unit = TimeUnit::NANO;
+  //       break;
+  //     default:
+  //       unit = TimeUnit::SECOND;
+  //       break;
+  //   }
+  //   return OptionsType(std::make_shared<ArrowScalar>(start, unit),
+  //                               skip_nulls, check_overflow);
+  // }
 
   void Assert(const std::string& values, const std::string& expected,
-              const CumulativeGenericOptions& options) {
-    auto values_arr = TestCumulativeOp<T>::array(values);
-    auto expected_arr = TestCumulativeOp<T>::array(expected);
-    TestCumulativeOp<T>::Assert("cumulative_sum", values_arr, expected_arr, options);
+              const OptionsType& options) {
+    auto values_arr = TestCumulativeOp<T, OptionsType>::array(values);
+    auto expected_arr = TestCumulativeOp<T, OptionsType>::array(expected);
+    auto func_name = options.check_overflow ? "cumulative_sum_checked" : "cumulative_sum";
+    TestCumulativeOp<T, OptionsType>::Assert(func_name, values_arr, expected_arr,
+                                             options);
   }
 };
 
-TYPED_TEST_SUITE(TestCumulativeSum, CumulativeTypes);
+TYPED_TEST_SUITE(TestCumulativeSum, NumericArrowTypes);
 
 TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
-  CumulativeGenericOptions options = this->generate_options();
+  CumulativeSumOptions options = this->generate_options();
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[1, 3, 6, 10, 15, 21]";
@@ -127,7 +120,7 @@ TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
-  CumulativeGenericOptions options = this->generate_options();
+  CumulativeSumOptions options = this->generate_options();
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
@@ -138,7 +131,7 @@ TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
-  CumulativeGenericOptions options = this->generate_options(0, true);
+  CumulativeSumOptions options = this->generate_options(0, true);
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[1, 3, 6, 10, 15, 21]";
@@ -147,7 +140,7 @@ TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
-  CumulativeGenericOptions options = this->generate_options(0, true);
+  CumulativeSumOptions options = this->generate_options(0, true);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
@@ -158,7 +151,7 @@ TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
-  CumulativeGenericOptions options = this->generate_options(10);
+  CumulativeSumOptions options = this->generate_options(10);
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[11, 13, 16, 20, 25, 31]";
@@ -167,7 +160,7 @@ TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
-  CumulativeGenericOptions options = this->generate_options(10);
+  CumulativeSumOptions options = this->generate_options(10);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
@@ -178,7 +171,7 @@ TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
-  CumulativeGenericOptions options = this->generate_options(10, true);
+  CumulativeSumOptions options = this->generate_options(10, true);
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[11, 13, 16, 20, 25, 31]";
@@ -187,7 +180,7 @@ TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
-  CumulativeGenericOptions options = this->generate_options(10, true);
+  CumulativeSumOptions options = this->generate_options(10, true);
   auto one_null = "[null]";
   auto three_null = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index fedace2f563..244e6392b14 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1736,21 +1736,28 @@ class PartitionNthOptions(_PartitionNthOptions):
         self._set_options(pivot, null_placement)
 
 
-cdef class _CumulativeGenericOptions(FunctionOptions):
+cdef class _CumulativeSumOptions(FunctionOptions):
     def _set_options(self, start, skip_nulls):
-        self.wrapped.reset(new CCumulativeGenericOptions(
-            pyarrow_unwrap_scalar(start), skip_nulls))
+        if not isinstance(start, Scalar):
+            # Is it a Python scalar?
+            try:
+                start = lib.scalar(start)
+            except Exception:
+                raise TypeError(f"Got unexpected argument type {type(start)} "
+                                "for cumulative function")
+
+        self.wrapped.reset(new CCumulativeSumOptions((<Scalar> start).unwrap(), skip_nulls))
 
 
-class CumulativeGenericOptions(_CumulativeGenericOptions):
+class CumulativeSumOptions(_CumulativeSumOptions):
     """
     Options for `cumulative_sum` function.
 
     Parameters
     ----------
-    start : Scalar
-        Optional starting value for sum computation
-    skip_nulls : bool
+    start : Scalar (optional, default 0)
+        Starting value for sum computation
+    skip_nulls : bool (optional, default False)
         When false, propagates the first null/NaN encountered
     """
 
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 2091de4b368..37bf90548bc 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -33,7 +33,7 @@
     AssumeTimezoneOptions,
     CastOptions,
     CountOptions,
-    CumulativeGenericOptions,
+    CumulativeSumOptions,
     DayOfWeekOptions,
     DictionaryEncodeOptions,
     ElementWiseAggregateOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 2a3314fa395..33c46e56b70 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2243,10 +2243,9 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         int64_t pivot
         CNullPlacement null_placement
 
-    cdef cppclass CCumulativeGenericOptions \
-            "arrow::compute::CumulativeGenericOptions"(CFunctionOptions):
-        CCumulativeGenericOptions(int64_t start)
-        CCumulativeGenericOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
+    cdef cppclass CCumulativeSumOptions \
+            "arrow::compute::CumulativeSumOptions"(CFunctionOptions):
+        CCumulativeSumOptions(shared_ptr[CScalar] start, c_bool skip_nulls)
         shared_ptr[CScalar] start
         c_bool skip_nulls
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index e98591d5248..14ca2355484 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -147,7 +147,7 @@ def test_option_class_equality():
         pc.NullOptions(),
         pc.PadOptions(5),
         pc.PartitionNthOptions(1, null_placement="at_start"),
-        pc.CumulativeGenericOptions(start=0, skip_nulls=False),
+        pc.CumulativeSumOptions(start=0, skip_nulls=False),
         pc.QuantileOptions(),
         pc.RandomOptions(10),
         pc.ReplaceSliceOptions(0, 1, "a"),

From 55ae02a84ef9b7d87ffe2810f7450cf9f1ba96e3 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 4 Apr 2022 05:22:57 -0400
Subject: [PATCH 37/67] cast start option

---
 .../arrow/compute/kernels/codegen_internal.h  | 22 +++++++++----------
 .../compute/kernels/vector_cumulative_ops.cc  | 19 ++++++++++------
 2 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 333f4835aa6..60481ba64cd 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -1134,31 +1134,31 @@ ArrayKernelExec GeneratePhysicalInteger(detail::GetTypeId get_id) {
   }
 }
 
-template <template <typename...> class KernelGenerator, typename Op, typename... Args>
+template <template <typename...> class KernelGenerator, typename... Args>
 ArrayKernelExec ArithmeticExecFromOp(detail::GetTypeId get_id) {
   switch (get_id.id) {
     case Type::INT8:
-      return KernelGenerator<Int8Type, Int8Type, Op, Args...>::Exec;
+      return KernelGenerator<Int8Type, Int8Type, Args...>::Exec;
     case Type::UINT8:
-      return KernelGenerator<UInt8Type, UInt8Type, Op, Args...>::Exec;
+      return KernelGenerator<UInt8Type, UInt8Type, Args...>::Exec;
     case Type::INT16:
-      return KernelGenerator<Int16Type, Int16Type, Op, Args...>::Exec;
+      return KernelGenerator<Int16Type, Int16Type, Args...>::Exec;
     case Type::UINT16:
-      return KernelGenerator<UInt16Type, UInt16Type, Op, Args...>::Exec;
+      return KernelGenerator<UInt16Type, UInt16Type, Args...>::Exec;
     case Type::INT32:
-      return KernelGenerator<Int32Type, Int32Type, Op, Args...>::Exec;
+      return KernelGenerator<Int32Type, Int32Type, Args...>::Exec;
     case Type::UINT32:
-      return KernelGenerator<UInt32Type, UInt32Type, Op, Args...>::Exec;
+      return KernelGenerator<UInt32Type, UInt32Type, Args...>::Exec;
     case Type::DURATION:
     case Type::INT64:
     case Type::TIMESTAMP:
-      return KernelGenerator<Int64Type, Int64Type, Op, Args...>::Exec;
+      return KernelGenerator<Int64Type, Int64Type, Args...>::Exec;
     case Type::UINT64:
-      return KernelGenerator<UInt64Type, UInt64Type, Op, Args...>::Exec;
+      return KernelGenerator<UInt64Type, UInt64Type, Args...>::Exec;
     case Type::FLOAT:
-      return KernelGenerator<FloatType, FloatType, Op, Args...>::Exec;
+      return KernelGenerator<FloatType, FloatType, Args...>::Exec;
     case Type::DOUBLE:
-      return KernelGenerator<DoubleType, DoubleType, Op, Args...>::Exec;
+      return KernelGenerator<DoubleType, DoubleType, Args...>::Exec;
     default:
       DCHECK(false);
       return ExecFail;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 5e870763cd3..0346ad2a866 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -18,6 +18,7 @@
 #include "arrow/array/array_base.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
+#include "arrow/compute/cast.h"
 #include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common.h"
@@ -36,8 +37,12 @@ struct CumulativeGeneric {
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = OptionsWrapper<OptionsType>::Get(ctx);
-    auto start = UnboxScalar<ArgType>::Unbox(*options.start);
-    bool skip_nulls = options.skip_nulls;
+    auto skip_nulls = options.skip_nulls;
+
+    // Cast `start` option to match output type
+    auto out_type = batch.GetDescriptors()[0].type;
+    ARROW_ASSIGN_OR_RAISE(auto cast_value, Cast(Datum(options.start), out_type));
+    auto start = UnboxScalar<OutType>::Unbox(*cast_value.scalar());
 
     switch (batch[0].kind()) {
       case Datum::ARRAY: {
@@ -61,17 +66,17 @@ struct CumulativeGeneric {
 
   static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
                      Datum* out, bool skip_nulls) {
-    Status st = Status::OK();
-    ArrayData* out_arr = out->mutable_array();
+    auto st = Status::OK();
+    auto out_arr = out->mutable_array();
     auto out_data = out_arr->GetMutableValues<OutValue>(1);
 
-    bool encounted_null = false;
+    bool encountered_null = false;
     auto start_null_idx = arg0.offset;
 
     VisitArrayValuesInline<ArgType>(
         arg0,
         [&](ArgValue v) {
-          if (!skip_nulls && encounted_null) {
+          if (!skip_nulls && encountered_null) {
             *out_data++ = OutValue{};
           } else {
             partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
@@ -83,7 +88,7 @@ struct CumulativeGeneric {
         [&]() {
           // null
           *out_data++ = OutValue{};
-          encounted_null = true;
+          encountered_null = true;
         });
 
     if (!skip_nulls) {

From 3d3261cbe2c42f8af6b73ede308f1e89e2015fc2 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 4 Apr 2022 06:20:18 -0400
Subject: [PATCH 38/67] split Call based on skip nulls, minor changes and notes

---
 .../compute/kernels/vector_cumulative_ops.cc  | 70 ++++++++++++-------
 .../kernels/vector_cumulative_ops_test.cc     | 17 -----
 cpp/src/arrow/compute/kernels/vector_sort.cc  |  8 +--
 3 files changed, 46 insertions(+), 49 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 0346ad2a866..4ac06bf45c1 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -30,6 +30,7 @@ namespace arrow {
 namespace compute {
 namespace internal {
 
+// NOTE: Missing description of this class
 template <typename OutType, typename ArgType, typename Op, typename OptionsType>
 struct CumulativeGeneric {
   using OutValue = typename GetOutputType<OutType>::T;
@@ -40,6 +41,8 @@ struct CumulativeGeneric {
     auto skip_nulls = options.skip_nulls;
 
     // Cast `start` option to match output type
+    // NOTE: Is at least one descriptor guaranteed? If not, need to check size
+    // before indexing.
     auto out_type = batch.GetDescriptors()[0].type;
     ARROW_ASSIGN_OR_RAISE(auto cast_value, Cast(Datum(options.start), out_type));
     auto start = UnboxScalar<OutType>::Unbox(*cast_value.scalar());
@@ -64,38 +67,53 @@ struct CumulativeGeneric {
     return Status::OK();
   }
 
-  static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
+  // NOTE: The option parameters are also available in `ctx`, so why passed them
+  // explicitly? For cases where this method gets invoked multiple times (e.g.,
+  // ChunkedArray), unboxing the options adds unnecessary overhead.
+  static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& accumulator,
                      Datum* out, bool skip_nulls) {
     auto st = Status::OK();
     auto out_arr = out->mutable_array();
     auto out_data = out_arr->GetMutableValues<OutValue>(1);
 
-    bool encountered_null = false;
-    auto start_null_idx = arg0.offset;
-
-    VisitArrayValuesInline<ArgType>(
-        arg0,
-        [&](ArgValue v) {
-          if (!skip_nulls && encountered_null) {
+    if (skip_nulls) {
+      VisitArrayValuesInline<ArgType>(
+          arg0,
+          [&](ArgValue v) {
+            // NOTE: If the Status `st` errors, would it be visible immediately or
+            // shadowed by subsequent successful operations?
+            accumulator =
+                Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v, accumulator, &st);
+            *out_data++ = accumulator;
+          },
+          [&]() { *out_data++ = OutValue{}; });
+    } else {
+      bool encountered_null = false;
+      auto start_null_idx = arg0.offset;
+
+      VisitArrayValuesInline<ArgType>(
+          arg0,
+          [&](ArgValue v) {
+            if (encountered_null) {
+              *out_data++ = OutValue{};
+            } else {
+              accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
+                  ctx, v, accumulator, &st);
+              *out_data++ = accumulator;
+              ++start_null_idx;
+            }
+          },
+          [&]() {
             *out_data++ = OutValue{};
-          } else {
-            partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
-                ctx, v, partial_scan, &st);
-            *out_data++ = partial_scan;
-            ++start_null_idx;
-          }
-        },
-        [&]() {
-          // null
-          *out_data++ = OutValue{};
-          encountered_null = true;
-        });
-
-    if (!skip_nulls) {
-      auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
-      auto null_length = arg0.length - (start_null_idx - arg0.offset);
-      out_arr->SetNullCount(null_length);
-      arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
+            encountered_null = true;
+          });
+
+      if (!skip_nulls) {
+        auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
+        auto null_length = arg0.length - (start_null_idx - arg0.offset);
+        out_arr->SetNullCount(null_length);
+        arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
+      }
     }
 
     return st;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 54f14244e43..810030c03d1 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -81,23 +81,6 @@ class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
     return OptionsType(std::make_shared<ArrowScalar>(start), skip_nulls, check_overflow);
   }
 
-  // enable_if_t<is_time_type<T>::value || is_timestamp_type<T>::value,
-  //             OptionsType>
-  // generate_time_options(CType start = 0, bool skip_nulls = false, bool check_overflow =
-  // false) {
-  //   TimeUnit::type unit;
-  //   switch (ArrowType::type_id) {
-  //     case Type::TIME64:
-  //       unit = TimeUnit::NANO;
-  //       break;
-  //     default:
-  //       unit = TimeUnit::SECOND;
-  //       break;
-  //   }
-  //   return OptionsType(std::make_shared<ArrowScalar>(start, unit),
-  //                               skip_nulls, check_overflow);
-  // }
-
   void Assert(const std::string& values, const std::string& expected,
               const OptionsType& options) {
     auto values_arr = TestCumulativeOp<T, OptionsType>::array(values);
diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 1f62ce5b42a..196aedcc713 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -1854,18 +1854,14 @@ class SelectKUnstableMetaFunction : public MetaFunction {
       return Status::Invalid("select_k_unstable requires a non-empty `sort_keys`");
     }
     switch (args[0].kind()) {
-      case Datum::ARRAY: {
+      case Datum::ARRAY:
         return SelectKth(*args[0].make_array(), select_k_options, ctx);
-      } break;
-      case Datum::CHUNKED_ARRAY: {
+      case Datum::CHUNKED_ARRAY:
         return SelectKth(*args[0].chunked_array(), select_k_options, ctx);
-      } break;
       case Datum::RECORD_BATCH:
         return SelectKth(*args[0].record_batch(), select_k_options, ctx);
-        break;
       case Datum::TABLE:
         return SelectKth(*args[0].table(), select_k_options, ctx);
-        break;
       default:
         break;
     }

From bd265d2d4b2d7c4cd5dd43ec566ff7a7c83fb113 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 4 Apr 2022 11:55:42 -0400
Subject: [PATCH 39/67] update docs with cumulative function/options

---
 docs/source/python/api/compute.rst | 17 ++++++++++++++++-
 python/pyarrow/_compute.pyx        |  3 +--
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index 664a3f76633..d85344740ff 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -45,6 +45,21 @@ Aggregations
    tdigest
    variance
 
+Cumulative Functions
+--------------------
+
+Cumulative functions are vector functions that perform a running total on its
+input and outputs an array containing the corresponding intermediate running values.
+By default these functions do not detect overflow. Most functions are also
+available in an overflow-checking variant, suffixed ``_checked``, which
+throws an ``ArrowInvalid`` exception when overflow is detected.
+
+.. autosummary::
+   :toctree: ../generated/
+
+   cumulative_sum
+   cumulative_sum_checked
+
 Arithmetic Functions
 --------------------
 
@@ -502,7 +517,7 @@ Compute Options
    CastOptions
    CountOptions
    CountOptions
-   CumulativeGenericOptions
+   CumulativeSumOptions
    DayOfWeekOptions
    DictionaryEncodeOptions
    ElementWiseAggregateOptions
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 244e6392b14..4b0ac26e57e 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1743,8 +1743,7 @@ cdef class _CumulativeSumOptions(FunctionOptions):
             try:
                 start = lib.scalar(start)
             except Exception:
-                raise TypeError(f"Got unexpected argument type {type(start)} "
-                                "for cumulative function")
+                _raise_invalid_function_option(start, "`start` type for CumulativeSumOptions", TypeError)
 
         self.wrapped.reset(new CCumulativeSumOptions((<Scalar> start).unwrap(), skip_nulls))
 

From 099711331d5c336a3b03ccc8277cbf787c7fc2c2 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Mon, 4 Apr 2022 14:36:00 -0400
Subject: [PATCH 40/67] Adding chunked arrays to tests

---
 .../kernels/vector_cumulative_ops_test.cc     | 39 ++++++++++++++++++-
 1 file changed, 37 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index c74b28e52b1..b1db121a5ab 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -58,8 +58,12 @@ class TestCumulativeOp : public ::testing::Test {
  protected:
   std::shared_ptr<DataType> type_singleton() { return default_type_instance<T>(); }
 
-  std::shared_ptr<Array> array(const std::string& value) {
-    return ArrayFromJSON(type_singleton(), value);
+  std::shared_ptr<Array> array(const std::string& values) {
+    return ArrayFromJSON(type_singleton(), values);
+  }
+
+  std::shared_ptr<ChunkedArray> chunked_array(const std::vector<std::string>& values) {
+    return ChunkedArrayFromJSON(type_singleton(), values);
   }
 
   template <typename V = T>
@@ -72,6 +76,16 @@ class TestCumulativeOp : public ::testing::Test {
     AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
   }
 
+  template <typename V = T>
+  enable_if_t<!is_floating_type<V>::value, void> Assert(
+      const std::string func, const std::shared_ptr<ChunkedArray>& input,
+      const std::shared_ptr<ChunkedArray>& expected, const CumulativeGenericOptions& options) {
+    ASSERT_OK_AND_ASSIGN(auto result,
+                         CallFunction(func, {Datum(input)}, &options, nullptr));
+
+    AssertChunkedEqual(*expected, result);
+  }
+
   template <typename V = T>
   enable_if_floating_point<V> Assert(const std::string func,
                                      const std::shared_ptr<Array>& input,
@@ -83,6 +97,17 @@ class TestCumulativeOp : public ::testing::Test {
     AssertArraysApproxEqual(*expected, *result.make_array(), false,
                             EqualOptions::Defaults());
   }
+
+  template <typename V = T>
+  enable_if_floating_point<V> Assert(const std::string func,
+                                     const std::shared_ptr<ChunkedArray>& input,
+                                     const std::shared_ptr<ChunkedArray>& expected,
+                                     const CumulativeGenericOptions& options) {
+    ASSERT_OK_AND_ASSIGN(auto result,
+                         CallFunction(func, {Datum(input)}, &options, nullptr));
+
+    AssertChunkedApproxEquivalent(*expected, *result.chunks(), EqualOptions::Defaults());
+  }
 };
 
 template <typename T>
@@ -122,6 +147,14 @@ class TestCumulativeSum : public TestCumulativeOp<T> {
     auto expected_arr = TestCumulativeOp<T>::array(expected);
     TestCumulativeOp<T>::Assert("cumulative_sum", values_arr, expected_arr, options);
   }
+
+  void Assert(const std::vector<std::string>& values,
+              const std::vector<std::string>& expected,
+              const CumulativeGenericOptions& options) {
+    auto values_arr = TestCumulativeOp<T>::chunked_array(values);
+    auto expected_arr = TestCumulativeOp<T>::chunked_array(expected);
+    TestCumulativeOp<T>::Assert("cumulative_sum", values_arr, expected_arr, options);
+  }
 };
 
 TYPED_TEST_SUITE(TestCumulativeSum, CumulativeTypes);
@@ -131,6 +164,8 @@ TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[1, 3, 6, 10, 15, 21]";
+  auto chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
+  auto chunked_expected = {"[1, 3, 6]", "[10, 15, 21]"};
   this->Assert(empty, empty, options);
   this->Assert(values, expected, options);
 }

From eaf5f3ead5d27ab2a65112b84a657a9fd4894aff Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 5 Apr 2022 20:05:51 -0400
Subject: [PATCH 41/67] Wrote tests for chunked arrays and fixed some bugs when
 computing their output

---
 cpp/src/arrow/compute/api_vector.cc           |  6 --
 .../compute/kernels/vector_cumulative_ops.cc  | 49 ++++++++-----
 .../kernels/vector_cumulative_ops_test.cc     | 73 ++++++++++++++-----
 python/pyarrow/_compute.pyx                   |  3 +-
 4 files changed, 86 insertions(+), 45 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index cca63d0bfbd..0e6cee8ed28 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -338,12 +338,6 @@ Result<std::shared_ptr<Array>> DropNull(const Array& values, ExecContext* ctx) {
   return out.make_array();
 }
 
-Result<Datum> CumulativeSum(const Datum& values, const CumulativeGenericOptions& options,
-                            ExecContext* ctx) {
-  auto func_name = (options.check_overflow) ? "cumulative_sum_checked" : "cumulative_sum";
-  return CallFunction(func_name, {Datum(values)}, &options, ctx);
-}
-
 // ----------------------------------------------------------------------
 // Cumulative functions
 
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index a25eaf3761b..d0e847ae61a 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -47,58 +47,69 @@ struct CumulativeGeneric {
     ARROW_ASSIGN_OR_RAISE(auto cast_value, Cast(Datum(options.start), out_type));
     auto start = UnboxScalar<OutType>::Unbox(*cast_value.scalar());
 
+    int64_t base_output_offset = 0;
+    bool encounted_null = false;
+    ArrayData* out_arr = out->mutable_array();
+
     switch (batch[0].kind()) {
       case Datum::ARRAY: {
-        return Call(ctx, *batch[0].array(), start, out, skip_nulls);
+        auto st = Call(ctx, base_output_offset, *batch[0].array(), out_arr, start,
+                       skip_nulls, encounted_null);
+        out_arr->SetNullCount(arrow::kUnknownNullCount);
+        return st;
       }
       case Datum::CHUNKED_ARRAY: {
         const auto& input = batch[0].chunked_array();
 
         for (const auto& chunk : input->chunks()) {
-          RETURN_NOT_OK(Call(ctx, *chunk->data(), start, out, skip_nulls));
+          RETURN_NOT_OK(Call(ctx, base_output_offset, *chunk->data(), out_arr, start,
+                             skip_nulls, encounted_null));
+          base_output_offset += chunk->length();
         }
+        out_arr->SetNullCount(arrow::kUnknownNullCount);
+        return Status::OK();
       }
       default:
         return Status::NotImplemented(
             "Unsupported input type for function 'cumulative_<operator>': ",
             batch[0].ToString());
     }
-
-    return Status::OK();
   }
 
-  static Status Call(KernelContext* ctx, const ArrayData& arg0, ArgValue& partial_scan,
-                     Datum* out, bool skip_nulls) {
+  static Status Call(KernelContext* ctx, int64_t base_output_offset,
+                     const ArrayData& input, ArrayData* output, ArgValue& accumulator,
+                     bool skip_nulls, bool& encounted_null) {
     Status st = Status::OK();
-    ArrayData* out_arr = out->mutable_array();
-    auto out_data = out_arr->GetMutableValues<OutValue>(1);
-
-    bool encounted_null = false;
-    auto start_null_idx = arg0.offset;
+    auto out_bitmap = output->GetMutableValues<uint8_t>(0);
+    auto out_data = output->GetMutableValues<OutValue>(1) + base_output_offset;
+    auto start_null_idx = input.offset;
+    int64_t curr = 0;
 
     VisitArrayValuesInline<ArgType>(
-        arg0,
+        input,
         [&](ArgValue v) {
           if (!skip_nulls && encounted_null) {
             *out_data++ = OutValue{};
           } else {
-            partial_scan = Op::template Call<OutValue, ArgValue, ArgValue>(
-                ctx, v, partial_scan, &st);
-            *out_data++ = partial_scan;
+            accumulator =
+                Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v, accumulator, &st);
+            *out_data++ = accumulator;
             ++start_null_idx;
           }
+          ++curr;
         },
         [&]() {
           // null
           *out_data++ = OutValue{};
           encounted_null = true;
+          arrow::bit_util::SetBitsTo(out_bitmap, base_output_offset + curr, 1, false);
+          ++curr;
         });
 
     if (!skip_nulls) {
-      auto out_bitmap = out_arr->GetMutableValues<uint8_t>(0);
-      auto null_length = arg0.length - (start_null_idx - arg0.offset);
-      out_arr->SetNullCount(null_length);
-      arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
+      auto null_length = input.length - (start_null_idx - input.offset);
+      arrow::bit_util::SetBitsTo(out_bitmap, base_output_offset + start_null_idx,
+                                 null_length, false);
     }
 
     return st;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index f04e07874ae..8dbc7350ac4 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -30,8 +30,9 @@
 
 #include "arrow/array.h"
 #include "arrow/array/builder_decimal.h"
-#include "arrow/compute/api_vector.h"
 #include "arrow/buffer.h"
+#include "arrow/chunked_array.h"
+#include "arrow/compute/api_vector.h"
 #include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
@@ -79,11 +80,12 @@ class TestCumulativeOp : public ::testing::Test {
   template <typename V = T>
   enable_if_t<!is_floating_type<V>::value, void> Assert(
       const std::string func, const std::shared_ptr<ChunkedArray>& input,
-      const std::shared_ptr<ChunkedArray>& expected, const CumulativeGenericOptions& options) {
+      const std::shared_ptr<ChunkedArray>& expected, const OptionsType& options) {
     ASSERT_OK_AND_ASSIGN(auto result,
                          CallFunction(func, {Datum(input)}, &options, nullptr));
 
-    AssertChunkedEqual(*expected, result);
+    ChunkedArray actual(result.chunks(), this->type_singleton());
+    AssertChunkedEqual(*expected, actual);
   }
 
   template <typename V = T>
@@ -101,11 +103,12 @@ class TestCumulativeOp : public ::testing::Test {
   enable_if_floating_point<V> Assert(const std::string func,
                                      const std::shared_ptr<ChunkedArray>& input,
                                      const std::shared_ptr<ChunkedArray>& expected,
-                                     const CumulativeGenericOptions& options) {
+                                     const OptionsType& options) {
     ASSERT_OK_AND_ASSIGN(auto result,
                          CallFunction(func, {Datum(input)}, &options, nullptr));
 
-    AssertChunkedApproxEquivalent(*expected, *result.chunks(), EqualOptions::Defaults());
+    ChunkedArray actual(result.chunks(), this->type_singleton());
+    AssertChunkedApproxEquivalent(*expected, actual, EqualOptions::Defaults());
   }
 };
 
@@ -119,15 +122,16 @@ class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
 
  protected:
   template <typename U = T>
-  enable_if_parameter_free<U, OptionsType> generate_options(
-      CType start = 0, bool skip_nulls = false, check_overflow = false) {
+  enable_if_parameter_free<U, OptionsType> generate_options(CType start = 0,
+                                                            bool skip_nulls = false,
+                                                            bool check_overflow = false) {
     return OptionsType(std::make_shared<ArrowScalar>(start), skip_nulls, check_overflow);
   }
 
   template <typename U = T>
-  enable_if_t<is_time_type<U>::value || is_timestamp_type<U>::value,
-              OptionsType>
-  generate_options(CType start = 0, bool skip_nulls = false, check_overflow = false) {
+  enable_if_t<is_time_type<U>::value || is_timestamp_type<U>::value, OptionsType>
+  generate_options(CType start = 0, bool skip_nulls = false,
+                   bool check_overflow = false) {
     TimeUnit::type unit;
     switch (ArrowType::type_id) {
       case Type::TIME64:
@@ -137,8 +141,8 @@ class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
         unit = TimeUnit::SECOND;
         break;
     }
-    return OptionsType(std::make_shared<ArrowScalar>(start, unit),
-                                    skip_nulls, check_overflow);
+    return OptionsType(std::make_shared<ArrowScalar>(start, unit), skip_nulls,
+                       check_overflow);
   }
 
   void Assert(const std::string& values, const std::string& expected,
@@ -151,11 +155,12 @@ class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
   }
 
   void Assert(const std::vector<std::string>& values,
-              const std::vector<std::string>& expected,
-              const CumulativeGenericOptions& options) {
-    auto values_arr = TestCumulativeOp<T>::chunked_array(values);
-    auto expected_arr = TestCumulativeOp<T>::chunked_array(expected);
-    TestCumulativeOp<T>::Assert("cumulative_sum", values_arr, expected_arr, options);
+              const std::vector<std::string>& expected, const OptionsType& options) {
+    auto values_arr = TestCumulativeOp<T, OptionsType>::chunked_array(values);
+    auto expected_arr = TestCumulativeOp<T, OptionsType>::chunked_array(expected);
+    auto func_name = options.check_overflow ? "cumulative_sum_checked" : "cumulative_sum";
+    TestCumulativeOp<T, OptionsType>::Assert(func_name, values_arr, expected_arr,
+                                             options);
   }
 };
 
@@ -166,10 +171,12 @@ TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[1, 3, 6, 10, 15, 21]";
-  auto chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
-  auto chunked_expected = {"[1, 3, 6]", "[10, 15, 21]"};
+  std::vector<std::string> chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
+  std::vector<std::string> chunked_expected = {"[1, 3, 6, 10, 15, 21]"};
+
   this->Assert(empty, empty, options);
   this->Assert(values, expected, options);
+  this->Assert(chunked_values, chunked_expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
@@ -178,9 +185,13 @@ TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
   auto three_null = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
   auto expected = "[1, 3, null, null, null, null]";
+  std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
+  std::vector<std::string> chunked_expected = {"[1, 3, null, null, null, null]"};
+
   this->Assert(one_null, one_null, options);
   this->Assert(three_null, three_null, options);
   this->Assert(values, expected, options);
+  this->Assert(chunked_values, chunked_expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
@@ -188,8 +199,12 @@ TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[1, 3, 6, 10, 15, 21]";
+  std::vector<std::string> chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
+  std::vector<std::string> chunked_expected = {"[1, 3, 6, 10, 15, 21]"};
+
   this->Assert(empty, empty, options);
   this->Assert(values, expected, options);
+  this->Assert(chunked_values, chunked_expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
@@ -198,9 +213,13 @@ TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
   auto three_null = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
   auto expected = "[1, 3, null, 7, null, 13]";
+  std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
+  std::vector<std::string> chunked_expected = {"[1, 3, null, 7, null, 13]"};
+
   this->Assert(one_null, one_null, options);
   this->Assert(three_null, three_null, options);
   this->Assert(values, expected, options);
+  this->Assert(chunked_values, chunked_expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
@@ -208,8 +227,12 @@ TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[11, 13, 16, 20, 25, 31]";
+  std::vector<std::string> chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
+  std::vector<std::string> chunked_expected = {"[11, 13, 16, 20, 25, 31]"};
+
   this->Assert(empty, empty, options);
   this->Assert(values, expected, options);
+  this->Assert(chunked_values, chunked_expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
@@ -218,9 +241,13 @@ TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
   auto three_null = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
   auto expected = "[11, 13, null, null, null, null]";
+  std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
+  std::vector<std::string> chunked_expected = {"[11, 13, null, null, null, null]"};
+
   this->Assert(one_null, one_null, options);
   this->Assert(three_null, three_null, options);
   this->Assert(values, expected, options);
+  this->Assert(chunked_values, chunked_expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
@@ -228,8 +255,12 @@ TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
   auto empty = "[]";
   auto values = "[1, 2, 3, 4, 5, 6]";
   auto expected = "[11, 13, 16, 20, 25, 31]";
+  std::vector<std::string> chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
+  std::vector<std::string> chunked_expected = {"[11, 13, 16, 20, 25, 31]"};
+
   this->Assert(empty, empty, options);
   this->Assert(values, expected, options);
+  this->Assert(chunked_values, chunked_expected, options);
 }
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
@@ -238,9 +269,13 @@ TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
   auto three_null = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
   auto expected = "[11, 13, null, 17, null, 23]";
+  std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
+  std::vector<std::string> chunked_expected = {"[11, 13, null, 17, null, 23]"};
+
   this->Assert(one_null, one_null, options);
   this->Assert(three_null, three_null, options);
   this->Assert(values, expected, options);
+  this->Assert(chunked_values, chunked_expected, options);
 }
 
 }  // namespace compute
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 4b0ac26e57e..b20da3e3e63 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1743,7 +1743,8 @@ cdef class _CumulativeSumOptions(FunctionOptions):
             try:
                 start = lib.scalar(start)
             except Exception:
-                _raise_invalid_function_option(start, "`start` type for CumulativeSumOptions", TypeError)
+                _raise_invalid_function_option(
+                    start, "`start` type for CumulativeSumOptions", TypeError)
 
         self.wrapped.reset(new CCumulativeSumOptions((<Scalar> start).unwrap(), skip_nulls))
 

From 1148f1ed23e226ec0bc1e842c4286910eb3ec80f Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 6 Apr 2022 18:08:55 -0400
Subject: [PATCH 42/67] Making changes suggested to PR

---
 cpp/src/arrow/compute/api_vector.h            |  4 +-
 .../compute/kernels/vector_cumulative_ops.cc  | 90 +++++++++++--------
 .../kernels/vector_cumulative_ops_test.cc     | 26 ++----
 3 files changed, 57 insertions(+), 63 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 7d94a88501e..913aa90c63a 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,10 +191,8 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  // Default `start` value is of type Int8 to allow type casting and compatibility rules
-  // to use the type of the function values.
   explicit CumulativeSumOptions(
-      std::shared_ptr<Scalar> start = std::make_shared<NumericScalar<Int64Type>>(0),
+      std::shared_ptr<Scalar> start = std::make_shared<Int64Scalar>(0),
       bool skip_nulls = false, bool check_overflow = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
   static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index d0e847ae61a..cb685911091 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -30,7 +30,11 @@ namespace arrow {
 namespace compute {
 namespace internal {
 
-// NOTE: Missing description of this class
+// Base class for all cumulative compute functions. Op can be any binary associative
+// operation (+, *, min, etc.) and OptionsType the options type corresponding to Op.
+// ArgType and OutType are the input and output types, which will normally be the
+// same (e.g. the cumulative sum of an array of Int64Type will result in an array of
+// Int64Type).
 template <typename OutType, typename ArgType, typename Op, typename OptionsType>
 struct CumulativeGeneric {
   using OutValue = typename GetOutputType<OutType>::T;
@@ -40,9 +44,6 @@ struct CumulativeGeneric {
     const auto& options = OptionsWrapper<OptionsType>::Get(ctx);
     auto skip_nulls = options.skip_nulls;
 
-    // Cast `start` option to match output type
-    // NOTE: Is at least one descriptor guaranteed? If not, need to check size
-    // before indexing.
     auto out_type = batch.GetDescriptors()[0].type;
     ARROW_ASSIGN_OR_RAISE(auto cast_value, Cast(Datum(options.start), out_type));
     auto start = UnboxScalar<OutType>::Unbox(*cast_value.scalar());
@@ -53,8 +54,8 @@ struct CumulativeGeneric {
 
     switch (batch[0].kind()) {
       case Datum::ARRAY: {
-        auto st = Call(ctx, base_output_offset, *batch[0].array(), out_arr, start,
-                       skip_nulls, encounted_null);
+        auto st = Call(ctx, base_output_offset, *batch[0].array(), out_arr, &start,
+                       skip_nulls, &encounted_null);
         out_arr->SetNullCount(arrow::kUnknownNullCount);
         return st;
       }
@@ -62,8 +63,8 @@ struct CumulativeGeneric {
         const auto& input = batch[0].chunked_array();
 
         for (const auto& chunk : input->chunks()) {
-          RETURN_NOT_OK(Call(ctx, base_output_offset, *chunk->data(), out_arr, start,
-                             skip_nulls, encounted_null));
+          RETURN_NOT_OK(Call(ctx, base_output_offset, *chunk->data(), out_arr, &start,
+                             skip_nulls, &encounted_null));
           base_output_offset += chunk->length();
         }
         out_arr->SetNullCount(arrow::kUnknownNullCount);
@@ -77,39 +78,50 @@ struct CumulativeGeneric {
   }
 
   static Status Call(KernelContext* ctx, int64_t base_output_offset,
-                     const ArrayData& input, ArrayData* output, ArgValue& accumulator,
-                     bool skip_nulls, bool& encounted_null) {
+                     const ArrayData& input, ArrayData* output, ArgValue* accumulator,
+                     bool skip_nulls, bool* encounted_null) {
     Status st = Status::OK();
-    auto out_bitmap = output->GetMutableValues<uint8_t>(0);
+    auto out_bitmap =
+        output->GetMutableValues<uint8_t>(0) + (base_output_offset / CHAR_BIT);
+    int64_t curr = base_output_offset % CHAR_BIT;
     auto out_data = output->GetMutableValues<OutValue>(1) + base_output_offset;
-    auto start_null_idx = input.offset;
-    int64_t curr = 0;
-
-    VisitArrayValuesInline<ArgType>(
-        input,
-        [&](ArgValue v) {
-          if (!skip_nulls && encounted_null) {
-            *out_data++ = OutValue{};
-          } else {
-            accumulator =
-                Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v, accumulator, &st);
-            *out_data++ = accumulator;
-            ++start_null_idx;
-          }
-          ++curr;
-        },
-        [&]() {
-          // null
-          *out_data++ = OutValue{};
-          encounted_null = true;
-          arrow::bit_util::SetBitsTo(out_bitmap, base_output_offset + curr, 1, false);
-          ++curr;
-        });
-
-    if (!skip_nulls) {
-      auto null_length = input.length - (start_null_idx - input.offset);
-      arrow::bit_util::SetBitsTo(out_bitmap, base_output_offset + start_null_idx,
-                                 null_length, false);
+
+    auto null_func = [&]() {
+      *out_data++ = OutValue{};
+      *encounted_null = true;
+      arrow::bit_util::SetBitsTo(out_bitmap, curr, 1, false);
+      ++curr;
+    };
+
+    if (skip_nulls) {
+      VisitArrayValuesInline<ArgType>(
+          input,
+          [&](ArgValue v) {
+            *accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
+                ctx, v, *accumulator, &st);
+            *out_data++ = *accumulator;
+            ++curr;
+          },
+          null_func);
+    } else {
+      auto start_null_idx = curr;
+      VisitArrayValuesInline<ArgType>(
+          input,
+          [&](ArgValue v) {
+            if (*encounted_null) {
+              *out_data++ = OutValue{};
+            } else {
+              *accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
+                  ctx, v, *accumulator, &st);
+              *out_data++ = *accumulator;
+              ++start_null_idx;
+            }
+            ++curr;
+          },
+          null_func);
+
+      auto null_length = curr - start_null_idx;
+      arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
     }
 
     return st;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 8dbc7350ac4..03b99125982 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -15,25 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <algorithm>
-#include <cstdint>
-#include <cstdio>
-#include <functional>
-#include <locale>
-#include <memory>
-#include <stdexcept>
 #include <string>
-#include <utility>
 #include <vector>
 
 #include <gtest/gtest.h>
 
 #include "arrow/array.h"
-#include "arrow/array/builder_decimal.h"
-#include "arrow/buffer.h"
 #include "arrow/chunked_array.h"
 #include "arrow/compute/api_vector.h"
-#include "arrow/testing/gtest_util.h"  // IntegralArrowTypes
+#include "arrow/testing/gtest_util.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
 #include "arrow/type_fwd.h"
@@ -41,20 +31,14 @@
 #include "arrow/compute/api.h"
 #include "arrow/compute/kernels/test_util.h"
 
-#include "arrow/ipc/json_simple.h"
-
 namespace arrow {
 namespace compute {
 
-using CumulativeTypes =
-    testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int8Type, Int16Type,
-                   Int32Type, Int64Type, FloatType, DoubleType>;
-
 template <typename T, typename OptionsType>
 class TestCumulativeOp : public ::testing::Test {
  public:
   using ArrowType = T;
-  using ArrowScalar = typename TypeTraits<T>::ScalarType;
+  using ScalarType = typename TypeTraits<T>::ScalarType;
   using CType = typename TypeTraits<T>::CType;
 
  protected:
@@ -117,7 +101,7 @@ class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
  public:
   using OptionsType = CumulativeSumOptions;
   using ArrowType = typename TestCumulativeOp<T, OptionsType>::ArrowType;
-  using ArrowScalar = typename TestCumulativeOp<T, OptionsType>::ArrowScalar;
+  using ScalarType = typename TestCumulativeOp<T, OptionsType>::ScalarType;
   using CType = typename TestCumulativeOp<T, OptionsType>::CType;
 
  protected:
@@ -125,7 +109,7 @@ class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
   enable_if_parameter_free<U, OptionsType> generate_options(CType start = 0,
                                                             bool skip_nulls = false,
                                                             bool check_overflow = false) {
-    return OptionsType(std::make_shared<ArrowScalar>(start), skip_nulls, check_overflow);
+    return OptionsType(std::make_shared<ScalarType>(start), skip_nulls, check_overflow);
   }
 
   template <typename U = T>
@@ -141,7 +125,7 @@ class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
         unit = TimeUnit::SECOND;
         break;
     }
-    return OptionsType(std::make_shared<ArrowScalar>(start, unit), skip_nulls,
+    return OptionsType(std::make_shared<ScalarType>(start, unit), skip_nulls,
                        check_overflow);
   }
 

From 2f3714b6ef7b6a1bcf1e851cf60fc745a1e975f5 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 7 Apr 2022 11:25:47 -0400
Subject: [PATCH 43/67] Simplifying write to null bitmap

---
 .../compute/kernels/vector_cumulative_ops.cc  | 30 ++++++++++---------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index cb685911091..c23d6ab53ba 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -45,17 +45,19 @@ struct CumulativeGeneric {
     auto skip_nulls = options.skip_nulls;
 
     auto out_type = batch.GetDescriptors()[0].type;
-    ARROW_ASSIGN_OR_RAISE(auto cast_value, Cast(Datum(options.start), out_type));
+    ARROW_ASSIGN_OR_RAISE(
+        auto cast_value,
+        Cast(Datum(options.start), out_type, CastOptions::Safe(), ctx->exec_context()));
     auto start = UnboxScalar<OutType>::Unbox(*cast_value.scalar());
 
     int64_t base_output_offset = 0;
-    bool encounted_null = false;
+    bool encountered_null = false;
     ArrayData* out_arr = out->mutable_array();
 
     switch (batch[0].kind()) {
       case Datum::ARRAY: {
         auto st = Call(ctx, base_output_offset, *batch[0].array(), out_arr, &start,
-                       skip_nulls, &encounted_null);
+                       skip_nulls, &encountered_null);
         out_arr->SetNullCount(arrow::kUnknownNullCount);
         return st;
       }
@@ -64,7 +66,7 @@ struct CumulativeGeneric {
 
         for (const auto& chunk : input->chunks()) {
           RETURN_NOT_OK(Call(ctx, base_output_offset, *chunk->data(), out_arr, &start,
-                             skip_nulls, &encounted_null));
+                             skip_nulls, &encountered_null));
           base_output_offset += chunk->length();
         }
         out_arr->SetNullCount(arrow::kUnknownNullCount);
@@ -79,17 +81,16 @@ struct CumulativeGeneric {
 
   static Status Call(KernelContext* ctx, int64_t base_output_offset,
                      const ArrayData& input, ArrayData* output, ArgValue* accumulator,
-                     bool skip_nulls, bool* encounted_null) {
+                     bool skip_nulls, bool* encountered_null) {
     Status st = Status::OK();
-    auto out_bitmap =
-        output->GetMutableValues<uint8_t>(0) + (base_output_offset / CHAR_BIT);
-    int64_t curr = base_output_offset % CHAR_BIT;
+    auto out_bitmap = output->GetMutableValues<uint8_t>(0);
     auto out_data = output->GetMutableValues<OutValue>(1) + base_output_offset;
+    int64_t curr = base_output_offset;
 
     auto null_func = [&]() {
       *out_data++ = OutValue{};
-      *encounted_null = true;
-      arrow::bit_util::SetBitsTo(out_bitmap, curr, 1, false);
+      *encountered_null = true;
+      arrow::bit_util::SetBitTo(out_bitmap, curr, false);
       ++curr;
     };
 
@@ -104,11 +105,11 @@ struct CumulativeGeneric {
           },
           null_func);
     } else {
-      auto start_null_idx = curr;
+      auto start_null_idx = 0;
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
-            if (*encounted_null) {
+            if (*encountered_null) {
               *out_data++ = OutValue{};
             } else {
               *accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
@@ -120,8 +121,9 @@ struct CumulativeGeneric {
           },
           null_func);
 
-      auto null_length = curr - start_null_idx;
-      arrow::bit_util::SetBitsTo(out_bitmap, start_null_idx, null_length, false);
+      auto null_length = input.length - start_null_idx;
+      arrow::bit_util::SetBitsTo(out_bitmap, base_output_offset + start_null_idx,
+                                 null_length, false);
     }
 
     return st;

From c90d535be0fcd99535441e966c0654a40b3777d9 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 8 Apr 2022 17:31:52 -0400
Subject: [PATCH 44/67] Minor changes to funtion docs, comments, and variables

---
 cpp/src/arrow/compute/api_vector.cc           |  4 ++
 cpp/src/arrow/compute/api_vector.h            | 10 ++--
 .../compute/kernels/vector_cumulative_ops.cc  | 49 ++++++++++---------
 .../kernels/vector_cumulative_ops_test.cc     |  3 +-
 4 files changed, 37 insertions(+), 29 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 0e6cee8ed28..e3db022536c 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -180,6 +180,10 @@ SelectKOptions::SelectKOptions(int64_t k, std::vector<SortKey> sort_keys)
       sort_keys(std::move(sort_keys)) {}
 constexpr char SelectKOptions::kTypeName[];
 
+CumulativeSumOptions::CumulativeSumOptions(double start, bool skip_nulls,
+                                           bool check_overflow)
+    : CumulativeSumOptions(std::make_shared<DoubleScalar>(start), skip_nulls,
+                           check_overflow) {}
 CumulativeSumOptions::CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls,
                                            bool check_overflow)
     : FunctionOptions(internal::kCumulativeSumOptionsType),
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 913aa90c63a..a6f526f7885 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,9 +191,10 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
-  explicit CumulativeSumOptions(
-      std::shared_ptr<Scalar> start = std::make_shared<Int64Scalar>(0),
-      bool skip_nulls = false, bool check_overflow = false);
+ explicit CumulativeSumOptions(double start = 0, bool skip_nulls = false,
+                               bool check_overflow = false);
+  explicit CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls = false,
+                                bool check_overflow = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
   static CumulativeSumOptions Defaults() { return CumulativeSumOptions(); }
 
@@ -201,8 +202,7 @@ class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
   std::shared_ptr<Scalar> start;
 
   /// If true, nulls in the input are ignored and produce a corresponding null output.
-  /// When false, the first null/NaN encountered is propagated through the remaining
-  /// output.
+  /// When false, the first null encountered is propagated through the remaining output.
   bool skip_nulls = false;
 
   /// When true, returns an Invalid Status when overflow is detected
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index c23d6ab53ba..c43537ea2fe 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -30,11 +30,11 @@ namespace arrow {
 namespace compute {
 namespace internal {
 
-// Base class for all cumulative compute functions. Op can be any binary associative
-// operation (+, *, min, etc.) and OptionsType the options type corresponding to Op.
-// ArgType and OutType are the input and output types, which will normally be the
-// same (e.g. the cumulative sum of an array of Int64Type will result in an array of
-// Int64Type).
+// The driver kernel for all cumulative compute functions. Op is a compute kernel
+// representing any binary associative operation (add, product, min, max, etc.) and
+// OptionsType the options type corresponding to Op. ArgType and OutType are the input
+// and output types, which will normally be the same (e.g. the cumulative sum of an array
+//  of Int64Type will result in an array of Int64Type).
 template <typename OutType, typename ArgType, typename Op, typename OptionsType>
 struct CumulativeGeneric {
   using OutValue = typename GetOutputType<OutType>::T;
@@ -83,13 +83,16 @@ struct CumulativeGeneric {
                      const ArrayData& input, ArrayData* output, ArgValue* accumulator,
                      bool skip_nulls, bool* encountered_null) {
     Status st = Status::OK();
+    ArgValue accumulator_tmp = *accumulator;
+    bool encountered_null_tmp = *encountered_null;
+
     auto out_bitmap = output->GetMutableValues<uint8_t>(0);
     auto out_data = output->GetMutableValues<OutValue>(1) + base_output_offset;
     int64_t curr = base_output_offset;
 
     auto null_func = [&]() {
       *out_data++ = OutValue{};
-      *encountered_null = true;
+      encountered_null_tmp = true;
       arrow::bit_util::SetBitTo(out_bitmap, curr, false);
       ++curr;
     };
@@ -98,9 +101,9 @@ struct CumulativeGeneric {
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
-            *accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
-                ctx, v, *accumulator, &st);
-            *out_data++ = *accumulator;
+            accumulator_tmp = Op::template Call<OutValue, ArgValue, ArgValue>(
+                ctx, v, accumulator_tmp, &st);
+            *out_data++ = accumulator_tmp;
             ++curr;
           },
           null_func);
@@ -109,12 +112,12 @@ struct CumulativeGeneric {
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
-            if (*encountered_null) {
+            if (encountered_null_tmp) {
               *out_data++ = OutValue{};
             } else {
-              *accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
-                  ctx, v, *accumulator, &st);
-              *out_data++ = *accumulator;
+              accumulator_tmp = Op::template Call<OutValue, ArgValue, ArgValue>(
+                  ctx, v, accumulator_tmp, &st);
+              *out_data++ = accumulator_tmp;
               ++start_null_idx;
             }
             ++curr;
@@ -126,26 +129,28 @@ struct CumulativeGeneric {
                                  null_length, false);
     }
 
+    *accumulator = accumulator_tmp;
+    *encountered_null = encountered_null_tmp;
     return st;
   }
 };
 
 const FunctionDoc cumulative_sum_doc{
-    "Compute the cumulative sum over an array of numbers",
-    ("`values` must be an array of numeric type values.\n"
-     "Return an array which is the cumulative sum computed over `values`.\n"
-     "Results will wrap around on integer overflow.\n"
+    "Compute the cumulative sum over an array/chunked array of numbers",
+    ("`values` must be an array/chunked array of numeric type values.\n"
+     "Return an array/chunked array which is the cumulative sum computed\n"
+     "over `values`. Results will wrap around on integer overflow.\n"
      "Use function \"cumulative_sum_checked\" if you want overflow\n"
      "to return an error."),
     {"values"},
     "CumulativeSumOptions"};
 
 const FunctionDoc cumulative_sum_checked_doc{
-    "Compute the cumulative sum over an array of numbers",
-    ("`values` must be an array of numeric type values.\n"
-     "Return an array which is the cumulative sum computed over `values`.\n"
-     "This function returns an error on overflow. For a variant that\n"
-     "doesn't fail on overflow, use function \"cumulative_sum\"."),
+    "Compute the cumulative sum over an array/chunked array of numbers",
+    ("`values` must be an array/chunked array of numeric type values.\n"
+     "Return an array/chunked array which is the cumulative sum computed\n"
+     "over `values`. This function returns an error on overflow. For a\n"
+     "variant that doesn't fail on overflow, use function \"cumulative_sum\"."),
     {"values"},
     "CumulativeSumOptions"};
 
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 03b99125982..d17dfe4d7f9 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -22,11 +23,9 @@
 
 #include "arrow/array.h"
 #include "arrow/chunked_array.h"
-#include "arrow/compute/api_vector.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
-#include "arrow/type_fwd.h"
 
 #include "arrow/compute/api.h"
 #include "arrow/compute/kernels/test_util.h"

From 6bba2fccba7783abd922977dae8f67ea6f201c4b Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 11 Apr 2022 16:33:20 -0400
Subject: [PATCH 45/67] add CumulativeOptionsWrapper

---
 .../compute/kernels/vector_cumulative_ops.cc  | 41 +++++++++++++++----
 1 file changed, 33 insertions(+), 8 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index c23d6ab53ba..287318cd777 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -29,6 +29,35 @@
 namespace arrow {
 namespace compute {
 namespace internal {
+namespace {
+template <typename OptionsType>
+struct CumulativeOptionsWrapper : public OptionsWrapper<OptionsType> {
+  using State = CumulativeOptionsWrapper<OptionsType>;
+
+  explicit CumulativeOptionsWrapper(OptionsType options) : OptionsWrapper<OptionsType>(std::move(options)) {}
+
+  static Result<std::unique_ptr<KernelState>> Init(KernelContext* ctx,
+                                                   const KernelInitArgs& args) {
+    auto options = static_cast<const OptionsType*>(args.options);
+    if (!options) {
+      return Status::Invalid(
+          "Attempted to initialize KernelState from null FunctionOptions");
+    }
+
+    const auto& start = options->start;
+    if (!start || !start->is_valid) {
+      return Status::Invalid("Cumulative `start` option must be non-null and valid");
+    }
+
+    // Ensure `start` option matches input type
+    if (!start->type->Equals(args.inputs[0].type)) {
+      ARROW_ASSIGN_OR_RAISE(auto casted_start, Cast(Datum(start), args.inputs[0].type));
+      auto new_options = OptionsType(casted_start.scalar(), options->skip_nulls);
+      return ::arrow::internal::make_unique<State>(new_options);
+    }
+    return ::arrow::internal::make_unique<State>(*options);
+  }
+};
 
 // Base class for all cumulative compute functions. Op can be any binary associative
 // operation (+, *, min, etc.) and OptionsType the options type corresponding to Op.
@@ -41,15 +70,10 @@ struct CumulativeGeneric {
   using ArgValue = typename GetViewType<ArgType>::T;
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const auto& options = OptionsWrapper<OptionsType>::Get(ctx);
+    const auto& options = CumulativeOptionsWrapper<OptionsType>::Get(ctx);
+    auto start = UnboxScalar<OutType>::Unbox(*(options.start));
     auto skip_nulls = options.skip_nulls;
 
-    auto out_type = batch.GetDescriptors()[0].type;
-    ARROW_ASSIGN_OR_RAISE(
-        auto cast_value,
-        Cast(Datum(options.start), out_type, CastOptions::Safe(), ctx->exec_context()));
-    auto start = UnboxScalar<OutType>::Unbox(*cast_value.scalar());
-
     int64_t base_output_offset = 0;
     bool encountered_null = false;
     ArrayData* out_arr = out->mutable_array();
@@ -148,6 +172,7 @@ const FunctionDoc cumulative_sum_checked_doc{
      "doesn't fail on overflow, use function \"cumulative_sum\"."),
     {"values"},
     "CumulativeSumOptions"};
+}  // namespace
 
 template <typename Op, typename OptionsType>
 void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string func_name,
@@ -166,7 +191,7 @@ void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
     kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Op, OptionsType>(ty);
-    kernel.init = OptionsWrapper<OptionsType>::Init;
+    kernel.init = CumulativeOptionsWrapper<OptionsType>::Init;
     DCHECK_OK(func->AddKernel(std::move(kernel)));
   }
 

From 58b36d52f854b55216e3622a5d300482f1845e38 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 11 Apr 2022 16:37:37 -0400
Subject: [PATCH 46/67] initialize with floating-point zero

---
 python/pyarrow/_compute.pyx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index b20da3e3e63..da2d278a02d 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1755,13 +1755,13 @@ class CumulativeSumOptions(_CumulativeSumOptions):
 
     Parameters
     ----------
-    start : Scalar (optional, default 0)
+    start : Scalar (optional, default 0.0)
         Starting value for sum computation
     skip_nulls : bool (optional, default False)
         When false, propagates the first null/NaN encountered
     """
 
-    def __init__(self, start=0, skip_nulls=False):
+    def __init__(self, start=0.0, skip_nulls=False):
         self._set_options(start, skip_nulls)
 
 

From 1933da77a5e2983a89ae86edbf60487442a664b6 Mon Sep 17 00:00:00 2001
From: Eduardo Ponce <edponce00@gmail.com>
Date: Mon, 11 Apr 2022 20:09:34 -0400
Subject: [PATCH 47/67] set default start to float64, add Python tests

---
 python/pyarrow/_compute.pyx          |  9 ++---
 python/pyarrow/tests/test_compute.py | 57 ++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+), 5 deletions(-)

diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index da2d278a02d..496d6d2a686 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1739,7 +1739,6 @@ class PartitionNthOptions(_PartitionNthOptions):
 cdef class _CumulativeSumOptions(FunctionOptions):
     def _set_options(self, start, skip_nulls):
         if not isinstance(start, Scalar):
-            # Is it a Python scalar?
             try:
                 start = lib.scalar(start)
             except Exception:
@@ -1755,13 +1754,13 @@ class CumulativeSumOptions(_CumulativeSumOptions):
 
     Parameters
     ----------
-    start : Scalar (optional, default 0.0)
+    start : Scalar, default 0.0
         Starting value for sum computation
-    skip_nulls : bool (optional, default False)
-        When false, propagates the first null/NaN encountered
+    skip_nulls : bool, default False
+        When false, propagates the first null encountered.
     """
 
-    def __init__(self, start=0.0, skip_nulls=False):
+    def __init__(self, start=0.0, *, skip_nulls=False):
         self._set_options(start, skip_nulls)
 
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 14ca2355484..7a1fe0e78fb 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -2504,6 +2504,63 @@ def test_min_max_element_wise():
     assert result == pa.array([1, 2, None])
 
 
+@pytest.mark.parametrize('start', (1.1, 10.5, -10.5))
+@pytest.mark.parametrize('skip_nulls', (True, False))
+def test_cumulative_sum(start, skip_nulls):
+    # Exact tests (e.g., integral types)
+    start_int = int(start)
+    starts = [start_int, pa.scalar(start_int, type=pa.int8()),
+              pa.scalar(start_int, type=pa.int64())]
+    for strt in starts:
+        arrays = [
+            pa.array([1, 2, 3]),
+            pa.array([0, None, 20, 30]),
+            pa.chunked_array([[0, None], [20, 30]])
+        ]
+        expected_arrays = [
+            pa.array([1, 3, 6]),
+            pa.array([0, None, 20, 50])
+            if skip_nulls else pa.array([0, None, None, None]),
+            pa.chunked_array([[0, None, 20, 50]])
+            if skip_nulls else pa.chunked_array([[0, None, None, None]])
+        ]
+        for i, arr in enumerate(arrays):
+            result = pc.cumulative_sum(arr, start=strt, skip_nulls=skip_nulls)
+            # Add `start` offset to expected array before comparing
+            expected = pc.add(expected_arrays[i], strt)
+            assert result.equals(expected)
+
+    # Approximate and NaN tests (e.g., floating-point types)
+    # NOTE: Conversion from Arrow to NumPy replaces null slots with NaNs
+    # which prevent fully validating both states of `skip_nulls` for
+    # floating-point values. Ideally, equality comparisons make use of Arrow's
+    # `equals()` functions but an approximate version is not exposed in Python.
+    starts = [start, pa.scalar(start, type=pa.float32()),
+              pa.scalar(start, type=pa.float64())]
+    for strt in starts:
+        arrays = [
+            pa.array([1.1, 2.2, 3.3]),
+            pa.array([1, np.nan, 2, -3, 4, 5]),
+            pa.array([1, np.nan, None, 3, None, 5])
+        ]
+        expected_arrays = [
+            np.array([1.1, 3.3, 6.6]),
+            np.array([1, np.nan, np.nan, np.nan, np.nan, np.nan]),
+            np.array([1, np.nan, None, np.nan, None, np.nan])
+            if skip_nulls else np.array([1, np.nan, None, None, None, None])
+        ]
+        for i, arr in enumerate(arrays):
+            result = pc.cumulative_sum(arr, start=strt, skip_nulls=skip_nulls)
+            # Add `start` offset to expected array before comparing
+            expected = pc.add(expected_arrays[i], strt)
+            np.testing.assert_array_almost_equal(result.to_numpy(
+                zero_copy_only=False), expected.to_numpy(zero_copy_only=False))
+
+    for strt in ['a', pa.scalar('arrow'), 1.1]:
+        with pytest.raises(pa.ArrowInvalid):
+            pc.cumulative_sum([1, 2, 3], start=strt)
+
+
 def test_make_struct():
     assert pc.make_struct(1, 'a').as_py() == {'0': 1, '1': 'a'}
 

From ae25c718a0febc468ec5f013cb9f5785c0334866 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 12 Apr 2022 11:57:35 -0400
Subject: [PATCH 48/67] Moved basic arithmetic kernels

---
 cpp/src/arrow/compute/api_vector.h            |   4 +-
 .../kernels/base_arithmetic_internal.h        | 483 ++++++++++++++++++
 .../compute/kernels/scalar_arithmetic.cc      | 479 -----------------
 .../compute/kernels/vector_cumulative_ops.cc  |   7 +-
 .../kernels/vector_cumulative_ops_test.cc     |  24 +-
 5 files changed, 498 insertions(+), 499 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index a6f526f7885..b5daddb17b9 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -191,8 +191,8 @@ class ARROW_EXPORT PartitionNthOptions : public FunctionOptions {
 /// \brief Options for cumulative sum function
 class ARROW_EXPORT CumulativeSumOptions : public FunctionOptions {
  public:
- explicit CumulativeSumOptions(double start = 0, bool skip_nulls = false,
-                               bool check_overflow = false);
+  explicit CumulativeSumOptions(double start = 0, bool skip_nulls = false,
+                                bool check_overflow = false);
   explicit CumulativeSumOptions(std::shared_ptr<Scalar> start, bool skip_nulls = false,
                                 bool check_overflow = false);
   static constexpr char const kTypeName[] = "CumulativeSumOptions";
diff --git a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
index e17fbb99f2d..1707ed7c137 100644
--- a/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
+++ b/cpp/src/arrow/compute/kernels/base_arithmetic_internal.h
@@ -29,6 +29,10 @@
 namespace arrow {
 
 using internal::AddWithOverflow;
+using internal::DivideWithOverflow;
+using internal::MultiplyWithOverflow;
+using internal::NegateWithOverflow;
+using internal::SubtractWithOverflow;
 
 namespace compute {
 namespace internal {
@@ -114,6 +118,485 @@ struct AddTimeDurationChecked {
   }
 };
 
+struct AbsoluteValue {
+  template <typename T, typename Arg>
+  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                         Status*) {
+    return std::fabs(arg);
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_unsigned_integer_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                                 Status*) {
+    return arg;
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                               Status* st) {
+    return (arg < 0) ? arrow::internal::SafeSignedNegate(arg) : arg;
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                        Status*) {
+    return arg.Abs();
+  }
+};
+
+struct AbsoluteValueChecked {
+  template <typename T, typename Arg>
+  static enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                     Status* st) {
+    static_assert(std::is_same<T, Arg>::value, "");
+    if (arg == std::numeric_limits<Arg>::min()) {
+      *st = Status::Invalid("overflow");
+      return arg;
+    }
+    return std::abs(arg);
+  }
+
+  template <typename T, typename Arg>
+  static enable_if_unsigned_integer_value<Arg, T> Call(KernelContext* ctx, Arg arg,
+                                                       Status* st) {
+    static_assert(std::is_same<T, Arg>::value, "");
+    return arg;
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                         Status* st) {
+    static_assert(std::is_same<T, Arg>::value, "");
+    return std::fabs(arg);
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                        Status*) {
+    return arg.Abs();
+  }
+};
+
+struct Subtract {
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                                    Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return left - right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                            Arg1 right, Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return left - right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
+                                                          Arg1 right, Status*) {
+    return arrow::internal::SafeSignedSubtract(left, right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + (-right);
+  }
+};
+
+struct SubtractChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(SubtractWithOverflow(left, right, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                          Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return left - right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left + (-right);
+  }
+};
+
+struct SubtractDate32 {
+  static constexpr int64_t kSecondsInDay = 86400;
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return arrow::internal::SafeSignedSubtract(left, right) * kSecondsInDay;
+  }
+};
+
+struct SubtractCheckedDate32 {
+  static constexpr int64_t kSecondsInDay = 86400;
+
+  template <typename T, typename Arg0, typename Arg1>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(SubtractWithOverflow(left, right, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, kSecondsInDay, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    return result;
+  }
+};
+
+template <int64_t multiple>
+struct SubtractTimeDuration {
+  template <typename T, typename Arg0, typename Arg1>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
+    T result = arrow::internal::SafeSignedSubtract(left, static_cast<T>(right));
+    if (result < 0 || multiple <= result) {
+      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
+                            multiple, ") s");
+    }
+    return result;
+  }
+};
+
+template <int64_t multiple>
+struct SubtractTimeDurationChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(SubtractWithOverflow(left, static_cast<T>(right), &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    if (result < 0 || multiple <= result) {
+      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
+                            multiple, ") s");
+    }
+    return result;
+  }
+};
+
+struct Multiply {
+  static_assert(std::is_same<decltype(int8_t() * int8_t()), int32_t>::value, "");
+  static_assert(std::is_same<decltype(uint8_t() * uint8_t()), int32_t>::value, "");
+  static_assert(std::is_same<decltype(int16_t() * int16_t()), int32_t>::value, "");
+  static_assert(std::is_same<decltype(uint16_t() * uint16_t()), int32_t>::value, "");
+  static_assert(std::is_same<decltype(int32_t() * int32_t()), int32_t>::value, "");
+  static_assert(std::is_same<decltype(uint32_t() * uint32_t()), uint32_t>::value, "");
+  static_assert(std::is_same<decltype(int64_t() * int64_t()), int64_t>::value, "");
+  static_assert(std::is_same<decltype(uint64_t() * uint64_t()), uint64_t>::value, "");
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_floating_value<T> Call(KernelContext*, T left, T right,
+                                                    Status*) {
+    return left * right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_t<
+      is_unsigned_integer_value<T>::value && !std::is_same<T, uint16_t>::value, T>
+  Call(KernelContext*, T left, T right, Status*) {
+    return left * right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_t<
+      is_signed_integer_value<T>::value && !std::is_same<T, int16_t>::value, T>
+  Call(KernelContext*, T left, T right, Status*) {
+    return to_unsigned(left) * to_unsigned(right);
+  }
+
+  // Multiplication of 16 bit integer types implicitly promotes to signed 32 bit
+  // integer. However, some inputs may nevertheless overflow (which triggers undefined
+  // behaviour). Therefore we first cast to 32 bit unsigned integers where overflow is
+  // well defined.
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_same<T, int16_t, T> Call(KernelContext*, int16_t left,
+                                                      int16_t right, Status*) {
+    return static_cast<uint32_t>(left) * static_cast<uint32_t>(right);
+  }
+  template <typename T, typename Arg0, typename Arg1>
+  static constexpr enable_if_same<T, uint16_t, T> Call(KernelContext*, uint16_t left,
+                                                       uint16_t right, Status*) {
+    return static_cast<uint32_t>(left) * static_cast<uint32_t>(right);
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left * right;
+  }
+};
+
+struct MultiplyChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(left, right, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                          Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return left * right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
+    return left * right;
+  }
+};
+
+struct Divide {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                          Status*) {
+    return left / right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    T result;
+    if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &result))) {
+      if (right == 0) {
+        *st = Status::Invalid("divide by zero");
+      } else {
+        result = 0;
+      }
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    if (right == Arg1()) {
+      *st = Status::Invalid("Divide by zero");
+      return T();
+    } else {
+      return left / right;
+    }
+  }
+};
+
+struct DivideChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                         Status* st) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    T result;
+    if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &result))) {
+      if (right == 0) {
+        *st = Status::Invalid("divide by zero");
+      } else {
+        *st = Status::Invalid("overflow");
+      }
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
+                                          Status* st) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    if (ARROW_PREDICT_FALSE(right == 0)) {
+      *st = Status::Invalid("divide by zero");
+      return 0;
+    }
+    return left / right;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_decimal_value<T> Call(KernelContext* ctx, Arg0 left, Arg1 right,
+                                         Status* st) {
+    return Divide::Call<T>(ctx, left, right, st);
+  }
+};
+
+struct Negate {
+  template <typename T, typename Arg>
+  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg arg, Status*) {
+    return -arg;
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg arg,
+                                                            Status*) {
+    return ~arg + 1;
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg arg,
+                                                          Status*) {
+    return arrow::internal::SafeSignedNegate(arg);
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                        Status*) {
+    return arg.Negate();
+  }
+};
+
+struct NegateChecked {
+  template <typename T, typename Arg>
+  static enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                     Status* st) {
+    static_assert(std::is_same<T, Arg>::value, "");
+    T result = 0;
+    if (ARROW_PREDICT_FALSE(NegateWithOverflow(arg, &result))) {
+      *st = Status::Invalid("overflow");
+    }
+    return result;
+  }
+
+  template <typename T, typename Arg>
+  static enable_if_unsigned_integer_value<Arg, T> Call(KernelContext* ctx, Arg arg,
+                                                       Status* st) {
+    static_assert(std::is_same<T, Arg>::value, "");
+    DCHECK(false) << "This is included only for the purposes of instantiability from the "
+                     "arithmetic kernel generator";
+    return 0;
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                         Status* st) {
+    static_assert(std::is_same<T, Arg>::value, "");
+    return -arg;
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                        Status*) {
+    return arg.Negate();
+  }
+};
+
+struct Power {
+  ARROW_NOINLINE
+  static uint64_t IntegerPower(uint64_t base, uint64_t exp) {
+    // right to left O(logn) power
+    uint64_t pow = 1;
+    while (exp) {
+      pow *= (exp & 1) ? base : 1;
+      base *= base;
+      exp >>= 1;
+    }
+    return pow;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, T base, T exp, Status* st) {
+    if (exp < 0) {
+      *st = Status::Invalid("integers to negative integer powers are not allowed");
+      return 0;
+    }
+    return static_cast<T>(IntegerPower(base, exp));
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, T base, T exp, Status*) {
+    return std::pow(base, exp);
+  }
+};
+
+struct PowerChecked {
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_integer_value<T> Call(KernelContext*, Arg0 base, Arg1 exp,
+                                         Status* st) {
+    if (exp < 0) {
+      *st = Status::Invalid("integers to negative integer powers are not allowed");
+      return 0;
+    } else if (exp == 0) {
+      return 1;
+    }
+    // left to right O(logn) power with overflow checks
+    bool overflow = false;
+    uint64_t bitmask =
+        1ULL << (63 - bit_util::CountLeadingZeros(static_cast<uint64_t>(exp)));
+    T pow = 1;
+    while (bitmask) {
+      overflow |= MultiplyWithOverflow(pow, pow, &pow);
+      if (exp & bitmask) {
+        overflow |= MultiplyWithOverflow(pow, base, &pow);
+      }
+      bitmask >>= 1;
+    }
+    if (overflow) {
+      *st = Status::Invalid("overflow");
+    }
+    return pow;
+  }
+
+  template <typename T, typename Arg0, typename Arg1>
+  static enable_if_floating_value<T> Call(KernelContext*, Arg0 base, Arg1 exp, Status*) {
+    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
+    return std::pow(base, exp);
+  }
+};
+
+struct SquareRoot {
+  template <typename T, typename Arg>
+  static enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg, Status*) {
+    static_assert(std::is_same<T, Arg>::value, "");
+    if (arg < 0.0) {
+      return std::numeric_limits<T>::quiet_NaN();
+    }
+    return std::sqrt(arg);
+  }
+};
+
+struct SquareRootChecked {
+  template <typename T, typename Arg>
+  static enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg, Status* st) {
+    static_assert(std::is_same<T, Arg>::value, "");
+    if (arg < 0.0) {
+      *st = Status::Invalid("square root of negative number");
+      return arg;
+    }
+    return std::sqrt(arg);
+  }
+};
+
+struct Sign {
+  template <typename T, typename Arg>
+  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                         Status*) {
+    return std::isnan(arg) ? arg : ((arg == 0) ? 0 : (std::signbit(arg) ? -1 : 1));
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_unsigned_integer_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                                 Status*) {
+    return (arg > 0) ? 1 : 0;
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                               Status*) {
+    return (arg > 0) ? 1 : ((arg == 0) ? 0 : -1);
+  }
+
+  template <typename T, typename Arg>
+  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
+                                                        Status*) {
+    return (arg == 0) ? 0 : arg.Sign();
+  }
+};
+
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 125af57a114..2f400140969 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -56,485 +56,6 @@ namespace {
 // N.B. take care not to conflict with type_traits.h as that can cause surprises in a
 // unity build
 
-struct AbsoluteValue {
-  template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                         Status*) {
-    return std::fabs(arg);
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_unsigned_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                                 Status*) {
-    return arg;
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                               Status* st) {
-    return (arg < 0) ? arrow::internal::SafeSignedNegate(arg) : arg;
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
-    return arg.Abs();
-  }
-};
-
-struct AbsoluteValueChecked {
-  template <typename T, typename Arg>
-  static enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                     Status* st) {
-    static_assert(std::is_same<T, Arg>::value, "");
-    if (arg == std::numeric_limits<Arg>::min()) {
-      *st = Status::Invalid("overflow");
-      return arg;
-    }
-    return std::abs(arg);
-  }
-
-  template <typename T, typename Arg>
-  static enable_if_unsigned_integer_value<Arg, T> Call(KernelContext* ctx, Arg arg,
-                                                       Status* st) {
-    static_assert(std::is_same<T, Arg>::value, "");
-    return arg;
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                         Status* st) {
-    static_assert(std::is_same<T, Arg>::value, "");
-    return std::fabs(arg);
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
-    return arg.Abs();
-  }
-};
-
-struct Subtract {
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                                    Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return left - right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                            Arg1 right, Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return left - right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg0 left,
-                                                          Arg1 right, Status*) {
-    return arrow::internal::SafeSignedSubtract(left, right);
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + (-right);
-  }
-};
-
-struct SubtractChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(SubtractWithOverflow(left, right, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return left - right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left + (-right);
-  }
-};
-
-struct SubtractDate32 {
-  static constexpr int64_t kSecondsInDay = 86400;
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr T Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return arrow::internal::SafeSignedSubtract(left, right) * kSecondsInDay;
-  }
-};
-
-struct SubtractCheckedDate32 {
-  static constexpr int64_t kSecondsInDay = 86400;
-
-  template <typename T, typename Arg0, typename Arg1>
-  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(SubtractWithOverflow(left, right, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(result, kSecondsInDay, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    return result;
-  }
-};
-
-template <int64_t multiple>
-struct SubtractTimeDuration {
-  template <typename T, typename Arg0, typename Arg1>
-  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
-    T result = arrow::internal::SafeSignedSubtract(left, static_cast<T>(right));
-    if (result < 0 || multiple <= result) {
-      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
-                            multiple, ") s");
-    }
-    return result;
-  }
-};
-
-template <int64_t multiple>
-struct SubtractTimeDurationChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static T Call(KernelContext*, Arg0 left, Arg1 right, Status* st) {
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(SubtractWithOverflow(left, static_cast<T>(right), &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    if (result < 0 || multiple <= result) {
-      *st = Status::Invalid(result, " is not within the acceptable range of ", "[0, ",
-                            multiple, ") s");
-    }
-    return result;
-  }
-};
-
-struct Multiply {
-  static_assert(std::is_same<decltype(int8_t() * int8_t()), int32_t>::value, "");
-  static_assert(std::is_same<decltype(uint8_t() * uint8_t()), int32_t>::value, "");
-  static_assert(std::is_same<decltype(int16_t() * int16_t()), int32_t>::value, "");
-  static_assert(std::is_same<decltype(uint16_t() * uint16_t()), int32_t>::value, "");
-  static_assert(std::is_same<decltype(int32_t() * int32_t()), int32_t>::value, "");
-  static_assert(std::is_same<decltype(uint32_t() * uint32_t()), uint32_t>::value, "");
-  static_assert(std::is_same<decltype(int64_t() * int64_t()), int64_t>::value, "");
-  static_assert(std::is_same<decltype(uint64_t() * uint64_t()), uint64_t>::value, "");
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, T left, T right,
-                                                    Status*) {
-    return left * right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_t<
-      is_unsigned_integer_value<T>::value && !std::is_same<T, uint16_t>::value, T>
-  Call(KernelContext*, T left, T right, Status*) {
-    return left * right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_t<
-      is_signed_integer_value<T>::value && !std::is_same<T, int16_t>::value, T>
-  Call(KernelContext*, T left, T right, Status*) {
-    return to_unsigned(left) * to_unsigned(right);
-  }
-
-  // Multiplication of 16 bit integer types implicitly promotes to signed 32 bit
-  // integer. However, some inputs may nevertheless overflow (which triggers undefined
-  // behaviour). Therefore we first cast to 32 bit unsigned integers where overflow is
-  // well defined.
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_same<T, int16_t, T> Call(KernelContext*, int16_t left,
-                                                      int16_t right, Status*) {
-    return static_cast<uint32_t>(left) * static_cast<uint32_t>(right);
-  }
-  template <typename T, typename Arg0, typename Arg1>
-  static constexpr enable_if_same<T, uint16_t, T> Call(KernelContext*, uint16_t left,
-                                                       uint16_t right, Status*) {
-    return static_cast<uint32_t>(left) * static_cast<uint32_t>(right);
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left * right;
-  }
-};
-
-struct MultiplyChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(MultiplyWithOverflow(left, right, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return left * right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right, Status*) {
-    return left * right;
-  }
-};
-
-struct Divide {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status*) {
-    return left / right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    T result;
-    if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &result))) {
-      if (right == 0) {
-        *st = Status::Invalid("divide by zero");
-      } else {
-        result = 0;
-      }
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    if (right == Arg1()) {
-      *st = Status::Invalid("Divide by zero");
-      return T();
-    } else {
-      return left / right;
-    }
-  }
-};
-
-struct DivideChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                         Status* st) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    T result;
-    if (ARROW_PREDICT_FALSE(DivideWithOverflow(left, right, &result))) {
-      if (right == 0) {
-        *st = Status::Invalid("divide by zero");
-      } else {
-        *st = Status::Invalid("overflow");
-      }
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 left, Arg1 right,
-                                          Status* st) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    if (ARROW_PREDICT_FALSE(right == 0)) {
-      *st = Status::Invalid("divide by zero");
-      return 0;
-    }
-    return left / right;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_decimal_value<T> Call(KernelContext* ctx, Arg0 left, Arg1 right,
-                                         Status* st) {
-    return Divide::Call<T>(ctx, left, right, st);
-  }
-};
-
-struct Negate {
-  template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<T> Call(KernelContext*, Arg arg, Status*) {
-    return -arg;
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_unsigned_integer_value<T> Call(KernelContext*, Arg arg,
-                                                            Status*) {
-    return ~arg + 1;
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_signed_integer_value<T> Call(KernelContext*, Arg arg,
-                                                          Status*) {
-    return arrow::internal::SafeSignedNegate(arg);
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
-    return arg.Negate();
-  }
-};
-
-struct NegateChecked {
-  template <typename T, typename Arg>
-  static enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                     Status* st) {
-    static_assert(std::is_same<T, Arg>::value, "");
-    T result = 0;
-    if (ARROW_PREDICT_FALSE(NegateWithOverflow(arg, &result))) {
-      *st = Status::Invalid("overflow");
-    }
-    return result;
-  }
-
-  template <typename T, typename Arg>
-  static enable_if_unsigned_integer_value<Arg, T> Call(KernelContext* ctx, Arg arg,
-                                                       Status* st) {
-    static_assert(std::is_same<T, Arg>::value, "");
-    DCHECK(false) << "This is included only for the purposes of instantiability from the "
-                     "arithmetic kernel generator";
-    return 0;
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                         Status* st) {
-    static_assert(std::is_same<T, Arg>::value, "");
-    return -arg;
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
-    return arg.Negate();
-  }
-};
-
-struct Power {
-  ARROW_NOINLINE
-  static uint64_t IntegerPower(uint64_t base, uint64_t exp) {
-    // right to left O(logn) power
-    uint64_t pow = 1;
-    while (exp) {
-      pow *= (exp & 1) ? base : 1;
-      base *= base;
-      exp >>= 1;
-    }
-    return pow;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, T base, T exp, Status* st) {
-    if (exp < 0) {
-      *st = Status::Invalid("integers to negative integer powers are not allowed");
-      return 0;
-    }
-    return static_cast<T>(IntegerPower(base, exp));
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, T base, T exp, Status*) {
-    return std::pow(base, exp);
-  }
-};
-
-struct PowerChecked {
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_integer_value<T> Call(KernelContext*, Arg0 base, Arg1 exp,
-                                         Status* st) {
-    if (exp < 0) {
-      *st = Status::Invalid("integers to negative integer powers are not allowed");
-      return 0;
-    } else if (exp == 0) {
-      return 1;
-    }
-    // left to right O(logn) power with overflow checks
-    bool overflow = false;
-    uint64_t bitmask =
-        1ULL << (63 - bit_util::CountLeadingZeros(static_cast<uint64_t>(exp)));
-    T pow = 1;
-    while (bitmask) {
-      overflow |= MultiplyWithOverflow(pow, pow, &pow);
-      if (exp & bitmask) {
-        overflow |= MultiplyWithOverflow(pow, base, &pow);
-      }
-      bitmask >>= 1;
-    }
-    if (overflow) {
-      *st = Status::Invalid("overflow");
-    }
-    return pow;
-  }
-
-  template <typename T, typename Arg0, typename Arg1>
-  static enable_if_floating_value<T> Call(KernelContext*, Arg0 base, Arg1 exp, Status*) {
-    static_assert(std::is_same<T, Arg0>::value && std::is_same<T, Arg1>::value, "");
-    return std::pow(base, exp);
-  }
-};
-
-struct SquareRoot {
-  template <typename T, typename Arg>
-  static enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg, Status*) {
-    static_assert(std::is_same<T, Arg>::value, "");
-    if (arg < 0.0) {
-      return std::numeric_limits<T>::quiet_NaN();
-    }
-    return std::sqrt(arg);
-  }
-};
-
-struct SquareRootChecked {
-  template <typename T, typename Arg>
-  static enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg, Status* st) {
-    static_assert(std::is_same<T, Arg>::value, "");
-    if (arg < 0.0) {
-      *st = Status::Invalid("square root of negative number");
-      return arg;
-    }
-    return std::sqrt(arg);
-  }
-};
-
-struct Sign {
-  template <typename T, typename Arg>
-  static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                         Status*) {
-    return std::isnan(arg) ? arg : ((arg == 0) ? 0 : (std::signbit(arg) ? -1 : 1));
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_unsigned_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                                 Status*) {
-    return (arg > 0) ? 1 : 0;
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_signed_integer_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                               Status*) {
-    return (arg > 0) ? 1 : ((arg == 0) ? 0 : -1);
-  }
-
-  template <typename T, typename Arg>
-  static constexpr enable_if_decimal_value<Arg, T> Call(KernelContext*, Arg arg,
-                                                        Status*) {
-    return (arg == 0) ? 0 : arg.Sign();
-  }
-};
-
 // Bitwise operations
 
 struct BitWiseNot {
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index c811135f45b..37fc649d0d8 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -34,7 +34,8 @@ template <typename OptionsType>
 struct CumulativeOptionsWrapper : public OptionsWrapper<OptionsType> {
   using State = CumulativeOptionsWrapper<OptionsType>;
 
-  explicit CumulativeOptionsWrapper(OptionsType options) : OptionsWrapper<OptionsType>(std::move(options)) {}
+  explicit CumulativeOptionsWrapper(OptionsType options)
+      : OptionsWrapper<OptionsType>(std::move(options)) {}
 
   static Result<std::unique_ptr<KernelState>> Init(KernelContext* ctx,
                                                    const KernelInitArgs& args) {
@@ -51,7 +52,9 @@ struct CumulativeOptionsWrapper : public OptionsWrapper<OptionsType> {
 
     // Ensure `start` option matches input type
     if (!start->type->Equals(args.inputs[0].type)) {
-      ARROW_ASSIGN_OR_RAISE(auto casted_start, Cast(Datum(start), args.inputs[0].type));
+      ARROW_ASSIGN_OR_RAISE(auto casted_start,
+                            Cast(Datum(start), args.inputs[0].type, CastOptions::Safe(),
+                                 ctx->exec_context()));
       auto new_options = OptionsType(casted_start.scalar(), options->skip_nulls);
       return ::arrow::internal::make_unique<State>(new_options);
     }
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index d17dfe4d7f9..ad2ab53b24c 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -164,15 +164,13 @@ TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
 
 TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
   CumulativeSumOptions options = this->generate_options();
-  auto one_null = "[null]";
-  auto three_null = "[null, null, null]";
+  auto three_nulls = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
   auto expected = "[1, 3, null, null, null, null]";
   std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
   std::vector<std::string> chunked_expected = {"[1, 3, null, null, null, null]"};
 
-  this->Assert(one_null, one_null, options);
-  this->Assert(three_null, three_null, options);
+  this->Assert(three_nulls, three_nulls, options);
   this->Assert(values, expected, options);
   this->Assert(chunked_values, chunked_expected, options);
 }
@@ -192,15 +190,13 @@ TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
 
 TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
   CumulativeSumOptions options = this->generate_options(0, true);
-  auto one_null = "[null]";
-  auto three_null = "[null, null, null]";
+  auto three_nulls = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
   auto expected = "[1, 3, null, 7, null, 13]";
   std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
   std::vector<std::string> chunked_expected = {"[1, 3, null, 7, null, 13]"};
 
-  this->Assert(one_null, one_null, options);
-  this->Assert(three_null, three_null, options);
+  this->Assert(three_nulls, three_nulls, options);
   this->Assert(values, expected, options);
   this->Assert(chunked_values, chunked_expected, options);
 }
@@ -220,15 +216,13 @@ TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
 
 TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
   CumulativeSumOptions options = this->generate_options(10);
-  auto one_null = "[null]";
-  auto three_null = "[null, null, null]";
+  auto three_nulls = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
   auto expected = "[11, 13, null, null, null, null]";
   std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
   std::vector<std::string> chunked_expected = {"[11, 13, null, null, null, null]"};
 
-  this->Assert(one_null, one_null, options);
-  this->Assert(three_null, three_null, options);
+  this->Assert(three_nulls, three_nulls, options);
   this->Assert(values, expected, options);
   this->Assert(chunked_values, chunked_expected, options);
 }
@@ -248,15 +242,13 @@ TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
 
 TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
   CumulativeSumOptions options = this->generate_options(10, true);
-  auto one_null = "[null]";
-  auto three_null = "[null, null, null]";
+  auto three_nulls = "[null, null, null]";
   auto values = "[1, 2, null, 4, null, 6]";
   auto expected = "[11, 13, null, 17, null, 23]";
   std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
   std::vector<std::string> chunked_expected = {"[11, 13, null, 17, null, 23]"};
 
-  this->Assert(one_null, one_null, options);
-  this->Assert(three_null, three_null, options);
+  this->Assert(three_nulls, three_nulls, options);
   this->Assert(values, expected, options);
   this->Assert(chunked_values, chunked_expected, options);
 }

From b061ab45855faa45b87534314cbf73b1e0c0e933 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 14 Apr 2022 21:25:01 -0400
Subject: [PATCH 49/67] Change from Type-Parameterized to Value-Parameterized
 Tests

---
 .../kernels/vector_cumulative_ops_test.cc     | 298 +++++++-----------
 1 file changed, 112 insertions(+), 186 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index ad2ab53b24c..4dd613e2336 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -33,225 +33,151 @@
 namespace arrow {
 namespace compute {
 
-template <typename T, typename OptionsType>
 class TestCumulativeOp : public ::testing::Test {
- public:
-  using ArrowType = T;
-  using ScalarType = typename TypeTraits<T>::ScalarType;
-  using CType = typename TypeTraits<T>::CType;
-
  protected:
-  std::shared_ptr<DataType> type_singleton() { return default_type_instance<T>(); }
-
-  std::shared_ptr<Array> array(const std::string& values) {
-    return ArrayFromJSON(type_singleton(), values);
+  std::shared_ptr<Array> array(std::shared_ptr<DataType>& type,
+                               const std::string& values) {
+    return ArrayFromJSON(type, values);
   }
 
-  std::shared_ptr<ChunkedArray> chunked_array(const std::vector<std::string>& values) {
-    return ChunkedArrayFromJSON(type_singleton(), values);
+  std::shared_ptr<ChunkedArray> chunked_array(std::shared_ptr<DataType>& type,
+                                              const std::vector<std::string>& values) {
+    return ChunkedArrayFromJSON(type, values);
   }
 
-  template <typename V = T>
-  enable_if_t<!is_floating_type<V>::value, void> Assert(
-      const std::string func, const std::shared_ptr<Array>& input,
-      const std::shared_ptr<Array>& expected, const OptionsType& options) {
-    ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
-
-    AssertArraysEqual(*expected, *result.make_array(), false, EqualOptions::Defaults());
-  }
-
-  template <typename V = T>
-  enable_if_t<!is_floating_type<V>::value, void> Assert(
-      const std::string func, const std::shared_ptr<ChunkedArray>& input,
-      const std::shared_ptr<ChunkedArray>& expected, const OptionsType& options) {
-    ASSERT_OK_AND_ASSIGN(auto result,
-                         CallFunction(func, {Datum(input)}, &options, nullptr));
-
-    ChunkedArray actual(result.chunks(), this->type_singleton());
-    AssertChunkedEqual(*expected, actual);
-  }
-
-  template <typename V = T>
-  enable_if_floating_point<V> Assert(const std::string func,
-                                     const std::shared_ptr<Array>& input,
-                                     const std::shared_ptr<Array>& expected,
-                                     const OptionsType& options) {
+  template <typename OptionsType>
+  void Assert(const std::string func, const std::shared_ptr<Array>& input,
+              const std::shared_ptr<Array>& expected, const OptionsType& options) {
     ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
 
     AssertArraysApproxEqual(*expected, *result.make_array(), false,
                             EqualOptions::Defaults());
   }
 
-  template <typename V = T>
-  enable_if_floating_point<V> Assert(const std::string func,
-                                     const std::shared_ptr<ChunkedArray>& input,
-                                     const std::shared_ptr<ChunkedArray>& expected,
-                                     const OptionsType& options) {
+  template <typename OptionsType>
+  void Assert(std::shared_ptr<DataType>& type, const std::string func,
+              const std::shared_ptr<ChunkedArray>& input,
+              const std::shared_ptr<ChunkedArray>& expected, const OptionsType& options) {
     ASSERT_OK_AND_ASSIGN(auto result,
                          CallFunction(func, {Datum(input)}, &options, nullptr));
 
-    ChunkedArray actual(result.chunks(), this->type_singleton());
+    ChunkedArray actual(result.chunks(), type);
     AssertChunkedApproxEquivalent(*expected, actual, EqualOptions::Defaults());
   }
 };
 
-template <typename T>
-class TestCumulativeSum : public TestCumulativeOp<T, CumulativeSumOptions> {
- public:
-  using OptionsType = CumulativeSumOptions;
-  using ArrowType = typename TestCumulativeOp<T, OptionsType>::ArrowType;
-  using ScalarType = typename TestCumulativeOp<T, OptionsType>::ScalarType;
-  using CType = typename TestCumulativeOp<T, OptionsType>::CType;
+struct CumulativeSumParam {
+  std::string start;
+  bool skip_nulls;
+  std::shared_ptr<DataType> type;
+  std::string json_arrays_input_no_nulls;
+  std::string json_arrays_expected_no_nulls;
+  std::string json_arrays_input_with_nulls;
+  std::string json_arrays_expected_with_nulls;
+  std::vector<std::string> json_chunked_arrays_input_no_nulls;
+  std::vector<std::string> json_chunked_arrays_expected_no_nulls;
+  std::vector<std::string> json_chunked_arrays_input_with_nulls;
+  std::vector<std::string> json_chunked_arrays_expected_with_nulls;
+};
 
- protected:
-  template <typename U = T>
-  enable_if_parameter_free<U, OptionsType> generate_options(CType start = 0,
-                                                            bool skip_nulls = false,
-                                                            bool check_overflow = false) {
-    return OptionsType(std::make_shared<ScalarType>(start), skip_nulls, check_overflow);
+std::vector<CumulativeSumParam> GenerateCumulativeSumParams(
+    std::string start, bool skip_nulls, std::string json_arrays_input_no_nulls,
+    std::string json_arrays_expected_no_nulls, std::string json_arrays_input_with_nulls,
+    std::string json_arrays_expected_with_nulls,
+    std::vector<std::string> json_chunked_arrays_input_no_nulls,
+    std::vector<std::string> json_chunked_arrays_expected_no_nulls,
+    std::vector<std::string> json_chunked_arrays_input_with_nulls,
+    std::vector<std::string> json_chunked_arrays_expected_with_nulls) {
+  std::vector<CumulativeSumParam> param_vector;
+
+  for (auto ty : NumericTypes()) {
+    param_vector.push_back(
+        {start, skip_nulls, ty, json_arrays_input_no_nulls, json_arrays_expected_no_nulls,
+         json_arrays_input_with_nulls, json_arrays_expected_with_nulls,
+         json_chunked_arrays_input_no_nulls, json_chunked_arrays_expected_no_nulls,
+         json_chunked_arrays_input_with_nulls, json_chunked_arrays_expected_with_nulls});
   }
 
-  template <typename U = T>
-  enable_if_t<is_time_type<U>::value || is_timestamp_type<U>::value, OptionsType>
-  generate_options(CType start = 0, bool skip_nulls = false,
-                   bool check_overflow = false) {
-    TimeUnit::type unit;
-    switch (ArrowType::type_id) {
-      case Type::TIME64:
-        unit = TimeUnit::NANO;
-        break;
-      default:
-        unit = TimeUnit::SECOND;
-        break;
-    }
-    return OptionsType(std::make_shared<ScalarType>(start, unit), skip_nulls,
-                       check_overflow);
+  return param_vector;
+}
+
+class TestCumulativeSum : public TestCumulativeOp,
+                          public testing::WithParamInterface<CumulativeSumParam> {
+ protected:
+  CumulativeSumOptions generate_options(std::shared_ptr<DataType> type,
+                                        std::string start = "", bool skip_nulls = false,
+                                        bool check_overflow = false) {
+    return CumulativeSumOptions(ScalarFromJSON(type, start), skip_nulls, check_overflow);
   }
 
-  void Assert(const std::string& values, const std::string& expected,
-              const OptionsType& options) {
-    auto values_arr = TestCumulativeOp<T, OptionsType>::array(values);
-    auto expected_arr = TestCumulativeOp<T, OptionsType>::array(expected);
+  void Assert(std::shared_ptr<DataType> type, const std::string& values,
+              const std::string& expected, const CumulativeSumOptions& options) {
+    auto values_arr = TestCumulativeOp::array(type, values);
+    auto expected_arr = TestCumulativeOp::array(type, expected);
     auto func_name = options.check_overflow ? "cumulative_sum_checked" : "cumulative_sum";
-    TestCumulativeOp<T, OptionsType>::Assert(func_name, values_arr, expected_arr,
-                                             options);
+    TestCumulativeOp::Assert(func_name, values_arr, expected_arr, options);
   }
 
-  void Assert(const std::vector<std::string>& values,
-              const std::vector<std::string>& expected, const OptionsType& options) {
-    auto values_arr = TestCumulativeOp<T, OptionsType>::chunked_array(values);
-    auto expected_arr = TestCumulativeOp<T, OptionsType>::chunked_array(expected);
+  void Assert(std::shared_ptr<DataType> type, const std::vector<std::string>& values,
+              const std::vector<std::string>& expected,
+              const CumulativeSumOptions& options) {
+    auto values_arr = TestCumulativeOp::chunked_array(type, values);
+    auto expected_arr = TestCumulativeOp::chunked_array(type, expected);
     auto func_name = options.check_overflow ? "cumulative_sum_checked" : "cumulative_sum";
-    TestCumulativeOp<T, OptionsType>::Assert(func_name, values_arr, expected_arr,
-                                             options);
+    TestCumulativeOp::Assert(type, func_name, values_arr, expected_arr, options);
   }
 };
 
-TYPED_TEST_SUITE(TestCumulativeSum, NumericArrowTypes);
-
-TYPED_TEST(TestCumulativeSum, NoStartNoSkipNoNulls) {
-  CumulativeSumOptions options = this->generate_options();
-  auto empty = "[]";
-  auto values = "[1, 2, 3, 4, 5, 6]";
-  auto expected = "[1, 3, 6, 10, 15, 21]";
-  std::vector<std::string> chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
-  std::vector<std::string> chunked_expected = {"[1, 3, 6, 10, 15, 21]"};
-
-  this->Assert(empty, empty, options);
-  this->Assert(values, expected, options);
-  this->Assert(chunked_values, chunked_expected, options);
-}
-
-TYPED_TEST(TestCumulativeSum, NoStartNoSkipHasNulls) {
-  CumulativeSumOptions options = this->generate_options();
-  auto three_nulls = "[null, null, null]";
-  auto values = "[1, 2, null, 4, null, 6]";
-  auto expected = "[1, 3, null, null, null, null]";
-  std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
-  std::vector<std::string> chunked_expected = {"[1, 3, null, null, null, null]"};
-
-  this->Assert(three_nulls, three_nulls, options);
-  this->Assert(values, expected, options);
-  this->Assert(chunked_values, chunked_expected, options);
-}
-
-TYPED_TEST(TestCumulativeSum, NoStartDoSkipNoNulls) {
-  CumulativeSumOptions options = this->generate_options(0, true);
-  auto empty = "[]";
-  auto values = "[1, 2, 3, 4, 5, 6]";
-  auto expected = "[1, 3, 6, 10, 15, 21]";
-  std::vector<std::string> chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
-  std::vector<std::string> chunked_expected = {"[1, 3, 6, 10, 15, 21]"};
-
-  this->Assert(empty, empty, options);
-  this->Assert(values, expected, options);
-  this->Assert(chunked_values, chunked_expected, options);
+TEST_P(TestCumulativeSum, CheckResult) {
+  const CumulativeSumParam param = GetParam();
+  CumulativeSumOptions options =
+      this->generate_options(param.type, param.start, param.skip_nulls);
+
+  std::vector<std::string> empty_chunked_array;
+  this->Assert(param.type, "[]", "[]", options);
+  this->Assert(param.type, empty_chunked_array, empty_chunked_array, options);
+  this->Assert(param.type, "[null, null, null]", "[null, null, null]", options);
+  this->Assert(param.type, param.json_arrays_input_no_nulls,
+               param.json_arrays_expected_no_nulls, options);
+  this->Assert(param.type, param.json_arrays_input_with_nulls,
+               param.json_arrays_expected_with_nulls, options);
+  this->Assert(param.type, param.json_chunked_arrays_input_no_nulls,
+               param.json_chunked_arrays_expected_no_nulls, options);
+  this->Assert(param.type, param.json_chunked_arrays_input_with_nulls,
+               param.json_chunked_arrays_expected_with_nulls, options);
 }
 
-TYPED_TEST(TestCumulativeSum, NoStartDoSkipHasNulls) {
-  CumulativeSumOptions options = this->generate_options(0, true);
-  auto three_nulls = "[null, null, null]";
-  auto values = "[1, 2, null, 4, null, 6]";
-  auto expected = "[1, 3, null, 7, null, 13]";
-  std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
-  std::vector<std::string> chunked_expected = {"[1, 3, null, 7, null, 13]"};
-
-  this->Assert(three_nulls, three_nulls, options);
-  this->Assert(values, expected, options);
-  this->Assert(chunked_values, chunked_expected, options);
-}
-
-TYPED_TEST(TestCumulativeSum, HasStartNoSkipNoNulls) {
-  CumulativeSumOptions options = this->generate_options(10);
-  auto empty = "[]";
-  auto values = "[1, 2, 3, 4, 5, 6]";
-  auto expected = "[11, 13, 16, 20, 25, 31]";
-  std::vector<std::string> chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
-  std::vector<std::string> chunked_expected = {"[11, 13, 16, 20, 25, 31]"};
-
-  this->Assert(empty, empty, options);
-  this->Assert(values, expected, options);
-  this->Assert(chunked_values, chunked_expected, options);
-}
-
-TYPED_TEST(TestCumulativeSum, HasStartNoSkipHasNulls) {
-  CumulativeSumOptions options = this->generate_options(10);
-  auto three_nulls = "[null, null, null]";
-  auto values = "[1, 2, null, 4, null, 6]";
-  auto expected = "[11, 13, null, null, null, null]";
-  std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
-  std::vector<std::string> chunked_expected = {"[11, 13, null, null, null, null]"};
-
-  this->Assert(three_nulls, three_nulls, options);
-  this->Assert(values, expected, options);
-  this->Assert(chunked_values, chunked_expected, options);
-}
-
-TYPED_TEST(TestCumulativeSum, HasStartDoSkipNoNulls) {
-  CumulativeSumOptions options = this->generate_options(10, true);
-  auto empty = "[]";
-  auto values = "[1, 2, 3, 4, 5, 6]";
-  auto expected = "[11, 13, 16, 20, 25, 31]";
-  std::vector<std::string> chunked_values = {"[1, 2, 3]", "[4, 5, 6]"};
-  std::vector<std::string> chunked_expected = {"[11, 13, 16, 20, 25, 31]"};
-
-  this->Assert(empty, empty, options);
-  this->Assert(values, expected, options);
-  this->Assert(chunked_values, chunked_expected, options);
-}
-
-TYPED_TEST(TestCumulativeSum, HasStartDoSkipHasNulls) {
-  CumulativeSumOptions options = this->generate_options(10, true);
-  auto three_nulls = "[null, null, null]";
-  auto values = "[1, 2, null, 4, null, 6]";
-  auto expected = "[11, 13, null, 17, null, 23]";
-  std::vector<std::string> chunked_values = {"[1, 2, null]", "[4, null, 6]"};
-  std::vector<std::string> chunked_expected = {"[11, 13, null, 17, null, 23]"};
-
-  this->Assert(three_nulls, three_nulls, options);
-  this->Assert(values, expected, options);
-  this->Assert(chunked_values, chunked_expected, options);
-}
+INSTANTIATE_TEST_SUITE_P(NoStartNoSkip, TestCumulativeSum,
+                         ::testing::ValuesIn(GenerateCumulativeSumParams(
+                             "0", false, "[1, 2, 3, 4, 5, 6]", "[1, 3, 6, 10, 15, 21]",
+                             "[1, 2, null, 4, null, 6]", "[1, 3, null, null, null, null]",
+                             {"[1, 2, 3]", "[4, 5, 6]"}, {"[1, 3, 6, 10, 15, 21]"},
+                             {"[1, 2, null]", "[4, null, 6]"},
+                             {"[1, 3, null, null, null, null]"})));
+
+INSTANTIATE_TEST_SUITE_P(NoStartDoSkip, TestCumulativeSum,
+                         ::testing::ValuesIn(GenerateCumulativeSumParams(
+                             "0", true, "[1, 2, 3, 4, 5, 6]", "[1, 3, 6, 10, 15, 21]",
+                             "[1, 2, null, 4, null, 6]", "[1, 3, null, 7, null, 13]",
+                             {"[1, 2, 3]", "[4, 5, 6]"}, {"[1, 3, 6, 10, 15, 21]"},
+                             {"[1, 2, null]", "[4, null, 6]"},
+                             {"[1, 3, null, 7, null, 13]"})));
+
+INSTANTIATE_TEST_SUITE_P(
+    HasStartNoSkip, TestCumulativeSum,
+    ::testing::ValuesIn(GenerateCumulativeSumParams(
+        "10", false, "[1, 2, 3, 4, 5, 6]", "[11, 13, 16, 20, 25, 31]",
+        "[1, 2, null, 4, null, 6]", "[11, 13, null, null, null, null]",
+        {"[1, 2, 3]", "[4, 5, 6]"}, {"[11, 13, 16, 20, 25, 31]"},
+        {"[1, 2, null]", "[4, null, 6]"}, {"[11, 13, null, null, null, null]"})));
+
+INSTANTIATE_TEST_SUITE_P(HasStartDoSkip, TestCumulativeSum,
+                         ::testing::ValuesIn(GenerateCumulativeSumParams(
+                             "10", true, "[1, 2, 3, 4, 5, 6]", "[11, 13, 16, 20, 25, 31]",
+                             "[1, 2, null, 4, null, 6]", "[11, 13, null, 17, null, 23]",
+                             {"[1, 2, 3]", "[4, 5, 6]"}, {"[11, 13, 16, 20, 25, 31]"},
+                             {"[1, 2, null]", "[4, null, 6]"},
+                             {"[11, 13, null, 17, null, 23]"})));
 
 }  // namespace compute
 }  // namespace arrow

From 84bdcd76ba01b430f6e9ed623d44e45760109fbd Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 15 Apr 2022 18:32:03 -0400
Subject: [PATCH 50/67] Including minor suggestions

---
 cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc | 4 ++--
 docs/source/python/api/compute.rst                     | 7 +++----
 python/pyarrow/_compute.pyx                            | 2 +-
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 37fc649d0d8..1cba00fd8e3 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -66,7 +66,7 @@ struct CumulativeOptionsWrapper : public OptionsWrapper<OptionsType> {
 // representing any binary associative operation (add, product, min, max, etc.) and
 // OptionsType the options type corresponding to Op. ArgType and OutType are the input
 // and output types, which will normally be the same (e.g. the cumulative sum of an array
-//  of Int64Type will result in an array of Int64Type).
+// of Int64Type will result in an array of Int64Type).
 template <typename OutType, typename ArgType, typename Op, typename OptionsType>
 struct CumulativeGeneric {
   using OutValue = typename GetOutputType<OutType>::T;
@@ -124,7 +124,7 @@ struct CumulativeGeneric {
       ++curr;
     };
 
-    if (skip_nulls) {
+    if (skip_nulls || input.GetNullCount() == 0) {
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
diff --git a/docs/source/python/api/compute.rst b/docs/source/python/api/compute.rst
index d85344740ff..1bef47f6ae2 100644
--- a/docs/source/python/api/compute.rst
+++ b/docs/source/python/api/compute.rst
@@ -48,9 +48,9 @@ Aggregations
 Cumulative Functions
 --------------------
 
-Cumulative functions are vector functions that perform a running total on its
-input and outputs an array containing the corresponding intermediate running values.
-By default these functions do not detect overflow. Most functions are also
+Cumulative functions are vector functions that perform a running total on their
+input and output an array containing the corresponding intermediate running values.
+By default these functions do not detect overflow. They are also
 available in an overflow-checking variant, suffixed ``_checked``, which
 throws an ``ArrowInvalid`` exception when overflow is detected.
 
@@ -494,7 +494,6 @@ Structural Transforms
 .. autosummary::
    :toctree: ../generated/
 
-   cumulative_sum
    fill_null_backward
    fill_null_forward
    list_element
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 496d6d2a686..273f1cc422d 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1757,7 +1757,7 @@ class CumulativeSumOptions(_CumulativeSumOptions):
     start : Scalar, default 0.0
         Starting value for sum computation
     skip_nulls : bool, default False
-        When false, propagates the first null encountered.
+        When false, the first encountered null is propagated.
     """
 
     def __init__(self, start=0.0, *, skip_nulls=False):

From 4e588570c5eecf3291a750bd549b2e7fdf3c635a Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 20 Apr 2022 16:12:36 -0400
Subject: [PATCH 51/67] Cumulative operations now trivially processes Scalar
 inputs

---
 .../compute/kernels/vector_cumulative_ops.cc  | 60 +++++++++----------
 1 file changed, 27 insertions(+), 33 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 1cba00fd8e3..ad255e243c2 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include "arrow/array/array_base.h"
+#include "arrow/array/builder_primitive.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/cast.h"
@@ -76,52 +77,53 @@ struct CumulativeGeneric {
     const auto& options = CumulativeOptionsWrapper<OptionsType>::Get(ctx);
     auto start = UnboxScalar<OutType>::Unbox(*(options.start));
     auto skip_nulls = options.skip_nulls;
-
-    int64_t base_output_offset = 0;
     bool encountered_null = false;
-    ArrayData* out_arr = out->mutable_array();
+
+    std::shared_ptr<ArrayData> out_arr;
+    NumericBuilder<OutType> builder;
 
     switch (batch[0].kind()) {
+      case Datum::SCALAR: {
+        auto in_value = UnboxScalar<OutType>::Unbox(*(batch[0].scalar()));
+        builder.Append(start + in_value);
+        break;
+      }
       case Datum::ARRAY: {
-        auto st = Call(ctx, base_output_offset, *batch[0].array(), out_arr, &start,
-                       skip_nulls, &encountered_null);
-        out_arr->SetNullCount(arrow::kUnknownNullCount);
-        return st;
+        auto input = batch[0].array();
+
+        RETURN_NOT_OK(Call(ctx, *input, builder, &start, skip_nulls, &encountered_null));
+        break;
       }
       case Datum::CHUNKED_ARRAY: {
         const auto& input = batch[0].chunked_array();
 
         for (const auto& chunk : input->chunks()) {
-          RETURN_NOT_OK(Call(ctx, base_output_offset, *chunk->data(), out_arr, &start,
-                             skip_nulls, &encountered_null));
-          base_output_offset += chunk->length();
+          RETURN_NOT_OK(
+              Call(ctx, *chunk->data(), builder, &start, skip_nulls, &encountered_null));
         }
-        out_arr->SetNullCount(arrow::kUnknownNullCount);
-        return Status::OK();
+        break;
       }
       default:
         return Status::NotImplemented(
             "Unsupported input type for function 'cumulative_<operator>': ",
             batch[0].ToString());
     }
+
+    RETURN_NOT_OK(builder.FinishInternal(&out_arr));
+    out->value = std::move(out_arr);
+    return Status::OK();
   }
 
-  static Status Call(KernelContext* ctx, int64_t base_output_offset,
-                     const ArrayData& input, ArrayData* output, ArgValue* accumulator,
+  static Status Call(KernelContext* ctx, const ArrayData& input,
+                     NumericBuilder<OutType>& builder, ArgValue* accumulator,
                      bool skip_nulls, bool* encountered_null) {
     Status st = Status::OK();
     ArgValue accumulator_tmp = *accumulator;
     bool encountered_null_tmp = *encountered_null;
 
-    auto out_bitmap = output->GetMutableValues<uint8_t>(0);
-    auto out_data = output->GetMutableValues<OutValue>(1) + base_output_offset;
-    int64_t curr = base_output_offset;
-
     auto null_func = [&]() {
-      *out_data++ = OutValue{};
+      builder.AppendNull();
       encountered_null_tmp = true;
-      arrow::bit_util::SetBitTo(out_bitmap, curr, false);
-      ++curr;
     };
 
     if (skip_nulls || input.GetNullCount() == 0) {
@@ -130,30 +132,22 @@ struct CumulativeGeneric {
           [&](ArgValue v) {
             accumulator_tmp = Op::template Call<OutValue, ArgValue, ArgValue>(
                 ctx, v, accumulator_tmp, &st);
-            *out_data++ = accumulator_tmp;
-            ++curr;
+            builder.Append(accumulator_tmp);
           },
           null_func);
     } else {
-      auto start_null_idx = 0;
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
             if (encountered_null_tmp) {
-              *out_data++ = OutValue{};
+              builder.AppendNull();
             } else {
               accumulator_tmp = Op::template Call<OutValue, ArgValue, ArgValue>(
                   ctx, v, accumulator_tmp, &st);
-              *out_data++ = accumulator_tmp;
-              ++start_null_idx;
+              builder.Append(accumulator_tmp);
             }
-            ++curr;
           },
           null_func);
-
-      auto null_length = input.length - start_null_idx;
-      arrow::bit_util::SetBitsTo(out_bitmap, base_output_offset + start_null_idx,
-                                 null_length, false);
     }
 
     *accumulator = accumulator_tmp;
@@ -196,7 +190,7 @@ void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string
     VectorKernel kernel;
     kernel.can_execute_chunkwise = false;
     kernel.null_handling = NullHandling::type::INTERSECTION;
-    kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
+    kernel.mem_allocation = MemAllocation::type::NO_PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
     kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Op, OptionsType>(ty);
     kernel.init = CumulativeOptionsWrapper<OptionsType>::Init;

From 6509bef8ad218a227cce5f5f8ed639dcc5df2661 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Wed, 20 Apr 2022 17:47:21 -0400
Subject: [PATCH 52/67] Fixing missed linting issue and handling

---
 cpp/src/arrow/compute/kernels/scalar_arithmetic.cc     |  2 +-
 cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 8bd72dfa7a6..b0055a019bd 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -24,8 +24,8 @@
 
 #include "arrow/compare.h"
 #include "arrow/compute/api_scalar.h"
-#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/compute/cast.h"
+#include "arrow/compute/kernels/base_arithmetic_internal.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/util_internal.h"
 #include "arrow/type.h"
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index ad255e243c2..d87968d2e99 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -85,7 +85,7 @@ struct CumulativeGeneric {
     switch (batch[0].kind()) {
       case Datum::SCALAR: {
         auto in_value = UnboxScalar<OutType>::Unbox(*(batch[0].scalar()));
-        builder.Append(start + in_value);
+        RETURN_NOT_OK(builder.Append(start + in_value));
         break;
       }
       case Datum::ARRAY: {
@@ -122,7 +122,7 @@ struct CumulativeGeneric {
     bool encountered_null_tmp = *encountered_null;
 
     auto null_func = [&]() {
-      builder.AppendNull();
+      st &= builder.AppendNull();
       encountered_null_tmp = true;
     };
 
@@ -132,7 +132,7 @@ struct CumulativeGeneric {
           [&](ArgValue v) {
             accumulator_tmp = Op::template Call<OutValue, ArgValue, ArgValue>(
                 ctx, v, accumulator_tmp, &st);
-            builder.Append(accumulator_tmp);
+            st &= builder.Append(accumulator_tmp);
           },
           null_func);
     } else {
@@ -140,11 +140,11 @@ struct CumulativeGeneric {
           input,
           [&](ArgValue v) {
             if (encountered_null_tmp) {
-              builder.AppendNull();
+              st &= builder.AppendNull();
             } else {
               accumulator_tmp = Op::template Call<OutValue, ArgValue, ArgValue>(
                   ctx, v, accumulator_tmp, &st);
-              builder.Append(accumulator_tmp);
+              st &= builder.Append(accumulator_tmp);
             }
           },
           null_func);

From c596d17655d55753947b40c98c970df76ae823a4 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 21 Apr 2022 14:44:33 -0400
Subject: [PATCH 53/67] Correcting logic for handling chunked arrays

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

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index d87968d2e99..4b47defaaf9 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -126,7 +126,7 @@ struct CumulativeGeneric {
       encountered_null_tmp = true;
     };
 
-    if (skip_nulls || input.GetNullCount() == 0) {
+    if (skip_nulls || (input.GetNullCount() == 0 && !encountered_null_tmp)) {
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {

From 16c448981b5eabedb58ef1603c3b0dea66ea9683 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 21 Apr 2022 17:28:36 -0400
Subject: [PATCH 54/67] Adding C++ documentation for Cumulative Functions

---
 docs/source/cpp/compute.rst | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index cb1fde7a31a..257cf580497 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1546,6 +1546,30 @@ random generator.
 Array-wise ("vector") functions
 -------------------------------
 
+Cumulative Functions
+~~~~~~~~~~~~~~~~~~~~
+
+Cumulative functions are vector functions that perform a running total on their
+input using an given binary associatve operation and output an array containing
+the corresponding intermediate running values. The input is expected to be of
+numeric type. By default these functions do not detect overflow. They are also
+available in an overflow-checking variant, suffixed ``_checked``, which returns
+an ``Invalid`` :class:`Status` when overflow is detected.
+
++------------------------+-------+-------------+-------------+--------------------------------+-------+
+| Function name          | Arity | Input types | Output type | Options class                  | Notes |
++========================+=======+=============+=============+================================+=======+
+| cumulative_sum         | Unary | Numeric     | Numeric     | :struct:`CumulativeSumOptions` | \(1)  |
++------------------------+-------+-------------+-------------+--------------------------------+-------+
+| cumulative_sum_checked | Unary | Numeric     | Numeric     | :struct:`CumulativeSumOptions` | \(1)  |
++------------------------+-------+-------------+-------------+--------------------------------+-------+
+
+* \(1) CumulativeSumOptions has two optional parameters. The first is
+  :member:`CumulativeSumOptions::start`, which is an optional starting value for
+  the running sum with the same type as the input. start has and default value
+  of 0. The second parameter is :member:`CumulativeSumOptions::skip_nulls`, which
+  is a boolean that when set to false, the first encountered null is propagated.
+
 Associative transforms
 ~~~~~~~~~~~~~~~~~~~~~~
 

From e8be46a29a7b4c60f55db60e4e75fa1039f8e600 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Mon, 25 Apr 2022 13:49:58 -0400
Subject: [PATCH 55/67] Editting wording of C++ documentation

---
 docs/source/cpp/compute.rst | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 257cf580497..5ca3d2ad8c4 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1564,11 +1564,13 @@ an ``Invalid`` :class:`Status` when overflow is detected.
 | cumulative_sum_checked | Unary | Numeric     | Numeric     | :struct:`CumulativeSumOptions` | \(1)  |
 +------------------------+-------+-------------+-------------+--------------------------------+-------+
 
-* \(1) CumulativeSumOptions has two optional parameters. The first is
-  :member:`CumulativeSumOptions::start`, which is an optional starting value for
-  the running sum with the same type as the input. start has and default value
-  of 0. The second parameter is :member:`CumulativeSumOptions::skip_nulls`, which
-  is a boolean that when set to false, the first encountered null is propagated.
+* \(1) CumulativeSumOptions has two optional parameters. The first parameter
+  :member:`CumulativeSumOptions::start` is a starting value for the running
+  sum. It has a default value of 0. Specified values of ``start`` must have the
+  same type as the input. The second parameter 
+  :member:`CumulativeSumOptions::skip_nulls` is a boolean. When set to
+  false (the default), the first encountered null is propagated. When set to
+  true, each null in the input produces a corresponding null in the output.
 
 Associative transforms
 ~~~~~~~~~~~~~~~~~~~~~~

From f8251300571bb602ed69e95f90f1be60de14e5b4 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 26 Apr 2022 12:13:40 -0400
Subject: [PATCH 56/67] Updating wording of function doc

---
 .../compute/kernels/vector_cumulative_ops.cc  | 21 +++++++++----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 4b47defaaf9..4ff4c46a861 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -157,21 +157,20 @@ struct CumulativeGeneric {
 };
 
 const FunctionDoc cumulative_sum_doc{
-    "Compute the cumulative sum over an array/chunked array of numbers",
-    ("`values` must be an array/chunked array of numeric type values.\n"
-     "Return an array/chunked array which is the cumulative sum computed\n"
-     "over `values`. Results will wrap around on integer overflow.\n"
-     "Use function \"cumulative_sum_checked\" if you want overflow\n"
-     "to return an error."),
+    "Computes the cumulative sum over a numeric input.",
+    ("`values` must be numeric. Return an array/chunked array which is the\n"
+     "cumulative sum computed over `values`. Results will wrap around on\n"
+     "integer overflow. Use function \"cumulative_sum_checked\" if you want\n"
+     "overflow to return an error."),
     {"values"},
     "CumulativeSumOptions"};
 
 const FunctionDoc cumulative_sum_checked_doc{
-    "Compute the cumulative sum over an array/chunked array of numbers",
-    ("`values` must be an array/chunked array of numeric type values.\n"
-     "Return an array/chunked array which is the cumulative sum computed\n"
-     "over `values`. This function returns an error on overflow. For a\n"
-     "variant that doesn't fail on overflow, use function \"cumulative_sum\"."),
+    "Computes the cumulative sum over a numeric input.",
+    ("`values` must be numeric. Return an array/chunked array which is the\n"
+     "cumulative sum computed over `values`. This function returns an error\n"
+     "on overflow. For a variant that doesn't fail on overflow, use\n"
+     "function \"cumulative_sum\"."),
     {"values"},
     "CumulativeSumOptions"};
 }  // namespace

From 9d1f44f2630722fcfb39839de08573a1836b167a Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 26 Apr 2022 12:38:05 -0400
Subject: [PATCH 57/67] Removed period at end of function doc summary

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

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 4ff4c46a861..b233acb0da3 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -157,7 +157,7 @@ struct CumulativeGeneric {
 };
 
 const FunctionDoc cumulative_sum_doc{
-    "Computes the cumulative sum over a numeric input.",
+    "Computes the cumulative sum over a numeric input",
     ("`values` must be numeric. Return an array/chunked array which is the\n"
      "cumulative sum computed over `values`. Results will wrap around on\n"
      "integer overflow. Use function \"cumulative_sum_checked\" if you want\n"
@@ -166,7 +166,7 @@ const FunctionDoc cumulative_sum_doc{
     "CumulativeSumOptions"};
 
 const FunctionDoc cumulative_sum_checked_doc{
-    "Computes the cumulative sum over a numeric input.",
+    "Computes the cumulative sum over a numeric input",
     ("`values` must be numeric. Return an array/chunked array which is the\n"
      "cumulative sum computed over `values`. This function returns an error\n"
      "on overflow. For a variant that doesn't fail on overflow, use\n"

From 1f2df7cb60d56b29eb514e6c52bf6c72f1dae974 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 29 Apr 2022 15:49:54 -0400
Subject: [PATCH 58/67] Using non-parameterized tests

---
 .../kernels/vector_cumulative_ops_test.cc     | 238 +++++++++---------
 1 file changed, 112 insertions(+), 126 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 4dd613e2336..356988312b2 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -33,151 +33,137 @@
 namespace arrow {
 namespace compute {
 
-class TestCumulativeOp : public ::testing::Test {
- protected:
-  std::shared_ptr<Array> array(std::shared_ptr<DataType>& type,
-                               const std::string& values) {
-    return ArrayFromJSON(type, values);
-  }
+void Assert(const std::string func, const std::shared_ptr<Scalar>& input,
+            const std::shared_ptr<Array>& expected, const FunctionOptions& options) {
+  ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
 
-  std::shared_ptr<ChunkedArray> chunked_array(std::shared_ptr<DataType>& type,
-                                              const std::vector<std::string>& values) {
-    return ChunkedArrayFromJSON(type, values);
-  }
+  AssertArraysApproxEqual(*expected, *result.make_array(), false,
+                          EqualOptions::Defaults());
+}
 
-  template <typename OptionsType>
-  void Assert(const std::string func, const std::shared_ptr<Array>& input,
-              const std::shared_ptr<Array>& expected, const OptionsType& options) {
-    ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
+void Assert(const std::string func, const std::shared_ptr<Array>& input,
+            const std::shared_ptr<Array>& expected, const FunctionOptions& options) {
+  ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
 
-    AssertArraysApproxEqual(*expected, *result.make_array(), false,
-                            EqualOptions::Defaults());
-  }
+  AssertArraysApproxEqual(*expected, *result.make_array(), false,
+                          EqualOptions::Defaults());
+}
+
+void Assert(const std::string func, std::shared_ptr<DataType>& type,
+            const std::shared_ptr<ChunkedArray>& input,
+            const std::shared_ptr<ChunkedArray>& expected,
+            const FunctionOptions& options) {
+  ASSERT_OK_AND_ASSIGN(auto result,
+                       CallFunction(func, {Datum(input)}, &options, nullptr));
 
-  template <typename OptionsType>
-  void Assert(std::shared_ptr<DataType>& type, const std::string func,
-              const std::shared_ptr<ChunkedArray>& input,
-              const std::shared_ptr<ChunkedArray>& expected, const OptionsType& options) {
-    ASSERT_OK_AND_ASSIGN(auto result,
-                         CallFunction(func, {Datum(input)}, &options, nullptr));
+  ChunkedArray actual(result.chunks(), type);
+  AssertChunkedApproxEquivalent(*expected, actual, EqualOptions::Defaults());
+}
 
-    ChunkedArray actual(result.chunks(), type);
-    AssertChunkedApproxEquivalent(*expected, actual, EqualOptions::Defaults());
+TEST(TestCumulativeSum, Empty) {
+  CumulativeSumOptions options;
+  for (auto ty : NumericTypes()) {
+    auto empty_arr = ArrayFromJSON(ty, "[]");
+    auto empty_chunked = ChunkedArrayFromJSON(ty, {"[]"});
+    Assert("cumulative_sum", empty_arr, empty_arr, options);
+    Assert("cumulative_sum", ty, empty_chunked, empty_chunked, options);
   }
-};
-
-struct CumulativeSumParam {
-  std::string start;
-  bool skip_nulls;
-  std::shared_ptr<DataType> type;
-  std::string json_arrays_input_no_nulls;
-  std::string json_arrays_expected_no_nulls;
-  std::string json_arrays_input_with_nulls;
-  std::string json_arrays_expected_with_nulls;
-  std::vector<std::string> json_chunked_arrays_input_no_nulls;
-  std::vector<std::string> json_chunked_arrays_expected_no_nulls;
-  std::vector<std::string> json_chunked_arrays_input_with_nulls;
-  std::vector<std::string> json_chunked_arrays_expected_with_nulls;
-};
-
-std::vector<CumulativeSumParam> GenerateCumulativeSumParams(
-    std::string start, bool skip_nulls, std::string json_arrays_input_no_nulls,
-    std::string json_arrays_expected_no_nulls, std::string json_arrays_input_with_nulls,
-    std::string json_arrays_expected_with_nulls,
-    std::vector<std::string> json_chunked_arrays_input_no_nulls,
-    std::vector<std::string> json_chunked_arrays_expected_no_nulls,
-    std::vector<std::string> json_chunked_arrays_input_with_nulls,
-    std::vector<std::string> json_chunked_arrays_expected_with_nulls) {
-  std::vector<CumulativeSumParam> param_vector;
+}
 
+TEST(TestCumulativeSum, AllNulls) {
+  CumulativeSumOptions options;
   for (auto ty : NumericTypes()) {
-    param_vector.push_back(
-        {start, skip_nulls, ty, json_arrays_input_no_nulls, json_arrays_expected_no_nulls,
-         json_arrays_input_with_nulls, json_arrays_expected_with_nulls,
-         json_chunked_arrays_input_no_nulls, json_chunked_arrays_expected_no_nulls,
-         json_chunked_arrays_input_with_nulls, json_chunked_arrays_expected_with_nulls});
+    auto nulls_arr = ArrayFromJSON(ty, "[null, null, null]");
+    auto nulls_one_chunk = ChunkedArrayFromJSON(ty, {"[null, null, null]"});
+    auto nulls_three_chunks = ChunkedArrayFromJSON(ty, {"[null]", "[null]", "[null]"});
+    Assert("cumulative_sum", nulls_arr, nulls_arr, options);
+    Assert("cumulative_sum", ty, nulls_one_chunk, nulls_one_chunk, options);
+    Assert("cumulative_sum", ty, nulls_three_chunks, nulls_one_chunk, options);
   }
+}
 
-  return param_vector;
+TEST(TestCumulativeSum, ScalarInput) {
+  CumulativeSumOptions no_start;
+  CumulativeSumOptions with_start(10);
+  for (auto ty : NumericTypes()) {
+    Assert("cumulative_sum", ScalarFromJSON(ty, "10"), ArrayFromJSON(ty, "[10]"),
+           no_start);
+    Assert("cumulative_sum", ScalarFromJSON(ty, "10"), ArrayFromJSON(ty, "[20]"),
+           with_start);
+  }
 }
 
-class TestCumulativeSum : public TestCumulativeOp,
-                          public testing::WithParamInterface<CumulativeSumParam> {
- protected:
-  CumulativeSumOptions generate_options(std::shared_ptr<DataType> type,
-                                        std::string start = "", bool skip_nulls = false,
-                                        bool check_overflow = false) {
-    return CumulativeSumOptions(ScalarFromJSON(type, start), skip_nulls, check_overflow);
+TEST(TestCumulativeSum, NoStartNoSkip) {
+  CumulativeSumOptions options;
+  for (auto ty : NumericTypes()) {
+    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+           ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), options);
+
+    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+           ArrayFromJSON(ty, "[1, 3, null, null, null, null]"), options);
+
+    Assert("cumulative_sum", ty, ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+           ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), options);
+
+    Assert("cumulative_sum", ty,
+           ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+           ChunkedArrayFromJSON(ty, {"[1, 3, null, null, null, null]"}), options);
   }
+}
+
+TEST(TestCumulativeSum, NoStartDoSkip) {
+  CumulativeSumOptions options(0, true);
+  for (auto ty : NumericTypes()) {
+    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+           ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), options);
+
+    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+           ArrayFromJSON(ty, "[1, 3, null, 7, null, 13]"), options);
 
-  void Assert(std::shared_ptr<DataType> type, const std::string& values,
-              const std::string& expected, const CumulativeSumOptions& options) {
-    auto values_arr = TestCumulativeOp::array(type, values);
-    auto expected_arr = TestCumulativeOp::array(type, expected);
-    auto func_name = options.check_overflow ? "cumulative_sum_checked" : "cumulative_sum";
-    TestCumulativeOp::Assert(func_name, values_arr, expected_arr, options);
+    Assert("cumulative_sum", ty, ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+           ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), options);
+
+    Assert("cumulative_sum", ty,
+           ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+           ChunkedArrayFromJSON(ty, {"[1, 3, null, 7, null, 13]"}), options);
   }
+}
+
+TEST(TestCumulativeSum, HasStartNoSkip) {
+  CumulativeSumOptions options(10);
+  for (auto ty : NumericTypes()) {
+    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+           ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), options);
 
-  void Assert(std::shared_ptr<DataType> type, const std::vector<std::string>& values,
-              const std::vector<std::string>& expected,
-              const CumulativeSumOptions& options) {
-    auto values_arr = TestCumulativeOp::chunked_array(type, values);
-    auto expected_arr = TestCumulativeOp::chunked_array(type, expected);
-    auto func_name = options.check_overflow ? "cumulative_sum_checked" : "cumulative_sum";
-    TestCumulativeOp::Assert(type, func_name, values_arr, expected_arr, options);
+    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+           ArrayFromJSON(ty, "[11, 13, null, null, null, null]"), options);
+
+    Assert("cumulative_sum", ty, ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+           ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), options);
+
+    Assert("cumulative_sum", ty,
+           ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+           ChunkedArrayFromJSON(ty, {"[11, 13, null, null, null, null]"}), options);
   }
-};
-
-TEST_P(TestCumulativeSum, CheckResult) {
-  const CumulativeSumParam param = GetParam();
-  CumulativeSumOptions options =
-      this->generate_options(param.type, param.start, param.skip_nulls);
-
-  std::vector<std::string> empty_chunked_array;
-  this->Assert(param.type, "[]", "[]", options);
-  this->Assert(param.type, empty_chunked_array, empty_chunked_array, options);
-  this->Assert(param.type, "[null, null, null]", "[null, null, null]", options);
-  this->Assert(param.type, param.json_arrays_input_no_nulls,
-               param.json_arrays_expected_no_nulls, options);
-  this->Assert(param.type, param.json_arrays_input_with_nulls,
-               param.json_arrays_expected_with_nulls, options);
-  this->Assert(param.type, param.json_chunked_arrays_input_no_nulls,
-               param.json_chunked_arrays_expected_no_nulls, options);
-  this->Assert(param.type, param.json_chunked_arrays_input_with_nulls,
-               param.json_chunked_arrays_expected_with_nulls, options);
 }
 
-INSTANTIATE_TEST_SUITE_P(NoStartNoSkip, TestCumulativeSum,
-                         ::testing::ValuesIn(GenerateCumulativeSumParams(
-                             "0", false, "[1, 2, 3, 4, 5, 6]", "[1, 3, 6, 10, 15, 21]",
-                             "[1, 2, null, 4, null, 6]", "[1, 3, null, null, null, null]",
-                             {"[1, 2, 3]", "[4, 5, 6]"}, {"[1, 3, 6, 10, 15, 21]"},
-                             {"[1, 2, null]", "[4, null, 6]"},
-                             {"[1, 3, null, null, null, null]"})));
-
-INSTANTIATE_TEST_SUITE_P(NoStartDoSkip, TestCumulativeSum,
-                         ::testing::ValuesIn(GenerateCumulativeSumParams(
-                             "0", true, "[1, 2, 3, 4, 5, 6]", "[1, 3, 6, 10, 15, 21]",
-                             "[1, 2, null, 4, null, 6]", "[1, 3, null, 7, null, 13]",
-                             {"[1, 2, 3]", "[4, 5, 6]"}, {"[1, 3, 6, 10, 15, 21]"},
-                             {"[1, 2, null]", "[4, null, 6]"},
-                             {"[1, 3, null, 7, null, 13]"})));
-
-INSTANTIATE_TEST_SUITE_P(
-    HasStartNoSkip, TestCumulativeSum,
-    ::testing::ValuesIn(GenerateCumulativeSumParams(
-        "10", false, "[1, 2, 3, 4, 5, 6]", "[11, 13, 16, 20, 25, 31]",
-        "[1, 2, null, 4, null, 6]", "[11, 13, null, null, null, null]",
-        {"[1, 2, 3]", "[4, 5, 6]"}, {"[11, 13, 16, 20, 25, 31]"},
-        {"[1, 2, null]", "[4, null, 6]"}, {"[11, 13, null, null, null, null]"})));
-
-INSTANTIATE_TEST_SUITE_P(HasStartDoSkip, TestCumulativeSum,
-                         ::testing::ValuesIn(GenerateCumulativeSumParams(
-                             "10", true, "[1, 2, 3, 4, 5, 6]", "[11, 13, 16, 20, 25, 31]",
-                             "[1, 2, null, 4, null, 6]", "[11, 13, null, 17, null, 23]",
-                             {"[1, 2, 3]", "[4, 5, 6]"}, {"[11, 13, 16, 20, 25, 31]"},
-                             {"[1, 2, null]", "[4, null, 6]"},
-                             {"[11, 13, null, 17, null, 23]"})));
+TEST(TestCumulativeSum, HasStartDoSkip) {
+  CumulativeSumOptions options(10, true);
+  for (auto ty : NumericTypes()) {
+    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+           ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), options);
+
+    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+           ArrayFromJSON(ty, "[11, 13, null, 17, null, 23]"), options);
+
+    Assert("cumulative_sum", ty, ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+           ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), options);
+
+    Assert("cumulative_sum", ty,
+           ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+           ChunkedArrayFromJSON(ty, {"[11, 13, null, 17, null, 23]"}), options);
+  }
+}
 
 }  // namespace compute
 }  // namespace arrow

From b04f898ae265a54e79aaccb2d7de48265cadc874 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 3 May 2022 18:43:50 -0400
Subject: [PATCH 59/67] Reserving memory up front for CumulativeGeneric and
 correcting Scalar case

---
 .../compute/kernels/vector_cumulative_ops.cc  | 111 ++++++++++--------
 1 file changed, 64 insertions(+), 47 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index b233acb0da3..c025f3a130e 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -40,7 +40,7 @@ struct CumulativeOptionsWrapper : public OptionsWrapper<OptionsType> {
 
   static Result<std::unique_ptr<KernelState>> Init(KernelContext* ctx,
                                                    const KernelInitArgs& args) {
-    auto options = static_cast<const OptionsType*>(args.options);
+    auto options = checked_cast<const OptionsType*>(args.options);
     if (!options) {
       return Status::Invalid(
           "Attempted to initialize KernelState from null FunctionOptions");
@@ -73,87 +73,104 @@ struct CumulativeGeneric {
   using OutValue = typename GetOutputType<OutType>::T;
   using ArgValue = typename GetViewType<ArgType>::T;
 
-  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    const auto& options = CumulativeOptionsWrapper<OptionsType>::Get(ctx);
-    auto start = UnboxScalar<OutType>::Unbox(*(options.start));
-    auto skip_nulls = options.skip_nulls;
-    bool encountered_null = false;
-
-    std::shared_ptr<ArrayData> out_arr;
-    NumericBuilder<OutType> builder;
+  KernelContext* ctx;
+  ArgValue accumulator;
+  bool skip_nulls;
+  bool encountered_null = false;
+  Datum values;
+  NumericBuilder<OutType>* builder;
 
-    switch (batch[0].kind()) {
+  Status Cumulate(std::shared_ptr<ArrayData>* out_arr) {
+    switch (values.kind()) {
       case Datum::SCALAR: {
-        auto in_value = UnboxScalar<OutType>::Unbox(*(batch[0].scalar()));
-        RETURN_NOT_OK(builder.Append(start + in_value));
+        auto in_value = UnboxScalar<OutType>::Unbox(*(values.scalar()));
+        Status st;
+        auto result = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, accumulator,
+                                                                      in_value, &st);
+        RETURN_NOT_OK(st);
+        RETURN_NOT_OK(builder->Append(result));
         break;
       }
       case Datum::ARRAY: {
-        auto input = batch[0].array();
-
-        RETURN_NOT_OK(Call(ctx, *input, builder, &start, skip_nulls, &encountered_null));
+        auto arr_input = values.array();
+        builder->Reserve(arr_input->length);
+        RETURN_NOT_OK(Call(*arr_input));
         break;
       }
       case Datum::CHUNKED_ARRAY: {
-        const auto& input = batch[0].chunked_array();
+        const auto& chunked_input = values.chunked_array();
 
-        for (const auto& chunk : input->chunks()) {
-          RETURN_NOT_OK(
-              Call(ctx, *chunk->data(), builder, &start, skip_nulls, &encountered_null));
+        for (const auto& chunk : chunked_input->chunks()) {
+          builder->Reserve(chunk->length());
+          RETURN_NOT_OK(Call(*chunk->data()));
         }
         break;
       }
       default:
         return Status::NotImplemented(
             "Unsupported input type for function 'cumulative_<operator>': ",
-            batch[0].ToString());
+            values.ToString());
     }
 
-    RETURN_NOT_OK(builder.FinishInternal(&out_arr));
-    out->value = std::move(out_arr);
+    RETURN_NOT_OK(builder->FinishInternal(out_arr));
     return Status::OK();
   }
 
-  static Status Call(KernelContext* ctx, const ArrayData& input,
-                     NumericBuilder<OutType>& builder, ArgValue* accumulator,
-                     bool skip_nulls, bool* encountered_null) {
+  Status Call(const ArrayData& input) {
     Status st = Status::OK();
-    ArgValue accumulator_tmp = *accumulator;
-    bool encountered_null_tmp = *encountered_null;
-
-    auto null_func = [&]() {
-      st &= builder.AppendNull();
-      encountered_null_tmp = true;
-    };
 
-    if (skip_nulls || (input.GetNullCount() == 0 && !encountered_null_tmp)) {
+    if (skip_nulls || (input.GetNullCount() == 0 && !encountered_null)) {
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
-            accumulator_tmp = Op::template Call<OutValue, ArgValue, ArgValue>(
-                ctx, v, accumulator_tmp, &st);
-            st &= builder.Append(accumulator_tmp);
+            accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
+                ctx, v, accumulator, &st);
+            builder->UnsafeAppend(accumulator);
           },
-          null_func);
+          [&]() {
+            builder->UnsafeAppendNull();
+          });
     } else {
+      auto nulls_start_idx = 0;
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
-            if (encountered_null_tmp) {
-              st &= builder.AppendNull();
-            } else {
-              accumulator_tmp = Op::template Call<OutValue, ArgValue, ArgValue>(
-                  ctx, v, accumulator_tmp, &st);
-              st &= builder.Append(accumulator_tmp);
+            if (!encountered_null) {
+              accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
+                  ctx, v, accumulator, &st);
+              builder->UnsafeAppend(accumulator);
+              ++nulls_start_idx;
             }
           },
-          null_func);
+          [&]() {
+            encountered_null = true;
+          });
+      
+      builder->AppendNulls(input.length - nulls_start_idx);
     }
 
-    *accumulator = accumulator_tmp;
-    *encountered_null = encountered_null_tmp;
     return st;
   }
+
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    const auto& options = CumulativeOptionsWrapper<OptionsType>::Get(ctx);
+
+    auto start = UnboxScalar<OutType>::Unbox(*(options.start));
+    auto skip_nulls = options.skip_nulls;
+    NumericBuilder<OutType> builder(ctx->memory_pool());
+
+    CumulativeGeneric self;
+    self.ctx = ctx;
+    self.accumulator = start;
+    self.skip_nulls = skip_nulls;
+    self.values = batch[0];
+    self.builder = &builder;
+
+    std::shared_ptr<ArrayData> out_arr;
+    RETURN_NOT_OK(self.Cumulate(&out_arr));
+    out->value = std::move(out_arr);
+    return Status::OK();
+  }
 };
 
 const FunctionDoc cumulative_sum_doc{
@@ -188,7 +205,7 @@ void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string
   for (const auto& ty : types) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = false;
-    kernel.null_handling = NullHandling::type::INTERSECTION;
+    kernel.null_handling = NullHandling::type::COMPUTED_NO_PREALLOCATE;
     kernel.mem_allocation = MemAllocation::type::NO_PREALLOCATE;
     kernel.signature = KernelSignature::Make({InputType(ty)}, OutputType(ty));
     kernel.exec = ArithmeticExecFromOp<CumulativeGeneric, Op, OptionsType>(ty);

From 4e3e1af87ba2385a198aa6a62b915fb6bf458f55 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 3 May 2022 20:22:56 -0400
Subject: [PATCH 60/67] Adding more test inputs to tests and using
 CheckVectorUnary

---
 .../compute/kernels/vector_cumulative_ops.cc  |  18 +--
 .../kernels/vector_cumulative_ops_test.cc     | 149 +++++++++---------
 2 files changed, 84 insertions(+), 83 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index c025f3a130e..3fa5db88bf6 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -123,13 +123,11 @@ struct CumulativeGeneric {
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
-            accumulator = Op::template Call<OutValue, ArgValue, ArgValue>(
-                ctx, v, accumulator, &st);
+            accumulator =
+                Op::template Call<OutValue, ArgValue, ArgValue>(ctx, v, accumulator, &st);
             builder->UnsafeAppend(accumulator);
           },
-          [&]() {
-            builder->UnsafeAppendNull();
-          });
+          [&]() { builder->UnsafeAppendNull(); });
     } else {
       auto nulls_start_idx = 0;
       VisitArrayValuesInline<ArgType>(
@@ -142,10 +140,8 @@ struct CumulativeGeneric {
               ++nulls_start_idx;
             }
           },
-          [&]() {
-            encountered_null = true;
-          });
-      
+          [&]() { encountered_null = true; });
+
       builder->AppendNulls(input.length - nulls_start_idx);
     }
 
@@ -174,7 +170,7 @@ struct CumulativeGeneric {
 };
 
 const FunctionDoc cumulative_sum_doc{
-    "Computes the cumulative sum over a numeric input",
+    "Compute the cumulative sum over a numeric input",
     ("`values` must be numeric. Return an array/chunked array which is the\n"
      "cumulative sum computed over `values`. Results will wrap around on\n"
      "integer overflow. Use function \"cumulative_sum_checked\" if you want\n"
@@ -183,7 +179,7 @@ const FunctionDoc cumulative_sum_doc{
     "CumulativeSumOptions"};
 
 const FunctionDoc cumulative_sum_checked_doc{
-    "Computes the cumulative sum over a numeric input",
+    "Compute the cumulative sum over a numeric input",
     ("`values` must be numeric. Return an array/chunked array which is the\n"
      "cumulative sum computed over `values`. This function returns an error\n"
      "on overflow. For a variant that doesn't fail on overflow, use\n"
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 356988312b2..d9ac911df22 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -33,40 +33,13 @@
 namespace arrow {
 namespace compute {
 
-void Assert(const std::string func, const std::shared_ptr<Scalar>& input,
-            const std::shared_ptr<Array>& expected, const FunctionOptions& options) {
-  ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
-
-  AssertArraysApproxEqual(*expected, *result.make_array(), false,
-                          EqualOptions::Defaults());
-}
-
-void Assert(const std::string func, const std::shared_ptr<Array>& input,
-            const std::shared_ptr<Array>& expected, const FunctionOptions& options) {
-  ASSERT_OK_AND_ASSIGN(auto result, CallFunction(func, {Datum(input)}, &options));
-
-  AssertArraysApproxEqual(*expected, *result.make_array(), false,
-                          EqualOptions::Defaults());
-}
-
-void Assert(const std::string func, std::shared_ptr<DataType>& type,
-            const std::shared_ptr<ChunkedArray>& input,
-            const std::shared_ptr<ChunkedArray>& expected,
-            const FunctionOptions& options) {
-  ASSERT_OK_AND_ASSIGN(auto result,
-                       CallFunction(func, {Datum(input)}, &options, nullptr));
-
-  ChunkedArray actual(result.chunks(), type);
-  AssertChunkedApproxEquivalent(*expected, actual, EqualOptions::Defaults());
-}
-
 TEST(TestCumulativeSum, Empty) {
   CumulativeSumOptions options;
   for (auto ty : NumericTypes()) {
     auto empty_arr = ArrayFromJSON(ty, "[]");
     auto empty_chunked = ChunkedArrayFromJSON(ty, {"[]"});
-    Assert("cumulative_sum", empty_arr, empty_arr, options);
-    Assert("cumulative_sum", ty, empty_chunked, empty_chunked, options);
+    CheckVectorUnary("cumulative_sum", empty_arr, empty_arr, &options);
+    CheckVectorUnary("cumulative_sum", empty_chunked, empty_chunked, &options);
   }
 }
 
@@ -76,9 +49,9 @@ TEST(TestCumulativeSum, AllNulls) {
     auto nulls_arr = ArrayFromJSON(ty, "[null, null, null]");
     auto nulls_one_chunk = ChunkedArrayFromJSON(ty, {"[null, null, null]"});
     auto nulls_three_chunks = ChunkedArrayFromJSON(ty, {"[null]", "[null]", "[null]"});
-    Assert("cumulative_sum", nulls_arr, nulls_arr, options);
-    Assert("cumulative_sum", ty, nulls_one_chunk, nulls_one_chunk, options);
-    Assert("cumulative_sum", ty, nulls_three_chunks, nulls_one_chunk, options);
+    CheckVectorUnary("cumulative_sum", nulls_arr, nulls_arr, &options);
+    CheckVectorUnary("cumulative_sum", nulls_one_chunk, nulls_one_chunk, &options);
+    CheckVectorUnary("cumulative_sum", nulls_three_chunks, nulls_one_chunk, &options);
   }
 }
 
@@ -86,82 +59,114 @@ TEST(TestCumulativeSum, ScalarInput) {
   CumulativeSumOptions no_start;
   CumulativeSumOptions with_start(10);
   for (auto ty : NumericTypes()) {
-    Assert("cumulative_sum", ScalarFromJSON(ty, "10"), ArrayFromJSON(ty, "[10]"),
-           no_start);
-    Assert("cumulative_sum", ScalarFromJSON(ty, "10"), ArrayFromJSON(ty, "[20]"),
-           with_start);
+    CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "10"),
+                     ArrayFromJSON(ty, "[10]"), &no_start);
+    CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "10"),
+                     ArrayFromJSON(ty, "[20]"), &with_start);
   }
 }
 
 TEST(TestCumulativeSum, NoStartNoSkip) {
   CumulativeSumOptions options;
   for (auto ty : NumericTypes()) {
-    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
-           ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), options);
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+                     ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), &options);
 
-    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
-           ArrayFromJSON(ty, "[1, 3, null, null, null, null]"), options);
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[1, 3, null, null, null, null]"), &options);
 
-    Assert("cumulative_sum", ty, ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
-           ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), options);
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[null, null, null, null, null, null]"), &options);
 
-    Assert("cumulative_sum", ty,
-           ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
-           ChunkedArrayFromJSON(ty, {"[1, 3, null, null, null, null]"}), options);
+    CheckVectorUnary("cumulative_sum",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), &options);
+
+    CheckVectorUnary(
+        "cumulative_sum", ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+        ChunkedArrayFromJSON(ty, {"[1, 3, null, null, null, null]"}), &options);
+
+    CheckVectorUnary(
+        "cumulative_sum", ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
+        ChunkedArrayFromJSON(ty, {"[null, null, null, null, null, null]"}), &options);
   }
 }
 
 TEST(TestCumulativeSum, NoStartDoSkip) {
   CumulativeSumOptions options(0, true);
   for (auto ty : NumericTypes()) {
-    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
-           ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), options);
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+                     ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), &options);
+
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[1, 3, null, 7, null, 13]"), &options);
+
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[null, 2, null, 6, null, 12]"), &options);
 
-    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
-           ArrayFromJSON(ty, "[1, 3, null, 7, null, 13]"), options);
+    CheckVectorUnary("cumulative_sum",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), &options);
 
-    Assert("cumulative_sum", ty, ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
-           ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), options);
+    CheckVectorUnary("cumulative_sum",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[1, 3, null, 7, null, 13]"}), &options);
 
-    Assert("cumulative_sum", ty,
-           ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
-           ChunkedArrayFromJSON(ty, {"[1, 3, null, 7, null, 13]"}), options);
+    CheckVectorUnary(
+        "cumulative_sum", ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
+        ChunkedArrayFromJSON(ty, {"[null, 2, null, 6, null, 12]"}), &options);
   }
 }
 
 TEST(TestCumulativeSum, HasStartNoSkip) {
   CumulativeSumOptions options(10);
   for (auto ty : NumericTypes()) {
-    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
-           ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), options);
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+                     ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), &options);
 
-    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
-           ArrayFromJSON(ty, "[11, 13, null, null, null, null]"), options);
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[11, 13, null, null, null, null]"), &options);
 
-    Assert("cumulative_sum", ty, ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
-           ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), options);
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[null, null, null, null, null, null]"), &options);
 
-    Assert("cumulative_sum", ty,
-           ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
-           ChunkedArrayFromJSON(ty, {"[11, 13, null, null, null, null]"}), options);
+    CheckVectorUnary("cumulative_sum",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), &options);
+
+    CheckVectorUnary(
+        "cumulative_sum", ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+        ChunkedArrayFromJSON(ty, {"[11, 13, null, null, null, null]"}), &options);
+
+    CheckVectorUnary(
+        "cumulative_sum", ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
+        ChunkedArrayFromJSON(ty, {"[null, null, null, null, null, null]"}), &options);
   }
 }
 
 TEST(TestCumulativeSum, HasStartDoSkip) {
   CumulativeSumOptions options(10, true);
   for (auto ty : NumericTypes()) {
-    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
-           ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), options);
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+                     ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), &options);
+
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[11, 13, null, 17, null, 23]"), &options);
+
+    CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[null, 12, null, 16, null, 22]"), &options);
 
-    Assert("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
-           ArrayFromJSON(ty, "[11, 13, null, 17, null, 23]"), options);
+    CheckVectorUnary("cumulative_sum",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), &options);
 
-    Assert("cumulative_sum", ty, ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
-           ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), options);
+    CheckVectorUnary(
+        "cumulative_sum", ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+        ChunkedArrayFromJSON(ty, {"[11, 13, null, 17, null, 23]"}), &options);
 
-    Assert("cumulative_sum", ty,
-           ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
-           ChunkedArrayFromJSON(ty, {"[11, 13, null, 17, null, 23]"}), options);
+    CheckVectorUnary(
+        "cumulative_sum", ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
+        ChunkedArrayFromJSON(ty, {"[null, 12, null, 16, null, 22]"}), &options);
   }
 }
 

From bbf7ff4dfca618ffd4db096ab6549751dc696397 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 5 May 2022 19:41:17 -0400
Subject: [PATCH 61/67] Added testing for "cumulative_sum_checked" and added
 checks for overflow

---
 .../kernels/vector_cumulative_ops_test.cc     | 129 ++++++++++++++++++
 1 file changed, 129 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index d9ac911df22..e456109818f 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -39,7 +39,10 @@ TEST(TestCumulativeSum, Empty) {
     auto empty_arr = ArrayFromJSON(ty, "[]");
     auto empty_chunked = ChunkedArrayFromJSON(ty, {"[]"});
     CheckVectorUnary("cumulative_sum", empty_arr, empty_arr, &options);
+    CheckVectorUnary("cumulative_sum_checked", empty_arr, empty_arr, &options);
+
     CheckVectorUnary("cumulative_sum", empty_chunked, empty_chunked, &options);
+    CheckVectorUnary("cumulative_sum_checked", empty_chunked, empty_chunked, &options);
   }
 }
 
@@ -50,8 +53,15 @@ TEST(TestCumulativeSum, AllNulls) {
     auto nulls_one_chunk = ChunkedArrayFromJSON(ty, {"[null, null, null]"});
     auto nulls_three_chunks = ChunkedArrayFromJSON(ty, {"[null]", "[null]", "[null]"});
     CheckVectorUnary("cumulative_sum", nulls_arr, nulls_arr, &options);
+    CheckVectorUnary("cumulative_sum_checked", nulls_arr, nulls_arr, &options);
+
     CheckVectorUnary("cumulative_sum", nulls_one_chunk, nulls_one_chunk, &options);
+    CheckVectorUnary("cumulative_sum_checked", nulls_one_chunk, nulls_one_chunk,
+                     &options);
+
     CheckVectorUnary("cumulative_sum", nulls_three_chunks, nulls_one_chunk, &options);
+    CheckVectorUnary("cumulative_sum_checked", nulls_three_chunks, nulls_one_chunk,
+                     &options);
   }
 }
 
@@ -61,34 +71,97 @@ TEST(TestCumulativeSum, ScalarInput) {
   for (auto ty : NumericTypes()) {
     CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "10"),
                      ArrayFromJSON(ty, "[10]"), &no_start);
+    CheckVectorUnary("cumulative_sum_checked", ScalarFromJSON(ty, "10"),
+                     ArrayFromJSON(ty, "[10]"), &no_start);
+
     CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "10"),
                      ArrayFromJSON(ty, "[20]"), &with_start);
+    CheckVectorUnary("cumulative_sum_checked", ScalarFromJSON(ty, "10"),
+                     ArrayFromJSON(ty, "[20]"), &with_start);
   }
 }
 
+using testing::HasSubstr;
+
+#define CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW(FUNC, ARROWTYPE, CTYPE)              \
+  {                                                                                 \
+    CumulativeSumOptions pos_overflow(1);                                           \
+    EXPECT_RAISES_WITH_MESSAGE_THAT(                                                \
+        Invalid, HasSubstr("overflow"),                                             \
+        CallFunction(                                                               \
+            FUNC,                                                                   \
+            {TypeTraits<ARROWTYPE>::ScalarType(std::numeric_limits<CTYPE>::max())}, \
+            &pos_overflow));                                                        \
+  }
+
+#define CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW(FUNC, ARROWTYPE, CTYPE)                   \
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW(FUNC, ARROWTYPE, CTYPE);                      \
+  {                                                                                    \
+    CumulativeSumOptions neg_overflow(-1);                                             \
+    EXPECT_RAISES_WITH_MESSAGE_THAT(                                                   \
+        Invalid, HasSubstr("overflow"),                                                \
+        CallFunction(                                                                  \
+            FUNC,                                                                      \
+            {TypeTraits<ARROWTYPE>::ScalarType(std::numeric_limits<CTYPE>::lowest())}, \
+            &neg_overflow));                                                           \
+  }
+
+TEST(TestCumulativeSum, IntegerOverflow) {
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt8Type, uint8_t);
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt16Type, uint16_t);
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt32Type, uint32_t);
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt64Type, uint64_t);
+  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int8Type, int8_t);
+  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int16Type, int16_t);
+  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int32Type, int32_t);
+  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int64Type, int64_t);
+}
+
+#undef CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW
+#undef CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW
+
 TEST(TestCumulativeSum, NoStartNoSkip) {
   CumulativeSumOptions options;
   for (auto ty : NumericTypes()) {
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
                      ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), &options);
+    CheckVectorUnary("cumulative_sum_checked", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+                     ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), &options);
 
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
                      ArrayFromJSON(ty, "[1, 3, null, null, null, null]"), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[1, 3, null, null, null, null]"), &options);
 
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
                      ArrayFromJSON(ty, "[null, null, null, null, null, null]"), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[null, null, null, null, null, null]"), &options);
 
     CheckVectorUnary("cumulative_sum",
                      ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
                      ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), &options);
 
     CheckVectorUnary(
         "cumulative_sum", ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
         ChunkedArrayFromJSON(ty, {"[1, 3, null, null, null, null]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[1, 3, null, null, null, null]"}),
+                     &options);
 
     CheckVectorUnary(
         "cumulative_sum", ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
         ChunkedArrayFromJSON(ty, {"[null, null, null, null, null, null]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[null, null, null, null, null, null]"}),
+                     &options);
   }
 }
 
@@ -97,24 +170,42 @@ TEST(TestCumulativeSum, NoStartDoSkip) {
   for (auto ty : NumericTypes()) {
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
                      ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), &options);
+    CheckVectorUnary("cumulative_sum_checked", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+                     ArrayFromJSON(ty, "[1, 3, 6, 10, 15, 21]"), &options);
 
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
                      ArrayFromJSON(ty, "[1, 3, null, 7, null, 13]"), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[1, 3, null, 7, null, 13]"), &options);
 
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
                      ArrayFromJSON(ty, "[null, 2, null, 6, null, 12]"), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[null, 2, null, 6, null, 12]"), &options);
 
     CheckVectorUnary("cumulative_sum",
                      ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
                      ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[1, 3, 6, 10, 15, 21]"}), &options);
 
     CheckVectorUnary("cumulative_sum",
                      ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
                      ChunkedArrayFromJSON(ty, {"[1, 3, null, 7, null, 13]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[1, 3, null, 7, null, 13]"}), &options);
 
     CheckVectorUnary(
         "cumulative_sum", ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
         ChunkedArrayFromJSON(ty, {"[null, 2, null, 6, null, 12]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[null, 2, null, 6, null, 12]"}),
+                     &options);
   }
 }
 
@@ -123,24 +214,43 @@ TEST(TestCumulativeSum, HasStartNoSkip) {
   for (auto ty : NumericTypes()) {
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
                      ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), &options);
+    CheckVectorUnary("cumulative_sum_checked", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+                     ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), &options);
 
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
                      ArrayFromJSON(ty, "[11, 13, null, null, null, null]"), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[11, 13, null, null, null, null]"), &options);
 
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
                      ArrayFromJSON(ty, "[null, null, null, null, null, null]"), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[null, null, null, null, null, null]"), &options);
 
     CheckVectorUnary("cumulative_sum",
                      ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
                      ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), &options);
 
     CheckVectorUnary(
         "cumulative_sum", ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
         ChunkedArrayFromJSON(ty, {"[11, 13, null, null, null, null]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[11, 13, null, null, null, null]"}),
+                     &options);
 
     CheckVectorUnary(
         "cumulative_sum", ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
         ChunkedArrayFromJSON(ty, {"[null, null, null, null, null, null]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[null, null, null, null, null, null]"}),
+                     &options);
   }
 }
 
@@ -149,24 +259,43 @@ TEST(TestCumulativeSum, HasStartDoSkip) {
   for (auto ty : NumericTypes()) {
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
                      ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), &options);
+    CheckVectorUnary("cumulative_sum_checked", ArrayFromJSON(ty, "[1, 2, 3, 4, 5, 6]"),
+                     ArrayFromJSON(ty, "[11, 13, 16, 20, 25, 31]"), &options);
 
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
                      ArrayFromJSON(ty, "[11, 13, null, 17, null, 23]"), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ArrayFromJSON(ty, "[1, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[11, 13, null, 17, null, 23]"), &options);
 
     CheckVectorUnary("cumulative_sum", ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
                      ArrayFromJSON(ty, "[null, 12, null, 16, null, 22]"), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ArrayFromJSON(ty, "[null, 2, null, 4, null, 6]"),
+                     ArrayFromJSON(ty, "[null, 12, null, 16, null, 22]"), &options);
 
     CheckVectorUnary("cumulative_sum",
                      ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
                      ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, 3]", "[4, 5, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[11, 13, 16, 20, 25, 31]"}), &options);
 
     CheckVectorUnary(
         "cumulative_sum", ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
         ChunkedArrayFromJSON(ty, {"[11, 13, null, 17, null, 23]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[1, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[11, 13, null, 17, null, 23]"}),
+                     &options);
 
     CheckVectorUnary(
         "cumulative_sum", ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
         ChunkedArrayFromJSON(ty, {"[null, 12, null, 16, null, 22]"}), &options);
+    CheckVectorUnary("cumulative_sum_checked",
+                     ChunkedArrayFromJSON(ty, {"[null, 2, null]", "[4, null, 6]"}),
+                     ChunkedArrayFromJSON(ty, {"[null, 12, null, 16, null, 22]"}),
+                     &options);
   }
 }
 

From e7203a019aa713ce2e03f55f2a7275de0efbb424 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 5 May 2022 20:11:47 -0400
Subject: [PATCH 62/67] Change MakeVectorCumulativeFunction to reflect changes
 to VectorFunction

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

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 3fa5db88bf6..aea935b8a56 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -190,7 +190,7 @@ const FunctionDoc cumulative_sum_checked_doc{
 
 template <typename Op, typename OptionsType>
 void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string func_name,
-                                  const FunctionDoc* doc) {
+                                  const FunctionDoc doc) {
   static const OptionsType kDefaultOptions = OptionsType::Defaults();
   auto func =
       std::make_shared<VectorFunction>(func_name, Arity::Unary(), doc, &kDefaultOptions);
@@ -214,9 +214,9 @@ void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string
 
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
   MakeVectorCumulativeFunction<Add, CumulativeSumOptions>(registry, "cumulative_sum",
-                                                          &cumulative_sum_doc);
+                                                          cumulative_sum_doc);
   MakeVectorCumulativeFunction<AddChecked, CumulativeSumOptions>(
-      registry, "cumulative_sum_checked", &cumulative_sum_checked_doc);
+      registry, "cumulative_sum_checked", cumulative_sum_checked_doc);
 }
 
 }  // namespace internal

From 2fe3e3aa023d7486ba8db88eb9cf6d4e13866599 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Fri, 6 May 2022 13:36:42 -0400
Subject: [PATCH 63/67] Handling Statuses returned from NumericBuilder

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

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index aea935b8a56..3dfc63f6984 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -93,7 +93,7 @@ struct CumulativeGeneric {
       }
       case Datum::ARRAY: {
         auto arr_input = values.array();
-        builder->Reserve(arr_input->length);
+        RETURN_NOT_OK(builder->Reserve(arr_input->length));
         RETURN_NOT_OK(Call(*arr_input));
         break;
       }
@@ -101,7 +101,7 @@ struct CumulativeGeneric {
         const auto& chunked_input = values.chunked_array();
 
         for (const auto& chunk : chunked_input->chunks()) {
-          builder->Reserve(chunk->length());
+          RETURN_NOT_OK(builder->Reserve(chunk->length()));
           RETURN_NOT_OK(Call(*chunk->data()));
         }
         break;
@@ -142,7 +142,7 @@ struct CumulativeGeneric {
           },
           [&]() { encountered_null = true; });
 
-      builder->AppendNulls(input.length - nulls_start_idx);
+      RETURN_NOT_OK(builder->AppendNulls(input.length - nulls_start_idx));
     }
 
     return st;

From 02a54be9f1f114818265a52d406bcccec8c85029 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Thu, 12 May 2022 14:39:11 -0400
Subject: [PATCH 64/67] Added arrays to overflow check

---
 .../kernels/vector_cumulative_ops_test.cc     | 65 +++++++++++--------
 1 file changed, 38 insertions(+), 27 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index e456109818f..23644354934 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -27,6 +27,7 @@
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
 
+#include "arrow/array/builder_primitive.h"
 #include "arrow/compute/api.h"
 #include "arrow/compute/kernels/test_util.h"
 
@@ -83,38 +84,48 @@ TEST(TestCumulativeSum, ScalarInput) {
 
 using testing::HasSubstr;
 
-#define CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW(FUNC, ARROWTYPE, CTYPE)              \
-  {                                                                                 \
-    CumulativeSumOptions pos_overflow(1);                                           \
-    EXPECT_RAISES_WITH_MESSAGE_THAT(                                                \
-        Invalid, HasSubstr("overflow"),                                             \
-        CallFunction(                                                               \
-            FUNC,                                                                   \
-            {TypeTraits<ARROWTYPE>::ScalarType(std::numeric_limits<CTYPE>::max())}, \
-            &pos_overflow));                                                        \
+#define CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW(FUNC, TYPENAME, CTYPE)            \
+  {                                                                              \
+    CumulativeSumOptions pos_overflow(1);                                        \
+    auto max = std::numeric_limits<CTYPE>::max();                                \
+    TYPENAME##Builder builder;                                                   \
+    std::shared_ptr<Array> array;                                                \
+    builder.Append(max);                                                         \
+    ASSERT_OK(builder.Finish(&array));                                           \
+    EXPECT_RAISES_WITH_MESSAGE_THAT(                                             \
+        Invalid, HasSubstr("overflow"),                                          \
+        CallFunction(FUNC, {TypeTraits<TYPENAME##Type>::ScalarType(max)},        \
+                     &pos_overflow));                                            \
+    EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, HasSubstr("overflow"),              \
+                                    CallFunction(FUNC, {array}, &pos_overflow)); \
   }
 
-#define CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW(FUNC, ARROWTYPE, CTYPE)                   \
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW(FUNC, ARROWTYPE, CTYPE);                      \
-  {                                                                                    \
-    CumulativeSumOptions neg_overflow(-1);                                             \
-    EXPECT_RAISES_WITH_MESSAGE_THAT(                                                   \
-        Invalid, HasSubstr("overflow"),                                                \
-        CallFunction(                                                                  \
-            FUNC,                                                                      \
-            {TypeTraits<ARROWTYPE>::ScalarType(std::numeric_limits<CTYPE>::lowest())}, \
-            &neg_overflow));                                                           \
+#define CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW(FUNC, TYPENAME, CTYPE)              \
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW(FUNC, TYPENAME, CTYPE);                 \
+  {                                                                              \
+    CumulativeSumOptions neg_overflow(-1);                                       \
+    auto min = std::numeric_limits<CTYPE>::lowest();                             \
+    TYPENAME##Builder builder;                                                   \
+    std::shared_ptr<Array> array;                                                \
+    builder.Append(min);                                                         \
+    ASSERT_OK(builder.Finish(&array));                                           \
+    EXPECT_RAISES_WITH_MESSAGE_THAT(                                             \
+        Invalid, HasSubstr("overflow"),                                          \
+        CallFunction(FUNC, {TypeTraits<TYPENAME##Type>::ScalarType(min)},        \
+                     &neg_overflow));                                            \
+    EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, HasSubstr("overflow"),              \
+                                    CallFunction(FUNC, {array}, &neg_overflow)); \
   }
 
 TEST(TestCumulativeSum, IntegerOverflow) {
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt8Type, uint8_t);
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt16Type, uint16_t);
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt32Type, uint32_t);
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt64Type, uint64_t);
-  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int8Type, int8_t);
-  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int16Type, int16_t);
-  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int32Type, int32_t);
-  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int64Type, int64_t);
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt8, uint8_t);
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt16, uint16_t);
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt32, uint32_t);
+  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt64, uint64_t);
+  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int8, int8_t);
+  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int16, int16_t);
+  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int32, int32_t);
+  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int64, int64_t);
 }
 
 #undef CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW

From 3673dec2bae60c5f1799db13af8aaea3a341ff6d Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Sat, 14 May 2022 20:33:20 -0400
Subject: [PATCH 65/67] Handling builder.Append() Status output

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

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 23644354934..cb637137eaf 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -90,7 +90,7 @@ using testing::HasSubstr;
     auto max = std::numeric_limits<CTYPE>::max();                                \
     TYPENAME##Builder builder;                                                   \
     std::shared_ptr<Array> array;                                                \
-    builder.Append(max);                                                         \
+    ASSERT_OK(builder.Append(max));                                              \
     ASSERT_OK(builder.Finish(&array));                                           \
     EXPECT_RAISES_WITH_MESSAGE_THAT(                                             \
         Invalid, HasSubstr("overflow"),                                          \
@@ -107,7 +107,7 @@ using testing::HasSubstr;
     auto min = std::numeric_limits<CTYPE>::lowest();                             \
     TYPENAME##Builder builder;                                                   \
     std::shared_ptr<Array> array;                                                \
-    builder.Append(min);                                                         \
+    ASSERT_OK(builder.Append(min));                                              \
     ASSERT_OK(builder.Finish(&array));                                           \
     EXPECT_RAISES_WITH_MESSAGE_THAT(                                             \
         Invalid, HasSubstr("overflow"),                                          \

From 2e20590f6acf6abba3d01e96d29011f57f25ce41 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Mon, 16 May 2022 17:21:48 -0400
Subject: [PATCH 66/67] Using templated functions instead of macros for
 IntegerOverflow test

---
 .../compute/kernels/vector_cumulative_ops.cc  |   2 +-
 .../kernels/vector_cumulative_ops_test.cc     | 106 +++++++++++-------
 2 files changed, 65 insertions(+), 43 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 3dfc63f6984..ba3faf2b6b1 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -99,9 +99,9 @@ struct CumulativeGeneric {
       }
       case Datum::CHUNKED_ARRAY: {
         const auto& chunked_input = values.chunked_array();
+        RETURN_NOT_OK(builder->Reserve(chunked_input->length()));
 
         for (const auto& chunk : chunked_input->chunks()) {
-          RETURN_NOT_OK(builder->Reserve(chunk->length()));
           RETURN_NOT_OK(Call(*chunk->data()));
         }
         break;
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index cb637137eaf..75d38a5b074 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -84,53 +84,75 @@ TEST(TestCumulativeSum, ScalarInput) {
 
 using testing::HasSubstr;
 
-#define CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW(FUNC, TYPENAME, CTYPE)            \
-  {                                                                              \
-    CumulativeSumOptions pos_overflow(1);                                        \
-    auto max = std::numeric_limits<CTYPE>::max();                                \
-    TYPENAME##Builder builder;                                                   \
-    std::shared_ptr<Array> array;                                                \
-    ASSERT_OK(builder.Append(max));                                              \
-    ASSERT_OK(builder.Finish(&array));                                           \
-    EXPECT_RAISES_WITH_MESSAGE_THAT(                                             \
-        Invalid, HasSubstr("overflow"),                                          \
-        CallFunction(FUNC, {TypeTraits<TYPENAME##Type>::ScalarType(max)},        \
-                     &pos_overflow));                                            \
-    EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, HasSubstr("overflow"),              \
-                                    CallFunction(FUNC, {array}, &pos_overflow)); \
-  }
+template <typename ArrowType>
+void CheckCumulativeSumUnsignedOverflow() {
+  using CType = typename TypeTraits<ArrowType>::CType;
+  using ScalarType = typename TypeTraits<ArrowType>::ScalarType;
+  using BuilderType = typename TypeTraits<ArrowType>::BuilderType;
+
+  CumulativeSumOptions pos_overflow(1);
+  auto max = std::numeric_limits<CType>::max();
+  auto min = std::numeric_limits<CType>::lowest();
+
+  BuilderType builder;
+  std::shared_ptr<Array> max_arr;
+  std::shared_ptr<Array> min_arr;
+  ASSERT_OK(builder.Append(max));
+  ASSERT_OK(builder.Finish(&max_arr));
+  builder.Reset();
+  ASSERT_OK(builder.Append(min));
+  ASSERT_OK(builder.Finish(&min_arr));
+
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, HasSubstr("overflow"),
+      CallFunction("cumulative_sum_checked", {ScalarType(max)}, &pos_overflow));
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, HasSubstr("overflow"),
+      CallFunction("cumulative_sum_checked", {max_arr}, &pos_overflow));
+  CheckVectorUnary("cumulative_sum", ScalarType(max), min_arr, &pos_overflow);
+}
 
-#define CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW(FUNC, TYPENAME, CTYPE)              \
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW(FUNC, TYPENAME, CTYPE);                 \
-  {                                                                              \
-    CumulativeSumOptions neg_overflow(-1);                                       \
-    auto min = std::numeric_limits<CTYPE>::lowest();                             \
-    TYPENAME##Builder builder;                                                   \
-    std::shared_ptr<Array> array;                                                \
-    ASSERT_OK(builder.Append(min));                                              \
-    ASSERT_OK(builder.Finish(&array));                                           \
-    EXPECT_RAISES_WITH_MESSAGE_THAT(                                             \
-        Invalid, HasSubstr("overflow"),                                          \
-        CallFunction(FUNC, {TypeTraits<TYPENAME##Type>::ScalarType(min)},        \
-                     &neg_overflow));                                            \
-    EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, HasSubstr("overflow"),              \
-                                    CallFunction(FUNC, {array}, &neg_overflow)); \
-  }
+template <typename ArrowType>
+void CheckCumulativeSumSignedOverflow() {
+  using CType = typename TypeTraits<ArrowType>::CType;
+  using ScalarType = typename TypeTraits<ArrowType>::ScalarType;
+  using BuilderType = typename TypeTraits<ArrowType>::BuilderType;
+
+  CheckCumulativeSumUnsignedOverflow<ArrowType>();
+
+  CumulativeSumOptions neg_overflow(-1);
+  auto max = std::numeric_limits<CType>::max();
+  auto min = std::numeric_limits<CType>::lowest();
+
+  BuilderType builder;
+  std::shared_ptr<Array> max_arr;
+  std::shared_ptr<Array> min_arr;
+  ASSERT_OK(builder.Append(max));
+  ASSERT_OK(builder.Finish(&max_arr));
+  builder.Reset();
+  ASSERT_OK(builder.Append(min));
+  ASSERT_OK(builder.Finish(&min_arr));
+
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, HasSubstr("overflow"),
+      CallFunction("cumulative_sum_checked", {ScalarType(min)}, &neg_overflow));
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, HasSubstr("overflow"),
+      CallFunction("cumulative_sum_checked", {min_arr}, &neg_overflow));
+  CheckVectorUnary("cumulative_sum", ScalarType(min), max_arr, &neg_overflow);
+}
 
 TEST(TestCumulativeSum, IntegerOverflow) {
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt8, uint8_t);
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt16, uint16_t);
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt32, uint32_t);
-  CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW("cumulative_sum_checked", UInt64, uint64_t);
-  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int8, int8_t);
-  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int16, int16_t);
-  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int32, int32_t);
-  CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW("cumulative_sum_checked", Int64, int64_t);
+  CheckCumulativeSumUnsignedOverflow<UInt8Type>();
+  CheckCumulativeSumUnsignedOverflow<UInt16Type>();
+  CheckCumulativeSumUnsignedOverflow<UInt32Type>();
+  CheckCumulativeSumUnsignedOverflow<UInt64Type>();
+  CheckCumulativeSumSignedOverflow<Int8Type>();
+  CheckCumulativeSumSignedOverflow<Int16Type>();
+  CheckCumulativeSumSignedOverflow<Int32Type>();
+  CheckCumulativeSumSignedOverflow<Int64Type>();
 }
 
-#undef CHECK_CUMULATIVE_SUM_UNSIGNED_OVERFLOW
-#undef CHECK_CUMULATIVE_SUM_SIGNED_OVERFLOW
-
 TEST(TestCumulativeSum, NoStartNoSkip) {
   CumulativeSumOptions options;
   for (auto ty : NumericTypes()) {

From 3f365578a8223aa29f681bd5658870470b934514 Mon Sep 17 00:00:00 2001
From: JabariBooker <o.jabari.booker@gmail.com>
Date: Tue, 17 May 2022 14:18:43 -0400
Subject: [PATCH 67/67] Added test for scalar null inputs; Minor change to
 python tests

---
 .../compute/kernels/vector_cumulative_ops.cc  | 15 +++++++--
 .../kernels/vector_cumulative_ops_test.cc     | 33 +++++++++++++++----
 python/pyarrow/tests/test_compute.py          | 11 ++-----
 3 files changed, 43 insertions(+), 16 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index ba3faf2b6b1..c0eb40964da 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -83,8 +83,19 @@ struct CumulativeGeneric {
   Status Cumulate(std::shared_ptr<ArrayData>* out_arr) {
     switch (values.kind()) {
       case Datum::SCALAR: {
-        auto in_value = UnboxScalar<OutType>::Unbox(*(values.scalar()));
+        auto in_scalar = values.scalar();
+        if (!skip_nulls && !in_scalar->is_valid) {
+          RETURN_NOT_OK(builder->AppendNull());
+          break;
+        }
+
+        if (skip_nulls && !in_scalar->is_valid) {
+          RETURN_NOT_OK(builder->Append(accumulator));
+          break;
+        }
+
         Status st;
+        auto in_value = UnboxScalar<OutType>::Unbox(*(in_scalar));
         auto result = Op::template Call<OutValue, ArgValue, ArgValue>(ctx, accumulator,
                                                                       in_value, &st);
         RETURN_NOT_OK(st);
@@ -129,7 +140,7 @@ struct CumulativeGeneric {
           },
           [&]() { builder->UnsafeAppendNull(); });
     } else {
-      auto nulls_start_idx = 0;
+      int64_t nulls_start_idx = 0;
       VisitArrayValuesInline<ArgType>(
           input,
           [&](ArgValue v) {
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 75d38a5b074..3485ffffb45 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -67,18 +67,39 @@ TEST(TestCumulativeSum, AllNulls) {
 }
 
 TEST(TestCumulativeSum, ScalarInput) {
-  CumulativeSumOptions no_start;
-  CumulativeSumOptions with_start(10);
+  CumulativeSumOptions no_start_no_skip;
+  CumulativeSumOptions no_start_do_skip(0, true);
+  CumulativeSumOptions has_start_no_skip(10);
+  CumulativeSumOptions has_start_do_skip(10, true);
+
   for (auto ty : NumericTypes()) {
     CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "10"),
-                     ArrayFromJSON(ty, "[10]"), &no_start);
+                     ArrayFromJSON(ty, "[10]"), &no_start_no_skip);
     CheckVectorUnary("cumulative_sum_checked", ScalarFromJSON(ty, "10"),
-                     ArrayFromJSON(ty, "[10]"), &no_start);
+                     ArrayFromJSON(ty, "[10]"), &no_start_no_skip);
 
     CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "10"),
-                     ArrayFromJSON(ty, "[20]"), &with_start);
+                     ArrayFromJSON(ty, "[20]"), &has_start_no_skip);
     CheckVectorUnary("cumulative_sum_checked", ScalarFromJSON(ty, "10"),
-                     ArrayFromJSON(ty, "[20]"), &with_start);
+                     ArrayFromJSON(ty, "[20]"), &has_start_no_skip);
+
+    CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "null"),
+                     ArrayFromJSON(ty, "[null]"), &no_start_no_skip);
+    CheckVectorUnary("cumulative_sum_checked", ScalarFromJSON(ty, "null"),
+                     ArrayFromJSON(ty, "[null]"), &no_start_no_skip);
+    CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "null"),
+                     ArrayFromJSON(ty, "[null]"), &has_start_no_skip);
+    CheckVectorUnary("cumulative_sum_checked", ScalarFromJSON(ty, "null"),
+                     ArrayFromJSON(ty, "[null]"), &has_start_no_skip);
+
+    CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "null"),
+                     ArrayFromJSON(ty, "[0]"), &no_start_do_skip);
+    CheckVectorUnary("cumulative_sum_checked", ScalarFromJSON(ty, "null"),
+                     ArrayFromJSON(ty, "[0]"), &no_start_do_skip);
+    CheckVectorUnary("cumulative_sum", ScalarFromJSON(ty, "null"),
+                     ArrayFromJSON(ty, "[10]"), &has_start_do_skip);
+    CheckVectorUnary("cumulative_sum_checked", ScalarFromJSON(ty, "null"),
+                     ArrayFromJSON(ty, "[10]"), &has_start_do_skip);
   }
 }
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index c6ee1c6c99a..eca707c0d95 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -2511,7 +2511,7 @@ def test_min_max_element_wise():
     assert result == pa.array([1, 2, None])
 
 
-@pytest.mark.parametrize('start', (1.1, 10.5, -10.5))
+@pytest.mark.parametrize('start', (1.25, 10.5, -10.5))
 @pytest.mark.parametrize('skip_nulls', (True, False))
 def test_cumulative_sum(start, skip_nulls):
     # Exact tests (e.g., integral types)
@@ -2537,21 +2537,16 @@ def test_cumulative_sum(start, skip_nulls):
             expected = pc.add(expected_arrays[i], strt)
             assert result.equals(expected)
 
-    # Approximate and NaN tests (e.g., floating-point types)
-    # NOTE: Conversion from Arrow to NumPy replaces null slots with NaNs
-    # which prevent fully validating both states of `skip_nulls` for
-    # floating-point values. Ideally, equality comparisons make use of Arrow's
-    # `equals()` functions but an approximate version is not exposed in Python.
     starts = [start, pa.scalar(start, type=pa.float32()),
               pa.scalar(start, type=pa.float64())]
     for strt in starts:
         arrays = [
-            pa.array([1.1, 2.2, 3.3]),
+            pa.array([1.125, 2.25, 3.03125]),
             pa.array([1, np.nan, 2, -3, 4, 5]),
             pa.array([1, np.nan, None, 3, None, 5])
         ]
         expected_arrays = [
-            np.array([1.1, 3.3, 6.6]),
+            np.array([1.125, 3.375, 6.40625]),
             np.array([1, np.nan, np.nan, np.nan, np.nan, np.nan]),
             np.array([1, np.nan, None, np.nan, None, np.nan])
             if skip_nulls else np.array([1, np.nan, None, None, None, None])