MyQuery.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // malloc, free
#include <string.h>     // memset
 
#include <mysql.h>
 
#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
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/MyQuery.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR_HANDLE(_error) \
    conn()->setErrorHandle(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    conn()->setErrorMessage(_msg, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(MyQuery, SQL::Query)
 
MyQuery::MyQuery(MyConnection* pConnection)
    : Query(pConnection)
{
    __stmt = NULL;
    __inBINDs = NULL;
    __outBINDs = NULL;
 
    __fields = NULL;
    __params = NULL;
}
 
MyQuery::~MyQuery()
{
#ifdef __DCL_DEBUG
    if (!reset()) {
        char buf[256];
        size_t buflen = sizeof(buf) - 1;
        bool b = conn()->__getErrorMessage(buf, &buflen);
        buf[b ? buflen : 0] = '\0';
        __DCL_TRACE1(L"Warning! Query reset error! %hs\n", buf);
    }
#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 (__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 long __TYPE_SIZE(const MYSQL_FIELD* _field)
{
    unsigned long 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((__stmt != NULL)
        && (__stmt->field_count > 0)
        && (Query::__fieldCount == 0)
        && (__fields == NULL)
        && (__outBINDs == NULL)
    );
 
    size_t alloc = sizeof(MYSQL_BIND) * __stmt->field_count;
    __DCL_TRACE1_N(L"outBINDs alloc [%zd]\n", alloc);
    __outBINDs = (MYSQL_BIND*)malloc(alloc);
    if (!__outBINDs) {
        __SET_ERROR_HANDLE(SQL::eOutOfMemory);
        return false;
    }
    memset(__outBINDs, 0, alloc);
 
    // __outBINDs에 적용할, 레코드 버퍼 크기를 계산한다.
    size_t offset = 0;
    for (unsigned int i = 0; i < __stmt->field_count; i++) {
        MYSQL_FIELD* field = __stmt->fields + i;
        offset = __TYPE_ALIGN(offset, field);
        // 1000문자(3 * 1000바이트)를 초과하면 __TYPE_SIZE은 0이다.
        __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) {
        __outBINDs = (MYSQL_BIND*)realloc(__outBINDs, alloc + offset);
        if (__outBINDs == NULL) {
            __SET_ERROR_HANDLE(SQL::eOutOfMemory);
            return false;
        }
    }
 
    char* outBuffer = (char*)(__outBINDs + __stmt->field_count);
    __DCL_TRACE2_N(L"__outBINDs[%p] outBuffer[%p]\n", __outBINDs, outBuffer);
    offset = 0;
    for (unsigned int i = 0; i < __stmt->field_count; 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 = 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;
    }
 
    Query::__fieldCount = __stmt->field_count;
    __fields = new MyField[Query::__fieldCount];
    if (!__fields) {
        __SET_ERROR_HANDLE(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_HANDLE(SQL::eOutOfMemory);
        return false;
    }
    memset(__inBINDs, 0, alloc);
 
    __params = new MyParam[Query::__paramCount];
    if (__params == NULL) {
        __SET_ERROR_HANDLE(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_HANDLE(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()
{
    // 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;
    }
 
    // 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;
    Query::__affectedRows = -1;
 
    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;
            }
        }
    }
    else {
        // UPDATE, INSERT, DELETE, etc, ...
        Query::__affectedRows = mysql_stmt_affected_rows(__stmt);
        __DCL_TRACE1_N(L"affectedRows[%lld]\n", Query::__affectedRows);
    }
 
    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::__moreResults(bool* _moreResults)
{
    if (__fields) {
        __DCL_ASSERT(Query::__fieldCount > 0);
        delete[] __fields;
        __fields = NULL;
        Query::__fieldCount = 0;
    }
 
    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);
    switch (r) {
        case -1: {
            // https://dev.mysql.com 메뉴얼에는 설명하고 있으나,
            // MariaDB에서는 이 값을 반환하지 않는다.
            // MariaDB는 ODBC의 경우처럼 INSERT, UPDATE, DELETE를 포함하는
            // 다중 SQL에 대하여 동작하지 않는것으로 추정된다.
            // 오직 SELECT를 동반한 프로시저이서만 동작하는것 같다.
            Query::__affectedRows = (size_t)-1;
            Query::__eof = true;
            *_moreResults = false;
            return true;
        }
        case 0: {
            *_moreResults = true;
            break;
        }
        default: {
            __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
 
    // UPDATE, INSERT, DELETE만 eof 이어야 한다.
    // 필드가 있는 경우, fetch에서 eof를 판별한다.
    Query::__eof = __stmt->field_count == 0;
    Query::__affectedRows = -1;
 
    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;
            }
        }
    }
    else {
        // UPDATE, INSERT, DELETE, etc, ...
        Query::__affectedRows = mysql_stmt_affected_rows(__stmt);
        __DCL_TRACE1_N(L"affectedRows[%lld]\n", Query::__affectedRows);
    }
 
    // __stmt->field_count == 0인 경우에도
    // mysql_stmt_affected_rows는 항상 0을 반환한다.
    // MariaDB는 ODBC의 경우처럼 INSERT, UPDATE, DELETE를 포함하는
    // 다중 SQL에 대하여 동작하지 않는것으로 추정된다.
    *_moreResults = !Query::__eof;
    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