SQLCore.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>        // for dcl/Thread.h
#endif
 
#include <string.h>
#include <wchar.h>          // wcslen, wcsncpy
#include <dcl/Object.h>
#include <dcl/Thread.h>     // Thread::incrementAndGet, decrementAndGet
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Array.h>           // ByteStringArray
#include <dcl/ListedHashMap.h>   // ListedByteStringToByteStringMap
#include <dcl/SQLCore.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLCore.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
typedef struct __SQL_ERROR
{
    SQL::Error error;
    const wchar_t* message;
} SQL_ERROR;
 
#if __DCL_DEBUG
#define __SQLERROR_MSG(code, msg) {code, L"(" __T(#code) L")"  __T(msg) }
#else
#define __SQLERROR_MSG(code, msg) {code, __T(msg) }
#endif
 
bool SQL::getErrorMessage(
        wchar_t* _buf,      // OUT
        size_t* _buflen,    // IN, OUT
        Error _errorCode   // IN
        )
{
    static const SQL_ERROR errors[] = {
    // Core Error
    __SQLERROR_MSG(eNoError,          "No Error"),
    __SQLERROR_MSG(eServerError,      "서버 혹은 서버 API 호출중에 에러가 발생했습니다."),
    __SQLERROR_MSG(eBadAddress,            "버퍼 혹은 파라메터의 주소가 잘못되었습니다."),
    __SQLERROR_MSG(eOutOfMemory,      "메모리 할당이 불가능합니다."),
    __SQLERROR_MSG(eNotSupportMethod,    "서버 혹은 드라이버에서 지원하지 않는 메소드 입니다."),
 
    // SQL::Connection::execute, SQL::Query::prepare, execute
    __SQLERROR_MSG(eNotSupportStatement, "이 인터페이스를 통해 실행할 수 없는 SQL 입니다"),
 
    // SQL::Connection Errors
    __SQLERROR_MSG(eInvalidConnectionString, "서버 연결을위한 연결문자열의 값이 잘못되었습니다."),
    __SQLERROR_MSG(eConnected,          "서버와 연결되어 있는 상태입니다. 다시 연결할 수 없습니다."),
    __SQLERROR_MSG(eNotConnected,        "서버에 연결되어 있지 않습니다. 연결을 끊을 수 없습니다."),
    __SQLERROR_MSG(eInTransaction,      "트랜잭션 중 입니다. 트랜잭션을 시작할 수 없습니다."),
    __SQLERROR_MSG(eNotInTransaction,    "트랜잭션 상태가 아닙니다. 트랜잭션을 종료할 수 없습니다."),
    __SQLERROR_MSG(eHaveChildQuery,        "이 연결을 사용하는 쿼리 인터페이스가 있습니다."),
    __SQLERROR_MSG(eNoChildQuery,        "이 연결을 사용하는 쿼리 인터페이스가 아닙니다."),
    __SQLERROR_MSG(eNotAvailable,        "서버의 정보를 얻을 수 없습니다."),
 
    // SQL::Query Errors
    __SQLERROR_MSG(eNotPrepared,      "쿼리가 준비되지 있지 않습니다."),
    __SQLERROR_MSG(eNotExecuted,      "쿼리가 실행되어 있지 않습니다."),
    __SQLERROR_MSG(eNotFetched,            "쿼리가 fetch되어 있지 않습니다."),
    __SQLERROR_MSG(eInvalidIndex,        "필드나 파라메터를 참조하는 인덱스가 잘못되었습니다."),
 
    // SQL::Field Errors
    __SQLERROR_MSG(eValueIsNull,      "필드의 값이 null 입니다."),
    __SQLERROR_MSG(eNotSupportDataType,    "서버 혹은 드라이버에서 지원하지 않는 데이터타입입니다."),
    __SQLERROR_MSG(eInvalidDataType,  "필드값을 얻거나 파라메터 값을 설정하기 위한 데이터타입이 잘못되었습니다."),
    __SQLERROR_MSG(eInvalidBufferSize,  "필드 혹은 아웃바인드의 값을 읽고자 하는 버퍼의 크기가 잘못되었습니다."),
    __SQLERROR_MSG(eOutOfRange,            "데이터타입과 사이즈로 Numeric 데이터를 얻는데 범위를 초과했습니다."),
 
    // SQL::Param Errors
    __SQLERROR_MSG(eInvalidData,      "데이터가 잘못되었거나 서버에 적용할수 없는 형식입니다."),
    __SQLERROR_MSG(eInvalidDataSize,  "데이터타입에 적절한 데이터 크기가 아닙니다.")
    };
 
    __DCL_ASSERT(_buf != NULL && _buflen != NULL);
 
    const wchar_t* psz = L"Unknown error code";
    for(size_t i = 0; i < __countof(errors, SQL_ERROR); i++) {
        if (_errorCode == errors[i].error) {
            psz = errors[i].message;
            break;
        }
    }
 
    size_t len = wcslen(psz);
    if (*_buflen >= len) {
        wcsncpy(_buf, psz, len);
        *_buflen = len;
        return true;
    }
 
    *_buflen = len;
    return false;
}
 
