database.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2013 OTClient <https://github.com/edubart/otclient>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#ifndef DATABASE_H
#define DATABASE_H
#include "declarations.h"
 
#include <framework/luaengine/luaobject.h>
 
#include <boost/thread.hpp>
 
class Database : public LuaObject
{
public:
    friend class DBTransaction;
 
    Database(): m_connected(false) {}
    virtual ~Database() { m_connected = false; }
 
    virtual void connect(const std::string& host, const std::string& user, const std::string& pass,
                 const std::string& db, uint16 port, const std::string& unix_socket = "") {}
 
    virtual bool beginTransaction() { return false; }
    virtual bool rollback() { return false; }
    virtual bool commit() { return false; }
 
    virtual bool executeQuery(const std::string& query) { return false; }
 
    virtual DBResultPtr storeQuery(const std::string& query) { return nullptr; }
 
    virtual std::string escapeString(const std::string&) { return "''"; }
 
    virtual std::string escapeBlob(const char*, uint32) { return "''"; }
 
    virtual uint64 getLastInsertedRowID() { return 0; }
 
    virtual std::string getStringComparer() { return "= "; }
    virtual std::string getUpdateLimiter() { return " LIMIT 1;"; }
 
    virtual Fw::DatabaseEngine getDatabaseEngine() { return Fw::DatabaseNone; }
 
    bool isConnected() { return m_connected; }
 
protected:
    void setConnected(bool connected) { m_connected = connected; }
 
    virtual bool handleError() { return false; }
    virtual bool internalExecuteQuery(const std::string &query) { return false; }
 
    DBResultPtr verifyResult(DBResultPtr result);
 
    ticks_t m_use;
    bool m_connected;
 
private:
    static DatabasePtr m_instance;
};
 
class DBResult : public LuaObject
{
public:
    DBResult() {}
    virtual ~DBResult() {}
 
    virtual int32 getDataInt(const std::string&) { return 0; }
 
    virtual int64 getDataLong(const std::string&) { return 0; }
 
    virtual std::string getDataString(const std::string&) { return ""; }
 
    virtual const char* getDataStream(const std::string&, uint64&) { return ""; }
 
    virtual void free() {}
 
    virtual bool next() { return false; }
 
    virtual int getRowCount() { return 0; }
};
 
class DBQuery : public std::stringstream, public LuaObject
{
friend class Database;
public:
    DBQuery() { databaseLock.lock(); }
    ~DBQuery() { databaseLock.unlock(); }
 
    void set(std::string& query) { str(query); }
    void append(char query) { putback(query); }
 
protected:
    static boost::recursive_mutex databaseLock;
};
 
class DBInsert
{
public:
    DBInsert(const DatabasePtr& db): m_db(db), m_rows(0) {}
    ~DBInsert() {}
 
    void setQuery(const std::string& query);
 
    bool addRow(const std::string& row);
 
    bool addRow(std::stringstream& row);
 
    bool execute();
 
protected:
    DatabasePtr m_db;
 
    uint32 m_rows;
    std::string m_query;
    std::string m_buf;
};
 
class DBTransaction
{
public:
    DBTransaction(DatabasePtr database)
    {
        m_db = database;
        m_state = STATE_FRESH;
    }
 
    ~DBTransaction()
    {
        if(m_state == STATE_READY)
            m_db->rollback();
    }
 
    bool begin()
    {
        m_state = STATE_READY;
        return m_db->beginTransaction();
    }
 
    bool commit()
    {
        if(m_state != STATE_READY)
            return false;
 
        m_state = STATE_DONE;
        return m_db->commit();
    }
 
private:
    DatabasePtr m_db;
    enum TransactionStates_t
    {
        STATE_FRESH,
        STATE_READY,
        STATE_DONE
    } m_state;
};
 
#endif