PeConnection.cpp

Go to the documentation of this file.

#line 1 "PeConnection.pgc"
#include <dcl/Config.h>
 
/* Processed by ecpg (17.7) */
/* These include files are added by the preprocessor */
#include <ecpglib.h>
#include <ecpgerrno.h>
#include <sqlca.h>
/* End of automatic include section */
 
#include <string.h>     // strlen, strncpy
 
#include <sqlda.h>
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Numeric.h>
#include <dcl/Regex.h>
#include <dcl/SQLCore.h>
 
#include "PeConnection.h"
#include "PeQuery.h"
#include "PeField.h"   // for _getServerInfo
 
#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/PeConnection.pgc");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    setErrorHandle(_error, 0L, __THIS_FILE__, __LINE__)
#define __SET_ERROR_HANDLE(_SQLCODE) \
    setErrorHandle(SQL::eServerError, _SQLCODE, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_message) \
    setErrorMessage(_message, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(PeConnection, SQL::Connection)
 
PeConnection::PeConnection(const wchar_t* pszServerTitle)
    : Connection(pszServerTitle)
{
    Connection::__canTransact = true;
}
 
PeConnection::~PeConnection()
{
    if (!__connectionID.isEmpty()) {
        __DCL_TRACE0_N(L"Warning!! The connection was not closed\n");
        close();
    }
}
 
void PeConnection::destroy()
{
    delete this;
}
 
/* 
_conns에 가능한 프로퍼티
    USER,
    PASSWORD,
    SERVER, -- host name
    DATABASE 
*/
 
bool PeConnection::__open(const char* _conns, size_t _connslen)
{
    ListedByteStringToByteStringMap map;
    Connection::splitConnStr(_conns, _connslen, map);
 
    ByteString _USER = map["USER"];
    ByteString _PASSWORD = map["PASSWORD"];
    ByteString _SERVER = map["SERVER"];
    ByteString _PORT = map["PORT"];
    ByteString _DATABASE = map["DATABASE"];
    ByteString _TARGET;
 
    {
        ByteStringBuilder sb;
        if (!_SERVER.isEmpty()) {
            sb.append("tcp:postgresql://").append(_SERVER);
            if (!_PORT.isEmpty()) {
                sb.append(":").append(_PORT);
            }
        }
        if (!_DATABASE.isEmpty()) {
            if (!sb.isEmpty()) {
                sb += "/";
            }
            sb += _DATABASE;
        }
        _TARGET = sb.toByteString();
        __DCL_TRACE1_N(L"TARGET [%hs]\n", _TARGET.data());
    }
 
    ByteString connectionID = ByteString::format("conn_%zx", (size_t)this);
 
    /* exec sql begin declare section */
         
         
         
         
    
#line 110 "PeConnection.pgc"
 char * user = ( _CONST char * ) _USER . data () ;
 
#line 111 "PeConnection.pgc"
 char * pass = ( _CONST char * ) _PASSWORD . data () ;
 
#line 112 "PeConnection.pgc"
 char * target = ( _CONST char * ) _TARGET . data () ;
 
#line 113 "PeConnection.pgc"
 char * connID = ( _CONST char * ) connectionID . data () ;
/* exec sql end declare section */
#line 114 "PeConnection.pgc"
 
 
    { ECPGconnect(__LINE__, 0, target , user , pass , connID, 0); }
#line 117 "PeConnection.pgc"
  
 
    if (SQLCODE < 0) {
        __SET_ERROR_HANDLE(SQLCODE);
        return false;
    }
    __connectionID = connectionID;
 
    return true;
}
 
bool PeConnection::__close()
{
    if (__connectionID.isEmpty()) {
        __SET_ERROR(SQL::eNotConnected);
        return false;
    }
 
    /* exec sql begin declare section */
         
    
#line 136 "PeConnection.pgc"
 char * connID = ( _CONST char * ) __connectionID . data () ;
/* exec sql end declare section */
#line 137 "PeConnection.pgc"
 
 
    { ECPGdisconnect(__LINE__, connID);}
#line 139 "PeConnection.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_HANDLE(SQLCODE);
        return false;
    }
 
    __connectionID.clear();
    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 PeConnection::__execute(const char* _sql, size_t _sqllen)
{
    // PostgreSQL에서 EXEC SQL EXECUTE IMMEDIATE는 DML만 사용할 수 있다!
    PGconn* conn = ECPGget_PGconn(__connectionID.data());
    PGresult* res = PQexec(conn, _sql);
    ExecStatusType status = PQresultStatus(res);
    if (status != PGRES_COMMAND_OK) {
        ByteStringBuilder sb;
        sb.format("ExecStatusType(%d)", status)
            .append(PQresultErrorMessage(res));
        __SET_ERROR_MSG(sb);
        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 PeConnection::__startTrans()
{
    /* exec sql begin declare section */
         
    
#line 214 "PeConnection.pgc"
 char * connID = ( _CONST char * ) __connectionID . data () ;
/* exec sql end declare section */
#line 215 "PeConnection.pgc"
 
 
    { ECPGsetconn(__LINE__, connID);}
#line 217 "PeConnection.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_HANDLE(SQLCODE);
        return false;
    }
 
    { ECPGtrans(__LINE__, NULL, "begin work");}
#line 223 "PeConnection.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_HANDLE(SQLCODE);
        return false;
    }
 
    __SET_STATE(stInTransaction);
    return true;
}
 
bool PeConnection::__commitTrans()
{
    /* exec sql begin declare section */
         
    
#line 236 "PeConnection.pgc"
 char * connID = ( _CONST char * ) __connectionID . data () ;
/* exec sql end declare section */
#line 237 "PeConnection.pgc"
 
 
    { ECPGsetconn(__LINE__, connID);}
#line 239 "PeConnection.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_HANDLE(SQLCODE);
        return false;
    }
 
    { ECPGtrans(__LINE__, NULL, "commit work");}
#line 245 "PeConnection.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_HANDLE(SQLCODE);
        return false;
    }
 
    __UNSET_STATE(stInTransaction);
    return true;
}
 
