C++使用Sqlite3，使用CppSQLite3的封装

////////////////////////////////////////////////////////////////////////////////
// CppSQLite3 - A C++ wrapper around the SQLite3 embedded database library.
//
// Copyright (c) 2004..2007 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()
//
// V3.2     01/07/2005  -Fixed execScalar to handle a NULL result
//          12/07/2007  -Added CppSQLiteDB::IsAutoCommitOn()
//                      -Added int64 functions to CppSQLite3Query
//                      -Added Name based parameter binding to CppSQLite3Statement.
////////////////////////////////////////////////////////////////////////////////
#ifndef _CppSQLite3_H_
#define _CppSQLite3_H_

#include "sqlite3.h"
#include <cstdio>
#include <cstring>

#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);

sqlite_int64 getInt64Field(int nField, sqlite_int64 nNullValue=0);
sqlite_int64 getInt64Field(const char* szField, sqlite_int64 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);

int bindParameterIndex(const char* szParam);
void bind(const char* szParam, const char* szValue);
void bind(const char* szParam, const int nValue);
void bind(const char* szParam, const double dwValue);
void bind(const char* szParam, const unsigned char* blobValue, int nLen);
void bindNull(const char* szParam);

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, int nNullValue=0);

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; }
static const char* SQLiteHeaderVersion() { return SQLITE_VERSION; }
static const char* SQLiteLibraryVersion() { return sqlite3_libversion(); }
static int SQLiteLibraryVersionNumber() { return sqlite3_libversion_number(); }

bool IsAutoCommitOn();

private:

CppSQLite3DB(const CppSQLite3DB& db);
CppSQLite3DB& operator=(const CppSQLite3DB& db);

sqlite3_stmt* compile(const char* szSQL);

void checkDB();

sqlite3* mpDB;
int mnBusyTimeoutMs;
};

#endif

////////////////////////////////////////////////////////////////////////////////
// CppSQLite3 - A C++ wrapper around the SQLite3 embedded database library.
//
// Copyright (c) 2004..2007 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()
//
// V3.2     01/07/2005  -Fixed execScalar to handle a NULL result
//          12/07/2007  -Added int64 functions to CppSQLite3Query
//                      -Throw exception from CppSQLite3DB::close() if error
//                      -Trap above exception in CppSQLite3DB::~CppSQLite3DB()
//                      -Fix to CppSQLite3DB::compile() as provided by Dave Rollins.
//                      -sqlite3_prepare replaced with sqlite3_prepare_v2
//                      -Added Name based parameter binding to CppSQLite3Statement.
////////////////////////////////////////////////////////////////////////////////
#include "CppSQLite3.h"
#include <cstdlib>

// Named constant for passing to CppSQLite3Exception when passing it a string
// that cannot be deleted.
static const bool DONT_DELETE_MSG=false;

////////////////////////////////////////////////////////////////////////////////
// Prototypes for SQLite functions not included in SQLite DLL, but copied below
// from SQLite encode.c
////////////////////////////////////////////////////////////////////////////////
int sqlite3_encode_binary(const unsigned char *in, int n, unsigned char *out);
int sqlite3_decode_binary(const unsigned char *in, unsigned char *out);

////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

CppSQLite3Exception::CppSQLite3Exception(const int nErrCode,
char* szErrMess,
bool bDeleteMsg/*=true*/) :
mnErrCode(nErrCode)
{
mpszErrMess = sqlite3_mprintf("%s[%d]: %s",
errorCodeAsString(nErrCode),
nErrCode,
szErrMess ? szErrMess : "");

if (bDeleteMsg && szErrMess)
{
sqlite3_free(szErrMess);
}
}

CppSQLite3Exception::CppSQLite3Exception(const CppSQLite3Exception&  e) :
mnErrCode(e.mnErrCode)
{
mpszErrMess = 0;
if (e.mpszErrMess)
{
mpszErrMess = sqlite3_mprintf("%s", e.mpszErrMess);
}
}

const char* CppSQLite3Exception::errorCodeAsString(int nErrCode)
{
switch (nErrCode)
{
case SQLITE_OK          : return "SQLITE_OK";
case SQLITE_ERROR       : return "SQLITE_ERROR";
case SQLITE_INTERNAL    : return "SQLITE_INTERNAL";
case SQLITE_PERM        : return "SQLITE_PERM";
case SQLITE_ABORT       : return "SQLITE_ABORT";
case SQLITE_BUSY        : return "SQLITE_BUSY";
case SQLITE_LOCKED      : return "SQLITE_LOCKED";
case SQLITE_NOMEM       : return "SQLITE_NOMEM";
case SQLITE_READONLY    : return "SQLITE_READONLY";
case SQLITE_INTERRUPT   : return "SQLITE_INTERRUPT";
case SQLITE_IOERR       : return "SQLITE_IOERR";
case SQLITE_CORRUPT     : return "SQLITE_CORRUPT";
case SQLITE_NOTFOUND    : return "SQLITE_NOTFOUND";
case SQLITE_FULL        : return "SQLITE_FULL";
case SQLITE_CANTOPEN    : return "SQLITE_CANTOPEN";
case SQLITE_PROTOCOL    : return "SQLITE_PROTOCOL";
case SQLITE_EMPTY       : return "SQLITE_EMPTY";
case SQLITE_SCHEMA      : return "SQLITE_SCHEMA";
case SQLITE_TOOBIG      : return "SQLITE_TOOBIG";
case SQLITE_CONSTRAINT  : return "SQLITE_CONSTRAINT";
case SQLITE_MISMATCH    : return "SQLITE_MISMATCH";
case SQLITE_MISUSE      : return "SQLITE_MISUSE";
case SQLITE_NOLFS       : return "SQLITE_NOLFS";
case SQLITE_AUTH        : return "SQLITE_AUTH";
case SQLITE_FORMAT      : return "SQLITE_FORMAT";
case SQLITE_RANGE       : return "SQLITE_RANGE";
case SQLITE_ROW         : return "SQLITE_ROW";
case SQLITE_DONE        : return "SQLITE_DONE";
case CPPSQLITE_ERROR    : return "CPPSQLITE_ERROR";
default: return "UNKNOWN_ERROR";
}
}