#define DATA_TYPE_NAME(type) case type : return __T(#type)
 
const wchar_t* SQL::dataTypeName(DataType _dataType)
{
    switch(_dataType) {
        DATA_TYPE_NAME(typeUnknown);
        DATA_TYPE_NAME(typeInteger);
        DATA_TYPE_NAME(typeUInteger);
        DATA_TYPE_NAME(typeFloat);
        DATA_TYPE_NAME(typeNumeric);
        DATA_TYPE_NAME(typeDate);
        DATA_TYPE_NAME(typeTime);
        DATA_TYPE_NAME(typeTimeStamp);
        DATA_TYPE_NAME(typeTimeStampTz);
        DATA_TYPE_NAME(typeInterval);
        DATA_TYPE_NAME(typeIntervalYm);
        DATA_TYPE_NAME(typeIntervalDs);
        DATA_TYPE_NAME(typeText);
        DATA_TYPE_NAME(typeBinary);
        DATA_TYPE_NAME(typeLongText);
        DATA_TYPE_NAME(typeLongBinary);
        DATA_TYPE_NAME(typeClob);
        DATA_TYPE_NAME(typeBlob);
 
        // additional buffer type
        DATA_TYPE_NAME(typeInputStream);
        DATA_TYPE_NAME(typeOutputStream);
    };
 
    __DCL_ASSERT(false);
    return __T("");
}
 
#define __CHECK_ADDRESS(p) \
{ \
    if (p == NULL) { \
        __SET_ERROR(eBadAddress); \
        return false; \
    } \
}
 

