PgConnection.cpp

Go to the documentation of this file.

/* Processed by ecpg (17.4) */
/* These include files are added by the preprocessor */
#include <ecpglib.h>
#include <ecpgerrno.h>
#include <sqlca.h>
/* End of automatic include section */
 
#line 1 "PgConnection.pgc"
#include <dcl/Config.h>
 
#if __DCL_WINDOWS
    #include <windows.h>
    #if __DCL_PTHREAD
        #include <pthread.h>
    #endif
#else
    #include <pthread.h>
#endif
 
#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/Thread.h>
 
#include <dcl/SQLCore.h>
 
#include "PgConnection.h"
#include "PgQuery.h"
#include "PgField.h"   // for _getServerInfo
 
#undef __THIS_FILE__
static const wchar_t __THIS_FILE__[] = __T("dcl/sql/PgConnection.ec");
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(PgConnection, SQL::Connection)
 
static volatile long __connectionID__ = 0;
 
PgConnection::PgConnection(const wchar_t* pszServerTitle)
    : Connection(pszServerTitle)
{
    Connection::__canTransact = true;
    __connectionID = ByteString::format("con:%ld",
        Thread::incrementAndGet(__connectionID__));
}
 
PgConnection::~PgConnection()
{
}
 
void PgConnection::destroy()
{
    delete this;
}
 
/* 
pszConnectionString에 가능한 프로퍼티
        USER,
        PASSWORD,
        SERVER, -- host name
        DATABASE 
*/
 
bool PgConnection::__open(const char* _pszConnString, size_t _n)
{
    ListedByteStringToByteStringMap map;
    Connection::splitConnectionString(_pszConnString, _n, map);
 
    ByteString strServer = map["SERVER"];
    ByteString strUser = map["USER"];
    ByteString strPassword = map["PASSWORD"];
    ByteString strDatabase = map["DATABASE"];
 
    ByteStringBuilder sbTarget;
    if (!strServer.isEmpty()) {
        sbTarget = strServer;
    }
    if (!strDatabase.isEmpty()) {
        if (!sbTarget.isEmpty()) {
            sbTarget += "/";
        }
        sbTarget += strDatabase;
    }
 
    /* exec sql begin declare section */
         
         
         
       
    
#line 88 "PgConnection.pgc"
 char * pszUserName = ( _CONST char * ) strUser . data () ;
 
#line 89 "PgConnection.pgc"
 char * pszPassword = ( _CONST char * ) strPassword . data () ;
 
#line 90 "PgConnection.pgc"
 char * pszTarget = ( _CONST char * ) sbTarget . data () ;
 
#line 91 "PgConnection.pgc"
 char * pszConnectionID = NULL ;
/* exec sql end declare section */
#line 92 "PgConnection.pgc"
 
 
    pszConnectionID = (_CONST char*) __connectionID.data();
 
    { ECPGconnect(__LINE__, 0, pszTarget , pszUserName , pszPassword , pszConnectionID, 0); }
#line 97 "PgConnection.pgc"
  
 
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    return true;
}
 
bool PgConnection::__close()
{
    /* exec sql begin declare section */
         
    
#line 111 "PgConnection.pgc"
 char * pszConnectionID = ( _CONST char * ) __connectionID . data () ;
/* exec sql end declare section */
#line 112 "PgConnection.pgc"
 
 
    { ECPGdisconnect(__LINE__, pszConnectionID);}
#line 114 "PgConnection.pgc"
 
    if (SQLCODE < 0)
    {
        __SET_ERROR_SQLCODE(SQLCODE);
        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* p)
        {
            p->destroy();
        }
    }
    return StmtOther;
}
 