CppSQLite3Exception::~CppSQLite3Exception()
{
if (mpszErrMess)
{
sqlite3_free(mpszErrMess);
mpszErrMess = 0;
}
}

////////////////////////////////////////////////////////////////////////////////

CppSQLite3Buffer::CppSQLite3Buffer()
{
mpBuf = 0;
}

CppSQLite3Buffer::~CppSQLite3Buffer()
{
clear();
}

void CppSQLite3Buffer::clear()
{
if (mpBuf)
{
sqlite3_free(mpBuf);
mpBuf = 0;
}

}

const char* CppSQLite3Buffer::format(const char* szFormat, ...)
{
clear();
va_list va;
va_start(va, szFormat);
mpBuf = sqlite3_vmprintf(szFormat, va);
va_end(va);
return mpBuf;
}

////////////////////////////////////////////////////////////////////////////////

CppSQLite3Binary::CppSQLite3Binary() :
mpBuf(0),
mnBinaryLen(0),
mnBufferLen(0),
mnEncodedLen(0),
mbEncoded(false)
{
}

CppSQLite3Binary::~CppSQLite3Binary()
{
clear();
}

void CppSQLite3Binary::setBinary(const unsigned char* pBuf, int nLen)
{
mpBuf = allocBuffer(nLen);
memcpy(mpBuf, pBuf, nLen);
}

void CppSQLite3Binary::setEncoded(const unsigned char* pBuf)
{
clear();

mnEncodedLen = strlen((const char*)pBuf);
mnBufferLen = mnEncodedLen + 1; // Allow for NULL terminator

mpBuf = (unsigned char*)malloc(mnBufferLen);

if (!mpBuf)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Cannot allocate memory",
DONT_DELETE_MSG);
}

memcpy(mpBuf, pBuf, mnBufferLen);
mbEncoded = true;
}

const unsigned char* CppSQLite3Binary::getEncoded()
{
if (!mbEncoded)
{
unsigned char* ptmp = (unsigned char*)malloc(mnBinaryLen);
memcpy(ptmp, mpBuf, mnBinaryLen);
mnEncodedLen = sqlite3_encode_binary(ptmp, mnBinaryLen, mpBuf);
free(ptmp);
mbEncoded = true;
}

return mpBuf;
}

const unsigned char* CppSQLite3Binary::getBinary()
{
if (mbEncoded)
{
// in/out buffers can be the same
mnBinaryLen = sqlite3_decode_binary(mpBuf, mpBuf);

if (mnBinaryLen == -1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Cannot decode binary",
DONT_DELETE_MSG);
}

mbEncoded = false;
}

return mpBuf;
}

int CppSQLite3Binary::getBinaryLength()
{
getBinary();
return mnBinaryLen;
}

unsigned char* CppSQLite3Binary::allocBuffer(int nLen)
{
clear();

// Allow extra space for encoded binary as per comments in
// SQLite encode.c See bottom of this file for implementation
// of SQLite functions use 3 instead of 2 just to be sure ;-)
mnBinaryLen = nLen;
mnBufferLen = 3 + (257*nLen)/254;

mpBuf = (unsigned char*)malloc(mnBufferLen);

if (!mpBuf)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Cannot allocate memory",
DONT_DELETE_MSG);
}

mbEncoded = false;

return mpBuf;
}

void CppSQLite3Binary::clear()
{
if (mpBuf)
{
mnBinaryLen = 0;
mnBufferLen = 0;
free(mpBuf);
mpBuf = 0;
}
}

////////////////////////////////////////////////////////////////////////////////

CppSQLite3Query::CppSQLite3Query()
{
mpVM = 0;
mbEof = true;
mnCols = 0;
mbOwnVM = false;
}

CppSQLite3Query::CppSQLite3Query(const CppSQLite3Query& rQuery)
{
mpVM = rQuery.mpVM;
// Only one object can own the VM
const_cast<CppSQLite3Query&>(rQuery).mpVM = 0;
mbEof = rQuery.mbEof;
mnCols = rQuery.mnCols;
mbOwnVM = rQuery.mbOwnVM;
}

CppSQLite3Query::CppSQLite3Query(sqlite3* pDB,
sqlite3_stmt* pVM,
bool bEof,
bool bOwnVM/*=true*/)
{
mpDB = pDB;
mpVM = pVM;
mbEof = bEof;
mnCols = sqlite3_column_count(mpVM);
mbOwnVM = bOwnVM;
}

