MyQuery.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // malloc, free
#include <string.h>     // memset
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/SQLCore.h>
 
#include "MyConnection.h"
#include "MyQuery.h"
#include "MyField.h"
#include "MyParam.h"
 
#define __TRACE_THIS    0
#if __TRACE_THIS
#define __DCL_TRACE0_N  __DCL_TRACE0
#define __DCL_TRACE1_N  __DCL_TRACE1
#define __DCL_TRACE2_N  __DCL_TRACE2
#define __DCL_TRACE3_N  __DCL_TRACE3
#define __DCL_TRACE4_N  __DCL_TRACE4
#else
#define __DCL_TRACE0_N(fmt)
#define __DCL_TRACE1_N(fmt, arg)
#define __DCL_TRACE2_N(fmt, arg1, arg2)
#define __DCL_TRACE3_N(fmt, arg1, arg2, arg3)
#define __DCL_TRACE4_N(fmt, arg1, arg2, arg3, arg4)
#endif
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const wchar_t __THIS_FILE__[] = __T("dcl/sql/MyQuery.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(MyQuery, SQL::Query)
 
MyQuery::MyQuery(MyConnection* pConnection)
    : Query(pConnection)
{
    __stmt = NULL;
    __inBINDs = NULL;
    __outBINDs = NULL;
    __outBuffer = NULL;
 
    __fields = NULL;
    __params = NULL;
}
 
MyQuery::~MyQuery()
{
#ifdef __DCL_DEBUG
    if (!reset()) {
        ByteString s;
        size_t n = 512;
        ByteBuffer* buf = ByteBuffer::create(n);
        bool b = conn()->__getErrorMessage(buf->data(), &n);
        if (b) {
            buf->__dataLength = n;
            s = buf;
        }
        buf->release();
 
        if (b) {
            __DCL_TRACE1_N(__T("Warning! %s\n"), s.data());
        }
        else {
            __DCL_TRACE0_N(__T("Warning! Query reset error\n"));
        }
    }
#else
    (void)reset();
#endif
}
 
void MyQuery::__destroy()
{
    delete this;
}
 
bool MyQuery::reset()
{
    Query::__eof = true;
    Query::__affectedRows = -1;
 
    if (__fields) {
        __DCL_ASSERT(Query::__fieldCount > 0);
        delete[] __fields;
        __fields = NULL;
        Query::__fieldCount = 0;
    }
 
    if (__params) {
        __DCL_ASSERT(Query::__paramCount > 0);
        delete[] __params;
        __params = NULL;
        Query::__paramCount = 0;
    }
 
    if (__outBuffer) {
        free(__outBuffer);
        __outBuffer = NULL;
    }
 
    if (__outBINDs) {
        free(__outBINDs);
        __outBINDs = NULL;
    }
 
    if (__inBINDs) {
        free(__inBINDs);
        __inBINDs = NULL;
    }
 
    bool r = true;
    if (__stmt) {
        __DCL_TRACE2_N(L"state[%d] result.data[%p]\n",
            __stmt->state, __stmt->result.data);
        if (__stmt->state >= MYSQL_STMT_USE_OR_STORE_CALLED) {
            if (mysql_stmt_free_result(__stmt)) {
                __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                    mysql_stmt_errno(__stmt),
                    mysql_stmt_error(__stmt)));
                return false;
            }
        }
        if (mysql_stmt_close(__stmt)) {
            __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                mysql_errno(conn()->connHandle()),
                mysql_error(conn()->connHandle())));
            r = false;
        }
        __stmt = NULL;
    }
 
    return r;
}
 
static unsigned int __TYPE_SIZE(const MYSQL_FIELD& _field)
{
    unsigned int size = 0;
    switch (_field.type) {
    case MYSQL_TYPE_TINY :
        size = sizeof(int8_t);
        break;
    case MYSQL_TYPE_YEAR :
    case MYSQL_TYPE_SHORT :
        size = sizeof(int16_t);
        break;
    case MYSQL_TYPE_INT24 :
    case MYSQL_TYPE_LONG :
        size = sizeof(int32_t);
        break;
    case MYSQL_TYPE_LONGLONG :
        size = sizeof(int64_t);
        break;
    case MYSQL_TYPE_FLOAT :
        size = sizeof(float);
        break;
    case MYSQL_TYPE_DOUBLE :
        size = sizeof(double);
        break;
    case MYSQL_TYPE_DATE:
    case MYSQL_TYPE_TIME:
    case MYSQL_TYPE_DATETIME:
    case MYSQL_TYPE_TIMESTAMP:
        size = sizeof(MYSQL_TIME);
        break;
    case MYSQL_TYPE_BIT:
        size = sizeof(int64_t); // cf. _field.length == 64 64bits
        break;
    default:
        // 1000문자(3 * 1000바이트)까지 버퍼를 미리 할당한다.
        // 그 외에는 mysql_stmt_fetch_column()을 사용한다.
        // UTF-8, TEXT의 경우 _field.length는 3 * 2^16를 지시한다.
        size = _field.length <= 3000 ? _field.length : 0;
    }
    return size;
}
 
