Add date array

CMakeLists.txt

@@ -201,6 +201,7 @@ set(SPARROW_HEADERS
     ${SPARROW_INCLUDE_DIR}/sparrow/layout/primitive_array.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/layout/struct_layout/struct_array.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/layout/struct_layout/struct_value.hpp
+    ${SPARROW_INCLUDE_DIR}/sparrow/layout/temporal/date_array.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/layout/temporal/duration_array.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/layout/temporal/timestamp_array.hpp
     ${SPARROW_INCLUDE_DIR}/sparrow/layout/temporal/timestamp_concepts.hpp

include/sparrow/arrow_interface/arrow_array_schema_info_utils.hpp

@@ -44,6 +44,8 @@ namespace sparrow
             case data_type::HALF_FLOAT:
             case data_type::FLOAT:
             case data_type::DOUBLE:
+            case data_type::DATE_DAYS:
+            case data_type::DATE_MILLISECONDS:
             case data_type::TIMESTAMP_SECONDS:
             case data_type::TIMESTAMP_MILLISECONDS:
             case data_type::TIMESTAMP_MICROSECONDS:

include/sparrow/builder/builder.hpp

@@ -31,6 +31,7 @@
 #include <sparrow/layout/list_layout/list_array.hpp>
 #include <sparrow/layout/primitive_array.hpp>
 #include <sparrow/layout/struct_layout/struct_array.hpp>
+#include <sparrow/layout/temporal/date_array.hpp>
 #include <sparrow/layout/union_array.hpp>
 #include <sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp>
 #include <sparrow/utils/ranges.hpp>
@@ -120,6 +121,12 @@ namespace sparrow
                                                  && std::is_scalar_v<ensured_range_value_t<T>>;
 
         template <typename T>
+        concept translates_to_date_layout = std::ranges::input_range<T>
+                                            && mpl::any_of(
+                                                date_types_t{},
+                                                mpl::predicate::same_as<ensured_range_value_t<T>>{}
+                                            );
+        template <typename T>
         concept translates_to_duration_layout = std::ranges::input_range<T>
                                                 && mpl::any_of(
                                                     duration_types_t{},
@@ -197,6 +204,18 @@ namespace sparrow
             }
         };
 
