ICDBManager.h

#pragma once
#include "ParaDatabase.h"
#include <map>
#include <vector>
#include <util/mutex.h>

struct sqlite3_stmt;
struct sqlite3;

#ifndef MAX_SQL_LENGTH 
#define MAX_SQL_LENGTH 2047
#endif

namespace ParaInfoCenter
{
    class CICRecordSet;
    class CICDBManager;
    class DBEntity;

    typedef pair<CICRecordSet*,bool> RSpair;
    typedef pair<DBEntity*,bool> DBpair;

    class CICSQLException
    {
    public:
        CICSQLException(int code,const char *zFormat,...);
        ~CICSQLException();
        int errcode;
        string errmsg;
    };

    class DBEntity 
    {
        friend class CICMapTrace;
        friend class CICRoot;
        friend class CICGenManager;
        friend class CICDBManager;
    public:
        
        PE_CORE_DECL ~DBEntity();
        //
        // database entity member functions
        //
        PE_CORE_DECL void Release();

        void addref()
        {
            ++m_refcount;
        }

        bool delref()
        {
            assert(m_refcount>0);
            return --m_refcount<=0;
        }
        int GetRefCount()
        {
            return m_refcount;
        }

        PE_CORE_DECL int ExecuteSqlStringFormated(const char *sql,...);
        PE_CORE_DECL int ExecuteSqlStringFormated(const char16_t *sql,...);

        PE_CORE_DECL int ExecuteSqlScript(const char *sql, bool bBreakOnError = false);


        PE_CORE_DECL int sql_prepare(const char *sql,...);
        PE_CORE_DECL int sql_prepare(const char16_t *sql,...);

        PE_CORE_DECL int sql_step();

        PE_CORE_DECL int sql_finalize();

        sqlite3_stmt* GetStatement(){return m_stmt;}

        PE_CORE_DECL void OpenDB();

        PE_CORE_DECL void CloseDB();

        PE_CORE_DECL bool IsValid() const {return m_isValid;};
        PE_CORE_DECL const string& GetConnectionString(){return m_filepath;};

        sqlite3 *GetDBHandle(){return m_db;};

        PE_CORE_DECL CICRecordSet* CreateRecordSet(const char* sql,...);
        PE_CORE_DECL CICRecordSet* CreateRecordSet(const char16_t* sql,...);
        PE_CORE_DECL CICRecordSet* CreateRecordSet1(const char* sql);
        PE_CORE_DECL CICRecordSet* CreateRecordSet1(const char16_t* sql);
        PE_CORE_DECL CICRecordSet *CreateRecordSet();
        PE_CORE_DECL void DeleteRecordSet(CICRecordSet* recordset);
        PE_CORE_DECL int64 GetLastInsertRowID();
    
        PE_CORE_DECL bool IsCreateFile();

        PE_CORE_DECL void SetCreateFile(bool bCreateFile);

    protected:
        /* @obsolete the following exec_sql* function are not used. Maybe obsolete soon
        * These functions do not guarantee the ' in text field are properly replaced by ''
        * The exec_sql* function will execute the given sql string completely. It will execute the string as a batch operation
        */

        void exec_sql16(const char16_t *sql);
        void exec_sql(const char *sql);
        void prepare_sql(const char16_t *sql,...);
        void prepare_sql(const char *sql,...);
        void exec_sql();
        void exec_sql16();

        sqlite3_stmt* exec_sql_prepare();
        sqlite3_stmt* exec_sql_prepare16();
        int exec_sql_finish();
        int exec_sql_finish(sqlite3_stmt* stmt);
        int exec_sql_step();
        int exec_sql_step(sqlite3_stmt* stmt);

        void OpenDB16(const char16_t* dbname);
        void OpenDB(const char* dbname);
        string PrepareDatabaseFile(const string& filename);

    protected:
        DBEntity();
        void init();
        sqlite3 *m_db;
        vector<RSpair> m_RSpool;
        u16string m_name;
        string m_filepath;
        bool m_isValid;
        bool m_bEncodingUTF8;

        bool m_bIsCreateFile;

        int m_nSQLite_OpenFlags;

        /* the following only used for sqlite3 wrapper. */
        std::u16string m_wsql;
        std::string m_sql;
        void * m_trail;
        sqlite3_stmt *m_stmt;

        ParaEngine::mutex   m_mutex;

        int m_refcount;
    };

    class CICDBManager
    {
    
    public:
        //
        // database management functions
        //

        PE_CORE_DECL static DBEntity * GetDB(const char16_t* name);
        PE_CORE_DECL static DBEntity *OpenDBEntity();
        PE_CORE_DECL static DBEntity *OpenDBEntity(const char16_t* dbname);
        PE_CORE_DECL static DBEntity *OpenDBEntity(const char* dbname);
        PE_CORE_DECL static DBEntity *OpenDBEntity(const char16_t* name, const char16_t* dbname);
        PE_CORE_DECL static DBEntity *OpenDBEntity(const char* name, const char* dbname);
        PE_CORE_DECL static bool CloseDBEntity(DBEntity * pEntity);

        PE_CORE_DECL static void Finalize();
        PE_CORE_DECL static void StaticInit();
    
    protected:
        static vector<DBpair> m_DBpool;

        static ParaEngine::mutex    m_mutex;
    
    public:
        friend class CICMapTrace;
        friend class CICRoot;
        friend class CICGenManager;
    };
}