static size_t __TYPE_ALIGN(size_t _offset, const MYSQL_FIELD& _field)
{
    size_t size = 0;
    switch (_field.type) {
    case MYSQL_TYPE_TINY:
        size = sizeof(int8_t);
        break;
    case MYSQL_TYPE_YEAR:
    case MYSQL_TYPE_SHORT:
        size = sizeof(int16_t);
        break;
    case MYSQL_TYPE_INT24:
    case MYSQL_TYPE_LONG:
        size = sizeof(int32_t);
        break;
    case MYSQL_TYPE_LONGLONG:
        size = sizeof(int64_t);
        break;
    case MYSQL_TYPE_FLOAT:
        size = sizeof(float);
        break;
    case MYSQL_TYPE_DOUBLE:
        size = sizeof(double);
        break;
    case MYSQL_TYPE_DATE:
    case MYSQL_TYPE_TIME:
    case MYSQL_TYPE_DATETIME:
    case MYSQL_TYPE_TIMESTAMP:
        size = sizeof(long);
        break;
    default:
        size = sizeof(char);
    }
    return (_offset + size - 1) & ~(size - 1);
}
 
bool MyQuery::initFields()
{
    __DCL_ASSERT((Query::__fieldCount == 0)
        && (__fields == NULL)
        && (__outBINDs == NULL)
        && (__outBuffer == NULL)
        && (__stmt != NULL)
        && (__stmt->field_count > 0)
    );
 
    Query::__fieldCount = __stmt->field_count;
    size_t alloc = sizeof(MYSQL_BIND) * Query::__fieldCount;
    __outBINDs = (MYSQL_BIND*)malloc(alloc);
    if (!__outBINDs) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    memset(__outBINDs, 0, alloc);
 
    // __fields를 위한 버퍼를 할당한다.
    size_t offset = 0;
    for (size_t i = 0; i < Query::__fieldCount; i++) {
        MYSQL_FIELD& field = __stmt->fields[i];
        offset = __TYPE_ALIGN(offset, field);
        __DCL_TRACE3_N(L"offset [%4zd][%4zd] [%hs]\n",
            offset, __TYPE_SIZE(field), field.name);
        offset += __TYPE_SIZE(field);
    }
 
    __DCL_TRACE1_N(L"alloc [%zd]\n", offset);
    // 모든 필드의 __TYPE_SIZE(field) == 0인 경우가 있을 수 있다.
    // 모든 필드가 3000바이트 이상인 VARCHAR, VARBINARY, TEXT, BLOB이면
    // offset의 값이 0이다.
    if (offset > 0) {
        __outBuffer = malloc(offset);
        __DCL_ASSERT((size_t)__outBuffer % sizeof(void*) == 0);
        if (__outBuffer == NULL) {
            __SET_ERROR(SQL::eOutOfMemory);
            return false;
        }
    }
 
    offset = 0;
    for (size_t i = 0; i < Query::__fieldCount; i++) {
        MYSQL_FIELD& field = __stmt->fields[i];
        MYSQL_BIND& bind = __outBINDs[i];
 
        offset = __TYPE_ALIGN(offset, field);
        bind.buffer_length = __TYPE_SIZE(field);
        bind.buffer_type = field.type;
        bind.buffer = (char*)__outBuffer + offset;
        offset += bind.buffer_length;
 
        bind.length = &bind.length_value;
        bind.is_null = &bind.is_null_value;
        bind.error = &bind.error_value;
    }
 
    if (mysql_stmt_bind_result(__stmt, __outBINDs)) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_stmt_errno(__stmt),
            mysql_stmt_error(__stmt)));
        return false;
    }
 
    __fields = new MyField[Query::__fieldCount];
    if (!__fields) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    for(unsigned int i = 0; i < Query::__fieldCount; i++) {
        MYSQL_FIELD* field = __stmt->fields + i;
        MYSQL_BIND* bind = __outBINDs + i;
        if (!__fields[i].init(this, i, field, bind))
            return false;
    }       
 
    return true;
}
 
