Replace tag-based column_field with fixed_string NTTP design

Author: Pierre-Luc Gagné

README.md

@@ -22,34 +22,21 @@ DSMySQL provides a **header-only** library for building type-safe SQL queries an
 
 using namespace ds_mysql;
 
-// 1. Define your table as a C++ struct
+// 1. Define your table as a C++ struct.
+//    Each field is a type alias for column_field<"name", ValueType>.
+//    The string literal is the SQL column name — no tag structs needed.
 struct product {
-    struct id_tag {};
-    struct sku_tag {};
-    struct name_tag {};
-    struct price_tag {};
-
-    using id    = column_field<id_tag,    uint32_t>;
-    using sku   = column_field<sku_tag,   varchar_field<64>>;
-    using name  = column_field<name_tag,  varchar_field<255>>;
-    using price = column_field<price_tag, double>;
+    using id    = column_field<"id",    uint32_t>;
+    using sku   = column_field<"sku",   varchar_field<64>>;
+    using name  = column_field<"name",  varchar_field<255>>;
+    using price = column_field<"price", double>;
 
     id    id_;
     sku   sku_;
     name  name_;
     price price_;
 };
 
-// Alternatively, use the COLUMN_FIELD macro to reduce boilerplate:
-struct product_v2 {
-    COLUMN_FIELD(id,    uint32_t);
-    COLUMN_FIELD(sku,   varchar_field<64>);
-    COLUMN_FIELD(name,  varchar_field<255>);
-    COLUMN_FIELD(price, double);
-};
-// Each COLUMN_FIELD(tag, type) expands to: a tag struct, a type alias, and a member variable.
-// The two definitions are equivalent and produce the same SQL schema.
-
 // 2. Connect and query
 auto db = mysql_database::connect(mysql_config{
     host_name{"127.0.0.1"},

examples/basic_query.cpp

@@ -35,36 +35,28 @@ constexpr unsigned int port = 3306;
 // ===================================================================
 // Define a typed table struct.
 //
-// Each field is a type alias for column_field<Tag, ValueType>.
-// The tag name drives the SQL column name: id_tag → "id".
+// Each field is a type alias for column_field<"name", ValueType>.
+// The string literal is the SQL column name.
 // Member variables use a trailing underscore to avoid shadowing the
 // column-descriptor aliases.
 // ===================================================================
 
 struct product {
-    struct id_tag {};
-    struct sku_tag {};
-    struct name_tag {};
-    struct price_tag {};
-    struct stock_tag {};
-    struct description_tag {};
-    struct created_at_tag {};
-
-    using id = ds_mysql::column_field<id_tag, uint32_t>;
-    using sku = ds_mysql::column_field<sku_tag, ds_mysql::varchar_field<64>>;
-    using name = ds_mysql::column_field<name_tag, ds_mysql::varchar_field<255>>;
-    using price = ds_mysql::column_field<price_tag, double>;
-    using stock = ds_mysql::column_field<stock_tag, uint32_t>;
-    using description = ds_mysql::column_field<description_tag, std::optional<ds_mysql::varchar_field<512>>>;
-    using created_at = ds_mysql::column_field<created_at_tag, ds_mysql::sql_datetime>;
-
-    id id_;
-    sku sku_;
-    name name_;
-    price price_;
-    stock stock_;
+    using id          = ds_mysql::column_field<"id",          uint32_t>;
+    using sku         = ds_mysql::column_field<"sku",         ds_mysql::varchar_field<64>>;
+    using name        = ds_mysql::column_field<"name",        ds_mysql::varchar_field<255>>;
+    using price       = ds_mysql::column_field<"price",       double>;
+    using stock       = ds_mysql::column_field<"stock",       uint32_t>;
+    using description = ds_mysql::column_field<"description", std::optional<ds_mysql::varchar_field<512>>>;
+    using created_at  = ds_mysql::column_field<"created_at",  ds_mysql::sql_datetime>;
+
+    id          id_;
+    sku         sku_;
+    name        name_;
+    price       price_;
+    stock       stock_;
     description description_;
-    created_at created_at_;
+    created_at  created_at_;
 };
 
 // ===================================================================

examples/schema_generation.cpp

@@ -21,17 +21,11 @@
 // ===================================================================
 
 struct user {
-    struct id_tag {};
-    struct username_tag {};
-    struct email_tag {};
-    struct is_active_tag {};
-    struct created_at_tag {};
-
-    using id = ds_mysql::column_field<id_tag, uint32_t>;
-    using username = ds_mysql::column_field<username_tag, ds_mysql::varchar_field<64>>;
-    using email = ds_mysql::column_field<email_tag, ds_mysql::varchar_field<255>>;
-    using is_active = ds_mysql::column_field<is_active_tag, bool>;
-    using created_at = ds_mysql::column_field<created_at_tag, ds_mysql::sql_datetime>;
+    using id         = ds_mysql::column_field<"id",         uint32_t>;
+    using username   = ds_mysql::column_field<"username",   ds_mysql::varchar_field<64>>;
+    using email      = ds_mysql::column_field<"email",      ds_mysql::varchar_field<255>>;
+    using is_active  = ds_mysql::column_field<"is_active",  bool>;
+    using created_at = ds_mysql::column_field<"created_at", ds_mysql::sql_datetime>;
 
     id         id_;
     username   username_;
@@ -45,12 +39,12 @@ struct user {
 // ===================================================================
 
 struct order_row {
-    struct order_id_tag {};          using id         = ds_mysql::column_field<order_id_tag,          uint32_t>;
-    struct user_id_tag {};           using user_id    = ds_mysql::column_field<user_id_tag,           uint32_t>;
-    struct amount_tag {};            using amount     = ds_mysql::column_field<amount_tag,            double>;
-    struct fee_tag {};               using fee        = ds_mysql::column_field<fee_tag,               std::optional<double>>;
-    struct status_tag {};            using status     = ds_mysql::column_field<status_tag,            ds_mysql::varchar_field<32>>;
-    struct order_created_at_tag {};  using created_at = ds_mysql::column_field<order_created_at_tag, ds_mysql::sql_datetime>;
+    using id         = ds_mysql::column_field<"order_id",         uint32_t>;
+    using user_id    = ds_mysql::column_field<"user_id",          uint32_t>;
+    using amount     = ds_mysql::column_field<"amount",           double>;
+    using fee        = ds_mysql::column_field<"fee",              std::optional<double>>;
+    using status     = ds_mysql::column_field<"status",           ds_mysql::varchar_field<32>>;
+    using created_at = ds_mysql::column_field<"order_created_at", ds_mysql::sql_datetime>;
 
     id         id_;
     user_id    user_id_;

lib/include/ds_mysql/column_field.hpp

@@ -8,7 +8,7 @@
 #include <type_traits>
 #include <utility>
 
-#include "ds_mysql/name_reflection.hpp"
+#include "ds_mysql/fixed_string.hpp"
 #include "ds_mysql/sql_temporal.hpp"
 #include "ds_mysql/varchar_field.hpp"
 
@@ -19,10 +19,10 @@ namespace ds_mysql {
  */
 struct column_field_tag {};
 
-// column_field<Tag, T> — the only user-facing form.
-// Tag determines the SQL column name (via tag_to_column_name); T is the stored value type.
-//   using id = column_field<struct id_tag, uint32_t>;
-template <typename Tag, typename T>
+// column_field<Name, T> — the only user-facing form.
+// Name is the SQL column name as a string literal; T is the stored value type.
+//   using id = column_field<"id", uint32_t>;
+template <fixed_string Name, typename T>
 struct column_field;
 
 // ===================================================================
@@ -451,61 +451,36 @@ struct base<std::optional<sql_timestamp>> : column_field_tag {
 }  // namespace column_field_detail
 
 // ===================================================================
-// column_field<Tag, T> — the only user-facing form
+// column_field<Name, T> — the only user-facing form
 // ===================================================================
 
 /**
- * column_field<Tag, T> — tagged column descriptor.
+ * column_field<Name, T> — named column descriptor.
  *
- * Tag determines the SQL column name (stripped of any trailing "_tag" suffix).
+ * Name is the SQL column name embedded directly as a string literal.
  * T is the stored value type. All constructors and operators are inherited
  * from the internal base type.
  *
- *   using id     = column_field<struct id_tag,     uint32_t>;
- *   using ticker = column_field<struct ticker_tag, varchar_field<32>>;
- *   using sector = column_field<struct sector_tag, std::optional<varchar_field<64>>>;
+ *   using id     = column_field<"id",     uint32_t>;
+ *   using ticker = column_field<"ticker", varchar_field<32>>;
+ *   using sector = column_field<"sector", std::optional<varchar_field<64>>>;
  *
  *   id     id_;
  *   ticker ticker_;
  *   sector sector_;
  *
  * SQL column names: "id", "ticker", "sector"
  */
-template <typename Tag, typename T>
+template <fixed_string Name, typename T>
 struct column_field : column_field_detail::base<T> {
-    using tag_type = Tag;
     using column_field_detail::base<T>::base;
     using column_field_detail::base<T>::operator=;
 
     [[nodiscard]] static constexpr std::string_view column_name() noexcept {
-        return detail::tag_to_column_name<Tag>();
+        return Name;
     }
 };
 
-// ===================================================================
-// COLUMN_FIELD convenience macro
-// ===================================================================
-
-/**
- * COLUMN_FIELD(tag, type) — declares a column field with a member variable.
- *
- * Expands to:
- *   struct tag_tag {};
- *   using tag = column_field<tag_tag, type>;
- *   tag tag_;
- *
- * Example (inside a struct/class body):
- *   COLUMN_FIELD(id,     uint32_t)
- *   COLUMN_FIELD(ticker, varchar_field<32>)
- *   COLUMN_FIELD(sector, std::optional<varchar_field<64>>)
- *
- * SQL column names: "id", "ticker", "sector"
- */
-#define COLUMN_FIELD(tag, type)                            \
-    struct tag##_tag {};                                   \
-    using tag = ::ds_mysql::column_field<tag##_tag, type>; \
-    tag tag##_
-
 // ===================================================================
 // ColumnFieldType concept
 // ===================================================================
@@ -514,8 +489,8 @@ struct column_field : column_field_detail::base<T> {
  * ColumnFieldType<T> — satisfied by any type that publicly derives from
  * column_field_tag and exposes a value_type alias.
  *
- * Only satisfied by the tagged form:
- *   using id = column_field<struct id_tag, uint32_t>;
+ * Only satisfied by the named form:
+ *   using id = column_field<"id", uint32_t>;
  */
 template <typename T>
 concept ColumnFieldType = std::derived_from<T, column_field_tag> && requires { typename T::value_type; };

lib/include/ds_mysql/fixed_string.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <string_view>
+
+namespace ds_mysql {
+
+/**
+ * fixed_string<N> — compile-time string literal for use as a non-type template parameter.
+ *
+ * Satisfies C++20 structural type requirements, enabling use as an NTTP:
+ *
+ *   template <fixed_string Name, typename T>
+ *   struct column_field { ... };
+ *
+ *   using id = column_field<"id", uint32_t>;
+ *
+ * The deduction guide allows the size to be inferred from a string literal:
+ *
+ *   fixed_string s{"hello"};  // fixed_string<6>
+ */
+template <std::size_t N>
+struct fixed_string {
+    char data[N]{};
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    consteval fixed_string(char const (&str)[N]) noexcept {
+        for (std::size_t i = 0; i < N; ++i)
+            data[i] = str[i];
+    }
+
+    [[nodiscard]] constexpr operator std::string_view() const noexcept {
+        return {data, N - 1};  // exclude null terminator
+    }
+
+    [[nodiscard]] constexpr std::string_view view() const noexcept {
+        return {data, N - 1};
+    }
+
+    template <std::size_t M>
+    [[nodiscard]] constexpr bool operator==(fixed_string<M> const& other) const noexcept {
+        if constexpr (N != M)
+            return false;
+        else {
+            for (std::size_t i = 0; i < N; ++i)
+                if (data[i] != other.data[i])
+                    return false;
+            return true;
+        }
+    }
+};
+
+template <std::size_t N>
+fixed_string(char const (&)[N]) -> fixed_string<N>;
+
+}  // namespace ds_mysql