IBQuery.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>     // malloc, free
 
#include <ibase.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 <dcl/OutputStream.h>
#include <dcl/Charset.h>
 
#include "IBConnection.h"
#include "IBQuery.h"
#include "IBField.h"
#include "IBParam.h"
 
#ifndef SQLDA_CURRENT_VERSION
    #define SQLDA_CURRENT_VERSION SQLDA_VERSION1
#endif
 
#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/IBQuery.cpp");
 
__DCL_BEGIN_NAMESPACE
 
#define __SET_ERROR(_error) \
    conn()->setErrorHandle(_error, __THIS_FILE__, __LINE__)
#define __SET_ERROR_MSG(_msg) \
    conn()->setErrorMessage(_msg, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(IBQuery, SQL::Query)
 
IBQuery::IBQuery(IBConnection* _connHandle)
    : Query(_connHandle)
{
    __stmtHandle = NULL_HANDLE;
    __inSQLDA = NULL;
    __outSQLDA = NULL;
 
    __stmtType = _IB_STMT_TYPE_UNKNOWN;
    __fields = NULL;
    __params = NULL;
}
 
IBQuery::~IBQuery()
{
#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 IBQuery::__destroy()
{
    delete this;
}
 
bool IBQuery::reset()
{
    Query::__eof = true;
    Query::__affectedRows = -1;
    __stmtType = _IB_STMT_TYPE_UNKNOWN;
    __fetchCounter = 0;
 
    // clear fields
    if (__fields) {
        __DCL_ASSERT(Query::__fieldCount > 0);
        delete[] __fields;
        __fields = NULL;
        Query::__fieldCount = 0;
    }
 
    // clear binds
    if (__params) {
        __DCL_ASSERT(Query::__paramCount > 0);
        delete[] __params;
        __params = NULL;
        Query::__paramCount = 0;
    }
 
    if (__outSQLDA) {
        free(__outSQLDA);
        __outSQLDA = NULL;
    }
 
    if (__inSQLDA) {
        free(__inSQLDA);
        __inSQLDA = NULL;
    }
 
    ISC_STATUS* statusVector = conn()->statusVector();
    bool r = true;
    if (__stmtHandle) {
        if (isc_dsql_free_statement(
            statusVector, 
            &__stmtHandle, 
            DSQL_drop
        )) {
            __SET_ERROR(SQL::eServerError);
            r = false;
        }
        __stmtHandle = NULL_HANDLE;
    }
    return r;
}
 
static size_t __TYPE_ALIGN(size_t _offset, int _sqltype)
{
    size_t size = 0;
    switch(_sqltype & ~1) {
        case SQL_BOOLEAN:
            size = sizeof(char);
            break;
        case SQL_SHORT:
            size = sizeof(short);
            break;
        case SQL_LONG:
            size = sizeof(long);
            break;
        case SQL_INT64:
            size = sizeof(ISC_INT64);
            break;
        case SQL_FLOAT:
            size = sizeof(float);
            break;
        case SQL_DOUBLE:
            size = sizeof(double);
            break;
        case SQL_TYPE_DATE:
            size = sizeof(ISC_DATE);
            break;
        case SQL_TYPE_TIME:
            size = sizeof(ISC_TIME);
            break;
        case SQL_TIMESTAMP:
            size = sizeof(ISC_TIMESTAMP);
            break;
#if defined(FIREBIRD_IBASE_H) && FB_API_VER >= 40
        case SQL_TIME_TZ_EX:
            size = sizeof(ISC_TIME_TZ_EX);
            break;
        case SQL_TIMESTAMP_TZ_EX:
            size = sizeof(ISC_TIMESTAMP_TZ_EX);
            break;
#endif
        case SQL_TEXT:
            size = sizeof(char);
            break;
        case SQL_VARYING:
            size = sizeof(short);
            break;
        case SQL_BLOB :
            size = sizeof(ISC_QUAD);
            break;
        default: {
            __DCL_TRACE3_N(__T("_offset[%d] _sqltype[%d] [%d]\n"),
                _offset, _sqltype, _sqltype & ~1);
            __DCL_ASSERT(false);
        }
    }
 
    return (_offset + size - 1) & ~(size - 1);
}
 
bool IBQuery::initFields()
{
    __DCL_ASSERT((__stmtHandle != NULL_HANDLE)
        && (Query::__fieldCount == 0)
        && (__fields == NULL)
        && (__outSQLDA == NULL)
    );
 
    ISC_STATUS* statusVector = conn()->statusVector();
    __outSQLDA = (XSQLDA*)malloc(XSQLDA_LENGTH(1));
    if (__outSQLDA == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    __outSQLDA->version = SQLDA_CURRENT_VERSION;
    __outSQLDA->sqln = 1;
 
    if(isc_dsql_describe(
        statusVector, 
        &__stmtHandle, 
        SQLDA_CURRENT_VERSION,
        __outSQLDA
    )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    if (__outSQLDA->sqld == 0) {
        // 필드가 없다.
        return true;
    }
 
    if (__outSQLDA->sqln < __outSQLDA->sqld) {
        __outSQLDA = (XSQLDA*)realloc(__outSQLDA, XSQLDA_LENGTH(__outSQLDA->sqld));
        if (__outSQLDA == NULL) {
            __SET_ERROR(SQL::eOutOfMemory);
            return false;
        }
        __DCL_ASSERT(__outSQLDA->version == SQLDA_CURRENT_VERSION);
        __outSQLDA->sqln = __outSQLDA->sqld;
 
        if (isc_dsql_describe(
            statusVector, 
            &__stmtHandle, 
            SQLDA_CURRENT_VERSION,
            __outSQLDA
        )) {
            __SET_ERROR(SQL::eServerError);
            return false;
        }
    }
 
    // __outSQLDA에 적용할, 레코드 버퍼 크기를 계산한다.
    size_t offset = 0;
    XSQLVAR* sqlvar = __outSQLDA->sqlvar;
    for(short i = 0; i < __outSQLDA->sqld; i++, sqlvar++) {
        offset = __TYPE_ALIGN(offset, sqlvar->sqltype);
        switch(sqlvar->sqltype & ~1) {
            case SQL_TEXT :
                offset += sqlvar->sqllen + 1;
                break;
            case SQL_VARYING :
                offset += sqlvar->sqllen + sizeof(short) + 1;
                break;
            default :
                offset += sqlvar->sqllen;
        }
    }
 
    __DCL_TRACE1_N(L"outBuffer [%zd]\n", offset);
    if (offset > 0) {
        __outSQLDA = (XSQLDA*)realloc(__outSQLDA,
            XSQLDA_LENGTH(__outSQLDA->sqld) + offset);
        if (__outSQLDA == NULL) {
            __SET_ERROR(SQL::eOutOfMemory);
            return false;
        }
    }
 
    char* outBuffer = (char*)__outSQLDA + XSQLDA_LENGTH(__outSQLDA->sqld);
    __DCL_TRACE2_N(L"__outSQLDA[%p] outBuffer[%p]\n", __outSQLDA, outBuffer);
    sqlvar = __outSQLDA->sqlvar;
    offset = 0;
    for(short i = 0; i < __outSQLDA->sqld; i++, sqlvar++) {
        offset = __TYPE_ALIGN(offset, sqlvar->sqltype);
        sqlvar->sqldata = outBuffer + offset;
        switch(sqlvar->sqltype & ~1) {
            case SQL_TEXT :
                offset += sqlvar->sqllen + 1;
                break;
            case SQL_VARYING :
                offset += sqlvar->sqllen + sizeof(short) + 1;
                break;
            default :
                offset += sqlvar->sqllen;
        }
    }
 
    Query::__fieldCount = __outSQLDA->sqld;
    __fields = new IBField[Query::__fieldCount];
    if (__fields == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    sqlvar = __outSQLDA->sqlvar;
    for (size_t i = 0; i < Query::__fieldCount; i++, sqlvar++) {
        if (!__fields[i].init(this, sqlvar))
            return false;
    }
 
    return true;
}
 
bool IBQuery::initParams(size_t _paramCount)
{
    __DCL_ASSERT((__stmtHandle != NULL_HANDLE)
        && (Query::__paramCount == 0)
        && (__params == NULL)
        && (__inSQLDA == NULL)
    );
 
    short paramCount = (short)_paramCount;
    ISC_STATUS* statusVector = conn()->statusVector();
    __inSQLDA = (XSQLDA*)malloc(XSQLDA_LENGTH(paramCount));
    if (__inSQLDA == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    __inSQLDA->version = SQLDA_CURRENT_VERSION;
    __inSQLDA->sqln = paramCount;
 
    if (isc_dsql_describe_bind(
        statusVector, 
        &__stmtHandle, 
        SQLDA_CURRENT_VERSION, 
        __inSQLDA
    )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
    __DCL_ASSERT(__inSQLDA->sqld == paramCount);
 
    Query::__paramCount = __inSQLDA->sqld;
    __params = new IBParam[Query::__paramCount];
    if (__params == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    XSQLVAR* sqlvar = __inSQLDA->sqlvar;
    for(size_t i = 0; i < Query::__paramCount; i++, sqlvar++) {
        if (!__params[i].init(this, sqlvar)) {
            return false;
        }
    }
 
    return true;
}
 
static char stmt_info_item[] = { isc_info_sql_stmt_type };
static char count_info_item[] = { isc_info_sql_records };
 
bool IBQuery::__prepare(const char* _sql, size_t _sqllen,
        size_t _paramCount)
{
    if(!reset())
        return false;
 
    if (isc_dsql_allocate_statement(
        conn()->statusVector(),
        conn()->dbHandlePtr(), 
        &__stmtHandle
    )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
#ifdef FIREBIRD_IBASE_H
    #undef _CONST
    #define _CONST const
#endif
 
    ISC_STATUS rs = isc_dsql_prepare(
        conn()->statusVector(),
        conn()->trHandlePtr(), 
        &__stmtHandle, 
        0, 
        (_CONST char*)_sql,
        conn()->dialect(), 
        NULL
    );
    if (rs) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    char res_buffer[8]; 
    if (isc_dsql_sql_info(
        conn()->statusVector(),
        &__stmtHandle,
        sizeof(stmt_info_item),
        stmt_info_item,
        sizeof(res_buffer),
        res_buffer
    )) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    if (res_buffer[0] != isc_info_sql_stmt_type) {
        __SET_ERROR(SQL::eServerError);
        return false;
    }
 
    int len = isc_vax_integer(&res_buffer[1], 2);
    __stmtType = isc_vax_integer(&res_buffer[3], len);
 
    // SELECT, EXECUTE PROCEDURE 는 Row Sets을 반환한다.
    if ((__stmtType == isc_info_sql_stmt_select)
        || (__stmtType == isc_info_sql_stmt_select_for_upd)
        || (__stmtType == isc_info_sql_stmt_exec_procedure)
    ) {
        if (!initFields())
            return false;
    }
 
    if (_paramCount > 0) {
        if (!initParams(_paramCount))
            return false;
    }
 
    return true;
//  rs = isc_dsql_set_cursor_name(statusVector, &__stmtHandle, "CURSOR1", 0);
}
 
bool IBQuery::__execute()
{
    if (__stmtType == isc_info_sql_stmt_exec_procedure) {
        // 2025-07-10
        // EXECUTE PROCEDURE에 대하여 커서를 만들지 않는다.
        // 따라서, __fetch()에서 isc_dsql_fetch는 사용할 수 없다.
        if (isc_dsql_execute2(
            conn()->statusVector(),
            conn()->trHandlePtr(),
            &__stmtHandle,
            conn()->dialect(),
            __inSQLDA,
            __outSQLDA
        )) {
            __SET_ERROR(SQL::eServerError);
            return false;
        }
    }
    else {
        if (isc_dsql_execute(
            conn()->statusVector(),
            conn()->trHandlePtr(),
            &__stmtHandle,
            conn()->dialect(),
            __inSQLDA
        )) {
            __SET_ERROR(SQL::eServerError);
            return false;
        }
    }
 
    for (size_t i = 0; i < Query::__paramCount; i++) {
        __params[i].onAfterExecute();
    }
 
    // INSERT, DELETE, UPDATE statement의 실행 후
    // affected records를 구한다.
 
    unsigned char count_type = 0;
    switch(__stmtType) {
        case isc_info_sql_stmt_update: {
            count_type = isc_info_req_update_count;
            break;
        }
        case isc_info_sql_stmt_delete: {
            count_type = isc_info_req_delete_count;
            break;
        }
        case isc_info_sql_stmt_insert: {
            count_type = isc_info_req_insert_count;
            break;
        }
        case isc_info_sql_stmt_select:
        case isc_info_sql_stmt_select_for_upd: {
            Query::__eof = false;
            break;
        }
        case isc_info_sql_stmt_exec_procedure: {
            Query::__eof = false;
            for (size_t i = 0; i < Query::__fieldCount; i++) {
                if (!__fields[i].onAfterFetch())
                    return false;
            }
            break;
        }
    }
 
    if (count_type) {
        unsigned char count_is = 0;
        char count_buffer[33];
        unsigned short length;
 
        if (isc_dsql_sql_info(
            conn()->statusVector(),
            &__stmtHandle, 
            sizeof(count_info_item),
            count_info_item,
            sizeof(count_buffer),
            count_buffer
        )) {
            __SET_ERROR(SQL::eServerError);
            return false;
        }
 
        for(char* p = count_buffer + 3; *p != isc_info_end; ) {
            count_is = *p++;
            length = (unsigned short)isc_vax_integer(p, 2);
            p += 2;
            Query::__affectedRows = isc_vax_integer(p, length);
            p += length;
            if (count_is == count_type)
                break;
        }
    }
 
    return true;
}
 
bool IBQuery::__fetch()
{
    __DCL_ASSERT(!eof());
    if (__stmtType == isc_info_sql_stmt_exec_procedure) {
        // 2025-07-10
        // SQLDA 구조를 따르는 Informix, PostgreSQL과 MariaDB 모두
        // PROCEDURE 실행의 결과를 필드 접근으로 구현되었다.
        // fetch 후 필드 접근 패턴으로 맞춘다.
        __fetchCounter++;
        if (__fetchCounter > 1) {
            Query::__eof = true;
        }
        return true;
    }
 
    __DCL_ASSERT(__stmtType == isc_info_sql_stmt_select
        || __stmtType == isc_info_sql_stmt_select_for_upd);
    ISC_STATUS rs = isc_dsql_fetch(
        conn()->statusVector(), 
        &__stmtHandle, 
        SQLDA_CURRENT_VERSION, 
        __outSQLDA
    );
    if (rs == 0) {
        for(size_t i = 0; i < Query::__fieldCount; i++) {
            if (!__fields[i].onAfterFetch())
                return false;
        }
        return true;
    }
    else if (rs == 100) {
        Query::__eof = true;
        return true;
    }
 
    __DCL_TRACE1(L"[%zd]\n", (int64_t)rs);
    __SET_ERROR(SQL::eServerError);
    return false;
}
 
bool IBQuery::__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 IBQuery::__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