KompexSQLiteStatement.h

Go to the documentation of this file.

/*
    This file is part of Kompex SQLite Wrapper.
    Copyright (c) 2008-2015 Sven Broeske

    Kompex SQLite Wrapper is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Kompex SQLite Wrapper 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 Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Kompex SQLite Wrapper. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef KompexSQLiteStatement_H
#define KompexSQLiteStatement_H

#include <map>
#include <string>

#include "sqlite3.h"

#include "KompexSQLitePrerequisites.h"

namespace Kompex
{   
    class SQLiteDatabase;

    enum ENCODING
    {
        UTF8 = 1,
        UTF16LE = 2,
        UTF16BE = 3,
        UTF16 = 4,
        UTF16_ALIGNED = 8
    };

    class _SQLiteWrapperExport SQLiteStatement
    {
    public:
        SQLiteStatement(SQLiteDatabase *db);
        virtual ~SQLiteStatement();

        inline void SqlStatement(const std::string &sqlStatement) {SqlStatement(sqlStatement.c_str());}
        void SqlStatement(const char *sqlStatement);
        inline void SqlStatement(const std::wstring &sqlStatement) {SqlStatement(sqlStatement.c_str());}
        void SqlStatement(const wchar_t *sqlStatement);

        inline void Sql(const std::string &sql) {Prepare(sql.c_str());}
        inline void Sql(const char *sql) {Prepare(sql);}
        inline void Sql(const std::wstring &sql) {Prepare(sql.c_str());}
        inline void Sql(const wchar_t *sql) {Prepare(sql);}

        bool FetchRow() const;
        void FreeQuery();

        float SqlAggregateFuncResult(const std::string &countSql);
        float SqlAggregateFuncResult(wchar_t *countSql);
        float SqlAggregateFuncResult(const char *countSql);

        const char *GetColumnName(int column) const;
        const char *GetColumnName(const std::string &column) const;

        wchar_t *GetColumnName16(int column) const;
        wchar_t *GetColumnName16(const std::string &column) const;

        int GetColumnType(int column) const;
        int GetColumnType(const std::string &column) const;

        const unsigned char *GetColumnCString(int column) const;
        const unsigned char *GetColumnCString(const std::string &column) const;

        std::string GetColumnString(int column) const;
        std::string GetColumnString(const std::string &column) const;

        wchar_t *GetColumnString16(int column) const;
        wchar_t *GetColumnString16(const std::string &column) const;

        double GetColumnDouble(int column) const;
        double GetColumnDouble(const std::string &column) const;

        int GetColumnInt(int column) const;
        int GetColumnInt(const std::string &column) const;

        bool GetColumnBool(int column) const;
        bool GetColumnBool(const std::string &column) const;

        int64 GetColumnInt64(int column) const;
        int64 GetColumnInt64(const std::string &column) const;

        const void *GetColumnBlob(int column) const;
        const void *GetColumnBlob(const std::string &column) const;     
        
        int GetColumnBytes(int column) const;
        int GetColumnBytes(const std::string &column) const;        
        int GetColumnBytes16(int column) const;
        int GetColumnBytes16(const std::string &column) const;      
        
        const char *GetColumnDatabaseName(int column) const;
        const char *GetColumnDatabaseName(const std::string &column) const;
        wchar_t *GetColumnDatabaseName16(int column) const;
        wchar_t *GetColumnDatabaseName16(const std::string &column) const;

        const char *GetColumnTableName(int column) const;
        const char *GetColumnTableName(const std::string &column) const;
        wchar_t *GetColumnTableName16(int column) const;
        wchar_t *GetColumnTableName16(const std::string &column) const;

        const char *GetColumnOriginName(int column) const;
        const char *GetColumnOriginName(const std::string &column) const;
        wchar_t *GetColumnOriginName16(int column) const;
        wchar_t *GetColumnOriginName16(const std::string &column) const;

        const char *GetColumnDeclaredDatatype(int column) const;
        const char *GetColumnDeclaredDatatype(const std::string &column) const;
        wchar_t *GetColumnDeclaredDatatype16(int column) const;
        wchar_t *GetColumnDeclaredDatatype16(const std::string &column) const;

        int GetColumnCount() const;
        inline int GetDataCount() const {return sqlite3_data_count(mStatement);}

        void BindInt(int column, int value) const;
        void BindBool(int column, bool value) const;
        void BindString(int column, const std::string &string) const;
        void BindString16(int column, const wchar_t *string) const;
        void BindString64(int column, const char *string, uint64 byteLength, ENCODING encoding) const;
        void BindDouble(int column, double value) const;
        void BindInt64(int column, int64 value) const;
        void BindNull(int column) const;
        void BindBlob(int column, const void* data, int numberOfBytes = -1) const;
        void BindBlob64(int column, const void* data, uint64 numberOfBytes = -1) const;
        void BindZeroBlob(int column, int length) const;
        void BindZeroBlob64(int column, uint64 length) const;

        void Execute() const;
        void ExecuteAndFree();

        void GetTable(const std::string &sql, unsigned short consoleOutputColumnWidth = 20) const;

        void GetTableColumnMetadata(const std::string &tableName, const std::string &columnName) const;

        void ClearBindings() const;

        void Reset() const;

        void BeginTransaction();
        void CommitTransaction();
        inline void RollbackTransaction()
        {
            FreeQuery();
            SqlStatement("ROLLBACK;");
        }

        inline void Transaction(const char *sql) {mTransactionSQL[mTransactionID++] = std::make_pair(sql, false);}
        inline void Transaction(const std::string &sql) {mTransactionSQL[mTransactionID++] = std::make_pair(sql.c_str(), false);}
        inline void Transaction(const wchar_t *sql) {mTransactionSQL16[mTransactionID++] = std::make_pair(sql, false);}

        void SecureTransaction(const char *sql);
        void SecureTransaction(const std::string sql);
        void SecureTransaction(const wchar_t *sql);

        std::string GetSqlResultString(const std::string &sql, const std::string &defaultReturnValue = "");
        std::string GetSqlResultString(const char *sql, const std::string &defaultReturnValue = "");
        std::string GetSqlResultString(const wchar_t *sql, const std::string &defaultReturnValue = "");

        int GetSqlResultInt(const std::string &sql, int defaultReturnValue = -1);
        int GetSqlResultInt(const char *sql, int defaultReturnValue = -1);
        int GetSqlResultInt(const wchar_t *sql, int defaultReturnValue = -1);

        int64 GetSqlResultInt64(const std::string &sql, int64 defaultReturnValue = -1);
        int64 GetSqlResultInt64(const char *sql, int64 defaultReturnValue = -1);
        int64 GetSqlResultInt64(const wchar_t *sql, int64 defaultReturnValue = -1);

        double GetSqlResultDouble(const std::string &sql, double defaultReturnValue = -1);
        double GetSqlResultDouble(const char *sql, double defaultReturnValue = -1);
        double GetSqlResultDouble(const wchar_t *sql, double defaultReturnValue = -1);

        const unsigned char *GetSqlResultCString(const std::string &sql, const unsigned char *defaultReturnValue = 0);
        const unsigned char *GetSqlResultCString(const char *sql, const unsigned char *defaultReturnValue = 0);
        const unsigned char *GetSqlResultCString(const wchar_t *sql, const unsigned char *defaultReturnValue = 0); 

        wchar_t *GetSqlResultString16(const std::string &sql, wchar_t *defaultReturnValue = 0); 
        wchar_t *GetSqlResultString16(const char *sql, wchar_t *defaultReturnValue = 0); 
        wchar_t *GetSqlResultString16(const wchar_t *sql, wchar_t *defaultReturnValue = 0); 

        const void *GetSqlResultBlob(const std::string &sql, const void *defaultReturnValue = 0); 
        const void *GetSqlResultBlob(const char *sql, const void *defaultReturnValue = 0); 
        const void *GetSqlResultBlob(const wchar_t *sql, const void *defaultReturnValue = 0);

        unsigned int GetNumberOfRows();
                
        static std::string Mprintf(const char *sql, ...);
        static std::string Vmprintf(const char *sql, va_list args);

    protected:
        void Prepare(const char *sqlStatement);
        void Prepare(const wchar_t *sqlStatement);
        bool Step() const;
        void CheckStatement() const;
        void CheckDatabase() const;

        sqlite3_stmt *GetStatementHandle() const {return mStatement;}

        const unsigned char *SqlResultCString(const unsigned char *defaultReturnValue);
        wchar_t *SqlResultString16(wchar_t *defaultReturnValue);
        const void *SqlResultBlob(const void *defaultReturnValue);

        void CheckColumnNumber(int columnNumber, const std::string &functionName = "") const;
        
        void CleanUpTransaction();

        template<class T>
        inline void DeleteTransactionSqlStr(bool isMemAllocated, T *str)
        {
            if(isMemAllocated)
                delete[] str;
        }

        template<class S, class T>
        T GetColumnValue(S sql, T(Kompex::SQLiteStatement::*getColumnFunc)(int columnNumber)const, T defaultReturnValue);

    private:
        void AssignColumnNumberToColumnName() const;
        int GetAssignedColumnNumber(const std::string &columnName) const;

        struct sqlite3_stmt *mStatement;
        SQLiteDatabase *mDatabase;

        typedef std::map<unsigned short /* transaction id */, std::pair<const char* /* sql */, bool /* memory allocated */> > TTransactionSQL;
        typedef std::map<unsigned short /* transaction id */, std::pair<const wchar_t* /* sql */, bool /*  is memory allocated */> > TTransactionSQL16;
    
        TTransactionSQL mTransactionSQL;
        TTransactionSQL16 mTransactionSQL16;

        unsigned short mTransactionID;
        
        mutable std::map<std::string /* column name */, int /* column number */> mColumnNumberToColumnNameAssignment;
        mutable bool mIsColumnNumberAssignedToColumnName;

    };
};

#endif // KompexSQLiteStatement_H