CppSQLite3Query::~CppSQLite3Query()
{
try
{
finalize();
}
catch (...)
{
}
}

CppSQLite3Query& CppSQLite3Query::operator=(const CppSQLite3Query& rQuery)
{
try
{
finalize();
}
catch (...)
{
}
mpVM = rQuery.mpVM;
// Only one object can own the VM
const_cast<CppSQLite3Query&>(rQuery).mpVM = 0;
mbEof = rQuery.mbEof;
mnCols = rQuery.mnCols;
mbOwnVM = rQuery.mbOwnVM;
return *this;
}

int CppSQLite3Query::numFields()
{
checkVM();
return mnCols;
}

const char* CppSQLite3Query::fieldValue(int nField)
{
checkVM();

if (nField < 0 || nField > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field index requested",
DONT_DELETE_MSG);
}

return (const char*)sqlite3_column_text(mpVM, nField);
}

const char* CppSQLite3Query::fieldValue(const char* szField)
{
int nField = fieldIndex(szField);
return (const char*)sqlite3_column_text(mpVM, nField);
}

int CppSQLite3Query::getIntField(int nField, int nNullValue/*=0*/)
{
if (fieldDataType(nField) == SQLITE_NULL)
{
return nNullValue;
}
else
{
return sqlite3_column_int(mpVM, nField);
}
}

int CppSQLite3Query::getIntField(const char* szField, int nNullValue/*=0*/)
{
int nField = fieldIndex(szField);
return getIntField(nField, nNullValue);
}

sqlite_int64 CppSQLite3Query::getInt64Field(int nField, sqlite_int64 nNullValue/*=0*/)
{
if (fieldDataType(nField) == SQLITE_NULL)
{
return nNullValue;
}
else
{
return sqlite3_column_int64(mpVM, nField);
}
}

sqlite_int64 CppSQLite3Query::getInt64Field(const char* szField, sqlite_int64 nNullValue/*=0*/)
{
int nField = fieldIndex(szField);
return getInt64Field(nField, nNullValue);
}

double CppSQLite3Query::getFloatField(int nField, double fNullValue/*=0.0*/)
{
if (fieldDataType(nField) == SQLITE_NULL)
{
return fNullValue;
}
else
{
return sqlite3_column_double(mpVM, nField);
}
}

double CppSQLite3Query::getFloatField(const char* szField, double fNullValue/*=0.0*/)
{
int nField = fieldIndex(szField);
return getFloatField(nField, fNullValue);
}

const char* CppSQLite3Query::getStringField(int nField, const char* szNullValue/*=""*/)
{
if (fieldDataType(nField) == SQLITE_NULL)
{
return szNullValue;
}
else
{
return (const char*)sqlite3_column_text(mpVM, nField);
}
}

const char* CppSQLite3Query::getStringField(const char* szField, const char* szNullValue/*=""*/)
{
int nField = fieldIndex(szField);
return getStringField(nField, szNullValue);
}

const unsigned char* CppSQLite3Query::getBlobField(int nField, int& nLen)
{
checkVM();

if (nField < 0 || nField > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field index requested",
DONT_DELETE_MSG);
}

nLen = sqlite3_column_bytes(mpVM, nField);
return (const unsigned char*)sqlite3_column_blob(mpVM, nField);
}

const unsigned char* CppSQLite3Query::getBlobField(const char* szField, int& nLen)
{
int nField = fieldIndex(szField);
return getBlobField(nField, nLen);
}

bool CppSQLite3Query::fieldIsNull(int nField)
{
return (fieldDataType(nField) == SQLITE_NULL);
}

bool CppSQLite3Query::fieldIsNull(const char* szField)
{
int nField = fieldIndex(szField);
return (fieldDataType(nField) == SQLITE_NULL);
}

int CppSQLite3Query::fieldIndex(const char* szField)
{
checkVM();

if (szField)
{
for (int nField = 0; nField < mnCols; nField++)
{
const char* szTemp = sqlite3_column_name(mpVM, nField);

if (strcmp(szField, szTemp) == 0)
{
return nField;
}
}
}

throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field name requested",
DONT_DELETE_MSG);
}

const char* CppSQLite3Query::fieldName(int nCol)
{
checkVM();

if (nCol < 0 || nCol > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field index requested",
DONT_DELETE_MSG);
}

return sqlite3_column_name(mpVM, nCol);
}

const char* CppSQLite3Query::fieldDeclType(int nCol)
{
checkVM();

if (nCol < 0 || nCol > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field index requested",
DONT_DELETE_MSG);
}

return sqlite3_column_decltype(mpVM, nCol);
}

int CppSQLite3Query::fieldDataType(int nCol)
{
checkVM();

if (nCol < 0 || nCol > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field index requested",
DONT_DELETE_MSG);
}

return sqlite3_column_type(mpVM, nCol);
}

bool CppSQLite3Query::eof()
{
checkVM();
return mbEof;
}

void CppSQLite3Query::nextRow()
{
checkVM();

int nRet = sqlite3_step(mpVM);

if (nRet == SQLITE_DONE)
{
// no rows
mbEof = true;
}
else if (nRet == SQLITE_ROW)
{
// more rows, nothing to do
}
else
{
nRet = sqlite3_finalize(mpVM);
mpVM = 0;
const char* szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet,
(char*)szError,
DONT_DELETE_MSG);
}
}

