feat(Core/DBLayer): replace char const* to std::string_view (#10211)

* feat(Core/DBLayer): replace `char const*` to `std::string_view`

* CString

* 1

* chore(Core/Misc): code cleanup

* cl

* db fix

* fmt style sql

* to fmt

* py

* del old

* 1

* 2

* 3

* 1

* 1

src/server/database/Database/DatabaseWorkerPool.cpp

@@ -17,11 +17,10 @@
 
 #include "DatabaseWorkerPool.h"
 #include "AdhocStatement.h"
+#include "CharacterDatabase.h"
 #include "Errors.h"
-#include "Implementation/CharacterDatabase.h"
-#include "Implementation/LoginDatabase.h"
-#include "Implementation/WorldDatabase.h"
 #include "Log.h"
+#include "LoginDatabase.h"
 #include "MySQLPreparedStatement.h"
 #include "MySQLWorkaround.h"
 #include "PCQueue.h"
@@ -31,7 +30,9 @@
 #include "QueryResult.h"
 #include "SQLOperation.h"
 #include "Transaction.h"
+#include "WorldDatabase.h"
 #include <mysqld_error.h>
+#include <limits>
 
 #ifdef ACORE_DEBUG
 #include <boost/stacktrace.hpp>
@@ -57,9 +58,10 @@ class PingOperation : public SQLOperation
 };
 
 template <class T>
-DatabaseWorkerPool<T>::DatabaseWorkerPool()
-    : _queue(new ProducerConsumerQueue<SQLOperation*>()),
-      _async_threads(0), _synch_threads(0)
+DatabaseWorkerPool<T>::DatabaseWorkerPool() :
+    _queue(new ProducerConsumerQueue<SQLOperation*>()),
+    _async_threads(0),
+    _synch_threads(0)
 {
     WPFatal(mysql_thread_safe(), "Used MySQL library isn't thread-safe.");
 
@@ -72,7 +74,7 @@ DatabaseWorkerPool<T>::DatabaseWorkerPool()
 #endif
 
     WPFatal(isSupportClientDB, "AzerothCore does not support MySQL versions below 5.7 and MariaDB 10.5\nSearch the wiki for ACE00043 in Common Errors (https://www.azerothcore.org/wiki/common-errors).");
-    WPFatal(isSameClientDB, "Used MySQL library version (%s id %lu) does not match the version id used to compile AzerothCore (id %u).\nSearch the wiki for ACE00046 in Common Errors (https://www.azerothcore.org/wiki/common-errors).",
+    WPFatal(isSameClientDB, "Used MySQL library version ({} id {}) does not match the version id used to compile AzerothCore (id {}).\nSearch the wiki for ACE00046 in Common Errors (https://www.azerothcore.org/wiki/common-errors).",
         mysql_get_client_info(), mysql_get_client_version(), MYSQL_VERSION_ID);
 }
 
@@ -83,8 +85,7 @@ DatabaseWorkerPool<T>::~DatabaseWorkerPool()
 }
 
 template <class T>
