Rename SQL wrapper types and headers

Author: Pierre-Luc Gagné

CHANGELOG.md

@@ -45,7 +45,7 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - Boost.PFR powered compile-time reflection — no macros required for reflection.
 - `COLUMN_FIELD` macro for ergonomic per-table, per-column unique type definitions.
 - Strong-type wrappers: `host_name`, `database_name`, `port_number`, `user_name`,
-  `user_password`, `varchar_field<N>`, `text_field`.
+  `user_password`, `varchar_type<N>`, `text_type`.
 - `std::optional<T>` support mapping to nullable SQL columns.
 - `std::expected`-based error handling throughout — no exceptions in the query path.
 - SQL extension helpers: `ROUND`, `FORMAT`, `COALESCE`, `IFNULL`, `DATE_FORMAT`,

README.md

@@ -12,7 +12,7 @@ DSMySQL provides a **header-only** library for building type-safe SQL queries an
 - **Schema validation** — verify a live database schema against your C++ definitions
 - **C++23** — uses `std::expected`, concepts, ranges, and structured bindings
 - **Zero-overhead abstractions** — all query building happens at compile time
-- **Strong types** — `host_name`, `database_name`, `port_number`, `varchar_field<N>`, etc.
+- **Strong types** — `host_name`, `database_name`, `port_number`, `varchar_type<N>`, etc.
 - **Optional support** — `std::optional<T>` maps to nullable SQL columns automatically
 - **Temporal types** — `datetime_type`, `timestamp_type`, and `time_type` map to MySQL
   `DATETIME`, `TIMESTAMP`, and `TIME`; `sql_now` sentinel resolves to `NOW()`
@@ -31,8 +31,8 @@ using namespace ds_mysql;
 //    one-liner that generates a nested tag struct, a type alias, and a member.
 struct product {
     COLUMN_FIELD(id,    uint32_t)
-    COLUMN_FIELD(sku,   varchar_field<64>)
-    COLUMN_FIELD(name,  varchar_field<255>)
+    COLUMN_FIELD(sku,   varchar_type<64>)
+    COLUMN_FIELD(name,  varchar_type<255>)
     COLUMN_FIELD(price, double)
 };
 
