ODBCQuery Class Reference

#include <ODBCQuery.h>

Inheritance diagram for ODBCQuery:

Public Member Functions
	ODBCQuery (ODBCConnection *_connection)
virtual	~ODBCQuery ()
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 (SQLSMALLINT _columnCount)
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
SQLHSTMT	__hstmt
BIND *	__paramBINDs
BIND *	__fieldBINDs
ODBCParam *	__params
ODBCField *	__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 44 of file ODBCQuery.h.

Constructor & Destructor Documentation

ODBCQuery()

ODBCQuery::ODBCQuery

(

ODBCConnection *

_connection

)

~ODBCQuery()

ODBCQuery::~ODBCQuery ( )

virtual

Definition at line 78 of file ODBCQuery.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 ODBCQuery::__destroy ( )

virtual

Implements SQL::Query.

Definition at line 93 of file ODBCQuery.cpp.

{
    delete this;
}

__execute()

bool ODBCQuery::__execute ( )

virtual

Implements SQL::Query.

Definition at line 447 of file ODBCQuery.cpp.

{
    // execute 전 매번 bind 한다.
    for (size_t i = 0; i < Query::__paramCount; i++) {
        if (!__params[i].onBeforeExecute())
            return false;
    }
 
    SQLRETURN rc = SQLExecute(__hstmt);
    switch (rc) {
        case SQL_NO_DATA: {
            // update, insert, or delete statement that does not affect any rows
            Query::__affectedRows = 0;
            return true;
        }
        case SQL_NEED_DATA: {
            __DCL_TRACE0_N(L"SQL_NEED_DATA\n");
            SQLPOINTER ptr;
            while ((rc = SQLParamData(__hstmt, &ptr)) == SQL_NEED_DATA) {
                if (!(((ODBCParam*)ptr)->onNeedData())) {
                    return false;
                }
            }
            __DCL_ASSERT(rc == SQL_SUCCESS);
            break;
        }
        case SQL_SUCCESS: {
            break;
        }
#if 0
        // SQLState 22001는 SQL_ERROR 이다.
        case SQL_SUCCESS_WITH_INFO: {
            // 22001    String data, right truncation
            bool ignore = true;
            SQLSMALLINT RecNumber = 0;
            SQLINTEGER  NativeError;
            SQLCHAR     SQLState[SQL_SQLSTATE_SIZE + 1];
            SQLCHAR     ErrorMsg[1024];
            SQLSMALLINT ErrorMsgLen;
            while ((rc = SQLGetDiagRecA(
                SQL_HANDLE_STMT, __hstmt, ++RecNumber, SQLState, &NativeError,
                ErrorMsg, __countof(ErrorMsg, SQLCHAR), &ErrorMsgLen
            )) == SQL_SUCCESS) {
                __DCL_TRACE4_N(L"Param [%2d] [%5hs] [%2d %hs]\n",
                    RecNumber, SQLState, ErrorMsgLen, ErrorMsg);
                if (memcmp(SQLState, "22001", 5)) {
                    ignore = false;
                    break;
                }
            }
            __DCL_TRACE2_N(L"%d %d\n", rc, RecNumber);
            __DCL_ASSERT(rc == SQL_NO_DATA);
            if (ignore) {
                break;
            }
        }
#endif
        default: {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
    }
 
    // execute 후 파라미터 값을 nil로 설정한다.
    for (size_t i = 0; i < Query::__paramCount; i++) {
        if (!__params[i].onAfterExecute()) {
            return false;
        }
    }
 
    SQLSMALLINT columnCount = 0;
    rc = SQLNumResultCols(__hstmt, &columnCount);
    if (!SQL_SUCCEEDED(rc)) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
        return false;
    }
    __SET_INFO_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
 
    // UPDATE, INSERT, DELETE만 eof 이어야 한다.
    // 필드가 있는 경우, fetch에서 eof를 판별한다.
    Query::__eof = columnCount == 0;
    Query::__affectedRows = -1;
 
    if (columnCount) {
        // SELECT
        if (!initFields(columnCount)) {
            return false;
        }
    }
    else {
        // MariaDB SELECT에서 rowCount의 값이 있다.
        // UPDATE, INSERT, DELETE, etc, ...
        SQLLEN rowCount;
        rc = SQLRowCount(__hstmt, &rowCount);
        if (!SQL_SUCCEEDED(rc)) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
        __SET_INFO_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
        Query::__affectedRows = rowCount;
    }
    __DCL_TRACE1_N(L"affectedRows[%zd]\n", Query::__affectedRows);
 
    return true;
}

