mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2024-12-22 21:43:35 +00:00
a60865cd19
* simplify leaderboard code, fully abstract database * update exception catching * update exception catching and sql references, remove ugc from gamemessages fix deleting model remove unrelated changes Update GameMessages.cpp * remove ugc from gamemessages * Update GameMessages.cpp * Update Leaderboard.cpp * bug fixes * fix racing leaderboard * remove extra stuff * update * add sqlite * use a default for optimizations * update sqlite * Fix limits on update and delete * fix bugs * use definition to switch between databases * add switch for different backends * fix include guard and includes * always build both * add mysql if block * Update Database.cpp * add new options and add check to prevent overriding mysql * correct config names * Update README.md * Update README.md * merge to 1 sql file for sqlite database * move to sqlite folder * add back mysql migrations * Update README.md * add migration to correct the folder name or mysql * yes aron * updates * Update CMakeLists.txt * dont use paths at all, add where check to only update if folder name still exist check also doesnt check for slashes and assumes one will be there since it will be. * default dont auto create account for releases we can change this flag * default 0 * add times played query * fix leaderboard not incrementing on a not better score * add env vars with defaults for docker * use an "enum" * default to mariadb * Update .env.example
1618 lines
34 KiB
C++
1618 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 sqlite_int64 nValue)
|
|
{
|
|
checkVM();
|
|
int nRes = sqlite3_bind_int64(mpVM, nParam, nValue);
|
|
|
|
if (nRes != SQLITE_OK)
|
|
{
|
|
throw CppSQLite3Exception(nRes,
|
|
(char*)"Error binding int64 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 sqlite_int64 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;
|
|
}
|