ODBCQuery.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // malloc, free, alloca
#include <string.h>     // memset
 
#ifdef _MSC_VER
#include <windows.h>
#endif
#include <sql.h>
#include <sqlext.h>
#include <msodbcsql.h>
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/size_t.h>
#include <dcl/SQLCore.h>
#include <dcl/Charset.h>
 
#include "ODBCConnection.h"
#include "ODBCQuery.h"
#include "ODBCData.h"
#include "ODBCField.h"
#include "ODBCParam.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
#define __DCL_TRACE5_N  __DCL_TRACE5
#define __DCL_TRACE6_N  __DCL_TRACE6
#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)
#define __DCL_TRACE5_N(fmt, arg1, arg2, arg3, arg4, arg5)
#define __DCL_TRACE6_N(fmt, arg1, arg2, arg3, arg4, arg5, arg6)
#endif
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/sql/ODBCQuery.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    connection()->setErrorStatus(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    conn()->setErrorMessage(_msg, __THIS_FILE__, __LINE__)
#define __SET_ERROR_HANDLE(_rc, _htype, _handle) \
    conn()->setErrorHandle(_rc, _htype, _handle, __THIS_FILE__, __LINE__)
#define __SET_INFO_HANDLE(_rc, _htype, _handle) \
    if (_rc == SQL_SUCCESS_WITH_INFO) { \
        conn()->setErrorHandle(_rc, _htype, _handle, __THIS_FILE__, __LINE__); \
    }
 
IMPLEMENT_CLASSINFO(ODBCQuery, SQL::Query)
 
ODBCQuery::ODBCQuery(ODBCConnection* _connection)
    : Query(_connection)
{
    __hstmt = NULL;
 
    __paramBINDs = NULL;
    __fieldBINDs = NULL;
 
    __params = NULL;
    __fields = NULL;
}
 
ODBCQuery::~ODBCQuery()
{
#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 ODBCQuery::__destroy()
{
    delete this;
}
 
bool ODBCQuery::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 (__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;
}
 
bool ODBCQuery::initParams(size_t _paramCount)
{
    __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;
}
 
bool ODBCQuery::initFields(SQLSMALLINT _columnCount)
{
    __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;
}
 
bool ODBCQuery::__prepare(
    const char* _sql, size_t _sqllen,
    size_t _paramCount
)
{
    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;
}
 
bool ODBCQuery::__execute()
{
    // 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;
}
 
bool ODBCQuery::__fetch()
{
    __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;
}
 
bool ODBCQuery::__moreResults(bool* _moreResults)
{
    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;
}
 
bool ODBCQuery::__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 ODBCQuery::__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