SQLQuery.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
#if __DCL_WINDOWS
#include <windows.h>
#endif
// 2005.01.26
 
#include <wchar.h>      // wcschr
#include <wctype.h>     // iswspace
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Charset.h>
#include <dcl/SQL.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLQuery.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE

IMPLEMENT_CLASSINFO(SQLFields, Object)
 
SQLFields::SQLFields()
{
    __fields = NULL;
    __count = 0;
}
 
SQLFields::~SQLFields()
{
    clear();
}
 
void SQLFields::clear()
{
    if (__fields) {
        __DCL_ASSERT(__count > 0);
        delete[] __fields;
        __fields = NULL;
        __count = 0;
    }
    __fieldMap.clear();
}
 
void SQLFields::initialize(SQLQuery* _query)
 
{
    SQL::Query* hQuery = _query->handle();
 
    __DCL_ASSERT(hQuery->fieldCount() > 0);
    __DCL_ASSERT((__fields == NULL) && (__count == 0));
 
    clear();
 
    __count = hQuery->fieldCount();
    __fields = new SQLField[__count];
    __DCL_ASSERT(__fields != NULL);
 
    SQLField* _field = NULL;
    for(size_t i = 0; i < hQuery->fieldCount(); i++) {
        _field = &(__fields[i]);
        _field->__query = _query;
        if (!hQuery->getField(i, &(_field->__handle))) {
            throw new SQLException(_query);
        }
    }
}
 
// public
_CONST SQLField& SQLFields::byName(const char_t* _name) _CONST
                    __DCL_THROWS1(InvalidIndexException*)
{
    __DCL_ASSERT(_name != NULL);
    __DCL_ASSERT(!isEmpty());
 
    SQLField* _field = NULL;
 
    if (__count >= 7) {     // 순차검색 n*n/2 Hashing 3*n
        if (__fieldMap.isEmpty()) {
            __fieldMap.initBuckets(__count);
            for(size_t i = 0; i < __count; i++)
                __fieldMap[__fields[i].name()] = &__fields[i];
        }
        _field = (SQLField*)(__fieldMap[_name]);
    }
    else {
        for(size_t i = 0; i < __count; i++) {
//          if (__fields[i].fieldName() == strFieldName)
            if (String::compare(__fields[i].name(), _name) == 0) {
                _field = &__fields[i];
                break;
            }
        }
    }
 
    if (_field == NULL) {
        throw new InvalidIndexException(_name);
    }
 
    return *_field;
}

IMPLEMENT_CLASSINFO(SQLParams, Object)
 
SQLParams::SQLParams()
{
    __params = NULL;
    __count = 0;
}
 
SQLParams::~SQLParams()
{
    clear();
}
 
void SQLParams::clear()
{
    if (__params) {
        __DCL_ASSERT(__count > 0);
        delete[] __params;
        __params = NULL;
        __count = 0;
    }
    __paramMap.clear();
}
 
void SQLParams::initialize(SQLQuery* _query, const StringArray _names)
{
    SQL::Query* hQuery = _query->handle();
 
    __DCL_ASSERT((__params == NULL) && (__count == 0));
    __DCL_ASSERT(hQuery->paramCount() == _names.size());
    
    __count = hQuery->paramCount();
    __params = new SQLParam[__count];
    __DCL_ASSERT(__params != NULL);
 
    for(size_t i = 0; i < hQuery->paramCount(); i++) {
        SQLParam* _param = &__params[i];
        _param->__query = _query;
        if (!hQuery->getParam(i, (SQL::Param**)&(_param->__handle))) {
            throw new SQLException(_query);
        }
        ((SQL::Param*)(_param->__handle))->setName(_names[i]);
    }
}
 
// public
SQLParam& SQLParams::byName(const wchar_t* _name) _CONST
                    __DCL_THROWS1(InvalidIndexException*)
{
    __DCL_ASSERT(_name != NULL);
    __DCL_ASSERT(!isEmpty());
 
    SQLParam* r = NULL;
 
    if (__count >= 7) {     // 순차검색 n*n/2 Hashing 3*n
        if (__paramMap.isEmpty()) {
            __paramMap.initBuckets(__count);
            for (size_t i = 0; i < __count; i++) {
                SQLParam* p = &__params[i];
                __paramMap[p->name()] = p;
            }
        }
        r = (SQLParam*)(__paramMap[_name]);
    }
    else {
        for(size_t i = 0; i < __count; i++) {
            if (String::compare(__params[i].name(), _name) == 0) {
                r = &__params[i];
                break;
            }
        }
    }
 
    if (r == NULL) {
        throw new InvalidIndexException(_name);
    }
 
    return *r;
}
 