@@ -77,7 +77,7 @@ auto db = mysql_database::connect(mysql_config{
 // CREATE TABLE IF NOT EXISTS product (...)
 db.execute(create_table<product>().if_not_exists());
 
-// Type-safe SELECT: returns std::expected<std::vector<std::tuple<uint32_t, varchar_field<255>>>, std::string>
+// Type-safe SELECT: returns std::expected<std::vector<std::tuple<uint32_t, varchar_type<255>>>, std::string>
 auto rows = db.query(select<product::id, product::name>()
                          .from<product>()
                          .where(product::price{9.99})

docs/QUICKREF.md

@@ -57,7 +57,7 @@ DSMySQL/
 | `ds_mysql/column_field.hpp` | Typed column descriptors |
 | `ds_mysql/schema_generator.hpp` | Schema generation |
 | `ds_mysql/config.hpp` | Connection configuration |
-| `ds_mysql/varchar_field.hpp` | Fixed-length string type |
+| `ds_mysql/sql_varchar.hpp` | Fixed-length string type |
 
 ## Environment Variables (Integration Tests)
 

examples/basic_query.cpp

@@ -43,11 +43,11 @@ constexpr unsigned int port = 3306;
 
 struct product {
     COLUMN_FIELD(id, uint32_t)
-    COLUMN_FIELD(sku, ds_mysql::varchar_field<64>)
-    COLUMN_FIELD(name, ds_mysql::varchar_field<255>)
+    COLUMN_FIELD(sku, ds_mysql::varchar_type<64>)
+    COLUMN_FIELD(name, ds_mysql::varchar_type<255>)
     COLUMN_FIELD(price, double)
     COLUMN_FIELD(stock, uint32_t)
-    COLUMN_FIELD(description, std::optional<ds_mysql::varchar_field<512>>)
+    COLUMN_FIELD(description, std::optional<ds_mysql::varchar_type<512>>)
     COLUMN_FIELD(created_at, ds_mysql::datetime_type<>)
 };
 

examples/schema_generation.cpp

@@ -22,8 +22,8 @@
 
 struct user {
     COLUMN_FIELD(id, uint32_t)
-    COLUMN_FIELD(username, ds_mysql::varchar_field<64>)
-    COLUMN_FIELD(email, ds_mysql::varchar_field<255>)
+    COLUMN_FIELD(username, ds_mysql::varchar_type<64>)
+    COLUMN_FIELD(email, ds_mysql::varchar_type<255>)
     COLUMN_FIELD(is_active, bool)
     COLUMN_FIELD(created_at, ds_mysql::datetime_type<>)
 };
@@ -40,7 +40,7 @@ struct order_row {
     COLUMN_FIELD(user_id, uint32_t)
     COLUMN_FIELD(amount, double)
     COLUMN_FIELD(fee, std::optional<double>)
-    COLUMN_FIELD(status, ds_mysql::varchar_field<32>)
+    COLUMN_FIELD(status, ds_mysql::varchar_type<32>)
 
     struct order_created_at_tag {};
     using created_at = ds_mysql::tagged_column_field<order_created_at_tag, ds_mysql::datetime_type<>>;

examples/tables_with_constraints.cpp

@@ -23,11 +23,11 @@
 struct symbol {
     COLUMN_FIELD(id, int32_t)
     COLUMN_FIELD(exchange_id, std::optional<int32_t>)
-    COLUMN_FIELD(ticker, ds_mysql::varchar_field<32>)
-    COLUMN_FIELD(instrument, ds_mysql::varchar_field<64>)
-    COLUMN_FIELD(name, std::optional<ds_mysql::varchar_field<255>>)
-    COLUMN_FIELD(sector, std::optional<ds_mysql::varchar_field<255>>)
-    COLUMN_FIELD(currency, std::optional<ds_mysql::varchar_field<32>>)
+    COLUMN_FIELD(ticker, ds_mysql::varchar_type<32>)
+    COLUMN_FIELD(instrument, ds_mysql::varchar_type<64>)
+    COLUMN_FIELD(name, std::optional<ds_mysql::varchar_type<255>>)
+    COLUMN_FIELD(sector, std::optional<ds_mysql::varchar_type<255>>)
+    COLUMN_FIELD(currency, std::optional<ds_mysql::varchar_type<32>>)
     COLUMN_FIELD(created_date, ds_mysql::datetime_type<>)
     COLUMN_FIELD(last_updated_date, ds_mysql::datetime_type<>)
 };

lib/include/ds_mysql/column_field.hpp

@@ -10,9 +10,9 @@
 
 #include "ds_mysql/fixed_string.hpp"
 #include "ds_mysql/name_reflection.hpp"
-#include "ds_mysql/numeric_field.hpp"
+#include "ds_mysql/sql_numeric.hpp"
 #include "ds_mysql/sql_temporal.hpp"
-#include "ds_mysql/varchar_field.hpp"
+#include "ds_mysql/sql_varchar.hpp"
 
 namespace ds_mysql {
 
@@ -316,42 +316,42 @@ struct base<std::string> : column_field_tag {
 };
 
 template <std::size_t N>
-struct base<varchar_field<N>> : column_field_tag {
-    using value_type = varchar_field<N>;
+struct base<varchar_type<N>> : column_field_tag {
+    using value_type = varchar_type<N>;
 
-    varchar_field<N> value{};
+    varchar_type<N> value{};
 
     constexpr base() = default;
-    constexpr base(varchar_field<N> v) noexcept(std::is_nothrow_move_constructible_v<varchar_field<N>>)
+    constexpr base(varchar_type<N> v) noexcept(std::is_nothrow_move_constructible_v<varchar_type<N>>)
         : value(std::move(v)) {
     }
 
     template <std::size_t M>
-    constexpr base(char const (&v)[M]) noexcept(std::is_nothrow_move_constructible_v<varchar_field<N>>) : value(v) {
+    constexpr base(char const (&v)[M]) noexcept(std::is_nothrow_move_constructible_v<varchar_type<N>>) : value(v) {
     }
 
-    constexpr base& operator=(varchar_field<N> v) noexcept(std::is_nothrow_move_assignable_v<varchar_field<N>>) {
+    constexpr base& operator=(varchar_type<N> v) noexcept(std::is_nothrow_move_assignable_v<varchar_type<N>>) {
         value = std::move(v);
         return *this;
     }
 
     template <std::size_t M>
-    constexpr base& operator=(char const (&v)[M]) noexcept(std::is_nothrow_move_assignable_v<varchar_field<N>>) {
+    constexpr base& operator=(char const (&v)[M]) noexcept(std::is_nothrow_move_assignable_v<varchar_type<N>>) {
         value = v;
         return *this;
     }
 
-    [[nodiscard]] constexpr varchar_field<N> const& get() const noexcept {
+    [[nodiscard]] constexpr varchar_type<N> const& get() const noexcept {
         return value;
     }
-    [[nodiscard]] constexpr varchar_field<N>& get() noexcept {
+    [[nodiscard]] constexpr varchar_type<N>& get() noexcept {
         return value;
     }
 
-    constexpr operator varchar_field<N> const&() const noexcept {
+    constexpr operator varchar_type<N> const&() const noexcept {
         return value;
     }
-    constexpr operator varchar_field<N>&() noexcept {
+    constexpr operator varchar_type<N>&() noexcept {
         return value;
     }
     constexpr operator std::string_view() const noexcept {
@@ -360,57 +360,57 @@ struct base<varchar_field<N>> : column_field_tag {
 };
 
 template <std::size_t N>
-struct base<std::optional<varchar_field<N>>> : column_field_tag {
-    using value_type = std::optional<varchar_field<N>>;
+struct base<std::optional<varchar_type<N>>> : column_field_tag {
+    using value_type = std::optional<varchar_type<N>>;
 
-    std::optional<varchar_field<N>> value{};
+    std::optional<varchar_type<N>> value{};
 
     constexpr base() = default;
     constexpr base(std::nullopt_t) noexcept : value(std::nullopt) {
     }
-    constexpr base(varchar_field<N> v) noexcept(std::is_nothrow_move_constructible_v<varchar_field<N>>)
+    constexpr base(varchar_type<N> v) noexcept(std::is_nothrow_move_constructible_v<varchar_type<N>>)
         : value(std::move(v)) {
     }
-    constexpr base(std::optional<varchar_field<N>> v) noexcept(
-        std::is_nothrow_move_constructible_v<std::optional<varchar_field<N>>>)
+    constexpr base(std::optional<varchar_type<N>> v) noexcept(
+        std::is_nothrow_move_constructible_v<std::optional<varchar_type<N>>>)
         : value(std::move(v)) {
     }
 
     template <std::size_t M>
-    constexpr base(char const (&v)[M]) noexcept(std::is_nothrow_move_constructible_v<varchar_field<N>>) : value(v) {
+    constexpr base(char const (&v)[M]) noexcept(std::is_nothrow_move_constructible_v<varchar_type<N>>) : value(v) {
     }
 
     constexpr base& operator=(std::nullopt_t) noexcept {
         value = std::nullopt;
         return *this;
     }
-    constexpr base& operator=(varchar_field<N> v) noexcept(std::is_nothrow_move_assignable_v<varchar_field<N>>) {
+    constexpr base& operator=(varchar_type<N> v) noexcept(std::is_nothrow_move_assignable_v<varchar_type<N>>) {
         value = std::move(v);
         return *this;
     }
-    constexpr base& operator=(std::optional<varchar_field<N>> v) noexcept(
-        std::is_nothrow_move_assignable_v<std::optional<varchar_field<N>>>) {
+    constexpr base& operator=(std::optional<varchar_type<N>> v) noexcept(
+        std::is_nothrow_move_assignable_v<std::optional<varchar_type<N>>>) {
         value = std::move(v);
         return *this;
     }
 
     template <std::size_t M>
-    constexpr base& operator=(char const (&v)[M]) noexcept(std::is_nothrow_move_assignable_v<varchar_field<N>>) {
-        value = varchar_field<N>{v};
+    constexpr base& operator=(char const (&v)[M]) noexcept(std::is_nothrow_move_assignable_v<varchar_type<N>>) {
+        value = varchar_type<N>{v};
         return *this;
     }
 
-    [[nodiscard]] constexpr std::optional<varchar_field<N>> const& get() const noexcept {
+    [[nodiscard]] constexpr std::optional<varchar_type<N>> const& get() const noexcept {
         return value;
     }
-    [[nodiscard]] constexpr std::optional<varchar_field<N>>& get() noexcept {
+    [[nodiscard]] constexpr std::optional<varchar_type<N>>& get() noexcept {
         return value;
     }
 
-    constexpr operator std::optional<varchar_field<N>> const&() const noexcept {
+    constexpr operator std::optional<varchar_type<N>> const&() const noexcept {
         return value;
     }
-    constexpr operator std::optional<varchar_field<N>>&() noexcept {
+    constexpr operator std::optional<varchar_type<N>>&() noexcept {
         return value;
     }
 };
@@ -622,8 +622,8 @@ struct base<std::optional<timestamp_type<Fsp>>> : column_field_tag {
  * internal base type.
  *
  *   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>>>;
+ *   using ticker = column_field<"ticker", varchar_type<32>>;
+ *   using sector = column_field<"sector", std::optional<varchar_type<64>>>;
  *
  *   id     id_;
  *   ticker ticker_;

lib/include/ds_mysql/ds_mysql.hpp

@@ -9,7 +9,7 @@
 //   metadata.hpp        — runtime metadata helpers (column info, schema introspection)
 //
 // All other library headers (column_field, schema_generator, sql_identifiers,
-// sql_temporal, varchar_field, text_field, config, credentials, …) are
+// sql_temporal, sql_varchar, sql_text, config, credentials, …) are
 // pulled in transitively by the four headers above.
 
 #include "ds_mysql/database.hpp"

lib/include/ds_mysql/schema_generator.hpp

@@ -13,9 +13,10 @@
 #include "ds_mysql/column_field.hpp"
 #include "ds_mysql/name_reflection.hpp"
 #include "ds_mysql/sql_identifiers.hpp"
+#include "ds_mysql/sql_numeric.hpp"
 #include "ds_mysql/sql_temporal.hpp"
-#include "ds_mysql/text_field.hpp"
-#include "ds_mysql/varchar_field.hpp"
+#include "ds_mysql/sql_text.hpp"
+#include "ds_mysql/sql_varchar.hpp"
 
 namespace ds_mysql {
 
@@ -74,17 +75,8 @@ struct sql_type_name {
                 return "DOUBLE";
             } else if constexpr (std::same_as<base_type, bool>) {
                 return "BOOLEAN";
-            } else if constexpr (is_varchar_field_v<base_type>) {
-                return "VARCHAR(" + std::to_string(is_varchar_field<base_type>::capacity) + ")";
-            } else if constexpr (is_text_field_v<base_type>) {
-                constexpr auto kind = is_text_field<base_type>::kind;
-                if constexpr (kind == text_kind::mediumtext) {
-                    return "MEDIUMTEXT";
-                } else if constexpr (kind == text_kind::longtext) {
-                    return "LONGTEXT";
-                } else {
-                    return "TEXT";
-                }
+            } else if constexpr (is_varchar_type_v<base_type> || is_text_type_v<base_type>) {
+                return base_type::sql_type();
             } else if constexpr (std::same_as<base_type, std::chrono::system_clock::time_point>) {
                 return "DATETIME";
             } else if constexpr (is_datetime_type_v<base_type>) {
@@ -109,8 +101,8 @@ struct sql_type_name {
                 static_assert(false,
                               "Unsupported type for SQL mapping. Supported: uint32_t, int32_t, uint64_t, "
                               "int64_t, float, double, float_type<P,S>, double_type<P,S>, decimal_type<P,S>, "
-                              "bool, varchar_field<N>, text_field (TEXT), "
-                              "mediumtext_field (MEDIUMTEXT, MySQL), longtext_field (LONGTEXT, MySQL), "
+                              "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");
             }

lib/include/ds_mysql/sql.hpp

@@ -25,7 +25,7 @@
 #include "ds_mysql/name_reflection.hpp"
 #include "ds_mysql/schema_generator.hpp"
 #include "ds_mysql/sql_temporal.hpp"
-#include "ds_mysql/varchar_field.hpp"
+#include "ds_mysql/sql_varchar.hpp"
 
 namespace ds_mysql {
 
@@ -236,7 +236,7 @@ inline std::string format_time(std::chrono::microseconds dur, uint32_t fractiona
  * to_sql_value — convert a typed C++ value to its SQL literal representation.
  *
  * Handles: column_field<T> wrappers, std::optional<T>, datetime_type, bool,
- * integral types, floating-point types, varchar_field<N>, std::string, and
+ * integral types, floating-point types, varchar_type<N>, text_type, std::string, and
  * std::chrono::system_clock::time_point.
  */
 template <typename T>
@@ -278,7 +278,7 @@ std::string to_sql_value(T const& v) {
         return std::to_string(v);
     } else if constexpr (std::floating_point<T>) {
         return std::to_string(v);
-    } else if constexpr (is_varchar_field_v<T>) {
+    } else if constexpr (is_varchar_type_v<T> || is_text_type_v<T>) {
         return "'" + escape_sql_string(v.view()) + "'";
     } else if constexpr (std::same_as<T, std::string>) {
         return "'" + escape_sql_string(v) + "'";
@@ -287,7 +287,7 @@ std::string to_sql_value(T const& v) {
                       "to_sql_value: unsupported type. "
                       "Supported: column_field<T>, optional<T>, datetime_type, timestamp_type, bool, "
                       "integral types, floating-point types, float_type<P,S>, double_type<P,S>, "
-                      "decimal_type<P,S>, varchar_field<N>, std::string, "
+                      "decimal_type<P,S>, varchar_type<N>, text_type, std::string, "
                       "std::chrono::system_clock::time_point, time_type");
     }
 }
@@ -299,10 +299,11 @@ std::string to_sql_value(T const& v) {
 // Constrains template parameters that must produce a valid SQL literal.
 // ===================================================================
 template <typename T>
-concept SqlValue = ColumnFieldType<T> || is_optional_v<T> || is_datetime_type_v<T> || is_timestamp_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_field_v<T> || std::same_as<T, std::string>;
+concept SqlValue =
+    ColumnFieldType<T> || is_optional_v<T> || is_datetime_type_v<T> || is_timestamp_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>;
 
 // ===================================================================
 // where_condition — a typed SQL WHERE fragment
@@ -655,7 +656,7 @@ struct col_expr {
     using value_type = typename Col::value_type;
 
     // Operators accept value_type directly; callers must construct explicitly
-    // (e.g. col_ref<trade::code> == varchar_field<32>{"AAPL"}).
+    // (e.g. col_ref<trade::code> == varchar_type<32>{"AAPL"}).
     [[nodiscard]] where_condition operator==(value_type const& val) const {
         return equal<Col>(Col{val});
     }
@@ -4948,8 +4949,10 @@ T from_mysql_value_nonnull(std::string_view sv) {
         return sv != "0" && sv != "false" && !sv.empty();
     } else if constexpr (std::same_as<T, std::string>) {
         return std::string{sv};
-    } else if constexpr (is_varchar_field_v<T>) {
+    } else if constexpr (is_varchar_type_v<T>) {
         return T::create(sv).value_or(T{});
+    } else if constexpr (is_text_type_v<T>) {
+        return T{sv};
     } else if constexpr (std::same_as<T, std::chrono::system_clock::time_point>) {
         std::istringstream ss{std::string{sv}};
         std::tm tm{};
@@ -4980,7 +4983,7 @@ T from_mysql_value_nonnull(std::string_view sv) {
         static_assert(false,
                       "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_field<N>, "
+                      "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, "
                       "and their std::optional variants.");
     }