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	__nextResult ()
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
void *	__outBuffer
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 = 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 55 of file MyQuery.cpp.

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

Member Function Documentation

__destroy()

void MyQuery::__destroy ( )

virtual

Implements SQL::Query.

Definition at line 81 of file MyQuery.cpp.

{
    delete this;
}

__execute()

bool MyQuery::__execute ( )

virtual

Implements SQL::Query.

Definition at line 381 of file MyQuery.cpp.

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

__fetch()

bool MyQuery::__fetch ( )

virtual

Implements SQL::Query.

Definition at line 456 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 570 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 578 of file MyQuery.cpp.

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

__nextResult()

bool MyQuery::__nextResult ( )

virtual

Reimplemented from SQL::Query.

Definition at line 497 of file MyQuery.cpp.

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

__prepare()

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

virtual

Implements SQL::Query.

Definition at line 336 of file MyQuery.cpp.

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

initFields()

bool MyQuery::initFields ( )

protected

Definition at line 222 of file MyQuery.cpp.

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

initParams()

bool MyQuery::initParams ( size_t _paramCount )

protected

Definition at line 303 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(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;
}

reset()

bool MyQuery::reset ( )

protected

Definition at line 86 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 (__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;
}

Member Data Documentation

__fields

MyField* MyQuery::__fields

protected

Definition at line 28 of file MyQuery.h.

__inBINDs

MYSQL_BIND* MyQuery::__inBINDs

protected

Definition at line 23 of file MyQuery.h.

__outBINDs

MYSQL_BIND* MyQuery::__outBINDs

protected

Definition at line 24 of file MyQuery.h.

__outBuffer

void* MyQuery::__outBuffer

protected

Definition at line 25 of file MyQuery.h.

__params

MyParam* MyQuery::__params

protected

Definition at line 27 of file MyQuery.h.

__stmt

MYSQL_STMT* MyQuery::__stmt

protected

Definition at line 22 of file MyQuery.h.

---

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

• MyQuery.h
• MyQuery.cpp