__fetch()

bool ODBCQuery::__fetch ( )

virtual

Implements SQL::Query.

Definition at line 553 of file ODBCQuery.cpp.

{
    __DCL_ASSERT(!Query::__eof);
    SQLRETURN rc = SQLFetch(__hstmt);
 
    // SQLFetch의 결과를 확인하기 앞서,
    // bind.size == 0 또는 > 12000 인 경우에 대하여
    // SQLGetData 호출 상태를 리셋한다.
    for (size_t i = 0; i < Query::__fieldCount; i++) {
        BIND& bind = __fieldBINDs[i];
        if (bind.valuePtr == NULL) {
            bind.valueMax = 0;
        }
    }
 
    switch (rc) {
        case SQL_NO_DATA: {
            Query::__eof = true;
            return true;
        }
        case SQL_SUCCESS_WITH_INFO: {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            /*
            * SQLSTATE
            * 01000     일반 경고
            * 01004     문자열 데이터, 오른쪽 잘림
            * 01S07     분수 잘림
            */
        }
        case SQL_SUCCESS: {
            return true;
        }
        default: {
            ;
        }
    }
 
    __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
    return false;
}

__getField()

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

virtual

Implements SQL::Query.

Definition at line 662 of file ODBCQuery.cpp.

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

__getParam()

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

virtual

Implements SQL::Query.

Definition at line 670 of file ODBCQuery.cpp.

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

__moreResults()

bool ODBCQuery::__moreResults ( bool * _moreResults )

virtual

Reimplemented from SQL::Query.

Definition at line 594 of file ODBCQuery.cpp.

{
    if (__fields) {
        __DCL_ASSERT(Query::__fieldCount > 0);
        delete[] __fields;
        __fields = NULL;
        Query::__fieldCount = 0;
    }
 
    if (__fieldBINDs) {
        free(__fieldBINDs);
        __fieldBINDs = NULL;
    }
 
    SQLRETURN rc = SQLMoreResults(__hstmt);
    switch (rc) {
        case SQL_NO_DATA: {
            Query::__affectedRows = (size_t)-1;
            Query::__eof = true;
            *_moreResults = false;
            return true;
        }
        case SQL_SUCCESS: {
            *_moreResults = true;
            break;
        }
        default: {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
    }
 
    SQLSMALLINT columnCount = 0;
    rc = SQLNumResultCols(__hstmt, &columnCount);
    if (!SQL_SUCCEEDED(rc)) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
        return false;
    }
    __SET_INFO_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
 
    // UPDATE, INSERT, DELETE만 eof 이어야 한다.
    // 필드가 있는 경우, fetch에서 eof를 판별한다.
    Query::__eof = columnCount == 0;
    Query::__affectedRows = -1;
 
    if (columnCount) {
        // SELECT
        if (!initFields(columnCount)) {
            return false;
        }
    }
    else {
        // MariaDB SELECT에서 rowCount의 값이 있다.
        // UPDATE, INSERT, DELETE, etc, ...
        SQLLEN rowCount;
        rc = SQLRowCount(__hstmt, &rowCount);
        if (!SQL_SUCCEEDED(rc)) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
        __SET_INFO_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
        Query::__affectedRows = rowCount;
    }
    __DCL_TRACE1_N(L"affectedRows[%zd]\n", Query::__affectedRows);
 
    return true;
}

__prepare()

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

virtual

Implements SQL::Query.

Definition at line 414 of file ODBCQuery.cpp.

{
    if (!reset()) {
        return false;
    }
 
    __DCL_ASSERT(__hstmt == NULL);
    __DCL_ASSERT(_sqllen <= INT32_MAX);
 
    SQLRETURN rc = SQLAllocHandle(SQL_HANDLE_STMT, conn()->connHandle(), &__hstmt);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_DBC, conn()->connHandle());
        return false;
    }
 
    rc = SQLPrepareA(__hstmt, (SQLCHAR*) _sql, (SQLINTEGER) _sqllen);
    if (!SQL_SUCCEEDED(rc)) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
        return false;
    }
    __SET_INFO_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
 
    if (_paramCount > 0) {
        if (!initParams(_paramCount))
            return false;
    }
 
    return true;
}

initFields()

bool ODBCQuery::initFields ( SQLSMALLINT _columnCount )

