fix equal and the relevant tests

Author: arashandishgar

cpp/src/arrow/array/statistics.cc

@@ -21,6 +21,7 @@
 #include "arrow/array/statistics.h"
 
 #include <memory>
+#include <type_traits>
 #include <variant>
 
 #include "arrow/scalar.h"
@@ -59,4 +60,39 @@ const std::shared_ptr<DataType>& ArrayStatistics::ValueToArrowType(
   } visitor{array_type};
   return std::visit(visitor, value.value());
 }
+namespace {
+bool ValueTypeEquality(const std::optional<ArrayStatistics::ValueType>& first,
+                       const std::optional<ArrayStatistics::ValueType>& second) {
+  if (first == second) {
+    return true;
+  }
+  if (!first || !second) {
+    return false;
+  }
+  // check for std::shared_ptr<Scalar> separately, as it does not have == operator
+  // overload
+  return std::visit(
+      [](auto& v1, auto& v2) {
+        if constexpr (std::is_same_v<std::decay_t<decltype(v1)>,
+                                     std::shared_ptr<Scalar>> &&
+                      std::is_same_v<std::decay_t<decltype(v2)>,
+                                     std::shared_ptr<Scalar>>) {
+          if (!v1 || !v2) {
+            // both null case is handled in std::optional and return true
+            return false;
+          }
+          return v1->Equals(*v2);
+        }
+        return false;
+      },
+      first.value(), second.value());
+}
+}  // namespace
+bool ArrayStatistics::Equals(const ArrayStatistics& other) const {
+  return null_count == other.null_count && distinct_count == other.distinct_count &&
+         is_min_exact == other.is_min_exact && is_max_exact == other.is_max_exact &&
+         ValueTypeEquality(this->max, other.max) &&
+         ValueTypeEquality(this->min, other.min);
+}
+
 }  // namespace arrow

cpp/src/arrow/array/statistics.h

@@ -101,11 +101,7 @@ struct ARROW_EXPORT ArrayStatistics {
   bool is_max_exact = false;
 
   /// \brief Check two statistics for equality
-  bool Equals(const ArrayStatistics& other) const {
-    return null_count == other.null_count && distinct_count == other.distinct_count &&
-           min == other.min && is_min_exact == other.is_min_exact && max == other.max &&
-           is_max_exact == other.is_max_exact;
-  }
+  bool Equals(const ArrayStatistics& other) const;
 
   /// \brief Check two statistics for equality
   bool operator==(const ArrayStatistics& other) const { return Equals(other); }

cpp/src/arrow/array/statistics_test.cc

@@ -18,6 +18,8 @@
 #include <gtest/gtest.h>
 
 #include "arrow/array/statistics.h"
+#include "arrow/scalar.h"
+#include "arrow/testing/gtest_util.h"
 
 namespace arrow {
 
@@ -91,6 +93,28 @@ TEST(ArrayStatisticsTest, TestEquality) {
   ASSERT_NE(statistics1, statistics2);
   statistics2.max = static_cast<int64_t>(-29);
   ASSERT_EQ(statistics1, statistics2);
+  statistics2.max = static_cast<int64_t>(2);
+  ASSERT_NE(statistics1, statistics2);
+
+  statistics1.max = std::nullopt;
+  statistics2.max = std::nullopt;
+  // check the state of both of them are std::nullopt
+  ASSERT_EQ(statistics1.max, statistics2.max);
+  //  the state of one of them is std::nullopt
+  statistics1.max = std::shared_ptr<Scalar>();
+  ASSERT_NE(statistics1, statistics2);
+  // the state of both of them are nullptr
+  statistics2.max = std::shared_ptr<Scalar>();
+  ASSERT_EQ(statistics1, statistics2);
+  ASSERT_OK_AND_ASSIGN(statistics1.max, MakeScalar(int64(), 5));
+  // the state of one of them is nullptr
+  ASSERT_NE(statistics1, statistics2);
+  // the state of one of them has different type
+  statistics2.max = static_cast<int64_t>(10);
+  ASSERT_NE(statistics1.max, statistics2.max);
+  ASSERT_OK_AND_ASSIGN(statistics2.max, MakeScalar(int64(), 5));
+  // the state of both of them are equal
+  ASSERT_EQ(statistics1, statistics2);
 
   statistics1.is_max_exact = true;
   ASSERT_NE(statistics1, statistics2);

cpp/src/arrow/record_batch_test.cc

@@ -1497,8 +1497,8 @@ TEST_F(TestRecordBatch, MakeStatisticsArrayNestedType) {
   auto rb = RecordBatch::Make(rb_schema, 5,
                               {struct_array, array_c, array_d, struct_nested_stat});
 
-  auto expected_scalar = std::static_pointer_cast<Scalar>(std::shared_ptr<StructScalar>(
-      new StructScalar({MakeScalar(int64_t{5}), MakeScalar(int64_t{10})}, struct_type)));
+  auto expected_scalar = internal::checked_pointer_cast<StructScalar>(
+      ScalarFromJSON(struct_type, R"([5,10])"));
   auto a = ArrayStatistics::ValueType{std::static_pointer_cast<Scalar>(expected_scalar)};
 
   ASSERT_OK_AND_ASSIGN(
@@ -1541,8 +1541,8 @@ TEST_F(TestRecordBatch, MakeStatisticsArrayNestedNestedType) {
       StructArray::Make({struct_nested_0, struct_nested_1},
                         {field("struct_nested_0", struct_nested_0->type()),
                          field("struct_nested_1", struct_nested_1->type())}));
-  auto expected_scalar = std::static_pointer_cast<Scalar>(std::shared_ptr<StructScalar>(
-      new StructScalar({MakeScalar(int32_t{5}), MakeScalar(int32_t{10})}, struct_type)));
+  auto expected_scalar = internal::checked_pointer_cast<StructScalar>(
+      ScalarFromJSON(struct_type, R"([5,10])"));
   auto rb_schema = schema({field("struct", struct_parent->type())});
   auto rb = RecordBatch::Make(rb_schema, 5, {struct_parent});
   ASSERT_OK_AND_ASSIGN(auto rb_stat, rb->MakeStatisticsArray())