+        template <translates_to_date_layout T, class OPTION_FLAGS>
+        struct builder<T, dont_enforce_layout, OPTION_FLAGS>
+        {
+            using type = sparrow::date_array<ensured_range_value_t<T>>;
+
+            template <class U>
+            static type create(U&& t)
+            {
+                return type(std::forward<U>(t));
+            }
+        };
+
         template <translates_to_duration_layout T, class OPTION_FLAGS>
         struct builder<T, dont_enforce_layout, OPTION_FLAGS>
         {

include/sparrow/layout/dispatch.hpp

@@ -26,12 +26,14 @@
 #include "sparrow/layout/primitive_array.hpp"
 #include "sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp"
 #include "sparrow/layout/struct_layout/struct_array.hpp"
+#include "sparrow/layout/temporal/date_array.hpp"
 #include "sparrow/layout/temporal/duration_array.hpp"
 #include "sparrow/layout/temporal/interval_array.hpp"
 #include "sparrow/layout/temporal/timestamp_array.hpp"
 #include "sparrow/layout/union_array.hpp"
 #include "sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp"
 #include "sparrow/types/data_traits.hpp"
+#include "sparrow/types/data_type.hpp"
 
 namespace sparrow
 {
@@ -131,6 +133,10 @@
                     return func(unwrap_array<decimal_256_array>(ar));
                 case data_type::FIXED_WIDTH_BINARY:
                     return func(unwrap_array<fixed_width_binary_array>(ar));
+                case sparrow::data_type::DATE_DAYS:
+                    return func(unwrap_array<date_days_array>(ar));
+                case data_type::DATE_MILLISECONDS:
+                    return func(unwrap_array<date_milliseconds_array>(ar));
                 case data_type::TIMESTAMP_SECONDS:
                     return func(unwrap_array<timestamp_array<timestamp<std::chrono::seconds>>>(ar));
                 case data_type::TIMESTAMP_MILLISECONDS:

include/sparrow/layout/temporal/date_array.hpp

@@ -0,0 +1,64 @@
+// Copyright 2024 Man Group Operations Limited
+//
+// Licensed 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 mplied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "sparrow/layout/array_trivial_copyable.hpp"
+#include "sparrow/layout/temporal/date_types.hpp"
+
+// tdD : std::chrono::seconds
+// tdm : std::chrono::milliseconds
+
+namespace sparrow
+{
+    using date_types_t = mpl::typelist<date_days, date_milliseconds>;
+
+    static constexpr date_types_t date_types;
+    template <typename T>
+    concept date_type = mpl::contains<T>(date_types);
+
+    /**
+     * Array of std::chrono::duration values.
+     *
+     * As the other arrays in sparrow, \c date_array<T> provides an API as if it was holding
+     * \c nullable<T> values instead of \c T values.
+     *
+     * Internally, the array contains a validity bitmap and a contiguous memory buffer
+     * holding the values.
+     *
+     * @tparam T the type of the values in the array.
+     * @see https://arrow.apache.org/docs/dev/format/Columnar.html#fixed-size-primitive-layout
+     */
+    template <date_type T>
+    using date_array = array_trivial_copyable<T>;
+
+    using date_days_array = date_array<date_days>;
+    using date_milliseconds_array = date_array<date_milliseconds>;
+
+    template <class T>
+    struct is_date_array : std::false_type
+    {
+    };
+
+    template <class T>
+    struct is_date_array<date_array<T>> : std::true_type
+    {
+    };
+
+    /**
+     * Checks whether T is a date_array type.
+     */
+    template <class T>
+    constexpr bool is_date_array_v = is_date_array<T>::value;
+}

include/sparrow/layout/temporal/date_types.hpp

@@ -0,0 +1,25 @@
+// Copyright 2024 Man Group Operations Limited
+//
+// Licensed 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 mplied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <chrono>
+
+#include "sparrow/layout/temporal/temporal_types.hpp"
+
+namespace sparrow
+{
+    using date_days = std::chrono::time_point<std::chrono::system_clock, chrono::days>;
+    using date_milliseconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>;
+}

include/sparrow/layout/temporal/interval_types.hpp

@@ -19,13 +19,10 @@
 #    include <format>
 #endif
 
+#include "sparrow/layout/temporal/temporal_types.hpp"
+
 namespace sparrow
 {
-    namespace chrono
-    {
-        using days = std::chrono::duration<int32_t, std::ratio<86400>>;
-        using months = std::chrono::duration<int32_t, std::ratio<2629746>>;
-    }
 
 // We pack the structures to ensure that they are the same size on all platforms
 #pragma pack(push, 1)

include/sparrow/layout/temporal/temporal_types.hpp

@@ -0,0 +1,23 @@
+// Copyright 2024 Man Group Operations Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <chrono>
+
+namespace sparrow::chrono
+{
+    using days = std::chrono::duration<int32_t, std::ratio<86400>>;      // 1 day = 86400 seconds
+    using months = std::chrono::duration<int32_t, std::ratio<2629746>>;  // 1 month = 2629746 seconds
+}

include/sparrow/types/data_traits.hpp

@@ -17,6 +17,7 @@
 #include <chrono>
 #include <concepts>
 
+#include "sparrow/layout/temporal/date_array.hpp"
 #include "sparrow/layout/temporal/interval_types.hpp"
 #include "sparrow/types/data_type.hpp"
 #include "sparrow/utils/nullable.hpp"
@@ -112,6 +113,18 @@ namespace sparrow
         using const_reference = decimal<int256_t>;
     };
 
+    template <>
+    struct arrow_traits<date_days> : common_native_types_traits<date_days>
+    {
+        static constexpr data_type type_id = data_type::DATE_DAYS;
+    };
+
+    template <>
+    struct arrow_traits<date_milliseconds> : common_native_types_traits<date_milliseconds>
+    {
+        static constexpr data_type type_id = data_type::DATE_MILLISECONDS;
+    };
+
     template <>
     struct arrow_traits<std::chrono::seconds> : common_native_types_traits<std::chrono::seconds>
     {

include/sparrow/types/data_type.hpp

@@ -17,6 +17,7 @@
 #include <chrono>
 #include <version>
 
+#include "sparrow/layout/temporal/date_types.hpp"
 #include "sparrow/layout/temporal/interval_types.hpp"
 
 #if defined(SPARROW_USE_DATE_POLYFILL)
@@ -188,6 +189,8 @@
         DECIMAL128,
         DECIMAL256,
         FIXED_WIDTH_BINARY,
+        DATE_DAYS,
+        DATE_MILLISECONDS,
         TIMESTAMP_SECONDS,
         TIMESTAMP_MILLISECONDS,
         TIMESTAMP_MICROSECONDS,
@@ -278,7 +281,15 @@
         // TODO: add propper timestamp support below
         else if (format.starts_with("t"))
         {
-            if (format.starts_with("tss:"))
+            if (format == "tdD")
+            {
+                return data_type::DATE_DAYS;
+            }
+            else if (format == "tdm")
+            {
+                return data_type::DATE_MILLISECONDS;
+            }
+            else if (format.starts_with("tss:"))
             {
                 return data_type::TIMESTAMP_SECONDS;
             }
@@ -500,6 +511,10 @@
                 return "z";
             case data_type::LARGE_BINARY:
                 return "Z";
+            case data_type::DATE_DAYS:
+                return "tdD";
+            case data_type::DATE_MILLISECONDS:
+                return "tdm";
             case data_type::TIMESTAMP_SECONDS:
                 return "tss:";
             case data_type::TIMESTAMP_MILLISECONDS:
@@ -595,6 +610,8 @@
         float64_t,
         std::string,
         std::vector<byte_t>,
+        date_days,
+        date_milliseconds,
         timestamp<std::chrono::seconds>,
         timestamp<std::chrono::milliseconds>,
         timestamp<std::chrono::microseconds>,
@@ -836,6 +853,10 @@
                         return "Binary";
                     case LARGE_BINARY:
                         return "Large binary";
+                    case DATE_DAYS:
+                        return "Date days";
+                    case DATE_MILLISECONDS:
+                        return "Date milliseconds";
                     case TIMESTAMP_SECONDS:
                         return "Timestamp seconds";
                     case TIMESTAMP_MILLISECONDS:

src/array_factory.cpp

@@ -22,6 +22,7 @@
 #include "sparrow/layout/primitive_array.hpp"
 #include "sparrow/layout/run_end_encoded_layout/run_end_encoded_array.hpp"
 #include "sparrow/layout/struct_layout/struct_array.hpp"
+#include "sparrow/layout/temporal/date_array.hpp"
 #include "sparrow/layout/temporal/duration_array.hpp"
 #include "sparrow/layout/temporal/interval_array.hpp"
 #include "sparrow/layout/temporal/timestamp_array.hpp"
@@ -123,6 +124,10 @@
                     return detail::make_wrapper_ptr<dense_union_array>(std::move(proxy));
                 case data_type::SPARSE_UNION:
                     return detail::make_wrapper_ptr<sparse_union_array>(std::move(proxy));
+                case data_type::DATE_DAYS:
+                    return detail::make_wrapper_ptr<date_days_array>(std::move(proxy));
+                case data_type::DATE_MILLISECONDS:
+                    return detail::make_wrapper_ptr<date_milliseconds_array>(std::move(proxy));
                 case data_type::TIMESTAMP_SECONDS:
                     return detail::make_wrapper_ptr<timestamp_seconds_array>(std::move(proxy));
                 case data_type::TIMESTAMP_MILLISECONDS:

src/arrow_interface/arrow_array.cpp

@@ -124,6 +124,9 @@ namespace sparrow
                 return {make_buffer(0, size)};
             case data_type::DENSE_UNION:
                 return {make_buffer(0, size), make_buffer(1, size * 4)};
+            case data_type::DATE_DAYS:
+                return {make_valid_buffer(), make_buffer(1, size * 4)};
+            case data_type::DATE_MILLISECONDS:
             case data_type::TIMESTAMP_SECONDS:
             case data_type::TIMESTAMP_MILLISECONDS:
             case data_type::TIMESTAMP_MICROSECONDS:

test/CMakeLists.txt

@@ -131,6 +131,7 @@ else()
         test_dictionary_encoded_array.cpp
         test_dispatch.cpp
         test_duration_array.cpp
+        test_date_array.cpp
         test_dynamic_bitset_view.cpp
         test_dynamic_bitset.cpp
         test_fixed_width_binary_array.cpp