Add tagged_column_field alias for tag-struct style without macros

Provides a third, macro-free way to define columns using a tag struct.
The SQL column name is derived at compile time from the tag type name
by stripping a trailing "_tag" suffix (if present):

    struct price_tag {};
    using price = tagged_column_field<price_tag, double>;
    price price_;

This is exactly equivalent to column_field<"price", double>.

Implementation:
- Add default constructor to fixed_string<N> so it can be constructed
  and filled character-by-character in consteval contexts
- Add detail::fixed_string_from_sv<N> consteval helper
- Add detail::column_name_from_tag<Tag>() consteval function that calls
  extract_type_name<Tag>() and strips the "_tag" suffix
- Add tagged_column_field<Tag, T> alias template in column_field.hpp
- Include name_reflection.hpp in column_field.hpp for extract_type_name
- Add static_assert and runtime tests in test_field_types.cpp
- Update README Quick Start to document all three styles

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Pierre-Luc Gagné

README.md

@@ -37,13 +37,20 @@ struct product {
     price price_;
 };
 
-// The COLUMN_FIELD(tag, type) macro is a one-liner convenience equivalent:
-// struct product {
-//     COLUMN_FIELD(id,    uint32_t)
-//     COLUMN_FIELD(sku,   varchar_field<64>)
-//     COLUMN_FIELD(name,  varchar_field<255>)
-//     COLUMN_FIELD(price, double)
-// };
+// Three equivalent styles — pick what suits your team:
+
+// a) Explicit string literal (recommended — column name is right there):
+//   using price = column_field<"price", double>;
+//   price price_;
+
+// b) Tag struct — no string literals, column name derived from tag type at
+//    compile time (trailing "_tag" suffix is stripped automatically):
+//   struct price_tag {};
+//   using price = tagged_column_field<price_tag, double>;
+//   price price_;
+
+// c) COLUMN_FIELD macro — one-liner shorthand for style (a):
+//   COLUMN_FIELD(price, double)
 
 // 2. Connect and query
 auto db = mysql_database::connect(mysql_config{

lib/include/ds_mysql/column_field.hpp

@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "ds_mysql/fixed_string.hpp"
+#include "ds_mysql/name_reflection.hpp"
 #include "ds_mysql/sql_temporal.hpp"
 #include "ds_mysql/varchar_field.hpp"
 
@@ -521,6 +522,68 @@ using unwrap_column_field_t = typename unwrap_column_field<T>::type;
 
 }  // namespace ds_mysql
 
+// ===================================================================
+// tagged_column_field — tag-struct convenience alias
+// ===================================================================
+
+namespace ds_mysql {
+
+namespace detail {
+
+/**
+ * Construct a fixed_string<N> from a string_view at compile time.
+ * N must equal sv.size() + 1 (to include the null terminator).
+ */
+template <std::size_t N>
+consteval fixed_string<N> fixed_string_from_sv(std::string_view sv) noexcept {
+    fixed_string<N> result{};
+    for (std::size_t i = 0; i + 1 < N; ++i)
+        result.data[i] = sv[i];
+    return result;
+}
+
+/**
+ * Derive the column name from a tag type at compile time.
+ * Strips a trailing "_tag" suffix if present, then returns a fixed_string.
+ *
+ * Examples:
+ *   column_name_from_tag<id_tag>()    →  fixed_string{"id"}
+ *   column_name_from_tag<price_tag>() →  fixed_string{"price"}
+ *   column_name_from_tag<foo>()       →  fixed_string{"foo"}   (no suffix)
+ */
+template <typename Tag>
+consteval auto column_name_from_tag() noexcept {
+    constexpr std::string_view full   = extract_type_name<Tag>();
+    constexpr std::string_view suffix = "_tag";
+    constexpr std::string_view name   = full.ends_with(suffix)
+                                            ? full.substr(0, full.size() - suffix.size())
+                                            : full;
+    return fixed_string_from_sv<name.size() + 1>(name);
+}
+
+}  // namespace detail
+
+/**
+ * tagged_column_field<Tag, T> — tag-struct alternative to column_field<"name", T>.
+ *
+ * Derive the SQL column name from a tag struct at compile time (stripping a
+ * trailing "_tag" suffix).  The result is an ordinary column_field, so it
+ * satisfies all the same concepts and works everywhere column_field does.
+ *
+ * Usage:
+ *   struct price_tag {};
+ *   using price = tagged_column_field<price_tag, double>;
+ *   price price_;
+ *
+ * This is exactly equivalent to:
+ *   using price = column_field<"price", double>;
+ *   price price_;
+ */
+template <typename Tag, typename T>
+using tagged_column_field = column_field<detail::column_name_from_tag<Tag>(), T>;
+
+}  // namespace ds_mysql
+
 /**
  * COLUMN_FIELD(tag, type) — convenience macro to declare a column field member.
  *

lib/include/ds_mysql/fixed_string.hpp

@@ -22,6 +22,8 @@ template <std::size_t N>
 struct fixed_string {
     char data[N]{};
 
+    constexpr fixed_string() noexcept = default;
+
     // NOLINTNEXTLINE(google-explicit-constructor)
     consteval fixed_string(char const (&str)[N]) noexcept {
         for (std::size_t i = 0; i < N; ++i)

tests/unit/test_field_types.cpp

@@ -157,9 +157,42 @@ suite<"varchar_field"> varchar_field_suite = [] {
 };
 
 // ===================================================================
-// column_field with std::string value type
+// tagged_column_field — tag-struct alias
 // ===================================================================
 
+namespace {
+struct price_tag {};
+struct order_id_tag {};
+struct no_suffix {};
+
+// With _tag suffix stripped:
+static_assert(std::is_same_v<tagged_column_field<price_tag, double>,
+                             column_field<"price", double>>);
+// Multi-word tag with _tag stripped:
+static_assert(std::is_same_v<tagged_column_field<order_id_tag, uint32_t>,
+                             column_field<"order_id", uint32_t>>);
+// Tag without _tag suffix — name kept as-is:
+static_assert(std::is_same_v<tagged_column_field<no_suffix, int>,
+                             column_field<"no_suffix", int>>);
+}  // namespace
+
+suite<"tagged_column_field"> tagged_column_field_suite = [] {
+    "tagged_column_field column_name matches derived tag name"_test = [] {
+        using price = tagged_column_field<price_tag, double>;
+        expect(price::column_name() == "price"sv);
+    };
+
+    "tagged_column_field with multi-word tag"_test = [] {
+        using order_id = tagged_column_field<order_id_tag, uint32_t>;
+        expect(order_id::column_name() == "order_id"sv);
+    };
+
+    "tagged_column_field without _tag suffix keeps full name"_test = [] {
+        using ns = tagged_column_field<no_suffix, int>;
+        expect(ns::column_name() == "no_suffix"sv);
+    };
+};
+
 namespace {
 using string_column = column_field<"string_col", std::string>;
 }  // namespace