cSQLite.h

Go to the documentation of this file.

//
 
#ifndef _INC_cSQLite_H
#define _INC_cSQLite_H
 
#include "GraySQLite.h"
#include "GrayLib/include/SQL/ISQLDriver.h"
 
#ifdef __cplusplus
extern "C" {
#endif
        typedef struct sqlite3 sqlite3;                         // opaque structure.
        typedef struct sqlite3_stmt sqlite3_stmt;       // opaque structure.
        typedef INT64 sqlite3_int64;
#ifdef __cplusplus
}
#endif
 
namespace GraySQLite
{
        typedef int cSQLiteCol_t; 
 
        class GRAYSQLITE_LINK cSQLiteColumn
        {
 
        private:
                ::sqlite3* const m_pDB;
                ::sqlite3_stmt* const m_pStmt;
                const cSQLiteCol_t m_nColumn;   // 0 based col.
 
        public:
                cSQLiteColumn(::sqlite3* pDB, ::sqlite3_stmt* pStmt, cSQLiteCol_t nColumn)
                        : m_pDB(pDB), m_pStmt(pStmt), m_nColumn(nColumn)
                {
                        ASSERT(m_pStmt != nullptr);
                }
 
                int GetInt() const;
                sqlite3_int64 GetInt64() const;
                double GetDouble() const;
                const GChar_t* GetTextPtr() const;
                cString GetString() const;
                cHeapBlock GetBlob() const;
 
                operator int() const
                {
                        return GetInt();
                }
                operator sqlite3_int64() const
                {
                        return GetInt64();
                }
                operator double() const
                {
                        return GetDouble();
                }
                operator const GChar_t*() const
                {
                        return GetTextPtr();
                }
                operator cString() const
                {
                        return GetString();
                }
                operator cHeapBlock() const
                {
                        return GetBlob();
                }
        };
 
        class GRAYSQLITE_LINK cSQLiteBase : public cRefBase
        {
 
                typedef cRefBase SUPER_t;
 
        public:
                ::sqlite3* m_pDB;               
                int m_nNativeError;             
 
        protected:
                HRESULT ThrowOnError();
 
        public:
                cSQLiteBase(::sqlite3* pDB = nullptr)
                        : m_pDB(pDB)
                        , m_nNativeError(0)     // SQLITE_OK=0
                {
                }
                virtual HRESULT FillException(cSQLException* pException = nullptr);
 
#define cSQLiteBase_DISAMBIG virtual HRESULT FillException(cSQLException* pException=nullptr) override { return SUPER_t::FillException(pException); } 
 
                IUNKNOWN_DISAMBIG(SUPER_t);
        };
 
        class GRAYSQLITE_LINK cSQLiteStatement : public cSQLiteBase, public ISQLStatement
        {
 
                typedef cSQLiteBase SUPER_t;
                friend class cSQLiteDb;
 
        protected:
                ::sqlite3_stmt* m_pStmt;        
                bool m_bNeedResetBind;          
 
        protected:
                void ResetBind();
                void ResetBindCheck()
                {
                        if (m_bNeedResetBind)
                                ResetBind();
                }
 
                HRESULT DoBind(SQL_COLUMN_t i, int value);
                HRESULT DoBind(SQL_COLUMN_t i, sqlite3_int64 value);
                HRESULT DoBind(SQL_COLUMN_t i, double value);
                HRESULT DoBind(SQL_COLUMN_t i, const cString& value);
                HRESULT DoBind(SQL_COLUMN_t i, const GChar_t* pszValue, StrLen_t iLen = -1);
                HRESULT DoBind(SQL_COLUMN_t i, const void* pValue, size_t nSize);
                HRESULT DoBind(SQL_COLUMN_t i);
 
                cSQLiteStatement(sqlite3* pDb, const GChar_t* pszQueryStr);
 
        public:
                virtual ~cSQLiteStatement();
 
                virtual HRESULT CloseStatement(bool bDrop) override;
                virtual HRESULT ExecuteAndFetch(bool bResultsExpected) override;
                virtual void ExecCancel() override;
                virtual HRESULT FetchNext(bool bMore = false) override;
                virtual ITERATE_t ReadColumnCount() override;
 
                cSQLiteColumn GetColumn(cSQLiteCol_t iColumn = 0) const;
 
                virtual bool ReadColumnInfo(SQL_COLUMN_t iColumn, OUT cSQLColumnInfo& info) override;
                virtual bool GetColumnVar(SQL_COLUMN_t iColumn, cSQLColumnInfo* pColInfo, OUT cVariant& vValRet) override;
 
                template<class T>
                HRESULT Bind(SQL_COLUMN_t i, const T& value)
                {
                        // 1 based col
                        ResetBindCheck();
                        return DoBind(i, value);
                }
 
                HRESULT BindBlob(SQL_COLUMN_t i, const void* value, int nSize)
                {
                        // 1 based col
                        ResetBindCheck();
                        return DoBind(i, value, nSize);
                }
                HRESULT BindNull(SQL_COLUMN_t i)
                {
                        // 1 based col
                        ResetBindCheck();
                        return DoBind(i);
                }
 
                IUNKNOWN_DISAMBIG(SUPER_t);
                cSQLiteBase_DISAMBIG;
        };
        typedef cRefPtr<cSQLiteStatement> cSQLiteStatementPtr;
 
        class GRAYSQLITE_LINK cSQLiteDb : public cSQLiteBase, public ISQLDatabase
        {
 
                typedef cSQLiteBase SUPER_t;
 
        protected:
                cSQLiteStatement* QueryInternal(const GChar_t* queryStr);
 
        public:
                cSQLiteDb(const FILECHAR_t* fileName);
                virtual ~cSQLiteDb();
 
                virtual HRESULT OpenConnect(const cSQLConnectionString& rConnectionString, INT_PTR hParentWnd) override;
                virtual HRESULT ReadConfigDB(OUT cSQLConfigDB& cfg) override;
                virtual bool Disconnect() override;
 
                cSQLiteStatementPtr Query(const GChar_t* queryStr)
                {
                        return QueryInternal(queryStr);
                }
                virtual ISQLStatement* AllocISQLStatement(const cSQLCmd& oCmd) override;
 
                HRESULT BeginTransaction()
                {
                        return Query(_GT("BEGIN;"))->ExecuteAndFetch(false);
                }
                virtual HRESULT EndTransaction(bool bCommit) override
                {
                        return Query(bCommit ? _GT("COMMIT;") : _GT("ROLLBACK;"))->ExecuteAndFetch(false);
                }
 
                bool TableExists(const GChar_t* tableName);
                sqlite3_int64 LastId();
 
                IUNKNOWN_DISAMBIG(SUPER_t);
                cSQLiteBase_DISAMBIG;
        };
}
 
#endif