void CppSQLite3Query::finalize()
{
if (mpVM && mbOwnVM)
{
int nRet = sqlite3_finalize(mpVM);
mpVM = 0;
if (nRet != SQLITE_OK)
{
const char* szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet, (char*)szError, DONT_DELETE_MSG);
}
}
}

void CppSQLite3Query::checkVM()
{
if (mpVM == 0)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Null Virtual Machine pointer",
DONT_DELETE_MSG);
}
}

////////////////////////////////////////////////////////////////////////////////

CppSQLite3Table::CppSQLite3Table()
{
mpaszResults = 0;
mnRows = 0;
mnCols = 0;
mnCurrentRow = 0;
}

CppSQLite3Table::CppSQLite3Table(const CppSQLite3Table& rTable)
{
mpaszResults = rTable.mpaszResults;
// Only one object can own the results
const_cast<CppSQLite3Table&>(rTable).mpaszResults = 0;
mnRows = rTable.mnRows;
mnCols = rTable.mnCols;
mnCurrentRow = rTable.mnCurrentRow;
}

CppSQLite3Table::CppSQLite3Table(char** paszResults, int nRows, int nCols)
{
mpaszResults = paszResults;
mnRows = nRows;
mnCols = nCols;
mnCurrentRow = 0;
}

CppSQLite3Table::~CppSQLite3Table()
{
try
{
finalize();
}
catch (...)
{
}
}

CppSQLite3Table& CppSQLite3Table::operator=(const CppSQLite3Table& rTable)
{
try
{
finalize();
}
catch (...)
{
}
mpaszResults = rTable.mpaszResults;
// Only one object can own the results
const_cast<CppSQLite3Table&>(rTable).mpaszResults = 0;
mnRows = rTable.mnRows;
mnCols = rTable.mnCols;
mnCurrentRow = rTable.mnCurrentRow;
return *this;
}

void CppSQLite3Table::finalize()
{
if (mpaszResults)
{
sqlite3_free_table(mpaszResults);
mpaszResults = 0;
}
}

int CppSQLite3Table::numFields()
{
checkResults();
return mnCols;
}

int CppSQLite3Table::numRows()
{
checkResults();
return mnRows;
}

const char* CppSQLite3Table::fieldValue(int nField)
{
checkResults();

if (nField < 0 || nField > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field index requested",
DONT_DELETE_MSG);
}

int nIndex = (mnCurrentRow*mnCols) + mnCols + nField;
return mpaszResults[nIndex];
}

const char* CppSQLite3Table::fieldValue(const char* szField)
{
checkResults();

if (szField)
{
for (int nField = 0; nField < mnCols; nField++)
{
if (strcmp(szField, mpaszResults[nField]) == 0)
{
int nIndex = (mnCurrentRow*mnCols) + mnCols + nField;
return mpaszResults[nIndex];
}
}
}

throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field name requested",
DONT_DELETE_MSG);
}

int CppSQLite3Table::getIntField(int nField, int nNullValue/*=0*/)
{
if (fieldIsNull(nField))
{
return nNullValue;
}
else
{
return atoi(fieldValue(nField));
}
}

int CppSQLite3Table::getIntField(const char* szField, int nNullValue/*=0*/)
{
if (fieldIsNull(szField))
{
return nNullValue;
}
else
{
return atoi(fieldValue(szField));
}
}

double CppSQLite3Table::getFloatField(int nField, double fNullValue/*=0.0*/)
{
if (fieldIsNull(nField))
{
return fNullValue;
}
else
{
return atof(fieldValue(nField));
}
}

double CppSQLite3Table::getFloatField(const char* szField, double fNullValue/*=0.0*/)
{
if (fieldIsNull(szField))
{
return fNullValue;
}
else
{
return atof(fieldValue(szField));
}
}

const char* CppSQLite3Table::getStringField(int nField, const char* szNullValue/*=""*/)
{
if (fieldIsNull(nField))
{
return szNullValue;
}
else
{
return fieldValue(nField);
}
}

const char* CppSQLite3Table::getStringField(const char* szField, const char* szNullValue/*=""*/)
{
if (fieldIsNull(szField))
{
return szNullValue;
}
else
{
return fieldValue(szField);
}
}

bool CppSQLite3Table::fieldIsNull(int nField)
{
checkResults();
return (fieldValue(nField) == 0);
}

bool CppSQLite3Table::fieldIsNull(const char* szField)
{
checkResults();
return (fieldValue(szField) == 0);
}

const char* CppSQLite3Table::fieldName(int nCol)
{
checkResults();

if (nCol < 0 || nCol > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid field index requested",
DONT_DELETE_MSG);
}

return mpaszResults[nCol];
}

void CppSQLite3Table::setRow(int nRow)
{
checkResults();

if (nRow < 0 || nRow > mnRows-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid row index requested",
DONT_DELETE_MSG);
}

mnCurrentRow = nRow;
}

void CppSQLite3Table::checkResults()
{
if (mpaszResults == 0)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Null Results pointer",
DONT_DELETE_MSG);
}
}

////////////////////////////////////////////////////////////////////////////////

CppSQLite3Statement::CppSQLite3Statement()
{
mpDB = 0;
mpVM = 0;
}

