MyQuery Class Reference

#include <MyQuery.h>

Inheritance diagram for MyQuery:

Public Member Functions
	MyQuery (MyConnection *pConnection)
virtual	~MyQuery ()
virtual void	__destroy ()
virtual bool	__prepare (const char *_sql, size_t _sqllen, size_t _paramCount)
virtual bool	__execute ()
virtual bool	__fetch ()
virtual bool	__moreResults (bool *_moreResults)
virtual bool	__getField (size_t _index, SQL::Field **_fieldHandleOut)
virtual bool	__getParam (size_t _index, SQL::Param **_paramHandleOut)
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Protected Member Functions
bool	reset ()
bool	initFields ()
bool	initParams (size_t _paramCount)
Protected Member Functions inherited from SQL::Query
	Query (Connection *_connHandle)
virtual	~Query ()
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Protected Attributes
MYSQL_STMT *	__stmt
MYSQL_BIND *	__inBINDs
MYSQL_BIND *	__outBINDs
MyParam *	__params
MyField *	__fields
Protected Attributes inherited from SQL::Query
Connection *	__connHandle
bool	__eof
int64_t	__affectedRows
size_t	__fieldCount
size_t	__paramCount
wchar_t	__placeholder
unsigned int	__states

Additional Inherited Members
Public Types inherited from SQL::Query
enum	State { stStandBy = (unsigned int) 0x0001 , stPrepared = 0x0002 , stExecuted = 0x0004 , stFetched = 0x0008 }

Detailed Description

Definition at line 9 of file MyQuery.h.

Constructor & Destructor Documentation

MyQuery()

MyQuery::MyQuery

(

MyConnection *

pConnection

)

~MyQuery()

MyQuery::~MyQuery ( )

virtual

Definition at line 59 of file MyQuery.cpp.

{
#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
}

Member Function Documentation

__destroy()

void MyQuery::__destroy ( )

virtual

Implements SQL::Query.

Definition at line 74 of file MyQuery.cpp.

{
    delete this;
}

__execute()

bool MyQuery::__execute ( )

virtual

Implements SQL::Query.

Definition at line 375 of file MyQuery.cpp.

{
    // 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;
}

__fetch()

bool MyQuery::__fetch ( )

virtual

Implements SQL::Query.

Definition at line 454 of file MyQuery.cpp.

{
    __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;
}

__getField()

bool MyQuery::__getField ( size_t _index, SQL::Field ** _fieldHandleOut )

virtual

Implements SQL::Query.

Definition at line 597 of file MyQuery.cpp.

{
    __DCL_ASSERT(Query::__fieldCount > 0);
    __DCL_ASSERT((0 <= _index) && (_index < Query::__fieldCount));
    *_fieldHandleOut = &__fields[_index];
    return true;
}

__getParam()

bool MyQuery::__getParam ( size_t _index, SQL::Param ** _paramHandleOut )

virtual

Implements SQL::Query.

Definition at line 605 of file MyQuery.cpp.

{
    __DCL_ASSERT(Query::__paramCount > 0);
    __DCL_ASSERT((0 <= _index) && (_index < Query::__paramCount));
    *_paramHandleOut = &__params[_index];
    return true;
}

__moreResults()

bool MyQuery::__moreResults ( bool * _moreResults )

virtual

Reimplemented from SQL::Query.

Definition at line 496 of file MyQuery.cpp.

{
    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;
}

__prepare()

bool MyQuery::__prepare ( const char * _sql, size_t _sqllen, size_t _paramCount )

virtual

Implements SQL::Query.

Definition at line 329 of file MyQuery.cpp.

{
    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;
}

initFields()

bool MyQuery::initFields ( )

protected

Definition at line 212 of file MyQuery.cpp.

{
    __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;
}

initParams()

bool MyQuery::initParams ( size_t _paramCount )

protected

Definition at line 296 of file MyQuery.cpp.

{
    __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;
}

reset()

bool MyQuery::reset ( )

protected

Definition at line 79 of file MyQuery.cpp.

{
    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;
}

Member Data Documentation

__fields

MyField* MyQuery::__fields

protected

Definition at line 22 of file MyQuery.h.

__inBINDs

MYSQL_BIND* MyQuery::__inBINDs

protected

Definition at line 18 of file MyQuery.h.

__outBINDs

MYSQL_BIND* MyQuery::__outBINDs

protected

Definition at line 19 of file MyQuery.h.

__params

MyParam* MyQuery::__params

protected

Definition at line 21 of file MyQuery.h.

__stmt

MYSQL_STMT* MyQuery::__stmt

protected

Definition at line 17 of file MyQuery.h.

---

The documentation for this class was generated from the following files:

• MyQuery.h
• MyQuery.cpp