www.pudn.com > CppSQLite_3_1_demo_and_src.zip > CppSQLite3.h

//////////////////////////////////////////////////////////////////////////////// 
// CppSQLite3 - A C++ wrapper around the SQLite3 embedded database library. 
// 
// Copyright (c) 2004 Rob Groves. All Rights Reserved. rob.groves@btinternet.com 
//  
// Permission to use, copy, modify, and distribute this software and its 
// documentation for any purpose, without fee, and without a written 
// agreement, is hereby granted, provided that the above copyright notice,  
// this paragraph and the following two paragraphs appear in all copies,  
// modifications, and distributions. 
// 
// IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, 
// INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST 
// PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, 
// EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
// 
// THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
// PARTICULAR PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF 
// ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". THE AUTHOR HAS NO OBLIGATION 
// TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 
// 
// V3.0		03/08/2004	-Initial Version for sqlite3 
// 
// V3.1		16/09/2004	-Implemented getXXXXField using sqlite3 functions 
//						-Added CppSQLiteDB3::tableExists() 
//////////////////////////////////////////////////////////////////////////////// 
#ifndef _CppSQLite3_H_ 
#define _CppSQLite3_H_ 
 
#include "sqlite3.h" 
#include  
#include  
 
#define CPPSQLITE_ERROR 1000 
 
class CppSQLite3Exception 
{ 
public: 
 
    CppSQLite3Exception(const int nErrCode, 
                    char* szErrMess, 
                    bool bDeleteMsg=true); 
 
    CppSQLite3Exception(const CppSQLite3Exception&  e); 
 
    virtual ~CppSQLite3Exception(); 
 
    const int errorCode() { return mnErrCode; } 
 
    const char* errorMessage() { return mpszErrMess; } 
 
    static const char* errorCodeAsString(int nErrCode); 
 
private: 
 
    int mnErrCode; 
    char* mpszErrMess; 
}; 
 
 
class CppSQLite3Buffer 
{ 
public: 
 
    CppSQLite3Buffer(); 
 
    ~CppSQLite3Buffer(); 
 
    const char* format(const char* szFormat, ...); 
 
    operator const char*() { return mpBuf; } 
 
    void clear(); 
 
private: 
 
    char* mpBuf; 
}; 
 
 
class CppSQLite3Binary 
{ 
public: 
 
    CppSQLite3Binary(); 
 
    ~CppSQLite3Binary(); 
 
    void setBinary(const unsigned char* pBuf, int nLen); 
    void setEncoded(const unsigned char* pBuf); 
 
    const unsigned char* getEncoded(); 
    const unsigned char* getBinary(); 
 
    int getBinaryLength(); 
 
    unsigned char* allocBuffer(int nLen); 
 
    void clear(); 
 
private: 
 
    unsigned char* mpBuf; 
    int mnBinaryLen; 
    int mnBufferLen; 
    int mnEncodedLen; 
    bool mbEncoded; 
}; 
 
 
class CppSQLite3Query 
{ 
public: 
 
    CppSQLite3Query(); 
 
    CppSQLite3Query(const CppSQLite3Query& rQuery); 
 
    CppSQLite3Query(sqlite3* pDB, 
				sqlite3_stmt* pVM, 
                bool bEof, 
                bool bOwnVM=true); 
 
    CppSQLite3Query& operator=(const CppSQLite3Query& rQuery); 
 
    virtual ~CppSQLite3Query(); 
 
    int numFields(); 
 
    int fieldIndex(const char* szField); 
    const char* fieldName(int nCol); 
 
    const char* fieldDeclType(int nCol); 
    int fieldDataType(int nCol); 
 
    const char* fieldValue(int nField); 
    const char* fieldValue(const char* szField); 
 
    int getIntField(int nField, int nNullValue=0); 
    int getIntField(const char* szField, int nNullValue=0); 
 
    double getFloatField(int nField, double fNullValue=0.0); 
    double getFloatField(const char* szField, double fNullValue=0.0); 
 
    const char* getStringField(int nField, const char* szNullValue=""); 
    const char* getStringField(const char* szField, const char* szNullValue=""); 
 
