PqConnection.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // strtol
#include <string.h>     // strlen, strncpy
 
#include <libpq-fe.h>
 
#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 "PqConnection.h"
#include "PqQuery.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/PqConnection.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(PqConnection, SQL::Connection)
 
PqConnection::PqConnection(const wchar_t* pszServerTitle)
    : Connection(pszServerTitle)
{
    Connection::__canTransact = true;
    __conn = NULL;
    __cursor = __CURSOR_FETCH_DEFAULT;
    __stmtNo = 0;
}
 
PqConnection::~PqConnection()
{
    if (__conn) {
        __DCL_TRACE0_N(L"Warning!! The connection was not closed\n");
        close();
    }
}
 
void PqConnection::destroy()
{
    delete this;
}
 
/* 
_conns에 가능한 프로퍼티
    USER,
    PASSWORD,
    SERVER, -- host name
    DATABASE 
*/
 
bool PqConnection::__open(const char* _conns, size_t _connslen)
{
    ByteString conns(_conns, _connslen);
    const char* regex = "CURSOR *= *[^&;]*[&;]*";
    if (conns.searches(regex, true)) {
        ByteString cursor = conns.substring(regex, true);
        cursor = cursor.substring(cursor.indexOf('=') + 1).trim();
        char* endptr;
        __cursor = strtol(cursor, &endptr, 10);
 
        conns = conns.replace_r(regex, "", true);
    }
 
    ListedByteStringToByteStringMap map;
    Connection::splitConnStr(conns, conns.length(), map);
 
    ByteString _USER = map["USER"];
    ByteString _PASSWORD = map["PASSWORD"];
    ByteString _SERVER = map["SERVER"];
    ByteString _PORT = map["PORT"];
    ByteString _DATABASE = map["DATABASE"];
    ByteString _CONNECT_TIMEOUT = map["CONNECT_TIMEOUT"];
    ByteString _APPLICATION = map["APPLICATION"];
 
    ByteString uri;
    if (!(_USER.isEmpty() || _SERVER.isEmpty() || _DATABASE.isEmpty())) {
        // URI를 만든다.
        ByteStringBuilder sb("postgresql://");
        sb.append(_USER);
        if (!_PASSWORD.isEmpty()) {
            sb.append(":").append(_PASSWORD);
        }
        sb.append("@").append(_SERVER);
        if (!_PORT.isEmpty()) {
            sb.append(":").append(_PORT);
        }
        sb.append("/").append(_DATABASE)
            .append("?connect_timeout=")
            .append(_CONNECT_TIMEOUT.isEmpty() ? "10" : _CONNECT_TIMEOUT)
            .append("&application_name=")
            .append(_APPLICATION.isEmpty() ? "DCL" : _APPLICATION)
            ;
        uri = sb.toByteString();
    }
    else {
        // _conns가 URI이다.
        uri = conns.replace_r("client_encoding=[^&]*&*", "", true);
        if (uri.indexOf('?') == (size_t)-1) {
            uri = uri + '?';
        }
        regex = "connect_timeout=[^&]*&*";
        if (!uri.searches(regex, true)) {
            uri = uri + "&connect_timeout=10";
        }
        regex = "application_name=[^&]*&*";
        if (!uri.searches(regex, true)) {
            uri = uri + "&application_name=DCL";
        }
 
        uri = uri.replace_r("&{2,}", "&", true)
            .replace_r("\\?&", "?", true)
            .trimRight("&")
            ;
    }
    uri = uri + "&client_encoding=UTF8";
    __DCL_TRACE2_N(L"connection URI [%hs] cursor[%ls]\n",
        uri.data(), String::valueOf(__cursor).data()
    );
 
    PGconn* conn = PQconnectdb(uri.data());
    if (PQstatus(conn) != CONNECTION_OK) {
        __SET_ERROR_MSG(PQerrorMessage(conn));
        return false;
    }
 
    __conn = conn;
 
    if (!__execute("SET DateStyle TO 'ISO'; SET IntervalStyle TO 'iso_8601'", (size_t)-1))
        return false;
 
    __DCL_TRACE1_N(L"client_encoding [%hs]\n", PQparameterStatus(conn, "client_encoding"));
    __DCL_TRACE1_N(L"DateStyle [%hs]\n", PQparameterStatus(conn, "DateStyle"));
    __DCL_TRACE1_N(L"integer_datetimes [%hs]\n", PQparameterStatus(conn, "integer_datetimes"));
    __DCL_TRACE1_N(L"IntervalStyle [%hs]\n", PQparameterStatus(conn, "IntervalStyle"));;
    __DCL_TRACE1_N(L"server_encoding [%hs]\n", PQparameterStatus(conn, "server_encoding"));
    __DCL_TRACE1_N(L"server_version [%hs]\n", PQparameterStatus(conn, "server_version"));
    __DCL_TRACE1_N(L"TimeZone [%hs]\n", PQparameterStatus(conn, "TimeZone"));
 
    return true;
}
 
bool PqConnection::__close()
{
    if (!__conn) {
        __SET_ERROR(SQL::eNotConnected);
        return false;
    }
 
    PQfinish(__conn);
    __conn = NULL;
 
    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 PqConnection::__execute(const char* _sql, size_t _sqllen)
{
    PGresult* res = PQexec(__conn, _sql);
    if (PQresultStatus(res) != PGRES_COMMAND_OK) {
        __SET_ERROR_MSG(PQerrorMessage(connHandle()));
        PQclear(res);
        return false;
    }
    PQclear(res);
 
    switch(__GetStmtType(_sql)) {
        case StmtTransBegin :
            __SET_STATE(stInTransaction);
            break;
        case StmtTransEnd :
            __UNSET_STATE(stInTransaction);
            break;
        case StmtOther :
        default :
            ;
    }
 
    return true;
}
 
bool PqConnection::__startTrans()
{
    return __execute("BEGIN", (size_t)-1);
}
 
bool PqConnection::__commitTrans()
{
    return __execute("COMMIT", (size_t)-1);
}
 
bool PqConnection::__rollbackTrans()
{   
    return __execute("ROLLBACK", (size_t)-1);
}
 
bool PqConnection::__createQueryInstance(SQL::Query** _queryHandleOut)
{
    __DCL_ASSERT(_queryHandleOut != NULL);
 
    SQL::Query* newQuery = new PqQuery(this);
    if (!newQuery) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    *_queryHandleOut = newQuery;
 
    return true;
}
 
bool PqConnection::__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 PqConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    int serverVersion = PQserverVersion(__conn);
    int protocolVersion =
#ifdef LIBPQ_HAS_FULL_PROTOCOL_VERSION
        PQfullProtocolVersion(__conn)
#else
        PQprotocolVersion(__conn) * 10000
#endif
        ;
    int libVersion = PQlibVersion();
 
    ByteString s = ByteString::format("PostgreSQL %d.%d/%d.%d/%d.%d",
        serverVersion / 10000, serverVersion % 10000,
        protocolVersion / 10000, protocolVersion % 10000,
        libVersion / 10000, libVersion % 10000
    );
    if (s.length() < *_buflen) {
        *_buflen = s.length();
        *(_buf + *_buflen) = '\0';
    }
    strncpy(_buf, s.data(), *_buflen);
    return true;
}       
 
__DCL_END_NAMESPACE