IBConnection.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // strtol
#include <string.h>     // strncpy
 
#include <ibase.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 "IBConnection.h"
#include "IBQuery.h"
 
#undef __THIS_FILE__
static const wchar_t __THIS_FILE__[] = __T("dcl/sql/IBConnection.cpp");
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(IBConnection, SQL::Connection)
 
IBConnection::IBConnection(const wchar_t* _serverTitle)
    : Connection(_serverTitle)
{
    Connection::__canTransact = true;
 
    __dialect = SQL_DIALECT_CURRENT;    
    __dbHandle = NULL;
    __trHandle = NULL;
//  memset(__status, 0, sizeof(ISC_STATUS) * ISC_STATUS_VECTOR_LENGTH);
}
 
IBConnection::~IBConnection()
{
}
 
void IBConnection::destroy()
{
//  cerr << "IBConnection::destory\n";
    delete this;
}
 
/*
    pszConnectionString에 가능한 property
        USER,
        PASSWORD,
        SERVER, -- host name
        DATABASE
        SQL_DIALECT
 
        or CREATE DATABASE statement
*/
 
static const char* __createDatabasePattern__ = "CREATE[[:space:]]+DATABASE";
 
bool IBConnection::__open(const char* _connString, size_t _connlen)
{
    try  {
        if (Regex::test(__createDatabasePattern__, _connString, true)) {
            // CREATE DATABASE
            if(isc_dsql_execute_immediate(
                    __status,
                    &__dbHandle,
                    &__trHandle,
                    0,
                    (_CONST char*)_connString,
                    __dialect,
                    NULL)) {
                __SET_ERROR(SQL::eServerError);
                return false;
            }
            return true;
        }
    }
    catch(RegexException* e) {
        e->destroy();
    }
 
    ListedByteStringToByteStringMap map;
    Connection::splitConnectionString(_connString, _connlen, map);
 
    ByteString strServer = map["SERVER"];
    ByteString strDatabase = map["DATABASE"];
    ByteString strUser = map["USER"];
    ByteString strPassword = map["PASSWORD"];
    ByteString strSqlDialect = map["SQL_DIALECT"];
 
    if (!strSqlDialect.isEmpty()) {
        int nDialect = SQL_DIALECT_CURRENT;
        char* endptr;
        long n = strtol(strSqlDialect, &endptr, 10);
        if (n == LONG_MAX || n == LONG_MIN
                || n < INT_MIN || INT_MAX < n
                ) {
            __SET_ERROR_MSG("연결 문자열이 잘못되었습니다. SQL_DIALECT="
                + strSqlDialect);
            return false;
        }
        
        nDialect = (int)n;
 
        if (!(nDialect == SQL_DIALECT_V5
                || nDialect == SQL_DIALECT_V6_TRANSITION
                || nDialect == SQL_DIALECT_V6)) {
            __SET_ERROR_MSG("\"SQL_DIALECT\"- invalid value");
            return false;
        }
 
        __dialect = nDialect;
    }
 
    if ((strUser.length() > 127) || (strPassword.length() > 127)) {
        // USER NAME 과 PASSWORD 의 길이는 127을 넘을 수 없다.
        __SET_ERROR(SQL::eInvalidConnectionString);
        return false;
    }
 
    ByteString strDatabaseEnv;
    if (!strServer.isEmpty())
        strDatabaseEnv = strServer + ":";
 
    if (!strDatabase.isEmpty())
        strDatabaseEnv = strDatabaseEnv + strDatabase;
 
    if (strDatabaseEnv.isEmpty()) {
        __SET_ERROR(SQL::eInvalidConnectionString);
        return false;
    }
 
    // database parameter block
    ByteStringBuilder dpb;
    dpb = (char)isc_dpb_version1;
    dpb += (char)isc_dpb_user_name;
    dpb += (char)strUser.length();
    dpb += strUser;
    dpb += (char)isc_dpb_password;
    dpb += (char)strPassword.length();
    dpb += strPassword;
 
    dpb += (char)isc_dpb_lc_ctype;
    dpb += (char)4;
    dpb += "UTF8";
 
    if (isc_attach_database(
            __status,
            strDatabaseEnv.length(),
            (_CONST char*)strDatabaseEnv.data(),
            &__dbHandle,
            dpb.length(),
            (_CONST char*)dpb.data())
            ) {
//      __DCL_ASSERT(STATUS_FAILED(__status));
        __SET_ERROR(SQL::eServerError);
        __dbHandle = NULL;
        return false;
    }
    return true;
}
 
bool IBConnection::__close()
{
    __DCL_ASSERT(__dbHandle != NULL);
    __DCL_ASSERT(__trHandle == NULL);
 
    if (isc_detach_database(
            __status,
            &__dbHandle)
            ) {
//      __DCL_ASSERT(STATUS_FAILED(__status));
        __SET_ERROR(SQL::eServerError);
        return false;
    }
    __dbHandle = NULL;
    return true;
}
 
enum StmtType {
    StmtOther,
    StmtTransBegin,
    StmtTransEnd,
    StmtCreateDatabase
};
 
typedef struct {
    StmtType type;
    const char* pattern;
} STMT_PATTERN;
 
