SqConnection.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // strtol
#include <string.h>     // strlen, strncpy
 
#if defined(__ANDROID__) && defined(SQLITE_HAS_CODEC)
#include <sqlcipher.h>
#else
#include <sqlite3.h>
#endif
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/size_t.h>
#include <dcl/Numeric.h>
#include <dcl/Regex.h>
#include <dcl/SQLCore.h>
 
#include "SqConnection.h"
#include "SqQuery.h"
 
#define __TRACE_THIS    0
#if __TRACE_THIS
#define __DCL_TRACE0_N  __DCL_TRACE0
#define __DCL_TRACE1_N  __DCL_TRACE1
#define __DCL_TRACE2_N  __DCL_TRACE2
#define __DCL_TRACE3_N  __DCL_TRACE3
#define __DCL_TRACE4_N  __DCL_TRACE4
#else
#define __DCL_TRACE0_N(fmt)
#define __DCL_TRACE1_N(fmt, arg)
#define __DCL_TRACE2_N(fmt, arg1, arg2)
#define __DCL_TRACE3_N(fmt, arg1, arg2, arg3)
#define __DCL_TRACE4_N(fmt, arg1, arg2, arg3, arg4)
#endif
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/SqConnection.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    setErrorStatus(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_message) \
    setErrorMessage(_message, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(SqConnection, SQL::Connection)
 
SqConnection::SqConnection(const wchar_t* pszServerTitle)
    : Connection(pszServerTitle)
{
    Connection::__canTransact = true;
    __conn = NULL;
}
 
SqConnection::~SqConnection()
{
    if (__conn) {
        __DCL_TRACE0_N(L"Warning!! The connection was not closed\n");
        close();
    }
}
 
void SqConnection::destroy()
{
    delete this;
}
 
bool SqConnection::__open(const char* _conns, size_t _connslen)
{
    ByteString conns(_conns, _connslen);
    ListedByteStringToByteStringMap map;
    Connection::splitConnStr(_conns, _connslen, map);
 
    ByteString _DATABASE = map["DATABASE"];
    ByteString _URI = map["URI"];
#ifdef SQLITE_HAS_CODEC
    ByteString _KEY = map["KEY"];
    ByteString _REKEY = map["REKEY"];
 
    const char* pKey = NULL;
    int nKey = 0;
    if (_KEY.length() > 0) {
        pKey = _KEY.data();
        nKey = _KEY.length();
    }
 
    bool hasReKey = conns.searches("REKEY", true);
    const char* pReKey = NULL;
    int nReKey = 0;
    if (_REKEY.length() > 0) {
        pReKey = _REKEY.data();
        nReKey = _REKEY.length();
    }
#endif
 
    int flags = SQLITE_OPEN_MEMORY;
    const char* zVfs = NULL;
    if (!(_DATABASE.isEmpty())) {
        _URI = _DATABASE;
        flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
    }
    else if (!(_URI.isEmpty())) {
        flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
    }
    else if (!conns.isEmpty()) {
        _URI = conns;
        if (!_URI.isEmpty()) {
            flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
        }
    }
    else {
        flags = SQLITE_OPEN_MEMORY;
        _URI.assign(":memory:");
    }
 
    if (_URI.toLowerCase().startsWith("file:")) {
        flags |= SQLITE_OPEN_URI;
    }
 
#ifdef __WINNT__
    zVfs = "win32-none";
#else
    zVfs = "unix-none";
#endif
 
    sqlite3* conn = NULL;
    int rc = sqlite3_open_v2(_URI, &conn, flags, zVfs);
    if (rc != SQLITE_OK) {
        __SET_ERROR_MSG(sqlite3_errstr(rc));
        return false;
    }
 
    for ( ; ; ) {
#ifdef SQLITE_HAS_CODEC
        rc = sqlite3_key(conn, pKey, nKey);
        if (rc != SQLITE_OK) {
            __SET_ERROR_MSG(sqlite3_errmsg(conn));
            break;
        }
        __DCL_TRACE2_N(L"sqlite3_key [%hs][%d]\n",
            (pKey ? pKey : "(nil)"), nKey);
        if (hasReKey) {
            rc = sqlite3_rekey(conn, pReKey, nReKey);
            if (rc != SQLITE_OK) {
                __SET_ERROR_MSG(sqlite3_errmsg(conn));
                break;
            }
        }
#endif
        __conn = conn;
        return true;
    }
 
    if (conn) {
        sqlite3_close_v2(conn);
    }
    return false;
}
 
bool SqConnection::__close()
{
    if (!__conn) {
        __SET_ERROR(SQL::eNotConnected);
        return false;
    }
 
    int rc = sqlite3_close_v2(__conn);
    __conn = NULL;
    if (rc != SQLITE_OK) {
        __SET_ERROR_MSG(sqlite3_errstr(rc));
        return false;
    }
    return true;
}
 
enum StmtType {
    StmtOther,
    StmtTransBegin,
    StmtTransEnd
};
 
typedef struct {
    StmtType type;
    const char* pattern;
} STMT_PATTERN;
 
static STMT_PATTERN sp[] = {
    { StmtTransBegin, "BEGIN"                 },
    { StmtTransEnd,     "COMMIT|ROLLBACK|END"   },
    { StmtOther,       NULL                    }
};
 
static StmtType __GetStmtType(const char* _sql)
{
    for(size_t i = 0; sp[i].type != StmtOther; i++) {
        try {
            if (Regex::test(sp[i].pattern, _sql, true))
                return sp[i].type;
        }
        catch(Exception* _e) {
            _e->destroy();
        }
    }
    return StmtOther;
}
 
bool SqConnection::__execute(const char* _sql, size_t _sqllen)
{
    char* errmsg = NULL;
    int rc = sqlite3_exec(__conn, _sql, NULL, NULL, &errmsg);
    if (rc != SQLITE_OK) {
        __SET_ERROR_MSG(errmsg);
        return false;
    }
 
    switch(__GetStmtType(_sql)) {
        case StmtTransBegin :
            __SET_STATE(stInTransaction);
            break;
        case StmtTransEnd :
            __UNSET_STATE(stInTransaction);
            break;
        case StmtOther :
        default :
            ;
    }
 
    return true;
}
 
bool SqConnection::__startTrans()
{
    return __execute("BEGIN", (size_t)-1);
}
 
bool SqConnection::__commitTrans()
{
    return __execute("COMMIT", (size_t)-1);
}
 
bool SqConnection::__rollbackTrans()
{   
    return __execute("ROLLBACK", (size_t)-1);
}
 
bool SqConnection::__createQueryInstance(SQL::Query** _queryHandleOut)
{
    __DCL_ASSERT(_queryHandleOut != NULL);
 
    SQL::Query* newQuery = new SqQuery(this);
    if (!newQuery) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    *_queryHandleOut = newQuery;
    return true;
}
 
bool SqConnection::__getErrorMessage(char* _buf, size_t* _buflen)
{
    __DCL_ASSERT(Connection::__errorCode == SQL::eServerError);
    if (__lastErrorMessage.length() < *_buflen) {
        *_buflen = __lastErrorMessage.length();
        *(_buf + *_buflen) = '\0';
    }
    strncpy(_buf, __lastErrorMessage.data(), *_buflen);
    return true;
}
 
bool SqConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    ByteStringBuilder sb = "SQLite ";
    sb += sqlite3_libversion();
#ifdef SQLITE_HAS_CODEC
    sb += "/SQLCipher";
#endif
 
    if (sb.length() < *_buflen) {
        *_buflen = sb.length();
        *(_buf + *_buflen) = '\0';
    }
    strncpy(_buf, sb.data(), *_buflen);
    return true;
}       
 
__DCL_END_NAMESPACE