#undef __SET_ERROR
#define __SET_ERROR(_errorCode) \
    __queryHandle->connection()->setErrorStatus(_errorCode, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(SQL::Field, Object)
 
SQL::Field::Field(Query* _queryHandle)
{
    __queryHandle = _queryHandle;
    __dataType = typeUnknown;
    __precision = -1;
    __scale = 0;
}
 
SQL::Field::~Field()
{
}
 
bool SQL::Field::getDataSize(
        size_t* _pn,
        bool _maxSize
        )
{
    __DCL_ASSERT(__dataType != typeUnknown);
 
    // check query state
    __DCL_ASSERT(__queryHandle->inState(SQL::Query::stExecuted));
    /*
    EXECUTE PROCEDURE 의 경우 fetch 하지 않고 
    바로 접근할 수 있어야 함 2004.02.04
    if (!__queryHandle->inState(SQL::Query::stFetched))
    {
        __SET_ERROR(eMustFetched);
        return false;
    }
    */
 
    __CHECK_ADDRESS(_pn)
 
    if (!_maxSize) {
        if (isNull()) {
            __SET_ERROR(eValueIsNull);
            return false;
        }
    }
 
    return __getDataSize(_pn, _maxSize);
}
 
static bool __CheckAccessType(
        SQL::DataType _dataType,   // field, or param datatype
        SQL::DataType _accessType  // buffer datatype
        )
{
    switch(_dataType) {
        case SQL::typeInteger :
        case SQL::typeUInteger :
        case SQL::typeFloat :
        case SQL::typeDate :
        case SQL::typeTime :
        case SQL::typeTimeStamp :
        case SQL::typeTimeStampTz :
        case SQL::typeInterval:
        case SQL::typeIntervalYm :
        case SQL::typeIntervalDs :
            if (_accessType == _dataType)
                return true;
            break;
        case SQL::typeNumeric :
            if (_accessType == SQL::typeInteger
                || _accessType == SQL::typeUInteger
                || _accessType == SQL::typeFloat
                || _accessType == SQL::typeText)
                return true;
            break;
        case SQL::typeText :
        case SQL::typeLongText :
        case SQL::typeClob :
            if (_accessType == SQL::typeText
                || _accessType == SQL::typeOutputStream)
                return true;
            break;
        case SQL::typeBinary :
        case SQL::typeLongBinary :
        case SQL::typeBlob :
            if (_accessType == SQL::typeBinary
                || _accessType == SQL::typeOutputStream)
                return true;
            break;
        default :
            __DCL_ASSERT(false);
    }
    return false;
}
 
bool SQL::Field::getData(
        void* _pv,              // buffer, OUT
        size_t* _pn,            // sizeof *_pv, IN, OUT
        DataType _dataType      // typeof *_pv
        )
{
    __DCL_ASSERT(__dataType != typeUnknown);
 
#if __DCL_DEBUG
    __DCL_ASSERT(_dataType != typeUnknown);
    __DCL_ASSERT(_dataType != typeNumeric);
    __DCL_ASSERT(_dataType != typeInputStream);
#else
    if (_dataType == typeUnknown
        || _dataType == typeNumeric
        || _dataType == typeInputStream) {
        __SET_ERROR(eInvalidData);
        return false;
    }
#endif
 
    /*
    EXECUTE PROCEDURE 의 경우 fetch 하지 않고 바로 접근 2004.0204
    if (!__queryHandle->inState(SQL::Query::stFetched)) {
        __SET_ERROR(eMustFetched);
        return false;
    }
    */
 
    __CHECK_ADDRESS(_pv)
    __CHECK_ADDRESS(_pn)
 
    if (isNull()) {
        __SET_ERROR(eValueIsNull);
        return false;
    }
 
    if (!__CheckAccessType(__dataType, _dataType)) {
        __SET_ERROR(eInvalidDataType);
        return false;
    }
 
    return __getData(_pv, _pn, _dataType);
}
 
IMPLEMENT_CLASSINFO(SQL::Param, SQL::Field)
 
SQL::Param::Param(SQL::Query* _queryHandle)
    : Field(_queryHandle)
{
}
 
SQL::Param::~Param()
{
}
 
 
void SQL::Param::setName(String _name)
{
    __name = _name;
}
 
bool SQL::Param::setData(
        _CONST        void* _pv,  // data, IN
        size_t      _n,         // sizeof *_pv
        DataType    _dataType,  // typeof *_pv
        DataType    _assignType // assign to server type
        )
{
#if __DCL_DEBUG
    switch(_dataType) {
        case typeInteger :
        case typeUInteger :
        case typeFloat :
        case typeDate :
            if (_dataType == typeDate) {
                const Date* p = (const Date*)_pv;
                __DCL_ASSERT(
                    (-9999 <= p->nYear && p->nYear <= 9999)
                    && (1 <= p->nMonth && p->nMonth <= 12)
                    && (1 <= p->nDay && p->nDay <= 31)
                    );
            }
        case typeTime :
            if (_dataType == typeTime) {
                const Time* p = (const Time*)_pv;
                __DCL_ASSERT(
                    (p->nHour <= 23)
                    && (p->nMin <= 59)
                    && (p->nSec <= 59)
                    && (p->nFrac <= 999999999)
                    );
            }
        case typeTimeStamp :
        case typeTimeStampTz :
            if (_dataType == typeTimeStamp || _dataType == typeTimeStampTz) {
                const TimeStamp* p = (const TimeStamp*)_pv;
                __DCL_ASSERT(
                    (-9999 <= p->nYear && p->nYear <= 9999)
                    && (1 <= p->nMonth && p->nMonth <= 12)
                    && (1 <= p->nDay && p->nDay <= 31)
                    && (p->nHour <= 23)
                    && (p->nMin <= 59)
                    && (p->nSec <= 59)
                    && (p->nFrac <= 999999999)
                    && (-720 <= p->nTzMin && p->nTzMin < 840)
                    );
            }
        case typeIntervalYm :
        case typeIntervalDs :
            if (_dataType == typeIntervalYm || _dataType == typeIntervalDs) {
                const Interval* p = (const Interval*)_pv;
                __DCL_ASSERT(
                    (-999999999 <= p->nYears && p->nYears <= 999999999)
                    && (-11 <= p->nMonths && p->nMonths <= 11)
                    && (-999999999 <= p->nDays && p->nDays <= 999999999)
                    && (p->nHours <= 23)
                    && (p->nMins <= 59)
                    && (p->nSecs <= 59)
                    && (p->nFracs <= 999999999)
                    );
            }
            // typeInteger ~ typeIntervalDs
#if __DCL_DEBUG
            __DCL_ASSERT(_dataType == _assignType);
#else
            if (_dataType != _assignType) {
                __SET_ERROR(eInvalidDataType);
                return false;
            }
#endif
            break;
        case typeText :
            switch(_assignType)
            {
            case typeNumeric :
            case typeText :
            case typeLongText :
            case typeClob :
                break;
            default :
#if __DCL_DEBUG
                __DCL_ASSERT(false);
#else
                __SET_ERROR(eInvalidDataType);
                return false;
#endif
            }
            break;
        case typeBinary :
            switch(_assignType) {
                case typeBinary :
                case typeLongBinary :
                case typeBlob :
                    break;
                default :
#if __DCL_DEBUG
                __DCL_ASSERT(false);
#else
                __SET_ERROR(eInvalidDataType);
                return false;
#endif
            }
            break;
        case typeInputStream :
            switch(_assignType) {
                case typeText :
                case typeBinary :
                case typeLongText :
                case typeLongBinary :
                case typeClob :
                case typeBlob :
                    break;
                default :
#if __DCL_DEBUG
                __DCL_ASSERT(false);
#else
                __SET_ERROR(eInvalidDataType);
                return false;
#endif
            }
            break;
        default :
        /*
        case typeUnknown :
        case typeNumeric :
        case typeLongText :
        case typeLongBinary :
        case typeClob :
        case typeBlob :
        case typeOutputStream :
        */
#if __DCL_DEBUG
            __DCL_ASSERT(false);
#else
            __SET_ERROR(eInvalidDataType);
            return false;
#endif
    }
#endif
 
    __DCL_ASSERT(__queryHandle->inState(SQL::Query::stPrepared));
 
    __CHECK_ADDRESS(_pv)
 
    return __setData(_pv, _n, _dataType, _assignType);
}
 
 
bool SQL::Param::setDataType(
        DataType    _dataType
        )
{
#if __DCL_DEBUG
    __DCL_ASSERT(_dataType != typeUnknown);
    __DCL_ASSERT(_dataType != typeInputStream);
    __DCL_ASSERT(_dataType != typeOutputStream);
#else
    if (_dataType == typeUnknown
        || _dataType == typeInputStream
        || _dataType == typeOutputStream) {
            __SET_ERROR(eInvalidDataType);
            return false;
    }
#endif
 
    __DCL_ASSERT(__queryHandle->inState(SQL::Query::stPrepared));
 
    return __setDataType(_dataType);
}
 
// isNull, __setDataType, __getDataSize, __getData는
// 드라이버에서 구현하지 않을 수도 있다.
 
bool SQL::Param::isNull() const
{
    return true;
}
 
bool SQL::Param::__setDataType(
        DataType    _dataType
        )
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Param::__getDataSize(
        size_t* _pn,
        bool _maxSize
        )
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Param::__getData(
        void* _pv,
        size_t* _pn,            // IN, OUT
        DataType _dataType
        )
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}