    const unsigned char* getBlobField(int nField, int& nLen); 
    const unsigned char* getBlobField(const char* szField, int& nLen); 
 
    bool fieldIsNull(int nField); 
    bool fieldIsNull(const char* szField); 
 
    bool eof(); 
 
    void nextRow(); 
 
    void finalize(); 
 
private: 
 
    void checkVM(); 
 
	sqlite3* mpDB; 
    sqlite3_stmt* mpVM; 
    bool mbEof; 
    int mnCols; 
    bool mbOwnVM; 
}; 
 
 
class CppSQLite3Table 
{ 
public: 
 
    CppSQLite3Table(); 
 
    CppSQLite3Table(const CppSQLite3Table& rTable); 
 
    CppSQLite3Table(char** paszResults, int nRows, int nCols); 
 
    virtual ~CppSQLite3Table(); 
 
    CppSQLite3Table& operator=(const CppSQLite3Table& rTable); 
 
    int numFields(); 
 
    int numRows(); 
 
    const char* fieldName(int nCol); 
 
    const char* fieldValue(int nField); 
    const char* fieldValue(const char* szField); 
 
    int getIntField(int nField, int nNullValue=0); 
    int getIntField(const char* szField, int nNullValue=0); 
 
    double getFloatField(int nField, double fNullValue=0.0); 
    double getFloatField(const char* szField, double fNullValue=0.0); 
 
    const char* getStringField(int nField, const char* szNullValue=""); 
    const char* getStringField(const char* szField, const char* szNullValue=""); 
 
    bool fieldIsNull(int nField); 
    bool fieldIsNull(const char* szField); 
 
    void setRow(int nRow); 
 
    void finalize(); 
 
private: 
 
    void checkResults(); 
 
    int mnCols; 
    int mnRows; 
    int mnCurrentRow; 
    char** mpaszResults; 
}; 
 
 
class CppSQLite3Statement 
{ 
public: 
 
    CppSQLite3Statement(); 
 
    CppSQLite3Statement(const CppSQLite3Statement& rStatement); 
 
    CppSQLite3Statement(sqlite3* pDB, sqlite3_stmt* pVM); 
 
    virtual ~CppSQLite3Statement(); 
 
    CppSQLite3Statement& operator=(const CppSQLite3Statement& rStatement); 
 
    int execDML(); 
 
    CppSQLite3Query execQuery(); 
 
    void bind(int nParam, const char* szValue); 
    void bind(int nParam, const int nValue); 
    void bind(int nParam, const double dwValue); 
    void bind(int nParam, const unsigned char* blobValue, int nLen); 
    void bindNull(int nParam); 
 
    void reset(); 
 
    void finalize(); 
 
private: 
 
    void checkDB(); 
    void checkVM(); 
 
    sqlite3* mpDB; 
    sqlite3_stmt* mpVM; 
}; 
 
 
class CppSQLite3DB 
{ 
public: 
 
    CppSQLite3DB(); 
 
    virtual ~CppSQLite3DB(); 
 
    void open(const char* szFile); 
 
    void close(); 
 
	bool tableExists(const char* szTable); 
 
    int execDML(const char* szSQL); 
 
    CppSQLite3Query execQuery(const char* szSQL); 
 
    int execScalar(const char* szSQL); 
 
    CppSQLite3Table getTable(const char* szSQL); 
 
    CppSQLite3Statement compileStatement(const char* szSQL); 
 
    sqlite_int64 lastRowId(); 
 
    void interrupt() { sqlite3_interrupt(mpDB); } 
 
    void setBusyTimeout(int nMillisecs); 
 
    static const char* SQLiteVersion() { return SQLITE_VERSION; } 
 
private: 
 
    CppSQLite3DB(const CppSQLite3DB& db); 
    CppSQLite3DB& operator=(const CppSQLite3DB& db); 
 
    sqlite3_stmt* compile(const char* szSQL); 
 
    void checkDB(); 
 
    sqlite3* mpDB; 
    int mnBusyTimeoutMs; 
}; 
 
#endif