feat: add instance-based overloads for validate_table and validate_database

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
+
+- Instance-based overloads for `mysql_connection::validate_table` and `validate_database` — e.g. `db->validate_table(trade{})` and `db->validate_database(trade_db{})` as alternatives to the template-only forms
+
 ---
 
 ## [4.3.0] – 2026-03-29

CLAUDE.md

@@ -67,7 +67,7 @@ Style: Google-based, 120-char line limit, 4-space indent (`.clang-format` at roo
 
 ### Schema Generation and Validation
 
-Tables are described as C++ structs. `schema_generator.hpp` reflects struct fields via Boost.PFR at compile time. To override the SQL type for a specific field, specialize `field_schema<T, I>`. `mysql_connection::validate_table<T>()` checks a live database schema against the C++ definition and returns detailed error messages on mismatch.
+Tables are described as C++ structs. `schema_generator.hpp` reflects struct fields via Boost.PFR at compile time. To override the SQL type for a specific field, specialize `field_schema<T, I>`. `mysql_connection::validate_table(T{})` / `validate_table<T>()` checks a live database schema against the C++ definition and returns detailed error messages on mismatch. `validate_database(DB{})` / `validate_database<DB>()` validates all tables in a database schema struct.
 
 ### Error Handling
 

lib/include/ds_mysql/mysql_connection.hpp

@@ -401,6 +401,11 @@ class mysql_connection {
     //
     // Returns std::expected<void, std::string>.
     // On mismatch, the error string lists every discrepancy found.
+    template <ValidTable T>
+    [[nodiscard]] std::expected<void, std::string> validate_table(T const&) const {
+        return validate_table<T>();
+    }
+
     template <ValidTable T>
     [[nodiscard]] std::expected<void, std::string> validate_table() const {
         auto describe_result = query(describe(T{}));
@@ -436,6 +441,11 @@ class mysql_connection {
     //
     // Returns std::expected<void, std::string>.
     // On mismatch, the error string aggregates every discrepancy across all tables.
+    template <Database DB>
+    [[nodiscard]] std::expected<void, std::string> validate_database(DB const&) const {
+        return validate_database<DB>();
+    }
+
     template <Database DB>
     [[nodiscard]] std::expected<void, std::string> validate_database() const {
         using tables_tuple = typename database_tables<DB>::type;

tests/integration/mysql/test_query_builder.cpp

@@ -792,6 +792,23 @@ suite<"Schema Validation Integration"> schema_validation_suite = [] {
                                           (result.has_value() ? "" : result.error());
     };
 
+    "validate_table instance-based succeeds when table matches C++ struct"_test = [] {
+        auto const config = mysql_config_from_env();
+        expect(fatal(config.has_value()));
+
+        auto const db = mysql_connection::connect(*config);
+        expect(fatal(db));
+        auto _ = scope_guard{[&] {
+            (void)(db->execute(drop_table(trade{}).if_exists()));
+        }};
+
+        expect(db->execute(create_table(trade{}).if_not_exists()).has_value());
+
+        auto const result = db->validate_table(trade{});
+        expect(result.has_value()) << "validate_table(trade{}) should succeed — " +
+                                          (result.has_value() ? "" : result.error());
+    };
+
     "validate_table fails when table does not exist"_test = [] {
         auto const config = mysql_config_from_env();
         expect(fatal(config.has_value()));
@@ -848,6 +865,23 @@ suite<"Schema Validation Integration"> schema_validation_suite = [] {
                                           (result.has_value() ? "" : result.error());
     };
 
+    "validate_database instance-based succeeds when all registered tables match"_test = [] {
+        auto const config = mysql_config_from_env();
+        expect(fatal(config.has_value()));
+
+        auto const db = mysql_connection::connect(*config);
+        expect(fatal(db));
+        auto _ = scope_guard{[&] {
+            (void)(db->execute(drop_table(trade{}).if_exists()));
+        }};
+
+        expect(db->execute(create_table(trade{}).if_not_exists()).has_value());
+
+        auto const result = db->validate_database(trade_db{});
+        expect(result.has_value()) << "validate_database(trade_db{}) should succeed — " +
+                                          (result.has_value() ? "" : result.error());
+    };
+
     "validate_database reports error when a table is absent"_test = [] {
         auto const config = mysql_config_from_env();
         expect(fatal(config.has_value()));