protected

Definition at line 288 of file ODBCQuery.cpp.

{
    __DCL_ASSERT((__hstmt != NULL)
        && (_columnCount > 0)
        && (Query::__fieldCount == 0)
        && (__fields == NULL)
        && (__fieldBINDs == NULL)
    );
 
    StringArray names;
    size_t alloc = sizeof(BIND) * _columnCount;
    __DCL_TRACE1_N(L"fieldBINDs alloc [%zd]\n", alloc);
    __fieldBINDs = (BIND*)malloc(alloc);
    if (!__fieldBINDs) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    memset(__fieldBINDs, 0, alloc);
 
    BIND* bind = __fieldBINDs;
    for (SQLSMALLINT i = 0; i < _columnCount; i++, bind++) {
        bind->number = i + 1;
        SQLCHAR _name[256];
        SQLCHAR* name = _name;
        SQLSMALLINT length = sizeof(_name);
        SQLRETURN rc = SQLDescribeColA(__hstmt, bind->number,
            name, length, &length,
            &(bind->type), &(bind->size), &(bind->scale), &(bind->nullable));
        if (rc == SQL_SUCCESS_WITH_INFO) {
            name = (SQLCHAR*)alloca(++length);
            rc = SQLDescribeColA(__hstmt, bind->number, name, length, &length,
                &(bind->type), &(bind->size), &(bind->scale), &(bind->nullable));
        }
        if (rc != SQL_SUCCESS) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
        SQLLEN numAttr = 0;
        rc = SQLColAttributeA(__hstmt, bind->number,
            SQL_DESC_PRECISION, NULL, 0, NULL, &numAttr);
        if (rc != SQL_SUCCESS) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
        bind->precision = (SQLSMALLINT)numAttr;
 
        __DCL_TRACE6_N(L"Field [%2d]   size [%10d %4d,%4d] type [%4d %hs]\n",
            bind->number,
            bind->size, bind->precision, bind->scale,
            bind->type, name
        );
 
        try {
            names.add(UTF8Decoder::decode((const char*)name, length).toUpperCase());
        }
        catch (CharsetConvertException* _e) {
            __SET_ERROR_MSG(UTF8Encoder::encode(_e->toStringAll()));
            _e->destroy();
            return false;
        }
 
        bind->valueType = ODBCData::__VALUE_TYPE(bind->type);
    }
 
    // __fieldBINDs에 적용할, 레코드 버퍼 크기를 계산한다.
    size_t offset = 0;
    bind = __fieldBINDs;
    for (SQLSMALLINT i = 0; i < _columnCount; i++, bind++) {
        offset = ODBCData::__TYPE_ALIGN(offset, bind->type);
        // 다음에서 bind.size == 0 또는 > 12000 인 경우에 valueMax는 0이다.
        // 이것은 SQLFetch가 아닌 SQLGetData를 사용하여 필드값을 얻는다.
        bind->valueMax = ODBCData::__TYPE_SIZE(bind->type, bind->size);
        __DCL_TRACE5_N(L"Field [%2d] offset [%10zd %5d    ] type [%4d %ls]\n",
            bind->number, offset, bind->valueMax, bind->type, names[i].data());
        offset += bind->valueMax;
    }
 
    __DCL_TRACE1_N(L"fieldsBuffer size [%zd]\n", offset);
    // 모든 필드의 __TYPE_SIZE(field) == 0 인 경우가 있을 수 있다.
    // 모든 필드가 12000 바이트를 초과하는 VARCHAR, VARBINARY, TEXT, BLOB이면
    // offset의 값이 0이다.
    if (offset > 0) {
        __fieldBINDs = (BIND*)realloc(__fieldBINDs, alloc + offset);
        if (__fieldBINDs == NULL) {
            __SET_ERROR(SQL::eOutOfMemory);
            return false;
        }
    }
 
    char* buffer = (char*)(__fieldBINDs + _columnCount);
    __DCL_TRACE2_N(L"__fieldBINDs[%p] buffer[%p]\n", __fieldBINDs, buffer);
    offset = 0;
    bind = __fieldBINDs;
    for (SQLSMALLINT i = 0; i < _columnCount; i++, bind++) {
        offset = ODBCData::__TYPE_ALIGN(offset, bind->type);
        if (bind->valueMax) {
            // SQLBindCol 바인드 대상만 버퍼를 할당한다.
            // valueMax가 0인 경우는 SQLGetData로 데이터의 실제 크기를 알아낸다.
            bind->valuePtr = buffer + offset;
            offset += bind->valueMax;
 
            SQLRETURN rc = SQLBindCol(__hstmt, bind->number, bind->valueType,
                bind->valuePtr, bind->valueMax, &bind->lenORind);
            if (rc != SQL_SUCCESS) {
                __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
                return false;
            }
        }
    }
 
    Query::__fieldCount = _columnCount;
    __fields = new ODBCField[Query::__fieldCount];
    if (!__fields) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    bind = __fieldBINDs;
    for (size_t i = 0; i < Query::__fieldCount; i++, bind++) {
        if (!__fields[i].init(this, bind, names[i]))
            return false;
    }
 
    return true;
}

