PgQuery.cpp

Go to the documentation of this file.

/* Processed by ecpg (17.4) */
/* These include files are added by the preprocessor */
#include <ecpglib.h>
#include <ecpgerrno.h>
#include <sqlca.h>
/* End of automatic include section */
 
#line 1 "PgQuery.pgc"
#include <dcl/Config.h>
 
#include <stdlib.h>     // malloc, free
 
#include <ecpgtype.h>
#include <sqlda.h>
#include <pgtypes_numeric.h>
#include <pgtypes_date.h>
#include <pgtypes_interval.h>
#include <pgtypes_timestamp.h>
 
#include <dcl/Object.h>
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Numeric.h>
#include <dcl/SQLCore.h>
 
#include "PgConnection.h"
#include "PgQuery.h"
#include "PgField.h"
#include "PgParam.h"
 
#undef __THIS_FILE__
static const wchar_t __THIS_FILE__[] = __T("dcl/sql/PgQuery.ec");
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(PgQuery, SQL::Query)
 
PgQuery::PgQuery(PgConnection* pConnection)
    : Query(pConnection)
{
    ByteString strID = ByteString::format("%p", this);
 
    __statementID = "stmt_" + strID;
    __cursorID = "cursor_" + strID;
 
    __inSQLDA = NULL;
    __outSQLDA = NULL;
 
    __cursorOpened = false;
    __cursorDeclared = false;
 
    __fields = NULL;
    __params = NULL;
}
 
PgQuery::~PgQuery()
{
#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(__T("Warning! %s\n"), s.data());
        }
        else {
            __DCL_TRACE0(__T("Warning! Query reset error\n"));
        }
    }
#else
    (void)reset();
#endif
}
 
void PgQuery::__destroy()
{
//  cerr << "PgQuery::destory\n";
    delete this;
}
 
bool PgQuery::reset()
{
    /* exec sql begin declare section */
       
        
        
    
#line 86 "PgQuery.pgc"
 char * pszConnectionID = conn () -> connectionID () ;
 
#line 87 "PgQuery.pgc"
 char * pszStatementID = ( _CONST char * ) __statementID . data () ;
 
#line 88 "PgQuery.pgc"
 char * pszCursorID = ( _CONST char * ) __cursorID . data () ;
/* exec sql end declare section */
#line 89 "PgQuery.pgc"
 
    
    { ECPGsetconn(__LINE__, pszConnectionID);}
#line 91 "PgQuery.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
    __DCL_ASSERT(SQLCODE == 0);
 
    if (__cursorOpened) {
        { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "close $0", 
    ECPGt_char,&(pszCursorID),(long)0,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
#line 99 "PgQuery.pgc"
 
        __cursorOpened = false;
    }
    
    if (__cursorDeclared) {
        { ECPGdeallocate(__LINE__, 0, NULL, pszCursorID);}
#line 104 "PgQuery.pgc"
 
        __cursorDeclared = false;
    }
    
    if (__outSQLDA) {
        { ECPGdeallocate(__LINE__, 0, NULL, pszStatementID);}
#line 109 "PgQuery.pgc"
 
    }
 
    Query::__eof = true;
    Query::__affectedRows = -1;
 
    // 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) {
        // __outSQLDA는 Informix API에서 할당됨.
    //  DCLPgFree(__outSQLDA);
        __outSQLDA = NULL;
    }
 
    if (__inSQLDA) {
        free(__inSQLDA);
        __inSQLDA = NULL;
    }
 
    return true;
}
 