#undef __SET_ERROR
#define __SET_ERROR(_errorCode) \
    __connHandle->setErrorStatus(_errorCode, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(SQL::Query, Object)
 
SQL::Query::Query(_CONST SQL::Connection* _connHandle)
{
    __connHandle = _connHandle;
    __eof = true;
    __affectedRows = -1;
 
    __fieldCount = 0;
    __paramCount = 0;
    __placeholder = L'?';
 
    __states = stStandBy;
 
    __connHandle->addRef();
}
 
SQL::Query::~Query()
{
    __connHandle->release();
}
 
bool SQL::Query::prepare(const char* _sql, size_t _sqllen,
        size_t _paramCount)
{
    __states = stStandBy;
 
    __CHECK_ADDRESS(_sql)
 
    if (__prepare(_sql, _sqllen, _paramCount)) {
        __SET_STATE(stPrepared);
        return true;
    }
    return false;
}
 
bool SQL::Query::execute()
{
    if (!inState(stPrepared)) {
        __SET_ERROR(eNotPrepared);
        return false;
    }
 
    if (__execute()) {
        __SET_STATE(stExecuted);
        return true;
    }
    return false;
}
 
bool SQL::Query::fetch()
{
    if(!inState(stExecuted)) {
        __SET_ERROR(eNotExecuted);
        return false;
    }
 
    if (__fetch()) {
        __SET_STATE(stFetched);
        return true;
    }
    return false;
}
 
bool SQL::Query::__nextResult()
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Query::nextResult()
{
    if (!inState(stExecuted)) {
        __SET_ERROR(eNotExecuted);
        return false;
    }
    return __nextResult();
}
 
bool SQL::Query::getField(size_t _index, SQL::Field** _fieldHandleOut)
{
    if (!inState(stExecuted)) {
        __SET_ERROR(eNotExecuted);
        return false;
    }
 
    if (_index >= __fieldCount) {
        __SET_ERROR(eInvalidIndex);
        return false;
    }
    __CHECK_ADDRESS(_fieldHandleOut)
 
    return __getField(_index, _fieldHandleOut);
}
 
bool SQL::Query::getParam(size_t _index, SQL::Param** _paramHandleOut)
{
    if (!inState(stPrepared)) {
        __SET_ERROR(eNotPrepared);
        return false;
    }
 
    if (_index >= __paramCount) {
        __SET_ERROR(eInvalidIndex);
        return false;
    }
    __CHECK_ADDRESS(_paramHandleOut);
 
    return __getParam(_index, _paramHandleOut);
}

#undef __SET_ERROR
#define __SET_ERROR(_errorCode) \
    setErrorStatus(_errorCode, __THIS_FILE__, __LINE__)
 
void SQL::Connection::setErrorStatus(
        SQL::Error _errorCode, const wchar_t* _filename, int _line)
{
    __errorCode = _errorCode;
    __errorFileName = _filename;
    __errorLine = _line;
}
 
IMPLEMENT_CLASSINFO(SQL::Connection, Object)
 
long SQL::Connection::addRef()
{
    return Thread::incrementAndGet(__refCount);
}
 
long SQL::Connection::release()
{
    long n = Thread::decrementAndGet(__refCount);
    __DCL_ASSERT(n >= 0);
    return n;
}
 
SQL::Connection::Connection(const wchar_t* _serverTitle)
{
    __refCount = 0;
 
    __canTransact = false;
    __serverTitle = _serverTitle;
 
    __errorCode = eNoError;
    __errorFileName = NULL;
    __errorLine = 0;
 
    __states = stClosed;
}
 
SQL::Connection::~Connection()
{
    __DCL_ASSERT(refCount() == 0);
}
 
bool SQL::Connection::open(const char* _connString, size_t _connlen)
{
    if (inState(stOpenned)) {
        __SET_ERROR(eConnected);
        return false;
    }
 
    __CHECK_ADDRESS(_connString)
 
    if (__open(_connString, _connlen)) {
        __SET_STATE(stOpenned);
        return true;
    }
    return false;
}
 
bool SQL::Connection::close()
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (refCount()) {
        __SET_ERROR(eHaveChildQuery);
        return false;
    }
 
    if (__close()) {
        __SET_STATE(stClosed);
        return true;
    }
    return false;
}
 
