IFXConnection.cpp

Go to the documentation of this file.

#line 1 "ifxconnection.ec"
#include <dcl/Config.h>
 
#include <sqlhdr.h>
#include <sqliapi.h>
 
#include <sqlstype.h>
 
#if __DCL_WINDOWS
    #include <windows.h>
    #if __DCL_PTHREAD
        #include <pthread.h>
    #endif
#else
    #include <pthread.h>
#endif
 
#include <ctype.h>      // isspace
#include <string.h>     // strlen, strncpy
 
#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 "IFXConnection.h"
#include "IFXQuery.h"
#include "IFXField.h" // for _getServerInfo
 
#undef __THIS_FILE__
static const wchar_t __THIS_FILE__[] = __T("dcl/sql/IFXConnection.ec");
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(IFXConnection, SQL::Connection)
 
static volatile long __connectionID__ = 0;
 
IFXConnection::IFXConnection(const wchar_t* _serverTitle)
    : Connection(_serverTitle)
{
    __connectionID = ByteString::format("con:%ld", Thread::incrementAndGet(__connectionID__));
}
 
IFXConnection::~IFXConnection()
{
}
 
void IFXConnection::destroy()
{
    delete this;
}
 
/*
pszConnectionString에 가능한 프로퍼티
        USER,
        PASSWORD,
        SERVER, -- host name
        DATABASE
*/
 
void IFXConnection::reset()
{
/*
 *  EXEC SQL BEGIN DECLARE SECTION;
 */
#line 67 "ifxconnection.ec"
#line 68 "ifxconnection.ec"
  char *pszConnectionID = (_CONST char*) __connectionID.data();
/*
 *  EXEC SQL END DECLARE SECTION;
 */
#line 69 "ifxconnection.ec"
 
 
/*
 *  EXEC SQL SET CONNECTION :pszConnectionID;
 */
#line 71 "ifxconnection.ec"
  {
#line 71 "ifxconnection.ec"
  sqli_connect_set(0, pszConnectionID, 0);
#line 71 "ifxconnection.ec"
  }
 
/*
 *  EXEC SQL BEGIN WORK;
 */
#line 73 "ifxconnection.ec"
  {
#line 73 "ifxconnection.ec"
  sqli_trans_begin2((mint)1);
#line 73 "ifxconnection.ec"
  }
    if (SQLCODE == 0) {
        Connection::__canTransact = true;
/*
 *      EXEC SQL ROLLBACK WORK;
 */
#line 76 "ifxconnection.ec"
  {
#line 76 "ifxconnection.ec"
  sqli_trans_rollback();
#line 76 "ifxconnection.ec"
  }
    }
    else
        Connection::__canTransact = false;
 
    __UNSET_STATE(stInTransaction);
}
 
