mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2024-12-22 21:43:35 +00:00
1598 lines
34 KiB
C++
1598 lines
34 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// 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>
|
|
#include <iostream>
|
|
|
|
|
|
// 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) {
|
|
char msg[] = "Cannot allocate memory"; //prevents warning of string conversion to char*
|
|
throw CppSQLite3Exception(CPPSQLITE_ERROR, msg, 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, (char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"Invalid field name requested",
|
|
DONT_DELETE_MSG);
|
|
}
|
|
|
|
|
|
const char* CppSQLite3Query::fieldName(int nCol)
|
|
{
|
|
checkVM();
|
|
|
|
if (nCol < 0 || nCol > mnCols-1)
|
|
{
|
|
throw CppSQLite3Exception(CPPSQLITE_ERROR,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"Invalid row index requested",
|
|
DONT_DELETE_MSG);
|
|
}
|
|
|
|
mnCurrentRow = nRow;
|
|
}
|
|
|
|
|
|
void CppSQLite3Table::checkResults()
|
|
{
|
|
if (mpaszResults == 0)
|
|
{
|
|
throw CppSQLite3Exception(CPPSQLITE_ERROR,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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,
|
|
(char*)"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];
|
|
#ifdef _WIN32
|
|
sprintf_s(buf, "Parameter '%s' is not valid for this statement", szParam);
|
|
#else
|
|
sprintf(buf, "Parameter '%s' is not valid for this statement", szParam);
|
|
#endif
|
|
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,
|
|
(char*)"Database not open",
|
|
DONT_DELETE_MSG);
|
|
}
|
|
}
|
|
|
|
|
|
void CppSQLite3Statement::checkVM()
|
|
{
|
|
if (mpVM == 0)
|
|
{
|
|
throw CppSQLite3Exception(CPPSQLITE_ERROR,
|
|
(char*)"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,
|
|
(char*)"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];
|
|
|
|
#ifdef _WIN32
|
|
sprintf_s(szSQL,
|
|
"select count(*) from sqlite_master where type='table' and name='%s'",
|
|
szTable);
|
|
#else
|
|
sprintf(szSQL,
|
|
"select count(*) from sqlite_master where type='table' and name='%s'",
|
|
szTable);
|
|
#endif
|
|
|
|
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,
|
|
(char*)"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,
|
|
(char*)"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);
|
|
std::cout << "Error: " << szError << std::endl;
|
|
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;
|
|
}
|