bool MyQuery::initParams(size_t _paramCount)
{
    __DCL_ASSERT((Query::__paramCount == 0)
        && (__params == NULL)
        && (__stmt != NULL)
        && (__stmt->param_count > 0));
    __DCL_ASSERT(__stmt->param_count == _paramCount);
 
    Query::__paramCount = __stmt->param_count;
    size_t alloc = sizeof(MYSQL_BIND) * Query::__paramCount;
    __inBINDs = (MYSQL_BIND*)malloc(alloc);
    if (!__inBINDs) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    memset(__inBINDs, 0, alloc);
 
    __params = new MyParam[Query::__paramCount];
    if (__params == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    for(unsigned int i = 0; i < Query::__paramCount; i++) {
        MYSQL_BIND* bind = &__inBINDs[i];
        bind->is_null = &bind->is_null_value;
        if (!__params[i].init(this, i, bind))
            return false;
    }
 
    return true;
}
 
bool MyQuery::__prepare(const char* _sql, size_t _sqllen,
        size_t _paramCount)
{
    if(!reset())
        return false;
 
    if ((__stmt = mysql_stmt_init(conn()->connHandle())) == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    int r = mysql_stmt_prepare(__stmt, _sql, (unsigned long)_sqllen);
    if (r) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_stmt_errno(__stmt),
            mysql_stmt_error(__stmt)));
        return false;
    }
 
#if __TRACE_THIS && 1
    __DCL_TRACE2_N(L"state[%d] result.data[%p]\n",
        __stmt->state, __stmt->result.data);
    __DCL_TRACE4_N(L"params[%u][%p] fields[%u][%p]\n",
        __stmt->param_count, __stmt->params,
        __stmt->field_count, __stmt->fields);
    for (unsigned int i = 0; i < __stmt->param_count; i++) {
        MYSQL_BIND* e = &(__stmt->params[i]);
        __DCL_TRACE4_N(L"param %02u buf[%p][%5u][%16ls]\n",
            i, e->buffer, e->buffer_length, __dataTypeName(e->buffer_type, e->flags));
    }
    for (unsigned int i = 0; i < __stmt->field_count; i++) {
        MYSQL_FIELD* e = &(__stmt->fields[i]);
        __DCL_TRACE4_N(L"field %02u [%14hs][%10u][%16ls]\n",
            i, e->name, e->length, __dataTypeName(e->type, e->flags));
    }
#endif
 
    if (_paramCount > 0) {
        if (!initParams(_paramCount))
            return false;
    }
 
    return true;
}
 
bool MyQuery::__execute()
{
    __DCL_ASSERT(__stmt->param_count == Query::__paramCount);
    // char*, byte_t*인 경우 데이터의 복사본을 유지하지 않는다.
    // execute 전 매번 bind 한다.
    if (Query::__paramCount) {
        __DCL_ASSERT(__inBINDs);
        if (mysql_stmt_bind_param(__stmt, __inBINDs)) {
            __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                mysql_stmt_errno(__stmt),
                mysql_stmt_error(__stmt)));
            return false;
        }
    }
 
    // 파라미터 값이 InputStream인 경우 mysql_stmt_send_long_data
    for (size_t i = 0; i < Query::__paramCount; i++) {
        if (!__params[i].onBeforeExecute()) {
            return false;
        }
    }
 
    if (mysql_stmt_execute(__stmt)) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_stmt_errno(__stmt),
            mysql_stmt_error(__stmt)));
        return false;
    }
 
    // UPDATE, INSERT, DELETE, etc, ...
    Query::__affectedRows = mysql_stmt_affected_rows(__stmt);
    __DCL_TRACE1_N(L"affectedRows[%lld]\n", Query::__affectedRows);
 
    // execute 후 파라미터 값을 nil로 설정한다.
    for (size_t i = 0; i < Query::__paramCount; i++) {
        __params[i].onAfterExecute();
    }
 
#if __TRACE_THIS && 1
    __DCL_TRACE2_N(L"state[%d] result.data[%p]\n",
        __stmt->state, __stmt->result.data);
    __DCL_TRACE2_N(L"fields[%u][%p]\n",
        __stmt->field_count, __stmt->fields);
    for (unsigned int i = 0; i < __stmt->field_count; i++) {
        MYSQL_FIELD* e = &(__stmt->fields[i]);
        __DCL_TRACE4_N(L"field %02u [%14hs][%10u][%16ls]\n",
            i, e->name, e->length, __dataTypeName(e->type, e->flags));
    }
    if (conn()->connHandle()->server_status & SERVER_PS_OUT_PARAMS) {
        __DCL_TRACE1_N(L"OUT/INOUT parameter [%u]\n", __stmt->field_count);
    }
#endif
    
    // UPDATE, INSERT, DELETE만 eof 이어야 한다.
    // 필드가 있는 경우, fetch에서 eof를 판별한다.
    Query::__eof = __stmt->field_count == 0;
 
    if (__stmt->field_count) {
        if (!initFields()) {
            return false;
        }
        if (conn()->storeResult()) {
            __DCL_TRACE0_N(L"mysql_stmt_store_result\n");
            if (mysql_stmt_store_result(__stmt)) {
                __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                    mysql_stmt_errno(__stmt),
                    mysql_stmt_error(__stmt)));
                return false;
            }
        }
    }
 
    return true;
}
 
