SQLCore.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#include <windows.h>        // 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>
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLCore.cpp");
 
__DCL_BEGIN_NAMESPACE
 
typedef struct __SQL_ERROR
{
    SQL::Error error;
    const wchar_t* message;
} SQL_ERROR;
 
#ifdef __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, SQL::Param Errors
    __SQLERROR_MSG(eValueIsNull,      "값이 null 입니다."),
    __SQLERROR_MSG(eNotSupportDataType,    "서버 혹은 드라이버에서 지원하지 않는 데이터 형식입니다."),
    __SQLERROR_MSG(eInvalidDataType,  "필드값을 얻거나 파라미터 값을 설정하기 위한 데이터 형식이 잘못되었습니다."),
    __SQLERROR_MSG(eInvalidBufferSize,  "필드 혹은 아웃바인드의 값을 읽고자 하는 버퍼의 크기가 잘못되었습니다."),
    __SQLERROR_MSG(eOutOfRange,            "Numeric 데이터의 범위를 벗어났습니다."),
    __SQLERROR_MSG(eBytesTruncated,        "문자열 또는 바이트 데이터가 크거나, 버퍼의 크기가 작아서 잘립니다."),
    __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(typeTimeTz);
        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) \
    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::getNull(
    size_t* _size   // *_size == (size_t)-1 null
)
{
    unsigned int state = dynamic_cast<SQL::Param*>(this) ?
        SQL::Query::stExecuted : SQL::Query::stFetched;
    if (!__queryHandle->inState(state)) {
        *_size = (size_t)-1;
        return true;
    }
    return __getDataSize(_size, false);
}
 
bool SQL::Field::getDataSize(
    size_t* _size,      // count of bytes
    bool    _maxsize
)
{
    __DCL_ASSERT(__dataType != typeUnknown);
 
    __CHECK_ADDRESS(_size)
 
    if (_maxsize) {
        if (!__queryHandle->inState(SQL::Query::stExecuted)) {
            __SET_ERROR(eNotExecuted);
            return false;
        }
        return __getDataSize(_size, true);
    }
 
    unsigned int state = dynamic_cast<SQL::Param*>(this) ?
        SQL::Query::stExecuted : SQL::Query::stFetched;
    if (!__queryHandle->inState(state)) {
        __SET_ERROR(eNotFetched);
        return false;
    }
 
    bool r = __getDataSize(_size, false);
    if (r && *_size == (size_t)-1) {
        __SET_ERROR(eValueIsNull);
        return false;
    }
 
    return r;
}
 
static bool __checkDataType__(
    SQL::DataType _bufType,        // typeof *_buf
    SQL::DataType _sqlType     // field or param assign type
)
{
    switch (_bufType) {
        case SQL::typeInteger:      // int32_t*, int64_t*
        case SQL::typeUInteger:        // uint32_t*, uint64_t* 
        case SQL::typeFloat:      // float*, double*
            if (_sqlType == _bufType
                || _sqlType == SQL::typeNumeric)
                return true;
            break;
        case SQL::typeDate:            // SQL::Date*
            if (_sqlType == _bufType)
                return true;
            break;
        case SQL::typeTime:            // SQL::Time*
            if (_sqlType == SQL::typeTime
                || _sqlType == SQL::typeTimeTz)
                return true;
            break;
        case SQL::typeTimeStamp:  // SQL::TimeStamp*
            if (_sqlType == SQL::typeTimeStamp
                || _sqlType == SQL::typeTimeStampTz)
                return true;
            break;
        case SQL::typeInterval:        // SQL::Interval*
            if (_sqlType == SQL::typeInterval
                || _sqlType == SQL::typeIntervalYm
                || _sqlType == SQL::typeIntervalDs)
                return true;
            break;
        case SQL::typeText:
            if (_sqlType == SQL::typeNumeric
                || _sqlType == SQL::typeText
                || _sqlType == SQL::typeLongText
                || _sqlType == SQL::typeClob)
                return true;
            break;
        case SQL::typeBinary:
            if (_sqlType == SQL::typeBinary
                || _sqlType == SQL::typeLongBinary
                || _sqlType == SQL::typeBlob)
                return true;
            break;
        case SQL::typeInputStream:
            if (_sqlType == SQL::typeText
                || _sqlType == SQL::typeBinary
                || _sqlType == SQL::typeLongText
                || _sqlType == SQL::typeLongBinary
                || _sqlType == SQL::typeClob
                || _sqlType == SQL::typeBlob)
                return true;
            break;
        case SQL::typeOutputStream:
            if (_sqlType == SQL::typeText
                || _sqlType == SQL::typeBinary
                || _sqlType == SQL::typeLongText
                || _sqlType == SQL::typeLongBinary
                || _sqlType == SQL::typeClob
                || _sqlType == SQL::typeBlob)
                return true;
            break;
        default:
        // case SQL::typeUnknown:
        // case SQL::typeNumeric:
        // case SQL::typeLongText:
        // case SQL::typeLongBinary:
        // case SQL::typeClob:
        // case SQL::typeBlob:
            __DCL_ASSERT(false);
    }
    return false;
}
 