initParams()

bool ODBCQuery::initParams ( size_t _paramCount )

protected

Definition at line 143 of file ODBCQuery.cpp.

{
    __DCL_ASSERT((__hstmt != NULL)
        && (_paramCount > 0)
        && (Query::__paramCount == 0)
        && (__params == NULL)
        && (__paramBINDs == NULL)
    );
 
    SQLSMALLINT paramCount = 0;
    SQLRETURN rc = SQLNumParams(__hstmt, &paramCount);
    __DCL_ASSERT((size_t)paramCount == _paramCount);
 
    size_t alloc = sizeof(BIND) * paramCount;
    __DCL_TRACE1_N(L"paramBINDs alloc [%zd]\n", alloc);
    __paramBINDs = (BIND*)malloc(alloc);
    if (!__paramBINDs) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    memset(__paramBINDs, 0, alloc);
 
    SQLHDESC hdesc = NULL;
    SQLINTEGER len = sizeof(hdesc);
    rc = SQLGetStmtAttr(__hstmt, SQL_ATTR_IMP_PARAM_DESC, &hdesc, len, &len);
    if (rc != SQL_SUCCESS) {
        __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
        return false;
    }
 
    BIND* bind = __paramBINDs;
    for (SQLSMALLINT i = 0; i < paramCount; i++, bind++) {
        bind->number = i + 1;
#if 0
        SQLCHAR name[1];
        SQLSMALLINT namelen = sizeof(name);
        SQLSMALLINT subtype;
        rc = SQLGetDescRecA(hdesc, bind->number, name, namelen, &namelen,
            &(bind->type), &subtype, (SQLLEN*)&(bind->size),
            &(bind->precision), &(bind->scale), &(bind->nullable));
        if (rc != SQL_SUCCESS) {
            // SQLDescribeParam호출 없이 SQLGetDescRecA가 호출되면
            // SQL_NO_DATA
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
#else
        rc = SQLDescribeParam(__hstmt, bind->number,
            &(bind->type), &(bind->size), &(bind->scale), &(bind->nullable));
        if (rc != SQL_SUCCESS) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
        SQLULEN numAttr = 0;
        rc = SQLGetDescFieldA(hdesc, bind->number, SQL_DESC_PRECISION, &numAttr, 0, NULL);
        if (rc != SQL_SUCCESS) {
            __SET_ERROR_HANDLE(rc, SQL_HANDLE_STMT, __hstmt);
            return false;
        }
        bind->precision = (SQLSMALLINT)numAttr;
#endif
        __DCL_TRACE6_N(L"Param [%2d]   size [%10d %4d,%4d] type [%4d %ls]\n",
            bind->number,
            bind->size, bind->precision, bind->scale,
            bind->type, ODBCData::__TYPE_NAME(bind->type)
        );
 
#if __USE_SS_PARAM_FIX
        switch (bind->type) {
            case SQL_SS_TIME2: {
                bind->type = SQL_TYPE_TIME;
                break;
            }
            case SQL_SS_TIMESTAMPOFFSET: {
                bind->type = SQL_TYPE_TIMESTAMP;
            }
        }
#endif
        // 파라미터가 NULL인 경우에도 valueType은 SQL_UNKNOWN이 될 수 없다.
        // See.  ODBCParam::setNull
        bind->valueType = SQL_C_DEFAULT;
        bind->lenORind = SQL_NULL_DATA;
    }
 
#define __TYPE_PARAM_SIZE(_type, _size) \
    __MAX(ODBCData::__TYPE_SIZE(_type, _size), sizeof(PARAM_BUFFER_MINIMAL))
#define __TYPE_PARAM_ALIGN(_offset) \
    ((_offset + sizeof(long) - 1) & ~(sizeof(long) - 1))
 
    // __paramBINDs에 적용할, 레코드 버퍼 크기를 계산한다.
    size_t offset = 0;
    bind = __paramBINDs;
    for (SQLSMALLINT i = 0; i < paramCount; i++, bind++) {
        offset = __TYPE_PARAM_ALIGN(offset);
        // 다음에서 bind.size == 0 또는 > 12000 인 경우에 valueMax는 0이다.
        // 이것은 SQLExecute가 아닌 SQLGetData를 사용하여 필드값을 얻는다.
        bind->valueMax = __TYPE_PARAM_SIZE(bind->type, bind->size);
        __DCL_TRACE5_N(L"Param [%2d] offset [%10zd %5d    ] type [%4d %ls]\n",
            bind->number, offset, bind->valueMax, bind->type, ODBCData::__TYPE_NAME(bind->type));
        offset += bind->valueMax;
    }
 
    __DCL_TRACE1_N(L"paramBuffer size [%zd]\n", offset);
    // 모든 필드의 __TYPE_SIZEM(field) == 0 인 경우가 있을 수 있다.
    // 모든 필드가 12000 바이트를 초과하는 VARCHAR, VARBINARY, TEXT, BLOB이면
    // offset의 값이 0이다.
    // 파라미터의 최소 버퍼 크기는 sizeof(PARAM_BUFFER_MINIMAL) 이다.
    if (offset > 0) {
        __paramBINDs = (BIND*)realloc(__paramBINDs, alloc + offset);
        if (__paramBINDs == NULL) {
            __SET_ERROR(SQL::eOutOfMemory);
            return false;
        }
    }
 
    char* buffer = (char*)(__paramBINDs + paramCount);
    __DCL_TRACE2_N(L"__paramBINDs[%p] buffer[%p]\n", __paramBINDs, buffer);
    offset = 0;
    bind = __paramBINDs;
    for (SQLSMALLINT i = 0; i < paramCount; i++, bind++) {
        offset = __TYPE_PARAM_ALIGN(offset);
        if (bind->valueMax) {
            // SQLBindCol 바인드 대상만 버퍼를 할당한다.
            // valueMax가 0인 경우는 SQLGetData로 데이터의 실제 크기를 알아낸다.
            bind->valuePtr = buffer + offset;
            offset += bind->valueMax;
        }
    }
 
    Query::__paramCount = paramCount;
    __params = new ODBCParam[Query::__paramCount];
    if (__params == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    bind = __paramBINDs;
    for(size_t i = 0; i < Query::__paramCount; i++, bind++) {
        if (!__params[i].init(this, bind))
            return false;
    }
 
    return true;
}

reset()

bool ODBCQuery::reset ( )

protected

Definition at line 98 of file ODBCQuery.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 (__fieldBINDs) {
        free(__fieldBINDs);
        __fieldBINDs = NULL;
    }
 
    if (__paramBINDs) {
        free(__paramBINDs);
        __paramBINDs = NULL;
    }
 
    bool r = true;
    if (__hstmt) {
        SQLRETURN rc_ = SQLFreeStmt(__hstmt, SQL_CLOSE);
        if (rc_ != SQL_SUCCESS) {
            __DCL_TRACE1_N(L"SQLFreeStmt(STMT) Fail! [%d]\n", rc_);
        }
        rc_ = SQLFreeHandle(SQL_HANDLE_STMT, __hstmt);
        if (rc_ != SQL_SUCCESS) {
            __DCL_TRACE1_N(L"SQLFreeHandle(STMT) Fail! [%d]\n", rc_);
        }
        __hstmt = NULL;
    }
 
    return r;
}

Member Data Documentation

__fieldBINDs

BIND* ODBCQuery::__fieldBINDs

protected

Definition at line 55 of file ODBCQuery.h.

__fields

ODBCField* ODBCQuery::__fields

protected

Definition at line 58 of file ODBCQuery.h.

__hstmt

SQLHSTMT ODBCQuery::__hstmt

protected

Definition at line 52 of file ODBCQuery.h.

__paramBINDs

BIND* ODBCQuery::__paramBINDs

protected

Definition at line 54 of file ODBCQuery.h.

__params

ODBCParam* ODBCQuery::__params

protected

Definition at line 57 of file ODBCQuery.h.

---

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

• ODBCQuery.h
• ODBCQuery.cpp