CppSQLite3Statement::CppSQLite3Statement(const CppSQLite3Statement& rStatement)
{
mpDB = rStatement.mpDB;
mpVM = rStatement.mpVM;
// Only one object can own VM
const_cast<CppSQLite3Statement&>(rStatement).mpVM = 0;
}

CppSQLite3Statement::CppSQLite3Statement(sqlite3* pDB, sqlite3_stmt* pVM)
{
mpDB = pDB;
mpVM = pVM;
}

CppSQLite3Statement::~CppSQLite3Statement()
{
try
{
finalize();
}
catch (...)
{
}
}

CppSQLite3Statement& CppSQLite3Statement::operator=(const CppSQLite3Statement& rStatement)
{
mpDB = rStatement.mpDB;
mpVM = rStatement.mpVM;
// Only one object can own VM
const_cast<CppSQLite3Statement&>(rStatement).mpVM = 0;
return *this;
}

int CppSQLite3Statement::execDML()
{
checkDB();
checkVM();

const char* szError=0;

int nRet = sqlite3_step(mpVM);

if (nRet == SQLITE_DONE)
{
int nRowsChanged = sqlite3_changes(mpDB);

nRet = sqlite3_reset(mpVM);

if (nRet != SQLITE_OK)
{
szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet, (char*)szError, DONT_DELETE_MSG);
}

return nRowsChanged;
}
else
{
nRet = sqlite3_reset(mpVM);
szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet, (char*)szError, DONT_DELETE_MSG);
}
}

CppSQLite3Query CppSQLite3Statement::execQuery()
{
checkDB();
checkVM();

int nRet = sqlite3_step(mpVM);

if (nRet == SQLITE_DONE)
{
// no rows
return CppSQLite3Query(mpDB, mpVM, true/*eof*/, false);
}
else if (nRet == SQLITE_ROW)
{
// at least 1 row
return CppSQLite3Query(mpDB, mpVM, false/*eof*/, false);
}
else
{
nRet = sqlite3_reset(mpVM);
const char* szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet, (char*)szError, DONT_DELETE_MSG);
}
}

void CppSQLite3Statement::bind(int nParam, const char* szValue)
{
checkVM();
int nRes = sqlite3_bind_text(mpVM, nParam, szValue, -1, SQLITE_TRANSIENT);

if (nRes != SQLITE_OK)
{
throw CppSQLite3Exception(nRes,
"Error binding string param",
DONT_DELETE_MSG);
}
}

void CppSQLite3Statement::bind(int nParam, const int nValue)
{
checkVM();
int nRes = sqlite3_bind_int(mpVM, nParam, nValue);

if (nRes != SQLITE_OK)
{
throw CppSQLite3Exception(nRes,
"Error binding int param",
DONT_DELETE_MSG);
}
}

void CppSQLite3Statement::bind(int nParam, const double dValue)
{
checkVM();
int nRes = sqlite3_bind_double(mpVM, nParam, dValue);

if (nRes != SQLITE_OK)
{
throw CppSQLite3Exception(nRes,
"Error binding double param",
DONT_DELETE_MSG);
}
}

void CppSQLite3Statement::bind(int nParam, const unsigned char* blobValue, int nLen)
{
checkVM();
int nRes = sqlite3_bind_blob(mpVM, nParam,
(const void*)blobValue, nLen, SQLITE_TRANSIENT);

if (nRes != SQLITE_OK)
{
throw CppSQLite3Exception(nRes,
"Error binding blob param",
DONT_DELETE_MSG);
}
}

void CppSQLite3Statement::bindNull(int nParam)
{
checkVM();
int nRes = sqlite3_bind_null(mpVM, nParam);

if (nRes != SQLITE_OK)
{
throw CppSQLite3Exception(nRes,
"Error binding NULL param",
DONT_DELETE_MSG);
}
}

int CppSQLite3Statement::bindParameterIndex(const char* szParam)
{
checkVM();

int nParam = sqlite3_bind_parameter_index(mpVM, szParam);

int nn = sqlite3_bind_parameter_count(mpVM);
const char* sz1 = sqlite3_bind_parameter_name(mpVM, 1);
const char* sz2 = sqlite3_bind_parameter_name(mpVM, 2);

if (!nParam)
{
char buf[128];
sprintf(buf, "Parameter '%s' is not valid for this statement", szParam);
throw CppSQLite3Exception(CPPSQLITE_ERROR, buf, DONT_DELETE_MSG);
}

return nParam;
}

void CppSQLite3Statement::bind(const char* szParam, const char* szValue)
{
int nParam = bindParameterIndex(szParam);
bind(nParam, szValue);
}

void CppSQLite3Statement::bind(const char* szParam, const int nValue)
{
int nParam = bindParameterIndex(szParam);
bind(nParam, nValue);
}

void CppSQLite3Statement::bind(const char* szParam, const double dwValue)
{
int nParam = bindParameterIndex(szParam);
bind(nParam, dwValue);
}

void CppSQLite3Statement::bind(const char* szParam, const unsigned char* blobValue, int nLen)
{
int nParam = bindParameterIndex(szParam);
bind(nParam, blobValue, nLen);
}

void CppSQLite3Statement::bindNull(const char* szParam)
{
int nParam = bindParameterIndex(szParam);
bindNull(nParam);
}

void CppSQLite3Statement::reset()
{
if (mpVM)
{
int nRet = sqlite3_reset(mpVM);

if (nRet != SQLITE_OK)
{
const char* szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet, (char*)szError, DONT_DELETE_MSG);
}
}
}