bool MyQuery::__fetch()
{
    __DCL_ASSERT(!Query::__eof);
    int r = mysql_stmt_fetch(__stmt);
    switch (r) {
        case MYSQL_NO_DATA: {
            // Success, no more data exists.
            Query::__eof = true;
            return true;
        }
        case MYSQL_DATA_TRUNCATED: {
            // BLOB, MEDIUM_BLOB, LONG_BLOB은 mysql_stmt_fetch_column을 사용한다.
            // 이 셋의 MYSQL_FIELD.length의 값은 0이다.
            // Data truncation occurred.
            // Check the error members of the MYSQL_BIND
            __DCL_TRACE0_N(L"Warning!! MYSQL_DATA_TRUNCATED\n");
 
#if __TRACE_THIS && 1
            for (unsigned int i = 0; i < __stmt->field_count; i++) {
                MYSQL_BIND& b = __stmt->bind[i];
                __DCL_TRACE2(L"field[%u] [%u]\n", i, b.error ? *b.error : 0);
            }
#endif
        }
        case 0: {
            // Success, the dta has been fetched to application data buffers.
            return true;
        }
        case 1 :
            // Error occurred. Error code and message can be obtained by calling
            // mysql_stmt_errno() and mysql_stmt_error().
        default:
            ;
    }
    
    __SET_ERROR_MSG(ByteString::format("(%u) %hs",
        mysql_stmt_errno(__stmt),
        mysql_stmt_error(__stmt)));
    return false;
}
 
bool MyQuery::__nextResult()
{
    if (__fields) {
        __DCL_ASSERT(Query::__fieldCount > 0);
        delete[] __fields;
        __fields = NULL;
        Query::__fieldCount = 0;
    }
 
    if (__outBuffer) {
        free(__outBuffer);
        __outBuffer = NULL;
    }
 
    if (__outBINDs) {
        free(__outBINDs);
        __outBINDs = NULL;
    }
 
    __DCL_TRACE2_N(L"state[%d] result.data[%p]\n",
        __stmt->state, __stmt->result.data);
    if (__stmt->state >= MYSQL_STMT_USE_OR_STORE_CALLED) {
        if (mysql_stmt_free_result(__stmt)) {
            __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                mysql_stmt_errno(__stmt),
                mysql_stmt_error(__stmt)));
                return false;
        }
    }
 
    int r = mysql_stmt_next_result(__stmt);
    if (r > 0) {
        __SET_ERROR_MSG(ByteString::format("(%u) %hs",
            mysql_stmt_errno(__stmt),
            mysql_stmt_error(__stmt)));
        return false;
    }
#if __TRACE_THIS && 1
    __DCL_TRACE2_N(L"state[%d] result.data[%p]\n",
        __stmt->state, __stmt->result.data);
    __DCL_TRACE3_N(L"next_[%d] fields[%u][%p]\n",
        r, __stmt->field_count, __stmt->fields);
    for (unsigned int i = 0; i < __stmt->field_count; i++) {
        MYSQL_FIELD* e = &(__stmt->fields[i]);
        __DCL_TRACE4_N(L"field %02u [%14hs][%10u][%16ls]\n",
            i, e->name, e->length, __dataTypeName(e->type, e->flags));
    }
    if (conn()->connHandle()->server_status & SERVER_PS_OUT_PARAMS) {
        __DCL_TRACE1_N(L"OUT/INOUT parameter [%u]\n", __stmt->field_count);
    }
#endif
 
    // 필드가 있는 경우, fetch에서 eof를 판별한다.
    Query::__eof = __stmt->field_count == 0;
 
    if (__stmt->field_count) {
        if (!initFields()) {
            return false;
        }
        if (conn()->storeResult()) {
            __DCL_TRACE0_N(L"mysql_stmt_store_result\n");
            if (mysql_stmt_store_result(__stmt)) {
                __SET_ERROR_MSG(ByteString::format("(%u) %hs",
                    mysql_stmt_errno(__stmt),
                    mysql_stmt_error(__stmt)));
                return false;
            }
        }
    }
 
    return true;
}
 
bool MyQuery::__getField(size_t _index, SQL::Field** _fieldHandleOut)
{
    __DCL_ASSERT(Query::__fieldCount > 0);
    __DCL_ASSERT((0 <= _index) && (_index < Query::__fieldCount));
    *_fieldHandleOut = &__fields[_index];
    return true;
}
 
bool MyQuery::__getParam(size_t _index, SQL::Param** _paramHandleOut)
{
    __DCL_ASSERT(Query::__paramCount > 0);
    __DCL_ASSERT((0 <= _index) && (_index < Query::__paramCount));
    *_paramHandleOut = &__params[_index];
    return true;
}
 
__DCL_END_NAMESPACE