From 4edad4a6d4e311fccea7361b3b2a8f4f044b6024 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 25 Mar 2021 17:17:39 +0100
Subject: [PATCH 01/23] Adding ScalarAggregateOptions.

---
 cpp/src/arrow/compute/api_aggregate.cc        |  10 +-
 cpp/src/arrow/compute/api_aggregate.h         |  33 +++-
 .../arrow/compute/kernels/aggregate_basic.cc  |  31 +++-
 .../compute/kernels/aggregate_basic_avx2.cc   |  18 +-
 .../compute/kernels/aggregate_basic_avx512.cc |  18 +-
 .../kernels/aggregate_basic_internal.h        |  43 ++++-
 .../arrow/compute/kernels/aggregate_test.cc   | 160 ++++++++++++++----
 7 files changed, 257 insertions(+), 56 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.cc b/cpp/src/arrow/compute/api_aggregate.cc
index 5afa1048960..3ee58f11d76 100644
--- a/cpp/src/arrow/compute/api_aggregate.cc
+++ b/cpp/src/arrow/compute/api_aggregate.cc
@@ -29,12 +29,14 @@ Result<Datum> Count(const Datum& value, CountOptions options, ExecContext* ctx)
   return CallFunction("count", {value}, &options, ctx);
 }
 
-Result<Datum> Mean(const Datum& value, ExecContext* ctx) {
-  return CallFunction("mean", {value}, ctx);
+Result<Datum> Mean(const Datum& value, const ScalarAggregateOptions& options,
+                   ExecContext* ctx) {
+  return CallFunction("mean", {value}, &options, ctx);
 }
 
-Result<Datum> Sum(const Datum& value, ExecContext* ctx) {
-  return CallFunction("sum", {value}, ctx);
+Result<Datum> Sum(const Datum& value, const ScalarAggregateOptions& options,
+                  ExecContext* ctx) {
+  return CallFunction("sum", {value}, &options, ctx);
 }
 
 Result<Datum> MinMax(const Datum& value, const MinMaxOptions& options, ExecContext* ctx) {
diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index ca118ec5678..4b25d7faa52 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -37,6 +37,27 @@ class ExecContext;
 // ----------------------------------------------------------------------
 // Aggregate functions
 
+/// \brief Control general scalar aggregate kernel behavior
+///
+/// By default, null values are ignored
+struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
+  enum Mode {
+    /// Skip null values.
+    SKIPNA = 0,
+    /// Calculate over all values.
+    KEEPNA,
+  };
+
+  explicit ScalarAggregateOptions(enum Mode null_handling = SKIPNA,
+                                  uint32_t min_count = 0)
+      : null_handling(null_handling), min_count(min_count) {}
+
+  static ScalarAggregateOptions Defaults() { return ScalarAggregateOptions{}; }
+
+  enum Mode null_handling;
+  uint32_t min_count = 0;
+};
+
 /// \addtogroup compute-concrete-options
 /// @{
 
@@ -167,24 +188,32 @@ Result<Datum> Count(const Datum& datum, CountOptions options = CountOptions::Def
 /// \brief Compute the mean of a numeric array.
 ///
 /// \param[in] value datum to compute the mean, expecting Array
+/// \param[in] options see ScalarAggregateOptions for more information
 /// \param[in] ctx the function execution context, optional
 /// \return datum of the computed mean as a DoubleScalar
 ///
 /// \since 1.0.0
 /// \note API not yet finalized
 ARROW_EXPORT
-Result<Datum> Mean(const Datum& value, ExecContext* ctx = NULLPTR);
+Result<Datum> Mean(
+    const Datum& value,
+    const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
 
 /// \brief Sum values of a numeric array.
 ///
 /// \param[in] value datum to sum, expecting Array or ChunkedArray
+/// \param[in] options see ScalarAggregateOptions for more information
 /// \param[in] ctx the function execution context, optional
 /// \return datum of the computed sum as a Scalar
 ///
 /// \since 1.0.0
 /// \note API not yet finalized
 ARROW_EXPORT
-Result<Datum> Sum(const Datum& value, ExecContext* ctx = NULLPTR);
+Result<Datum> Sum(
+    const Datum& value,
+    const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
 
 /// \brief Calculate the min / max of a numeric array
 ///
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index e4eec50c66d..6f7624a73e1 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -103,20 +103,30 @@ Result<std::unique_ptr<KernelState>> CountInit(KernelContext*,
 // Sum implementation
 
 template <typename ArrowType>
-struct SumImplDefault : public SumImpl<ArrowType, SimdLevel::NONE> {};
+struct SumImplDefault : public SumImpl<ArrowType, SimdLevel::NONE> {
+  explicit SumImplDefault(const ScalarAggregateOptions options) : options(std::move(options)) {}
+  ScalarAggregateOptions options;
+};
 
 template <typename ArrowType>
-struct MeanImplDefault : public MeanImpl<ArrowType, SimdLevel::NONE> {};
+struct MeanImplDefault : public MeanImpl<ArrowType, SimdLevel::NONE> {
+  explicit MeanImplDefault(const ScalarAggregateOptions options) : options(std::move(options)) {}
+  ScalarAggregateOptions options;
+};
 
 Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
                                              const KernelInitArgs& args) {
-  SumLikeInit<SumImplDefault> visitor(ctx, *args.inputs[0].type);
+  SumLikeInit<SumImplDefault> visitor(
+      ctx, *args.inputs[0].type,
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
 Result<std::unique_ptr<KernelState>> MeanInit(KernelContext* ctx,
                                               const KernelInitArgs& args) {
-  SumLikeInit<MeanImplDefault> visitor(ctx, *args.inputs[0].type);
+  SumLikeInit<MeanImplDefault> visitor(
+      ctx, *args.inputs[0].type,
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
@@ -245,6 +255,9 @@ void AddMinMaxKernels(KernelInit init,
 namespace internal {
 namespace {
 
+//using ScalarAggregateState = internal::OptionsWrapper<ScalarAggregateOptions>;
+////const auto& state = checked_cast<const SetLookupState<Type>&>(*ctx->state());
+
 const FunctionDoc count_doc{"Count the number of null / non-null values",
                             ("By default, non-null values are counted.\n"
                              "This can be changed through CountOptions."),
@@ -286,7 +299,10 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
                aggregate::CountInit, func.get());
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  func = std::make_shared<ScalarAggregateFunction>("sum", Arity::Unary(), &sum_doc);
+  static ScalarAggregateOptions sum_default_scalar_aggregate_options =
+      ScalarAggregateOptions::Defaults();
+  func = std::make_shared<ScalarAggregateFunction>("sum", Arity::Unary(), &sum_doc,
+                                                   &sum_default_scalar_aggregate_options);
   aggregate::AddBasicAggKernels(aggregate::SumInit, {boolean()}, int64(), func.get());
   aggregate::AddBasicAggKernels(aggregate::SumInit, SignedIntTypes(), int64(),
                                 func.get());
@@ -310,7 +326,10 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
 #endif
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  func = std::make_shared<ScalarAggregateFunction>("mean", Arity::Unary(), &mean_doc);
+  static ScalarAggregateOptions mean_default_scalar_aggregate_options =
+      ScalarAggregateOptions::Defaults();
+  func = std::make_shared<ScalarAggregateFunction>(
+      "mean", Arity::Unary(), &mean_doc, &mean_default_scalar_aggregate_options);
   aggregate::AddBasicAggKernels(aggregate::MeanInit, {boolean()}, float64(), func.get());
   aggregate::AddBasicAggKernels(aggregate::MeanInit, NumericTypes(), float64(),
                                 func.get());
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index a70363aab9b..6a3049a8317 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -25,20 +25,30 @@ namespace aggregate {
 // Sum implementation
 
 template <typename ArrowType>
-struct SumImplAvx2 : public SumImpl<ArrowType, SimdLevel::AVX2> {};
+struct SumImplAvx2 : public SumImpl<ArrowType, SimdLevel::AVX2> {
+  explicit SumImplAvx2(const ScalarAggregateOptions options) : options(std::move(options)) {}
+  ScalarAggregateOptions options;
+};
 
 template <typename ArrowType>
-struct MeanImplAvx2 : public MeanImpl<ArrowType, SimdLevel::AVX2> {};
+struct MeanImplAvx2 : public MeanImpl<ArrowType, SimdLevel::AVX2> {
+  explicit MeanImplAvx2(const ScalarAggregateOptions options) : options(std::move(options)) {}
+  ScalarAggregateOptions options;
+};
 
 Result<std::unique_ptr<KernelState>> SumInitAvx2(KernelContext* ctx,
                                                  const KernelInitArgs& args) {
-  SumLikeInit<SumImplAvx2> visitor(ctx, *args.inputs[0].type);
+  SumLikeInit<SumImplAvx2> visitor(
+      ctx, *args.inputs[0].type,
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
 Result<std::unique_ptr<KernelState>> MeanInitAvx2(KernelContext* ctx,
                                                   const KernelInitArgs& args) {
-  SumLikeInit<MeanImplAvx2> visitor(ctx, *args.inputs[0].type);
+  SumLikeInit<MeanImplAvx2> visitor(
+      ctx, *args.inputs[0].type,
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 1ecbd7041e6..499c4b58f4a 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -25,20 +25,30 @@ namespace aggregate {
 // Sum implementation
 
 template <typename ArrowType>
-struct SumImplAvx512 : public SumImpl<ArrowType, SimdLevel::AVX512> {};
+struct SumImplAvx512 : public SumImpl<ArrowType, SimdLevel::AVX512> {
+  explicit SumImplAvx512(const ScalarAggregateOptions options) : options(std::move(options)) {}
+  ScalarAggregateOptions options;
+};
 
 template <typename ArrowType>
-struct MeanImplAvx512 : public MeanImpl<ArrowType, SimdLevel::AVX512> {};
+struct MeanImplAvx512 : public MeanImpl<ArrowType, SimdLevel::AVX512> {
+  explicit MeanImplAvx512(const ScalarAggregateOptions options) : options(std::move(options)) {}
+  ScalarAggregateOptions options;
+};
 
 Result<std::unique_ptr<KernelState>> SumInitAvx512(KernelContext* ctx,
                                                    const KernelInitArgs& args) {
-  SumLikeInit<SumImplAvx512> visitor(ctx, *args.inputs[0].type);
+  SumLikeInit<SumImplAvx512> visitor(
+      ctx, *args.inputs[0].type,
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
 Result<std::unique_ptr<KernelState>> MeanInitAvx512(KernelContext* ctx,
                                                     const KernelInitArgs& args) {
-  SumLikeInit<MeanImplAvx512> visitor(ctx, *args.inputs[0].type);
+  SumLikeInit<MeanImplAvx512> visitor(
+      ctx, *args.inputs[0].type,
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index f8db180b1e3..f8ae452ca96 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -60,6 +60,7 @@ struct SumImpl : public ScalarAggregator {
 
   Status Consume(KernelContext*, const ExecBatch& batch) override {
     const auto& data = batch[0].array();
+    this->length = data->length;
     this->count = data->length - data->GetNullCount();
     if (is_boolean_type<ArrowType>::value) {
       this->sum = static_cast<typename SumType::c_type>(BooleanArray(data).true_count());
@@ -72,12 +73,24 @@ struct SumImpl : public ScalarAggregator {
 
   Status MergeFrom(KernelContext*, KernelState&& src) override {
     const auto& other = checked_cast<const ThisType&>(src);
+    this->length += other.length;
     this->count += other.count;
     this->sum += other.sum;
     return Status::OK();
   }
 
   Status Finalize(KernelContext*, Datum* out) override {
+    const auto& state = checked_cast<const SumImpl&>(*ctx->state());
+//    ARROW_LOG(INFO) << "options.min_count: " << options.min_count;
+    ARROW_LOG(INFO) << "SumImpl: options.null_handling: " << options.null_handling << " options.min_count: " << options.min_count;
+
+//    ARROW_LOG(INFO) << "state.options.min_count: " << state.options.min_count;
+//    ARROW_LOG(INFO) << "state.options.null_handling: " << state.options.null_handling;
+
+    if (state.options.min_count != 0 ||  options.min_count != 0) {
+      ARROW_LOG(FATAL) << "state.options.min_count: " << state.options.min_count;
+    }
+
     if (this->count == 0) {
       out->value = std::make_shared<OutputType>();
     } else {
@@ -86,21 +99,38 @@ struct SumImpl : public ScalarAggregator {
     return Status::OK();
   }
 
+  size_t length = 0;
   size_t count = 0;
   typename SumType::c_type sum = 0;
+  ScalarAggregateOptions options;
 };
 
 template <typename ArrowType, SimdLevel::type SimdLevel>
 struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
   Status Finalize(KernelContext*, Datum* out) override {
-    if (this->count == 0) {
+    //    const ScalarAggregateOptions& options = checked_cast<const ScalarAggregateState&>(*ctx->state()).options;
+    const auto& state = checked_cast<const MeanImpl&>(*ctx->state());
+//    ARROW_LOG(INFO) << "options.min_count: " << options.min_count;
+    ARROW_LOG(INFO) << "SumImpl: options.null_handling: " << options.null_handling << " options.min_count: " << options.min_count;
+
+//    ARROW_LOG(INFO) << "state.options.min_count: " << state.options.min_count;
+//    ARROW_LOG(INFO) << "state.options.null_handling: " << state.options.null_handling;
+    if (state.options.min_count != 0 || options.min_count != 0) {
+      ARROW_LOG(FATAL) << "state.options.min_count: " << state.options.min_count;
+    }
+
+    if (this->count == 0 || this->count < options.min_count) {
       out->value = std::make_shared<DoubleScalar>();
-    } else {
+    } else if (options.null_handling == ScalarAggregateOptions::SKIPNA) {
       const double mean = static_cast<double>(this->sum) / this->count;
       out->value = std::make_shared<DoubleScalar>(mean);
+    } else {
+      const double mean = static_cast<double>(this->sum) / this->length;
+      out->value = std::make_shared<DoubleScalar>(mean);
     }
     return Status::OK();
   }
+  ScalarAggregateOptions options;
 };
 
 template <template <typename> class KernelClass>
@@ -108,8 +138,11 @@ struct SumLikeInit {
   std::unique_ptr<KernelState> state;
   KernelContext* ctx;
   const DataType& type;
+  ScalarAggregateOptions options;
 
-  SumLikeInit(KernelContext* ctx, const DataType& type) : ctx(ctx), type(type) {}
+  SumLikeInit(KernelContext* ctx, const DataType& type,
+              const ScalarAggregateOptions& options)
+      : ctx(ctx), type(type), options(options) {}
 
   Status Visit(const DataType&) { return Status::NotImplemented("No sum implemented"); }
 
@@ -118,13 +151,13 @@ struct SumLikeInit {
   }
 
   Status Visit(const BooleanType&) {
-    state.reset(new KernelClass<BooleanType>());
+    state.reset(new KernelClass<BooleanType>(options));
     return Status::OK();
   }
 
   template <typename Type>
   enable_if_number<Type, Status> Visit(const Type&) {
-    state.reset(new KernelClass<Type>());
+    state.reset(new KernelClass<Type>(options));
     return Status::OK();
   }
 
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 455a3edaaf8..490af75f6af 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -104,31 +104,38 @@ static Datum NaiveSum(const Array& array) {
 }
 
 template <typename ArrowType>
-void ValidateSum(const Array& input, Datum expected) {
+void ValidateSum(
+    const Array& input, Datum expected,
+    const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults()) {
   using OutputType = typename FindAccumulatorType<ArrowType>::Type;
 
-  ASSERT_OK_AND_ASSIGN(Datum result, Sum(input));
+  ASSERT_OK_AND_ASSIGN(Datum result, Sum(input, options));
   DatumEqual<OutputType>::EnsureEqual(result, expected);
 }
 
 template <typename ArrowType>
-void ValidateSum(const std::shared_ptr<ChunkedArray>& input, Datum expected) {
+void ValidateSum(const std::shared_ptr<ChunkedArray>& input, Datum expected,
+                 const ScalarAggregateOptions& options) {
   using OutputType = typename FindAccumulatorType<ArrowType>::Type;
 
-  ASSERT_OK_AND_ASSIGN(Datum result, Sum(input));
+  ASSERT_OK_AND_ASSIGN(Datum result, Sum(input, options));
   DatumEqual<OutputType>::EnsureEqual(result, expected);
 }
 
 template <typename ArrowType>
-void ValidateSum(const char* json, Datum expected) {
+void ValidateSum(
+    const char* json, Datum expected,
+    const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults()) {
   auto array = ArrayFromJSON(TypeTraits<ArrowType>::type_singleton(), json);
-  ValidateSum<ArrowType>(*array, expected);
+  ValidateSum<ArrowType>(*array, expected, options);
 }
 
 template <typename ArrowType>
-void ValidateSum(const std::vector<std::string>& json, Datum expected) {
+void ValidateSum(
+    const std::vector<std::string>& json, Datum expected,
+    const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults()) {
   auto array = ChunkedArrayFromJSON(TypeTraits<ArrowType>::type_singleton(), json);
-  ValidateSum<ArrowType>(array, expected);
+  ValidateSum<ArrowType>(array, expected, options);
 }
 
 template <typename ArrowType>
@@ -136,39 +143,71 @@ void ValidateSum(const Array& array) {
   ValidateSum<ArrowType>(array, NaiveSum<ArrowType>(array));
 }
 
-using UnaryOp = Result<Datum>(const Datum&, ExecContext*);
+using UnaryOp = Result<Datum>(const Datum&, const ScalarAggregateOptions&, ExecContext*);
 
-template <UnaryOp& Op, typename ScalarType>
+template <UnaryOp& Op, typename ScalarAggregateOptions, typename ScalarType>
 void ValidateBooleanAgg(const std::string& json,
-                        const std::shared_ptr<ScalarType>& expected) {
+                        const std::shared_ptr<ScalarType>& expected,
+                        const ScalarAggregateOptions& options) {
   auto array = ArrayFromJSON(boolean(), json);
   auto exp = Datum(expected);
-  ASSERT_OK_AND_ASSIGN(Datum result, Op(array, nullptr));
+  ASSERT_OK_AND_ASSIGN(Datum result, Op(array, options, nullptr));
   ASSERT_TRUE(result.Equals(exp));
 }
 
 TEST(TestBooleanAggregation, Sum) {
-  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>());
-  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>());
-  ValidateBooleanAgg<Sum>("[null, false]", std::make_shared<UInt64Scalar>(0));
-  ValidateBooleanAgg<Sum>("[true]", std::make_shared<UInt64Scalar>(1));
-  ValidateBooleanAgg<Sum>("[true, false, true]", std::make_shared<UInt64Scalar>(2));
+  const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults();
+  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(), options);
+  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(), options);
+  ValidateBooleanAgg<Sum>("[null, false]", std::make_shared<UInt64Scalar>(0), options);
+  ValidateBooleanAgg<Sum>("[true]", std::make_shared<UInt64Scalar>(1), options);
+  ValidateBooleanAgg<Sum>("[true, false, true]", std::make_shared<UInt64Scalar>(2),
+                          options);
   ValidateBooleanAgg<Sum>("[true, false, true, true, null]",
-                          std::make_shared<UInt64Scalar>(3));
+                          std::make_shared<UInt64Scalar>(3), options);
+
+  const char* json = "[true, null, false, null]";
+  ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
+  ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
+    ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
+    ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
+  ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
+  ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
+    ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
+    ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
 }
 
 TEST(TestBooleanAggregation, Mean) {
-  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>());
-  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>());
-  ValidateBooleanAgg<Mean>("[null, false]", std::make_shared<DoubleScalar>(0));
-  ValidateBooleanAgg<Mean>("[true]", std::make_shared<DoubleScalar>(1));
+  const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults();
+  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(), options);
+  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(), options);
+  ValidateBooleanAgg<Mean>("[null, false]", std::make_shared<DoubleScalar>(0), options);
+  ValidateBooleanAgg<Mean>("[true]", std::make_shared<DoubleScalar>(1), options);
   ValidateBooleanAgg<Mean>("[true, false, true, false]",
-                           std::make_shared<DoubleScalar>(0.5));
-  ValidateBooleanAgg<Mean>("[true, null]", std::make_shared<DoubleScalar>(1));
+                           std::make_shared<DoubleScalar>(0.5), options);
+  ValidateBooleanAgg<Mean>("[true, null]", std::make_shared<DoubleScalar>(1), options);
   ValidateBooleanAgg<Mean>("[true, null, false, true, true]",
-                           std::make_shared<DoubleScalar>(0.75));
+                           std::make_shared<DoubleScalar>(0.75), options);
   ValidateBooleanAgg<Mean>("[true, null, false, false, false]",
-                           std::make_shared<DoubleScalar>(0.25));
+                           std::make_shared<DoubleScalar>(0.25), options);
+
+  const char* json = "[true, null, false, null]";
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
+                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
+                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
+  //  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
+                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
+                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
+  //  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
 }
 
 template <typename ArrowType>
@@ -208,6 +247,32 @@ TYPED_TEST(TestNumericSumKernel, SimpleSum) {
                          Datum(std::make_shared<ScalarType>(expected_result)));
 }
 
+TYPED_TEST_SUITE(TestNumericSumKernel, NumericArrowTypes);
+TYPED_TEST(TestNumericSumKernel, ScalarAggregateOptions) {
+  using SumType = typename FindAccumulatorType<TypeParam>::Type;
+  using ScalarType = typename TypeTraits<SumType>::ScalarType;
+  using T = typename TypeParam::c_type;
+
+  const T expected_result = static_cast<T>(14);
+  auto null_result = Datum(std::make_shared<ScalarType>());
+  auto result = Datum(std::make_shared<ScalarType>(expected_result));
+  const char* json = "[1, null, 3, null, 3, null, 7]";
+
+  ValidateSum<TypeParam>(json, result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
+  ValidateSum<TypeParam>(json, result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 4));
+  //  ValidateSum<TypeParam>(json, null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
+
+  ValidateSum<TypeParam>(json, result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
+  ValidateSum<TypeParam>(json, result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 4));
+  //  ValidateSum<TypeParam>(json, null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 5));
+}
+
 template <typename ArrowType>
 class TestRandomNumericSumKernel : public ::testing::Test {};
 
@@ -374,22 +439,26 @@ static Datum NaiveMean(const Array& array) {
 }
 
 template <typename ArrowType>
-void ValidateMean(const Array& input, Datum expected) {
+void ValidateMean(const Array& input, Datum expected,
+                  const ScalarAggregateOptions& options) {
   using OutputType = typename FindAccumulatorType<DoubleType>::Type;
 
-  ASSERT_OK_AND_ASSIGN(Datum result, Mean(input));
+  ASSERT_OK_AND_ASSIGN(Datum result, Mean(input, options, nullptr));
   DatumEqual<OutputType>::EnsureEqual(result, expected);
 }
 
 template <typename ArrowType>
-void ValidateMean(const char* json, Datum expected) {
+void ValidateMean(
+    const char* json, Datum expected,
+    const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults()) {
   auto array = ArrayFromJSON(TypeTraits<ArrowType>::type_singleton(), json);
-  ValidateMean<ArrowType>(*array, expected);
+  ValidateMean<ArrowType>(*array, expected, options);
 }
 
 template <typename ArrowType>
 void ValidateMean(const Array& array) {
-  ValidateMean<ArrowType>(array, NaiveMean<ArrowType>(array));
+  ValidateMean<ArrowType>(array, NaiveMean<ArrowType>(array),
+                          ScalarAggregateOptions::Defaults());
 }
 
 template <typename ArrowType>
@@ -415,6 +484,35 @@ TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
                           Datum(std::make_shared<ScalarType>(1.0)));
 }
 
+TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
+TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
+  using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
+  using T = typename TypeParam::c_type;
+
+  auto expected_result_keepna = Datum(std::make_shared<ScalarType>(static_cast<T>(2)));
+  auto expected_result_skipna = Datum(std::make_shared<ScalarType>(static_cast<T>(3)));
+  auto null_result = Datum(std::make_shared<ScalarType>());
+  const char* json = "[1, null, 2, 2, null, 7]";
+
+  ValidateMean<TypeParam>(json, expected_result_skipna,
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
+  ValidateMean<TypeParam>(json, expected_result_skipna,
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
+  ValidateMean<TypeParam>(json, expected_result_skipna,
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 4));
+  //  ValidateMean<TypeParam>(json, null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
+
+  ValidateMean<TypeParam>(json, expected_result_keepna,
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
+  ValidateMean<TypeParam>(json, expected_result_keepna,
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
+  ValidateMean<TypeParam>(json, expected_result_keepna,
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 4));
+  //  ValidateMean<TypeParam>(json, null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 15));
+}
+
 template <typename ArrowType>
 class TestRandomNumericMeanKernel : public ::testing::Test {};
 

From 9e90fb045e3a4d998ebe6bda24c1a72696f6fd15 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Mon, 12 Apr 2021 17:38:16 +0200
Subject: [PATCH 02/23] Minor changes.

---
 cpp/src/arrow/compute/api_aggregate.h         |  8 ++--
 .../arrow/compute/kernels/aggregate_basic.cc  | 13 +++----
 .../compute/kernels/aggregate_basic_avx2.cc   | 10 +++--
 .../compute/kernels/aggregate_basic_avx512.cc | 10 +++--
 .../kernels/aggregate_basic_internal.h        | 27 +++-----------
 .../arrow/compute/kernels/aggregate_test.cc   | 37 +++++++++----------
 6 files changed, 45 insertions(+), 60 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index 4b25d7faa52..ecf1ff93340 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -42,10 +42,10 @@ class ExecContext;
 /// By default, null values are ignored
 struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
   enum Mode {
-    /// Skip null values.
-    SKIPNA = 0,
     /// Calculate over all values.
-    KEEPNA,
+    KEEPNA = 0,
+    /// Skip null values.
+    SKIPNA,
   };
 
   explicit ScalarAggregateOptions(enum Mode null_handling = SKIPNA,
@@ -55,7 +55,7 @@ struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
   static ScalarAggregateOptions Defaults() { return ScalarAggregateOptions{}; }
 
   enum Mode null_handling;
-  uint32_t min_count = 0;
+  uint32_t min_count;
 };
 
 /// \addtogroup compute-concrete-options
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 6f7624a73e1..2e2d81d247f 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -104,14 +104,16 @@ Result<std::unique_ptr<KernelState>> CountInit(KernelContext*,
 
 template <typename ArrowType>
 struct SumImplDefault : public SumImpl<ArrowType, SimdLevel::NONE> {
-  explicit SumImplDefault(const ScalarAggregateOptions options) : options(std::move(options)) {}
-  ScalarAggregateOptions options;
+  explicit SumImplDefault(const ScalarAggregateOptions& options_) {
+    this->options = options_;
+  }
 };
 
 template <typename ArrowType>
 struct MeanImplDefault : public MeanImpl<ArrowType, SimdLevel::NONE> {
-  explicit MeanImplDefault(const ScalarAggregateOptions options) : options(std::move(options)) {}
-  ScalarAggregateOptions options;
+  explicit MeanImplDefault(const ScalarAggregateOptions& options_) {
+    this->options = options_;
+  }
 };
 
 Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
@@ -255,9 +257,6 @@ void AddMinMaxKernels(KernelInit init,
 namespace internal {
 namespace {
 
-//using ScalarAggregateState = internal::OptionsWrapper<ScalarAggregateOptions>;
-////const auto& state = checked_cast<const SetLookupState<Type>&>(*ctx->state());
-
 const FunctionDoc count_doc{"Count the number of null / non-null values",
                             ("By default, non-null values are counted.\n"
                              "This can be changed through CountOptions."),
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index 6a3049a8317..7360fa33359 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -26,14 +26,16 @@ namespace aggregate {
 
 template <typename ArrowType>
 struct SumImplAvx2 : public SumImpl<ArrowType, SimdLevel::AVX2> {
-  explicit SumImplAvx2(const ScalarAggregateOptions options) : options(std::move(options)) {}
-  ScalarAggregateOptions options;
+  explicit SumImplAvx2(const ScalarAggregateOptions& options_) {
+    this->options = options_;
+  }
 };
 
 template <typename ArrowType>
 struct MeanImplAvx2 : public MeanImpl<ArrowType, SimdLevel::AVX2> {
-  explicit MeanImplAvx2(const ScalarAggregateOptions options) : options(std::move(options)) {}
-  ScalarAggregateOptions options;
+  explicit MeanImplAvx2(const ScalarAggregateOptions& options_) {
+    this->options = options_;
+  }
 };
 
 Result<std::unique_ptr<KernelState>> SumInitAvx2(KernelContext* ctx,
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 499c4b58f4a..e5d7ec1931a 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -26,14 +26,16 @@ namespace aggregate {
 
 template <typename ArrowType>
 struct SumImplAvx512 : public SumImpl<ArrowType, SimdLevel::AVX512> {
-  explicit SumImplAvx512(const ScalarAggregateOptions options) : options(std::move(options)) {}
-  ScalarAggregateOptions options;
+  explicit SumImplAvx512(const ScalarAggregateOptions& options_) {
+    this->options = options_;
+  }
 };
 
 template <typename ArrowType>
 struct MeanImplAvx512 : public MeanImpl<ArrowType, SimdLevel::AVX512> {
-  explicit MeanImplAvx512(const ScalarAggregateOptions options) : options(std::move(options)) {}
-  ScalarAggregateOptions options;
+  explicit MeanImplAvx512(const ScalarAggregateOptions& options_) {
+    this->options = options_;
+  }
 };
 
 Result<std::unique_ptr<KernelState>> SumInitAvx512(KernelContext* ctx,
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index f8ae452ca96..73359e83d1e 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -81,17 +81,8 @@ struct SumImpl : public ScalarAggregator {
 
   Status Finalize(KernelContext*, Datum* out) override {
     const auto& state = checked_cast<const SumImpl&>(*ctx->state());
-//    ARROW_LOG(INFO) << "options.min_count: " << options.min_count;
-    ARROW_LOG(INFO) << "SumImpl: options.null_handling: " << options.null_handling << " options.min_count: " << options.min_count;
 
-//    ARROW_LOG(INFO) << "state.options.min_count: " << state.options.min_count;
-//    ARROW_LOG(INFO) << "state.options.null_handling: " << state.options.null_handling;
-
-    if (state.options.min_count != 0 ||  options.min_count != 0) {
-      ARROW_LOG(FATAL) << "state.options.min_count: " << state.options.min_count;
-    }
-
-    if (this->count == 0) {
+    if (this->count == 0 || this->count < options.min_count) {
       out->value = std::make_shared<OutputType>();
     } else {
       out->value = MakeScalar(this->sum);
@@ -110,22 +101,14 @@ struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
   Status Finalize(KernelContext*, Datum* out) override {
     //    const ScalarAggregateOptions& options = checked_cast<const ScalarAggregateState&>(*ctx->state()).options;
     const auto& state = checked_cast<const MeanImpl&>(*ctx->state());
-//    ARROW_LOG(INFO) << "options.min_count: " << options.min_count;
-    ARROW_LOG(INFO) << "SumImpl: options.null_handling: " << options.null_handling << " options.min_count: " << options.min_count;
-
-//    ARROW_LOG(INFO) << "state.options.min_count: " << state.options.min_count;
-//    ARROW_LOG(INFO) << "state.options.null_handling: " << state.options.null_handling;
-    if (state.options.min_count != 0 || options.min_count != 0) {
-      ARROW_LOG(FATAL) << "state.options.min_count: " << state.options.min_count;
-    }
 
     if (this->count == 0 || this->count < options.min_count) {
       out->value = std::make_shared<DoubleScalar>();
-    } else if (options.null_handling == ScalarAggregateOptions::SKIPNA) {
-      const double mean = static_cast<double>(this->sum) / this->count;
+    } else if (options.null_handling == ScalarAggregateOptions::KEEPNA) {
+      const double mean = static_cast<double>(this->sum) / this->length;
       out->value = std::make_shared<DoubleScalar>(mean);
     } else {
-      const double mean = static_cast<double>(this->sum) / this->length;
+      const double mean = static_cast<double>(this->sum) / this->count;
       out->value = std::make_shared<DoubleScalar>(mean);
     }
     return Status::OK();
@@ -138,7 +121,7 @@ struct SumLikeInit {
   std::unique_ptr<KernelState> state;
   KernelContext* ctx;
   const DataType& type;
-  ScalarAggregateOptions options;
+  const ScalarAggregateOptions& options;
 
   SumLikeInit(KernelContext* ctx, const DataType& type,
               const ScalarAggregateOptions& options)
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 490af75f6af..6e036b13cd9 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -171,14 +171,14 @@ TEST(TestBooleanAggregation, Sum) {
                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
-    ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
-    ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
+  ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
-    ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
-    ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
+  ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
 }
 
 TEST(TestBooleanAggregation, Mean) {
@@ -200,14 +200,14 @@ TEST(TestBooleanAggregation, Mean) {
                            ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
                            ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
-  //  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
-  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
+                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.25),
                            ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
-  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.25),
                            ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
-  //  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
+                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
 }
 
 template <typename ArrowType>
@@ -262,15 +262,14 @@ TYPED_TEST(TestNumericSumKernel, ScalarAggregateOptions) {
                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
   ValidateSum<TypeParam>(json, result,
                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 4));
-  //  ValidateSum<TypeParam>(json, null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
-
+  ValidateSum<TypeParam>(json, null_result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
   ValidateSum<TypeParam>(json, result,
                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
   ValidateSum<TypeParam>(json, result,
                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 4));
-  //  ValidateSum<TypeParam>(json, null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 5));
+  ValidateSum<TypeParam>(json, null_result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 5));
 }
 
 template <typename ArrowType>
@@ -500,8 +499,8 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
   ValidateMean<TypeParam>(json, expected_result_skipna,
                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 4));
-  //  ValidateMean<TypeParam>(json, null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
+  ValidateMean<TypeParam>(json, null_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
 
   ValidateMean<TypeParam>(json, expected_result_keepna,
                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
@@ -509,8 +508,8 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
   ValidateMean<TypeParam>(json, expected_result_keepna,
                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 4));
-  //  ValidateMean<TypeParam>(json, null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 15));
+  ValidateMean<TypeParam>(json, null_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 15));
 }
 
 template <typename ArrowType>

From 78d8fa0534d6b2cf0f6c56c4747e6ace537ceb75 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 13 Apr 2021 11:55:01 +0200
Subject: [PATCH 03/23] Replacing MinMaxOptions with ScalarAggregateOptions.

---
 cpp/src/arrow/compute/api_aggregate.cc        |  2 +-
 cpp/src/arrow/compute/api_aggregate.h         | 28 ++++---------------
 .../arrow/compute/kernels/aggregate_basic.cc  | 13 ++++-----
 .../compute/kernels/aggregate_basic_avx2.cc   |  2 +-
 .../compute/kernels/aggregate_basic_avx512.cc |  2 +-
 .../kernels/aggregate_basic_internal.h        | 15 +++++-----
 .../arrow/compute/kernels/aggregate_test.cc   | 26 ++++++++---------
 .../arrow/compute/kernels/hash_aggregate.cc   | 14 +++++-----
 .../compute/kernels/hash_aggregate_test.cc    |  4 +--
 9 files changed, 43 insertions(+), 63 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.cc b/cpp/src/arrow/compute/api_aggregate.cc
index 3ee58f11d76..bbb26b7af89 100644
--- a/cpp/src/arrow/compute/api_aggregate.cc
+++ b/cpp/src/arrow/compute/api_aggregate.cc
@@ -39,7 +39,7 @@ Result<Datum> Sum(const Datum& value, const ScalarAggregateOptions& options,
   return CallFunction("sum", {value}, &options, ctx);
 }
 
-Result<Datum> MinMax(const Datum& value, const MinMaxOptions& options, ExecContext* ctx) {
+Result<Datum> MinMax(const Datum& value, const ScalarAggregateOptions& options, ExecContext* ctx) {
   return CallFunction("min_max", {value}, &options, ctx);
 }
 
diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index ecf1ff93340..689737f212d 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -42,10 +42,10 @@ class ExecContext;
 /// By default, null values are ignored
 struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
   enum Mode {
-    /// Calculate over all values.
-    KEEPNA = 0,
     /// Skip null values.
-    SKIPNA,
+    SKIPNA = 0,
+    /// Calculate over all values.
+    KEEPNA,
   };
 
   explicit ScalarAggregateOptions(enum Mode null_handling = SKIPNA,
@@ -79,24 +79,6 @@ struct ARROW_EXPORT CountOptions : public FunctionOptions {
   enum Mode count_mode;
 };
 
-/// \brief Control MinMax kernel behavior
-///
-/// By default, null values are ignored
-struct ARROW_EXPORT MinMaxOptions : public FunctionOptions {
-  enum Mode {
-    /// Skip null values
-    SKIP = 0,
-    /// Any nulls will result in null output
-    EMIT_NULL
-  };
-
-  explicit MinMaxOptions(enum Mode null_handling = SKIP) : null_handling(null_handling) {}
-
-  static MinMaxOptions Defaults() { return MinMaxOptions{}; }
-
-  enum Mode null_handling;
-};
-
 /// \brief Control Mode kernel behavior
 ///
 /// Returns top-n common values and counts.
@@ -221,7 +203,7 @@ Result<Datum> Sum(
 /// struct<min: T, max: T>, where T is the input type
 ///
 /// \param[in] value input datum, expecting Array or ChunkedArray
-/// \param[in] options see MinMaxOptions for more information
+/// \param[in] options see ScalarAggregateOptions for more information
 /// \param[in] ctx the function execution context, optional
 /// \return resulting datum as a struct<min: T, max: T> scalar
 ///
@@ -229,7 +211,7 @@ Result<Datum> Sum(
 /// \note API not yet finalized
 ARROW_EXPORT
 Result<Datum> MinMax(const Datum& value,
-                     const MinMaxOptions& options = MinMaxOptions::Defaults(),
+                     const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults(),
                      ExecContext* ctx = NULLPTR);
 
 /// \brief Test whether any element in a boolean array evaluates to true.
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 2e2d81d247f..39ed8f5dc56 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -139,7 +139,7 @@ Result<std::unique_ptr<KernelState>> MinMaxInit(KernelContext* ctx,
                                                 const KernelInitArgs& args) {
   MinMaxInitState<SimdLevel::NONE> visitor(
       ctx, *args.inputs[0].type, args.kernel->signature->out_type().type(),
-      static_cast<const MinMaxOptions&>(*args.options));
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
@@ -273,9 +273,9 @@ const FunctionDoc mean_doc{"Compute the mean of a numeric array",
 
 const FunctionDoc min_max_doc{"Compute the minimum and maximum values of a numeric array",
                               ("Null values are ignored by default.\n"
-                               "This can be changed through MinMaxOptions."),
+                               "This can be changed through ScalarAggregateOptions."),
                               {"array"},
-                              "MinMaxOptions"};
+                              "ScalarAggregateOptions"};
 
 const FunctionDoc any_doc{"Test whether any element in a boolean array evaluates to true",
                           ("Null values are ignored."),
@@ -325,8 +325,7 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
 #endif
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  static ScalarAggregateOptions mean_default_scalar_aggregate_options =
-      ScalarAggregateOptions::Defaults();
+  static ScalarAggregateOptions mean_default_scalar_aggregate_options = ScalarAggregateOptions::Defaults();
   func = std::make_shared<ScalarAggregateFunction>(
       "mean", Arity::Unary(), &mean_doc, &mean_default_scalar_aggregate_options);
   aggregate::AddBasicAggKernels(aggregate::MeanInit, {boolean()}, float64(), func.get());
@@ -345,9 +344,9 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
 #endif
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  static auto default_minmax_options = MinMaxOptions::Defaults();
+  static auto minmax_default_scalar_aggregate_options = ScalarAggregateOptions::Defaults();
   func = std::make_shared<ScalarAggregateFunction>("min_max", Arity::Unary(),
-                                                   &min_max_doc, &default_minmax_options);
+                                                   &min_max_doc, &minmax_default_scalar_aggregate_options);
   aggregate::AddMinMaxKernels(aggregate::MinMaxInit, {boolean()}, func.get());
   aggregate::AddMinMaxKernels(aggregate::MinMaxInit, NumericTypes(), func.get());
   // Add the SIMD variants for min max
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index 7360fa33359..8d3e5a0409d 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -61,7 +61,7 @@ Result<std::unique_ptr<KernelState>> MinMaxInitAvx2(KernelContext* ctx,
                                                     const KernelInitArgs& args) {
   MinMaxInitState<SimdLevel::AVX2> visitor(
       ctx, *args.inputs[0].type, args.kernel->signature->out_type().type(),
-      static_cast<const MinMaxOptions&>(*args.options));
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index e5d7ec1931a..4f8ad74a086 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -61,7 +61,7 @@ Result<std::unique_ptr<KernelState>> MinMaxInitAvx512(KernelContext* ctx,
                                                       const KernelInitArgs& args) {
   MinMaxInitState<SimdLevel::AVX512> visitor(
       ctx, *args.inputs[0].type, args.kernel->signature->out_type().type(),
-      static_cast<const MinMaxOptions&>(*args.options));
+      static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
 }
 
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 73359e83d1e..9d40dd1edea 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -81,7 +81,6 @@ struct SumImpl : public ScalarAggregator {
 
   Status Finalize(KernelContext*, Datum* out) override {
     const auto& state = checked_cast<const SumImpl&>(*ctx->state());
-
     if (this->count == 0 || this->count < options.min_count) {
       out->value = std::make_shared<OutputType>();
     } else {
@@ -234,7 +233,7 @@ struct MinMaxImpl : public ScalarAggregator {
   using ThisType = MinMaxImpl<ArrowType, SimdLevel>;
   using StateType = MinMaxState<ArrowType, SimdLevel>;
 
-  MinMaxImpl(const std::shared_ptr<DataType>& out_type, const MinMaxOptions& options)
+  MinMaxImpl(const std::shared_ptr<DataType>& out_type, const ScalarAggregateOptions& options)
       : out_type(out_type), options(options) {}
 
   Status Consume(KernelContext*, const ExecBatch& batch) override {
@@ -246,7 +245,7 @@ struct MinMaxImpl : public ScalarAggregator {
     local.has_nulls = null_count > 0;
     local.has_values = (arr.length() - null_count) > 0;
 
-    if (local.has_nulls && options.null_handling == MinMaxOptions::EMIT_NULL) {
+    if (local.has_nulls && options.null_handling == ScalarAggregateOptions::KEEPNA) {
       this->state = local;
       return Status::OK();
     }
@@ -273,7 +272,7 @@ struct MinMaxImpl : public ScalarAggregator {
 
     std::vector<std::shared_ptr<Scalar>> values;
     if (!state.has_values ||
-        (state.has_nulls && options.null_handling == MinMaxOptions::EMIT_NULL)) {
+        (state.has_nulls && options.null_handling == ScalarAggregateOptions::KEEPNA)) {
       // (null, null)
       values = {std::make_shared<ScalarType>(), std::make_shared<ScalarType>()};
     } else {
@@ -285,7 +284,7 @@ struct MinMaxImpl : public ScalarAggregator {
   }
 
   std::shared_ptr<DataType> out_type;
-  MinMaxOptions options;
+  ScalarAggregateOptions options;
   MinMaxState<ArrowType, SimdLevel> state;
 
  private:
@@ -364,7 +363,7 @@ struct BooleanMinMaxImpl : public MinMaxImpl<BooleanType, SimdLevel> {
 
     local.has_nulls = null_count > 0;
     local.has_values = valid_count > 0;
-    if (local.has_nulls && options.null_handling == MinMaxOptions::EMIT_NULL) {
+    if (local.has_nulls && options.null_handling == ScalarAggregateOptions::KEEPNA) {
       this->state = local;
       return Status::OK();
     }
@@ -385,10 +384,10 @@ struct MinMaxInitState {
   KernelContext* ctx;
   const DataType& in_type;
   const std::shared_ptr<DataType>& out_type;
-  const MinMaxOptions& options;
+  const ScalarAggregateOptions& options;
 
   MinMaxInitState(KernelContext* ctx, const DataType& in_type,
-                  const std::shared_ptr<DataType>& out_type, const MinMaxOptions& options)
+                  const std::shared_ptr<DataType>& out_type, const ScalarAggregateOptions& options)
       : ctx(ctx), in_type(in_type), out_type(out_type), options(options) {}
 
   Status Visit(const DataType&) {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 6e036b13cd9..67d7a63dcba 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -566,7 +566,7 @@ class TestPrimitiveMinMaxKernel : public ::testing::Test {
 
  public:
   void AssertMinMaxIs(const Datum& array, c_type expected_min, c_type expected_max,
-                      const MinMaxOptions& options) {
+                      const ScalarAggregateOptions& options) {
     ASSERT_OK_AND_ASSIGN(Datum out, MinMax(array, options));
     const StructScalar& value = out.scalar_as<StructScalar>();
 
@@ -578,31 +578,31 @@ class TestPrimitiveMinMaxKernel : public ::testing::Test {
   }
 
   void AssertMinMaxIs(const std::string& json, c_type expected_min, c_type expected_max,
-                      const MinMaxOptions& options) {
+                      const ScalarAggregateOptions& options) {
     auto array = ArrayFromJSON(type_singleton(), json);
     AssertMinMaxIs(array, expected_min, expected_max, options);
   }
 
   void AssertMinMaxIs(const std::vector<std::string>& json, c_type expected_min,
-                      c_type expected_max, const MinMaxOptions& options) {
+                      c_type expected_max, const ScalarAggregateOptions& options) {
     auto array = ChunkedArrayFromJSON(type_singleton(), json);
     AssertMinMaxIs(array, expected_min, expected_max, options);
   }
 
-  void AssertMinMaxIsNull(const Datum& array, const MinMaxOptions& options) {
+  void AssertMinMaxIsNull(const Datum& array, const ScalarAggregateOptions& options) {
     ASSERT_OK_AND_ASSIGN(Datum out, MinMax(array, options));
     for (const auto& val : out.scalar_as<StructScalar>().value) {
       ASSERT_FALSE(val->is_valid);
     }
   }
 
-  void AssertMinMaxIsNull(const std::string& json, const MinMaxOptions& options) {
+  void AssertMinMaxIsNull(const std::string& json, const ScalarAggregateOptions& options) {
     auto array = ArrayFromJSON(type_singleton(), json);
     AssertMinMaxIsNull(array, options);
   }
 
   void AssertMinMaxIsNull(const std::vector<std::string>& json,
-                          const MinMaxOptions& options) {
+                          const ScalarAggregateOptions& options) {
     auto array = ChunkedArrayFromJSON(type_singleton(), json);
     AssertMinMaxIsNull(array, options);
   }
@@ -619,7 +619,7 @@ class TestFloatingMinMaxKernel : public TestPrimitiveMinMaxKernel<ArrowType> {};
 class TestBooleanMinMaxKernel : public TestPrimitiveMinMaxKernel<BooleanType> {};
 
 TEST_F(TestBooleanMinMaxKernel, Basics) {
-  MinMaxOptions options;
+ScalarAggregateOptions options;
   std::vector<std::string> chunked_input0 = {"[]", "[]"};
   std::vector<std::string> chunked_input1 = {"[true, true, null]", "[true, null]"};
   std::vector<std::string> chunked_input2 = {"[false, false, false]", "[false]"};
@@ -638,7 +638,7 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
   this->AssertMinMaxIs(chunked_input2, false, false, options);
   this->AssertMinMaxIs(chunked_input3, false, true, options);
 
-  options = MinMaxOptions(MinMaxOptions::EMIT_NULL);
+  options = ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA);
   this->AssertMinMaxIsNull("[]", options);
   this->AssertMinMaxIsNull("[null, null, null]", options);
   this->AssertMinMaxIsNull("[false, null, false]", options);
@@ -654,7 +654,7 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
 
 TYPED_TEST_SUITE(TestIntegerMinMaxKernel, IntegralArrowTypes);
 TYPED_TEST(TestIntegerMinMaxKernel, Basics) {
-  MinMaxOptions options;
+ScalarAggregateOptions options;
   std::vector<std::string> chunked_input1 = {"[5, 1, 2, 3, 4]", "[9, 1, null, 3, 4]"};
   std::vector<std::string> chunked_input2 = {"[5, null, 2, 3, 4]", "[9, 1, 2, 3, 4]"};
   std::vector<std::string> chunked_input3 = {"[5, 1, 2, 3, null]", "[9, 1, null, 3, 4]"};
@@ -668,7 +668,7 @@ TYPED_TEST(TestIntegerMinMaxKernel, Basics) {
   this->AssertMinMaxIs(chunked_input2, 1, 9, options);
   this->AssertMinMaxIs(chunked_input3, 1, 9, options);
 
-  options = MinMaxOptions(MinMaxOptions::EMIT_NULL);
+  options = ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA);
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   // output null
   this->AssertMinMaxIsNull("[5, null, 2, 3, 4]", options);
@@ -680,7 +680,7 @@ TYPED_TEST(TestIntegerMinMaxKernel, Basics) {
 
 TYPED_TEST_SUITE(TestFloatingMinMaxKernel, RealArrowTypes);
 TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
-  MinMaxOptions options;
+ScalarAggregateOptions options;
   std::vector<std::string> chunked_input1 = {"[5, 1, 2, 3, 4]", "[9, 1, null, 3, 4]"};
   std::vector<std::string> chunked_input2 = {"[5, null, 2, 3, 4]", "[9, 1, 2, 3, 4]"};
   std::vector<std::string> chunked_input3 = {"[5, 1, 2, 3, null]", "[9, 1, null, 3, 4]"};
@@ -695,7 +695,7 @@ TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
   this->AssertMinMaxIs(chunked_input2, 1, 9, options);
   this->AssertMinMaxIs(chunked_input3, 1, 9, options);
 
-  options = MinMaxOptions(MinMaxOptions::EMIT_NULL);
+  options = ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA);
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   this->AssertMinMaxIs("[5, -Inf, 2, 3, 4]", -INFINITY, 5, options);
   // output null
@@ -713,7 +713,7 @@ TYPED_TEST(TestFloatingMinMaxKernel, DefaultOptions) {
 
   ASSERT_OK_AND_ASSIGN(auto no_options_provided, CallFunction("min_max", {values}));
 
-  auto default_options = MinMaxOptions::Defaults();
+  auto default_options = ScalarAggregateOptions::Defaults();
   ASSERT_OK_AND_ASSIGN(auto explicit_defaults,
                        CallFunction("min_max", {values}, &default_options));
 
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index ae7bf9324db..2ceed62ba0c 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -699,7 +699,7 @@ struct GroupedMinMaxImpl : public GroupedAggregator {
 
   Status Init(ExecContext* ctx, const FunctionOptions* options,
               const std::shared_ptr<DataType>& input_type) override {
-    options_ = *checked_cast<const MinMaxOptions*>(options);
+    options_ = *checked_cast<const ScalarAggregateOptions*>(options);
     type_ = input_type;
 
     mins_ = BufferBuilder(ctx->memory_pool());
@@ -739,7 +739,7 @@ struct GroupedMinMaxImpl : public GroupedAggregator {
     // aggregation for group is valid if there was at least one value in that group
     ARROW_ASSIGN_OR_RAISE(auto null_bitmap, has_values_.Finish());
 
-    if (options_.null_handling == MinMaxOptions::EMIT_NULL) {
+    if (options_.null_handling == ScalarAggregateOptions::KEEPNA) {
       // ... and there were no nulls in that group
       ARROW_ASSIGN_OR_RAISE(auto has_nulls, has_nulls_.Finish());
       arrow::internal::BitmapAndNot(null_bitmap->data(), 0, has_nulls->data(), 0,
@@ -764,7 +764,7 @@ struct GroupedMinMaxImpl : public GroupedAggregator {
   std::shared_ptr<DataType> type_;
   ConsumeImpl consume_impl_;
   ResizeImpl resize_min_impl_, resize_max_impl_, resize_bitmap_impl_;
-  MinMaxOptions options_;
+  ScalarAggregateOptions options_;
 };
 
 template <typename Impl>
@@ -1031,9 +1031,9 @@ const FunctionDoc hash_sum_doc{"Sum values of a numeric array",
 const FunctionDoc hash_min_max_doc{
     "Compute the minimum and maximum values of a numeric array",
     ("Null values are ignored by default.\n"
-     "This can be changed through MinMaxOptions."),
+     "This can be changed through ScalarAggregateOptions."),
     {"array", "group_id_array", "group_count"},
-    "MinMaxOptions"};
+    "ScalarAggregateOptions"};
 }  // namespace
 
 void RegisterHashAggregateBasic(FunctionRegistry* registry) {
@@ -1053,9 +1053,9 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
   }
 
   {
-    static auto default_minmax_options = MinMaxOptions::Defaults();
+    static auto default_scalaraggregate_options = ScalarAggregateOptions::Defaults();
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_min_max", Arity::Ternary(), &hash_min_max_doc, &default_minmax_options);
+        "hash_min_max", Arity::Ternary(), &hash_min_max_doc, &default_scalaraggregate_options);
     DCHECK_OK(func->AddKernel(MakeKernel<GroupedMinMaxImpl>(ValueDescr::ARRAY)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
index 507f1716110..5eb519b8cca 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
@@ -662,7 +662,7 @@ TEST(GroupBy, ConcreteCaseWithValidateGroupBy) {
   CountOptions count_non_null{CountOptions::COUNT_NON_NULL},
       count_null{CountOptions::COUNT_NULL};
 
-  MinMaxOptions emit_null{MinMaxOptions::EMIT_NULL};
+ScalarAggregateOptions skipna{ScalarAggregateOptions::KEEPNA};
 
   using internal::Aggregate;
   for (auto agg : {
@@ -670,7 +670,7 @@ TEST(GroupBy, ConcreteCaseWithValidateGroupBy) {
            Aggregate{"hash_count", &count_non_null},
            Aggregate{"hash_count", &count_null},
            Aggregate{"hash_min_max", nullptr},
-           Aggregate{"hash_min_max", &emit_null},
+           Aggregate{"hash_min_max", &skipna},
        }) {
     SCOPED_TRACE(agg.function);
     ValidateGroupBy({agg}, {batch->GetColumnByName("argument")},

From b031a3b969fd2c8c0312c49f4da7946f8a79e07d Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 13 Apr 2021 12:31:29 +0200
Subject: [PATCH 04/23] Replace CountOptions with ScalarAggregateOptions.

---
 cpp/src/arrow/compute/api_aggregate.cc        |  6 ++-
 cpp/src/arrow/compute/api_aggregate.h         | 33 ++++-------------
 .../arrow/compute/kernels/aggregate_basic.cc  | 37 +++++++++----------
 .../kernels/aggregate_basic_internal.h        |  6 ++-
 .../arrow/compute/kernels/aggregate_test.cc   | 13 ++++---
 .../arrow/compute/kernels/hash_aggregate.cc   | 22 ++++++-----
 .../compute/kernels/hash_aggregate_test.cc    | 12 +++---
 7 files changed, 56 insertions(+), 73 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.cc b/cpp/src/arrow/compute/api_aggregate.cc
index bbb26b7af89..dca54a0faba 100644
--- a/cpp/src/arrow/compute/api_aggregate.cc
+++ b/cpp/src/arrow/compute/api_aggregate.cc
@@ -25,7 +25,8 @@ namespace compute {
 // ----------------------------------------------------------------------
 // Scalar aggregates
 
-Result<Datum> Count(const Datum& value, CountOptions options, ExecContext* ctx) {
+Result<Datum> Count(const Datum& value, ScalarAggregateOptions options,
+                    ExecContext* ctx) {
   return CallFunction("count", {value}, &options, ctx);
 }
 
@@ -39,7 +40,8 @@ Result<Datum> Sum(const Datum& value, const ScalarAggregateOptions& options,
   return CallFunction("sum", {value}, &options, ctx);
 }
 
-Result<Datum> MinMax(const Datum& value, const ScalarAggregateOptions& options, ExecContext* ctx) {
+Result<Datum> MinMax(const Datum& value, const ScalarAggregateOptions& options,
+                     ExecContext* ctx) {
   return CallFunction("min_max", {value}, &options, ctx);
 }
 
diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index 689737f212d..1682c65b389 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -58,27 +58,6 @@ struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
   uint32_t min_count;
 };
 
-/// \addtogroup compute-concrete-options
-/// @{
-
-/// \brief Control Count kernel behavior
-///
-/// By default, all non-null values are counted.
-struct ARROW_EXPORT CountOptions : public FunctionOptions {
-  enum Mode {
-    /// Count all non-null values.
-    COUNT_NON_NULL = 0,
-    /// Count all null values.
-    COUNT_NULL,
-  };
-
-  explicit CountOptions(enum Mode count_mode = COUNT_NON_NULL) : count_mode(count_mode) {}
-
-  static CountOptions Defaults() { return CountOptions(COUNT_NON_NULL); }
-
-  enum Mode count_mode;
-};
-
 /// \brief Control Mode kernel behavior
 ///
 /// Returns top-n common values and counts.
@@ -156,7 +135,7 @@ struct ARROW_EXPORT TDigestOptions : public FunctionOptions {
 
 /// \brief Count non-null (or null) values in an array.
 ///
-/// \param[in] options counting options, see CountOptions for more information
+/// \param[in] options counting options, see ScalarAggregateOptions for more information
 /// \param[in] datum to count
 /// \param[in] ctx the function execution context, optional
 /// \return out resulting datum
@@ -164,7 +143,8 @@ struct ARROW_EXPORT TDigestOptions : public FunctionOptions {
 /// \since 1.0.0
 /// \note API not yet finalized
 ARROW_EXPORT
-Result<Datum> Count(const Datum& datum, CountOptions options = CountOptions::Defaults(),
+Result<Datum> Count(const Datum& datum,
+                    ScalarAggregateOptions options = ScalarAggregateOptions::Defaults(),
                     ExecContext* ctx = NULLPTR);
 
 /// \brief Compute the mean of a numeric array.
@@ -210,9 +190,10 @@ Result<Datum> Sum(
 /// \since 1.0.0
 /// \note API not yet finalized
 ARROW_EXPORT
-Result<Datum> MinMax(const Datum& value,
-                     const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults(),
-                     ExecContext* ctx = NULLPTR);
+Result<Datum> MinMax(
+    const Datum& value,
+    const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
 
 /// \brief Test whether any element in a boolean array evaluates to true.
 ///
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 39ed8f5dc56..c0cf5a6c603 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -56,7 +56,7 @@ namespace aggregate {
 // Count implementation
 
 struct CountImpl : public ScalarAggregator {
-  explicit CountImpl(CountOptions options) : options(std::move(options)) {}
+  explicit CountImpl(ScalarAggregateOptions options) : options(std::move(options)) {}
 
   Status Consume(KernelContext*, const ExecBatch& batch) override {
     const ArrayData& input = *batch[0].array();
@@ -75,20 +75,20 @@ struct CountImpl : public ScalarAggregator {
 
   Status Finalize(KernelContext* ctx, Datum* out) override {
     const auto& state = checked_cast<const CountImpl&>(*ctx->state());
-    switch (state.options.count_mode) {
-      case CountOptions::COUNT_NON_NULL:
+    switch (state.options.null_handling) {
+      case ScalarAggregateOptions::SKIPNA:
         *out = Datum(state.non_nulls);
         break;
-      case CountOptions::COUNT_NULL:
+      case ScalarAggregateOptions::KEEPNA:
         *out = Datum(state.nulls);
         break;
       default:
-        return Status::Invalid("Unknown CountOptions encountered");
+        return Status::Invalid("Unknown ScalarAggregateOptions encountered");
     }
     return Status::OK();
   }
 
-  CountOptions options;
+  ScalarAggregateOptions options;
   int64_t non_nulls = 0;
   int64_t nulls = 0;
 };
@@ -96,7 +96,7 @@ struct CountImpl : public ScalarAggregator {
 Result<std::unique_ptr<KernelState>> CountInit(KernelContext*,
                                                const KernelInitArgs& args) {
   return ::arrow::internal::make_unique<CountImpl>(
-      static_cast<const CountOptions&>(*args.options));
+      static_cast<const ScalarAggregateOptions&>(*args.options));
 }
 
 // ----------------------------------------------------------------------
@@ -259,9 +259,9 @@ namespace {
 
 const FunctionDoc count_doc{"Count the number of null / non-null values",
                             ("By default, non-null values are counted.\n"
-                             "This can be changed through CountOptions."),
+                             "This can be changed through ScalarAggregateOptions."),
                             {"array"},
-                            "CountOptions"};
+                            "ScalarAggregateOptions"};
 
 const FunctionDoc sum_doc{
     "Sum values of a numeric array", ("Null values are ignored."), {"array"}};
@@ -288,9 +288,10 @@ const FunctionDoc all_doc{"Test whether all elements in a boolean array evaluate
 }  // namespace
 
 void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
-  static auto default_count_options = CountOptions::Defaults();
+  static auto default_scalar_aggregate_options = ScalarAggregateOptions::Defaults();
+
   auto func = std::make_shared<ScalarAggregateFunction>(
-      "count", Arity::Unary(), &count_doc, &default_count_options);
+      "count", Arity::Unary(), &count_doc, &default_scalar_aggregate_options);
 
   // Takes any array input, outputs int64 scalar
   InputType any_array(ValueDescr::ARRAY);
@@ -298,10 +299,8 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
                aggregate::CountInit, func.get());
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  static ScalarAggregateOptions sum_default_scalar_aggregate_options =
-      ScalarAggregateOptions::Defaults();
   func = std::make_shared<ScalarAggregateFunction>("sum", Arity::Unary(), &sum_doc,
-                                                   &sum_default_scalar_aggregate_options);
+                                                   &default_scalar_aggregate_options);
   aggregate::AddBasicAggKernels(aggregate::SumInit, {boolean()}, int64(), func.get());
   aggregate::AddBasicAggKernels(aggregate::SumInit, SignedIntTypes(), int64(),
                                 func.get());
@@ -325,9 +324,8 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
 #endif
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  static ScalarAggregateOptions mean_default_scalar_aggregate_options = ScalarAggregateOptions::Defaults();
-  func = std::make_shared<ScalarAggregateFunction>(
-      "mean", Arity::Unary(), &mean_doc, &mean_default_scalar_aggregate_options);
+  func = std::make_shared<ScalarAggregateFunction>("mean", Arity::Unary(), &mean_doc,
+                                                   &default_scalar_aggregate_options);
   aggregate::AddBasicAggKernels(aggregate::MeanInit, {boolean()}, float64(), func.get());
   aggregate::AddBasicAggKernels(aggregate::MeanInit, NumericTypes(), float64(),
                                 func.get());
@@ -344,9 +342,8 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
 #endif
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
-  static auto minmax_default_scalar_aggregate_options = ScalarAggregateOptions::Defaults();
-  func = std::make_shared<ScalarAggregateFunction>("min_max", Arity::Unary(),
-                                                   &min_max_doc, &minmax_default_scalar_aggregate_options);
+  func = std::make_shared<ScalarAggregateFunction>(
+      "min_max", Arity::Unary(), &min_max_doc, &default_scalar_aggregate_options);
   aggregate::AddMinMaxKernels(aggregate::MinMaxInit, {boolean()}, func.get());
   aggregate::AddMinMaxKernels(aggregate::MinMaxInit, NumericTypes(), func.get());
   // Add the SIMD variants for min max
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 9d40dd1edea..857683b9400 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -233,7 +233,8 @@ struct MinMaxImpl : public ScalarAggregator {
   using ThisType = MinMaxImpl<ArrowType, SimdLevel>;
   using StateType = MinMaxState<ArrowType, SimdLevel>;
 
-  MinMaxImpl(const std::shared_ptr<DataType>& out_type, const ScalarAggregateOptions& options)
+  MinMaxImpl(const std::shared_ptr<DataType>& out_type,
+             const ScalarAggregateOptions& options)
       : out_type(out_type), options(options) {}
 
   Status Consume(KernelContext*, const ExecBatch& batch) override {
@@ -387,7 +388,8 @@ struct MinMaxInitState {
   const ScalarAggregateOptions& options;
 
   MinMaxInitState(KernelContext* ctx, const DataType& in_type,
-                  const std::shared_ptr<DataType>& out_type, const ScalarAggregateOptions& options)
+                  const std::shared_ptr<DataType>& out_type,
+                  const ScalarAggregateOptions& options)
       : ctx(ctx), in_type(in_type), out_type(out_type), options(options) {}
 
   Status Visit(const DataType&) {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 67d7a63dcba..ddd36a48e18 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -373,8 +373,8 @@ static CountPair NaiveCount(const Array& array) {
 }
 
 void ValidateCount(const Array& input, CountPair expected) {
-  CountOptions all = CountOptions(CountOptions::COUNT_NON_NULL);
-  CountOptions nulls = CountOptions(CountOptions::COUNT_NULL);
+  ScalarAggregateOptions all = ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA);
+  ScalarAggregateOptions nulls = ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA);
 
   ASSERT_OK_AND_ASSIGN(Datum result, Count(input, all));
   AssertDatumsEqual(result, Datum(expected.first));
@@ -596,7 +596,8 @@ class TestPrimitiveMinMaxKernel : public ::testing::Test {
     }
   }
 
-  void AssertMinMaxIsNull(const std::string& json, const ScalarAggregateOptions& options) {
+  void AssertMinMaxIsNull(const std::string& json,
+                          const ScalarAggregateOptions& options) {
     auto array = ArrayFromJSON(type_singleton(), json);
     AssertMinMaxIsNull(array, options);
   }
@@ -619,7 +620,7 @@ class TestFloatingMinMaxKernel : public TestPrimitiveMinMaxKernel<ArrowType> {};
 class TestBooleanMinMaxKernel : public TestPrimitiveMinMaxKernel<BooleanType> {};
 
 TEST_F(TestBooleanMinMaxKernel, Basics) {
-ScalarAggregateOptions options;
+  ScalarAggregateOptions options;
   std::vector<std::string> chunked_input0 = {"[]", "[]"};
   std::vector<std::string> chunked_input1 = {"[true, true, null]", "[true, null]"};
   std::vector<std::string> chunked_input2 = {"[false, false, false]", "[false]"};
@@ -654,7 +655,7 @@ ScalarAggregateOptions options;
 
 TYPED_TEST_SUITE(TestIntegerMinMaxKernel, IntegralArrowTypes);
 TYPED_TEST(TestIntegerMinMaxKernel, Basics) {
-ScalarAggregateOptions options;
+  ScalarAggregateOptions options;
   std::vector<std::string> chunked_input1 = {"[5, 1, 2, 3, 4]", "[9, 1, null, 3, 4]"};
   std::vector<std::string> chunked_input2 = {"[5, null, 2, 3, 4]", "[9, 1, 2, 3, 4]"};
   std::vector<std::string> chunked_input3 = {"[5, 1, 2, 3, null]", "[9, 1, null, 3, 4]"};
@@ -680,7 +681,7 @@ ScalarAggregateOptions options;
 
 TYPED_TEST_SUITE(TestFloatingMinMaxKernel, RealArrowTypes);
 TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
-ScalarAggregateOptions options;
+  ScalarAggregateOptions options;
   std::vector<std::string> chunked_input1 = {"[5, 1, 2, 3, 4]", "[9, 1, null, 3, 4]"};
   std::vector<std::string> chunked_input2 = {"[5, null, 2, 3, 4]", "[9, 1, 2, 3, 4]"};
   std::vector<std::string> chunked_input3 = {"[5, 1, 2, 3, null]", "[9, 1, null, 3, 4]"};
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index 2ceed62ba0c..ddb76232302 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -466,7 +466,7 @@ struct GroupedAggregator : KernelState {
 struct GroupedCountImpl : public GroupedAggregator {
   Status Init(ExecContext* ctx, const FunctionOptions* options,
               const std::shared_ptr<DataType>&) override {
-    options_ = checked_cast<const CountOptions&>(*options);
+    options_ = checked_cast<const ScalarAggregateOptions&>(*options);
     counts_ = BufferBuilder(ctx->memory_pool());
     return Status::OK();
   }
@@ -482,8 +482,8 @@ struct GroupedCountImpl : public GroupedAggregator {
 
     const auto& input = batch[0].array();
 
-    if (options_.count_mode == CountOptions::COUNT_NULL) {
-      if (input->GetNullCount() != 0) {
+    if (options_.null_handling == ScalarAggregateOptions::KEEPNA) {
+      if (input->GetNullCount() >= options_.min_count) {
         for (int64_t i = 0, input_i = input->offset; i < input->length; ++i, ++input_i) {
           auto g = group_ids[i];
           raw_counts[g] += !BitUtil::GetBit(input->buffers[0]->data(), input_i);
@@ -512,7 +512,7 @@ struct GroupedCountImpl : public GroupedAggregator {
   std::shared_ptr<DataType> out_type() const override { return int64(); }
 
   int64_t num_groups_ = 0;
-  CountOptions options_;
+  ScalarAggregateOptions options_;
   BufferBuilder counts_;
 };
 
@@ -1020,9 +1020,9 @@ Result<std::shared_ptr<ListArray>> Grouper::MakeGroupings(const UInt32Array& ids
 namespace {
 const FunctionDoc hash_count_doc{"Count the number of null / non-null values",
                                  ("By default, non-null values are counted.\n"
-                                  "This can be changed through CountOptions."),
+                                  "This can be changed through ScalarAggregateOptions."),
                                  {"array", "group_id_array", "group_count"},
-                                 "CountOptions"};
+                                 "ScalarAggregateOptions"};
 
 const FunctionDoc hash_sum_doc{"Sum values of a numeric array",
                                ("Null values are ignored."),
@@ -1038,9 +1038,10 @@ const FunctionDoc hash_min_max_doc{
 
 void RegisterHashAggregateBasic(FunctionRegistry* registry) {
   {
-    static auto default_count_options = CountOptions::Defaults();
+    static auto default_scalar_aggregate_options = ScalarAggregateOptions::Defaults();
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_count", Arity::Ternary(), &hash_count_doc, &default_count_options);
+        "hash_count", Arity::Ternary(), &hash_count_doc,
+        &default_scalar_aggregate_options);
     DCHECK_OK(func->AddKernel(MakeKernel<GroupedCountImpl>(ValueDescr::ARRAY)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
@@ -1053,9 +1054,10 @@ void RegisterHashAggregateBasic(FunctionRegistry* registry) {
   }
 
   {
-    static auto default_scalaraggregate_options = ScalarAggregateOptions::Defaults();
+    static auto default_scalar_aggregate_options = ScalarAggregateOptions::Defaults();
     auto func = std::make_shared<HashAggregateFunction>(
-        "hash_min_max", Arity::Ternary(), &hash_min_max_doc, &default_scalaraggregate_options);
+        "hash_min_max", Arity::Ternary(), &hash_min_max_doc,
+        &default_scalar_aggregate_options);
     DCHECK_OK(func->AddKernel(MakeKernel<GroupedMinMaxImpl>(ValueDescr::ARRAY)));
     DCHECK_OK(registry->AddFunction(std::move(func)));
   }
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
index 5eb519b8cca..67d9f318c8f 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
@@ -567,7 +567,7 @@ TEST(GroupBy, CountAndSum) {
     [null,  3]
   ])");
 
-  CountOptions count_options;
+  ScalarAggregateOptions count_options;
   ASSERT_OK_AND_ASSIGN(
       Datum aggregated_and_grouped,
       internal::GroupBy(
@@ -659,16 +659,14 @@ TEST(GroupBy, ConcreteCaseWithValidateGroupBy) {
     [null,  "gama"]
   ])");
 
-  CountOptions count_non_null{CountOptions::COUNT_NON_NULL},
-      count_null{CountOptions::COUNT_NULL};
-
-ScalarAggregateOptions skipna{ScalarAggregateOptions::KEEPNA};
+  ScalarAggregateOptions keepna{ScalarAggregateOptions::KEEPNA};
+  ScalarAggregateOptions skipna{ScalarAggregateOptions::KEEPNA};
 
   using internal::Aggregate;
   for (auto agg : {
            Aggregate{"hash_sum", nullptr},
-           Aggregate{"hash_count", &count_non_null},
-           Aggregate{"hash_count", &count_null},
+           Aggregate{"hash_count", &skipna},
+           Aggregate{"hash_count", &keepna},
            Aggregate{"hash_min_max", nullptr},
            Aggregate{"hash_min_max", &skipna},
        }) {

From 81a4aefec2c1dc996a1df6cd2edfd57d2001ead2 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 14 Apr 2021 03:04:58 +0200
Subject: [PATCH 05/23] Updating R bindings.

---
 .../arrow/compute/kernels/aggregate_test.cc   | 29 +++++++++++++++++
 docs/source/cpp/compute.rst                   | 14 ++++-----
 r/R/compute.R                                 | 31 ++++++++++---------
 r/src/compute.cpp                             | 16 +++++++---
 r/tests/testthat/test-compute-aggregate.R     |  2 +-
 5 files changed, 66 insertions(+), 26 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index ddd36a48e18..c5cb1e39095 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -255,6 +255,7 @@ TYPED_TEST(TestNumericSumKernel, ScalarAggregateOptions) {
 
   const T expected_result = static_cast<T>(14);
   auto null_result = Datum(std::make_shared<ScalarType>());
+  auto zero_result = Datum(std::make_shared<ScalarType>(static_cast<T>(0)));
   auto result = Datum(std::make_shared<ScalarType>(expected_result));
   const char* json = "[1, null, 3, null, 3, null, 7]";
 
@@ -270,6 +271,34 @@ TYPED_TEST(TestNumericSumKernel, ScalarAggregateOptions) {
                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 4));
   ValidateSum<TypeParam>(json, null_result,
                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 5));
+
+  //  ValidateSum<TypeParam>("[null]", zero_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
+  //  ValidateSum<TypeParam>("[null]", zero_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
+  //  ValidateSum<TypeParam>("[null]", zero_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
+
+  //  ValidateSum<TypeParam>("[null]", null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
+  //  ValidateSum<TypeParam>("[null]", null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
+  //  ValidateSum<TypeParam>("[null]", null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
+  //
+  //  ValidateSum<TypeParam>("[]", null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
+  //  ValidateSum<TypeParam>("[]", null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
+  //  ValidateSum<TypeParam>("[]", null_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
+  //
+  //  ValidateSum<TypeParam>("[]", zero_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
+  //  ValidateSum<TypeParam>("[]", zero_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
+  //  ValidateSum<TypeParam>("[]", zero_result,
+  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
 }
 
 template <typename ArrowType>
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 592dc4ec1b0..e8ed38bc655 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -82,15 +82,15 @@ Many compute functions are also available directly as concrete APIs, here
 Some functions accept or require an options structure that determines the
 exact semantics of the function::
 
-   MinMaxOptions min_max_options;
-   min_max_options.null_handling = MinMaxOptions::EMIT_NULL;
+   ScalarAggregateOptions min_max_options;
+   scalar_aggregate_options.null_handling = ScalarAggregateOptions::KEEPNA;
 
    std::shared_ptr<arrow::Array> array = ...;
    arrow::Datum min_max;
 
    ARROW_ASSIGN_OR_RAISE(min_max,
                          arrow::compute::CallFunction("min_max", {array},
-                                                      &min_max_options));
+                                                      &scalar_aggregate_options));
 
    // Unpack struct scalar result (a two-field {"min", "max"} scalar)
    std::shared_ptr<arrow::Scalar> min_value, max_value;
@@ -190,11 +190,11 @@ Aggregations
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
 | any                      | Unary      | Boolean            | Scalar Boolean        |                                            |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
-| count                    | Unary      | Any                | Scalar Int64          | :struct:`CountOptions`                     |
+| count                    | Unary      | Any                | Scalar Int64          | :struct:`ScalarAggregateOptions`           |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
-| mean                     | Unary      | Numeric            | Scalar Float64        |                                            |
+| mean                     | Unary      | Numeric            | Scalar Float64        | :struct:`ScalarAggregateOptions`           |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
-| min_max                  | Unary      | Numeric            | Scalar Struct  (1)    | :struct:`MinMaxOptions`                    |
+| min_max                  | Unary      | Numeric            | Scalar Struct  (1)    | :struct:`ScalarAggregateOptions`           |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
 | mode                     | Unary      | Numeric            | Struct  (2)           | :struct:`ModeOptions`                      |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
@@ -202,7 +202,7 @@ Aggregations
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
 | stddev                   | Unary      | Numeric            | Scalar Float64        | :struct:`VarianceOptions`                  |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
-| sum                      | Unary      | Numeric            | Scalar Numeric (4)    |                                            |
+| sum                      | Unary      | Numeric            | Scalar Numeric (4)    | :struct:`ScalarAggregateOptions`           |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
 | tdigest                  | Unary      | Numeric            | Scalar Float64        | :struct:`TDigestOptions`                   |
 +--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
diff --git a/r/R/compute.R b/r/R/compute.R
index c3783ba3295..97636f9477e 100644
--- a/r/R/compute.R
+++ b/r/R/compute.R
@@ -95,30 +95,33 @@ list_compute_functions <- function(pattern = NULL, ...) {
 }
 
 #' @export
-sum.ArrowDatum <- function(..., na.rm = FALSE) scalar_aggregate("sum", ..., na.rm = na.rm)
+sum.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = NULL) {
+  a <- collect_arrays_from_dots(list(...))
+  if (is.null(na.min_count)) {
+    na.min_count = 0
+  }
+  scalar_aggregate("sum", ..., na.rm = na.rm, na.min_count = na.min_count)
+}
 
 #' @export
-mean.ArrowDatum <- function(..., na.rm = FALSE) scalar_aggregate("mean", ..., na.rm = na.rm)
+mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+  a <- collect_arrays_from_dots(list(...))
+  scalar_aggregate("mean", ..., na.rm = na.rm, na.min_count = na.min_count)
+}
 
 #' @export
-min.ArrowDatum <- function(..., na.rm = FALSE) {
-  scalar_aggregate("min_max", ..., na.rm = na.rm)$GetFieldByName("min")
+min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+  scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("min")
 }
 
 #' @export
-max.ArrowDatum <- function(..., na.rm = FALSE) {
-  scalar_aggregate("min_max", ..., na.rm = na.rm)$GetFieldByName("max")
+max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+  scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("max")
 }
 
-scalar_aggregate <- function(FUN, ..., na.rm = FALSE) {
+scalar_aggregate <- function(FUN, ..., na.rm, na.min_count) {
   a <- collect_arrays_from_dots(list(...))
-  if (!na.rm && a$null_count > 0 && (FUN %in% c("mean", "sum"))) {
-    # Arrow sum/mean function always drops NAs so handle that here
-    # https://issues.apache.org/jira/browse/ARROW-9054
-    return(Scalar$create(NA_real_))
-  }
-
-  call_function(FUN, a, options = list(na.rm = na.rm))
+  call_function(FUN, a, options = list(na.rm = na.rm, na.min_count = na.min_count))
 }
 
 collect_arrays_from_dots <- function(dots) {
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 0ffe53578c4..8d13682c726 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -171,11 +171,19 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
     return out;
   }
 
-  if (func_name == "min_max") {
-    using Options = arrow::compute::MinMaxOptions;
+  if (func_name == "min_max" || func_name == "sum" || func_name == "mean" || func_name == "count") {
+    using Options = arrow::compute::ScalarAggregateOptions;
     auto out = std::make_shared<Options>(Options::Defaults());
-    out->null_handling =
-        cpp11::as_cpp<bool>(options["na.rm"]) ? Options::SKIP : Options::EMIT_NULL;
+
+    SEXP min_count = options["na.min_count"];
+    if (!Rf_isNull(min_count)) {
+      out->min_count = cpp11::as_cpp<int>(options["na.min_count"]);
+    }
+    SEXP null_handling = options["na.rm"];
+    if (!Rf_isNull(null_handling)) {
+      out->null_handling = cpp11::as_cpp<bool>(options["na.rm"]) ? Options::SKIPNA : Options::KEEPNA;
+    }
+
     return out;
   }
 
diff --git a/r/tests/testthat/test-compute-aggregate.R b/r/tests/testthat/test-compute-aggregate.R
index 95f958cf9f3..74b6014395a 100644
--- a/r/tests/testthat/test-compute-aggregate.R
+++ b/r/tests/testthat/test-compute-aggregate.R
@@ -92,7 +92,7 @@ test_that("mean.Array", {
 
   bools <- c(TRUE, NA, TRUE, FALSE)
   b <- Array$create(bools)
-  expect_identical(as.vector(mean(b)), mean(bools))
+  expect_identical(as.vector(mean(b, na.min_count=length(b))), mean(bools))
   expect_identical(as.integer(sum(b, na.rm = TRUE)), sum(bools, na.rm = TRUE))
 })
 

From 3ae521e037222dca98f43b56daf8d7d14cf4585a Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 14 Apr 2021 17:35:36 +0200
Subject: [PATCH 06/23] Fix to sum/mean behaviour.

---
 cpp/src/arrow/compute/api_aggregate.h         |  2 +-
 .../kernels/aggregate_basic_internal.h        |  6 +-
 .../arrow/compute/kernels/aggregate_test.cc   | 82 ++++++++++++-------
 r/R/compute.R                                 | 16 ++--
 r/src/compute.cpp                             | 12 +--
 r/tests/testthat/test-compute-aggregate.R     |  7 +-
 6 files changed, 71 insertions(+), 54 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index 1682c65b389..f3ff81154ba 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -49,7 +49,7 @@ struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
   };
 
   explicit ScalarAggregateOptions(enum Mode null_handling = SKIPNA,
-                                  uint32_t min_count = 0)
+                                  uint32_t min_count = 1)
       : null_handling(null_handling), min_count(min_count) {}
 
   static ScalarAggregateOptions Defaults() { return ScalarAggregateOptions{}; }
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 857683b9400..42b89c75c40 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -81,7 +81,7 @@ struct SumImpl : public ScalarAggregator {
 
   Status Finalize(KernelContext*, Datum* out) override {
     const auto& state = checked_cast<const SumImpl&>(*ctx->state());
-    if (this->count == 0 || this->count < options.min_count) {
+    if (this->count < options.min_count) {
       out->value = std::make_shared<OutputType>();
     } else {
       out->value = MakeScalar(this->sum);
@@ -101,7 +101,9 @@ struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
     //    const ScalarAggregateOptions& options = checked_cast<const ScalarAggregateState&>(*ctx->state()).options;
     const auto& state = checked_cast<const MeanImpl&>(*ctx->state());
 
-    if (this->count == 0 || this->count < options.min_count) {
+    if (this->count == 0 && options.min_count == 0) {
+      out->value = std::make_shared<DoubleScalar>(0);
+    } else if (this->count < options.min_count) {
       out->value = std::make_shared<DoubleScalar>();
     } else if (options.null_handling == ScalarAggregateOptions::KEEPNA) {
       const double mean = static_cast<double>(this->sum) / this->length;
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index c5cb1e39095..35396d853b1 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -166,6 +166,13 @@ TEST(TestBooleanAggregation, Sum) {
   ValidateBooleanAgg<Sum>("[true, false, true, true, null]",
                           std::make_shared<UInt64Scalar>(3), options);
 
+  const ScalarAggregateOptions& options_min_count_zero =
+      ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0);
+  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(0),
+                          options_min_count_zero);
+  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(0),
+                          options_min_count_zero);
+
   const char* json = "[true, null, false, null]";
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
@@ -195,6 +202,13 @@ TEST(TestBooleanAggregation, Mean) {
   ValidateBooleanAgg<Mean>("[true, null, false, false, false]",
                            std::make_shared<DoubleScalar>(0.25), options);
 
+  const ScalarAggregateOptions& options_min_count_zero =
+      ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0);
+  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(0),
+                           options_min_count_zero);
+  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(0),
+                           options_min_count_zero);
+
   const char* json = "[true, null, false, null]";
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
                            ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
@@ -218,6 +232,14 @@ TYPED_TEST(TestNumericSumKernel, SimpleSum) {
   using SumType = typename FindAccumulatorType<TypeParam>::Type;
   using ScalarType = typename TypeTraits<SumType>::ScalarType;
   using T = typename TypeParam::c_type;
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0);
+
+  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))),
+                         options);
+
+  ValidateSum<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))),
+                         options);
 
   ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>()));
 
@@ -259,46 +281,26 @@ TYPED_TEST(TestNumericSumKernel, ScalarAggregateOptions) {
   auto result = Datum(std::make_shared<ScalarType>(expected_result));
   const char* json = "[1, null, 3, null, 3, null, 7]";
 
+  ValidateSum<TypeParam>("[]", zero_result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
+  ValidateSum<TypeParam>("[null]", zero_result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
   ValidateSum<TypeParam>(json, result,
                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
   ValidateSum<TypeParam>(json, result,
                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 4));
   ValidateSum<TypeParam>(json, null_result,
                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
+  ValidateSum<TypeParam>("[]", null_result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
+  ValidateSum<TypeParam>("[null]", null_result,
+                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
   ValidateSum<TypeParam>(json, result,
                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
   ValidateSum<TypeParam>(json, result,
                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 4));
   ValidateSum<TypeParam>(json, null_result,
                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 5));
-
-  //  ValidateSum<TypeParam>("[null]", zero_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
-  //  ValidateSum<TypeParam>("[null]", zero_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
-  //  ValidateSum<TypeParam>("[null]", zero_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
-
-  //  ValidateSum<TypeParam>("[null]", null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
-  //  ValidateSum<TypeParam>("[null]", null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
-  //  ValidateSum<TypeParam>("[null]", null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
-  //
-  //  ValidateSum<TypeParam>("[]", null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
-  //  ValidateSum<TypeParam>("[]", null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
-  //  ValidateSum<TypeParam>("[]", null_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
-  //
-  //  ValidateSum<TypeParam>("[]", zero_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
-  //  ValidateSum<TypeParam>("[]", zero_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
-  //  ValidateSum<TypeParam>("[]", zero_result,
-  //  ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
 }
 
 template <typename ArrowType>
@@ -496,6 +498,13 @@ TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
 TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
   using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
 
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0);
+
+  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>(0)), options);
+
+  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(0)), options);
+
   ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>()));
 
   ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()));
@@ -520,8 +529,17 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
   auto expected_result_keepna = Datum(std::make_shared<ScalarType>(static_cast<T>(2)));
   auto expected_result_skipna = Datum(std::make_shared<ScalarType>(static_cast<T>(3)));
   auto null_result = Datum(std::make_shared<ScalarType>());
+  auto zero_result = Datum(std::make_shared<ScalarType>(static_cast<T>(0)));
   const char* json = "[1, null, 2, 2, null, 7]";
 
+  ValidateMean<TypeParam>("[]", zero_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
+  ValidateMean<TypeParam>("[null]", zero_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
+  ValidateMean<TypeParam>("[]", null_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
+  ValidateMean<TypeParam>("[null]", null_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
   ValidateMean<TypeParam>(json, expected_result_skipna,
                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
   ValidateMean<TypeParam>(json, expected_result_skipna,
@@ -531,6 +549,14 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
   ValidateMean<TypeParam>(json, null_result,
                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
 
+  ValidateMean<TypeParam>("[]", zero_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
+  ValidateMean<TypeParam>("[null]", zero_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
+  ValidateMean<TypeParam>("[]", null_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
+  ValidateMean<TypeParam>("[null]", null_result,
+                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
   ValidateMean<TypeParam>(json, expected_result_keepna,
                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
   ValidateMean<TypeParam>(json, expected_result_keepna,
diff --git a/r/R/compute.R b/r/R/compute.R
index 97636f9477e..f94183d44ed 100644
--- a/r/R/compute.R
+++ b/r/R/compute.R
@@ -95,32 +95,30 @@ list_compute_functions <- function(pattern = NULL, ...) {
 }
 
 #' @export
-sum.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = NULL) {
-  a <- collect_arrays_from_dots(list(...))
-  if (is.null(na.min_count)) {
-    na.min_count = 0
-  }
+sum.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
   scalar_aggregate("sum", ..., na.rm = na.rm, na.min_count = na.min_count)
 }
 
 #' @export
-mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
-  a <- collect_arrays_from_dots(list(...))
+mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
   scalar_aggregate("mean", ..., na.rm = na.rm, na.min_count = na.min_count)
 }
 
 #' @export
-min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
   scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("min")
 }
 
 #' @export
-max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
   scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("max")
 }
 
 scalar_aggregate <- function(FUN, ..., na.rm, na.min_count) {
   a <- collect_arrays_from_dots(list(...))
+  if (!na.rm) {
+    na.min_count = length(a)
+  }
   call_function(FUN, a, options = list(na.rm = na.rm, na.min_count = na.min_count))
 }
 
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 8d13682c726..e0d25a6288d 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -174,16 +174,8 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
   if (func_name == "min_max" || func_name == "sum" || func_name == "mean" || func_name == "count") {
     using Options = arrow::compute::ScalarAggregateOptions;
     auto out = std::make_shared<Options>(Options::Defaults());
-
-    SEXP min_count = options["na.min_count"];
-    if (!Rf_isNull(min_count)) {
-      out->min_count = cpp11::as_cpp<int>(options["na.min_count"]);
-    }
-    SEXP null_handling = options["na.rm"];
-    if (!Rf_isNull(null_handling)) {
-      out->null_handling = cpp11::as_cpp<bool>(options["na.rm"]) ? Options::SKIPNA : Options::KEEPNA;
-    }
-
+    out->min_count = cpp11::as_cpp<int>(options["na.min_count"]);
+    out->null_handling = cpp11::as_cpp<bool>(options["na.rm"]) ? Options::SKIPNA : Options::KEEPNA;
     return out;
   }
 
diff --git a/r/tests/testthat/test-compute-aggregate.R b/r/tests/testthat/test-compute-aggregate.R
index 74b6014395a..fce60ac389b 100644
--- a/r/tests/testthat/test-compute-aggregate.R
+++ b/r/tests/testthat/test-compute-aggregate.R
@@ -92,7 +92,7 @@ test_that("mean.Array", {
 
   bools <- c(TRUE, NA, TRUE, FALSE)
   b <- Array$create(bools)
-  expect_identical(as.vector(mean(b, na.min_count=length(b))), mean(bools))
+  expect_identical(as.vector(mean(b)), mean(bools))
   expect_identical(as.integer(sum(b, na.rm = TRUE)), sum(bools, na.rm = TRUE))
 })
 
@@ -205,13 +205,12 @@ test_that("max.ChunkedArray", {
 })
 
 test_that("Edge cases", {
-  skip("ARROW-9054")
   a <- Array$create(NA)
   for (type in c(int32(), float64(), bool())) {
     expect_equal(as.vector(sum(a$cast(type), na.rm = TRUE)), sum(NA, na.rm = TRUE))
     expect_equal(as.vector(mean(a$cast(type), na.rm = TRUE)), mean(NA, na.rm = TRUE))
-    expect_equal(as.vector(min(a$cast(type), na.rm = TRUE)), min(NA, na.rm = TRUE))
-    expect_equal(as.vector(max(a$cast(type), na.rm = TRUE)), max(NA, na.rm = TRUE))
+    # expect_equal(as.vector(min(a$cast(type), na.rm = TRUE)), min(NA, na.rm = TRUE))
+    # expect_equal(as.vector(max(a$cast(type), na.rm = TRUE)), max(NA, na.rm = TRUE))
   }
 })
 

From 71afe91dab79eaadfbedb4d4fee79cc84bba1fdd Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 15 Apr 2021 03:49:49 +0200
Subject: [PATCH 07/23] Switching CountOptions to ScalarAggregateOptions.

---
 c_glib/arrow-glib/compute.cpp | 106 +++++++++++++++++-----------------
 c_glib/arrow-glib/compute.h   |  26 ++++-----
 c_glib/arrow-glib/compute.hpp |   8 +--
 c_glib/test/test-count.rb     |   8 +--
 4 files changed, 74 insertions(+), 74 deletions(-)

diff --git a/c_glib/arrow-glib/compute.cpp b/c_glib/arrow-glib/compute.cpp
index 275e406be79..3d299ee78f8 100644
--- a/c_glib/arrow-glib/compute.cpp
+++ b/c_glib/arrow-glib/compute.cpp
@@ -130,7 +130,7 @@ G_BEGIN_DECLS
  * #GArrowCastOptions is a class to customize the `cast` function and
  * garrow_array_cast().
  *
- * #GArrowCountOptions is a class to customize the `count` function and
+ * #GArrowScalarAggregateOptions is a class to customize the `count` function and
  * garrow_array_count().
  *
  * #GArrowFilterOptions is a class to customize the `filter` function and
@@ -636,60 +636,60 @@ garrow_cast_options_new(void)
 }
 
 
-typedef struct GArrowCountOptionsPrivate_ {
-  arrow::compute::CountOptions options;
-} GArrowCountOptionsPrivate;
+typedef struct GArrowScalarAggregateOptionsPrivate_ {
+  arrow::compute::ScalarAggregateOptions options;
+} GArrowScalarAggregateOptionsPrivate;
 
 enum {
   PROP_MODE = 1,
 };
 
 static arrow::compute::FunctionOptions *
-garrow_count_options_get_raw_function_options(GArrowFunctionOptions *options)
+garrow_scalar_aggregate_options_get_raw_function_options(GArrowFunctionOptions *options)
 {
-  return garrow_count_options_get_raw(GARROW_COUNT_OPTIONS(options));
+  return garrow_scalar_aggregate_options_get_raw(GARROW_SCALAR_AGGREGATE_OPTIONS(options));
 }
 
 static void
-garrow_count_options_function_options_interface_init(
+garrow_scalar_aggregate_options_function_options_interface_init(
   GArrowFunctionOptionsInterface *iface)
 {
-  iface->get_raw = garrow_count_options_get_raw_function_options;
+  iface->get_raw = garrow_scalar_aggregate_options_get_raw_function_options;
 }
 
-G_DEFINE_TYPE_WITH_CODE(GArrowCountOptions,
-                        garrow_count_options,
+G_DEFINE_TYPE_WITH_CODE(GArrowScalarAggregateOptions,
+                        garrow_scalar_aggregate_options,
                         G_TYPE_OBJECT,
-                        G_ADD_PRIVATE(GArrowCountOptions)
+                        G_ADD_PRIVATE(GArrowScalarAggregateOptions)
                         G_IMPLEMENT_INTERFACE(
                           GARROW_TYPE_FUNCTION_OPTIONS,
-                          garrow_count_options_function_options_interface_init))
+                          garrow_scalar_aggregate_options_function_options_interface_init))
 
-#define GARROW_COUNT_OPTIONS_GET_PRIVATE(object)        \
-  static_cast<GArrowCountOptionsPrivate *>(             \
-    garrow_count_options_get_instance_private(          \
-      GARROW_COUNT_OPTIONS(object)))
+#define GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object)        \
+  static_cast<GArrowScalarAggregateOptionsPrivate *>(             \
+    garrow_scalar_aggregate_options_get_instance_private(          \
+      GARROW_SCALAR_AGGREGATE_OPTIONS(object)))
 
 static void
-garrow_count_options_finalize(GObject *object)
+garrow_scalar_aggregate_options_finalize(GObject *object)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
-  priv->options.~CountOptions();
-  G_OBJECT_CLASS(garrow_count_options_parent_class)->finalize(object);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
+  priv->options.~ScalarAggregateOptions();
+  G_OBJECT_CLASS(garrow_scalar_aggregate_options_parent_class)->finalize(object);
 }
 
 static void
-garrow_count_options_set_property(GObject *object,
+garrow_scalar_aggregate_options_set_property(GObject *object,
                                   guint prop_id,
                                   const GValue *value,
                                   GParamSpec *pspec)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
   case PROP_MODE:
-    priv->options.count_mode =
-      static_cast<arrow::compute::CountOptions::Mode>(g_value_get_enum(value));
+    priv->options.null_handling =
+      static_cast<arrow::compute::ScalarAggregateOptions::Mode>(g_value_get_enum(value));
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -698,12 +698,12 @@ garrow_count_options_set_property(GObject *object,
 }
 
 static void
-garrow_count_options_get_property(GObject *object,
+garrow_scalar_aggregate_options_get_property(GObject *object,
                                  guint prop_id,
                                  GValue *value,
                                  GParamSpec *pspec)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
   case PROP_MODE:
@@ -716,25 +716,25 @@ garrow_count_options_get_property(GObject *object,
 }
 
 static void
-garrow_count_options_init(GArrowCountOptions *object)
+garrow_scalar_aggregate_options_init(GArrowScalarAggregateOptions *object)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
-  new(&priv->options) arrow::compute::CountOptions(
-    arrow::compute::CountOptions::COUNT_NON_NULL);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
+  new(&priv->options) arrow::compute::ScalarAggregateOptions(
+    arrow::compute::ScalarAggregateOptions::SKIPNA);
 }
 
 static void
-garrow_count_options_class_init(GArrowCountOptionsClass *klass)
+garrow_scalar_aggregate_options_class_init(GArrowScalarAggregateOptionsClass *klass)
 {
   auto gobject_class = G_OBJECT_CLASS(klass);
 
-  gobject_class->finalize     = garrow_count_options_finalize;
-  gobject_class->set_property = garrow_count_options_set_property;
-  gobject_class->get_property = garrow_count_options_get_property;
+  gobject_class->finalize     = garrow_scalar_aggregate_options_finalize;
+  gobject_class->set_property = garrow_scalar_aggregate_options_set_property;
+  gobject_class->get_property = garrow_scalar_aggregate_options_get_property;
 
   GParamSpec *spec;
   /**
-   * GArrowCountOptions:mode:
+   * GArrowScalarAaggregateptions:mode:
    *
    * How to count values.
    *
@@ -750,17 +750,17 @@ garrow_count_options_class_init(GArrowCountOptionsClass *klass)
 }
 
 /**
- * garrow_count_options_new:
+ * garrow_scalar_aggregate_options_new:
  *
- * Returns: A newly created #GArrowCountOptions.
+ * Returns: A newly created #GArrowScalarAggregateOptions.
  *
  * Since: 0.13.0
  */
-GArrowCountOptions *
-garrow_count_options_new(void)
+GArrowScalarAggregateOptions *
+garrow_scalar_aggregate_options_new(void)
 {
-  auto count_options = g_object_new(GARROW_TYPE_COUNT_OPTIONS, NULL);
-  return GARROW_COUNT_OPTIONS(count_options);
+  auto scalar_aggregate_options = g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS, NULL);
+  return GARROW_SCALAR_AGGREGATE_OPTIONS(scalar_aggregate_options);
 }
 
 
@@ -1682,7 +1682,7 @@ garrow_array_dictionary_encode(GArrowArray *array,
 /**
  * garrow_array_count:
  * @array: A #GArrowArray.
- * @options: (nullable): A #GArrowCountOptions.
+ * @options: (nullable): A #GArrowScalarAggregateOptions.
  * @error: (nullable): Return location for a #GError or %NULL.
  *
  * Returns: The number of target values on success. If an error is occurred,
@@ -1692,14 +1692,14 @@ garrow_array_dictionary_encode(GArrowArray *array,
  */
 gint64
 garrow_array_count(GArrowArray *array,
-                   GArrowCountOptions *options,
+                   GArrowScalarAggregateOptions *options,
                    GError **error)
 {
   auto arrow_array = garrow_array_get_raw(array);
   auto arrow_array_raw = arrow_array.get();
   arrow::Result<arrow::Datum> arrow_counted_datum;
   if (options) {
-    auto arrow_options = garrow_count_options_get_raw(options);
+    auto arrow_options = garrow_scalar_aggregate_options_get_raw(options);
     arrow_counted_datum =
       arrow::compute::Count(*arrow_array_raw, *arrow_options);
   } else {
@@ -3059,20 +3059,20 @@ garrow_cast_options_get_raw(GArrowCastOptions *cast_options)
   return &(priv->options);
 }
 
-GArrowCountOptions *
-garrow_count_options_new_raw(arrow::compute::CountOptions *arrow_count_options)
+GArrowScalarAggregateOptions *
+garrow_scalar_aggregate_options_new_raw(arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options)
 {
-  auto count_options =
-    g_object_new(GARROW_TYPE_COUNT_OPTIONS,
-                 "mode", arrow_count_options->count_mode,
+  auto scalar_aggregate_options =
+    g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS,
+                 "mode", arrow_scalar_aggregate_options->count_mode,
                  NULL);
-  return GARROW_COUNT_OPTIONS(count_options);
+  return GARROW_SCALAR_AGGREGATE_OPTIONS(scalar_aggregate_options);
 }
 
-arrow::compute::CountOptions *
-garrow_count_options_get_raw(GArrowCountOptions *count_options)
+arrow::compute::ScalarAggregateOptions *
+garrow_scalar_aggregate_options_get_raw(GArrowScalarAggregateOptions *scalar_aggregate_options)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(count_options);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(scalar_aggregate_options);
   return &(priv->options);
 }
 
diff --git a/c_glib/arrow-glib/compute.h b/c_glib/arrow-glib/compute.h
index 63ba6e0eae5..6842c161558 100644
--- a/c_glib/arrow-glib/compute.h
+++ b/c_glib/arrow-glib/compute.h
@@ -85,30 +85,30 @@ GArrowCastOptions *garrow_cast_options_new(void);
 
 /**
  * GArrowCountMode:
- * @GARROW_COUNT_ALL: Count all non-null values.
- * @GARROW_COUNT_NULL: Count all null values.
+ * @GARROW_SKIPNA: Count all non-null values.
+ * @GARROW_KEEPNA: Count all null values.
  *
- * They are corresponding to `arrow::compute::CountOptions::Mode` values.
+ * They are corresponding to `arrow::compute::ScalarAggregateOptions::Mode` values.
  */
 typedef enum {
-  GARROW_COUNT_ALL,
-  GARROW_COUNT_NULL,
+  GARROW_SKIPNA,
+  GARROW_KEEPNA,
 } GArrowCountMode;
 
-#define GARROW_TYPE_COUNT_OPTIONS (garrow_count_options_get_type())
-G_DECLARE_DERIVABLE_TYPE(GArrowCountOptions,
-                         garrow_count_options,
+#define GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS (garrow_scalar_aggregate_options_get_type())
+G_DECLARE_DERIVABLE_TYPE(GArrowScalarAggregateOptions,
+                         garrow_scalar_aggregate_options,
                          GARROW,
-                         COUNT_OPTIONS,
+                         SCALAR_AGGREGATE_OPTIONS,
                          GObject)
-struct _GArrowCountOptionsClass
+struct _GArrowScalarAggregateOptionsClass
 {
   GObjectClass parent_class;
 };
 
 GARROW_AVAILABLE_IN_0_13
-GArrowCountOptions *
-garrow_count_options_new(void);
+GArrowScalarAggregateOptions *
+garrow_scalar_aggregate_options_new(void);
 
 
 /**
@@ -290,7 +290,7 @@ GArrowDictionaryArray *garrow_array_dictionary_encode(GArrowArray *array,
                                                       GError **error);
 GARROW_AVAILABLE_IN_0_13
 gint64 garrow_array_count(GArrowArray *array,
-                          GArrowCountOptions *options,
+                          GArrowScalarAggregateOptions *options,
                           GError **error);
 GARROW_AVAILABLE_IN_0_13
 GArrowStructArray *garrow_array_count_values(GArrowArray *array,
diff --git a/c_glib/arrow-glib/compute.hpp b/c_glib/arrow-glib/compute.hpp
index 1bc6fefdd40..0b7b9a2bd76 100644
--- a/c_glib/arrow-glib/compute.hpp
+++ b/c_glib/arrow-glib/compute.hpp
@@ -46,10 +46,10 @@ garrow_function_get_raw(GArrowFunction *function);
 GArrowCastOptions *garrow_cast_options_new_raw(arrow::compute::CastOptions *arrow_cast_options);
 arrow::compute::CastOptions *garrow_cast_options_get_raw(GArrowCastOptions *cast_options);
 
-GArrowCountOptions *
-garrow_count_options_new_raw(arrow::compute::CountOptions *arrow_count_options);
-arrow::compute::CountOptions *
-garrow_count_options_get_raw(GArrowCountOptions *count_options);
+GArrowScalarAggregateOptions *
+garrow_scalar_aggregate_options_new_raw(arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options);
+arrow::compute::ScalarAggregateOptions *
+garrow_scalar_aggregate_options_get_raw(GArrowScalarAggregateOptions *scalar_aggregate_options);
 
 arrow::compute::FilterOptions *
 garrow_filter_options_get_raw(GArrowFilterOptions *filter_options);
diff --git a/c_glib/test/test-count.rb b/c_glib/test/test-count.rb
index 36390f880aa..cbbff4af291 100644
--- a/c_glib/test/test-count.rb
+++ b/c_glib/test/test-count.rb
@@ -19,10 +19,10 @@ class TestCount < Test::Unit::TestCase
   include Helper::Buildable
   include Helper::Omittable
 
-  sub_test_case("CountOptions") do
+  sub_test_case("ScalarAggregateOptions") do
     def test_default_mode
       assert_equal(Arrow::CountMode::ALL,
-                   Arrow::CountOptions.new.mode)
+                   Arrow::ScalarAggregateOptions.new.mode)
     end
   end
 
@@ -32,13 +32,13 @@ def test_default
     end
 
     def test_all
-      options = Arrow::CountOptions.new
+      options = Arrow::ScalarAggregateOptions.new
       options.mode = :all
       assert_equal(2, build_int32_array([1, nil, 3]).count(options))
     end
 
     def test_null
-      options = Arrow::CountOptions.new
+      options = Arrow::ScalarAggregateOptions.new
       options.mode = :null
       assert_equal(1, build_int32_array([1, nil, 3]).count(options))
     end

From d78b9cd6dc924249aaa3e74a3bf1364ffaf5a193 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 15 Apr 2021 15:18:01 +0200
Subject: [PATCH 08/23] Changes to Python and c_glib.

---
 c_glib/arrow-glib/compute.cpp        |  2 +-
 c_glib/arrow-glib/compute.h          |  4 +--
 c_glib/test/test-count.rb            |  2 +-
 python/pyarrow/_compute.pyx          | 47 +++++++---------------------
 python/pyarrow/compute.py            |  3 +-
 python/pyarrow/includes/libarrow.pxd | 34 +++++++-------------
 python/pyarrow/tests/test_compute.py | 27 +++++++++-------
 r/src/compute.cpp                    |  3 +-
 8 files changed, 45 insertions(+), 77 deletions(-)

diff --git a/c_glib/arrow-glib/compute.cpp b/c_glib/arrow-glib/compute.cpp
index 3d299ee78f8..5237c9ab68f 100644
--- a/c_glib/arrow-glib/compute.cpp
+++ b/c_glib/arrow-glib/compute.cpp
@@ -707,7 +707,7 @@ garrow_scalar_aggregate_options_get_property(GObject *object,
 
   switch (prop_id) {
   case PROP_MODE:
-    g_value_set_enum(value, priv->options.count_mode);
+    g_value_set_enum(value, priv->options.scalar_aggregate_mode);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
diff --git a/c_glib/arrow-glib/compute.h b/c_glib/arrow-glib/compute.h
index 6842c161558..fdc6555409a 100644
--- a/c_glib/arrow-glib/compute.h
+++ b/c_glib/arrow-glib/compute.h
@@ -84,7 +84,7 @@ GArrowCastOptions *garrow_cast_options_new(void);
 
 
 /**
- * GArrowCountMode:
+ * GArrowScalarAggregateMode:
  * @GARROW_SKIPNA: Count all non-null values.
  * @GARROW_KEEPNA: Count all null values.
  *
@@ -93,7 +93,7 @@ GArrowCastOptions *garrow_cast_options_new(void);
 typedef enum {
   GARROW_SKIPNA,
   GARROW_KEEPNA,
-} GArrowCountMode;
+} GArrowScalarAggregateMode;
 
 #define GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS (garrow_scalar_aggregate_options_get_type())
 G_DECLARE_DERIVABLE_TYPE(GArrowScalarAggregateOptions,
diff --git a/c_glib/test/test-count.rb b/c_glib/test/test-count.rb
index cbbff4af291..aba673292c9 100644
--- a/c_glib/test/test-count.rb
+++ b/c_glib/test/test-count.rb
@@ -21,7 +21,7 @@ class TestCount < Test::Unit::TestCase
 
   sub_test_case("ScalarAggregateOptions") do
     def test_default_mode
-      assert_equal(Arrow::CountMode::ALL,
+      assert_equal(Arrow::ScalarAggregateMode::KEEPNA,
                    Arrow::ScalarAggregateOptions.new.mode)
     end
   end
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 3af485343f2..2cf7bfada7b 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -824,56 +824,31 @@ class ProjectOptions(_ProjectOptions):
         self._set_options(field_names)
 
 
-cdef class _MinMaxOptions(FunctionOptions):
+cdef class _ScalarAggregateOptions(FunctionOptions):
     cdef:
-        unique_ptr[CMinMaxOptions] min_max_options
+        unique_ptr[CScalarAggregateOptions] scalar_aggregate_options
 
     cdef const CFunctionOptions* get_options(self) except NULL:
-        return self.min_max_options.get()
+        return self.scalar_aggregate_options.get()
 
     def _set_options(self, null_handling):
-        if null_handling == 'skip':
-            self.min_max_options.reset(
-                new CMinMaxOptions(CMinMaxMode_SKIP))
-        elif null_handling == 'emit_null':
-            self.min_max_options.reset(
-                new CMinMaxOptions(CMinMaxMode_EMIT_NULL))
+        if null_handling == 'skipna':
+            self.scalar_aggregate_options.reset(
+                new CScalarAggregateOptions(CScalarAggregateMode_SKIPNA))
+        elif null_handling == 'keepna':
+            self.scalar_aggregate_options.reset(
+                new CScalarAggregateOptions(CScalarAggregateMode_KEEPNA))
         else:
             raise ValueError(
                 '{!r} is not a valid null_handling'
                 .format(null_handling))
 
 
-class MinMaxOptions(_MinMaxOptions):
-    def __init__(self, null_handling='skip'):
+class ScalarAggregateOptions(_ScalarAggregateOptions):
+    def __init__(self, null_handling='skipna'):
         self._set_options(null_handling)
 
 
-cdef class _CountOptions(FunctionOptions):
-    cdef:
-        unique_ptr[CCountOptions] count_options
-
-    cdef const CFunctionOptions* get_options(self) except NULL:
-        return self.count_options.get()
-
-    def _set_options(self, count_mode):
-        if count_mode == 'count_null':
-            self.count_options.reset(
-                new CCountOptions(CCountMode_COUNT_NULL))
-        elif count_mode == 'count_non_null':
-            self.count_options.reset(
-                new CCountOptions(CCountMode_COUNT_NON_NULL))
-        else:
-            raise ValueError(
-                '{!r} is not a valid count_mode'
-                .format(count_mode))
-
-
-class CountOptions(_CountOptions):
-    def __init__(self, count_mode='count_non_null'):
-        self._set_options(count_mode)
-
-
 cdef class _ModeOptions(FunctionOptions):
     cdef:
         unique_ptr[CModeOptions] mode_options
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index ec38710b023..e2be4d59855 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -31,13 +31,12 @@
     # Option classes
     ArraySortOptions,
     CastOptions,
-    CountOptions,
     DictionaryEncodeOptions,
     ExtractRegexOptions,
     FilterOptions,
     MatchSubstringOptions,
-    MinMaxOptions,
     ModeOptions,
+    ScalarAggregateOptions,
     SplitOptions,
     SplitPatternOptions,
     PartitionNthOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 4ac18d1e905..7a8c541fdd9 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1872,35 +1872,23 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         CVarianceOptions(int ddof)
         int ddof
 
-    enum CMinMaxMode \
-            "arrow::compute::MinMaxOptions::Mode":
-        CMinMaxMode_SKIP \
-            "arrow::compute::MinMaxOptions::SKIP"
-        CMinMaxMode_EMIT_NULL \
-            "arrow::compute::MinMaxOptions::EMIT_NULL"
-
-    cdef cppclass CMinMaxOptions \
-            "arrow::compute::MinMaxOptions"(CFunctionOptions):
-        CMinMaxOptions(CMinMaxMode null_handling)
-        CMinMaxMode null_handling
+    enum CScalarAggregateMode \
+            "arrow::compute::ScalarAggregateOptions::Mode":
+        CScalarAggregateMode_SKIPNA \
+            "arrow::compute::ScalarAggregateOptions::SKIPNA"
+        CScalarAggregateMode_KEEPNA \
+            "arrow::compute::ScalarAggregateOptions::KEEPNA"
+
+    cdef cppclass CScalarAggregateOptions \
+            "arrow::compute::ScalarAggregateOptions"(CFunctionOptions):
+        CScalarAggregateOptions(CScalarAggregateMode null_handling)
+        CScalarAggregateMode null_handling
 
     cdef cppclass CModeOptions \
             "arrow::compute::ModeOptions"(CFunctionOptions):
         CModeOptions(int64_t n)
         int64_t n
 
-    enum CCountMode \
-            "arrow::compute::CountOptions::Mode":
-        CCountMode_COUNT_NON_NULL \
-            "arrow::compute::CountOptions::COUNT_NON_NULL"
-        CCountMode_COUNT_NULL \
-            "arrow::compute::CountOptions::COUNT_NULL"
-
-    cdef cppclass CCountOptions \
-            "arrow::compute::CountOptions"(CFunctionOptions):
-        CCountOptions(CCountMode count_mode)
-        CCountMode count_mode
-
     cdef cppclass CPartitionNthOptions \
             "arrow::compute::PartitionNthOptions"(CFunctionOptions):
         CPartitionNthOptions(int64_t pivot)
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 8e045fb4f2d..17f9aa974d4 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -354,24 +354,28 @@ def test_min_max():
     data = [4, 5, 6, None, 1]
     s = pc.min_max(data)
     assert s.as_py() == {'min': 1, 'max': 6}
-    s = pc.min_max(data, options=pc.MinMaxOptions())
+    s = pc.min_max(data, options=pc.ScalarAggregateOptions())
     assert s.as_py() == {'min': 1, 'max': 6}
-    s = pc.min_max(data, options=pc.MinMaxOptions(null_handling='skip'))
+    s = pc.min_max(data, options=pc.ScalarAggregateOptions(
+        null_handling='skipna'))
     assert s.as_py() == {'min': 1, 'max': 6}
-    s = pc.min_max(data, options=pc.MinMaxOptions(null_handling='emit_null'))
+    s = pc.min_max(data, options=pc.ScalarAggregateOptions(
+        null_handling='keepna'))
     assert s.as_py() == {'min': None, 'max': None}
 
     # Options as dict of kwargs
-    s = pc.min_max(data, options={'null_handling': 'emit_null'})
+    s = pc.min_max(data, options={
+        'null_handling': 'keepna'})
     assert s.as_py() == {'min': None, 'max': None}
     # Options as named functions arguments
-    s = pc.min_max(data, null_handling='emit_null')
+    s = pc.min_max(data,
+                   null_handling='keepna')
     assert s.as_py() == {'min': None, 'max': None}
 
     # Both options and named arguments
     with pytest.raises(TypeError):
-        s = pc.min_max(data, options=pc.MinMaxOptions(),
-                       null_handling='emit_null')
+        s = pc.min_max(data, options=pc.ScalarAggregateOptions(),
+                       null_handling='keepna')
 
     # Wrong options type
     options = pc.TakeOptions()
@@ -427,7 +431,7 @@ def test_generated_docstrings():
         Compute the minimum and maximum values of a numeric array.
 
         Null values are ignored by default.
-        This can be changed through MinMaxOptions.
+        This can be changed through ScalarAggregateOptions.
 
         Parameters
         ----------
@@ -435,11 +439,12 @@ def test_generated_docstrings():
             Argument to compute function
         memory_pool : pyarrow.MemoryPool, optional
             If not passed, will allocate memory from the default memory pool.
-        options : pyarrow.compute.MinMaxOptions, optional
+        options : pyarrow.compute.ScalarAggregateOptions, optional
             Parameters altering compute function semantics
         **kwargs : optional
-            Parameters for MinMaxOptions constructor.  Either `options`
-            or `**kwargs` can be passed, but not both at the same time.
+            Parameters for ScalarAggregateOptions constructor.  Either
+            `options` or `**kwargs` can be passed, but not both at the same
+            time.
         """)
     assert pc.add.__doc__ == textwrap.dedent("""\
         Add the arguments element-wise.
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index e0d25a6288d..30b2454ccfb 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -171,7 +171,8 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
     return out;
   }
 
-  if (func_name == "min_max" || func_name == "sum" || func_name == "mean" || func_name == "count") {
+  if (func_name == "min_max" || func_name == "sum" || func_name == "mean" ||
+      func_name == "count") {
     using Options = arrow::compute::ScalarAggregateOptions;
     auto out = std::make_shared<Options>(Options::Defaults());
     out->min_count = cpp11::as_cpp<int>(options["na.min_count"]);

From ebdcbade044d27935b89df9419781a92af863167 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Fri, 16 Apr 2021 01:42:40 +0200
Subject: [PATCH 09/23] Further R and Python work.

---
 cpp/src/arrow/compute/api_aggregate.h         |  16 +-
 .../arrow/compute/kernels/aggregate_basic.cc  |  13 +-
 .../kernels/aggregate_basic_internal.h        |  19 ++-
 .../arrow/compute/kernels/aggregate_test.cc   | 146 ++++++++----------
 .../arrow/compute/kernels/hash_aggregate.cc   |   4 +-
 .../compute/kernels/hash_aggregate_test.cc    |   4 +-
 docs/source/cpp/compute.rst                   |   4 +-
 python/pyarrow/_compute.pyx                   |  18 +--
 python/pyarrow/compute.py                     |   2 +-
 python/pyarrow/includes/libarrow.pxd          |  12 +-
 python/pyarrow/tests/test_compute.py          |  28 ++--
 r/R/compute.R                                 |  30 ++--
 r/src/compute.cpp                             |   2 +-
 r/tests/testthat/test-compute-aggregate.R     |   6 +-
 14 files changed, 129 insertions(+), 175 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index f3ff81154ba..34f676e25e3 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -41,21 +41,13 @@ class ExecContext;
 ///
 /// By default, null values are ignored
 struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
-  enum Mode {
-    /// Skip null values.
-    SKIPNA = 0,
-    /// Calculate over all values.
-    KEEPNA,
-  };
-
-  explicit ScalarAggregateOptions(enum Mode null_handling = SKIPNA,
-                                  uint32_t min_count = 1)
-      : null_handling(null_handling), min_count(min_count) {}
+  explicit ScalarAggregateOptions(bool skip_nulls = true, uint32_t min_count = 1)
+      : skip_nulls(skip_nulls), min_count(min_count) {}
 
   static ScalarAggregateOptions Defaults() { return ScalarAggregateOptions{}; }
 
-  enum Mode null_handling;
-  uint32_t min_count;
+  bool skip_nulls = true;
+  uint32_t min_count = 1;
 };
 
 /// \brief Control Mode kernel behavior
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index c0cf5a6c603..feb10375d49 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -75,15 +75,10 @@ struct CountImpl : public ScalarAggregator {
 
   Status Finalize(KernelContext* ctx, Datum* out) override {
     const auto& state = checked_cast<const CountImpl&>(*ctx->state());
-    switch (state.options.null_handling) {
-      case ScalarAggregateOptions::SKIPNA:
-        *out = Datum(state.non_nulls);
-        break;
-      case ScalarAggregateOptions::KEEPNA:
-        *out = Datum(state.nulls);
-        break;
-      default:
-        return Status::Invalid("Unknown ScalarAggregateOptions encountered");
+    if (state.options.skip_nulls) {
+      *out = Datum(state.non_nulls);
+    } else {
+      *out = Datum(state.nulls);
     }
     return Status::OK();
   }
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 42b89c75c40..41cb7fb4f11 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -101,15 +101,15 @@ struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
     //    const ScalarAggregateOptions& options = checked_cast<const ScalarAggregateState&>(*ctx->state()).options;
     const auto& state = checked_cast<const MeanImpl&>(*ctx->state());
 
-    if (this->count == 0 && options.min_count == 0) {
+    if (this->count == 0 || this->count < options.min_count) {
       out->value = std::make_shared<DoubleScalar>(0);
     } else if (this->count < options.min_count) {
       out->value = std::make_shared<DoubleScalar>();
-    } else if (options.null_handling == ScalarAggregateOptions::KEEPNA) {
-      const double mean = static_cast<double>(this->sum) / this->length;
+    } else if (options.skip_nulls) {
+      const double mean = static_cast<double>(this->sum) / this->count;
       out->value = std::make_shared<DoubleScalar>(mean);
     } else {
-      const double mean = static_cast<double>(this->sum) / this->count;
+      const double mean = static_cast<double>(this->sum) / this->length;
       out->value = std::make_shared<DoubleScalar>(mean);
     }
     return Status::OK();
@@ -248,7 +248,7 @@ struct MinMaxImpl : public ScalarAggregator {
     local.has_nulls = null_count > 0;
     local.has_values = (arr.length() - null_count) > 0;
 
-    if (local.has_nulls && options.null_handling == ScalarAggregateOptions::KEEPNA) {
+    if (local.has_nulls && !options.skip_nulls) {
       this->state = local;
       return Status::OK();
     }
@@ -274,8 +274,11 @@ struct MinMaxImpl : public ScalarAggregator {
     using ScalarType = typename TypeTraits<ArrowType>::ScalarType;
 
     std::vector<std::shared_ptr<Scalar>> values;
-    if (!state.has_values ||
-        (state.has_nulls && options.null_handling == ScalarAggregateOptions::KEEPNA)) {
+    if (!state.has_values && options.skip_nulls && options.min_count == 0) {
+      // (Inf, -Inf)
+      values = {std::make_shared<ScalarType>(INFINITY),
+                std::make_shared<ScalarType>(-INFINITY)};
+    } else if (!state.has_values || (state.has_nulls && !options.skip_nulls)) {
       // (null, null)
       values = {std::make_shared<ScalarType>(), std::make_shared<ScalarType>()};
     } else {
@@ -366,7 +369,7 @@ struct BooleanMinMaxImpl : public MinMaxImpl<BooleanType, SimdLevel> {
 
     local.has_nulls = null_count > 0;
     local.has_values = valid_count > 0;
-    if (local.has_nulls && options.null_handling == ScalarAggregateOptions::KEEPNA) {
+    if (local.has_nulls && !options.skip_nulls) {
       this->state = local;
       return Status::OK();
     }
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 35396d853b1..bff3e4612bf 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -166,8 +166,7 @@ TEST(TestBooleanAggregation, Sum) {
   ValidateBooleanAgg<Sum>("[true, false, true, true, null]",
                           std::make_shared<UInt64Scalar>(3), options);
 
-  const ScalarAggregateOptions& options_min_count_zero =
-      ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0);
+  const ScalarAggregateOptions& options_min_count_zero = ScalarAggregateOptions(true, 0);
   ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(0),
                           options_min_count_zero);
   ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(0),
@@ -175,17 +174,17 @@ TEST(TestBooleanAggregation, Sum) {
 
   const char* json = "[true, null, false, null]";
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
+                          ScalarAggregateOptions(true, 1));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
+                          ScalarAggregateOptions(true, 2));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
+                          ScalarAggregateOptions(true, 3));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
+                          ScalarAggregateOptions(false, 1));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
+                          ScalarAggregateOptions(false, 2));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
+                          ScalarAggregateOptions(false, 3));
 }
 
 TEST(TestBooleanAggregation, Mean) {
@@ -202,26 +201,25 @@ TEST(TestBooleanAggregation, Mean) {
   ValidateBooleanAgg<Mean>("[true, null, false, false, false]",
                            std::make_shared<DoubleScalar>(0.25), options);
 
-  const ScalarAggregateOptions& options_min_count_zero =
-      ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0);
-  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(0),
+  const ScalarAggregateOptions& options_min_count_zero = ScalarAggregateOptions(true, 0);
+  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(),
                            options_min_count_zero);
-  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(0),
+  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(),
                            options_min_count_zero);
 
   const char* json = "[true, null, false, null]";
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
-                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
+                           ScalarAggregateOptions(true, 1));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
-                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 2));
+                           ScalarAggregateOptions(true, 2));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
-                           ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
+                           ScalarAggregateOptions(true, 3));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.25),
-                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
+                           ScalarAggregateOptions(false, 1));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.25),
-                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 2));
+                           ScalarAggregateOptions(false, 2));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
-                           ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
+                           ScalarAggregateOptions(false, 3));
 }
 
 template <typename ArrowType>
@@ -232,8 +230,7 @@ TYPED_TEST(TestNumericSumKernel, SimpleSum) {
   using SumType = typename FindAccumulatorType<TypeParam>::Type;
   using ScalarType = typename TypeTraits<SumType>::ScalarType;
   using T = typename TypeParam::c_type;
-  const ScalarAggregateOptions& options =
-      ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0);
+  const ScalarAggregateOptions& options = ScalarAggregateOptions(true, 0);
 
   ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))),
                          options);
@@ -281,26 +278,16 @@ TYPED_TEST(TestNumericSumKernel, ScalarAggregateOptions) {
   auto result = Datum(std::make_shared<ScalarType>(expected_result));
   const char* json = "[1, null, 3, null, 3, null, 7]";
 
-  ValidateSum<TypeParam>("[]", zero_result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
-  ValidateSum<TypeParam>("[null]", zero_result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
-  ValidateSum<TypeParam>(json, result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
-  ValidateSum<TypeParam>(json, result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 4));
-  ValidateSum<TypeParam>(json, null_result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
-  ValidateSum<TypeParam>("[]", null_result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
-  ValidateSum<TypeParam>("[null]", null_result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
-  ValidateSum<TypeParam>(json, result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
-  ValidateSum<TypeParam>(json, result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 4));
-  ValidateSum<TypeParam>(json, null_result,
-                         ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 5));
+  ValidateSum<TypeParam>("[]", zero_result, ScalarAggregateOptions(true, 0));
+  ValidateSum<TypeParam>("[null]", zero_result, ScalarAggregateOptions(true, 0));
+  ValidateSum<TypeParam>(json, result, ScalarAggregateOptions(true, 3));
+  ValidateSum<TypeParam>(json, result, ScalarAggregateOptions(true, 4));
+  ValidateSum<TypeParam>(json, null_result, ScalarAggregateOptions(true, 5));
+  ValidateSum<TypeParam>("[]", null_result, ScalarAggregateOptions(true, 1));
+  ValidateSum<TypeParam>("[null]", null_result, ScalarAggregateOptions(true, 1));
+  ValidateSum<TypeParam>(json, result, ScalarAggregateOptions(false, 3));
+  ValidateSum<TypeParam>(json, result, ScalarAggregateOptions(false, 4));
+  ValidateSum<TypeParam>(json, null_result, ScalarAggregateOptions(false, 5));
 }
 
 template <typename ArrowType>
@@ -404,8 +391,8 @@ static CountPair NaiveCount(const Array& array) {
 }
 
 void ValidateCount(const Array& input, CountPair expected) {
-  ScalarAggregateOptions all = ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA);
-  ScalarAggregateOptions nulls = ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA);
+  ScalarAggregateOptions all = ScalarAggregateOptions(true);
+  ScalarAggregateOptions nulls = ScalarAggregateOptions(false);
 
   ASSERT_OK_AND_ASSIGN(Datum result, Count(input, all));
   AssertDatumsEqual(result, Datum(expected.first));
@@ -498,12 +485,11 @@ TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
 TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
   using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
 
-  const ScalarAggregateOptions& options =
-      ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0);
+  const ScalarAggregateOptions& options = ScalarAggregateOptions(true, 0);
 
-  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>(0)), options);
+  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>()), options);
 
-  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(0)), options);
+  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()), options);
 
   ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>()));
 
@@ -532,39 +518,23 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
   auto zero_result = Datum(std::make_shared<ScalarType>(static_cast<T>(0)));
   const char* json = "[1, null, 2, 2, null, 7]";
 
-  ValidateMean<TypeParam>("[]", zero_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
-  ValidateMean<TypeParam>("[null]", zero_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
-  ValidateMean<TypeParam>("[]", null_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
-  ValidateMean<TypeParam>("[null]", null_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 1));
-  ValidateMean<TypeParam>(json, expected_result_skipna,
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 0));
-  ValidateMean<TypeParam>(json, expected_result_skipna,
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 3));
-  ValidateMean<TypeParam>(json, expected_result_skipna,
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 4));
-  ValidateMean<TypeParam>(json, null_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::SKIPNA, 5));
-
-  ValidateMean<TypeParam>("[]", zero_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
-  ValidateMean<TypeParam>("[null]", zero_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
-  ValidateMean<TypeParam>("[]", null_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
-  ValidateMean<TypeParam>("[null]", null_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 1));
-  ValidateMean<TypeParam>(json, expected_result_keepna,
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 0));
-  ValidateMean<TypeParam>(json, expected_result_keepna,
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 3));
-  ValidateMean<TypeParam>(json, expected_result_keepna,
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 4));
-  ValidateMean<TypeParam>(json, null_result,
-                          ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA, 15));
+  ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(true, 0));
+  ValidateMean<TypeParam>("[null]", null_result, ScalarAggregateOptions(true, 0));
+  ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(true, 1));
+  ValidateMean<TypeParam>("[null]", null_result, ScalarAggregateOptions(true, 1));
+  ValidateMean<TypeParam>(json, expected_result_skipna, ScalarAggregateOptions(true, 0));
+  ValidateMean<TypeParam>(json, expected_result_skipna, ScalarAggregateOptions(true, 3));
+  ValidateMean<TypeParam>(json, expected_result_skipna, ScalarAggregateOptions(true, 4));
+  ValidateMean<TypeParam>(json, null_result, ScalarAggregateOptions(true, 5));
+
+  ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(false, 0));
+  ValidateMean<TypeParam>("[null]", null_result, ScalarAggregateOptions(false, 0));
+  ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(false, 1));
+  ValidateMean<TypeParam>("[null]", null_result, ScalarAggregateOptions(false, 1));
+  ValidateMean<TypeParam>(json, expected_result_keepna, ScalarAggregateOptions(false, 0));
+  ValidateMean<TypeParam>(json, expected_result_keepna, ScalarAggregateOptions(false, 3));
+  ValidateMean<TypeParam>(json, expected_result_keepna, ScalarAggregateOptions(false, 4));
+  ValidateMean<TypeParam>(json, null_result, ScalarAggregateOptions(false, 15));
 }
 
 template <typename ArrowType>
@@ -694,7 +664,7 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
   this->AssertMinMaxIs(chunked_input2, false, false, options);
   this->AssertMinMaxIs(chunked_input3, false, true, options);
 
-  options = ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA);
+  options = ScalarAggregateOptions(false);
   this->AssertMinMaxIsNull("[]", options);
   this->AssertMinMaxIsNull("[null, null, null]", options);
   this->AssertMinMaxIsNull("[false, null, false]", options);
@@ -706,6 +676,10 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
   this->AssertMinMaxIsNull(chunked_input1, options);
   this->AssertMinMaxIs(chunked_input2, false, false, options);
   this->AssertMinMaxIsNull(chunked_input3, options);
+
+  options = ScalarAggregateOptions(true, 0);
+  this->AssertMinMaxIs("[]", INFINITY, -INFINITY, options);
+  this->AssertMinMaxIs("[null]", INFINITY, -INFINITY, options);
 }
 
 TYPED_TEST_SUITE(TestIntegerMinMaxKernel, IntegralArrowTypes);
@@ -724,7 +698,7 @@ TYPED_TEST(TestIntegerMinMaxKernel, Basics) {
   this->AssertMinMaxIs(chunked_input2, 1, 9, options);
   this->AssertMinMaxIs(chunked_input3, 1, 9, options);
 
-  options = ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA);
+  options = ScalarAggregateOptions(false);
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   // output null
   this->AssertMinMaxIsNull("[5, null, 2, 3, 4]", options);
@@ -751,7 +725,7 @@ TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
   this->AssertMinMaxIs(chunked_input2, 1, 9, options);
   this->AssertMinMaxIs(chunked_input3, 1, 9, options);
 
-  options = ScalarAggregateOptions(ScalarAggregateOptions::KEEPNA);
+  options = ScalarAggregateOptions(false);
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   this->AssertMinMaxIs("[5, -Inf, 2, 3, 4]", -INFINITY, 5, options);
   // output null
@@ -762,6 +736,14 @@ TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
   this->AssertMinMaxIsNull(chunked_input1, options);
   this->AssertMinMaxIsNull(chunked_input2, options);
   this->AssertMinMaxIsNull(chunked_input3, options);
+
+  options = ScalarAggregateOptions(true, 0);
+  this->AssertMinMaxIs("[]", INFINITY, -INFINITY, options);
+  this->AssertMinMaxIs("[null]", INFINITY, -INFINITY, options);
+
+  options = ScalarAggregateOptions(false, 1);
+  this->AssertMinMaxIsNull("[]", options);
+  this->AssertMinMaxIsNull("[null]", options);
 }
 
 TYPED_TEST(TestFloatingMinMaxKernel, DefaultOptions) {
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index ddb76232302..df2a387219b 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -482,7 +482,7 @@ struct GroupedCountImpl : public GroupedAggregator {
 
     const auto& input = batch[0].array();
 
-    if (options_.null_handling == ScalarAggregateOptions::KEEPNA) {
+    if (!options_.skip_nulls) {
       if (input->GetNullCount() >= options_.min_count) {
         for (int64_t i = 0, input_i = input->offset; i < input->length; ++i, ++input_i) {
           auto g = group_ids[i];
@@ -739,7 +739,7 @@ struct GroupedMinMaxImpl : public GroupedAggregator {
     // aggregation for group is valid if there was at least one value in that group
     ARROW_ASSIGN_OR_RAISE(auto null_bitmap, has_values_.Finish());
 
-    if (options_.null_handling == ScalarAggregateOptions::KEEPNA) {
+    if (!options_.skip_nulls) {
       // ... and there were no nulls in that group
       ARROW_ASSIGN_OR_RAISE(auto has_nulls, has_nulls_.Finish());
       arrow::internal::BitmapAndNot(null_bitmap->data(), 0, has_nulls->data(), 0,
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
index 67d9f318c8f..aeeab84f335 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
@@ -659,8 +659,8 @@ TEST(GroupBy, ConcreteCaseWithValidateGroupBy) {
     [null,  "gama"]
   ])");
 
-  ScalarAggregateOptions keepna{ScalarAggregateOptions::KEEPNA};
-  ScalarAggregateOptions skipna{ScalarAggregateOptions::KEEPNA};
+  ScalarAggregateOptions keepna{false};
+  ScalarAggregateOptions skipna{true};
 
   using internal::Aggregate;
   for (auto agg : {
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index e8ed38bc655..4788bec8bdb 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -82,8 +82,8 @@ Many compute functions are also available directly as concrete APIs, here
 Some functions accept or require an options structure that determines the
 exact semantics of the function::
 
-   ScalarAggregateOptions min_max_options;
-   scalar_aggregate_options.null_handling = ScalarAggregateOptions::KEEPNA;
+   ScalarAggregateOptions scalar_aggregate_options;
+   scalar_aggregate_options.skip_nulls = false;
 
    std::shared_ptr<arrow::Array> array = ...;
    arrow::Datum min_max;
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 2cf7bfada7b..aea72c457e0 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -831,22 +831,14 @@ cdef class _ScalarAggregateOptions(FunctionOptions):
     cdef const CFunctionOptions* get_options(self) except NULL:
         return self.scalar_aggregate_options.get()
 
-    def _set_options(self, null_handling):
-        if null_handling == 'skipna':
-            self.scalar_aggregate_options.reset(
-                new CScalarAggregateOptions(CScalarAggregateMode_SKIPNA))
-        elif null_handling == 'keepna':
-            self.scalar_aggregate_options.reset(
-                new CScalarAggregateOptions(CScalarAggregateMode_KEEPNA))
-        else:
-            raise ValueError(
-                '{!r} is not a valid null_handling'
-                .format(null_handling))
+    def _set_options(self, skip_nulls, min_count):
+        self.scalar_aggregate_options.reset(
+            new CScalarAggregateOptions(skip_nulls, min_count))
 
 
 class ScalarAggregateOptions(_ScalarAggregateOptions):
-    def __init__(self, null_handling='skipna'):
-        self._set_options(null_handling)
+    def __init__(self, skip_nulls=True, min_count=1):
+        self._set_options(skip_nulls, min_count)
 
 
 cdef class _ModeOptions(FunctionOptions):
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index e2be4d59855..367d1316c99 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -127,7 +127,7 @@ def _decorate_compute_function(wrapper, exposed_name, func, option_class):
             options : pyarrow.compute.{0}, optional
                 Parameters altering compute function semantics
             **kwargs : optional
-                Parameters for {0} constructor.  Either `options`
+                Parameters for {0} constructor. Either `options`
                 or `**kwargs` can be passed, but not both at the same time.
             """.format(option_class.__name__))
 
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 7a8c541fdd9..9b05359bdf4 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1872,17 +1872,11 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         CVarianceOptions(int ddof)
         int ddof
 
-    enum CScalarAggregateMode \
-            "arrow::compute::ScalarAggregateOptions::Mode":
-        CScalarAggregateMode_SKIPNA \
-            "arrow::compute::ScalarAggregateOptions::SKIPNA"
-        CScalarAggregateMode_KEEPNA \
-            "arrow::compute::ScalarAggregateOptions::KEEPNA"
-
     cdef cppclass CScalarAggregateOptions \
             "arrow::compute::ScalarAggregateOptions"(CFunctionOptions):
-        CScalarAggregateOptions(CScalarAggregateMode null_handling)
-        CScalarAggregateMode null_handling
+        CScalarAggregateOptions(c_bool skip_nulls, int64_t min_count)
+        c_bool skip_nulls
+        int64_t min_count
 
     cdef cppclass CModeOptions \
             "arrow::compute::ModeOptions"(CFunctionOptions):
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 17f9aa974d4..3f09f2b17d3 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -356,26 +356,22 @@ def test_min_max():
     assert s.as_py() == {'min': 1, 'max': 6}
     s = pc.min_max(data, options=pc.ScalarAggregateOptions())
     assert s.as_py() == {'min': 1, 'max': 6}
-    s = pc.min_max(data, options=pc.ScalarAggregateOptions(
-        null_handling='skipna'))
+    s = pc.min_max(data, options=pc.ScalarAggregateOptions(skip_nulls=True))
     assert s.as_py() == {'min': 1, 'max': 6}
-    s = pc.min_max(data, options=pc.ScalarAggregateOptions(
-        null_handling='keepna'))
+    s = pc.min_max(data, options=pc.ScalarAggregateOptions(skip_nulls=False))
     assert s.as_py() == {'min': None, 'max': None}
 
     # Options as dict of kwargs
-    s = pc.min_max(data, options={
-        'null_handling': 'keepna'})
+    s = pc.min_max(data, options={'skip_nulls': False})
     assert s.as_py() == {'min': None, 'max': None}
     # Options as named functions arguments
-    s = pc.min_max(data,
-                   null_handling='keepna')
+    s = pc.min_max(data, skip_nulls=False)
     assert s.as_py() == {'min': None, 'max': None}
 
     # Both options and named arguments
     with pytest.raises(TypeError):
-        s = pc.min_max(data, options=pc.ScalarAggregateOptions(),
-                       null_handling='keepna')
+        s = pc.min_max(
+            data, options=pc.ScalarAggregateOptions(), skip_nulls=False)
 
     # Wrong options type
     options = pc.TakeOptions()
@@ -442,9 +438,8 @@ def test_generated_docstrings():
         options : pyarrow.compute.ScalarAggregateOptions, optional
             Parameters altering compute function semantics
         **kwargs : optional
-            Parameters for ScalarAggregateOptions constructor.  Either
-            `options` or `**kwargs` can be passed, but not both at the same
-            time.
+            Parameters for ScalarAggregateOptions constructor. Either `options`
+            or `**kwargs` can be passed, but not both at the same time.
         """)
     assert pc.add.__doc__ == textwrap.dedent("""\
         Add the arguments element-wise.
@@ -1097,11 +1092,8 @@ def test_strptime():
 def test_count():
     arr = pa.array([1, 2, 3, None, None])
     assert pc.count(arr).as_py() == 3
-    assert pc.count(arr, count_mode='count_non_null').as_py() == 3
-    assert pc.count(arr, count_mode='count_null').as_py() == 2
-
-    with pytest.raises(ValueError, match="'zzz' is not a valid count_mode"):
-        pc.count(arr, count_mode='zzz')
+    assert pc.count(arr, skip_nulls=True).as_py() == 3
+    assert pc.count(arr, skip_nulls=False).as_py() == 2
 
 
 def test_partition_nth():
diff --git a/r/R/compute.R b/r/R/compute.R
index f94183d44ed..addbbcd957f 100644
--- a/r/R/compute.R
+++ b/r/R/compute.R
@@ -96,30 +96,32 @@ list_compute_functions <- function(pattern = NULL, ...) {
 
 #' @export
 sum.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
-  scalar_aggregate("sum", ..., na.rm = na.rm, na.min_count = na.min_count)
+  a <- collect_arrays_from_dots(list(...))
+  if (!na.rm) {
+    na.min_count = length(a)
+  }
+  call_function("sum", a, options = list(na.rm = na.rm, na.min_count = na.min_count))
 }
 
 #' @export
-mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
-  scalar_aggregate("mean", ..., na.rm = na.rm, na.min_count = na.min_count)
+mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+  a <- collect_arrays_from_dots(list(...))
+  if (!na.rm) {
+    na.min_count = length(a)
+  }
+  call_function("mean", a, options = list(na.rm = na.rm, na.min_count = na.min_count))
 }
 
 #' @export
-min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
-  scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("min")
+min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+  a <- collect_arrays_from_dots(list(...))
+  call_function("min_max", a, options = list(na.rm = na.rm, na.min_count = na.min_count))$GetFieldByName("min")
 }
 
 #' @export
-max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
-  scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("max")
-}
-
-scalar_aggregate <- function(FUN, ..., na.rm, na.min_count) {
+max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
   a <- collect_arrays_from_dots(list(...))
-  if (!na.rm) {
-    na.min_count = length(a)
-  }
-  call_function(FUN, a, options = list(na.rm = na.rm, na.min_count = na.min_count))
+  call_function("min_max", a, options = list(na.rm = na.rm, na.min_count = na.min_count))$GetFieldByName("max")
 }
 
 collect_arrays_from_dots <- function(dots) {
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 30b2454ccfb..b8a5b89d931 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -176,7 +176,7 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
     using Options = arrow::compute::ScalarAggregateOptions;
     auto out = std::make_shared<Options>(Options::Defaults());
     out->min_count = cpp11::as_cpp<int>(options["na.min_count"]);
-    out->null_handling = cpp11::as_cpp<bool>(options["na.rm"]) ? Options::SKIPNA : Options::KEEPNA;
+    out->skip_nulls = cpp11::as_cpp<bool>(options["na.rm"]);
     return out;
   }
 
diff --git a/r/tests/testthat/test-compute-aggregate.R b/r/tests/testthat/test-compute-aggregate.R
index fce60ac389b..a558099cc45 100644
--- a/r/tests/testthat/test-compute-aggregate.R
+++ b/r/tests/testthat/test-compute-aggregate.R
@@ -209,8 +209,10 @@ test_that("Edge cases", {
   for (type in c(int32(), float64(), bool())) {
     expect_equal(as.vector(sum(a$cast(type), na.rm = TRUE)), sum(NA, na.rm = TRUE))
     expect_equal(as.vector(mean(a$cast(type), na.rm = TRUE)), mean(NA, na.rm = TRUE))
-    # expect_equal(as.vector(min(a$cast(type), na.rm = TRUE)), min(NA, na.rm = TRUE))
-    # expect_equal(as.vector(max(a$cast(type), na.rm = TRUE)), max(NA, na.rm = TRUE))
+  }
+  for (type in c(float64())) {
+    expect_equal(as.vector(min(a$cast(type), na.rm = TRUE)), min(NA, na.rm = TRUE))
+    expect_equal(as.vector(max(a$cast(type), na.rm = TRUE)), max(NA, na.rm = TRUE))
   }
 })
 

From e9aefdb88ac693594fca8be204597335a2cdf8f1 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Fri, 16 Apr 2021 04:07:26 +0200
Subject: [PATCH 10/23] Reverting c_glib changes.

---
 c_glib/arrow-glib/compute.cpp | 108 +++++++++++++++++-----------------
 c_glib/arrow-glib/compute.h   |  30 +++++-----
 c_glib/arrow-glib/compute.hpp |   8 +--
 c_glib/test/test-count.rb     |  10 ++--
 4 files changed, 78 insertions(+), 78 deletions(-)

diff --git a/c_glib/arrow-glib/compute.cpp b/c_glib/arrow-glib/compute.cpp
index 5237c9ab68f..275e406be79 100644
--- a/c_glib/arrow-glib/compute.cpp
+++ b/c_glib/arrow-glib/compute.cpp
@@ -130,7 +130,7 @@ G_BEGIN_DECLS
  * #GArrowCastOptions is a class to customize the `cast` function and
  * garrow_array_cast().
  *
- * #GArrowScalarAggregateOptions is a class to customize the `count` function and
+ * #GArrowCountOptions is a class to customize the `count` function and
  * garrow_array_count().
  *
  * #GArrowFilterOptions is a class to customize the `filter` function and
@@ -636,60 +636,60 @@ garrow_cast_options_new(void)
 }
 
 
-typedef struct GArrowScalarAggregateOptionsPrivate_ {
-  arrow::compute::ScalarAggregateOptions options;
-} GArrowScalarAggregateOptionsPrivate;
+typedef struct GArrowCountOptionsPrivate_ {
+  arrow::compute::CountOptions options;
+} GArrowCountOptionsPrivate;
 
 enum {
   PROP_MODE = 1,
 };
 
 static arrow::compute::FunctionOptions *
-garrow_scalar_aggregate_options_get_raw_function_options(GArrowFunctionOptions *options)
+garrow_count_options_get_raw_function_options(GArrowFunctionOptions *options)
 {
-  return garrow_scalar_aggregate_options_get_raw(GARROW_SCALAR_AGGREGATE_OPTIONS(options));
+  return garrow_count_options_get_raw(GARROW_COUNT_OPTIONS(options));
 }
 
 static void
-garrow_scalar_aggregate_options_function_options_interface_init(
+garrow_count_options_function_options_interface_init(
   GArrowFunctionOptionsInterface *iface)
 {
-  iface->get_raw = garrow_scalar_aggregate_options_get_raw_function_options;
+  iface->get_raw = garrow_count_options_get_raw_function_options;
 }
 
-G_DEFINE_TYPE_WITH_CODE(GArrowScalarAggregateOptions,
-                        garrow_scalar_aggregate_options,
+G_DEFINE_TYPE_WITH_CODE(GArrowCountOptions,
+                        garrow_count_options,
                         G_TYPE_OBJECT,
-                        G_ADD_PRIVATE(GArrowScalarAggregateOptions)
+                        G_ADD_PRIVATE(GArrowCountOptions)
                         G_IMPLEMENT_INTERFACE(
                           GARROW_TYPE_FUNCTION_OPTIONS,
-                          garrow_scalar_aggregate_options_function_options_interface_init))
+                          garrow_count_options_function_options_interface_init))
 
-#define GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object)        \
-  static_cast<GArrowScalarAggregateOptionsPrivate *>(             \
-    garrow_scalar_aggregate_options_get_instance_private(          \
-      GARROW_SCALAR_AGGREGATE_OPTIONS(object)))
+#define GARROW_COUNT_OPTIONS_GET_PRIVATE(object)        \
+  static_cast<GArrowCountOptionsPrivate *>(             \
+    garrow_count_options_get_instance_private(          \
+      GARROW_COUNT_OPTIONS(object)))
 
 static void
-garrow_scalar_aggregate_options_finalize(GObject *object)
+garrow_count_options_finalize(GObject *object)
 {
-  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
-  priv->options.~ScalarAggregateOptions();
-  G_OBJECT_CLASS(garrow_scalar_aggregate_options_parent_class)->finalize(object);
+  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
+  priv->options.~CountOptions();
+  G_OBJECT_CLASS(garrow_count_options_parent_class)->finalize(object);
 }
 
 static void
-garrow_scalar_aggregate_options_set_property(GObject *object,
+garrow_count_options_set_property(GObject *object,
                                   guint prop_id,
                                   const GValue *value,
                                   GParamSpec *pspec)
 {
-  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
+  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
   case PROP_MODE:
-    priv->options.null_handling =
-      static_cast<arrow::compute::ScalarAggregateOptions::Mode>(g_value_get_enum(value));
+    priv->options.count_mode =
+      static_cast<arrow::compute::CountOptions::Mode>(g_value_get_enum(value));
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -698,16 +698,16 @@ garrow_scalar_aggregate_options_set_property(GObject *object,
 }
 
 static void
-garrow_scalar_aggregate_options_get_property(GObject *object,
+garrow_count_options_get_property(GObject *object,
                                  guint prop_id,
                                  GValue *value,
                                  GParamSpec *pspec)
 {
-  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
+  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
   case PROP_MODE:
-    g_value_set_enum(value, priv->options.scalar_aggregate_mode);
+    g_value_set_enum(value, priv->options.count_mode);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -716,25 +716,25 @@ garrow_scalar_aggregate_options_get_property(GObject *object,
 }
 
 static void
-garrow_scalar_aggregate_options_init(GArrowScalarAggregateOptions *object)
+garrow_count_options_init(GArrowCountOptions *object)
 {
-  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
-  new(&priv->options) arrow::compute::ScalarAggregateOptions(
-    arrow::compute::ScalarAggregateOptions::SKIPNA);
+  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
+  new(&priv->options) arrow::compute::CountOptions(
+    arrow::compute::CountOptions::COUNT_NON_NULL);
 }
 
 static void
-garrow_scalar_aggregate_options_class_init(GArrowScalarAggregateOptionsClass *klass)
+garrow_count_options_class_init(GArrowCountOptionsClass *klass)
 {
   auto gobject_class = G_OBJECT_CLASS(klass);
 
-  gobject_class->finalize     = garrow_scalar_aggregate_options_finalize;
-  gobject_class->set_property = garrow_scalar_aggregate_options_set_property;
-  gobject_class->get_property = garrow_scalar_aggregate_options_get_property;
+  gobject_class->finalize     = garrow_count_options_finalize;
+  gobject_class->set_property = garrow_count_options_set_property;
+  gobject_class->get_property = garrow_count_options_get_property;
 
   GParamSpec *spec;
   /**
-   * GArrowScalarAaggregateptions:mode:
+   * GArrowCountOptions:mode:
    *
    * How to count values.
    *
@@ -750,17 +750,17 @@ garrow_scalar_aggregate_options_class_init(GArrowScalarAggregateOptionsClass *kl
 }
 
 /**
- * garrow_scalar_aggregate_options_new:
+ * garrow_count_options_new:
  *
- * Returns: A newly created #GArrowScalarAggregateOptions.
+ * Returns: A newly created #GArrowCountOptions.
  *
  * Since: 0.13.0
  */
-GArrowScalarAggregateOptions *
-garrow_scalar_aggregate_options_new(void)
+GArrowCountOptions *
+garrow_count_options_new(void)
 {
-  auto scalar_aggregate_options = g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS, NULL);
-  return GARROW_SCALAR_AGGREGATE_OPTIONS(scalar_aggregate_options);
+  auto count_options = g_object_new(GARROW_TYPE_COUNT_OPTIONS, NULL);
+  return GARROW_COUNT_OPTIONS(count_options);
 }
 
 
@@ -1682,7 +1682,7 @@ garrow_array_dictionary_encode(GArrowArray *array,
 /**
  * garrow_array_count:
  * @array: A #GArrowArray.
- * @options: (nullable): A #GArrowScalarAggregateOptions.
+ * @options: (nullable): A #GArrowCountOptions.
  * @error: (nullable): Return location for a #GError or %NULL.
  *
  * Returns: The number of target values on success. If an error is occurred,
@@ -1692,14 +1692,14 @@ garrow_array_dictionary_encode(GArrowArray *array,
  */
 gint64
 garrow_array_count(GArrowArray *array,
-                   GArrowScalarAggregateOptions *options,
+                   GArrowCountOptions *options,
                    GError **error)
 {
   auto arrow_array = garrow_array_get_raw(array);
   auto arrow_array_raw = arrow_array.get();
   arrow::Result<arrow::Datum> arrow_counted_datum;
   if (options) {
-    auto arrow_options = garrow_scalar_aggregate_options_get_raw(options);
+    auto arrow_options = garrow_count_options_get_raw(options);
     arrow_counted_datum =
       arrow::compute::Count(*arrow_array_raw, *arrow_options);
   } else {
@@ -3059,20 +3059,20 @@ garrow_cast_options_get_raw(GArrowCastOptions *cast_options)
   return &(priv->options);
 }
 
-GArrowScalarAggregateOptions *
-garrow_scalar_aggregate_options_new_raw(arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options)
+GArrowCountOptions *
+garrow_count_options_new_raw(arrow::compute::CountOptions *arrow_count_options)
 {
-  auto scalar_aggregate_options =
-    g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS,
-                 "mode", arrow_scalar_aggregate_options->count_mode,
+  auto count_options =
+    g_object_new(GARROW_TYPE_COUNT_OPTIONS,
+                 "mode", arrow_count_options->count_mode,
                  NULL);
-  return GARROW_SCALAR_AGGREGATE_OPTIONS(scalar_aggregate_options);
+  return GARROW_COUNT_OPTIONS(count_options);
 }
 
-arrow::compute::ScalarAggregateOptions *
-garrow_scalar_aggregate_options_get_raw(GArrowScalarAggregateOptions *scalar_aggregate_options)
+arrow::compute::CountOptions *
+garrow_count_options_get_raw(GArrowCountOptions *count_options)
 {
-  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(scalar_aggregate_options);
+  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(count_options);
   return &(priv->options);
 }
 
diff --git a/c_glib/arrow-glib/compute.h b/c_glib/arrow-glib/compute.h
index fdc6555409a..63ba6e0eae5 100644
--- a/c_glib/arrow-glib/compute.h
+++ b/c_glib/arrow-glib/compute.h
@@ -84,31 +84,31 @@ GArrowCastOptions *garrow_cast_options_new(void);
 
 
 /**
- * GArrowScalarAggregateMode:
- * @GARROW_SKIPNA: Count all non-null values.
- * @GARROW_KEEPNA: Count all null values.
+ * GArrowCountMode:
+ * @GARROW_COUNT_ALL: Count all non-null values.
+ * @GARROW_COUNT_NULL: Count all null values.
  *
- * They are corresponding to `arrow::compute::ScalarAggregateOptions::Mode` values.
+ * They are corresponding to `arrow::compute::CountOptions::Mode` values.
  */
 typedef enum {
-  GARROW_SKIPNA,
-  GARROW_KEEPNA,
-} GArrowScalarAggregateMode;
+  GARROW_COUNT_ALL,
+  GARROW_COUNT_NULL,
+} GArrowCountMode;
 
-#define GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS (garrow_scalar_aggregate_options_get_type())
-G_DECLARE_DERIVABLE_TYPE(GArrowScalarAggregateOptions,
-                         garrow_scalar_aggregate_options,
+#define GARROW_TYPE_COUNT_OPTIONS (garrow_count_options_get_type())
+G_DECLARE_DERIVABLE_TYPE(GArrowCountOptions,
+                         garrow_count_options,
                          GARROW,
-                         SCALAR_AGGREGATE_OPTIONS,
+                         COUNT_OPTIONS,
                          GObject)
-struct _GArrowScalarAggregateOptionsClass
+struct _GArrowCountOptionsClass
 {
   GObjectClass parent_class;
 };
 
 GARROW_AVAILABLE_IN_0_13
-GArrowScalarAggregateOptions *
-garrow_scalar_aggregate_options_new(void);
+GArrowCountOptions *
+garrow_count_options_new(void);
 
 
 /**
@@ -290,7 +290,7 @@ GArrowDictionaryArray *garrow_array_dictionary_encode(GArrowArray *array,
                                                       GError **error);
 GARROW_AVAILABLE_IN_0_13
 gint64 garrow_array_count(GArrowArray *array,
-                          GArrowScalarAggregateOptions *options,
+                          GArrowCountOptions *options,
                           GError **error);
 GARROW_AVAILABLE_IN_0_13
 GArrowStructArray *garrow_array_count_values(GArrowArray *array,
diff --git a/c_glib/arrow-glib/compute.hpp b/c_glib/arrow-glib/compute.hpp
index 0b7b9a2bd76..1bc6fefdd40 100644
--- a/c_glib/arrow-glib/compute.hpp
+++ b/c_glib/arrow-glib/compute.hpp
@@ -46,10 +46,10 @@ garrow_function_get_raw(GArrowFunction *function);
 GArrowCastOptions *garrow_cast_options_new_raw(arrow::compute::CastOptions *arrow_cast_options);
 arrow::compute::CastOptions *garrow_cast_options_get_raw(GArrowCastOptions *cast_options);
 
-GArrowScalarAggregateOptions *
-garrow_scalar_aggregate_options_new_raw(arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options);
-arrow::compute::ScalarAggregateOptions *
-garrow_scalar_aggregate_options_get_raw(GArrowScalarAggregateOptions *scalar_aggregate_options);
+GArrowCountOptions *
+garrow_count_options_new_raw(arrow::compute::CountOptions *arrow_count_options);
+arrow::compute::CountOptions *
+garrow_count_options_get_raw(GArrowCountOptions *count_options);
 
 arrow::compute::FilterOptions *
 garrow_filter_options_get_raw(GArrowFilterOptions *filter_options);
diff --git a/c_glib/test/test-count.rb b/c_glib/test/test-count.rb
index aba673292c9..36390f880aa 100644
--- a/c_glib/test/test-count.rb
+++ b/c_glib/test/test-count.rb
@@ -19,10 +19,10 @@ class TestCount < Test::Unit::TestCase
   include Helper::Buildable
   include Helper::Omittable
 
-  sub_test_case("ScalarAggregateOptions") do
+  sub_test_case("CountOptions") do
     def test_default_mode
-      assert_equal(Arrow::ScalarAggregateMode::KEEPNA,
-                   Arrow::ScalarAggregateOptions.new.mode)
+      assert_equal(Arrow::CountMode::ALL,
+                   Arrow::CountOptions.new.mode)
     end
   end
 
@@ -32,13 +32,13 @@ def test_default
     end
 
     def test_all
-      options = Arrow::ScalarAggregateOptions.new
+      options = Arrow::CountOptions.new
       options.mode = :all
       assert_equal(2, build_int32_array([1, nil, 3]).count(options))
     end
 
     def test_null
-      options = Arrow::ScalarAggregateOptions.new
+      options = Arrow::CountOptions.new
       options.mode = :null
       assert_equal(1, build_int32_array([1, nil, 3]).count(options))
     end

From b9986915c5f3ab82217e1ff8f6c8cef4fa1eacc5 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Fri, 16 Apr 2021 14:41:12 +0200
Subject: [PATCH 11/23] Changes to c_glib.

---
 c_glib/arrow-glib/compute.cpp | 118 +++++++++++++++++-----------------
 c_glib/arrow-glib/compute.h   |  28 +++-----
 c_glib/arrow-glib/compute.hpp |   8 +--
 c_glib/test/test-count.rb     |  19 +++---
 4 files changed, 79 insertions(+), 94 deletions(-)

diff --git a/c_glib/arrow-glib/compute.cpp b/c_glib/arrow-glib/compute.cpp
index 275e406be79..f1554033c16 100644
--- a/c_glib/arrow-glib/compute.cpp
+++ b/c_glib/arrow-glib/compute.cpp
@@ -130,7 +130,7 @@ G_BEGIN_DECLS
  * #GArrowCastOptions is a class to customize the `cast` function and
  * garrow_array_cast().
  *
- * #GArrowCountOptions is a class to customize the `count` function and
+ * #GArrowScalarAggregateOptions is a class to customize the `count` function and
  * garrow_array_count().
  *
  * #GArrowFilterOptions is a class to customize the `filter` function and
@@ -636,60 +636,59 @@ garrow_cast_options_new(void)
 }
 
 
-typedef struct GArrowCountOptionsPrivate_ {
-  arrow::compute::CountOptions options;
-} GArrowCountOptionsPrivate;
+typedef struct GArrowScalarAggregateOptionsPrivate_ {
+  arrow::compute::ScalarAggregateOptions options;
+} GArrowScalarAggregateOptionsPrivate;
 
 enum {
   PROP_MODE = 1,
 };
 
 static arrow::compute::FunctionOptions *
-garrow_count_options_get_raw_function_options(GArrowFunctionOptions *options)
+garrow_scalar_aggregate_options_get_raw_function_options(GArrowFunctionOptions *options)
 {
-  return garrow_count_options_get_raw(GARROW_COUNT_OPTIONS(options));
+  return garrow_scalar_aggregate_options_get_raw(GARROW_SCALAR_AGGREGATE_OPTIONS(options));
 }
 
 static void
-garrow_count_options_function_options_interface_init(
+garrow_scalar_aggregate_options_function_options_interface_init(
   GArrowFunctionOptionsInterface *iface)
 {
-  iface->get_raw = garrow_count_options_get_raw_function_options;
+  iface->get_raw = garrow_scalar_aggregate_options_get_raw_function_options;
 }
 
-G_DEFINE_TYPE_WITH_CODE(GArrowCountOptions,
-                        garrow_count_options,
+G_DEFINE_TYPE_WITH_CODE(GArrowScalarAggregateOptions,
+                        garrow_scalar_aggregate_options,
                         G_TYPE_OBJECT,
-                        G_ADD_PRIVATE(GArrowCountOptions)
+                        G_ADD_PRIVATE(GArrowScalarAggregateOptions)
                         G_IMPLEMENT_INTERFACE(
                           GARROW_TYPE_FUNCTION_OPTIONS,
-                          garrow_count_options_function_options_interface_init))
+                          garrow_scalar_aggregate_options_function_options_interface_init))
 
-#define GARROW_COUNT_OPTIONS_GET_PRIVATE(object)        \
-  static_cast<GArrowCountOptionsPrivate *>(             \
-    garrow_count_options_get_instance_private(          \
-      GARROW_COUNT_OPTIONS(object)))
+#define GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object)        \
+  static_cast<GArrowScalarAggregateOptionsPrivate *>(             \
+    garrow_scalar_aggregate_options_get_instance_private(          \
+      GARROW_SCALAR_AGGREGATE_OPTIONS(object)))
 
 static void
-garrow_count_options_finalize(GObject *object)
+garrow_scalar_aggregate_options_finalize(GObject *object)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
-  priv->options.~CountOptions();
-  G_OBJECT_CLASS(garrow_count_options_parent_class)->finalize(object);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
+  priv->options.~ScalarAggregateOptions();
+  G_OBJECT_CLASS(garrow_scalar_aggregate_options_parent_class)->finalize(object);
 }
 
 static void
-garrow_count_options_set_property(GObject *object,
+garrow_scalar_aggregate_options_set_property(GObject *object,
                                   guint prop_id,
                                   const GValue *value,
                                   GParamSpec *pspec)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
   case PROP_MODE:
-    priv->options.count_mode =
-      static_cast<arrow::compute::CountOptions::Mode>(g_value_get_enum(value));
+    priv->options.skip_nulls = g_value_get_boolean(value);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -698,16 +697,16 @@ garrow_count_options_set_property(GObject *object,
 }
 
 static void
-garrow_count_options_get_property(GObject *object,
+garrow_scalar_aggregate_options_get_property(GObject *object,
                                  guint prop_id,
                                  GValue *value,
                                  GParamSpec *pspec)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
   case PROP_MODE:
-    g_value_set_enum(value, priv->options.count_mode);
+    g_value_set_enum(value, priv->options.skip_nulls);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -716,51 +715,50 @@ garrow_count_options_get_property(GObject *object,
 }
 
 static void
-garrow_count_options_init(GArrowCountOptions *object)
+garrow_scalar_aggregate_options_init(GArrowScalarAggregateOptions *object)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(object);
-  new(&priv->options) arrow::compute::CountOptions(
-    arrow::compute::CountOptions::COUNT_NON_NULL);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
+  new(&priv->options) arrow::compute::ScalarAggregateOptions(
+    TRUE);
 }
 
 static void
-garrow_count_options_class_init(GArrowCountOptionsClass *klass)
+garrow_scalar_aggregate_options_class_init(GArrowScalarAggregateOptionsClass *klass)
 {
   auto gobject_class = G_OBJECT_CLASS(klass);
 
-  gobject_class->finalize     = garrow_count_options_finalize;
-  gobject_class->set_property = garrow_count_options_set_property;
-  gobject_class->get_property = garrow_count_options_get_property;
+  gobject_class->finalize     = garrow_scalar_aggregate_options_finalize;
+  gobject_class->set_property = garrow_scalar_aggregate_options_set_property;
+  gobject_class->get_property = garrow_scalar_aggregate_options_get_property;
 
   GParamSpec *spec;
   /**
-   * GArrowCountOptions:mode:
+   * GArrowScalarAggregateOptions:skip_nulls:
    *
    * How to count values.
    *
    * Since: 0.13.0
    */
-  spec = g_param_spec_enum("mode",
-                           "Mode",
-                           "How to count values",
-                           GARROW_TYPE_COUNT_MODE,
-                           GARROW_COUNT_ALL,
-                           static_cast<GParamFlags>(G_PARAM_READWRITE));
+  spec = g_param_spec_boolean("skip_nulls",
+                              "Skip nulls",
+                              "How to count values",
+                              TRUE,
+                              static_cast<GParamFlags>(G_PARAM_READWRITE));
   g_object_class_install_property(gobject_class, PROP_MODE, spec);
 }
 
 /**
- * garrow_count_options_new:
+ * garrow_scalar_aggregate_options_new:
  *
- * Returns: A newly created #GArrowCountOptions.
+ * Returns: A newly created #GArrowScalarAggregateOptions.
  *
  * Since: 0.13.0
  */
-GArrowCountOptions *
-garrow_count_options_new(void)
+GArrowScalarAggregateOptions *
+garrow_scalar_aggregate_options_new(void)
 {
-  auto count_options = g_object_new(GARROW_TYPE_COUNT_OPTIONS, NULL);
-  return GARROW_COUNT_OPTIONS(count_options);
+  auto scalar_aggregate_options = g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS, NULL);
+  return GARROW_SCALAR_AGGREGATE_OPTIONS(scalar_aggregate_options);
 }
 
 
@@ -1682,7 +1680,7 @@ garrow_array_dictionary_encode(GArrowArray *array,
 /**
  * garrow_array_count:
  * @array: A #GArrowArray.
- * @options: (nullable): A #GArrowCountOptions.
+ * @options: (nullable): A #GArrowScalarAggregateOptions.
  * @error: (nullable): Return location for a #GError or %NULL.
  *
  * Returns: The number of target values on success. If an error is occurred,
@@ -1692,14 +1690,14 @@ garrow_array_dictionary_encode(GArrowArray *array,
  */
 gint64
 garrow_array_count(GArrowArray *array,
-                   GArrowCountOptions *options,
+                   GArrowScalarAggregateOptions *options,
                    GError **error)
 {
   auto arrow_array = garrow_array_get_raw(array);
   auto arrow_array_raw = arrow_array.get();
   arrow::Result<arrow::Datum> arrow_counted_datum;
   if (options) {
-    auto arrow_options = garrow_count_options_get_raw(options);
+    auto arrow_options = garrow_scalar_aggregate_options_get_raw(options);
     arrow_counted_datum =
       arrow::compute::Count(*arrow_array_raw, *arrow_options);
   } else {
@@ -3059,20 +3057,20 @@ garrow_cast_options_get_raw(GArrowCastOptions *cast_options)
   return &(priv->options);
 }
 
-GArrowCountOptions *
-garrow_count_options_new_raw(arrow::compute::CountOptions *arrow_count_options)
+GArrowScalarAggregateOptions *
+garrow_scalar_aggregate_options_new_raw(arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options)
 {
-  auto count_options =
-    g_object_new(GARROW_TYPE_COUNT_OPTIONS,
-                 "mode", arrow_count_options->count_mode,
+  auto scalar_aggregate_options =
+    g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS,
+                 "skip_nulls", arrow_scalar_aggregate_options->skip_nulls,
                  NULL);
-  return GARROW_COUNT_OPTIONS(count_options);
+  return GARROW_SCALAR_AGGREGATE_OPTIONS(scalar_aggregate_options);
 }
 
-arrow::compute::CountOptions *
-garrow_count_options_get_raw(GArrowCountOptions *count_options)
+arrow::compute::ScalarAggregateOptions *
+garrow_scalar_aggregate_options_get_raw(GArrowScalarAggregateOptions *scalar_aggregate_options)
 {
-  auto priv = GARROW_COUNT_OPTIONS_GET_PRIVATE(count_options);
+  auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(scalar_aggregate_options);
   return &(priv->options);
 }
 
diff --git a/c_glib/arrow-glib/compute.h b/c_glib/arrow-glib/compute.h
index 63ba6e0eae5..5ce538adb4c 100644
--- a/c_glib/arrow-glib/compute.h
+++ b/c_glib/arrow-glib/compute.h
@@ -83,32 +83,20 @@ struct _GArrowCastOptionsClass
 GArrowCastOptions *garrow_cast_options_new(void);
 
 
-/**
- * GArrowCountMode:
- * @GARROW_COUNT_ALL: Count all non-null values.
- * @GARROW_COUNT_NULL: Count all null values.
- *
- * They are corresponding to `arrow::compute::CountOptions::Mode` values.
- */
-typedef enum {
-  GARROW_COUNT_ALL,
-  GARROW_COUNT_NULL,
-} GArrowCountMode;
-
-#define GARROW_TYPE_COUNT_OPTIONS (garrow_count_options_get_type())
-G_DECLARE_DERIVABLE_TYPE(GArrowCountOptions,
-                         garrow_count_options,
+#define GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS (garrow_scalar_aggregate_options_get_type())
+G_DECLARE_DERIVABLE_TYPE(GArrowScalarAggregateOptions,
+                         garrow_scalar_aggregate_options,
                          GARROW,
-                         COUNT_OPTIONS,
+                         SCALAR_AGGREGATE_OPTIONS,
                          GObject)
-struct _GArrowCountOptionsClass
+struct _GArrowScalarAggregateOptionsClass
 {
   GObjectClass parent_class;
 };
 
 GARROW_AVAILABLE_IN_0_13
-GArrowCountOptions *
-garrow_count_options_new(void);
+GArrowScalarAggregateOptions *
+garrow_scalar_aggregate_options_new(void);
 
 
 /**
@@ -290,7 +278,7 @@ GArrowDictionaryArray *garrow_array_dictionary_encode(GArrowArray *array,
                                                       GError **error);
 GARROW_AVAILABLE_IN_0_13
 gint64 garrow_array_count(GArrowArray *array,
-                          GArrowCountOptions *options,
+                          GArrowScalarAggregateOptions *options,
                           GError **error);
 GARROW_AVAILABLE_IN_0_13
 GArrowStructArray *garrow_array_count_values(GArrowArray *array,
diff --git a/c_glib/arrow-glib/compute.hpp b/c_glib/arrow-glib/compute.hpp
index 1bc6fefdd40..0b7b9a2bd76 100644
--- a/c_glib/arrow-glib/compute.hpp
+++ b/c_glib/arrow-glib/compute.hpp
@@ -46,10 +46,10 @@ garrow_function_get_raw(GArrowFunction *function);
 GArrowCastOptions *garrow_cast_options_new_raw(arrow::compute::CastOptions *arrow_cast_options);
 arrow::compute::CastOptions *garrow_cast_options_get_raw(GArrowCastOptions *cast_options);
 
-GArrowCountOptions *
-garrow_count_options_new_raw(arrow::compute::CountOptions *arrow_count_options);
-arrow::compute::CountOptions *
-garrow_count_options_get_raw(GArrowCountOptions *count_options);
+GArrowScalarAggregateOptions *
+garrow_scalar_aggregate_options_new_raw(arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options);
+arrow::compute::ScalarAggregateOptions *
+garrow_scalar_aggregate_options_get_raw(GArrowScalarAggregateOptions *scalar_aggregate_options);
 
 arrow::compute::FilterOptions *
 garrow_filter_options_get_raw(GArrowFilterOptions *filter_options);
diff --git a/c_glib/test/test-count.rb b/c_glib/test/test-count.rb
index 36390f880aa..e563600d804 100644
--- a/c_glib/test/test-count.rb
+++ b/c_glib/test/test-count.rb
@@ -19,28 +19,27 @@ class TestCount < Test::Unit::TestCase
   include Helper::Buildable
   include Helper::Omittable
 
-  sub_test_case("CountOptions") do
+  sub_test_case("ScalarAggregateOptions") do
     def test_default_mode
-      assert_equal(Arrow::CountMode::ALL,
-                   Arrow::CountOptions.new.mode)
+      assert_equal(false, Arrow::ScalarAggregateOptions.new.skip_nulls?)
     end
   end
 
-  sub_test_case("mode") do
+  sub_test_case("skip_nulls") do
     def test_default
       assert_equal(2, build_int32_array([1, nil, 3]).count)
     end
 
     def test_all
-      options = Arrow::CountOptions.new
-      options.mode = :all
-      assert_equal(2, build_int32_array([1, nil, 3]).count(options))
+      options = Arrow::ScalarAggregateOptions.new
+      options.skip_nulls = false
+      assert_equal(1, build_int32_array([1, nil, 3]).count(options))
     end
 
     def test_null
-      options = Arrow::CountOptions.new
-      options.mode = :null
-      assert_equal(1, build_int32_array([1, nil, 3]).count(options))
+      options = Arrow::ScalarAggregateOptions.new
+      options.skip_nulls = :null
+      assert_equal(2, build_int32_array([1, nil, 3]).count(options))
     end
   end
 end

From 33958cf9b962686fa3ab177cd211771d58740fa4 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sat, 17 Apr 2021 17:13:19 +0200
Subject: [PATCH 12/23] Fixing casting warnings.

---
 .../arrow/compute/kernels/aggregate_basic_internal.h  |  5 ++---
 cpp/src/arrow/compute/kernels/aggregate_test.cc       | 11 +++++------
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 41cb7fb4f11..2d5eb7bc785 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -275,9 +275,8 @@ struct MinMaxImpl : public ScalarAggregator {
 
     std::vector<std::shared_ptr<Scalar>> values;
     if (!state.has_values && options.skip_nulls && options.min_count == 0) {
-      // (Inf, -Inf)
-      values = {std::make_shared<ScalarType>(INFINITY),
-                std::make_shared<ScalarType>(-INFINITY)};
+      values = {std::make_shared<ScalarType>(state.min),
+                std::make_shared<ScalarType>(state.max)};
     } else if (!state.has_values || (state.has_nulls && !options.skip_nulls)) {
       // (null, null)
       values = {std::make_shared<ScalarType>(), std::make_shared<ScalarType>()};
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index bff3e4612bf..aa039cd6fc6 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -510,12 +510,11 @@ TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
 TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
 TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
   using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
-  using T = typename TypeParam::c_type;
 
-  auto expected_result_keepna = Datum(std::make_shared<ScalarType>(static_cast<T>(2)));
-  auto expected_result_skipna = Datum(std::make_shared<ScalarType>(static_cast<T>(3)));
+  auto expected_result_keepna = Datum(std::make_shared<ScalarType>(2));
+  auto expected_result_skipna = Datum(std::make_shared<ScalarType>(3));
   auto null_result = Datum(std::make_shared<ScalarType>());
-  auto zero_result = Datum(std::make_shared<ScalarType>(static_cast<T>(0)));
+  auto zero_result = Datum(std::make_shared<ScalarType>(0));
   const char* json = "[1, null, 2, 2, null, 7]";
 
   ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(true, 0));
@@ -678,8 +677,8 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
   this->AssertMinMaxIsNull(chunked_input3, options);
 
   options = ScalarAggregateOptions(true, 0);
-  this->AssertMinMaxIs("[]", INFINITY, -INFINITY, options);
-  this->AssertMinMaxIs("[null]", INFINITY, -INFINITY, options);
+  this->AssertMinMaxIs("[]", true, false, options);
+  this->AssertMinMaxIs("[null]", true, false, options);
 }
 
 TYPED_TEST_SUITE(TestIntegerMinMaxKernel, IntegralArrowTypes);

From f61c7325e942aeac810455ca0b0a8528d2eb4424 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Sun, 18 Apr 2021 05:51:24 +0900
Subject: [PATCH 13/23] [GLib] Adjust for CountOptions ->
 ScalarAggregateOptions change

---
 c_glib/arrow-glib/compute.cpp                | 91 +++++++++++++-------
 c_glib/arrow-glib/compute.h                  |  2 +-
 c_glib/arrow-glib/version.h.in               | 23 +++++
 c_glib/doc/arrow-glib/arrow-glib-docs.xml    |  4 +
 c_glib/test/test-count.rb                    | 14 +--
 c_glib/test/test-scalar-aggregate-options.rb | 32 +++++++
 6 files changed, 121 insertions(+), 45 deletions(-)
 create mode 100644 c_glib/test/test-scalar-aggregate-options.rb

diff --git a/c_glib/arrow-glib/compute.cpp b/c_glib/arrow-glib/compute.cpp
index f1554033c16..ebdb18f438d 100644
--- a/c_glib/arrow-glib/compute.cpp
+++ b/c_glib/arrow-glib/compute.cpp
@@ -130,8 +130,9 @@ G_BEGIN_DECLS
  * #GArrowCastOptions is a class to customize the `cast` function and
  * garrow_array_cast().
  *
- * #GArrowScalarAggregateOptions is a class to customize the `count` function and
- * garrow_array_count().
+ * #GArrowScalarAggregateOptions is a class to customize the scalar
+ * aggregate functions such as `count` function and convenient
+ * functions of them such as garrow_array_count().
  *
  * #GArrowFilterOptions is a class to customize the `filter` function and
  * garrow_array_filter() family.
@@ -641,13 +642,16 @@ typedef struct GArrowScalarAggregateOptionsPrivate_ {
 } GArrowScalarAggregateOptionsPrivate;
 
 enum {
-  PROP_MODE = 1,
+  PROP_SKIP_NULLS = 1,
+  PROP_MIN_COUNT,
 };
 
 static arrow::compute::FunctionOptions *
-garrow_scalar_aggregate_options_get_raw_function_options(GArrowFunctionOptions *options)
+garrow_scalar_aggregate_options_get_raw_function_options(
+  GArrowFunctionOptions *options)
 {
-  return garrow_scalar_aggregate_options_get_raw(GARROW_SCALAR_AGGREGATE_OPTIONS(options));
+  return garrow_scalar_aggregate_options_get_raw(
+    GARROW_SCALAR_AGGREGATE_OPTIONS(options));
 }
 
 static void
@@ -666,7 +670,7 @@ G_DEFINE_TYPE_WITH_CODE(GArrowScalarAggregateOptions,
                           garrow_scalar_aggregate_options_function_options_interface_init))
 
 #define GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object)        \
-  static_cast<GArrowScalarAggregateOptionsPrivate *>(             \
+  static_cast<GArrowScalarAggregateOptionsPrivate *>(              \
     garrow_scalar_aggregate_options_get_instance_private(          \
       GARROW_SCALAR_AGGREGATE_OPTIONS(object)))
 
@@ -680,16 +684,19 @@ garrow_scalar_aggregate_options_finalize(GObject *object)
 
 static void
 garrow_scalar_aggregate_options_set_property(GObject *object,
-                                  guint prop_id,
-                                  const GValue *value,
-                                  GParamSpec *pspec)
+                                             guint prop_id,
+                                             const GValue *value,
+                                             GParamSpec *pspec)
 {
   auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
-  case PROP_MODE:
+  case PROP_SKIP_NULLS:
     priv->options.skip_nulls = g_value_get_boolean(value);
     break;
+  case PROP_MIN_COUNT:
+    priv->options.skip_nulls = g_value_get_uint(value);
+    break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
     break;
@@ -698,15 +705,18 @@ garrow_scalar_aggregate_options_set_property(GObject *object,
 
 static void
 garrow_scalar_aggregate_options_get_property(GObject *object,
-                                 guint prop_id,
-                                 GValue *value,
-                                 GParamSpec *pspec)
+                                             guint prop_id,
+                                             GValue *value,
+                                             GParamSpec *pspec)
 {
   auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
-  case PROP_MODE:
-    g_value_set_enum(value, priv->options.skip_nulls);
+  case PROP_SKIP_NULLS:
+    g_value_set_boolean(value, priv->options.skip_nulls);
+    break;
+  case PROP_MIN_COUNT:
+    g_value_set_uint(value, priv->options.min_count);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -718,12 +728,12 @@ static void
 garrow_scalar_aggregate_options_init(GArrowScalarAggregateOptions *object)
 {
   auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(object);
-  new(&priv->options) arrow::compute::ScalarAggregateOptions(
-    TRUE);
+  new(&priv->options) arrow::compute::ScalarAggregateOptions();
 }
 
 static void
-garrow_scalar_aggregate_options_class_init(GArrowScalarAggregateOptionsClass *klass)
+garrow_scalar_aggregate_options_class_init(
+  GArrowScalarAggregateOptionsClass *klass)
 {
   auto gobject_class = G_OBJECT_CLASS(klass);
 
@@ -731,20 +741,38 @@ garrow_scalar_aggregate_options_class_init(GArrowScalarAggregateOptionsClass *kl
   gobject_class->set_property = garrow_scalar_aggregate_options_set_property;
   gobject_class->get_property = garrow_scalar_aggregate_options_get_property;
 
+  auto options = arrow::compute::ScalarAggregateOptions::Defaults();
+
   GParamSpec *spec;
   /**
-   * GArrowScalarAggregateOptions:skip_nulls:
+   * GArrowScalarAggregateOptions:skip-nulls:
    *
-   * How to count values.
+   * Whether NULLs are skipped or not.
    *
-   * Since: 0.13.0
+   * Since: 5.0.0
    */
-  spec = g_param_spec_boolean("skip_nulls",
-                              "Skip nulls",
-                              "How to count values",
-                              TRUE,
+  spec = g_param_spec_boolean("skip-nulls",
+                              "Skip NULLs",
+                              "Whether NULLs are skipped or not",
+                              options.skip_nulls,
                               static_cast<GParamFlags>(G_PARAM_READWRITE));
-  g_object_class_install_property(gobject_class, PROP_MODE, spec);
+  g_object_class_install_property(gobject_class, PROP_SKIP_NULLS, spec);
+
+  /**
+   * GArrowScalarAggregateOptions:min-count:
+   *
+   * The minimum required number of values.
+   *
+   * Since: 5.0.0
+   */
+  spec = g_param_spec_uint("min-count",
+                           "Min count",
+                           "The minimum required number of values",
+                           0,
+                           G_MAXUINT,
+                           options.min_count,
+                           static_cast<GParamFlags>(G_PARAM_READWRITE));
+  g_object_class_install_property(gobject_class, PROP_MIN_COUNT, spec);
 }
 
 /**
@@ -752,12 +780,13 @@ garrow_scalar_aggregate_options_class_init(GArrowScalarAggregateOptionsClass *kl
  *
  * Returns: A newly created #GArrowScalarAggregateOptions.
  *
- * Since: 0.13.0
+ * Since: 5.0.0
  */
 GArrowScalarAggregateOptions *
 garrow_scalar_aggregate_options_new(void)
 {
-  auto scalar_aggregate_options = g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS, NULL);
+  auto scalar_aggregate_options =
+    g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS, NULL);
   return GARROW_SCALAR_AGGREGATE_OPTIONS(scalar_aggregate_options);
 }
 
@@ -861,14 +890,14 @@ garrow_filter_options_class_init(GArrowFilterOptionsClass *klass)
 
   GParamSpec *spec;
   /**
-   * GArrowFilterOptions:null_selection_behavior:
+   * GArrowFilterOptions:null-selection-behavior:
    *
    * How to handle filtered values.
    *
    * Since: 0.17.0
    */
-  spec = g_param_spec_enum("null_selection_behavior",
-                           "Null selection behavior",
+  spec = g_param_spec_enum("null-selection-behavior",
+                           "NULL selection behavior",
                            "How to handle filtered values",
                            GARROW_TYPE_FILTER_NULL_SELECTION_BEHAVIOR,
                            static_cast<GArrowFilterNullSelectionBehavior>(
diff --git a/c_glib/arrow-glib/compute.h b/c_glib/arrow-glib/compute.h
index 5ce538adb4c..a9e57945ba5 100644
--- a/c_glib/arrow-glib/compute.h
+++ b/c_glib/arrow-glib/compute.h
@@ -94,7 +94,7 @@ struct _GArrowScalarAggregateOptionsClass
   GObjectClass parent_class;
 };
 
-GARROW_AVAILABLE_IN_0_13
+GARROW_AVAILABLE_IN_5_0
 GArrowScalarAggregateOptions *
 garrow_scalar_aggregate_options_new(void);
 
diff --git a/c_glib/arrow-glib/version.h.in b/c_glib/arrow-glib/version.h.in
index 5a74566fd4a..3dc2f702c5e 100644
--- a/c_glib/arrow-glib/version.h.in
+++ b/c_glib/arrow-glib/version.h.in
@@ -110,6 +110,15 @@
 #  define GARROW_UNAVAILABLE(major, minor) G_UNAVAILABLE(major, minor)
 #endif
 
+/**
+ * GARROW_VERSION_5_0:
+ *
+ * You can use this macro value for compile time API version check.
+ *
+ * Since: 5.0.0
+ */
+#define GARROW_VERSION_5_0 G_ENCODE_VERSION(5, 0)
+
 /**
  * GARROW_VERSION_4_0:
  *
@@ -256,6 +265,20 @@
 
 #define GARROW_AVAILABLE_IN_ALL
 
+#if GARROW_VERSION_MIN_REQUIRED >= GARROW_VERSION_5_0
+#  define GARROW_DEPRECATED_IN_5_0                GARROW_DEPRECATED
+#  define GARROW_DEPRECATED_IN_5_0_FOR(function)  GARROW_DEPRECATED_FOR(function)
+#else
+#  define GARROW_DEPRECATED_IN_5_0
+#  define GARROW_DEPRECATED_IN_5_0_FOR(function)
+#endif
+
+#if GARROW_VERSION_MAX_ALLOWED < GARROW_VERSION_5_0
+#  define GARROW_AVAILABLE_IN_5_0 GARROW_UNAVAILABLE(5, 0)
+#else
+#  define GARROW_AVAILABLE_IN_5_0
+#endif
+
 #if GARROW_VERSION_MIN_REQUIRED >= GARROW_VERSION_4_0
 #  define GARROW_DEPRECATED_IN_4_0                GARROW_DEPRECATED
 #  define GARROW_DEPRECATED_IN_4_0_FOR(function)  GARROW_DEPRECATED_FOR(function)
diff --git a/c_glib/doc/arrow-glib/arrow-glib-docs.xml b/c_glib/doc/arrow-glib/arrow-glib-docs.xml
index 9198b6a13a6..22ff7217d75 100644
--- a/c_glib/doc/arrow-glib/arrow-glib-docs.xml
+++ b/c_glib/doc/arrow-glib/arrow-glib-docs.xml
@@ -179,6 +179,10 @@
     <title>Index of deprecated API</title>
     <xi:include href="xml/api-index-deprecated.xml"><xi:fallback /></xi:include>
   </index>
+  <index id="api-index-5-0-0" role="5.0.0">
+    <title>Index of new symbols in 5.0.0</title>
+    <xi:include href="xml/api-index-4.0.0.xml"><xi:fallback /></xi:include>
+  </index>
   <index id="api-index-4-0-0" role="4.0.0">
     <title>Index of new symbols in 4.0.0</title>
     <xi:include href="xml/api-index-4.0.0.xml"><xi:fallback /></xi:include>
diff --git a/c_glib/test/test-count.rb b/c_glib/test/test-count.rb
index e563600d804..39b6f06c4e6 100644
--- a/c_glib/test/test-count.rb
+++ b/c_glib/test/test-count.rb
@@ -19,27 +19,15 @@ class TestCount < Test::Unit::TestCase
   include Helper::Buildable
   include Helper::Omittable
 
-  sub_test_case("ScalarAggregateOptions") do
-    def test_default_mode
-      assert_equal(false, Arrow::ScalarAggregateOptions.new.skip_nulls?)
-    end
-  end
-
   sub_test_case("skip_nulls") do
     def test_default
       assert_equal(2, build_int32_array([1, nil, 3]).count)
     end
 
-    def test_all
+    def test_false
       options = Arrow::ScalarAggregateOptions.new
       options.skip_nulls = false
       assert_equal(1, build_int32_array([1, nil, 3]).count(options))
     end
-
-    def test_null
-      options = Arrow::ScalarAggregateOptions.new
-      options.skip_nulls = :null
-      assert_equal(2, build_int32_array([1, nil, 3]).count(options))
-    end
   end
 end
diff --git a/c_glib/test/test-scalar-aggregate-options.rb b/c_glib/test/test-scalar-aggregate-options.rb
new file mode 100644
index 00000000000..4ec7c389215
--- /dev/null
+++ b/c_glib/test/test-scalar-aggregate-options.rb
@@ -0,0 +1,32 @@
+# 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.
+
+class TestScalarAggregateOptions < Test::Unit::TestCase
+  def setup
+    @options = Arrow::ScalarAggregateOptions.new
+  end
+
+  def test_default_skip_nulls?
+    assert do
+      @options.skip_nulls?
+    end
+  end
+
+  def test_default_min_count
+    assert_equal(1, @options.min_count)
+  end
+end

From 72e84aba5e3f9c21147ac6c4f571c683605ba700 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sun, 18 Apr 2021 00:22:29 +0200
Subject: [PATCH 14/23] R change.

---
 r/R/compute.R                             | 29 +++++++++++++----------
 r/tests/testthat/test-compute-aggregate.R |  2 --
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/r/R/compute.R b/r/R/compute.R
index addbbcd957f..03271bfc95d 100644
--- a/r/R/compute.R
+++ b/r/R/compute.R
@@ -96,32 +96,35 @@ list_compute_functions <- function(pattern = NULL, ...) {
 
 #' @export
 sum.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
-  a <- collect_arrays_from_dots(list(...))
-  if (!na.rm) {
-    na.min_count = length(a)
-  }
-  call_function("sum", a, options = list(na.rm = na.rm, na.min_count = na.min_count))
+  scalar_aggregate("sum", ..., na.rm = na.rm, na.min_count = na.min_count)
 }
 
 #' @export
 mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
-  a <- collect_arrays_from_dots(list(...))
-  if (!na.rm) {
-    na.min_count = length(a)
-  }
-  call_function("mean", a, options = list(na.rm = na.rm, na.min_count = na.min_count))
+  scalar_aggregate("mean", ..., na.rm = na.rm, na.min_count = na.min_count)
 }
 
 #' @export
 min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
-  a <- collect_arrays_from_dots(list(...))
-  call_function("min_max", a, options = list(na.rm = na.rm, na.min_count = na.min_count))$GetFieldByName("min")
+  scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("min")
 }
 
 #' @export
 max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+  scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("max")
+}
+
+scalar_aggregate <- function(FUN, ..., na.rm = FALSE, na.min_count = 0) {
   a <- collect_arrays_from_dots(list(...))
-  call_function("min_max", a, options = list(na.rm = na.rm, na.min_count = na.min_count))$GetFieldByName("max")
+  if (FUN %in% c("mean", "sum") && !na.rm) {
+    na.min_count = length(a)
+  }
+  if (FUN == "min_max" && na.rm && a$null_count == length(a)) {
+    # Arrow sum/mean returns with the output type equal to input. But here R expects +/-Inf for boolean
+    # and integer types which arrow will only return with float input.
+    a <- a$cast(float64())
+  }
+  call_function(FUN, a, options = list(na.rm = na.rm, na.min_count = na.min_count))
 }
 
 collect_arrays_from_dots <- function(dots) {
diff --git a/r/tests/testthat/test-compute-aggregate.R b/r/tests/testthat/test-compute-aggregate.R
index a558099cc45..1e9d21b8248 100644
--- a/r/tests/testthat/test-compute-aggregate.R
+++ b/r/tests/testthat/test-compute-aggregate.R
@@ -209,8 +209,6 @@ test_that("Edge cases", {
   for (type in c(int32(), float64(), bool())) {
     expect_equal(as.vector(sum(a$cast(type), na.rm = TRUE)), sum(NA, na.rm = TRUE))
     expect_equal(as.vector(mean(a$cast(type), na.rm = TRUE)), mean(NA, na.rm = TRUE))
-  }
-  for (type in c(float64())) {
     expect_equal(as.vector(min(a$cast(type), na.rm = TRUE)), min(NA, na.rm = TRUE))
     expect_equal(as.vector(max(a$cast(type), na.rm = TRUE)), max(NA, na.rm = TRUE))
   }

From a5aef8e9ea6e338c7a74b74e60edce75c93bcef3 Mon Sep 17 00:00:00 2001
From: Rok Mihevc <rok@mihevc.org>
Date: Mon, 19 Apr 2021 11:57:42 +0200
Subject: [PATCH 15/23] Update cpp/src/arrow/compute/kernels/aggregate_test.cc

Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 cpp/src/arrow/compute/kernels/aggregate_test.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index aa039cd6fc6..b3324b5d970 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -166,7 +166,7 @@ TEST(TestBooleanAggregation, Sum) {
   ValidateBooleanAgg<Sum>("[true, false, true, true, null]",
                           std::make_shared<UInt64Scalar>(3), options);
 
-  const ScalarAggregateOptions& options_min_count_zero = ScalarAggregateOptions(true, 0);
+  const ScalarAggregateOptions& options_min_count_zero = ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
   ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(0),
                           options_min_count_zero);
   ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(0),

From 16e3af63d5e69b198b524ff0867e6dc4353d312a Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Mon, 19 Apr 2021 13:47:00 +0200
Subject: [PATCH 16/23] Changing ScalarAggregateOptions.min_count default to 0.

---
 cpp/src/arrow/compute/api_aggregate.h         |   4 +-
 .../arrow/compute/kernels/aggregate_test.cc   | 196 +++++++++++-------
 .../compute/kernels/hash_aggregate_test.cc    |  13 +-
 3 files changed, 128 insertions(+), 85 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index 34f676e25e3..6df0dae9e7b 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -41,13 +41,13 @@ class ExecContext;
 ///
 /// By default, null values are ignored
 struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
-  explicit ScalarAggregateOptions(bool skip_nulls = true, uint32_t min_count = 1)
+  explicit ScalarAggregateOptions(bool skip_nulls = true, uint32_t min_count = 0)
       : skip_nulls(skip_nulls), min_count(min_count) {}
 
   static ScalarAggregateOptions Defaults() { return ScalarAggregateOptions{}; }
 
   bool skip_nulls = true;
-  uint32_t min_count = 1;
+  uint32_t min_count = 0;
 };
 
 /// \brief Control Mode kernel behavior
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index b3324b5d970..d7410ad642c 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -139,8 +139,9 @@ void ValidateSum(
 }
 
 template <typename ArrowType>
-void ValidateSum(const Array& array) {
-  ValidateSum<ArrowType>(array, NaiveSum<ArrowType>(array));
+void ValidateSum(const Array& array, const ScalarAggregateOptions& options =
+                                         ScalarAggregateOptions::Defaults()) {
+  ValidateSum<ArrowType>(array, NaiveSum<ArrowType>(array), options);
 }
 
 using UnaryOp = Result<Datum>(const Datum&, const ScalarAggregateOptions&, ExecContext*);
@@ -157,8 +158,8 @@ void ValidateBooleanAgg(const std::string& json,
 
 TEST(TestBooleanAggregation, Sum) {
   const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults();
-  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(), options);
-  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(), options);
+  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(0), options);
+  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(0), options);
   ValidateBooleanAgg<Sum>("[null, false]", std::make_shared<UInt64Scalar>(0), options);
   ValidateBooleanAgg<Sum>("[true]", std::make_shared<UInt64Scalar>(1), options);
   ValidateBooleanAgg<Sum>("[true, false, true]", std::make_shared<UInt64Scalar>(2),
@@ -166,25 +167,25 @@ TEST(TestBooleanAggregation, Sum) {
   ValidateBooleanAgg<Sum>("[true, false, true, true, null]",
                           std::make_shared<UInt64Scalar>(3), options);
 
-  const ScalarAggregateOptions& options_min_count_zero = ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
-  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(0),
-                          options_min_count_zero);
-  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(0),
+  const ScalarAggregateOptions& options_min_count_zero =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
+  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(), options_min_count_zero);
+  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(),
                           options_min_count_zero);
 
   const char* json = "[true, null, false, null]";
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
-                          ScalarAggregateOptions(true, 1));
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
-                          ScalarAggregateOptions(true, 2));
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/2));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
-                          ScalarAggregateOptions(true, 3));
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/3));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
-                          ScalarAggregateOptions(false, 1));
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(1),
-                          ScalarAggregateOptions(false, 2));
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/2));
   ValidateBooleanAgg<Sum>(json, std::make_shared<UInt64Scalar>(),
-                          ScalarAggregateOptions(false, 3));
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/3));
 }
 
 TEST(TestBooleanAggregation, Mean) {
@@ -201,7 +202,8 @@ TEST(TestBooleanAggregation, Mean) {
   ValidateBooleanAgg<Mean>("[true, null, false, false, false]",
                            std::make_shared<DoubleScalar>(0.25), options);
 
-  const ScalarAggregateOptions& options_min_count_zero = ScalarAggregateOptions(true, 0);
+  const ScalarAggregateOptions& options_min_count_zero =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
   ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(),
                            options_min_count_zero);
   ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(),
@@ -209,17 +211,17 @@ TEST(TestBooleanAggregation, Mean) {
 
   const char* json = "[true, null, false, null]";
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
-                           ScalarAggregateOptions(true, 1));
+                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
-                           ScalarAggregateOptions(true, 2));
+                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/2));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
-                           ScalarAggregateOptions(true, 3));
+                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/3));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.25),
-                           ScalarAggregateOptions(false, 1));
+                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.25),
-                           ScalarAggregateOptions(false, 2));
+                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/2));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
-                           ScalarAggregateOptions(false, 3));
+                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/3));
 }
 
 template <typename ArrowType>
@@ -230,17 +232,11 @@ TYPED_TEST(TestNumericSumKernel, SimpleSum) {
   using SumType = typename FindAccumulatorType<TypeParam>::Type;
   using ScalarType = typename TypeTraits<SumType>::ScalarType;
   using T = typename TypeParam::c_type;
-  const ScalarAggregateOptions& options = ScalarAggregateOptions(true, 0);
-
-  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))),
-                         options);
 
-  ValidateSum<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))),
-                         options);
+  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))));
 
-  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>()));
-
-  ValidateSum<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()));
+  ValidateSum<TypeParam>("[null]",
+                         Datum(std::make_shared<ScalarType>(static_cast<T>(0))));
 
   ValidateSum<TypeParam>("[0, 1, 2, 3, 4, 5]",
                          Datum(std::make_shared<ScalarType>(static_cast<T>(5 * 6 / 2))));
@@ -257,13 +253,19 @@ TYPED_TEST(TestNumericSumKernel, SimpleSum) {
   ValidateSum<TypeParam>(chunks,
                          Datum(std::make_shared<ScalarType>(static_cast<T>(5 * 6 / 2))));
 
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
+
+  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>()), options);
+
+  ValidateSum<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()), options);
+
   chunks = {};
-  ValidateSum<TypeParam>(chunks,
-                         Datum(std::make_shared<ScalarType>()));  // null
+  ValidateSum<TypeParam>(chunks, Datum(std::make_shared<ScalarType>()), options);  // null
 
   const T expected_result = static_cast<T>(14);
   ValidateSum<TypeParam>("[1, null, 3, null, 3, null, 7]",
-                         Datum(std::make_shared<ScalarType>(expected_result)));
+                         Datum(std::make_shared<ScalarType>(expected_result)), options);
 }
 
 TYPED_TEST_SUITE(TestNumericSumKernel, NumericArrowTypes);
@@ -278,16 +280,26 @@ TYPED_TEST(TestNumericSumKernel, ScalarAggregateOptions) {
   auto result = Datum(std::make_shared<ScalarType>(expected_result));
   const char* json = "[1, null, 3, null, 3, null, 7]";
 
-  ValidateSum<TypeParam>("[]", zero_result, ScalarAggregateOptions(true, 0));
-  ValidateSum<TypeParam>("[null]", zero_result, ScalarAggregateOptions(true, 0));
-  ValidateSum<TypeParam>(json, result, ScalarAggregateOptions(true, 3));
-  ValidateSum<TypeParam>(json, result, ScalarAggregateOptions(true, 4));
-  ValidateSum<TypeParam>(json, null_result, ScalarAggregateOptions(true, 5));
-  ValidateSum<TypeParam>("[]", null_result, ScalarAggregateOptions(true, 1));
-  ValidateSum<TypeParam>("[null]", null_result, ScalarAggregateOptions(true, 1));
-  ValidateSum<TypeParam>(json, result, ScalarAggregateOptions(false, 3));
-  ValidateSum<TypeParam>(json, result, ScalarAggregateOptions(false, 4));
-  ValidateSum<TypeParam>(json, null_result, ScalarAggregateOptions(false, 5));
+  ValidateSum<TypeParam>("[]", zero_result,
+                         ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0));
+  ValidateSum<TypeParam>("[null]", zero_result,
+                         ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0));
+  ValidateSum<TypeParam>(json, result,
+                         ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/3));
+  ValidateSum<TypeParam>(json, result,
+                         ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/4));
+  ValidateSum<TypeParam>(json, null_result,
+                         ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/5));
+  ValidateSum<TypeParam>("[]", null_result,
+                         ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
+  ValidateSum<TypeParam>("[null]", null_result,
+                         ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
+  ValidateSum<TypeParam>(json, result,
+                         ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/3));
+  ValidateSum<TypeParam>(json, result,
+                         ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/4));
+  ValidateSum<TypeParam>(json, null_result,
+                         ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/5));
 }
 
 template <typename ArrowType>
@@ -296,13 +308,15 @@ class TestRandomNumericSumKernel : public ::testing::Test {};
 TYPED_TEST_SUITE(TestRandomNumericSumKernel, NumericArrowTypes);
 TYPED_TEST(TestRandomNumericSumKernel, RandomArraySum) {
   auto rand = random::RandomArrayGenerator(0x5487655);
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
   // Test size up to 1<<13 (8192).
   for (size_t i = 3; i < 14; i += 2) {
     for (auto null_probability : {0.0, 0.001, 0.1, 0.5, 0.999, 1.0}) {
       for (auto length_adjust : {-2, -1, 0, 1, 2}) {
         int64_t length = (1UL << i) + length_adjust;
         auto array = rand.Numeric<TypeParam>(length, 0, 100, null_probability);
-        ValidateSum<TypeParam>(*array);
+        ValidateSum<TypeParam>(*array, options);
       }
     }
   }
@@ -322,12 +336,14 @@ TYPED_TEST(TestRandomNumericSumKernel, RandomArraySumOverflow) {
   int64_t length = 1024;
 
   auto rand = random::RandomArrayGenerator(0x5487655);
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
   for (auto null_probability : {0.0, 0.1, 0.5, 1.0}) {
     // Test overflow on the original type
     auto array = rand.Numeric<TypeParam>(length, max - 200, max - 100, null_probability);
-    ValidateSum<TypeParam>(*array);
+    ValidateSum<TypeParam>(*array, options);
     array = rand.Numeric<TypeParam>(length, min + 100, min + 200, null_probability);
-    ValidateSum<TypeParam>(*array);
+    ValidateSum<TypeParam>(*array, options);
   }
 }
 
@@ -391,8 +407,8 @@ static CountPair NaiveCount(const Array& array) {
 }
 
 void ValidateCount(const Array& input, CountPair expected) {
-  ScalarAggregateOptions all = ScalarAggregateOptions(true);
-  ScalarAggregateOptions nulls = ScalarAggregateOptions(false);
+  ScalarAggregateOptions all = ScalarAggregateOptions(/*skip_nulls=*/true);
+  ScalarAggregateOptions nulls = ScalarAggregateOptions(/*skip_nulls=*/false);
 
   ASSERT_OK_AND_ASSIGN(Datum result, Count(input, all));
   AssertDatumsEqual(result, Datum(expected.first));
@@ -485,7 +501,8 @@ TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
 TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
   using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
 
-  const ScalarAggregateOptions& options = ScalarAggregateOptions(true, 0);
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
 
   ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>()), options);
 
@@ -517,23 +534,39 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
   auto zero_result = Datum(std::make_shared<ScalarType>(0));
   const char* json = "[1, null, 2, 2, null, 7]";
 
-  ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(true, 0));
-  ValidateMean<TypeParam>("[null]", null_result, ScalarAggregateOptions(true, 0));
-  ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(true, 1));
-  ValidateMean<TypeParam>("[null]", null_result, ScalarAggregateOptions(true, 1));
-  ValidateMean<TypeParam>(json, expected_result_skipna, ScalarAggregateOptions(true, 0));
-  ValidateMean<TypeParam>(json, expected_result_skipna, ScalarAggregateOptions(true, 3));
-  ValidateMean<TypeParam>(json, expected_result_skipna, ScalarAggregateOptions(true, 4));
-  ValidateMean<TypeParam>(json, null_result, ScalarAggregateOptions(true, 5));
-
-  ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(false, 0));
-  ValidateMean<TypeParam>("[null]", null_result, ScalarAggregateOptions(false, 0));
-  ValidateMean<TypeParam>("[]", null_result, ScalarAggregateOptions(false, 1));
-  ValidateMean<TypeParam>("[null]", null_result, ScalarAggregateOptions(false, 1));
-  ValidateMean<TypeParam>(json, expected_result_keepna, ScalarAggregateOptions(false, 0));
-  ValidateMean<TypeParam>(json, expected_result_keepna, ScalarAggregateOptions(false, 3));
-  ValidateMean<TypeParam>(json, expected_result_keepna, ScalarAggregateOptions(false, 4));
-  ValidateMean<TypeParam>(json, null_result, ScalarAggregateOptions(false, 15));
+  ValidateMean<TypeParam>("[]", null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0));
+  ValidateMean<TypeParam>("[null]", null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0));
+  ValidateMean<TypeParam>("[]", null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
+  ValidateMean<TypeParam>("[null]", null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
+  ValidateMean<TypeParam>(json, expected_result_skipna,
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0));
+  ValidateMean<TypeParam>(json, expected_result_skipna,
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/3));
+  ValidateMean<TypeParam>(json, expected_result_skipna,
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/4));
+  ValidateMean<TypeParam>(json, null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/5));
+
+  ValidateMean<TypeParam>("[]", null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0));
+  ValidateMean<TypeParam>("[null]", null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0));
+  ValidateMean<TypeParam>("[]", null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1));
+  ValidateMean<TypeParam>("[null]", null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1));
+  ValidateMean<TypeParam>(json, expected_result_keepna,
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0));
+  ValidateMean<TypeParam>(json, expected_result_keepna,
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/3));
+  ValidateMean<TypeParam>(json, expected_result_keepna,
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/4));
+  ValidateMean<TypeParam>(json, null_result,
+                          ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/15));
 }
 
 template <typename ArrowType>
@@ -651,6 +684,7 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
   std::vector<std::string> chunked_input3 = {"[true, null]", "[null, false]"};
 
   // SKIP nulls by default
+  options = ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
   this->AssertMinMaxIsNull("[]", options);
   this->AssertMinMaxIsNull("[null, null, null]", options);
   this->AssertMinMaxIs("[false, false, false]", false, false, options);
@@ -663,7 +697,7 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
   this->AssertMinMaxIs(chunked_input2, false, false, options);
   this->AssertMinMaxIs(chunked_input3, false, true, options);
 
-  options = ScalarAggregateOptions(false);
+  options = ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1);
   this->AssertMinMaxIsNull("[]", options);
   this->AssertMinMaxIsNull("[null, null, null]", options);
   this->AssertMinMaxIsNull("[false, null, false]", options);
@@ -676,28 +710,32 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
   this->AssertMinMaxIs(chunked_input2, false, false, options);
   this->AssertMinMaxIsNull(chunked_input3, options);
 
-  options = ScalarAggregateOptions(true, 0);
+  options = ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
   this->AssertMinMaxIs("[]", true, false, options);
   this->AssertMinMaxIs("[null]", true, false, options);
 }
 
 TYPED_TEST_SUITE(TestIntegerMinMaxKernel, IntegralArrowTypes);
 TYPED_TEST(TestIntegerMinMaxKernel, Basics) {
+  using T = typename TypeParam::c_type;
+  T min = std::numeric_limits<T>::max();
+  T max = std::numeric_limits<T>::min();
+
   ScalarAggregateOptions options;
   std::vector<std::string> chunked_input1 = {"[5, 1, 2, 3, 4]", "[9, 1, null, 3, 4]"};
   std::vector<std::string> chunked_input2 = {"[5, null, 2, 3, 4]", "[9, 1, 2, 3, 4]"};
   std::vector<std::string> chunked_input3 = {"[5, 1, 2, 3, null]", "[9, 1, null, 3, 4]"};
 
-  // SKIP nulls by default
-  this->AssertMinMaxIsNull("[]", options);
-  this->AssertMinMaxIsNull("[null, null, null]", options);
+  // Default behaviour
+  this->AssertMinMaxIs("[]", min, max, options);
+  this->AssertMinMaxIs("[null, null, null]", min, max, options);
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   this->AssertMinMaxIs("[5, null, 2, 3, 4]", 2, 5, options);
   this->AssertMinMaxIs(chunked_input1, 1, 9, options);
   this->AssertMinMaxIs(chunked_input2, 1, 9, options);
   this->AssertMinMaxIs(chunked_input3, 1, 9, options);
 
-  options = ScalarAggregateOptions(false);
+  options = ScalarAggregateOptions(/*skip_nulls=*/false);
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   // output null
   this->AssertMinMaxIsNull("[5, null, 2, 3, 4]", options);
@@ -724,7 +762,7 @@ TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
   this->AssertMinMaxIs(chunked_input2, 1, 9, options);
   this->AssertMinMaxIs(chunked_input3, 1, 9, options);
 
-  options = ScalarAggregateOptions(false);
+  options = ScalarAggregateOptions(/*skip_nulls=*/false);
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   this->AssertMinMaxIs("[5, -Inf, 2, 3, 4]", -INFINITY, 5, options);
   // output null
@@ -736,11 +774,11 @@ TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
   this->AssertMinMaxIsNull(chunked_input2, options);
   this->AssertMinMaxIsNull(chunked_input3, options);
 
-  options = ScalarAggregateOptions(true, 0);
+  options = ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
   this->AssertMinMaxIs("[]", INFINITY, -INFINITY, options);
   this->AssertMinMaxIs("[null]", INFINITY, -INFINITY, options);
 
-  options = ScalarAggregateOptions(false, 1);
+  options = ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1);
   this->AssertMinMaxIsNull("[]", options);
   this->AssertMinMaxIsNull("[null]", options);
 }
@@ -845,11 +883,11 @@ static enable_if_floating_point<ArrowType, MinMaxResult<ArrowType>> NaiveMinMax(
 }
 
 template <typename ArrowType>
-void ValidateMinMax(const Array& array) {
+void ValidateMinMax(const Array& array, const ScalarAggregateOptions& options) {
   using Traits = TypeTraits<ArrowType>;
   using ScalarType = typename Traits::ScalarType;
 
-  ASSERT_OK_AND_ASSIGN(Datum out, MinMax(array));
+  ASSERT_OK_AND_ASSIGN(Datum out, MinMax(array, options));
   const StructScalar& value = out.scalar_as<StructScalar>();
 
   auto expected = NaiveMinMax<ArrowType>(array);
@@ -873,6 +911,8 @@ class TestRandomNumericMinMaxKernel : public ::testing::Test {};
 TYPED_TEST_SUITE(TestRandomNumericMinMaxKernel, NumericArrowTypes);
 TYPED_TEST(TestRandomNumericMinMaxKernel, RandomArrayMinMax) {
   auto rand = random::RandomArrayGenerator(0x8afc055);
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
   // Test size up to 1<<11 (2048).
   for (size_t i = 3; i < 12; i += 2) {
     for (auto null_probability : {0.0, 0.01, 0.1, 0.5, 0.99, 1.0}) {
@@ -880,7 +920,7 @@ TYPED_TEST(TestRandomNumericMinMaxKernel, RandomArrayMinMax) {
       auto array = rand.Numeric<TypeParam>(base_length, 0, 100, null_probability);
       for (auto length_adjust : {-2, -1, 0, 1, 2}) {
         int64_t length = (1UL << i) + length_adjust;
-        ValidateMinMax<TypeParam>(*array->Slice(0, length));
+        ValidateMinMax<TypeParam>(*array->Slice(0, length), options);
       }
     }
   }
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
index aeeab84f335..25d1b7f6ef9 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
@@ -659,15 +659,16 @@ TEST(GroupBy, ConcreteCaseWithValidateGroupBy) {
     [null,  "gama"]
   ])");
 
-  ScalarAggregateOptions keepna{false};
-  ScalarAggregateOptions skipna{true};
+  ScalarAggregateOptions keepna{false, 1};
+  ScalarAggregateOptions skipna{true, 1};
+  ScalarAggregateOptions other{true, 1};
 
   using internal::Aggregate;
   for (auto agg : {
-           Aggregate{"hash_sum", nullptr},
+           Aggregate{"hash_sum", &other},
            Aggregate{"hash_count", &skipna},
            Aggregate{"hash_count", &keepna},
-           Aggregate{"hash_min_max", nullptr},
+           Aggregate{"hash_min_max", &other},
            Aggregate{"hash_min_max", &skipna},
        }) {
     SCOPED_TRACE(agg.function);
@@ -700,6 +701,8 @@ TEST(GroupBy, CountNull) {
 }
 
 TEST(GroupBy, RandomArraySum) {
+  ScalarAggregateOptions skipna{true, 1};
+
   for (int64_t length : {1 << 10, 1 << 12, 1 << 15}) {
     for (auto null_probability : {0.0, 0.01, 0.5, 1.0}) {
       auto batch = random::GenerateBatch(
@@ -713,7 +716,7 @@ TEST(GroupBy, RandomArraySum) {
 
       ValidateGroupBy(
           {
-              {"hash_sum", nullptr},
+              {"hash_sum", &skipna},
           },
           {batch->GetColumnByName("argument")}, {batch->GetColumnByName("key")});
     }

From c47a58f0db49f47f581d4bf882750944f31f9d45 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Mon, 19 Apr 2021 20:23:45 +0200
Subject: [PATCH 17/23] Implementing review feedback.

---
 c_glib/test/test-scalar-aggregate-options.rb  |  2 +-
 .../arrow/compute/kernels/aggregate_basic.cc  | 24 +++++---
 .../kernels/aggregate_basic_internal.h        |  5 +-
 .../arrow/compute/kernels/aggregate_test.cc   | 58 ++++++++++++-------
 python/pyarrow/_compute.pyx                   |  2 +-
 python/pyarrow/tests/test_compute.py          |  4 +-
 6 files changed, 61 insertions(+), 34 deletions(-)

diff --git a/c_glib/test/test-scalar-aggregate-options.rb b/c_glib/test/test-scalar-aggregate-options.rb
index 4ec7c389215..480e255164c 100644
--- a/c_glib/test/test-scalar-aggregate-options.rb
+++ b/c_glib/test/test-scalar-aggregate-options.rb
@@ -27,6 +27,6 @@ def test_default_skip_nulls?
   end
 
   def test_default_min_count
-    assert_equal(1, @options.min_count)
+    assert_equal(0, @options.min_count)
   end
 end
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index feb10375d49..446c1b9fc62 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -258,13 +258,23 @@ const FunctionDoc count_doc{"Count the number of null / non-null values",
                             {"array"},
                             "ScalarAggregateOptions"};
 
-const FunctionDoc sum_doc{
-    "Sum values of a numeric array", ("Null values are ignored."), {"array"}};
-
-const FunctionDoc mean_doc{"Compute the mean of a numeric array",
-                           ("Null values are ignored. The result is always computed\n"
-                            "as a double, regardless of the input types"),
-                           {"array"}};
+const FunctionDoc sum_doc{"Sum values of a numeric array",
+                          ("Null values are ignored. Minimum count of non-NA\n"
+                           "values can be set and NAN is returned if too "
+                           "few are present.\n"
+                           "This can be changed through ScalarAggregateOptions."),
+                          {"array"},
+                          "ScalarAggregateOptions"};
+
+const FunctionDoc mean_doc{
+    "Compute the mean of a numeric array",
+    ("Null values are ignored by default. Minimum count of non-NA\n"
+     "values can be set and NAN is returned if too few are \n"
+     "present. The result is always computed as a double, \n"
+     "regardless of the input types.\n"
+     "This can be changed through ScalarAggregateOptions."),
+    {"array"},
+    "ScalarAggregateOptions"};
 
 const FunctionDoc min_max_doc{"Compute the minimum and maximum values of a numeric array",
                               ("Null values are ignored by default.\n"
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 2d5eb7bc785..fad6e817149 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -101,9 +101,8 @@ struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
     //    const ScalarAggregateOptions& options = checked_cast<const ScalarAggregateState&>(*ctx->state()).options;
     const auto& state = checked_cast<const MeanImpl&>(*ctx->state());
 
-    if (this->count == 0 || this->count < options.min_count) {
-      out->value = std::make_shared<DoubleScalar>(0);
-    } else if (this->count < options.min_count) {
+  void Finalize(KernelContext*, Datum* out) override {
+    if (this->count < options.min_count) {
       out->value = std::make_shared<DoubleScalar>();
     } else if (options.skip_nulls) {
       const double mean = static_cast<double>(this->sum) / this->count;
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index d7410ad642c..91db10fb2e1 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -151,9 +151,13 @@ void ValidateBooleanAgg(const std::string& json,
                         const std::shared_ptr<ScalarType>& expected,
                         const ScalarAggregateOptions& options) {
   auto array = ArrayFromJSON(boolean(), json);
-  auto exp = Datum(expected);
   ASSERT_OK_AND_ASSIGN(Datum result, Op(array, options, nullptr));
-  ASSERT_TRUE(result.Equals(exp));
+
+  const auto& exp = Datum(expected);
+  const auto& res = checked_pointer_cast<ScalarType>(result.scalar());
+  if (!(std::isnan((double)res->value) && std::isnan((double)expected->value))) {
+    ASSERT_TRUE(result.Equals(exp));
+  }
 }
 
 TEST(TestBooleanAggregation, Sum) {
@@ -190,8 +194,8 @@ TEST(TestBooleanAggregation, Sum) {
 
 TEST(TestBooleanAggregation, Mean) {
   const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults();
-  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(), options);
-  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(), options);
+  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(NAN), options);
+  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(NAN), options);
   ValidateBooleanAgg<Mean>("[null, false]", std::make_shared<DoubleScalar>(0), options);
   ValidateBooleanAgg<Mean>("[true]", std::make_shared<DoubleScalar>(1), options);
   ValidateBooleanAgg<Mean>("[true, false, true, false]",
@@ -204,9 +208,9 @@ TEST(TestBooleanAggregation, Mean) {
 
   const ScalarAggregateOptions& options_min_count_zero =
       ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
-  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(),
+  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(NAN),
                            options_min_count_zero);
-  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(),
+  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(NAN),
                            options_min_count_zero);
 
   const char* json = "[true, null, false, null]";
@@ -477,7 +481,12 @@ void ValidateMean(const Array& input, Datum expected,
   using OutputType = typename FindAccumulatorType<DoubleType>::Type;
 
   ASSERT_OK_AND_ASSIGN(Datum result, Mean(input, options, nullptr));
-  DatumEqual<OutputType>::EnsureEqual(result, expected);
+  using ScalarType = typename TypeTraits<OutputType>::ScalarType;
+  const auto& res = checked_pointer_cast<ScalarType>(result.scalar());
+  const auto& exp = checked_pointer_cast<ScalarType>(expected.scalar());
+  if (!(std::isnan(res->value) && std::isnan(exp->value))) {
+    DatumEqual<OutputType>::EnsureEqual(result, expected);
+  }
 }
 
 template <typename ArrowType>
@@ -489,9 +498,9 @@ void ValidateMean(
 }
 
 template <typename ArrowType>
-void ValidateMean(const Array& array) {
-  ValidateMean<ArrowType>(array, NaiveMean<ArrowType>(array),
-                          ScalarAggregateOptions::Defaults());
+void ValidateMean(const Array& array, const ScalarAggregateOptions& options =
+                                          ScalarAggregateOptions::Defaults()) {
+  ValidateMean<ArrowType>(array, NaiveMean<ArrowType>(array), options);
 }
 
 template <typename ArrowType>
@@ -501,16 +510,20 @@ TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
 TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
   using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
 
+  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>(NAN)));
+
+  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(NAN)));
+
   const ScalarAggregateOptions& options =
-      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
 
   ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>()), options);
 
   ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()), options);
 
-  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>()));
+  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>(NAN)));
 
-  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()));
+  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(NAN)));
 
   ValidateMean<TypeParam>("[1, null, 1]", Datum(std::make_shared<ScalarType>(1.0)));
 
@@ -531,12 +544,13 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
   auto expected_result_keepna = Datum(std::make_shared<ScalarType>(2));
   auto expected_result_skipna = Datum(std::make_shared<ScalarType>(3));
   auto null_result = Datum(std::make_shared<ScalarType>());
+  auto nan_result = Datum(std::make_shared<ScalarType>(NAN));
   auto zero_result = Datum(std::make_shared<ScalarType>(0));
   const char* json = "[1, null, 2, 2, null, 7]";
 
-  ValidateMean<TypeParam>("[]", null_result,
+  ValidateMean<TypeParam>("[]", nan_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0));
-  ValidateMean<TypeParam>("[null]", null_result,
+  ValidateMean<TypeParam>("[null]", nan_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0));
   ValidateMean<TypeParam>("[]", null_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
@@ -551,9 +565,9 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
   ValidateMean<TypeParam>(json, null_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/5));
 
-  ValidateMean<TypeParam>("[]", null_result,
+  ValidateMean<TypeParam>("[]", nan_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0));
-  ValidateMean<TypeParam>("[null]", null_result,
+  ValidateMean<TypeParam>("[null]", zero_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0));
   ValidateMean<TypeParam>("[]", null_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1));
@@ -575,13 +589,15 @@ class TestRandomNumericMeanKernel : public ::testing::Test {};
 TYPED_TEST_SUITE(TestRandomNumericMeanKernel, NumericArrowTypes);
 TYPED_TEST(TestRandomNumericMeanKernel, RandomArrayMean) {
   auto rand = random::RandomArrayGenerator(0x8afc055);
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
   // Test size up to 1<<13 (8192).
   for (size_t i = 3; i < 14; i += 2) {
     for (auto null_probability : {0.0, 0.001, 0.1, 0.5, 0.999, 1.0}) {
       for (auto length_adjust : {-2, -1, 0, 1, 2}) {
         int64_t length = (1UL << i) + length_adjust;
         auto array = rand.Numeric<TypeParam>(length, 0, 100, null_probability);
-        ValidateMean<TypeParam>(*array);
+        ValidateMean<TypeParam>(*array, options);
       }
     }
   }
@@ -601,12 +617,14 @@ TYPED_TEST(TestRandomNumericMeanKernel, RandomArrayMeanOverflow) {
   int64_t length = 1024;
 
   auto rand = random::RandomArrayGenerator(0x8afc055);
+  const ScalarAggregateOptions& options =
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
   for (auto null_probability : {0.0, 0.1, 0.5, 1.0}) {
     // Test overflow on the original type
     auto array = rand.Numeric<TypeParam>(length, max - 200, max - 100, null_probability);
-    ValidateMean<TypeParam>(*array);
+    ValidateMean<TypeParam>(*array, options);
     array = rand.Numeric<TypeParam>(length, min + 100, min + 200, null_probability);
-    ValidateMean<TypeParam>(*array);
+    ValidateMean<TypeParam>(*array, options);
   }
 }
 
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index aea72c457e0..33335a05dbf 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -837,7 +837,7 @@ cdef class _ScalarAggregateOptions(FunctionOptions):
 
 
 class ScalarAggregateOptions(_ScalarAggregateOptions):
-    def __init__(self, skip_nulls=True, min_count=1):
+    def __init__(self, skip_nulls=True, min_count=0):
         self._set_options(skip_nulls, min_count)
 
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 3f09f2b17d3..09ff405dc56 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -207,7 +207,7 @@ def test_sum_array(arrow_type):
     assert pc.sum(arr).as_py() == 10
 
     arr = pa.array([], type=arrow_type)
-    assert arr.sum().as_py() is None  # noqa: E711
+    assert arr.sum().as_py() == 0
 
 
 @pytest.mark.parametrize('arrow_type', numerical_arrow_types)
@@ -229,7 +229,7 @@ def test_sum_chunked_array(arrow_type):
 
     arr = pa.chunked_array((), type=arrow_type)
     assert arr.num_chunks == 0
-    assert pc.sum(arr).as_py() is None  # noqa: E711
+    assert pc.sum(arr).as_py() == 0
 
 
 def test_mode_array():

From e6b217fcea81c3f4b560812d74ec7280df171260 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Fri, 23 Apr 2021 00:46:52 +0200
Subject: [PATCH 18/23] Fixing doxygen issue.

---
 cpp/src/arrow/compute/api_aggregate.h                    | 3 +++
 cpp/src/arrow/compute/kernels/aggregate_basic_internal.h | 5 -----
 cpp/src/arrow/compute/kernels/hash_aggregate.cc          | 2 +-
 cpp/src/arrow/compute/kernels/hash_aggregate_test.cc     | 7 +++----
 4 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index 6df0dae9e7b..225731faa24 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -37,6 +37,9 @@ class ExecContext;
 // ----------------------------------------------------------------------
 // Aggregate functions
 
+/// \addtogroup compute-concrete-options
+/// @{
+
 /// \brief Control general scalar aggregate kernel behavior
 ///
 /// By default, null values are ignored
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index fad6e817149..b086b62e9b2 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -80,7 +80,6 @@ struct SumImpl : public ScalarAggregator {
   }
 
   Status Finalize(KernelContext*, Datum* out) override {
-    const auto& state = checked_cast<const SumImpl&>(*ctx->state());
     if (this->count < options.min_count) {
       out->value = std::make_shared<OutputType>();
     } else {
@@ -98,10 +97,6 @@ struct SumImpl : public ScalarAggregator {
 template <typename ArrowType, SimdLevel::type SimdLevel>
 struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
   Status Finalize(KernelContext*, Datum* out) override {
-    //    const ScalarAggregateOptions& options = checked_cast<const ScalarAggregateState&>(*ctx->state()).options;
-    const auto& state = checked_cast<const MeanImpl&>(*ctx->state());
-
-  void Finalize(KernelContext*, Datum* out) override {
     if (this->count < options.min_count) {
       out->value = std::make_shared<DoubleScalar>();
     } else if (options.skip_nulls) {
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index df2a387219b..245bae890c9 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -483,7 +483,7 @@ struct GroupedCountImpl : public GroupedAggregator {
     const auto& input = batch[0].array();
 
     if (!options_.skip_nulls) {
-      if (input->GetNullCount() >= options_.min_count) {
+      if (input->GetNullCount() != 0) {
         for (int64_t i = 0, input_i = input->offset; i < input->length; ++i, ++input_i) {
           auto g = group_ids[i];
           raw_counts[g] += !BitUtil::GetBit(input->buffers[0]->data(), input_i);
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
index 25d1b7f6ef9..61a759a86a8 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
@@ -686,13 +686,12 @@ TEST(GroupBy, CountNull) {
     [3.0, "gama"]
   ])");
 
-  CountOptions count_non_null{CountOptions::COUNT_NON_NULL},
-      count_null{CountOptions::COUNT_NULL};
+  ScalarAggregateOptions keepna{false}, skipna{true};
 
   using internal::Aggregate;
   for (auto agg : {
-           Aggregate{"hash_count", &count_non_null},
-           Aggregate{"hash_count", &count_null},
+           Aggregate{"hash_count", &keepna},
+           Aggregate{"hash_count", &skipna},
        }) {
     SCOPED_TRACE(agg.function);
     ValidateGroupBy({agg}, {batch->GetColumnByName("argument")},

From 1e703ff266aabbca6c3be290a74da62627dcb37c Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 4 May 2021 17:46:07 +0200
Subject: [PATCH 19/23] Implementing review feedback.

---
 c_glib/test/test-scalar-aggregate-options.rb  |  2 +-
 cpp/src/arrow/compute/api_aggregate.h         |  6 +-
 .../kernels/aggregate_basic_internal.h        |  6 +-
 .../arrow/compute/kernels/aggregate_test.cc   | 55 +++++++++----------
 .../compute/kernels/hash_aggregate_test.cc    | 11 ++--
 python/pyarrow/_compute.pyx                   |  2 +-
 python/pyarrow/tests/test_compute.py          | 15 ++++-
 r/R/compute.R                                 |  5 +-
 8 files changed, 52 insertions(+), 50 deletions(-)

diff --git a/c_glib/test/test-scalar-aggregate-options.rb b/c_glib/test/test-scalar-aggregate-options.rb
index 480e255164c..4ec7c389215 100644
--- a/c_glib/test/test-scalar-aggregate-options.rb
+++ b/c_glib/test/test-scalar-aggregate-options.rb
@@ -27,6 +27,6 @@ def test_default_skip_nulls?
   end
 
   def test_default_min_count
-    assert_equal(0, @options.min_count)
+    assert_equal(1, @options.min_count)
   end
 end
diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index 225731faa24..a7ceb2ac2fd 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -44,13 +44,13 @@ class ExecContext;
 ///
 /// By default, null values are ignored
 struct ARROW_EXPORT ScalarAggregateOptions : public FunctionOptions {
-  explicit ScalarAggregateOptions(bool skip_nulls = true, uint32_t min_count = 0)
+  explicit ScalarAggregateOptions(bool skip_nulls = true, uint32_t min_count = 1)
       : skip_nulls(skip_nulls), min_count(min_count) {}
 
   static ScalarAggregateOptions Defaults() { return ScalarAggregateOptions{}; }
 
-  bool skip_nulls = true;
-  uint32_t min_count = 0;
+  bool skip_nulls;
+  uint32_t min_count;
 };
 
 /// \brief Control Mode kernel behavior
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index b086b62e9b2..55538a5845f 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -268,10 +268,8 @@ struct MinMaxImpl : public ScalarAggregator {
     using ScalarType = typename TypeTraits<ArrowType>::ScalarType;
 
     std::vector<std::shared_ptr<Scalar>> values;
-    if (!state.has_values && options.skip_nulls && options.min_count == 0) {
-      values = {std::make_shared<ScalarType>(state.min),
-                std::make_shared<ScalarType>(state.max)};
-    } else if (!state.has_values || (state.has_nulls && !options.skip_nulls)) {
+    if (options.min_count > 0 &&
+        (!state.has_values || (state.has_nulls && !options.skip_nulls))) {
       // (null, null)
       values = {std::make_shared<ScalarType>(), std::make_shared<ScalarType>()};
     } else {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 91db10fb2e1..f8361a45b78 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -162,8 +162,8 @@ void ValidateBooleanAgg(const std::string& json,
 
 TEST(TestBooleanAggregation, Sum) {
   const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults();
-  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(0), options);
-  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(0), options);
+  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(), options);
+  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(), options);
   ValidateBooleanAgg<Sum>("[null, false]", std::make_shared<UInt64Scalar>(0), options);
   ValidateBooleanAgg<Sum>("[true]", std::make_shared<UInt64Scalar>(1), options);
   ValidateBooleanAgg<Sum>("[true, false, true]", std::make_shared<UInt64Scalar>(2),
@@ -172,9 +172,10 @@ TEST(TestBooleanAggregation, Sum) {
                           std::make_shared<UInt64Scalar>(3), options);
 
   const ScalarAggregateOptions& options_min_count_zero =
-      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
-  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(), options_min_count_zero);
-  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(),
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
+  ValidateBooleanAgg<Sum>("[]", std::make_shared<UInt64Scalar>(0),
+                          options_min_count_zero);
+  ValidateBooleanAgg<Sum>("[null]", std::make_shared<UInt64Scalar>(0),
                           options_min_count_zero);
 
   const char* json = "[true, null, false, null]";
@@ -194,8 +195,8 @@ TEST(TestBooleanAggregation, Sum) {
 
 TEST(TestBooleanAggregation, Mean) {
   const ScalarAggregateOptions& options = ScalarAggregateOptions::Defaults();
-  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(NAN), options);
-  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(NAN), options);
+  ValidateBooleanAgg<Mean>("[]", std::make_shared<DoubleScalar>(), options);
+  ValidateBooleanAgg<Mean>("[null]", std::make_shared<DoubleScalar>(), options);
   ValidateBooleanAgg<Mean>("[null, false]", std::make_shared<DoubleScalar>(0), options);
   ValidateBooleanAgg<Mean>("[true]", std::make_shared<DoubleScalar>(1), options);
   ValidateBooleanAgg<Mean>("[true, false, true, false]",
@@ -237,10 +238,9 @@ TYPED_TEST(TestNumericSumKernel, SimpleSum) {
   using ScalarType = typename TypeTraits<SumType>::ScalarType;
   using T = typename TypeParam::c_type;
 
-  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))));
+  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>()));
 
-  ValidateSum<TypeParam>("[null]",
-                         Datum(std::make_shared<ScalarType>(static_cast<T>(0))));
+  ValidateSum<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()));
 
   ValidateSum<TypeParam>("[0, 1, 2, 3, 4, 5]",
                          Datum(std::make_shared<ScalarType>(static_cast<T>(5 * 6 / 2))));
@@ -258,14 +258,17 @@ TYPED_TEST(TestNumericSumKernel, SimpleSum) {
                          Datum(std::make_shared<ScalarType>(static_cast<T>(5 * 6 / 2))));
 
   const ScalarAggregateOptions& options =
-      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
 
-  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>()), options);
+  ValidateSum<TypeParam>("[]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))),
+                         options);
 
-  ValidateSum<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()), options);
+  ValidateSum<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(static_cast<T>(0))),
+                         options);
 
   chunks = {};
-  ValidateSum<TypeParam>(chunks, Datum(std::make_shared<ScalarType>()), options);  // null
+  ValidateSum<TypeParam>(chunks, Datum(std::make_shared<ScalarType>(static_cast<T>(0))),
+                         options);
 
   const T expected_result = static_cast<T>(14);
   ValidateSum<TypeParam>("[1, null, 3, null, 3, null, 7]",
@@ -510,20 +513,16 @@ TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
 TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
   using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
 
-  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>(NAN)));
-
-  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(NAN)));
-
   const ScalarAggregateOptions& options =
-      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1);
+      ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
 
-  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>()), options);
+  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>(NAN)), options);
 
-  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()), options);
+  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(NAN)), options);
 
-  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>(NAN)));
+  ValidateMean<TypeParam>("[]", Datum(std::make_shared<ScalarType>()));
 
-  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>(NAN)));
+  ValidateMean<TypeParam>("[null]", Datum(std::make_shared<ScalarType>()));
 
   ValidateMean<TypeParam>("[1, null, 1]", Datum(std::make_shared<ScalarType>(1.0)));
 
@@ -735,18 +734,14 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
 
 TYPED_TEST_SUITE(TestIntegerMinMaxKernel, IntegralArrowTypes);
 TYPED_TEST(TestIntegerMinMaxKernel, Basics) {
-  using T = typename TypeParam::c_type;
-  T min = std::numeric_limits<T>::max();
-  T max = std::numeric_limits<T>::min();
-
   ScalarAggregateOptions options;
   std::vector<std::string> chunked_input1 = {"[5, 1, 2, 3, 4]", "[9, 1, null, 3, 4]"};
   std::vector<std::string> chunked_input2 = {"[5, null, 2, 3, 4]", "[9, 1, 2, 3, 4]"};
   std::vector<std::string> chunked_input3 = {"[5, 1, 2, 3, null]", "[9, 1, null, 3, 4]"};
 
-  // Default behaviour
-  this->AssertMinMaxIs("[]", min, max, options);
-  this->AssertMinMaxIs("[null, null, null]", min, max, options);
+  // SKIP nulls by default
+  this->AssertMinMaxIsNull("[]", options);
+  this->AssertMinMaxIsNull("[null, null, null]", options);
   this->AssertMinMaxIs("[5, 1, 2, 3, 4]", 1, 5, options);
   this->AssertMinMaxIs("[5, null, 2, 3, 4]", 2, 5, options);
   this->AssertMinMaxIs(chunked_input1, 1, 9, options);
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
index 61a759a86a8..9339a8729e9 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate_test.cc
@@ -661,15 +661,14 @@ TEST(GroupBy, ConcreteCaseWithValidateGroupBy) {
 
   ScalarAggregateOptions keepna{false, 1};
   ScalarAggregateOptions skipna{true, 1};
-  ScalarAggregateOptions other{true, 1};
 
   using internal::Aggregate;
   for (auto agg : {
-           Aggregate{"hash_sum", &other},
+           Aggregate{"hash_sum", nullptr},
            Aggregate{"hash_count", &skipna},
            Aggregate{"hash_count", &keepna},
-           Aggregate{"hash_min_max", &other},
-           Aggregate{"hash_min_max", &skipna},
+           Aggregate{"hash_min_max", nullptr},
+           Aggregate{"hash_min_max", &keepna},
        }) {
     SCOPED_TRACE(agg.function);
     ValidateGroupBy({agg}, {batch->GetColumnByName("argument")},
@@ -700,8 +699,6 @@ TEST(GroupBy, CountNull) {
 }
 
 TEST(GroupBy, RandomArraySum) {
-  ScalarAggregateOptions skipna{true, 1};
-
   for (int64_t length : {1 << 10, 1 << 12, 1 << 15}) {
     for (auto null_probability : {0.0, 0.01, 0.5, 1.0}) {
       auto batch = random::GenerateBatch(
@@ -715,7 +712,7 @@ TEST(GroupBy, RandomArraySum) {
 
       ValidateGroupBy(
           {
-              {"hash_sum", &skipna},
+              {"hash_sum", nullptr},
           },
           {batch->GetColumnByName("argument")}, {batch->GetColumnByName("key")});
     }
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 33335a05dbf..aea72c457e0 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -837,7 +837,7 @@ cdef class _ScalarAggregateOptions(FunctionOptions):
 
 
 class ScalarAggregateOptions(_ScalarAggregateOptions):
-    def __init__(self, skip_nulls=True, min_count=0):
+    def __init__(self, skip_nulls=True, min_count=1):
         self._set_options(skip_nulls, min_count)
 
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 09ff405dc56..20995ea170c 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -206,8 +206,16 @@ def test_sum_array(arrow_type):
     assert arr.sum().as_py() == 10
     assert pc.sum(arr).as_py() == 10
 
+    arr = pa.array([1, 2, 3, 4, None], type=arrow_type)
+    assert arr.sum().as_py() == 10
+    assert pc.sum(arr).as_py() == 10
+
+    arr = pa.array([None], type=arrow_type)
+    assert arr.sum().as_py() is None  # noqa: E711
+    assert pc.sum(arr).as_py() is None  # noqa: E711
+
     arr = pa.array([], type=arrow_type)
-    assert arr.sum().as_py() == 0
+    assert arr.sum().as_py() is None  # noqa: E711
 
 
 @pytest.mark.parametrize('arrow_type', numerical_arrow_types)
@@ -229,7 +237,7 @@ def test_sum_chunked_array(arrow_type):
 
     arr = pa.chunked_array((), type=arrow_type)
     assert arr.num_chunks == 0
-    assert pc.sum(arr).as_py() == 0
+    assert pc.sum(arr).as_py() is None  # noqa: E711
 
 
 def test_mode_array():
@@ -1095,6 +1103,9 @@ def test_count():
     assert pc.count(arr, skip_nulls=True).as_py() == 3
     assert pc.count(arr, skip_nulls=False).as_py() == 2
 
+    with pytest.raises(TypeError, match="an integer is required"):
+        pc.count(arr, min_count='zzz')
+
 
 def test_partition_nth():
     data = list(range(100, 140))
diff --git a/r/R/compute.R b/r/R/compute.R
index 03271bfc95d..61888827176 100644
--- a/r/R/compute.R
+++ b/r/R/compute.R
@@ -105,12 +105,12 @@ mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
 }
 
 #' @export
-min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
   scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("min")
 }
 
 #' @export
-max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
+max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
   scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("max")
 }
 
@@ -122,6 +122,7 @@ scalar_aggregate <- function(FUN, ..., na.rm = FALSE, na.min_count = 0) {
   if (FUN == "min_max" && na.rm && a$null_count == length(a)) {
     # Arrow sum/mean returns with the output type equal to input. But here R expects +/-Inf for boolean
     # and integer types which arrow will only return with float input.
+    na.min_count = 0
     a <- a$cast(float64())
   }
   call_function(FUN, a, options = list(na.rm = na.rm, na.min_count = na.min_count))

From 3d1fa604cfdb9ee86fbbf8a1fb3cf6eeb155a8f6 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sat, 8 May 2021 04:03:46 +0200
Subject: [PATCH 20/23] Changing mean behaviour.

---
 .../kernels/aggregate_basic_internal.h        |  8 +------
 .../arrow/compute/kernels/aggregate_test.cc   | 23 ++++++++-----------
 2 files changed, 11 insertions(+), 20 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 55538a5845f..7e79f92bb5b 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -60,7 +60,6 @@ struct SumImpl : public ScalarAggregator {
 
   Status Consume(KernelContext*, const ExecBatch& batch) override {
     const auto& data = batch[0].array();
-    this->length = data->length;
     this->count = data->length - data->GetNullCount();
     if (is_boolean_type<ArrowType>::value) {
       this->sum = static_cast<typename SumType::c_type>(BooleanArray(data).true_count());
@@ -73,7 +72,6 @@ struct SumImpl : public ScalarAggregator {
 
   Status MergeFrom(KernelContext*, KernelState&& src) override {
     const auto& other = checked_cast<const ThisType&>(src);
-    this->length += other.length;
     this->count += other.count;
     this->sum += other.sum;
     return Status::OK();
@@ -88,7 +86,6 @@ struct SumImpl : public ScalarAggregator {
     return Status::OK();
   }
 
-  size_t length = 0;
   size_t count = 0;
   typename SumType::c_type sum = 0;
   ScalarAggregateOptions options;
@@ -99,11 +96,8 @@ struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
   Status Finalize(KernelContext*, Datum* out) override {
     if (this->count < options.min_count) {
       out->value = std::make_shared<DoubleScalar>();
-    } else if (options.skip_nulls) {
-      const double mean = static_cast<double>(this->sum) / this->count;
-      out->value = std::make_shared<DoubleScalar>(mean);
     } else {
-      const double mean = static_cast<double>(this->sum) / this->length;
+      const double mean = static_cast<double>(this->sum) / this->count;
       out->value = std::make_shared<DoubleScalar>(mean);
     }
     return Status::OK();
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index f8361a45b78..8200581aaf8 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -221,9 +221,9 @@ TEST(TestBooleanAggregation, Mean) {
                            ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/2));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
                            ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/3));
-  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.25),
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
                            ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1));
-  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.25),
+  ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(0.5),
                            ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/2));
   ValidateBooleanAgg<Mean>(json, std::make_shared<DoubleScalar>(),
                            ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/3));
@@ -539,12 +539,9 @@ TYPED_TEST(TestMeanKernelNumeric, SimpleMean) {
 TYPED_TEST_SUITE(TestMeanKernelNumeric, NumericArrowTypes);
 TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
   using ScalarType = typename TypeTraits<DoubleType>::ScalarType;
-
-  auto expected_result_keepna = Datum(std::make_shared<ScalarType>(2));
-  auto expected_result_skipna = Datum(std::make_shared<ScalarType>(3));
+  auto expected_result = Datum(std::make_shared<ScalarType>(2));
   auto null_result = Datum(std::make_shared<ScalarType>());
   auto nan_result = Datum(std::make_shared<ScalarType>(NAN));
-  auto zero_result = Datum(std::make_shared<ScalarType>(0));
   const char* json = "[1, null, 2, 2, null, 7]";
 
   ValidateMean<TypeParam>("[]", nan_result,
@@ -555,28 +552,28 @@ TYPED_TEST(TestMeanKernelNumeric, ScalarAggregateOptions) {
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
   ValidateMean<TypeParam>("[null]", null_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/1));
-  ValidateMean<TypeParam>(json, expected_result_skipna,
+  ValidateMean<TypeParam>(json, expected_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0));
-  ValidateMean<TypeParam>(json, expected_result_skipna,
+  ValidateMean<TypeParam>(json, expected_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/3));
-  ValidateMean<TypeParam>(json, expected_result_skipna,
+  ValidateMean<TypeParam>(json, expected_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/4));
   ValidateMean<TypeParam>(json, null_result,
                           ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/5));
 
   ValidateMean<TypeParam>("[]", nan_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0));
-  ValidateMean<TypeParam>("[null]", zero_result,
+  ValidateMean<TypeParam>("[null]", nan_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0));
   ValidateMean<TypeParam>("[]", null_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1));
   ValidateMean<TypeParam>("[null]", null_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1));
-  ValidateMean<TypeParam>(json, expected_result_keepna,
+  ValidateMean<TypeParam>(json, expected_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0));
-  ValidateMean<TypeParam>(json, expected_result_keepna,
+  ValidateMean<TypeParam>(json, expected_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/3));
-  ValidateMean<TypeParam>(json, expected_result_keepna,
+  ValidateMean<TypeParam>(json, expected_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/4));
   ValidateMean<TypeParam>(json, null_result,
                           ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/15));

From 4583049f07ba89764e8a3c3922f1396f3b4f3f33 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Mon, 10 May 2021 14:00:11 +0200
Subject: [PATCH 21/23] Removing min_count from minmax.

---
 .../compute/kernels/aggregate_basic_internal.h   |  3 +--
 cpp/src/arrow/compute/kernels/aggregate_test.cc  |  8 ++++----
 r/R/compute.R                                    | 16 +++++++---------
 3 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 7e79f92bb5b..86e321ba522 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -262,8 +262,7 @@ struct MinMaxImpl : public ScalarAggregator {
     using ScalarType = typename TypeTraits<ArrowType>::ScalarType;
 
     std::vector<std::shared_ptr<Scalar>> values;
-    if (options.min_count > 0 &&
-        (!state.has_values || (state.has_nulls && !options.skip_nulls))) {
+    if (!state.has_values || (state.has_nulls && !options.skip_nulls)) {
       // (null, null)
       values = {std::make_shared<ScalarType>(), std::make_shared<ScalarType>()};
     } else {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 8200581aaf8..f1a2863e97d 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -725,8 +725,8 @@ TEST_F(TestBooleanMinMaxKernel, Basics) {
   this->AssertMinMaxIsNull(chunked_input3, options);
 
   options = ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
-  this->AssertMinMaxIs("[]", true, false, options);
-  this->AssertMinMaxIs("[null]", true, false, options);
+  this->AssertMinMaxIsNull("[]", options);
+  this->AssertMinMaxIsNull("[null]", options);
 }
 
 TYPED_TEST_SUITE(TestIntegerMinMaxKernel, IntegralArrowTypes);
@@ -785,8 +785,8 @@ TYPED_TEST(TestFloatingMinMaxKernel, Floats) {
   this->AssertMinMaxIsNull(chunked_input3, options);
 
   options = ScalarAggregateOptions(/*skip_nulls=*/true, /*min_count=*/0);
-  this->AssertMinMaxIs("[]", INFINITY, -INFINITY, options);
-  this->AssertMinMaxIs("[null]", INFINITY, -INFINITY, options);
+  this->AssertMinMaxIsNull("[]", options);
+  this->AssertMinMaxIsNull("[null]", options);
 
   options = ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/1);
   this->AssertMinMaxIsNull("[]", options);
diff --git a/r/R/compute.R b/r/R/compute.R
index 61888827176..1ee4c2a4ddd 100644
--- a/r/R/compute.R
+++ b/r/R/compute.R
@@ -105,13 +105,13 @@ mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
 }
 
 #' @export
-min.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
-  scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("min")
+min.ArrowDatum <- function(..., na.rm = FALSE) {
+  scalar_aggregate("min_max", ..., na.rm = na.rm)$GetFieldByName("min")
 }
 
 #' @export
-max.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 1) {
-  scalar_aggregate("min_max", ..., na.rm = na.rm, na.min_count = na.min_count)$GetFieldByName("max")
+max.ArrowDatum <- function(..., na.rm = FALSE) {
+  scalar_aggregate("min_max", ..., na.rm = na.rm)$GetFieldByName("max")
 }
 
 scalar_aggregate <- function(FUN, ..., na.rm = FALSE, na.min_count = 0) {
@@ -120,12 +120,10 @@ scalar_aggregate <- function(FUN, ..., na.rm = FALSE, na.min_count = 0) {
     na.min_count = length(a)
   }
   if (FUN == "min_max" && na.rm && a$null_count == length(a)) {
-    # Arrow sum/mean returns with the output type equal to input. But here R expects +/-Inf for boolean
-    # and integer types which arrow will only return with float input.
-    na.min_count = 0
-    a <- a$cast(float64())
+    Array$create(data.frame(min=Inf, max=-Inf))
+  } else {
+    call_function(FUN, a, options = list(na.rm = na.rm, na.min_count = na.min_count))
   }
-  call_function(FUN, a, options = list(na.rm = na.rm, na.min_count = na.min_count))
 }
 
 collect_arrays_from_dots <- function(dots) {

From 2672108f61361bc489566219a3a299ea0043d61b Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 19 May 2021 10:58:32 +0900
Subject: [PATCH 22/23] Improve GLib part

* Fix typos
* Improve styles
* Add more tests
---
 c_glib/arrow-glib/compute.cpp                | 11 ++++++---
 c_glib/arrow-glib/compute.hpp                |  6 +++--
 c_glib/doc/arrow-glib/arrow-glib-docs.xml    |  2 +-
 c_glib/test/test-scalar-aggregate-options.rb | 26 ++++++++++++++++----
 4 files changed, 33 insertions(+), 12 deletions(-)

diff --git a/c_glib/arrow-glib/compute.cpp b/c_glib/arrow-glib/compute.cpp
index ebdb18f438d..d284a430b81 100644
--- a/c_glib/arrow-glib/compute.cpp
+++ b/c_glib/arrow-glib/compute.cpp
@@ -695,7 +695,7 @@ garrow_scalar_aggregate_options_set_property(GObject *object,
     priv->options.skip_nulls = g_value_get_boolean(value);
     break;
   case PROP_MIN_COUNT:
-    priv->options.skip_nulls = g_value_get_uint(value);
+    priv->options.min_count = g_value_get_uint(value);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -3087,17 +3087,20 @@ garrow_cast_options_get_raw(GArrowCastOptions *cast_options)
 }
 
 GArrowScalarAggregateOptions *
-garrow_scalar_aggregate_options_new_raw(arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options)
+garrow_scalar_aggregate_options_new_raw(
+  arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options)
 {
   auto scalar_aggregate_options =
     g_object_new(GARROW_TYPE_SCALAR_AGGREGATE_OPTIONS,
-                 "skip_nulls", arrow_scalar_aggregate_options->skip_nulls,
+                 "skip-nulls", arrow_scalar_aggregate_options->skip_nulls,
+                 "min-count", arrow_scalar_aggregate_options->min_count,
                  NULL);
   return GARROW_SCALAR_AGGREGATE_OPTIONS(scalar_aggregate_options);
 }
 
 arrow::compute::ScalarAggregateOptions *
-garrow_scalar_aggregate_options_get_raw(GArrowScalarAggregateOptions *scalar_aggregate_options)
+garrow_scalar_aggregate_options_get_raw(
+  GArrowScalarAggregateOptions *scalar_aggregate_options)
 {
   auto priv = GARROW_SCALAR_AGGREGATE_OPTIONS_GET_PRIVATE(scalar_aggregate_options);
   return &(priv->options);
diff --git a/c_glib/arrow-glib/compute.hpp b/c_glib/arrow-glib/compute.hpp
index 0b7b9a2bd76..289bcbe31af 100644
--- a/c_glib/arrow-glib/compute.hpp
+++ b/c_glib/arrow-glib/compute.hpp
@@ -47,9 +47,11 @@ GArrowCastOptions *garrow_cast_options_new_raw(arrow::compute::CastOptions *arro
 arrow::compute::CastOptions *garrow_cast_options_get_raw(GArrowCastOptions *cast_options);
 
 GArrowScalarAggregateOptions *
-garrow_scalar_aggregate_options_new_raw(arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options);
+garrow_scalar_aggregate_options_new_raw(
+  arrow::compute::ScalarAggregateOptions *arrow_scalar_aggregate_options);
 arrow::compute::ScalarAggregateOptions *
-garrow_scalar_aggregate_options_get_raw(GArrowScalarAggregateOptions *scalar_aggregate_options);
+garrow_scalar_aggregate_options_get_raw(
+  GArrowScalarAggregateOptions *scalar_aggregate_options);
 
 arrow::compute::FilterOptions *
 garrow_filter_options_get_raw(GArrowFilterOptions *filter_options);
diff --git a/c_glib/doc/arrow-glib/arrow-glib-docs.xml b/c_glib/doc/arrow-glib/arrow-glib-docs.xml
index 22ff7217d75..80af9506ecd 100644
--- a/c_glib/doc/arrow-glib/arrow-glib-docs.xml
+++ b/c_glib/doc/arrow-glib/arrow-glib-docs.xml
@@ -181,7 +181,7 @@
   </index>
   <index id="api-index-5-0-0" role="5.0.0">
     <title>Index of new symbols in 5.0.0</title>
-    <xi:include href="xml/api-index-4.0.0.xml"><xi:fallback /></xi:include>
+    <xi:include href="xml/api-index-5.0.0.xml"><xi:fallback /></xi:include>
   </index>
   <index id="api-index-4-0-0" role="4.0.0">
     <title>Index of new symbols in 4.0.0</title>
diff --git a/c_glib/test/test-scalar-aggregate-options.rb b/c_glib/test/test-scalar-aggregate-options.rb
index 4ec7c389215..a794b53243a 100644
--- a/c_glib/test/test-scalar-aggregate-options.rb
+++ b/c_glib/test/test-scalar-aggregate-options.rb
@@ -20,13 +20,29 @@ def setup
     @options = Arrow::ScalarAggregateOptions.new
   end
 
-  def test_default_skip_nulls?
-    assert do
-      @options.skip_nulls?
+  sub_test_case("skip_nulls") do
+    def test_default
+      assert do
+        @options.skip_nulls?
+      end
+    end
+
+    def test_accessor
+      @options.skip_nulls = false
+      assert do
+        not @options.skip_nulls?
+      end
     end
   end
 
-  def test_default_min_count
-    assert_equal(1, @options.min_count)
+  sub_test_case("min_count") do
+    def test_default
+      assert_equal(1, @options.min_count)
+    end
+
+    def test_accessor
+      @options.min_count = 0
+      assert_equal(0, @options.min_count)
+    end
   end
 end

From 3708060a83ceb7698858ef955880456e3bba5bf5 Mon Sep 17 00:00:00 2001
From: Neal Richardson <neal.p.richardson@gmail.com>
Date: Thu, 20 May 2021 07:54:43 -0700
Subject: [PATCH 23/23] :nail_care: in R

Co-authored-by: Rok Mihevc <rok@mihevc.org>
---
 r/R/compute.R | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/r/R/compute.R b/r/R/compute.R
index 1ee4c2a4ddd..43c3285481c 100644
--- a/r/R/compute.R
+++ b/r/R/compute.R
@@ -95,13 +95,13 @@ list_compute_functions <- function(pattern = NULL, ...) {
 }
 
 #' @export
-sum.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
-  scalar_aggregate("sum", ..., na.rm = na.rm, na.min_count = na.min_count)
+sum.ArrowDatum <- function(..., na.rm = FALSE) {
+  scalar_aggregate("sum", ..., na.rm = na.rm)
 }
 
 #' @export
-mean.ArrowDatum <- function(..., na.rm = FALSE, na.min_count = 0) {
-  scalar_aggregate("mean", ..., na.rm = na.rm, na.min_count = na.min_count)
+mean.ArrowDatum <- function(..., na.rm = FALSE) {
+  scalar_aggregate("mean", ..., na.rm = na.rm)
 }
 
 #' @export
@@ -116,11 +116,17 @@ max.ArrowDatum <- function(..., na.rm = FALSE) {
 
 scalar_aggregate <- function(FUN, ..., na.rm = FALSE, na.min_count = 0) {
   a <- collect_arrays_from_dots(list(...))
-  if (FUN %in% c("mean", "sum") && !na.rm) {
-    na.min_count = length(a)
+  if (!na.rm) {
+    # When not removing null values, we require all values to be not null and 
+    # return null otherwise. We do that by setting minimum count of non-null 
+    # option values to the full array length.
+    na.min_count <- length(a)
   }
   if (FUN == "min_max" && na.rm && a$null_count == length(a)) {
-    Array$create(data.frame(min=Inf, max=-Inf))
+    Array$create(data.frame(min = Inf, max = -Inf))
+    # If na.rm == TRUE and all values in array are NA, R returns
+    # Inf/-Inf, which are type double. Since Arrow is type-stable
+    # and does not do that, we handle this special case here.
   } else {
     call_function(FUN, a, options = list(na.rm = na.rm, na.min_count = na.min_count))
   }