MySQLConnection.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 _MYSQLCONNECTION_H
#define _MYSQLCONNECTION_H
 
#include "Define.h"
#include "DatabaseEnvFwd.h"
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
template <typename T>
class ProducerConsumerQueue;
 
class DatabaseWorker;
class MySQLPreparedStatement;
class SQLOperation;
 
enum ConnectionFlags
{
    CONNECTION_ASYNC = 0x1,
    CONNECTION_SYNCH = 0x2,
    CONNECTION_BOTH = CONNECTION_ASYNC | CONNECTION_SYNCH
};
 
struct TC_DATABASE_API MySQLConnectionInfo
{
    explicit MySQLConnectionInfo(std::string const& infoString);
 
    std::string user;
    std::string password;
    std::string database;
    std::string host;
    std::string port_or_socket;
    std::string ssl;
};
 
class TC_DATABASE_API MySQLConnection
{
    template <class T> friend class DatabaseWorkerPool;
    friend class PingOperation;
 
    public:
        MySQLConnection(MySQLConnectionInfo& connInfo);                               
        MySQLConnection(ProducerConsumerQueue<SQLOperation*>* queue, MySQLConnectionInfo& connInfo);  
        virtual ~MySQLConnection();
 
        virtual uint32 Open();
        void Close();
 
        bool PrepareStatements();
 
        bool Execute(char const* sql);
        bool Execute(PreparedStatementBase* stmt);
        ResultSet* Query(char const* sql);
        PreparedResultSet* Query(PreparedStatementBase* stmt);
        bool _Query(char const* sql, MySQLResult** pResult, MySQLField** pFields, uint64* pRowCount, uint32* pFieldCount);
        bool _Query(PreparedStatementBase* stmt, MySQLPreparedStatement** mysqlStmt, MySQLResult** pResult, uint64* pRowCount, uint32* pFieldCount);
 
        void BeginTransaction();
        void RollbackTransaction();
        void CommitTransaction();
        int ExecuteTransaction(std::shared_ptr<TransactionBase> transaction);
        size_t EscapeString(char* to, const char* from, size_t length);
        void Ping();
 
        uint32 GetLastError();
 
    protected:
        bool LockIfReady();
 
        void Unlock();
 
        uint32 GetServerVersion() const;
        MySQLPreparedStatement* GetPreparedStatement(uint32 index);
        void PrepareStatement(uint32 index, std::string const& sql, ConnectionFlags flags);
 
        virtual void DoPrepareStatements() = 0;
 
        typedef std::vector<std::unique_ptr<MySQLPreparedStatement>> PreparedStatementContainer;
 
        PreparedStatementContainer           m_stmts;         
        bool                                 m_reconnecting;  
        bool                                 m_prepareError;  
 
    private:
        bool _HandleMySQLErrno(uint32 errNo, uint8 attempts = 5);
 
        ProducerConsumerQueue<SQLOperation*>* m_queue;      
        std::unique_ptr<DatabaseWorker> m_worker;           
        MySQLHandle*          m_Mysql;                      
        MySQLConnectionInfo&  m_connectionInfo;             
        ConnectionFlags       m_connectionFlags;            
        std::mutex            m_Mutex;
 
        MySQLConnection(MySQLConnection const& right) = delete;
        MySQLConnection& operator=(MySQLConnection const& right) = delete;
};
 
#endif