void CppSQLite3Statement::finalize()
{
if (mpVM)
{
int nRet = sqlite3_finalize(mpVM);
mpVM = 0;

if (nRet != SQLITE_OK)
{
const char* szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet, (char*)szError, DONT_DELETE_MSG);
}
}
}

void CppSQLite3Statement::checkDB()
{
if (mpDB == 0)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Database not open",
DONT_DELETE_MSG);
}
}

void CppSQLite3Statement::checkVM()
{
if (mpVM == 0)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Null Virtual Machine pointer",
DONT_DELETE_MSG);
}
}

////////////////////////////////////////////////////////////////////////////////

CppSQLite3DB::CppSQLite3DB()
{
mpDB = 0;
mnBusyTimeoutMs = 60000; // 60 seconds
}

CppSQLite3DB::CppSQLite3DB(const CppSQLite3DB& db)
{
mpDB = db.mpDB;
mnBusyTimeoutMs = 60000; // 60 seconds
}

CppSQLite3DB::~CppSQLite3DB()
{
try
{
close();
}
catch (...)
{
}
}

CppSQLite3DB& CppSQLite3DB::operator=(const CppSQLite3DB& db)
{
mpDB = db.mpDB;
mnBusyTimeoutMs = 60000; // 60 seconds
return *this;
}

void CppSQLite3DB::open(const char* szFile)
{
int nRet = sqlite3_open(szFile, &mpDB);

if (nRet != SQLITE_OK)
{
const char* szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet, (char*)szError, DONT_DELETE_MSG);
}

setBusyTimeout(mnBusyTimeoutMs);
}

void CppSQLite3DB::close()
{
if (mpDB)
{
if (sqlite3_close(mpDB) == SQLITE_OK)
{
mpDB = 0;
}
else
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Unable to close database",
DONT_DELETE_MSG);
}
}
}

CppSQLite3Statement CppSQLite3DB::compileStatement(const char* szSQL)
{
checkDB();

sqlite3_stmt* pVM = compile(szSQL);
return CppSQLite3Statement(mpDB, pVM);
}

bool CppSQLite3DB::tableExists(const char* szTable)
{
char szSQL[256];
sprintf(szSQL,
"select count(*) from sqlite_master where type='table' and name='%s'",
szTable);
int nRet = execScalar(szSQL);
return (nRet > 0);
}

int CppSQLite3DB::execDML(const char* szSQL)
{
checkDB();

char* szError=0;

int nRet = sqlite3_exec(mpDB, szSQL, 0, 0, &szError);

if (nRet == SQLITE_OK)
{
return sqlite3_changes(mpDB);
}
else
{
throw CppSQLite3Exception(nRet, szError);
}
}

CppSQLite3Query CppSQLite3DB::execQuery(const char* szSQL)
{
checkDB();

sqlite3_stmt* pVM = compile(szSQL);

int nRet = sqlite3_step(pVM);

if (nRet == SQLITE_DONE)
{
// no rows
return CppSQLite3Query(mpDB, pVM, true/*eof*/);
}
else if (nRet == SQLITE_ROW)
{
// at least 1 row
return CppSQLite3Query(mpDB, pVM, false/*eof*/);
}
else
{
nRet = sqlite3_finalize(pVM);
const char* szError= sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet, (char*)szError, DONT_DELETE_MSG);
}
}

int CppSQLite3DB::execScalar(const char* szSQL, int nNullValue/*=0*/)
{
CppSQLite3Query q = execQuery(szSQL);

if (q.eof() || q.numFields() < 1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Invalid scalar query",
DONT_DELETE_MSG);
}

return q.getIntField(0, nNullValue);
}

CppSQLite3Table CppSQLite3DB::getTable(const char* szSQL)
{
checkDB();

char* szError=0;
char** paszResults=0;
int nRet;
int nRows(0);
int nCols(0);

nRet = sqlite3_get_table(mpDB, szSQL, &paszResults, &nRows, &nCols, &szError);

if (nRet == SQLITE_OK)
{
return CppSQLite3Table(paszResults, nRows, nCols);
}
else
{
throw CppSQLite3Exception(nRet, szError);
}
}

sqlite_int64 CppSQLite3DB::lastRowId()
{
return sqlite3_last_insert_rowid(mpDB);
}

void CppSQLite3DB::setBusyTimeout(int nMillisecs)
{
mnBusyTimeoutMs = nMillisecs;
sqlite3_busy_timeout(mpDB, mnBusyTimeoutMs);
}

void CppSQLite3DB::checkDB()
{
if (!mpDB)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
"Database not open",
DONT_DELETE_MSG);
}
}

sqlite3_stmt* CppSQLite3DB::compile(const char* szSQL)
{
checkDB();

const char* szTail=0;
sqlite3_stmt* pVM;

int nRet = sqlite3_prepare_v2(mpDB, szSQL, -1, &pVM, &szTail);

if (nRet != SQLITE_OK)
{
const char* szError = sqlite3_errmsg(mpDB);
throw CppSQLite3Exception(nRet,
(char*)szError,
DONT_DELETE_MSG);
}

return pVM;
}

bool CppSQLite3DB::IsAutoCommitOn()
{
checkDB();
return sqlite3_get_autocommit(mpDB) ? true : false;
}

