style: apply clang-format to all new code

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

Author: Pierre-Luc Gagné

lib/include/ds_mysql/column_field_base_core.hpp

@@ -147,16 +147,32 @@ inline constexpr set_null_t set_null{};
 inline constexpr no_action_t no_action{};
 
 // on_delete(action) — intermediate composable style
-constexpr on_delete_cascade on_delete(cascade_t) { return {}; }
-constexpr on_delete_restrict on_delete(restrict_t) { return {}; }
-constexpr on_delete_set_null on_delete(set_null_t) { return {}; }
-constexpr on_delete_no_action on_delete(no_action_t) { return {}; }
+constexpr on_delete_cascade on_delete(cascade_t) {
+    return {};
+}
+constexpr on_delete_restrict on_delete(restrict_t) {
+    return {};
+}
+constexpr on_delete_set_null on_delete(set_null_t) {
+    return {};
+}
+constexpr on_delete_no_action on_delete(no_action_t) {
+    return {};
+}
 
 // on_update(action) — intermediate composable style
-constexpr on_update_cascade on_update(cascade_t) { return {}; }
-constexpr on_update_restrict on_update(restrict_t) { return {}; }
-constexpr on_update_set_null on_update(set_null_t) { return {}; }
-constexpr on_update_no_action on_update(no_action_t) { return {}; }
+constexpr on_update_cascade on_update(cascade_t) {
+    return {};
+}
+constexpr on_update_restrict on_update(restrict_t) {
+    return {};
+}
+constexpr on_update_set_null on_update(set_null_t) {
+    return {};
+}
+constexpr on_update_no_action on_update(no_action_t) {
+    return {};
+}
 
 // Descriptors for fully composable on(delete_(...)) / on(update_(...)) style
 template <typename Action>
@@ -165,15 +181,31 @@ struct delete_action {};
 template <typename Action>
 struct update_action {};
 
-constexpr delete_action<cascade_t> delete_(cascade_t) { return {}; }
-constexpr delete_action<restrict_t> delete_(restrict_t) { return {}; }
-constexpr delete_action<set_null_t> delete_(set_null_t) { return {}; }
-constexpr delete_action<no_action_t> delete_(no_action_t) { return {}; }
+constexpr delete_action<cascade_t> delete_(cascade_t) {
+    return {};
+}
+constexpr delete_action<restrict_t> delete_(restrict_t) {
+    return {};
+}
+constexpr delete_action<set_null_t> delete_(set_null_t) {
+    return {};
+}
+constexpr delete_action<no_action_t> delete_(no_action_t) {
+    return {};
+}
 
-constexpr update_action<cascade_t> update_(cascade_t) { return {}; }
-constexpr update_action<restrict_t> update_(restrict_t) { return {}; }
-constexpr update_action<set_null_t> update_(set_null_t) { return {}; }
-constexpr update_action<no_action_t> update_(no_action_t) { return {}; }
+constexpr update_action<cascade_t> update_(cascade_t) {
+    return {};
+}
+constexpr update_action<restrict_t> update_(restrict_t) {
+    return {};
+}
+constexpr update_action<set_null_t> update_(set_null_t) {
+    return {};
+}
+constexpr update_action<no_action_t> update_(no_action_t) {
+    return {};
+}
 
 // on(delete_action<A>) / on(update_action<A>) — dispatch to flat types
 template <typename A>

lib/include/ds_mysql/connection_pool.hpp

