feat: add date_type for MySQL DATE columns

Adds date_type backed by std::chrono::sys_days with full support for
DDL generation, serialization, deserialization, and optional variants.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Pierre-Luc Gagné

CHANGELOG.md

@@ -8,6 +8,10 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Added
+
+- `date_type` for MySQL `DATE` columns — stores `std::chrono::sys_days`, supports serialization (`'YYYY-MM-DD'`), deserialization, and `std::optional<date_type>` for nullable columns
+
 ---
 
 ## [4.5.0] – 2026-03-29

lib/include/ds_mysql/column_field_base_temporal.hpp

@@ -210,6 +210,94 @@ struct base<std::optional<timestamp_type<Fsp>>> : column_field_tag {
     }
 };
 
+// ===================================================================
+// base<date_type> specializations
+// ===================================================================
+
+template <>
+struct base<date_type> : column_field_tag {
+    using value_type = date_type;
+
+    date_type value{};
+
+    constexpr base() = default;
+    base(std::chrono::sys_days d) noexcept : value(d) {
+    }
+    base(date_type v) noexcept : value(v) {
+    }
+
+    base& operator=(std::chrono::sys_days d) noexcept {
+        value = date_type{d};
+        return *this;
+    }
+    base& operator=(date_type v) noexcept {
+        value = v;
+        return *this;
+    }
+
+    [[nodiscard]] constexpr date_type const& get() const noexcept {
+        return value;
+    }
+    [[nodiscard]] constexpr date_type& get() noexcept {
+        return value;
+    }
+
+    constexpr operator date_type const&() const noexcept {
+        return value;
+    }
+    constexpr operator date_type&() noexcept {
+        return value;
+    }
+};
+
+template <>
+struct base<std::optional<date_type>> : column_field_tag {
+    using value_type = std::optional<date_type>;
+
+    std::optional<date_type> value{};
+
+    constexpr base() = default;
+    constexpr base(std::nullopt_t) noexcept : value(std::nullopt) {
+    }
+    base(std::chrono::sys_days d) noexcept : value(date_type{d}) {
+    }
+    base(date_type v) noexcept : value(std::move(v)) {
+    }
+    base(std::optional<date_type> v) noexcept : value(std::move(v)) {
+    }
+
+    constexpr base& operator=(std::nullopt_t) noexcept {
+        value = std::nullopt;
+        return *this;
+    }
+    constexpr base& operator=(std::chrono::sys_days d) noexcept {
+        value = date_type{d};
+        return *this;
+    }
+    constexpr base& operator=(date_type v) noexcept {
+        value = std::move(v);
+        return *this;
+    }
+    constexpr base& operator=(std::optional<date_type> v) noexcept {
+        value = std::move(v);
+        return *this;
+    }
+
+    [[nodiscard]] constexpr std::optional<date_type> const& get() const noexcept {
+        return value;
+    }
+    [[nodiscard]] constexpr std::optional<date_type>& get() noexcept {
+        return value;
+    }
+
+    constexpr operator std::optional<date_type> const&() const noexcept {
+        return value;
+    }
+    constexpr operator std::optional<date_type>&() noexcept {
+        return value;
+    }
+};
+
 }  // namespace column_field_detail
 
 }  // namespace ds_mysql

lib/include/ds_mysql/schema_generator.hpp

@@ -96,6 +96,8 @@ struct sql_type_name {
                 } else {
                     return "TIME(" + std::to_string(base_type::column_fsp) + ")";
                 }
+            } else if constexpr (is_date_type_v<base_type>) {
+                return "DATE";
             } else {
                 static_assert(false,
                               "Unsupported type for SQL mapping. Supported: uint32_t, int32_t, uint64_t, "
@@ -105,7 +107,7 @@ struct sql_type_name {
                               "bool, varchar_type<N>, text_type (TEXT), "
                               "mediumtext_type (MEDIUMTEXT, MySQL), longtext_type (LONGTEXT, MySQL), "
                               "std::chrono::system_clock::time_point, datetime_type<Fsp>, timestamp_type<Fsp>, "
-                              "time_type<Fsp>, and their std::optional variants");
+                              "time_type<Fsp>, date_type, and their std::optional variants");
             }
         }  // end else (not ColumnFieldType)
     }