bool SQL::Field::getData(
    void*   _buf,           // buffer, OUT
    size_t* _size,          // sizeof *_buf, IN, OUT
    DataType _bufType       // typeof *_buf
)
{
    __DCL_ASSERT(__dataType != typeUnknown);
 
    __DCL_ASSERT(_bufType != typeUnknown);
    __DCL_ASSERT(_bufType != typeNumeric);
    __DCL_ASSERT(_bufType != typeTimeTz);
    __DCL_ASSERT(_bufType != typeTimeStampTz);
    __DCL_ASSERT(_bufType != typeIntervalYm);
    __DCL_ASSERT(_bufType != typeIntervalDs);
    __DCL_ASSERT(_bufType != typeLongText);
    __DCL_ASSERT(_bufType != typeLongBinary);
    __DCL_ASSERT(_bufType != typeClob);
    __DCL_ASSERT(_bufType != typeBlob);
    __DCL_ASSERT(_bufType != typeInputStream);
 
    if ((_bufType == typeInputStream) ||
        !__checkDataType__(_bufType, __dataType)) {
        __SET_ERROR(eInvalidDataType);
        return false;
    }
 
    __CHECK_ADDRESS(_buf)
    __CHECK_ADDRESS(_size)
 
    unsigned int state = dynamic_cast<SQL::Param*>(this) ?
        SQL::Query::stExecuted : SQL::Query::stFetched;
    if (!__queryHandle->inState(state)) {
        __SET_ERROR(eNotFetched);
        return false;
    }
#if 0
    size_t size = (size_t)-1;
    if (!__getDataSize(&size, false)) {
        return false;
    }
 
    if (size == (size_t)-1) {
        __SET_ERROR(eValueIsNull);
        return false;
    }
#endif
    return __getData(_buf, _size, _bufType);
}
 
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* _val,        // data, IN
    size_t      _size,      // sizeof *_buf
    DataType    _valType,   // typeof *_buf
    DataType    _sqlType    // assign to server type
)
{
    __DCL_ASSERT(_valType != typeUnknown);
    __DCL_ASSERT(_valType != typeNumeric);
    __DCL_ASSERT(_valType != typeTimeTz);
    __DCL_ASSERT(_valType != typeTimeStampTz);
    __DCL_ASSERT(_valType != typeIntervalYm);
    __DCL_ASSERT(_valType != typeIntervalDs);
    __DCL_ASSERT(_valType != typeLongText);
    __DCL_ASSERT(_valType != typeLongBinary);
    __DCL_ASSERT(_valType != typeClob);
    __DCL_ASSERT(_valType != typeBlob);
    __DCL_ASSERT(_valType != typeOutputStream);
 
    if ((_valType == typeOutputStream) ||
        !__checkDataType__(_valType, _sqlType)) {
        __SET_ERROR(eInvalidDataType);
        return false;
    }
 
    __CHECK_ADDRESS(_val)
 
#ifdef __DCL_DEBUG
    switch (_valType) {
        case typeDate: {
            const Date* p = (const Date*)_val;
            __DCL_ASSERT(
                (-9999 <= p->year && p->year <= 9999)
                && (1 <= p->month && p->month <= 12)
                && (1 <= p->day && p->day <= 31)
            );
            break;
        }
        case typeTime: {            
            const Time* p = (const Time*)_val;
            __DCL_ASSERT(
                (p->hour <= 23)
                && (p->min <= 59)
                && (p->sec <= 59)
                && (p->frac <= 999999999)
            );
            __DCL_ASSERT(
                (p->tzoff == INT16_MIN)
                || (-720 <= p->tzoff && p->tzoff < 840)
            );
            break;
        }
        case typeTimeStamp: {
            const TimeStamp* p = (const TimeStamp*)_val;
            __DCL_ASSERT(
                (-9999 <= p->year && p->year <= 9999)
                && (1 <= p->month && p->month <= 12)
                && (1 <= p->day && p->day <= 31)
                && (p->hour <= 23)
                && (p->min <= 59)
                && (p->sec <= 59)
                && (p->frac <= 999999999)
            );
            __DCL_ASSERT(
                (p->tzoff == INT16_MIN)
                || (-720 <= p->tzoff && p->tzoff < 840)
            );
            break;
        }
        case typeInterval: {
            const Interval* p = (const Interval*)_val;
            __DCL_ASSERT(
                (-999999999 <= p->years && p->years <= 999999999)
                && (-11 <= p->months && p->months <= 11)
                && (-999999999 <= p->days && p->days <= 999999999)
                && (p->hours <= 23)
                && (p->mins <= 59)
                && (p->secs <= 59)
                && (p->fracs <= 999999999)
            );
            break;
        }
        default: {
            ;
        }
    }
#endif
 
    if (!__queryHandle->inState(SQL::Query::stPrepared)) {
        __SET_ERROR(eNotPrepared);
        return false;
    }
 
    return __setData(_val, _size, _valType, _sqlType);
}
 