////////////////////////////////////////////////////////////////////////////////
// SQLite encode.c reproduced here, containing implementation notes and source
// for sqlite3_encode_binary() and sqlite3_decode_binary()
////////////////////////////////////////////////////////////////////////////////

/*
** 2002 April 25
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains helper routines used to translate binary data into
** a null-terminated string (suitable for use in SQLite) and back again.
** These are convenience routines for use by people who want to store binary
** data in an SQLite database.  The code in this file is not used by any other
** part of the SQLite library.
**
** $Id: encode.c,v 1.10 2004/01/14 21:59:23 drh Exp $
*/

/*
** How This Encoder Works
**
** The output is allowed to contain any character except 0x27 (') and
** 0x00.  This is accomplished by using an escape character to encode
** 0x27 and 0x00 as a two-byte sequence.  The escape character is always
** 0x01.  An 0x00 is encoded as the two byte sequence 0x01 0x01.  The
** 0x27 character is encoded as the two byte sequence 0x01 0x03.  Finally,
** the escape character itself is encoded as the two-character sequence
** 0x01 0x02.
**
** To summarize, the encoder works by using an escape sequences as follows:
**
**       0x00  ->  0x01 0x01
**       0x01  ->  0x01 0x02
**       0x27  ->  0x01 0x03
**
** If that were all the encoder did, it would work, but in certain cases
** it could double the size of the encoded string.  For example, to
** encode a string of 100 0x27 characters would require 100 instances of
** the 0x01 0x03 escape sequence resulting in a 200-character output.
** We would prefer to keep the size of the encoded string smaller than
** this.
**
** To minimize the encoding size, we first add a fixed offset value to each
** byte in the sequence.  The addition is modulo 256.  (That is to say, if
** the sum of the original character value and the offset exceeds 256, then
** the higher order bits are truncated.)  The offset is chosen to minimize
** the number of characters in the string that need to be escaped.  For
** example, in the case above where the string was composed of 100 0x27
** characters, the offset might be 0x01.  Each of the 0x27 characters would
** then be converted into an 0x28 character which would not need to be
** escaped at all and so the 100 character input string would be converted
** into just 100 characters of output.  Actually 101 characters of output -
** we have to record the offset used as the first byte in the sequence so
** that the string can be decoded.  Since the offset value is stored as
** part of the output string and the output string is not allowed to contain
** characters 0x00 or 0x27, the offset cannot be 0x00 or 0x27.
**
** Here, then, are the encoding steps:
**
**     (1)   Choose an offset value and make it the first character of
**           output.
**
**     (2)   Copy each input character into the output buffer, one by
**           one, adding the offset value as you copy.
**
**     (3)   If the value of an input character plus offset is 0x00, replace
**           that one character by the two-character sequence 0x01 0x01.
**           If the sum is 0x01, replace it with 0x01 0x02.  If the sum
**           is 0x27, replace it with 0x01 0x03.
**
**     (4)   Put a 0x00 terminator at the end of the output.
**
** Decoding is obvious:
**
**     (5)   Copy encoded characters except the first into the decode
**           buffer.  Set the first encoded character aside for use as
**           the offset in step 7 below.
**
**     (6)   Convert each 0x01 0x01 sequence into a single character 0x00.
**           Convert 0x01 0x02 into 0x01.  Convert 0x01 0x03 into 0x27.
**
**     (7)   Subtract the offset value that was the first character of
**           the encoded buffer from all characters in the output buffer.
**
** The only tricky part is step (1) - how to compute an offset value to
** minimize the size of the output buffer.  This is accomplished by testing
** all offset values and picking the one that results in the fewest number
** of escapes.  To do that, we first scan the entire input and count the
** number of occurances of each character value in the input.  Suppose
** the number of 0x00 characters is N(0), the number of occurances of 0x01
** is N(1), and so forth up to the number of occurances of 0xff is N(255).
** An offset of 0 is not allowed so we don't have to test it.  The number
** of escapes required for an offset of 1 is N(1)+N(2)+N(40).  The number
** of escapes required for an offset of 2 is N(2)+N(3)+N(41).  And so forth.
** In this way we find the offset that gives the minimum number of escapes,
** and thus minimizes the length of the output string.
*/

/*
** Encode a binary buffer "in" of size n bytes so that it contains
** no instances of characters '\'' or '\000'.  The output is
** null-terminated and can be used as a string value in an INSERT
** or UPDATE statement.  Use sqlite3_decode_binary() to convert the
** string back into its original binary.
**
** The result is written into a preallocated output buffer "out".
** "out" must be able to hold at least 2 +(257*n)/254 bytes.
** In other words, the output will be expanded by as much as 3
** bytes for every 254 bytes of input plus 2 bytes of fixed overhead.
** (This is approximately 2 + 1.0118*n or about a 1.2% size increase.)
**
** The return value is the number of characters in the encoded
** string, excluding the "\000" terminator.
*/
int sqlite3_encode_binary(const unsigned char *in, int n, unsigned char *out){
int i, j, e, m;
int cnt[256];
if( n<=0 ){
out[0] = 'x';
out[1] = 0;
return 1;
}
memset(cnt, 0, sizeof(cnt));
for(i=n-1; i>=0; i--){ cnt[in[i]]++; }
m = n;
for(i=1; i<256; i++){
int sum;
if( i=='\'' ) continue;
sum = cnt[i] + cnt[(i+1)&0xff] + cnt[(i+'\'')&0xff];
if( sum<m ){
m = sum;
e = i;
if( m==0 ) break;
}
}
out[0] = e;
j = 1;
for(i=0; i<n; i++){
int c = (in[i] - e)&0xff;
if( c==0 ){
out[j++] = 1;
out[j++] = 1;
}else if( c==1 ){
out[j++] = 1;
out[j++] = 2;
}else if( c=='\'' ){
out[j++] = 1;
out[j++] = 3;
}else{
out[j++] = c;
}
}
out[j] = 0;
return j;
}