@@ -213,6 +215,10 @@ namespace sql_type_format {
     return "TIME(" + std::to_string(fractional_second_precision) + ")";
 }
 
+[[nodiscard]] inline std::string date_type() {
+    return "DATE";
+}
+
 }  // namespace sql_type_format
 
 // ===================================================================

lib/include/ds_mysql/sql_core.hpp

@@ -235,6 +235,8 @@ template <typename T>
         return format_datetime(v);
     } else if constexpr (is_time_type_v<T>) {
         return format_time(v.duration(), v.fractional_second_precision());
+    } else if constexpr (is_date_type_v<T>) {
+        return std::format("'{:%Y-%m-%d}'", v.days());
     } else if constexpr (std::same_as<T, bool>) {
         return v ? "1" : "0";
     } else if constexpr (is_formatted_numeric_type_v<T>) {
@@ -250,7 +252,7 @@ template <typename T>
     } else {
         static_assert(false,
                       "to_sql_value: unsupported type. "
-                      "Supported: column_field<T>, optional<T>, datetime_type, timestamp_type, bool, "
+                      "Supported: column_field<T>, optional<T>, datetime_type, timestamp_type, date_type, bool, "
                       "integral types, floating-point types, float_type<P,S>, double_type<P,S>, "
                       "decimal_type<P,S>, varchar_type<N>, text_type, std::string, "
                       "std::chrono::system_clock::time_point, time_type");
@@ -265,7 +267,7 @@ template <typename T>
 // ===================================================================
 template <typename T>
 concept SqlValue =
-    ColumnFieldType<T> || is_optional_v<T> || is_datetime_type_v<T> || is_timestamp_type_v<T> ||
+    ColumnFieldType<T> || is_optional_v<T> || is_datetime_type_v<T> || is_timestamp_type_v<T> || is_date_type_v<T> ||
     std::same_as<T, std::chrono::system_clock::time_point> || is_time_type_v<T> || std::same_as<T, bool> ||
     std::integral<T> || std::floating_point<T> || is_formatted_numeric_type_v<T> || is_varchar_type_v<T> ||
     is_text_type_v<T> || std::same_as<T, std::string>;

lib/include/ds_mysql/sql_dql.hpp

@@ -2892,6 +2892,14 @@ T from_mysql_value_nonnull(std::string_view sv) {
         std::tm tm{};
         ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
         return std::chrono::system_clock::from_time_t(std::mktime(&tm));
+    } else if constexpr (is_date_type_v<T>) {
+        std::istringstream ss{std::string{sv}};
+        std::tm tm{};
+        ss >> std::get_time(&tm, "%Y-%m-%d");
+        tm.tm_hour = 0;
+        tm.tm_min = 0;
+        tm.tm_sec = 0;
+        return T{std::chrono::floor<std::chrono::days>(std::chrono::system_clock::from_time_t(std::mktime(&tm)))};
     } else if constexpr (is_time_type_v<T>) {
         bool const negative = !sv.empty() && sv[0] == '-';
         std::string_view const s = negative ? sv.substr(1) : sv;
@@ -2918,7 +2926,7 @@ T from_mysql_value_nonnull(std::string_view sv) {
                       "Unsupported type for MySQL deserialization. "
                       "Supported: uint32_t, int32_t, uint64_t, int64_t, float, double, float_type<P,S>, "
                       "double_type<P,S>, decimal_type<P,S>, bool, std::string, varchar_type<N>, text_type, "
-                      "std::chrono::system_clock::time_point (for DATETIME/TIMESTAMP), time_type, "
+                      "std::chrono::system_clock::time_point (for DATETIME/TIMESTAMP), date_type, time_type, "
                       "and their std::optional variants.");
     }
 }

lib/include/ds_mysql/sql_temporal.hpp

@@ -103,6 +103,21 @@ class time_type {
     uint32_t fractional_second_precision_;
 };
 
+class date_type {
+public:
+    date_type() noexcept : days_() {
+    }
+    explicit date_type(std::chrono::sys_days d) noexcept : days_(d) {
+    }
+
+    [[nodiscard]] std::chrono::sys_days days() const noexcept {
+        return days_;
+    }
+
+private:
+    std::chrono::sys_days days_{};
+};
+
 using datetime_type_default = datetime_type<>;
 using timestamp_type_default = timestamp_type<>;
 using time_type_default = time_type<>;