static void __sql_transform__(const String& _sql,
    wchar_t _placeholder, String& _newsql, StringArray& _names)
{
    StringBuilder newsql(_sql.length());
    const wchar_t* s = _sql.data();
    const wchar_t* e = s + _sql.length();
    const wchar_t* p = s;
    while (p < e) {
        // :: := 는 제외한다.
        // : ? 는 1개의 문자만 있어도 포함한다.
        if ((*p == L':' && !wcschr(L":=",  *(p + 1))) || *p == L'?') {
            newsql.append(s, p);
            if (_placeholder == L'?')
                newsql.append(L'?');
            else { // L':'
                // Oracle에서 position은 1부터
                newsql.format(L":%zd", _names.size() + 1);
            }
            p++;
            s = p;
            while (p < e) {
                // :; :name; :name::char
                if (wcschr(L",);:", *p) || iswspace(*p)) {
                    break;
                }
                p++;
            }
            // s == p 이름이 없는 경우도 있다.
            _names.add(String(s, p));
        //  __DCL_TRACE1(L"[%ls]\n", _names[_names.size() - 1].data());
            s = p;
        }
        else if (*p == L'\'') {
            p++;
            while (p < e) {
                if (*p++ == L'\'') {
                    break;
                }
            }
        }
        else {
            p++;
        }
    }
 
    if (s < p) {
        newsql.append(s, p);
    }
 
    _newsql = newsql.toString();
}

IMPLEMENT_CLASSINFO(SQLQuery, Object)
 
void SQLQuery::initialize(SQLConnection* _conn) __DCL_THROWS1(SQLException*)
{
    __handle = NULL;
    __connection = NULL;
 
    __DCL_ASSERT(_conn != NULL);
 
    SQL::Query* hQuery = NULL;
    if (!_conn->handle()->createQueryInstance(&hQuery)) {
        throw new SQLException(_conn);
    }
    __DCL_ASSERT(hQuery != NULL);
 
    __handle = hQuery;
    __connection = _conn;
}
 
SQLQuery::SQLQuery(SQLConnection* _conn) __DCL_THROWS1(SQLException*)
{
    initialize(_conn);
}
 
SQLQuery::SQLQuery(SQLConnection& _conn) __DCL_THROWS1(SQLException*)
{
    initialize(&_conn);
}
 
SQLQuery::~SQLQuery()
{
    __connection->handle()->destroyQueryInstance(__handle);
}
 
void SQLQuery::prepare(
        const String& _sql
        ) __DCL_THROWS2(SQLException*, CharsetConvertException*)
{
#ifdef __DCL_DEBUG
    __sql = _sql;
#endif
 
    __params.clear();
    __fields.clear();
 
    String sql;
    StringArray names;
    __sql_transform__(_sql, __handle->placeholder(), sql, names);
    //__DCL_TRACE2(L"[%zd][%ls]\n", names.size(), sql.data());
 
    ByteString bstr = UTF8Encoder::encode(sql);
    if (!__handle->prepare(bstr, bstr.length(), names.size())) {
#ifdef __DCL_DEBUG
        throw new SQLException(this, __sql);
#else
        throw new SQLException(this);
#endif
    }
 
    if (__handle->paramCount() > 0)
        __params.initialize(this, names);
}
 
void SQLQuery::execute() __DCL_THROWS1(SQLException*)
{
    if (!__handle->execute()) {
#ifdef __DCL_DEBUG
        throw new SQLException(this, __sql);
#else
        throw new SQLException(this);
#endif
    }
 
    if (__handle->fieldCount() > 0 && __fields.isEmpty())
        __fields.initialize(this);
}
 
void SQLQuery::execute(
        const String& _sql
        ) __DCL_THROWS2(SQLException*, CharsetConvertException*)
{
    prepare(_sql);
    execute();
}
 
void SQLQuery::fetch() __DCL_THROWS1(SQLException*)
{
    if (!__handle->fetch()) {
        throw new SQLException(this);
    }
}
 
bool SQLQuery::nextResult() __DCL_THROWS1(SQLException*)
{
    if (!__handle->nextResult()) {
        throw new SQLException(this);
    }
 
    __fields.clear();
    if (__handle->fieldCount() > 0)
        __fields.initialize(this);
 
    return  !__handle->eof();
}
 
__DCL_END_NAMESPACE