bool PgConnection::__execute(const char* _sql, size_t n)
{
    // 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 PgConnection::__startTrans()
{
    /* exec sql begin declare section */
         
    
#line 193 "PgConnection.pgc"
 char * pszConnectionID = ( _CONST char * ) __connectionID . data () ;
/* exec sql end declare section */
#line 194 "PgConnection.pgc"
 
 
    { ECPGsetconn(__LINE__, pszConnectionID);}
#line 196 "PgConnection.pgc"
 
    if (SQLCODE < 0)
    {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    { ECPGtrans(__LINE__, NULL, "begin work");}
#line 203 "PgConnection.pgc"
 
    if (SQLCODE < 0)
    {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    __SET_STATE(stInTransaction);
 
    return true;
}
 
bool PgConnection::__commitTrans()
{
    /* exec sql begin declare section */
         
    
#line 218 "PgConnection.pgc"
 char * pszConnectionID = ( _CONST char * ) __connectionID . data () ;
/* exec sql end declare section */
#line 219 "PgConnection.pgc"
 
 
    { ECPGsetconn(__LINE__, pszConnectionID);}
#line 221 "PgConnection.pgc"
 
    if (SQLCODE < 0)
    {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    { ECPGtrans(__LINE__, NULL, "commit work");}
#line 228 "PgConnection.pgc"
 
    if (SQLCODE < 0)
    {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    __UNSET_STATE(stInTransaction);
 
    return true;
}
 
bool PgConnection::__rollbackTrans()
{   
    /* exec sql begin declare section */
         
    
#line 243 "PgConnection.pgc"
 char * pszConnectionID = ( _CONST char * ) __connectionID . data () ;
/* exec sql end declare section */
#line 244 "PgConnection.pgc"
 
 
    { ECPGsetconn(__LINE__, pszConnectionID);}
#line 246 "PgConnection.pgc"
 
    if (SQLCODE < 0)
    {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    { ECPGtrans(__LINE__, NULL, "rollback work");}
#line 253 "PgConnection.pgc"
 
    if (SQLCODE < 0)
    {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    __UNSET_STATE(stInTransaction);
    
    return true;
}
 
bool PgConnection::__createQueryInstance(SQL::Query** _queryHandleOut)
{
    __DCL_ASSERT(_queryHandleOut != NULL);
 
    SQL::Query* pNewQuery = new PgQuery(this);
    if (!pNewQuery)
    {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    
    *_queryHandleOut = pNewQuery;
    return true;
}
 
void PgConnection::setErrorStatus(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 PgConnection::__getErrorMessage(char* _buf, size_t* _buflen)
{
    __DCL_ASSERT(Connection::__errorCode == SQL::eServerError);
    if (__lastErrorMessage.length() < *_buflen)
        *_buflen = __lastErrorMessage.length();
    strncpy(_buf, __lastErrorMessage.data(), *_buflen);
    return true;
}
 
bool PgConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    PgQuery* pQuery = new PgQuery(this);
    if (pQuery == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    bool localTrans = false;
    if (!inState(SQL::Connection::stInTransaction)) {
        __startTrans();
        localTrans = true;
    }
 
    const char* _sql = "select version()";
    for ( ; ; ) {
        if (!pQuery->prepare(_sql, ByteString::length(_sql), 0))
            break;
 
        if (!pQuery->execute())
            break;
 
        if (!pQuery->fetch())
            break;
 
        if (pQuery->eof()) {
            __SET_ERROR(SQL::eNotAvailable);
            break;
        }
 
        PgField* pField = NULL;
        if (!pQuery->__getField(0, (SQL::Field**)&pField))
            break;
 
        if (pField->isNull()) {
            __SET_ERROR(SQL::eNotAvailable);
            break;
        }
 
        if (!pField->__getData(_buf, _buflen, SQL::typeText))
            break;
 
        pQuery->__destroy();
        pQuery = NULL;
 
        if (localTrans) {
            __commitTrans();
        }
        return true;
    }
 
    if (pQuery) {
        pQuery->__destroy();
    }
 
    if (localTrans) {
        __rollbackTrans();
    }
    return false;
}       
 
__DCL_END_NAMESPACE