bool PeConnection::__rollbackTrans()
{   
    /* exec sql begin declare section */
         
    
#line 258 "PeConnection.pgc"
 char * connID = ( _CONST char * ) __connectionID . data () ;
/* exec sql end declare section */
#line 259 "PeConnection.pgc"
 
 
    { ECPGsetconn(__LINE__, connID);}
#line 261 "PeConnection.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_HANDLE(SQLCODE);
        return false;
    }
 
    { ECPGtrans(__LINE__, NULL, "rollback work");}
#line 267 "PeConnection.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_HANDLE(SQLCODE);
        return false;
    }
 
    __UNSET_STATE(stInTransaction);
    return true;
}
 
bool PeConnection::__createQueryInstance(SQL::Query** _queryHandleOut)
{
    __DCL_ASSERT(_queryHandleOut != NULL);
 
    SQL::Query* pNewQuery = new PeQuery(this);
    if (!pNewQuery) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    *_queryHandleOut = pNewQuery;
    return true;
}
 
void PeConnection::setErrorHandle(
    SQL::Error _error, long _SQLCODE,
    const wchar_t* _filename, int _line
)
{
    Connection::setErrorStatus(_error, _filename, _line);
    if (_SQLCODE == 0 /* ECPG_NO_ERROR */) {
        __lastErrorMessage.clear();
    }
    else {
        ByteStringBuilder sb;
        sb.format("SQLCODE(%d) ", _SQLCODE);
        sb.append(sqlca.sqlerrm.sqlerrmc, sqlca.sqlerrm.sqlerrml);
        __lastErrorMessage = sb.toByteString();
    }
}
 
bool PeConnection::__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 PeConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    PGconn* conn = ECPGget_PGconn(__connectionID.data());
    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/ecpg",
        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