-void DatabaseWorkerPool<T>::SetConnectionInfo(std::string const& infoString,
-    uint8 const asyncThreads, uint8 const synchThreads)
+void DatabaseWorkerPool<T>::SetConnectionInfo(std::string_view infoString, uint8 const asyncThreads, uint8 const synchThreads)
 {
     _connectionInfo = std::make_unique<MySQLConnectionInfo>(infoString);
 
@@ -141,9 +142,9 @@ void DatabaseWorkerPool<T>::Close()
 template <class T>
 bool DatabaseWorkerPool<T>::PrepareStatements()
 {
-    for (auto& connections : _connections)
+    for (auto const& connections : _connections)
     {
-        for (auto& connection : connections)
+        for (auto const& connection : connections)
         {
             connection->LockIfReady();
             if (!connection->PrepareStatements())
@@ -170,8 +171,8 @@ bool DatabaseWorkerPool<T>::PrepareStatements()
                 {
                     uint32 const paramCount = stmt->GetParameterCount();
 
-                    // TC only supports uint8 indices.
-                    ASSERT(paramCount < (std::numeric_limits<uint8>::max)());
+                    // WH only supports uint8 indices.
+                    ASSERT(paramCount < std::numeric_limits<uint8>::max());
 
                     _preparedStatementSize[i] = static_cast<uint8>(paramCount);
                 }
@@ -183,13 +184,13 @@ bool DatabaseWorkerPool<T>::PrepareStatements()
 }
 
 template <class T>
-QueryResult DatabaseWorkerPool<T>::Query(char const* sql, T* connection /*= nullptr*/)
+QueryResult DatabaseWorkerPool<T>::Query(std::string_view sql)
 {
-    if (!connection)
-        connection = GetFreeConnection();
+    auto connection = GetFreeConnection();
 
     ResultSet* result = connection->Query(sql);
     connection->Unlock();
+
     if (!result || !result->GetRowCount() || !result->NextRow())
     {
         delete result;
@@ -219,7 +220,7 @@ PreparedQueryResult DatabaseWorkerPool<T>::Query(PreparedStatement<T>* stmt)
 }
 
 template <class T>
-QueryCallback DatabaseWorkerPool<T>::AsyncQuery(char const* sql)
+QueryCallback DatabaseWorkerPool<T>::AsyncQuery(std::string_view sql)
 {
     BasicStatementTask* task = new BasicStatementTask(sql, true);
     // Store future result before enqueueing - task might get already processed and deleted before returning from this method
@@ -308,6 +309,7 @@ void DatabaseWorkerPool<T>::DirectCommitTransaction(SQLTransaction<T>& transacti
 {
     T* connection = GetFreeConnection();
     int errorCode = connection->ExecuteTransaction(transaction);
+
     if (!errorCode)
     {
         connection->Unlock();      // OK, operation succesful
@@ -320,6 +322,7 @@ void DatabaseWorkerPool<T>::DirectCommitTransaction(SQLTransaction<T>& transacti
     {
         //todo: handle multiple sync threads deadlocking in a similar way as async threads
         uint8 loopBreaker = 5;
+
         for (uint8 i = 0; i < loopBreaker; ++i)
         {
             if (!connection->ExecuteTransaction(transaction))
@@ -368,6 +371,7 @@ void DatabaseWorkerPool<T>::KeepAlive()
     //! If one or more worker threads are busy, the ping operations will not be split evenly, but this doesn't matter
     //! as the sole purpose is to prevent connections from idling.
     auto const count = _connections[IDX_ASYNC].size();
+
     for (uint8 i = 0; i < count; ++i)
         Enqueue(new PingOperation);
 }
@@ -378,7 +382,8 @@ uint32 DatabaseWorkerPool<T>::OpenConnections(InternalIndex type, uint8 numConne
     for (uint8 i = 0; i < numConnections; ++i)
     {
         // Create the connection
-        auto connection = [&] {
+        auto connection = [&]
+        {
             switch (type)
             {
             case IDX_ASYNC:
@@ -461,15 +466,15 @@ T* DatabaseWorkerPool<T>::GetFreeConnection()
 }
 
 template <class T>
-char const* DatabaseWorkerPool<T>::GetDatabaseName() const
+std::string_view DatabaseWorkerPool<T>::GetDatabaseName() const
 {
-    return _connectionInfo->database.c_str();
+    return std::string_view{ _connectionInfo->database };
 }
 
 template <class T>
-void DatabaseWorkerPool<T>::Execute(char const* sql)
+void DatabaseWorkerPool<T>::Execute(std::string_view sql)
 {
-    if (Acore::IsFormatEmptyOrNull(sql))
+    if (sql.empty())
         return;
 
     BasicStatementTask* task = new BasicStatementTask(sql);
@@ -484,9 +489,9 @@ void DatabaseWorkerPool<T>::Execute(PreparedStatement<T>* stmt)
 }
 
 template <class T>
-void DatabaseWorkerPool<T>::DirectExecute(char const* sql)
+void DatabaseWorkerPool<T>::DirectExecute(std::string_view sql)
 {
-    if (Acore::IsFormatEmptyOrNull(sql))
+    if (sql.empty())
         return;
 
     T* connection = GetFreeConnection();
@@ -506,7 +511,7 @@ void DatabaseWorkerPool<T>::DirectExecute(PreparedStatement<T>* stmt)
 }
 
 template <class T>
-void DatabaseWorkerPool<T>::ExecuteOrAppend(SQLTransaction<T>& trans, char const* sql)
+void DatabaseWorkerPool<T>::ExecuteOrAppend(SQLTransaction<T>& trans, std::string_view sql)
 {
     if (!trans)
         Execute(sql);