bool IFXConnection::__open(const char* _connString, size_t _connlen)
{
    ListedByteStringToByteStringMap map;
    Connection::splitConnectionString(_connString, _connlen, map);
 
    ByteString strServer = map["SERVER"];
    ByteString strUser = map["USER"];
    ByteString strPassword = map["PASSWORD"];
    ByteString strDatabase = map["DATABASE"];
 
    ByteString strDatabaseEnv = strDatabase;
    if (!strServer.isEmpty()) {
        strDatabaseEnv = strDatabaseEnv + "@" + strServer;
    }
    //__DCL_TRACE1(L"[%hs]\n", strDatabaseEnv.data());
 
/*
 *  EXEC SQL BEGIN DECLARE SECTION;
 */
#line 100 "ifxconnection.ec"
#line 101 "ifxconnection.ec"
  char *pszUserName = (_CONST char*) strUser.data();
  char *pszPassword = (_CONST char*) strPassword.data();
  char *pszDatabaseEnv = (_CONST char*) strDatabaseEnv.data();
  char *pszConnectionID = NULL;
/*
 *  EXEC SQL END DECLARE SECTION;
 */
#line 105 "ifxconnection.ec"
 
 
    pszConnectionID = (_CONST char*) __connectionID.data();
 
/*
 *  EXEC SQL CONNECT TO :pszDatabaseEnv AS :pszConnectionID
 *              USER :pszUserName USING :pszPassword
 *              WITH CONCURRENT TRANSACTION;
 */
#line 109 "ifxconnection.ec"
  {
#line 111 "ifxconnection.ec"
  ifx_conn_t      *_sqiconn;
  _sqiconn = (ifx_conn_t *)ifx_alloc_conn_user(pszUserName, pszPassword);
  sqli_connect_open(ESQLINTVERSION, 0, pszDatabaseEnv, pszConnectionID, _sqiconn, 1);
  ifx_free_conn_user(&_sqiconn);
#line 111 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    if (!strDatabase.isEmpty())
        reset();
 
    return true;
}
 
bool IFXConnection::__close()
{
/*
 *  EXEC SQL BEGIN DECLARE SECTION;
 */
#line 125 "ifxconnection.ec"
#line 126 "ifxconnection.ec"
  char *pszConnectionID = (_CONST char*) __connectionID.data();
/*
 *  EXEC SQL END DECLARE SECTION;
 */
#line 127 "ifxconnection.ec"
 
 
/*
 *  EXEC SQL DISCONNECT :pszConnectionID;
 */
#line 129 "ifxconnection.ec"
  {
#line 129 "ifxconnection.ec"
  sqli_connect_close(0, pszConnectionID, 0, 0);
#line 129 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
    
    return true;
}
 
enum StmtType {
    StmtOther,
    StmtTransBegin,
    StmtTransEnd,
    StmtDatabase
};
 
typedef struct {
    StmtType type;
    const char* pattern;
} STMT_PATTERN;
 
static STMT_PATTERN sp[] = {
    {   StmtTransBegin,       "BEGIN" },
    {   StmtTransEnd,       "COMMIT|ROLLBACK"   },
    {   StmtDatabase,       "DATABASE"          },
    {   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 IFXConnection::__execute(const char* _sql, size_t _sqllen)
{
/*
 *  EXEC SQL BEGIN DECLARE SECTION;
 */
#line 173 "ifxconnection.ec"
#line 174 "ifxconnection.ec"
  char *pszConnectionID = (_CONST char*) __connectionID.data();
  char *pszSqlStatement = (_CONST char*) _sql;
/*
 *  EXEC SQL END DECLARE SECTION;
 */
#line 176 "ifxconnection.ec"
 
 
/*
 *  EXEC SQL SET CONNECTION :pszConnectionID;
 */
#line 178 "ifxconnection.ec"
  {
#line 178 "ifxconnection.ec"
  sqli_connect_set(0, pszConnectionID, 0);
#line 178 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
/*
 *  EXEC SQL EXECUTE IMMEDIATE :pszSqlStatement;
 */
#line 184 "ifxconnection.ec"
  {
#line 184 "ifxconnection.ec"
  sqli_exec_immed(pszSqlStatement);
#line 184 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    switch(__GetStmtType(_sql)) {
    case StmtTransBegin :
        __SET_STATE(stInTransaction);
        break;
    case StmtTransEnd :
        __UNSET_STATE(stInTransaction);
        break;
    case StmtDatabase :
        reset();
        break;
    case StmtOther :
    default :
        ;
    }
 
    return true;
}
 
bool IFXConnection::__startTrans()
{
/*
 *  EXEC SQL BEGIN DECLARE SECTION;
 */
#line 210 "ifxconnection.ec"
#line 211 "ifxconnection.ec"
  char *pszConnectionID = (_CONST char*) __connectionID.data();
/*
 *  EXEC SQL END DECLARE SECTION;
 */
#line 212 "ifxconnection.ec"
 
 
/*
 *  EXEC SQL SET CONNECTION :pszConnectionID;
 */
#line 214 "ifxconnection.ec"
  {
#line 214 "ifxconnection.ec"
  sqli_connect_set(0, pszConnectionID, 0);
#line 214 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
/*
 *  EXEC SQL BEGIN WORK;
 */
#line 220 "ifxconnection.ec"
  {
#line 220 "ifxconnection.ec"
  sqli_trans_begin2((mint)1);
#line 220 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    __SET_STATE(stInTransaction);
    return true;
}
 
bool IFXConnection::__commitTrans()
{
/*
 *  EXEC SQL BEGIN DECLARE SECTION;
 */
#line 232 "ifxconnection.ec"
#line 233 "ifxconnection.ec"
  char *pszConnectionID = (_CONST char*) __connectionID.data();
/*
 *  EXEC SQL END DECLARE SECTION;
 */
#line 234 "ifxconnection.ec"
 
 
/*
 *  EXEC SQL SET CONNECTION :pszConnectionID;
 */
#line 236 "ifxconnection.ec"
  {
#line 236 "ifxconnection.ec"
  sqli_connect_set(0, pszConnectionID, 0);
#line 236 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
/*
 *  EXEC SQL COMMIT WORK;
 */
#line 242 "ifxconnection.ec"
  {
#line 242 "ifxconnection.ec"
  sqli_trans_commit();
#line 242 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    __UNSET_STATE(stInTransaction);
    return true;
}
 
bool IFXConnection::__rollbackTrans()
{   
/*
 *  EXEC SQL BEGIN DECLARE SECTION;
 */
#line 254 "ifxconnection.ec"
#line 255 "ifxconnection.ec"
  char *pszConnectionID = (_CONST char*) __connectionID.data();
/*
 *  EXEC SQL END DECLARE SECTION;
 */
#line 256 "ifxconnection.ec"
 
 
/*
 *  EXEC SQL SET CONNECTION :pszConnectionID;
 */
#line 258 "ifxconnection.ec"
  {
#line 258 "ifxconnection.ec"
  sqli_connect_set(0, pszConnectionID, 0);
#line 258 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
/*
 *  EXEC SQL ROLLBACK WORK;
 */
#line 264 "ifxconnection.ec"
  {
#line 264 "ifxconnection.ec"
  sqli_trans_rollback();
#line 264 "ifxconnection.ec"
  }
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    __UNSET_STATE(stInTransaction);
    return true;
}
 
bool IFXConnection::__createQueryInstance(SQL::Query** _queryHandleOut)
{
    __DCL_ASSERT(_queryHandleOut != NULL);
 
    SQL::Query* pNewQuery = new IFXQuery(this);
    if (!pNewQuery) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    
    *_queryHandleOut = pNewQuery;
    return true;
}
 
void IFXConnection::setErrorStatus(SQL::Error _error, long _SQLCODE,
        const wchar_t* _filename, int _line)
{
    Connection::setErrorStatus(_error, _filename, _line);
    if (_SQLCODE == 0) {
        __lastErrorMessage.clear();
        return;
    }
 
    __DCL_ASSERT(_SQLCODE == sqlca.sqlcode);
 
    ByteStringBuilder sb;
    sb.format("SQLCODE(%d) ", _SQLCODE);
 
    char buf[600];
    mint actual = 0;
    mint r = rgetlmsg(_SQLCODE, buf, sizeof(buf), &actual);
    if (!r) {
        while (actual > 0) {
            if (!isspace(buf[actual - 1]))
                break;
            actual--;
        }
        buf[actual] = '\0';
        sb.format(buf, sqlca.sqlerrm);
    }
    else {
        sb.format("(%d)", r);
        switch (r) {
        case -1227:
            sb.append("Message file not found");
            break;
        case -1228:
            sb.append("Message number not found in message file");
            break;
        case -1231:
            sb.append("Cannot seek within messge file");
            break;
        case -1232:
            sb.append("Message buffer too small");
            break;
        default:
            sb.append("Unkndown");
        }
    }
    __lastErrorMessage = sb.toByteString();
}
 
bool IFXConnection::__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 IFXConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    IFXQuery* pQuery = new IFXQuery(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 DBINFO('version', 'full')"
        "   FROM systables WHERE tabid = 1";
    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;
        }
 
        IFXField* 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
 
#line 408 "ifxconnection.ec"