/*
** Decode the string "in" into binary data and write it into "out".
** This routine reverses the encoding created by sqlite3_encode_binary().
** The output will always be a few bytes less than the input.  The number
** of bytes of output is returned.  If the input is not a well-formed
** encoding, -1 is returned.
**
** The "in" and "out" parameters may point to the same buffer in order
** to decode a string in place.
*/
int sqlite3_decode_binary(const unsigned char *in, unsigned char *out){
int i, c, e;
e = *(in++);
i = 0;
while( (c = *(in++))!=0 ){
if( c==1 ){
c = *(in++);
if( c==1 ){
c = 0;
}else if( c==2 ){
c = 1;
}else if( c==3 ){
c = '\'';
}else{
return -1;
}
}
out[i++] = (c + e)&0xff;
}
return i;
}

#include <iostream>

#include "CppSQLite3.h"
#include <ctime>

using namespace std;

const char * gszFile = "e:\\sqlite3\\test.db";

//测试Sqlite3的使用
void main1()
{
cout << "hello sqlite3" << endl;

try
{
int i, fld;
time_t tmStart, tmEnd;
CppSQLite3DB db;

char *sql;

cout << "SQLite Header Version: " << CppSQLite3DB::SQLiteHeaderVersion() << endl;
cout << "SQLite Library Version: " << CppSQLite3DB::SQLiteLibraryVersion() << endl;
cout << "SQLite Library Version Number: " << CppSQLite3DB::SQLiteLibraryVersionNumber() << endl;

//remove(gszFile);
db.open(gszFile);
//插入数据
cout << endl << "emp table exists=" << (db.tableExists("person") ? "TRUE" : "FALSE") << endl;
// Create SQL statement
sql = "CREATE TABLE person("  \
"id INT PRIMARY KEY     NOT NULL," \
"name           TEXT    NOT NULL," \
"age            INT     NOT NULL," \
"address        CHAR(50)," \
"salary         REAL );";
//db.execDML(sql);
//cout << endl << "emp table exists=" << (db.tableExists("person") ? "TRUE" : "FALSE") << endl;
//cout << endl << "DML tests" << endl;

sql = "insert into person values (1, 'David Beckham',34,'china person',3455.78);"\
"insert into person values (2, 'changshuhang',33,'china person1',3455.34);"\
"insert into person values (3, 'houyuzhu',37,'china person2',34534);"\
"insert into person values (4, 'chengye',356,'china person3',45.78);"\
"insert into person values (5, 'dujianfei',38,'china person4',3655.78);";
int nRows = db.execDML(sql);
cout << nRows << " rows inserted" << endl;

//update
/*
sql = "update person set name = 'xijinping' where id = 5 ;"\
"update person set name = 'hujingtao' where address = 'china person2' ;";
int nRows = db.execDML(sql);
cout << nRows << " rows updated" << endl;
*/

//delete
/*
sql = "delete from person where id = 5 ;"\
"delete from person where address = 'china person2' ;";
int nRows = db.execDML(sql);
cout << nRows << " rows updated" << endl;
*/

/*
// Query data and also show results of inserts into auto-increment field
cout << endl << "Select statement test" << endl;
CppSQLite3Query q = db.execQuery("select * from person order by id;");

for (fld = 0; fld < q.numFields(); fld++)
{
cout << q.fieldName(fld) << "(" << q.fieldDeclType(fld) << ")|";
}
cout << endl;

while (!q.eof())
{
cout << q.fieldValue(0) << "|";
cout << q.fieldValue(1) << "|";
cout << q.fieldValue(2) << "|";
cout << q.fieldValue(3) << endl;
q.nextRow();
}
*/

/*
// Fetch table at once, and also show how to use CppSQLiteTable::setRow() method
cout << endl << "getTable() test" << endl;
CppSQLite3Table t = db.getTable("select * from person order by id;");

for (fld = 0; fld < t.numFields(); fld++)
{
cout << t.fieldName(fld) << "|";
}
cout << endl;
for (int row = 0; row < t.numRows(); row++)
{
t.setRow(row);
for (int fld = 0; fld < t.numFields(); fld++)
{
if (!t.fieldIsNull(fld))
cout << t.fieldValue(fld) << "|";
else
cout << "NULL" << "|";
}
cout << endl;
}
*/

}
catch (CppSQLite3Exception& e)
{
cerr << e.errorCode() << ":" << e.errorMessage() << endl;
}

////////////////////////////////////////////////////////////////////////////////
// Loop until user enters q or Q
////////////////////////////////////////////////////////////////////////////////
char c(' ');

while (c != 'q' && c != 'Q')
{
cout << "Press q then enter to quit: ";
cin >> c;
}
}