ARROW-10924: [C++] Validate temporal data in ValidateArrayFull

cpp/src/arrow/array/array_test.cc

@@ -534,7 +534,7 @@ static ScalarVector GetScalars() {
       std::make_shared<UInt64Scalar>(3),
       std::make_shared<DoubleScalar>(3.0),
       std::make_shared<Date32Scalar>(10),
-      std::make_shared<Date64Scalar>(11),
+      std::make_shared<Date64Scalar>(864000000),
       std::make_shared<Time32Scalar>(1000, time32(TimeUnit::SECOND)),
       std::make_shared<Time64Scalar>(1111, time64(TimeUnit::MICRO)),
       std::make_shared<TimestampScalar>(1111, timestamp(TimeUnit::MILLI)),

cpp/src/arrow/array/validate.cc

@@ -168,6 +168,81 @@ struct ValidateArrayImpl {
     return Status::OK();
   }
 
+  Status Visit(const Date64Type& type) {
+    RETURN_NOT_OK(ValidateFixedWidthBuffers());
+
+    if (full_validation) {
+      using c_type = typename Date64Type::c_type;
+      return VisitArrayDataInline<Date64Type>(
+          data,
+          [&](c_type date) {
+            constexpr c_type kFullDayMillis = 1000 * 60 * 60 * 24;
+            if (date % kFullDayMillis != 0) {
+              return Status::Invalid(type, " ", date,
+                                     " does not represent a whole number of days");
+            }
+            return Status::OK();
+          },
+          []() { return Status::OK(); });
+    }
+    return Status::OK();
+  }
+
+  Status Visit(const Time32Type& type) {
+    RETURN_NOT_OK(ValidateFixedWidthBuffers());
+
+    if (full_validation) {
+      using c_type = typename Time32Type::c_type;
+      return VisitArrayDataInline<Time32Type>(
+          data,
+          [&](c_type time) {
+            constexpr c_type kFullDaySeconds = 60 * 60 * 24;
+            constexpr c_type kFullDayMillis = kFullDaySeconds * 1000;
+            if (type.unit() == TimeUnit::SECOND &&
+                (time < 0 || time >= kFullDaySeconds)) {
+              return Status::Invalid(type, " ", time,
+                                     " is not within the acceptable range of ", "[0, ",
+                                     kFullDaySeconds, ") s");
+            }
+            if (type.unit() == TimeUnit::MILLI && (time < 0 || time >= kFullDayMillis)) {
+              return Status::Invalid(type, " ", time,
+                                     " is not within the acceptable range of ", "[0, ",
+                                     kFullDayMillis, ") ms");
+            }
+            return Status::OK();
+          },
+          []() { return Status::OK(); });
+    }
+    return Status::OK();
+  }
+
+  Status Visit(const Time64Type& type) {
+    RETURN_NOT_OK(ValidateFixedWidthBuffers());
+
+    if (full_validation) {
+      using c_type = typename Time64Type::c_type;
+      return VisitArrayDataInline<Time64Type>(
+          data,
+          [&](c_type time) {
+            constexpr c_type kFullDayMicro = 1000000LL * 60 * 60 * 24;
+            constexpr c_type kFullDayNano = kFullDayMicro * 1000;
+            if (type.unit() == TimeUnit::MICRO && (time < 0 || time >= kFullDayMicro)) {
+              return Status::Invalid(type, " ", time,
+                                     " is not within the acceptable range of ", "[0, ",
+                                     kFullDayMicro, ") us");
+            }
+            if (type.unit() == TimeUnit::NANO && (time < 0 || time >= kFullDayNano)) {
+              return Status::Invalid(type, " ", time,
+                                     " is not within the acceptable range of ", "[0, ",
+                                     kFullDayNano, ") ns");
+            }
+            return Status::OK();
+          },
+          []() { return Status::OK(); });
+    }
+    return Status::OK();
+  }
+
   Status Visit(const BinaryType& type) { return ValidateBinaryLike(type); }
 
   Status Visit(const LargeBinaryType& type) { return ValidateBinaryLike(type); }

cpp/src/arrow/c/bridge_test.cc

@@ -1668,6 +1668,7 @@ static const float data_buffer5[] = {0.0f, 1.5f, -2.0f, 3.0f, 4.0f, 5.0f};
 static const double data_buffer6[] = {0.0, 1.5, -2.0, 3.0, 4.0, 5.0};
 static const int32_t data_buffer7[] = {1234, 5678, 9012, 3456};
 static const int64_t data_buffer8[] = {123456789, 987654321, -123456789, -987654321};
+static const int64_t date64_data_buffer8[] = {86400000, 172800000, -86400000, -172800000};
 #if ARROW_LITTLE_ENDIAN
 static const void* primitive_buffers_no_nulls1_8[2] = {nullptr, data_buffer1};
 static const void* primitive_buffers_no_nulls1_16[2] = {nullptr, data_buffer1};
@@ -1699,6 +1700,9 @@ static const void* primitive_buffers_nulls7[2] = {bits_buffer1, data_buffer7};
 static const void* primitive_buffers_no_nulls8[2] = {nullptr, data_buffer8};
 static const void* primitive_buffers_nulls8[2] = {bits_buffer1, data_buffer8};
 
+static const void* date64_buffers_no_nulls8[2] = {nullptr, date64_data_buffer8};
+static const void* date64_buffers_nulls8[2] = {bits_buffer1, date64_data_buffer8};
+
 static const int64_t timestamp_data_buffer1[] = {0, 951782400, -2203977600LL};
 static const int64_t timestamp_data_buffer2[] = {0, 951782400000LL, -2203977600000LL};
 static const int64_t timestamp_data_buffer3[] = {0, 951782400000000LL,
@@ -1987,8 +1991,8 @@ TEST_F(TestArrayImport, Primitive) {
 TEST_F(TestArrayImport, Temporal) {
   FillPrimitive(3, 0, 0, primitive_buffers_no_nulls7);
   CheckImport(ArrayFromJSON(date32(), "[1234, 5678, 9012]"));
-  FillPrimitive(3, 0, 0, primitive_buffers_no_nulls8);
-  CheckImport(ArrayFromJSON(date64(), "[123456789, 987654321, -123456789]"));
+  FillPrimitive(3, 0, 0, date64_buffers_no_nulls8);
+  CheckImport(ArrayFromJSON(date64(), "[86400000, 172800000, -86400000]"));
 
   FillPrimitive(2, 0, 0, primitive_buffers_no_nulls7);
   CheckImport(ArrayFromJSON(time32(TimeUnit::SECOND), "[1234, 5678]"));
@@ -2026,8 +2030,8 @@ TEST_F(TestArrayImport, Temporal) {
   // With nulls
   FillPrimitive(3, -1, 0, primitive_buffers_nulls7);
   CheckImport(ArrayFromJSON(date32(), "[1234, null, 9012]"));
-  FillPrimitive(3, -1, 0, primitive_buffers_nulls8);
-  CheckImport(ArrayFromJSON(date64(), "[123456789, null, -123456789]"));
+  FillPrimitive(3, -1, 0, date64_buffers_nulls8);
+  CheckImport(ArrayFromJSON(date64(), "[86400000, null, -86400000]"));
   FillPrimitive(2, -1, 0, primitive_buffers_nulls8);
   CheckImport(ArrayFromJSON(time64(TimeUnit::NANO), "[123456789, null]"));
   FillPrimitive(2, -1, 0, primitive_buffers_nulls8);

cpp/src/arrow/compute/kernels/hash_aggregate_test.cc

@@ -1616,14 +1616,12 @@ TEST(GroupBy, MinMaxTypes) {
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
   types.insert(types.end(), TemporalTypes().begin(), TemporalTypes().end());
   types.push_back(month_interval());
-  for (const auto& ty : types) {
-    SCOPED_TRACE(ty->ToString());
-    auto in_schema = schema({field("argument0", ty), field("key", int64())});
-    auto table = TableFromJSON(in_schema, {R"([
+
+  const std::vector<std::string> default_table = {R"([
     [1,    1],
     [null, 1]
 ])",
-                                           R"([
+                                                  R"([
     [0,    2],
     [null, 3],
     [3,    4],
@@ -1632,11 +1630,54 @@ TEST(GroupBy, MinMaxTypes) {
     [3,    1],
     [0,    2]
 ])",
-                                           R"([
+                                                  R"([
     [0,    2],
     [1,    null],
     [null, 3]
-])"});
+])"};
+
+  const std::vector<std::string> date64_table = {R"([
+    [86400000,    1],
+    [null, 1]
+])",
+                                                 R"([
+    [0,    2],
+    [null, 3],
+    [259200000,    4],
+    [432000000,    4],
+    [345600000,    null],
+    [259200000,    1],
+    [0,    2]
+])",
+                                                 R"([
+    [0,    2],
+    [86400000,    null],
+    [null, 3]
+])"};
+
+  const std::string default_expected =
+      R"([
+    [{"min": 1, "max": 3},       1],
+    [{"min": 0, "max": 0},       2],
+    [{"min": null, "max": null}, 3],
+    [{"min": 3, "max": 5},       4],
+    [{"min": 1, "max": 4},       null]
+    ])";
+
+  const std::string date64_expected =
+      R"([
+    [{"min": 86400000, "max": 259200000},       1],
+    [{"min": 0, "max": 0},       2],
+    [{"min": null, "max": null}, 3],
+    [{"min": 259200000, "max": 432000000},       4],
+    [{"min": 86400000, "max": 345600000},       null]
+    ])";
+
+  for (const auto& ty : types) {
+    SCOPED_TRACE(ty->ToString());
+    auto in_schema = schema({field("argument0", ty), field("key", int64())});
+    auto table =
+        TableFromJSON(in_schema, (ty->name() == "date64") ? date64_table : default_table);
 
     ASSERT_OK_AND_ASSIGN(
         Datum aggregated_and_grouped,
@@ -1652,13 +1693,7 @@ TEST(GroupBy, MinMaxTypes) {
                 field("hash_min_max", struct_({field("min", ty), field("max", ty)})),
                 field("key_0", int64()),
             }),
-            R"([
-    [{"min": 1, "max": 3},       1],
-    [{"min": 0, "max": 0},       2],
-    [{"min": null, "max": null}, 3],
-    [{"min": 3, "max": 5},       4],
-    [{"min": 1, "max": 4},       null]
-  ])"),
+            (ty->name() == "date64") ? date64_expected : default_expected),
         aggregated_and_grouped,
         /*verbose=*/true);
   }

cpp/src/arrow/compute/kernels/scalar_cast_test.cc

@@ -1670,10 +1670,11 @@ TEST(Cast, DateZeroCopy) {
            date64(),
            int64(),  // ARROW-1773: cast to int64
        }) {
-    CheckCastZeroCopy(ArrayFromJSON(date64(), "[0, null, 2000, 1000, 0]"),
+    CheckCastZeroCopy(ArrayFromJSON(date64(), "[0, null, 172800000, 86400000, 0]"),
                       zero_copy_to_type);
   }
-  CheckCastZeroCopy(ArrayFromJSON(int64(), "[0, null, 2000, 1000, 0]"), date64());
+  CheckCastZeroCopy(ArrayFromJSON(int64(), "[0, null, 172800000, 86400000, 0]"),
+                    date64());
 }
 
 TEST(Cast, DurationToDuration) {