bool SQL::Connection::execute(const char* _sql, size_t _sqllen)
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    __CHECK_ADDRESS(_sql)
 
    return __execute(_sql, _sqllen);
}
 
bool SQL::Connection::startTrans()
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (inState(stInTransaction)) {
        __SET_ERROR(eInTransaction);
        return false;
    }
 
    if (__startTrans()) {
        __SET_STATE(stInTransaction);
        return true;
    }
    return false;
}
 
bool SQL::Connection::commitTrans()
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (!inState(stInTransaction)) {
        __SET_ERROR(eNotInTransaction);
        return false;
    }
 
    if (__commitTrans()) {
        __UNSET_STATE(stInTransaction);
        return true;
    }
    return false;
}
 
bool SQL::Connection::rollbackTrans()
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (!inState(stInTransaction)) {
        __SET_ERROR(eNotInTransaction);
        return false;
    }
 
    if (__rollbackTrans()) {
        __UNSET_STATE(stInTransaction);
        return true;
    }
    return false;
}
 
bool SQL::Connection::getErrorMessage(char* _buf, size_t* _buflen)
{
    if ((_buf == NULL) || (_buflen == NULL) || (*_buflen <= 0))
        return false;
 
    return __getErrorMessage(_buf, _buflen);
}
 
bool SQL::Connection::getServerInfo(char* _buf, size_t* _buflen)
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    __CHECK_ADDRESS(_buf)
    __CHECK_ADDRESS(_buflen)
 
    return __getServerInfo(_buf, _buflen);
}
 