@@ -97,8 +97,8 @@ class connection_pool {
     ~connection_pool() = default;
 
     /// Create a pool with `pool_size` connections using the given config.
-    [[nodiscard]] static std::expected<std::unique_ptr<connection_pool>, std::string> create(
-        mysql_config const& config, std::size_t pool_size) {
+    [[nodiscard]] static std::expected<std::unique_ptr<connection_pool>, std::string> create(mysql_config const& config,
+                                                                                             std::size_t pool_size) {
         return create_impl(config, pool_size, nullptr);
     }
 
@@ -111,7 +111,9 @@ class connection_pool {
     /// Acquire a connection from the pool (blocks until one is available).
     [[nodiscard]] pooled_connection acquire() {
         std::unique_lock lock(mutex_);
-        cv_.wait(lock, [this] { return !pool_.empty(); });
+        cv_.wait(lock, [this] {
+            return !pool_.empty();
+        });
         auto conn = std::move(pool_.front());
         pool_.pop();
         return pooled_connection{this, std::move(conn)};

lib/include/ds_mysql/mysql_connection.hpp

@@ -452,8 +452,7 @@ class mysql_connection {
 
     // Open a server-side cursor from a typed query builder with prefetch hint.
     template <typename RowType, SqlBuilder Stmt, typename... Params>
-    [[nodiscard]] std::expected<server_cursor<RowType>, std::string> open_cursor(Stmt const& stmt,
-                                                                                 prefetch_rows hint,
+    [[nodiscard]] std::expected<server_cursor<RowType>, std::string> open_cursor(Stmt const& stmt, prefetch_rows hint,
                                                                                  Params const&... params) const {
         return open_cursor_impl<RowType>(stmt.build_sql(), hint, params...);
     }
@@ -663,8 +662,8 @@ class mysql_connection {
 
     template <typename RowType, typename... Params>
     [[nodiscard]] std::expected<server_cursor<RowType>, std::string> open_cursor_impl(std::string_view sql,
-                                                                                       prefetch_rows hint,
-                                                                                       Params const&... params) const {
+                                                                                      prefetch_rows hint,
+                                                                                      Params const&... params) const {
         using cursor_t = server_cursor<RowType>;
         using deleter_t = typename cursor_t::stmt_deleter;
 

lib/include/ds_mysql/server_cursor.hpp

@@ -163,8 +163,7 @@ class server_cursor {
         if (truncated) {
             (refetch_truncated<std::tuple_element_t<Is, RowType>>(Is), ...);
         }
-        return std::optional<RowType>{
-            RowType{extract_value<std::tuple_element_t<Is, RowType>>(Is)...}};
+        return std::optional<RowType>{RowType{extract_value<std::tuple_element_t<Is, RowType>>(Is)...}};
     }
 
     template <typename T>

lib/include/ds_mysql/sql_ddl.hpp

@@ -2850,8 +2850,8 @@ class create_function_builder {
     }
 
     [[nodiscard]] std::string build_sql() const {
-        return "CREATE FUNCTION " + std::string(Name) + "(" + params_ + ")\nRETURNS " + returns_ +
-               characteristics_ + "\nBEGIN\n" + body_ + "\nEND";
+        return "CREATE FUNCTION " + std::string(Name) + "(" + params_ + ")\nRETURNS " + returns_ + characteristics_ +
+               "\nBEGIN\n" + body_ + "\nEND";
     }
 
 private:
@@ -2864,9 +2864,8 @@ class create_function_builder {
 }  // namespace ddl_detail
 
 template <fixed_string Name>
-[[nodiscard]] ddl_detail::create_function_builder<Name> create_function(function_id<Name> const& id,
-                                                                        std::string params, std::string returns,
-                                                                        std::string body) {
+[[nodiscard]] ddl_detail::create_function_builder<Name> create_function(function_id<Name> const& id, std::string params,
+                                                                        std::string returns, std::string body) {
     return {id, std::move(params), std::move(returns), std::move(body)};
 }
 
@@ -3048,19 +3047,19 @@ template <Database T>
 
 template <ValidTable T, fixed_string Name>
 [[nodiscard]] ddl_detail::trigger_desc<Name, T> trigger(trigger_id<Name> const&, TriggerTiming timing,
-                                                         TriggerEvent event, std::string body) {
+                                                        TriggerEvent event, std::string body) {
     return {timing, event, std::move(body)};
 }
 
 template <fixed_string Name>
 [[nodiscard]] ddl_detail::procedure_desc<Name> procedure(procedure_id<Name> const&, std::string params,
-                                                          std::string body) {
+                                                         std::string body) {
     return {std::move(params), std::move(body)};
 }
 
 template <fixed_string Name>
 [[nodiscard]] ddl_detail::function_desc<Name> function(function_id<Name> const&, std::string params,
-                                                        std::string returns, std::string body) {
+                                                       std::string returns, std::string body) {
     return {std::move(params), std::move(returns), std::move(body)};
 }
 

tests/integration/mysql/test_query_builder.cpp

@@ -2083,7 +2083,9 @@ suite<"server cursor"> cursor_suite = [] {
         // Set up test data
         (void)(db->execute(drop_table(trade{}).if_exists()));
         expect(db->execute(create_table(trade{})).has_value());
-        auto _ = scope_guard{[&] { (void)(db->execute(drop_table(trade{}).if_exists())); }};
+        auto _ = scope_guard{[&] {
+            (void)(db->execute(drop_table(trade{}).if_exists()));
+        }};
 
         expect(db->execute(insert_into(trade{})
                                .columns(trade::code{}, trade::type{}, trade::name{}, trade::executed_at{},

tests/unit/test_ddl.cpp

@@ -1523,8 +1523,7 @@ struct child_table_composable {
 struct child_table_on_composed {
     COLUMN_FIELD(id, uint32_t)
     COLUMN_FIELD(parent_id, uint32_t, fk_attr::references<parent_table, parent_table::id>{},
-                 fk_attr::on(fk_attr::delete_(fk_attr::cascade)),
-                 fk_attr::on(fk_attr::update_(fk_attr::restrict_)))
+                 fk_attr::on(fk_attr::delete_(fk_attr::cascade)), fk_attr::on(fk_attr::update_(fk_attr::restrict_)))
 };
 }  // namespace
 
@@ -2126,8 +2125,7 @@ suite<"DDL procedures"> ddl_procedure_suite = [] {
 
 suite<"DDL functions"> ddl_function_suite = [] {
     "create_function - generates CREATE FUNCTION with RETURNS"_test = [] {
-        auto const sql =
-            create_function(function_id<"fn_hello">{}, "", "VARCHAR(50)", "RETURN 'Hello';").build_sql();
+        auto const sql = create_function(function_id<"fn_hello">{}, "", "VARCHAR(50)", "RETURN 'Hello';").build_sql();
         expect(sql ==
                "CREATE FUNCTION fn_hello()\n"
                "RETURNS VARCHAR(50)\n"
@@ -2138,8 +2136,7 @@ suite<"DDL functions"> ddl_function_suite = [] {
     };
 
     "create_function with params - includes params and return type"_test = [] {
-        auto const sql =
-            create_function(function_id<"fn_add">{}, "a INT, b INT", "INT", "RETURN a + b;").build_sql();
+        auto const sql = create_function(function_id<"fn_add">{}, "a INT, b INT", "INT", "RETURN a + b;").build_sql();
         expect(sql ==
                "CREATE FUNCTION fn_add(a INT, b INT)\n"
                "RETURNS INT\n"
@@ -2163,8 +2160,7 @@ suite<"DDL functions"> ddl_function_suite = [] {
     };
 
     "create_function.no_sql - adds NO SQL characteristic"_test = [] {
-        auto const sql =
-            create_function(function_id<"fn_pi">{}, "", "DOUBLE", "RETURN 3.14159;").no_sql().build_sql();
+        auto const sql = create_function(function_id<"fn_pi">{}, "", "DOUBLE", "RETURN 3.14159;").no_sql().build_sql();
         expect(sql ==
                "CREATE FUNCTION fn_pi()\n"
                "RETURNS DOUBLE\n"
@@ -2176,10 +2172,10 @@ suite<"DDL functions"> ddl_function_suite = [] {
     };
 
     "create_function.reads_sql_data - adds READS SQL DATA characteristic"_test = [] {
-        auto const sql =
-            create_function(function_id<"fn_lookup">{}, "uid INT", "VARCHAR(100)", "RETURN (SELECT name FROM users WHERE id = uid);")
-                .reads_sql_data()
-                .build_sql();
+        auto const sql = create_function(function_id<"fn_lookup">{}, "uid INT", "VARCHAR(100)",
+                                         "RETURN (SELECT name FROM users WHERE id = uid);")
+                             .reads_sql_data()
+                             .build_sql();
         expect(sql ==
                "CREATE FUNCTION fn_lookup(uid INT)\n"
                "RETURNS VARCHAR(100)\n"
@@ -2191,11 +2187,10 @@ suite<"DDL functions"> ddl_function_suite = [] {
     };
 
     "create_function.modifies_sql_data - adds MODIFIES SQL DATA characteristic"_test = [] {
-        auto const sql =
-            create_function(function_id<"fn_inc">{}, "uid INT", "INT",
-                            "UPDATE counters SET cnt = cnt + 1 WHERE id = uid;\nRETURN 1;")
-                .modifies_sql_data()
-                .build_sql();
+        auto const sql = create_function(function_id<"fn_inc">{}, "uid INT", "INT",
+                                         "UPDATE counters SET cnt = cnt + 1 WHERE id = uid;\nRETURN 1;")
+                             .modifies_sql_data()
+                             .build_sql();
         expect(sql ==
                "CREATE FUNCTION fn_inc(uid INT)\n"
                "RETURNS INT\n"
@@ -2208,10 +2203,8 @@ suite<"DDL functions"> ddl_function_suite = [] {
     };
 
     "create_function chained characteristics - combines DETERMINISTIC + NO SQL"_test = [] {
-        auto const sql = create_function(function_id<"fn_const">{}, "", "INT", "RETURN 42;")
-                             .deterministic()
-                             .no_sql()
-                             .build_sql();
+        auto const sql =
+            create_function(function_id<"fn_const">{}, "", "INT", "RETURN 42;").deterministic().no_sql().build_sql();
         expect(sql ==
                "CREATE FUNCTION fn_const()\n"
                "RETURNS INT\n"
@@ -2392,7 +2385,8 @@ suite<"DDL composition"> ddl_composition_suite = [] {
 
     // --- create(procedure(...)) ---
     "create(procedure) - equivalent to create_procedure"_test = [] {
-        auto const sql = create(procedure(procedure_id<"usp_add">{}, "IN a INT, IN b INT", "SELECT a + b;")).build_sql();
+        auto const sql =
+            create(procedure(procedure_id<"usp_add">{}, "IN a INT, IN b INT", "SELECT a + b;")).build_sql();
         auto const expected =
             create_procedure(procedure_id<"usp_add">{}, "IN a INT, IN b INT", "SELECT a + b;").build_sql();
         expect(sql == expected) << sql;
@@ -2407,22 +2401,20 @@ suite<"DDL composition"> ddl_composition_suite = [] {
     };
 
     "create(function).deterministic - chains correctly"_test = [] {
-        auto const sql = create(function(function_id<"fn_dbl">{}, "x INT", "INT", "RETURN x * 2;"))
-                             .deterministic()
-                             .build_sql();
+        auto const sql =
+            create(function(function_id<"fn_dbl">{}, "x INT", "INT", "RETURN x * 2;")).deterministic().build_sql();
         auto const expected =
             create_function(function_id<"fn_dbl">{}, "x INT", "INT", "RETURN x * 2;").deterministic().build_sql();
         expect(sql == expected) << sql;
     };
 
     // --- create(trigger<T>(...)) ---
     "create(trigger) - equivalent to create_trigger"_test = [] {
-        auto const sql =
-            create(trigger<test_table>(trigger_id<"trg_bi">{}, TriggerTiming::Before, TriggerEvent::Insert,
-                                       "SET NEW.name = UPPER(NEW.name);"))
-                .build_sql();
+        auto const sql = create(trigger<test_table>(trigger_id<"trg_bi">{}, TriggerTiming::Before, TriggerEvent::Insert,
+                                                    "SET NEW.name = UPPER(NEW.name);"))
+                             .build_sql();
         auto const expected = create_trigger<test_table>(trigger_id<"trg_bi">{}, TriggerTiming::Before,
-                                                          TriggerEvent::Insert, "SET NEW.name = UPPER(NEW.name);")
+                                                         TriggerEvent::Insert, "SET NEW.name = UPPER(NEW.name);")
                                   .build_sql();
         expect(sql == expected) << sql;
     };

tests/unit/test_dml.cpp

@@ -795,23 +795,19 @@ suite<"DML - sql_default assignability"> dml_sql_default_suite = [] {
 
 suite<"DML CASE in UPDATE"> dml_case_update_suite = [] {
     "set_case - UPDATE with CASE WHEN expression"_test = [] {
-        auto const sql =
-            update(asset{})
-                .set_case(asset::instrument{},
-                          case_when(equal<asset::ticker>(asset::ticker{"AAPL"}), "Tech"s).else_("Other"s))
-                .build_sql();
-        expect(sql ==
-               "UPDATE asset SET instrument = CASE WHEN ticker = 'AAPL' THEN 'Tech' ELSE 'Other' END"s)
-            << sql;
+        auto const sql = update(asset{})
+                             .set_case(asset::instrument{},
+                                       case_when(equal<asset::ticker>(asset::ticker{"AAPL"}), "Tech"s).else_("Other"s))
+                             .build_sql();
+        expect(sql == "UPDATE asset SET instrument = CASE WHEN ticker = 'AAPL' THEN 'Tech' ELSE 'Other' END"s) << sql;
     };
 
     "set_case with WHERE - adds WHERE clause"_test = [] {
         auto const sql =
             update(asset{})
-                .set_case(asset::instrument{},
-                          case_when(equal<asset::ticker>(asset::ticker{"AAPL"}), "Tech"s)
-                              .when(equal<asset::ticker>(asset::ticker{"MSFT"}), "Software"s)
-                              .else_("Unknown"s))
+                .set_case(asset::instrument{}, case_when(equal<asset::ticker>(asset::ticker{"AAPL"}), "Tech"s)
+                                                   .when(equal<asset::ticker>(asset::ticker{"MSFT"}), "Software"s)
+                                                   .else_("Unknown"s))
                 .where(is_not_null<asset::name>())
                 .build_sql();
         expect(sql.find("SET instrument = CASE WHEN ticker = 'AAPL' THEN 'Tech'"
@@ -821,21 +817,20 @@ suite<"DML CASE in UPDATE"> dml_case_update_suite = [] {
     };
 
     "set_case mixed with set - regular assignments and CASE together"_test = [] {
-        auto const sql = update(asset{})
-                             .set(asset::ticker{"UPDATED"})
-                             .set_case(asset::instrument{},
-                                       case_when(equal<asset::exchange_id>(1u), "Local"s).else_("Foreign"s))
-                             .build_sql();
+        auto const sql =
+            update(asset{})
+                .set(asset::ticker{"UPDATED"})
+                .set_case(asset::instrument{}, case_when(equal<asset::exchange_id>(1u), "Local"s).else_("Foreign"s))
+                .build_sql();
         expect(sql.find("SET ticker = 'UPDATED', instrument = CASE WHEN") != std::string::npos) << sql;
     };
 
     "set_case on update_builder directly - starts chain with CASE"_test = [] {
-        auto const sql =
-            update(asset{})
-                .set_case(asset::ticker{},
-                          case_when(equal<asset::id>(1u), asset::ticker{"A"}).else_(asset::ticker{"B"}))
-                .where(equal<asset::id>(1u))
-                .build_sql();
+        auto const sql = update(asset{})
+                             .set_case(asset::ticker{},
+                                       case_when(equal<asset::id>(1u), asset::ticker{"A"}).else_(asset::ticker{"B"}))
+                             .where(equal<asset::id>(1u))
+                             .build_sql();
         expect(sql == "UPDATE asset SET ticker = CASE WHEN id = 1 THEN 'A' ELSE 'B' END WHERE id = 1"s) << sql;
     };
 };