@@ -132,4 +147,11 @@ struct is_time_type<time_type<Fsp>> : std::true_type {};
 template <typename T>
 inline constexpr bool is_time_type_v = is_time_type<T>::value;
 
+template <typename T>
+struct is_date_type : std::false_type {};
+template <>
+struct is_date_type<date_type> : std::true_type {};
+template <typename T>
+inline constexpr bool is_date_type_v = is_date_type<T>::value;
+
 }  // namespace ds_mysql

tests/unit/test_ddl.cpp

@@ -98,6 +98,12 @@ struct time_table {
     COLUMN_FIELD(end_time, std::optional<time_type<>>)
 };
 
+struct date_table {
+    COLUMN_FIELD(id, uint32_t)
+    COLUMN_FIELD(birth_date, date_type)
+    COLUMN_FIELD(expiry_date, std::optional<date_type>)
+};
+
 struct fsp_temporal_table {
     COLUMN_FIELD(id, uint32_t)
     COLUMN_FIELD(created_at, datetime_type<6>)
@@ -368,6 +374,17 @@ suite<"DDL"> ddl_suite = [] {
             << sql;
     };
 
+    "create_table date type - emits DATE definitions"_test = [] {
+        auto const sql = create_table(date_table{}).build_sql();
+        expect(sql ==
+               "CREATE TABLE date_table (\n"
+               "    id INT UNSIGNED NOT NULL,\n"
+               "    birth_date DATE NOT NULL,\n"
+               "    expiry_date DATE\n"
+               ");\n"s)
+            << sql;
+    };
+
     "sql_type_for - templated temporal types embed FSP in the type string"_test = [] {
         expect(sql_type_for<datetime_type<0>>() == "DATETIME"s);
         expect(sql_type_for<datetime_type<3>>() == "DATETIME(3)"s);
@@ -381,9 +398,12 @@ suite<"DDL"> ddl_suite = [] {
         expect(sql_type_for<time_type<3>>() == "TIME(3)"s);
         expect(sql_type_for<time_type<6>>() == "TIME(6)"s);
 
-        // std::optional wrappers preserve the FSP
+        expect(sql_type_for<date_type>() == "DATE"s);
+
+        // std::optional wrappers preserve the type
         expect(sql_type_for<std::optional<datetime_type<6>>>() == "DATETIME(6)"s);
         expect(sql_type_for<std::optional<time_type<4>>>() == "TIME(4)"s);
+        expect(sql_type_for<std::optional<date_type>>() == "DATE"s);
     };
 
     "create_table with templated temporal FSP columns - emits types with precision"_test = [] {

tests/unit/test_dml.cpp

@@ -199,6 +199,27 @@ suite<"DML"> dml_suite = [] {
         expect(t5.duration() == microseconds{(838 * 3600LL + 59 * 60LL + 59LL) * 1000000LL});
     };
 
+    "date_type serialization formats as YYYY-MM-DD"_test = [] {
+        using namespace std::chrono;
+        auto const d1 = date_type{sys_days{year{2024} / January / 15}};
+        expect(sql_detail::to_sql_value(d1) == "'2024-01-15'"s);
+
+        auto const d2 = date_type{sys_days{year{1999} / December / 31}};
+        expect(sql_detail::to_sql_value(d2) == "'1999-12-31'"s);
+
+        // Default-constructed date_type → epoch
+        expect(sql_detail::to_sql_value(date_type{}) == "'1970-01-01'"s);
+    };
+
+    "date_type deserialization parses MySQL DATE strings correctly"_test = [] {
+        using namespace std::chrono;
+        auto const d1 = ::ds_mysql::detail::from_mysql_value_nonnull<date_type>("2024-01-15");
+        expect(d1.days() == sys_days{year{2024} / January / 15});
+
+        auto const d2 = ::ds_mysql::detail::from_mysql_value_nonnull<date_type>("1999-12-31");
+        expect(d2.days() == sys_days{year{1999} / December / 31});
+    };
+
     "formatted numeric wrapper types serialize and deserialize like their underlying values"_test = [] {
         expect(sql_type_for<float_type<>>() == "FLOAT"s);
         expect(sql_type_for<float_type<12, 4>>() == "FLOAT(12,4)"s);