DatabaseWorkerPool.h

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef _DATABASEWORKERPOOL_H
#define _DATABASEWORKERPOOL_H
 
#include "Define.h"
#include "DatabaseEnvFwd.h"
#include "StringFormat.h"
#include <array>
#include <string>
#include <vector>
 
template <typename T>
class ProducerConsumerQueue;
 
class SQLOperation;
struct MySQLConnectionInfo;
 
template <class T>
class DatabaseWorkerPool
{
    private:
        enum InternalIndex
        {
            IDX_ASYNC,
            IDX_SYNCH,
            IDX_SIZE
        };
 
    public:
        /* Activity state */
        DatabaseWorkerPool();
 
        ~DatabaseWorkerPool();
 
        void SetConnectionInfo(std::string const& infoString, uint8 const asyncThreads, uint8 const synchThreads);
 
        uint32 Open();
 
        void Close();
 
        bool PrepareStatements();
 
        inline MySQLConnectionInfo const* GetConnectionInfo() const
        {
            return _connectionInfo.get();
        }
 
        void Execute(char const* sql);
 
        template<typename... Args>
        void PExecute(Trinity::FormatString<Args...> sql, Args&&... args)
        {
            if (Trinity::IsFormatEmptyOrNull(sql))
                return;
 
            this->Execute(Trinity::StringFormat(sql, std::forward<Args>(args)...).c_str());
        }
 
        void Execute(PreparedStatement<T>* stmt);
 
        void DirectExecute(char const* sql);
 
        template<typename... Args>
        void DirectPExecute(Trinity::FormatString<Args...> sql, Args&&... args)
        {
            if (Trinity::IsFormatEmptyOrNull(sql))
                return;
 
            this->DirectExecute(Trinity::StringFormat(sql, std::forward<Args>(args)...).c_str());
        }
 
        void DirectExecute(PreparedStatement<T>* stmt);
 
        QueryResult Query(char const* sql, T* connection = nullptr);
 
        template<typename... Args>
        QueryResult PQuery(Trinity::FormatString<Args...> sql, T* conn, Args&&... args)
        {
            if (Trinity::IsFormatEmptyOrNull(sql))
                return QueryResult(nullptr);
 
            return this->Query(Trinity::StringFormat(sql, std::forward<Args>(args)...).c_str(), conn);
        }
 
        template<typename... Args>
        QueryResult PQuery(Trinity::FormatString<Args...> sql, Args&&... args)
        {
            if (Trinity::IsFormatEmptyOrNull(sql))
                return QueryResult(nullptr);
 
            return this->Query(Trinity::StringFormat(sql, std::forward<Args>(args)...).c_str());
        }
 
        PreparedQueryResult Query(PreparedStatement<T>* stmt);
 
        QueryCallback AsyncQuery(char const* sql);
 
        QueryCallback AsyncQuery(PreparedStatement<T>* stmt);
 
        SQLQueryHolderCallback DelayQueryHolder(std::shared_ptr<SQLQueryHolder<T>> holder);
 
        SQLTransaction<T> BeginTransaction();
 
        void CommitTransaction(SQLTransaction<T> transaction);
 
        TransactionCallback AsyncCommitTransaction(SQLTransaction<T> transaction);
 
        void DirectCommitTransaction(SQLTransaction<T>& transaction);
 
        void ExecuteOrAppend(SQLTransaction<T>& trans, char const* sql);
 
        void ExecuteOrAppend(SQLTransaction<T>& trans, PreparedStatement<T>* stmt);
 
        typedef typename T::Statements PreparedStatementIndex;
 
        PreparedStatement<T>* GetPreparedStatement(PreparedStatementIndex index);
 
        void EscapeString(std::string& str);
 
        void KeepAlive();
 
        void WarnAboutSyncQueries([[maybe_unused]] bool warn)
        {
#ifdef TRINITY_DEBUG
            _warnSyncQueries = warn;
#endif
        }
 
        size_t QueueSize() const;
 
    private:
        uint32 OpenConnections(InternalIndex type, uint8 numConnections);
 
        unsigned long EscapeString(char* to, char const* from, unsigned long length);
 
        void Enqueue(SQLOperation* op);
 
        T* GetFreeConnection();
 
        char const* GetDatabaseName() const;
 
        std::unique_ptr<ProducerConsumerQueue<SQLOperation*>> _queue;
        std::array<std::vector<std::unique_ptr<T>>, IDX_SIZE> _connections;
        std::unique_ptr<MySQLConnectionInfo> _connectionInfo;
        std::vector<uint8> _preparedStatementSize;
        uint8 _async_threads, _synch_threads;
#ifdef TRINITY_DEBUG
        static inline thread_local bool _warnSyncQueries = false;
#endif
};
 
#endif