style: reformat with clang-format-22

clang-format 22 changed line-break heuristics; CI's "Check C++ style" job
caught the drift. Reformat the affected files (BasicStringBinder.hpp,
SqlVariant.cpp, SqlError.cpp, SqlOdbcWide.hpp, SqlScopedTraceLogger.hpp,
DataBinderTests.cpp, Utils.hpp) to match the version pinned in CI.

Signed-off-by: Christian Parpart <christian@parpart.family>

Author: christianparpart

src/Lightweight/DataBinder/BasicStringBinder.hpp

@@ -157,8 +157,7 @@ namespace detail
             {
                 if (*indicator != SQL_NULL_DATA && *indicator != SQL_NO_TOTAL)
                 {
-                    auto const syntheticIndicator =
-                        static_cast<SQLLEN>(StringTraits::Size(result) * sizeof(CharType));
+                    auto const syntheticIndicator = static_cast<SQLLEN>(StringTraits::Size(result) * sizeof(CharType));
                     StringTraits::PostProcessOutputColumn(result, syntheticIndicator);
                 }
             }
@@ -201,9 +200,8 @@ struct SqlDataBinder<AnsiStringType>
         // call path in the library produces (file readers, query formatters, etc.).
         if (cb.ServerType() == SqlServerType::POSTGRESQL)
         {
-            auto u16String = std::make_shared<std::u16string>(
-                ToUtf16(std::u8string_view { reinterpret_cast<char8_t const*>(StringTraits::Data(&value)),
-                                             StringTraits::Size(&value) }));
+            auto u16String = std::make_shared<std::u16string>(ToUtf16(std::u8string_view {
+                reinterpret_cast<char8_t const*>(StringTraits::Data(&value)), StringTraits::Size(&value) }));
             cb.PlanPostExecuteCallback([u16String = u16String]() {}); // keep buffer alive
             auto const charCount = u16String->size();
             auto const byteCount = charCount * sizeof(char16_t);
@@ -440,8 +438,7 @@ struct SqlDataBinder<Utf16StringType>
         auto const* data = StringTraits::Data(&value);
         auto const sizeInBytes = StringTraits::Size(&value) * sizeof(CharType);
         auto const charCount = StringTraits::Size(&value);
-        auto const sqlType =
-            static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
+        auto const sqlType = static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
 
         SQLLEN* indicator = cb.ProvideInputIndicator();
         *indicator = static_cast<SQLLEN>(sizeInBytes);
@@ -538,15 +535,13 @@ struct SqlDataBinder<Utf32StringType>
     {
         // Always go via UTF-16 + SQL_C_WCHAR; the driver handles encoding conversion
         // for the target server.
-        auto u16String =
-            std::make_shared<std::u16string>(ToUtf16(detail::SqlViewHelper<Utf32StringType>::View(value)));
+        auto u16String = std::make_shared<std::u16string>(ToUtf16(detail::SqlViewHelper<Utf32StringType>::View(value)));
         cb.PlanPostExecuteCallback([u16String = u16String]() {}); // Keep the string alive
         auto const* data = u16String->data();
         auto const charCount = u16String->size();
         auto const sizeInBytes = u16String->size() * sizeof(char16_t);
         auto const CType = SQLSMALLINT { SQL_C_WCHAR };
-        auto const sqlType =
-            static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
+        auto const sqlType = static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
 
         SQLLEN* indicator = cb.ProvideInputIndicator();
         *indicator = static_cast<SQLLEN>(sizeInBytes);
@@ -612,15 +607,13 @@ struct SqlDataBinder<Utf8StringType>
     {
         // Always go via UTF-16 + SQL_C_WCHAR; the driver handles encoding conversion
         // for the target server.
-        auto u16String =
-            std::make_shared<std::u16string>(ToUtf16(detail::SqlViewHelper<Utf8StringType>::View(value)));
+        auto u16String = std::make_shared<std::u16string>(ToUtf16(detail::SqlViewHelper<Utf8StringType>::View(value)));
         cb.PlanPostExecuteCallback([u16String = u16String]() {}); // Keep the string alive
 
         auto const CType = SQL_C_WCHAR;
         auto const charCount = u16String->size();
         auto const byteCount = u16String->size() * sizeof(char16_t);
-        auto const sqlType =
-            static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
+        auto const sqlType = static_cast<SQLSMALLINT>(charCount > SqlOptimalMaxColumnSize ? SQL_WLONGVARCHAR : SQL_WVARCHAR);
 
         SQLLEN* indicator = cb.ProvideInputIndicator();
         *indicator = static_cast<SQLLEN>(byteCount);

src/Lightweight/DataBinder/SqlVariant.cpp

@@ -25,8 +25,7 @@ SQLRETURN SqlDataBinder<SqlVariant>::GetColumn(
     // Use the W variant — the call passes nullptr for the string buffer (we only fetch
     // the numeric SQL_DESC_TYPE), so it's a near-pure rename, but it keeps the entire
     // ODBC call surface on the Unicode-app path the rest of the library is using.
-    SQLRETURN returnCode =
-        SQLColAttributeW(stmt, column, SQL_DESC_TYPE, nullptr, 0, nullptr, &columnType);
+    SQLRETURN returnCode = SQLColAttributeW(stmt, column, SQL_DESC_TYPE, nullptr, 0, nullptr, &columnType);
     if (!SQL_SUCCEEDED(returnCode))
         return returnCode;
 

src/Lightweight/SqlError.cpp

@@ -37,7 +37,7 @@ SqlErrorInfo SqlErrorInfo::FromHandle(SQLSMALLINT handleType, SQLHANDLE handle)
 {
     SqlErrorInfo info {};
 
-    constexpr SQLSMALLINT SqlStateLen = 6;       // 5 SQLSTATE chars + NUL
+    constexpr SQLSMALLINT SqlStateLen = 6; // 5 SQLSTATE chars + NUL
     constexpr SQLSMALLINT MessageBufferLen = 1024;
     std::array<SQLWCHAR, SqlStateLen> sqlStateBuffer {};
     std::array<SQLWCHAR, MessageBufferLen> messageBuffer {};
@@ -57,14 +57,14 @@ SqlErrorInfo SqlErrorInfo::FromHandle(SQLSMALLINT handleType, SQLHANDLE handle)
     // The SQLWCHAR ↔ char16_t layout invariant lives in SqlOdbcWide.hpp; the buffers
     // we just filled are reinterpretable as char16_t under that same assumption.
     auto const sqlStateChars = static_cast<size_t>(SqlStateLen - 1); // SQLSTATE is exactly 5 chars
-    auto const sqlStateUtf8 = ToUtf8(std::u16string_view {
-        reinterpret_cast<char16_t const*>(sqlStateBuffer.data()), sqlStateChars });
+    auto const sqlStateUtf8 =
+        ToUtf8(std::u16string_view { reinterpret_cast<char16_t const*>(sqlStateBuffer.data()), sqlStateChars });
     info.sqlState.assign(reinterpret_cast<char const*>(sqlStateUtf8.data()), sqlStateUtf8.size());
 
     auto const messageChars =
         msgLen > 0 ? std::min(static_cast<SQLSMALLINT>(MessageBufferLen - 1), msgLen) : SQLSMALLINT { 0 };
-    auto const messageUtf8 = ToUtf8(std::u16string_view {
-        reinterpret_cast<char16_t const*>(messageBuffer.data()), static_cast<size_t>(messageChars) });
+    auto const messageUtf8 = ToUtf8(
+        std::u16string_view { reinterpret_cast<char16_t const*>(messageBuffer.data()), static_cast<size_t>(messageChars) });
     info.message.assign(reinterpret_cast<char const*>(messageUtf8.data()), messageUtf8.size());
 
     return info;

src/Lightweight/SqlOdbcWide.hpp

@@ -16,8 +16,7 @@ namespace Lightweight::detail
 // ODBC W variants assume `SQLWCHAR` is layout-compatible with `char16_t` (true on
 // Windows where it's `wchar_t`, and on Linux unixODBC where it's `unsigned short` —
 // both 16-bit). Anything else and the reinterpret_casts below would silently corrupt.
-static_assert(sizeof(SQLWCHAR) == sizeof(char16_t),
-              "ODBC W variants require a 16-bit code unit; SQLWCHAR shape mismatch");
+static_assert(sizeof(SQLWCHAR) == sizeof(char16_t), "ODBC W variants require a 16-bit code unit; SQLWCHAR shape mismatch");
 
 /// @brief Converts a UTF-8 string view into a `std::u16string` for ODBC W variants.
 /// Use this rather than `ToUtf16(std::string const&)` from `UnicodeConverter.hpp`:

src/Lightweight/SqlScopedTraceLogger.hpp

@@ -55,8 +55,7 @@ class LIGHTWEIGHT_API SqlScopedTraceLogger
         // unnecessarily. `path::u16string()` does the platform-correct conversion (UTF-16
         // is path's native form on Windows; UTF-8 → UTF-16 on POSIX).
         auto wLogFile = logFile.u16string();
-        SQLSetConnectAttrW(
-            m_nativeConnection, SQL_ATTR_TRACEFILE, detail::AsSqlWChar(wLogFile.data()), SQL_NTS);
+        SQLSetConnectAttrW(m_nativeConnection, SQL_ATTR_TRACEFILE, detail::AsSqlWChar(wLogFile.data()), SQL_NTS);
         SQLSetConnectAttrW(m_nativeConnection, SQL_ATTR_TRACE, (SQLPOINTER) SQL_OPT_TRACE_ON, SQL_IS_UINTEGER);
     }
 

src/tests/DataBinderTests.cpp

@@ -1409,9 +1409,7 @@ struct UnicodeAcrossDynamicStringTypes
     Field<SqlDynamicWideString<256>> stringWide {};
 };
 
-TEST_CASE_METHOD(SqlTestFixture,
-                 "Unicode round-trip across DataMapper dynamic string types",
-                 "[DataMapper][Unicode]")
+TEST_CASE_METHOD(SqlTestFixture, "Unicode round-trip across DataMapper dynamic string types", "[DataMapper][Unicode]")
 {
     auto dm = DataMapper {};
     dm.CreateTable<UnicodeAcrossDynamicStringTypes>();
@@ -1436,9 +1434,7 @@ struct UnicodeTrimmedFixedRow
     Field<SqlTrimmedWideFixedString<32>> stringWide {};
 };
 
-TEST_CASE_METHOD(SqlTestFixture,
-                 "Trimmed fixed strings strip trailing padding through DataMapper",
-                 "[DataMapper][Unicode]")
+TEST_CASE_METHOD(SqlTestFixture, "Trimmed fixed strings strip trailing padding through DataMapper", "[DataMapper][Unicode]")
 {
     auto dm = DataMapper {};
     dm.CreateTable<UnicodeTrimmedFixedRow>();

src/tests/Utils.hpp

@@ -3,9 +3,10 @@
 #pragma once
 
 #if defined(_WIN32) || defined(_WIN64)
+    #include <cstdlib>
+
     #include <Windows.h>
     #include <crtdbg.h>
-    #include <cstdlib>
 #endif
 
 #include <Lightweight/Lightweight.hpp>
@@ -535,8 +536,7 @@ class SqlTestFixture
             auto wTraceFile = std::u16string { u"CONOUT$" };
 #endif
             SQLHDBC handle = connection.NativeHandle();
-            SQLSetConnectAttrW(
-                handle, SQL_ATTR_TRACEFILE, Lightweight::detail::AsSqlWChar(wTraceFile.data()), SQL_NTS);
+            SQLSetConnectAttrW(handle, SQL_ATTR_TRACEFILE, Lightweight::detail::AsSqlWChar(wTraceFile.data()), SQL_NTS);
             SQLSetConnectAttrW(handle, SQL_ATTR_TRACE, (SQLPOINTER) SQL_OPT_TRACE_ON, SQL_IS_UINTEGER);
         }