MyConnection.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <string.h>     // strlen, strncpy
#include <stdlib.h>     // strtol, strtoul, strtoll, strtoull
 
#include <mysql.h>
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Regex.h>
#include <dcl/ListedHashMap.h>
#include <dcl/SQLCore.h>
 
#include "MyConnection.h"
#include "MyQuery.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/MyConnection.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR_HANDLE(_error) \
    setErrorHandle(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    setErrorMessage(_msg, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(MyConnection, SQL::Connection)
 
MyConnection::MyConnection(const wchar_t* _serverTitle)
    : Connection(_serverTitle)
{
    Connection::__canTransact = true;
    __mysql = NULL;
    __storeResult = false;
}
 
MyConnection::~MyConnection()
{
    if (__mysql) {
        __DCL_TRACE0_N(L"Warning!! The connection was not closed\n");
        close();
    }
}
 
void MyConnection::destroy()
{
    delete this;
}
 
/* 
_conns에 가능한 property
    for mysql_real_connect
        USER,
        PASSWORD,
        SERVER, -- host name
        DATABASE,
        PORT,       -- tcp port
        UNIX_SOCKET,
 
    for mysql_options
        APPLICATION
 
    driver options
        STORE_RESULT
 
*/
 
bool MyConnection::__open(const char* _conns, size_t _connslen)
{
    if (__mysql == NULL && (__mysql = mysql_init(NULL)) == NULL) {
        __SET_ERROR_HANDLE(SQL::eOutOfMemory);
        return false;
    }
 
    ListedByteStringToByteStringMap map;
    Connection::splitConnStr(_conns, _connslen, map);
 
    ByteString _APPLICATION = map["APPLICATION"];
    if (!_APPLICATION.isEmpty()) {
        mysql_options(connHandle(), MYSQL_READ_DEFAULT_GROUP, _APPLICATION.data());
    }
 
    ByteString _USER = map["USER"];
    ByteString _PASSWORD = map["PASSWORD"];
    ByteString _SERVER = map["SERVER"];
    ByteString _DATABASE = map["DATABASE"];
    ByteString _PORT = map["PORT"];
    ByteString _UNIX_SOCKET = map["UNIX_SOCKET"];
    __storeResult = map.find("STORE_RESULT") != map.end();
 
    unsigned int port = 0;
    if (!_PORT.isEmpty()) {
        char* endptr;
        unsigned long n = strtoul(_PORT.data(), &endptr, 10);
        if (n == ULONG_MAX) {
            __SET_ERROR_MSG("연결 문자열이 잘못되었습니다. PORT=" + _PORT);
            return false;
        }
        port = (unsigned int) n;
    }
 
    if (mysql_real_connect(
        connHandle(),
        _SERVER.isEmpty()? NULL : _SERVER.data(),
        _USER.isEmpty()? NULL : _USER.data(),
        _PASSWORD.isEmpty()? NULL : _PASSWORD.data(),
        _DATABASE.isEmpty() ? NULL : _DATABASE.data(),
        port,
        _UNIX_SOCKET.isEmpty() ? NULL : _UNIX_SOCKET.data(),
        0
    ) == NULL) {
        __SET_ERROR_HANDLE(SQL::eServerError);
        return false;
    }
 
    if (mysql_set_character_set(connHandle(), "utf8")) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_errno(connHandle()),
            mysql_error(connHandle()))
        );
        return false;
    }
 
    if (mysql_autocommit(connHandle(), 0)) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_errno(connHandle()),
            mysql_error(connHandle()))
        );
        return false;
    }
 
    return true;
}
 
bool MyConnection::__close()
{
    if (!__mysql) {
        __SET_ERROR_HANDLE(SQL::eNotConnected);
        return false;
    }
 
    mysql_close(__mysql);
    __mysql = NULL;
 
    return true;
}
 
enum StmtType {
    StmtOther,
    StmtTransBegin,
    StmtTransEnd
};
 
typedef struct {
    StmtType type;
    const char* pattern;
} STMT_PATTERN;
 
static STMT_PATTERN sp[] = {
    {   StmtTransBegin,       "START[[:space:]]+TRANSACTION|BEGIN"    },
    {   StmtTransEnd,       "COMMIT|ROLLBACK"   },
    {   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* p) {
            p->destroy();
        }
    }
    return StmtOther;
}
 
bool MyConnection::__execute(const char* _sql, size_t _sqllen)
{
    if (mysql_real_query(connHandle(), _sql, (unsigned long) _sqllen)) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_errno(connHandle()),
            mysql_error(connHandle()))
        );
    }
 
    switch (__GetStmtType(_sql)) {
    case StmtTransBegin:
        __SET_STATE(stInTransaction);
        break;
    case StmtTransEnd:
        __UNSET_STATE(stInTransaction);
        break;
    case StmtOther:
    default:
        ;
    }
 
    return true;
}
 
bool MyConnection::__startTrans()
{
    return __execute("START TRANSACTION", 17);
}
 
bool MyConnection::__commitTrans()
{
    if (mysql_commit(connHandle())) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_errno(connHandle()),
            mysql_error(connHandle()))
        );
    }
 
    return true;
}
 
bool MyConnection::__rollbackTrans()
{   
    if (mysql_rollback(connHandle())) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_errno(connHandle()),
            mysql_error(connHandle()))
        );
    }
 
    return true;
}
 
bool MyConnection::__createQueryInstance(SQL::Query** _queryHandleOut)
{
    __DCL_ASSERT(_queryHandleOut != NULL);
 
    MyQuery* pNewQuery = new MyQuery(this);
    if (!pNewQuery) {
        __SET_ERROR_HANDLE(SQL::eOutOfMemory);
        return false;
    }
 
    *_queryHandleOut = pNewQuery;
    return true;
}
 
bool MyConnection::__getErrorMessage(char* _buf, size_t* _buflen)
{
    if (__lastErrorMessage.length() < *_buflen) {
        *_buflen = __lastErrorMessage.length();
        *(_buf + *_buflen) = '\0';
    }
    strncpy(_buf, __lastErrorMessage.data(), *_buflen);
    return true;
}
 
bool MyConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    const char* psz = mysql_get_server_info(connHandle());
    if (!psz) {
        return false;
    }
 
    size_t length = strlen(psz);
    if (length < *_buflen) {
        *_buflen = length;
        *(_buf + *_buflen) = '\0';
    }
    strncpy(_buf, psz, *_buflen);
    return true;
}       
 
__DCL_END_NAMESPACE