bool PgQuery::initFields()
{
    __DCL_ASSERT((__fields == NULL) 
            && (Query::__fieldCount == 0)
            && (__outSQLDA != NULL)
            && (__outSQLDA->sqld > 0));
 
    Query::__fieldCount = __outSQLDA->sqld;
    __fields = new PgField[Query::__fieldCount];
    if (__fields == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    sqlvar_t* sqlvar = __outSQLDA->sqlvar;
    for(size_t i = 0; i < Query::__fieldCount; i++, sqlvar++) {
        if (!__fields[i].init(this, sqlvar))
            return false;
    }       
 
    return true;
}
 
bool PgQuery::initParams(size_t _paramCount)
{
    __DCL_ASSERT((__params == NULL)
        && (Query::__paramCount == 0)
        && (__outSQLDA != NULL));
 
    size_t nAllocSize = sizeof(sqlda_t)
        + (sizeof(sqlvar_t) * _paramCount);
    __inSQLDA = (sqlda_t*)malloc(nAllocSize);
    if (__inSQLDA == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
    memset(__inSQLDA, 0, nAllocSize);
    __inSQLDA->sqln = (short)_paramCount;
 
    Query::__paramCount = _paramCount;
    __params = new PgParam[Query::__paramCount];
    if (__params == NULL) {
        __SET_ERROR(SQL::eOutOfMemory);
        return false;
    }
 
    sqlvar_t* sqlvar = __inSQLDA->sqlvar;
    for(size_t i = 0; i < Query::__paramCount; i++, sqlvar++) {
        if (!__params[i].init(this, sqlvar))
            return false;
    }
 
    return true;
}
 
const wchar_t* __dataTypeName(const sqlvar_t* _sqlvar);
 
bool PgQuery::__prepare(const char* _sql, size_t _sqllen,
        size_t _paramCount)
{
    if(!reset())
        return false;
 
    /* exec sql begin declare section */
       
        
        
    
#line 209 "PgQuery.pgc"
 char * pszConnectionID = conn () -> connectionID () ;
 
#line 210 "PgQuery.pgc"
 char * pszStatementID = ( _CONST char * ) __statementID . data () ;
 
#line 211 "PgQuery.pgc"
 char * pszSQL = ( _CONST char * ) _sql ;
/* exec sql end declare section */
#line 212 "PgQuery.pgc"
 
    
    { ECPGsetconn(__LINE__, pszConnectionID);}
#line 214 "PgQuery.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
    __DCL_ASSERT(SQLCODE == 0);
 
    { ECPGprepare(__LINE__, NULL, 0, pszStatementID, pszSQL);}
#line 221 "PgQuery.pgc"
 
 
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    { ECPGdescribe(__LINE__, 0, 0, NULL, pszStatementID,
    ECPGt_sqlda, &__outSQLDA, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
#line 228 "PgQuery.pgc"
 
 
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
 
    if (__outSQLDA)   {
#if 0
        __DCL_TRACE1(L"[%p]\n", __outSQLDA);
        __DCL_TRACE4(L"[%hs] [%ld] sqln[%d] sqld[%d]\n",
            __outSQLDA->sqldaid, __outSQLDA->sqldabc,
            __outSQLDA->sqln, __outSQLDA->sqld
        );
        for (int i = 0; i < __outSQLDA->sqld; i++) {
            sqlvar_t* p = &(__outSQLDA->sqlvar[i]);
            __DCL_TRACE4(L"[%19ls] [%hd] [%p] [%p]\n",
                __dataTypeName(p), p->sqllen, p->sqldata, p->sqlind
            );
        }
#endif
        if (__outSQLDA->sqld > 0) {
            if (!initFields())
                return false;
        }
    }
 
    if (_paramCount > 0) {
        if (!initParams(_paramCount))
            return false;
    }
 
    return true;
}
 
bool PgQuery::__execute()
{
    /* exec sql begin declare section */
       
        
        
    
#line 266 "PgQuery.pgc"
 char * pszConnectionID = conn () -> connectionID () ;
 
#line 267 "PgQuery.pgc"
 char * pszStatementID = ( _CONST char * ) __statementID . data () ;
 
#line 268 "PgQuery.pgc"
 char * pszCursorID = ( _CONST char * ) __cursorID . data () ;
/* exec sql end declare section */
#line 269 "PgQuery.pgc"
 
 
    { ECPGsetconn(__LINE__, pszConnectionID);}
#line 271 "PgQuery.pgc"
 
    if (SQLCODE < 0) {
        __SET_ERROR_SQLCODE(SQLCODE);
        return false;
    }
    __DCL_ASSERT(SQLCODE == 0);
 
    if (__outSQLDA && __outSQLDA->sqld > 0) {
        if (!__cursorDeclared) {
            ECPGset_var( 0, &( pszCursorID ), __LINE__);\
 /* declare $0 cursor for $1 */
#line 280 "PgQuery.pgc"
 
#line 280 "PgQuery.pgc"
 
            if (SQLCODE < 0) {
                __SET_ERROR_SQLCODE(SQLCODE);
                return false;
            }
            __cursorDeclared = true;
        }
 
        if (__cursorOpened) {
            { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "close $0", 
    ECPGt_char,&(pszCursorID),(long)0,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
#line 289 "PgQuery.pgc"
 
            if (SQLCODE < 0) {
                __SET_ERROR_SQLCODE(SQLCODE);
                return false;
            }
            __cursorOpened = false;
        }
 
        if (__inSQLDA)
            { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "declare $0 cursor for $1", 
    ECPGt_char,&(pszCursorID),(long)0,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
    ECPGt_char_variable,(ECPGprepared_statement(NULL, pszStatementID, __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
    ECPGt_sqlda, &__inSQLDA, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
#line 298 "PgQuery.pgc"
 
        else
            { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "declare $0 cursor for $1", 
    ECPGt_char,&(pszCursorID),(long)0,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
    ECPGt_char_variable,(ECPGprepared_statement(NULL, pszStatementID, __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
#line 300 "PgQuery.pgc"
 
 
        if (SQLCODE < 0) {
            __SET_ERROR_SQLCODE(SQLCODE);
            return false;
        }
 
        __cursorOpened = true;
        __eof = false;
    }
    else {
#if 0
        // 2025.05.06 __outSQLDA 조건은 CURSOR로 처리 하므로
        // 다음 EXEC SQL EXECUTE는 의미가 없다.
        if (__outSQLDA && __inSQLDA)
            { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_execute, pszStatementID, 
    ECPGt_sqlda, &__inSQLDA, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
    ECPGt_sqlda, &__outSQLDA, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
#line 316 "PgQuery.pgc"
 
        else if (__outSQLDA)
            { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_execute, pszStatementID, ECPGt_EOIT, 
    ECPGt_sqlda, &__outSQLDA, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
#line 318 "PgQuery.pgc"
 
        else
#endif
        if (__inSQLDA)
            { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_execute, pszStatementID, 
    ECPGt_sqlda, &__inSQLDA, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
#line 322 "PgQuery.pgc"
 
        else
            { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_execute, pszStatementID, ECPGt_EOIT, ECPGt_EORT);}
#line 324 "PgQuery.pgc"
 
 
        if (SQLCODE < 0) {
            __SET_ERROR_SQLCODE(SQLCODE);
            Query::__affectedRows = -1;
            return false;
        }
 
        // INSERT, UPDATE, DELETE
        Query::__affectedRows = sqlca.sqlerrd[2];
    }
 
    for(size_t i = 0; i < Query::__paramCount; i++) {
        if (!(__params[i].onAfterExecute()))
            return false;
    }
 
    return true;
}
 
bool PgQuery::__fetch()
{
    // SELECT, CALL
    __DCL_ASSERT(!eof());
    __DCL_ASSERT(__outSQLDA && __outSQLDA->sqld > 0);
 
    /* exec sql begin declare section */
        
    
#line 351 "PgQuery.pgc"
 char * pszCursorID = ( _CONST char * ) __cursorID . data () ;
/* exec sql end declare section */
#line 352 "PgQuery.pgc"
 
 
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "fetch $0", 
    ECPGt_char,&(pszCursorID),(long)0,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
    ECPGt_sqlda, &__outSQLDA, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
#line 354 "PgQuery.pgc"
 
 
    if (SQLCODE == ECPG_NO_ERROR) {
#if 0
        __DCL_TRACE1(L"[%p]\n", __outSQLDA);
        __DCL_TRACE4(L"[%hs] [%ld] sqln[%d] sqld[%d]\n",
            __outSQLDA->sqldaid, __outSQLDA->sqldabc,
            __outSQLDA->sqln, __outSQLDA->sqld
        );
        for (int i = 0; i < __outSQLDA->sqld; i++) {
            sqlvar_t* p = &(__outSQLDA->sqlvar[i]);
            __DCL_TRACE4(L"[%19ls] [%hd] [%p] [%p]\n",
                __dataTypeName(p), p->sqllen, p->sqldata, p->sqlind
            );
        }
#endif
        sqlvar_t* sqlvar = __outSQLDA->sqlvar;
        for (size_t i = 0; i < Query::__fieldCount; i++) {
            if (!__fields[i].onAfterFetch(sqlvar++))
                return false;
        }
        return true;
    }
    else if (SQLCODE == ECPG_NOT_FOUND) {
        Query::__eof = true;
        return true;
    }
 
    __SET_ERROR_SQLCODE(SQLCODE);
    return false;
}
 
bool PgQuery::__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 PgQuery::__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