bool SQL::Connection::createQueryInstance(SQL::Query** _queryHandleOut)
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    __CHECK_ADDRESS(_queryHandleOut);
 
    if (__createQueryInstance(_queryHandleOut)) {
        addRef();
        return true;
    }
    return false;
}
 
bool SQL::Connection::destroyQueryInstance(SQL::Query* _queryHandle)
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (_queryHandle->__connHandle != this) {
        __SET_ERROR(eNoChildQuery);
        return false;
    }
 
    release();
    _queryHandle->__destroy();
    return true;
}
 
// static members
// for driver implemtation
size_t SQL::Connection::splitConnectionString(
        const char* _pszConnectionString, size_t _n,
        ListedByteStringToByteStringMap& _map
        )
{
    __DCL_ASSERT(_pszConnectionString != NULL);
    ByteStringArray elts;
    ByteString::split(
        _pszConnectionString, _pszConnectionString + _n,
        ';', elts
        );
 
    for(ByteStringArray::Iterator it = elts.begin(); it != elts.end(); it++) {
        ByteStringArray pair;
        (*it).split('=', pair);
        if (pair.size() > 0) {
            ByteStringArray::Iterator itPair = pair.begin();
            ByteString name = *itPair++;
            ByteString value;
            if (pair.size() > 1) {
                value = *itPair;
            }
            _map[name.trim().toUpperCase()] = value.trim();
        }
    }
    return _map.size();
}
 
__DCL_END_NAMESPACE