bool SQL::Param::setOutputType(
    DataType    _sqlType
)
{
#ifdef __DCL_DEBUG
    __DCL_ASSERT(_sqlType != typeUnknown);
    __DCL_ASSERT(_sqlType != typeInputStream);
    __DCL_ASSERT(_sqlType != typeOutputStream);
#else
    if (_sqlType == typeUnknown
            || _sqlType == typeInputStream
            || _sqlType == typeOutputStream) {
        __SET_ERROR(eInvalidDataType);
        return false;
    }
#endif
 
    if (!__queryHandle->inState(SQL::Query::stPrepared)) {
        __SET_ERROR(eNotPrepared);
        return false;
    }
 
    return __setOutputType(_sqlType);
}
 
// __setOutputType, __getDataSize, __getData는
// 드라이버에서 구현하지 않을 수도 있다.
bool SQL::Param::__setOutputType(
    DataType    _sqlType
)
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Param::__getDataSize(
    size_t*     _size,
    bool        _maxsize
)
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Param::__getData(
    void*       _buf,
    size_t*     _size,          // IN, OUT
    DataType    _bufType
)
{
    __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::__moreResults(bool* _moreResults)
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Query::moreResults(bool* _moreResults)
{
    if (!inState(stExecuted)) {
        __SET_ERROR(eNotExecuted);
        return false;
    }
    return __moreResults(_moreResults);
}
 
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::splitConnStr(
    const char* _connstr,
    size_t _strlen,
    ListedByteStringToByteStringMap& _results
)
{
    __DCL_ASSERT(_connstr != NULL);
    ByteStringArray elts;
    ByteString::split(
        _connstr, _connstr + _strlen,
        ';', 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;
            }
            _results[name.trim().toUpperCase()] = value.trim();
        }
    }
    return _results.size();
}
 
__DCL_END_NAMESPACE