static STMT_PATTERN sp[] = {
    {   StmtTransBegin,       "SET[[:space:]]+TRANSACTION"    },
    {   StmtTransEnd,       "COMMIT|ROLLBACK"               },
    {   StmtCreateDatabase, __createDatabasePattern__     },
    {   StmtOther,         NULL                            }
};
 
static StmtType __GetStmtType(const char* _sql)
{
    for(size_t i = 0; sp[i].type != StmtOther; i++) {
        if (Regex::test(sp[i].pattern, _sql, true))
            return sp[i].type;
    }
    return StmtOther;
}
 
bool IBConnection::__execute(const char* _sql, size_t n)
{
    __DCL_ASSERT(n <= UINT16_MAX);
    __DCL_ASSERT(__dbHandle != NULL);
    if(isc_dsql_execute_immediate(
            __status,
            &__dbHandle,
            &__trHandle,
            (unsigned short int)n,
            (_CONST char*)_sql,
            __dialect,
            NULL)
            ) {
//      __DCL_ASSERT(STATUS_FAILED(__status));
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    switch (__GetStmtType(_sql)) {
    case StmtTransBegin :
        __SET_STATE(stInTransaction);
        __DCL_ASSERT(__trHandle != NULL);
        break;
    case StmtTransEnd :
        __UNSET_STATE(stInTransaction);
        __trHandle = NULL;
        break;
    default :
        ;
    }
 
    return true;
}
 
bool IBConnection::__startTrans()
{
    __DCL_ASSERT(__trHandle == NULL);
    if (isc_start_transaction(
            __status, 
            &__trHandle, 
            1, 
            &__dbHandle, 
            0, 
            NULL)
            ) {
//      __DCL_ASSERT(STATUS_FAILED(__status));
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    return true;
}
 
bool IBConnection::__commitTrans()
{
    __DCL_ASSERT(__trHandle != NULL);
    if(isc_commit_transaction(
            __status, 
            &__trHandle)
            ) {
//      __DCL_ASSERT(STATUS_FAILED(__status));
        __SET_ERROR(SQL::eServerError);
        return false;
    }
    __trHandle = NULL;
 
    return true;
}
 
bool IBConnection::__rollbackTrans()
{
    __DCL_ASSERT(__trHandle != NULL);
    if(isc_rollback_transaction(
            __status, 
            &__trHandle)
            ) {
//      __DCL_ASSERT(STATUS_FAILED(__status));
        __SET_ERROR(SQL::eServerError);
        return false;
    }
    __trHandle = NULL;
 
    return true;
}
 
bool IBConnection::__createQueryInstance(SQL::Query** _queryHandleOut)
{
    __DCL_ASSERT(_queryHandleOut != NULL);
 
    SQL::Query* pNewQuery = new IBQuery(this);
    if (!pNewQuery) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    
    *_queryHandleOut = pNewQuery;
    return true;
}
 
bool IBConnection::__getErrorMessage(char* _buf, size_t* _buflen)
{
    ByteStringBuilder sb;
    if (!__lastErrorMessage.isEmpty())
        sb = __lastErrorMessage;
    else {
        char sz[512];
        ISC_STATUS* pStatus = __status;
        long nLen = 0;
        for(size_t i = 0; (nLen = isc_interprete(sz, &pStatus))
                && (i < ISC_STATUS_VECTOR_LENGTH); i++) {
            if (i > 0)
                sb += ", ";
            sb.append(sz, 0, nLen);
        }
    }
 
    if (sb.length() < *_buflen)
        *_buflen = sb.length();
 
    strncpy(_buf, sb.data(), *_buflen);
 
    return true;
}
 
static char database_info_items[] = {
    isc_info_version,
    isc_info_db_id,
    isc_info_end
};
 
bool IBConnection::__getServerInfo(char* _buf, size_t* _buflen)
{
    char buffer[512];
    if (isc_database_info (
            __status,
            &__dbHandle,
            sizeof(database_info_items),
            database_info_items,
            sizeof(buffer),
            buffer)) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    ByteString strVersion;
    ByteString strDb;
    ByteString strSite;
 
    char* p = buffer;
    char item;
    unsigned short length;
    __DCL_ASSERT(sizeof(unsigned short) == 2);
    while(*p != isc_info_end) {
        item = *p++;
        length = (unsigned short)isc_vax_integer(p, 2);
        p += 2;
        if (item == isc_info_version) {
        //  __DCL_ASSERT(p[0] == 1);
            //__DCL_TRACE1(L"[%d]\n", p[0]);
            strVersion.assign(p, 2, p[1]);
        }
        else if (item == isc_info_db_id) {
            char* t = p;
            //__DCL_TRACE1(L"[%d]\n", *t);
            //__DCL_ASSERT(*t == 2);
            t++;
            unsigned short nStrLen = *t++;
            strDb.assign(t, nStrLen);
            t += nStrLen;
            nStrLen = *t++;
            strSite.assign(t, nStrLen);
        }
        else {
            __SET_ERROR(SQL::eNotAvailable);
            return false;
        }
        p += length;
    }
 
    ByteString strInfo = "InterBase " + strVersion + " \"" + strSite + ':' + strDb + "\"";
    if (strInfo.length() < *_buflen)
        *_buflen = strInfo.length();
 
    strncpy(_buf, strInfo.data(), *_buflen);
    return true;
}
 
__DCL_END_NAMESPACE