.ad 8
.bm 8
.fm 4
.bt $Copyright (c) 2000-2005 SAP AG$$Page %$
.tm 12
.hm 6
.hs 3
.tt 1 $SQL$Project Distributed Database System$VPA10EC$
.tt 2 $$$
.TT 3 $BurkhardD$CORE-LEVEL FUNTIONS  E - F$2001-06-26$
***********************************************************
.nf

.nf

.nf

    ========== licence begin  GPL
    Copyright (c) 2000-2005 SAP AG

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    ========== licence end
.fo


.fo


.fo
Module  :
=========
.sp
Purpose :
.CM *-END-* purpose -------------------------------------
Define  :
.CM *-END-* define --------------------------------------
Use     :
.CM *-END-* use -----------------------------------------
Synonym :
.CM *-END-* synonym -------------------------------------
.sp;.cp 3
Author  : BurkhardD
.sp
.cp 3
Created : 08-31-1993
.sp
.cp 3
Version : 1994-04-25
.sp
.cp 3
Release :  7.3    Date : 2001-06-26
.sp
Specification:
.CM *-END-* specification -------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.fo
.oc _/1
Description:
.CM *-END-* description ---------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.nf
.oc _/1
Structure:
.CM *-END-* structure -----------------------------------
.sp 2
**********************************************************
.sp
.cp 10
.nf
.CM -lll-
Code    :
#ifndef DEBUG
#line 63 "vpa10ec"
#endif
#ifdef MSDOS
#define FCALL _pascal
#else
#define FCALL
#endif
/* API_RETCODE pa01mkstm( UCHAR * stmt_str, 
                       SDWORD  * stmt_len, 
                       tpa60Stmt *stmt_block_ptr,
                       SDWORD  order_type );
*/
#include "vpa00global.h"
#include "vpa10Handle.h"
#include "vpa20Desc.h"
#include "vpa40DBC.h"
#include "vpa50Env.h"
#include "vpa60Stmt.h"
#include "vpa70SQLDA.h"
#include "vpa30.h"
#include "vpa06.h"
#include "vpa09.h"
#include "gpr11.h"
#include "vpr04Long.h"

RETCODE SQL_API CALL_ODBC(SQLExecute, (SQLHSTMT   hstmt));

void FCALL p11initlooprec (struct tpr_sqlloop * looprec);

void p04sqldout( sqlcatype          *sqlca,
                 sqlcxatype         *sqlxa,
                 void               *sqlda,
                 struct tpr_sqlloop *lp );

#ifdef WIN
extern api_global_tab pa07global[];
#endif

/* extern HENV pa10_henv; */
#ifndef SAPDB_FAST
#ifndef _UNICODE_ODBC
UCHAR *PA10_FN_SQLEXECDIRECT = { (UCHAR*) "SQLExecDirect" };
UCHAR *PA10_FN_SQLEXECUTE = { (UCHAR*) "SQLExecute" };
UCHAR *PA10_FN_SQLFETCH = { (UCHAR*) "SQLFetch" };
UCHAR *PA10_FN_SQLFETCHSCROLL = { (UCHAR*) "SQLFetchScroll" };
#else
extern UCHAR *PA10_FN_SQLEXECDIRECT;
extern UCHAR *PA10_FN_SQLEXECUTE;
extern UCHAR *PA10_FN_SQLFETCH;
extern UCHAR *PA10_FN_SQLFETCHSCROLL;
#endif
#endif

#define PA01_BEGIN_TRANS    1
#define PA01_COMMIT_TRANS   2
#define PA01_ROLLBACK_TRANS 3
#define PA01_COMMIT_ROLLBACK 4

/* Prototypes from vpa01c */
API_RETCODE pa01mkstm (tpr05_String *sqlStmt,
                       tpa60Stmt *stmt_block_ptr,
                       SDWORD  order_type );
VOID pa01vfwtrace (tpa41ESQBlock *api_cb_ptr, 
                   UCHAR FAR *trace_str);


/* Prototypes from VPA10EC */
RETCODE pa10execute( tpa50Env  *env_block_ptr,
                     tpa40DBC  *dbc_block_ptr,
                     tpa60Stmt *stmt_block_ptr,
                     SQLHSTMT   hstmt);

tpr05_String* pa10PushSubtrans (SWORD         trans,
                                tpa40DBC     *dbc_block_ptr,
                                tpr05_String *SqlStmt);

VOID pa10PopSubtrans( SWORD     trans,
                      tpa40DBC *dbc_block_ptr,
                      RETCODE   retcode);

SWORD pa01TransactionSearch (tpr05_String * stmt_str);

API_RETCODE pa10PutLongData ( tpa41ESQBlock  *api_cb_ptr,
                              tpa40DBC       *api_dbc_ptr,
                              tpa60Stmt      *api_stmt_ptr,
                              tpa20Desc      *appl_desc_ptr,
                              tpa20Desc      *impl_desc_ptr );

RETCODE pa10GetADBSParameter( SQLHSTMT hstmt);

API_RETCODE pa10ShortFieldParamGet( tpa40DBC  *dbc_block_ptr,
                                    tpa60Stmt *stmt_block_ptr);

void pa10eNumberOfRows( SQLHSTMT       hstmt,
                        tpa60Stmt     *stmt_block_ptr,
                        tpa41ESQBlock *esqblk_ptr,
                        RETCODE       *retcode );

int pa10ProcessParseResult (tpa40DBC *dbc_block_ptr, tpa60Stmt *stmt_block_ptr);

#if defined(WIN32)
void pa10_CallErrorBox (const char *, tpa40DBC *, tpa60Stmt *);
#endif

/* void FCALL sqlfinish( char ); */

#define PA10TOOMANYHOSTVAR(sql_code, error_exit); \
switch (sql_code) {\
   case (PA_OK):\
      break;\
   case (PA_ROW_NOT_FOUND):\
   case (PA_ERR_TOO_MANY_HOSTVAR):\
      sql_code = PA_OK;\
      break;\
   default:\
      retcode = SQL_ERROR;\
      pa60PutError( hstmt, \
	 pa41apmercv(&dbc_block_ptr->esqblk), &dbc_block_ptr->esqblk);\
      goto error_exit;\
      break;\
}

#ifdef _UNICODE_ODBC
ODBC_PROC(SQLExecDirectW, ( SQLHSTMT    hstmt,
                            SQLWCHAR   *szSqlStr,
                            SQLINTEGER  cbSqlStr),
          (hstmt, szSqlStr, cbSqlStr))
#else
ODBC_PROC(SQLExecDirect, ( SQLHSTMT    hstmt,
                           SQLCHAR    *szSqlStr,
                           SQLINTEGER  cbSqlStr),
          (hstmt, szSqlStr, cbSqlStr))
#endif
{
    RETCODE retcode=SQL_SUCCESS;
    API_RETCODE api_retcode;
    UWORD state;
    tpa60Stmt * stmt_block_ptr;
    tpa62DBCSpecial * dbc_special_ptr;
    tpr05_String * stmt_str_ptr;
    UCHAR * parsid_ptr;
    SQLHDBC hdbc;
    tpa40DBC * dbc_block_ptr;
    SQLHENV henv;
    tpa50Env * env_block_ptr;
    SWORD trans;
    tpr05_String *SqlStmt = NULL;
    int ret;

    API_TRACE(API_TR_ENTRY, PA10_FN_SQLEXECDIRECT,0);
    API_TRACE(API_TR_HANDLE,"hstmt",&hstmt);
#ifdef _UNICODE_ODBC
    API_TRACE (API_TR_WSTRING,"szSqlStr",szSqlStr);
#else
    API_TRACE_LEN(API_TR_ODBC_STRING,"szSqlStr",szSqlStr,cbSqlStr);
#endif    
    API_TRACE(API_TR_SDWORD,"cbSqlStr",&cbSqlStr);
  
    api_retcode = apmstfc( SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
                           SQL_API_SQLEXECDIRECT);
    if (api_retcode != API_OK) {
        retcode = SQL_INVALID_HANDLE;
    }
    else {
        if (pa60VerifyStmt( hstmt ) != API_OK) { /* hstmt valid? */
            retcode = SQL_INVALID_HANDLE;
        }
        else {    
            /* get the parents of the statement */
            apmlocp(&hstmt, &stmt_block_ptr, &hdbc, &dbc_block_ptr, 
                    &henv, &env_block_ptr);    
            stmt_block_ptr -> setPosNeedData = FALSE;
            state = stmt_block_ptr->state;
    
            PA09ENTERASYNCFUNCTION(dbc_block_ptr, stmt_block_ptr);
            if (pa09IsAsync(stmt_block_ptr, dbc_block_ptr, NULL)) {
                if (pa09IsConnectionBusy(stmt_block_ptr, dbc_block_ptr)) {
                    retcode = SQL_ERROR;
                    /* function sequence error */
                    pa60PutError( hstmt, API_ODBC_S1010, NULL);
                    goto exit_1_lock;
                }
                if (state == API_STMT_POSITIONED) {
                    retcode = SQL_ERROR;
                    /* invalid cursor state */
                    pa60PutError( hstmt, API_ODBC_24000, NULL);
                    goto exit_1_lock;
                }

                if (szSqlStr == NULL) {
                    retcode = SQL_ERROR;
                    pa60PutError( hstmt, API_ODBC_S1009, NULL);
                    /* invalid argument */	
                    goto exit_1_lock;
                }    


                if (cbSqlStr == SQL_NTS)
#ifdef _UNICODE_ODBC
                    cbSqlStr = sp81UCS2strlen ((tsp81_UCS2Char*) szSqlStr);
                cbSqlStr *= sizeof (tsp81_UCS2Char);
#else
                    cbSqlStr = (SQLINTEGER) API_STRLEN (szSqlStr);
#endif
                
                if (cbSqlStr <= 0) {
                    retcode = SQL_ERROR;
                    pa60PutError( hstmt, API_ODBC_S1090, NULL);
                    /* invalid string */	
                    goto exit_1_lock;
                }    
                /*
                if (stmt_block_ptr->stmt_str_len == 0) {
                    retcode = SQL_ERROR;
                    pa60PutError( hstmt, 
                                  API_ODBC_37000, NULL);
                    goto exit_1_lock;
                }

                API_TRACE( API_TR_SDWORD, "stmt_str_len",
                           &stmt_block_ptr->stmt_str_len);
                */
#ifdef _UNICODE_ODBC
                SqlStmt = pr05IfCom_String_NewDynString (cbSqlStr,
                                                         sp77nativeUnicodeEncoding ());
#else
                SqlStmt = pr05IfCom_String_NewDynString (cbSqlStr,
                                                         sp77encodingAscii);
#endif
                API_MEMCPY (SqlStmt->rawString, szSqlStr, cbSqlStr);
                SqlStmt->cbLen = cbSqlStr;

                if (stmt_block_ptr -> stmtopt.passthrough != TRUE) {
                    stmt_block_ptr->stmt_function_code = csp1_nil_fc;
                    pa01anstm ( SqlStmt,
                                &stmt_block_ptr->dbc_special.order_type);
#ifdef PA10SYNTAXCHECK       
                    if (stmt_block_ptr->dbc_special.order_type
                        == API_CMD_DESCRIBE && special == API_SPEC_NOT) {
                        api_retcode =
                            pa30SyntaxCheck(&dbc_block_ptr->esqblk,
                                            dbc_block_ptr,
                                            stmt_block_ptr,
                                            szSqlStr,
                                            stmt_block_ptr->stmt_str_len);
                    }
#endif
                }	
                else {
                    stmt_block_ptr->dbc_special.order_type = API_CMD_PARSE;
                }
                if (stmt_block_ptr->dbc_special.order_type
                    == API_CMD_ERROR) {
                    retcode = SQL_ERROR;
                    pa41apmmker(API_SQLRUNTIME_3008, &dbc_block_ptr->esqblk);
                    pa60PutError( hstmt,
                                  pa41apmercv(&dbc_block_ptr->esqblk),
                                  &dbc_block_ptr->esqblk);
                    goto exit_1_lock;
                }       
                api_retcode = pa01mkstm( SqlStmt,
                                         stmt_block_ptr,
                                         stmt_block_ptr->dbc_special.order_type);
                if (api_retcode != API_OK) {
                    retcode = SQL_ERROR;
                    pa60PutError( hstmt, API_ODBC_S1001, NULL );
                    /* allocation error */
                    goto exit_1_lock;
                }        
                if (pa09IsAsync(stmt_block_ptr, dbc_block_ptr, &retcode)) {
                    pa09PrepareAsyncCall(hstmt, SQL_API_SQLEXECDIRECT);
                }
            } /* async exec */
            if (pa09IsAsync(stmt_block_ptr, dbc_block_ptr, &retcode)) {
                pa09ExecuteAsyncCall(hstmt);
                goto exit_1_lock;
            }
        
            stmt_str_ptr = (tpr05_String*) (stmt_block_ptr->stmt_str_handle);
    
            parsid_ptr = stmt_block_ptr -> stmt_parsid;
            /* lock SQLDAs */
            stmt_block_ptr->input_sqlda_ptr = (sqldatype *)
                (stmt_block_ptr -> input_sqlda_handle);
            API_ASSERT_PTR(stmt_block_ptr->input_sqlda_ptr);
            stmt_block_ptr->output_sqlda_ptr = (sqldatype *)
                (stmt_block_ptr -> output_sqlda_handle);
            API_ASSERT_PTR(stmt_block_ptr->output_sqlda_ptr);
    
            trans = pa01TransactionSearch(stmt_str_ptr);
            if (trans) {
                stmt_str_ptr = pa10PushSubtrans( trans,
                                                 dbc_block_ptr,
                                                 stmt_str_ptr);
                stmt_block_ptr->stmt_str_handle = stmt_str_ptr;
            }; /* if */
            dbc_special_ptr = &stmt_block_ptr -> dbc_special;

            stmt_block_ptr->output_sqlda_ptr -> sqln = 0;
            stmt_block_ptr->input_sqlda_ptr -> sqln = 0;
            switch (dbc_special_ptr->order_type) {
            case (API_CMD_EXECUTE) : {
                pa60DropParseIds( stmt_block_ptr );
                if (apeimme( &dbc_block_ptr->esqblk,
                             stmt_str_ptr,
                             dbc_block_ptr,
                             stmt_block_ptr) != API_OK) {
                    retcode = SQL_ERROR;
                    pa60PutError( hstmt, API_ODBC_S1000, NULL);
                    /* general error */
                    goto exit_4_lock;
                }
                if (PA_ENV_SQLCODE != PA_OK ) { /* ESQ apeimm ok? */
                    if (PA_ENV_SQLCODE == -8020) {
                        /* Next Volumne Fehlermeldung vom Kern,
                         * wenn der USER ein neues Band einlegen soll.
                         * Es gibt hier sogar noch einen Datapart. */
                        retcode = SQL_SUCCESS_WITH_INFO;
                        pa60PutError( hstmt,
                                      pa41apmercv(&dbc_block_ptr->esqblk),
                                      &dbc_block_ptr->esqblk);
                        PA_ENV_SQLCODE = PA_OK;
                    }
                    else {
                        if (PA_ENV_SQLCODE == PA_ROW_NOT_FOUND)
                            retcode = SQL_SUCCESS_WITH_INFO;
                        else 
                            retcode = SQL_ERROR;
                        pa60PutError( hstmt,
                                      pa41apmercv(&dbc_block_ptr->esqblk),
                                      &dbc_block_ptr->esqblk);
                        goto exit_4_lock;
                    }
                }
                pa10ShortFieldParamGet(dbc_block_ptr, stmt_block_ptr);
                PA10TOOMANYHOSTVAR(PA_ENV_SQLCODE, exit_4_lock);
                break;
            }
            case (API_CMD_PARSE) : {}
            case (API_CMD_DESCRIBE) : {
                int try2;
                pa60DropParseIds( stmt_block_ptr );
                for(try2=0; try2 < 2; try2++) {
                    if (apeprep( &dbc_block_ptr->esqblk,
                                 stmt_str_ptr,
                                 parsid_ptr,
                                 dbc_block_ptr,
                                 stmt_block_ptr) != API_OK) {
                        /* ESQ prepare function ok? */
                        retcode = SQL_ERROR;
                        pa60PutError( hstmt,
                                      API_ODBC_S1000, NULL);
                        /* general error */
                        goto exit_4_lock;
                    }
                    if (PA_ENV_SQLCODE == PA_UPDATE_NOT_ALLOWED) {
                        UWORD stmt_type = stmt_block_ptr->stmt_type;		
                        stmt_block_ptr->stmt_type |= API_ATTRIB_SELECT_FOR_UPDATE;

                        if (SqlStmt == NULL) {           /* async call of SQLExecDirect */
                            tpr05_String *str = (tpr05_String *) (stmt_block_ptr->stmt_str_handle);
                            
                            SqlStmt = pr05IfCom_String_NewDynString (str->cbLen+30,
                                                                     str->encodingType);

                            pr05IfCom_String_InitString (SqlStmt, str->rawString, str->cbLen,
                                                         str->encodingType, str->allocationType);
                        }

                        api_retcode = pa01mkstm( SqlStmt,
                                                 stmt_block_ptr,
                                                 dbc_special_ptr->order_type);
                        if (api_retcode != API_OK) {
                            retcode = SQL_ERROR;
                            pa60PutError( hstmt,
                                          API_ODBC_S1001,  NULL);
                            goto exit_4_lock;
                        }
                        stmt_str_ptr =
                            (tpr05_String *) (stmt_block_ptr->stmt_str_handle);
                        API_ASSERT_PTR(stmt_str_ptr);    
                        stmt_block_ptr->stmt_type = stmt_type;
                        continue;
                    }
                    else
                        break;
                }
                if (stmt_block_ptr->stmt_function_code == csp1_cursor_pl_sql_execute_fc) {
                    stmt_block_ptr -> state = API_STMT_PREPARED;
                    /* PTS 1118144 process proc's parameters */
                    pa10ProcessParseResult (dbc_block_ptr, stmt_block_ptr);
                    retcode = CALL_ODBC(SQLExecute, (hstmt));
                }
                PA10TOOMANYHOSTVAR(PA_ENV_SQLCODE, exit_4_lock);
                /* describe the resulttable */
                if ( dbc_special_ptr->order_type == API_CMD_DESCRIBE ) {
                    api_retcode = apedesc( &dbc_block_ptr->esqblk,
                                           parsid_ptr,
                                           dbc_block_ptr,
                                           stmt_block_ptr);
                    if (api_retcode != API_OK) { 
                        retcode = SQL_ERROR;
                        pa60PutError( hstmt, API_ODBC_S1000, NULL);
                        /* general error */
                        goto exit_4_lock;
                    }
                    PA10TOOMANYHOSTVAR(PA_ENV_SQLCODE, exit_4_lock);
                } /* end describe */
                break;	     
            }
            default : {
                retcode = SQL_ERROR;
                pa60PutError( hstmt, API_ODBC_37000, NULL );
                /* syntax error or access violation */
                goto exit_4_lock;
                break;
            }
            }
    
            ret = pa10ProcessParseResult (dbc_block_ptr, stmt_block_ptr);

            switch (ret) {
            case 1:  goto exit_1_lock; break;
            case 4:  goto exit_4_lock; break;
            case 5:  goto exit_5_lock; break;
            case 6:  goto exit_6_lock; break;
            default:;
            }

            switch (dbc_special_ptr->order_type) {
            case (API_CMD_EXECUTE) : {
                RETCODE ret;
                ret = pa10GetADBSParameter(hstmt);
                if (ret == SQL_ERROR || ret == SQL_SUCCESS_WITH_INFO) {
                    retcode = retcode;
                }
                if (pa40UseOldAutocommit( dbc_block_ptr )) {
                    if (retcode == SQL_SUCCESS
                        || retcode == SQL_SUCCESS_WITH_INFO) {
                        if (dbc_block_ptr->set_autocommit_flag)
                            api_retcode = pa30commit( &dbc_block_ptr->esqblk,
                                                      dbc_block_ptr);
                    }; /* if */
                }; /* if */
                break;
            }
            case (API_CMD_PARSE) : {}
            case (API_CMD_DESCRIBE) : {
                /* now Execute the statement */
                if (stmt_block_ptr->stmt_function_code != csp1_cursor_pl_sql_execute_fc) {
                    stmt_block_ptr -> state = API_STMT_PREPARED;
                    retcode = CALL_ODBC(SQLExecute, (hstmt));
                }  
                PA09LEAVEASYNCFUNCTION();
                goto exit_no_lock;
                break;
            }
            default: {
                break;
            }
            }
            stmt_block_ptr -> number_rows
                = dbc_block_ptr->esqblk.number_rows_modified;
            stmt_block_ptr -> state = API_STMT_EXECUTED;
       
        exit_6_lock:
    
        exit_5_lock:

        exit_4_lock:
            if (trans)
                pa10PopSubtrans(trans, dbc_block_ptr, retcode);

        exit_1_lock:
            if(dbc_block_ptr->status == API_STMT_RECONNECTED) {
                dbc_block_ptr->status = API_DBC_CONNECTED;
                if (retcode == SQL_SUCCESS)
                    retcode = SQL_SUCCESS_WITH_INFO;
                pa41apmmker( API_SQLODBC_22005, &dbc_block_ptr->esqblk );
                pa60PutError( hstmt,
                              API_ODBC_01000, &dbc_block_ptr->esqblk);
            }

            PA09LEAVEASYNCFUNCTION();
        }/* of if hstmt valid */
    } /* set odbc_function */
exit_no_lock:    

    /*
#if defined(WIN32)
    if (dbc_block_ptr->esqblk.esq_sql_code != 0)
        pa10_CallErrorBox ("SQLExecDirect", dbc_block_ptr, stmt_block_ptr);
#endif
    */

    pr05IfCom_String_DeleteString (SqlStmt);
    
    API_TRACE(API_TR_EXIT,PA10_FN_SQLEXECDIRECT,0);
    API_TRACE(API_TR_RETCODE,"retcode",&retcode);
    return (retcode);
} /* SQLExecDirect */


#ifndef _UNICODE_ODBC
API_RETCODE pa60MoveLong( tpa40DBC   *dbc_block_ptr,
                          tpa60Stmt  *stmt_block_ptr,
                          tpa20Desc  *appl_desc_ptr,
                          tpa20Desc  *impl_desc_ptr,
                          UWORD       icol,
                          UWORD       number_cols );

ODBC_PROC(SQLExecute, 
          (SQLHSTMT   hstmt),
          (hstmt))
{
    RETCODE retcode=SQL_SUCCESS;
    tpa60Stmt * stmt_block_ptr;
    tpa62DBCSpecial * dbc_special_ptr;
    UWORD number_cols;
    SQLHDBC hdbc;
    tpa40DBC * dbc_block_ptr;
    SQLHENV henv;
    tpa50Env * env_block_ptr;
    sqldatype * sqlda_ptr;  
    API_HANDLE sqlda_handle;
    API_HANDLE parm_handle;
    UDWORD parm_size;
    UCHAR * parm_ptr;
    API_RETCODE api_retcode, conv_retcode = API_OK;
    UWORD number_parms;
    UDWORD crow;
    UDWORD *pirow = NULL;
    UDWORD  pos;
    UDWORD  irow;
    UDWORD i;
                                      
    tpa20Desc *apd_ptr;
    tpa20Desc *ipd_ptr;
    tsp00_Bool use_local_desc = false; /* use local descriptor blocks for
                                        * array commands to preserve
                                        * the original desc */
    tpa20Desc *local_apd_ptr = NULL;
    tpa20Desc *local_ipd_ptr = NULL;
    
    API_TRACE(API_TR_ENTRY,PA10_FN_SQLEXECUTE,0);
    API_TRACE(API_TR_HANDLE,"hstmt",&hstmt);

    if (apmstfc(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt, 
                SQL_API_SQLEXECUTE) != API_OK) {
        retcode = SQL_INVALID_HANDLE;
        goto no_lock_exit;
    }
    if (pa60VerifyStmt( hstmt ) != API_OK) { /* hstmt valid? */
        retcode = SQL_INVALID_HANDLE;
        goto no_lock_exit;
    }
    apmlocp(&hstmt, &stmt_block_ptr, &hdbc, &dbc_block_ptr, 
            &henv, &env_block_ptr);
    stmt_block_ptr -> setPosNeedData = FALSE;
    /* state = stmt_block_ptr->state; */
    PA09ENTERASYNCFUNCTION(dbc_block_ptr, stmt_block_ptr);
    if (pa09IsAsync(stmt_block_ptr, dbc_block_ptr, NULL))
        {
            if (pa09IsConnectionBusy(stmt_block_ptr, dbc_block_ptr)) {
                retcode = SQL_ERROR;
                /* function sequence error */
                pa60PutError( hstmt, API_ODBC_S1010, NULL);
                goto exit_1_lock;
            }
            if ( stmt_block_ptr->state == API_STMT_POSITIONED) {
                retcode = SQL_ERROR;
                /* invalid cursor state */
                pa60PutError( hstmt, API_ODBC_24000, NULL);
                goto exit_1_lock;
            }
            if (pa09IsAsync(stmt_block_ptr, dbc_block_ptr, &retcode))
                pa09PrepareAsyncCall(hstmt, SQL_API_SQLEXECUTE);     
        } /* async exec */
    if (pa09IsAsync(stmt_block_ptr, dbc_block_ptr, &retcode)) {
        pa09ExecuteAsyncCall(hstmt);
        goto exit_1_lock;
    }
    dbc_special_ptr = &stmt_block_ptr -> dbc_special;
    number_cols = stmt_block_ptr -> number_cols;
    number_parms = stmt_block_ptr -> number_parms;
    API_TRACE(API_TR_UWORD,"number_cols",&number_cols);
    API_TRACE(API_TR_UWORD,"number_parms",&number_parms);

    retcode = SQL_SUCCESS;
    /* make sure sqlda ptr is set */
    sqlda_handle = stmt_block_ptr -> input_sqlda_handle;
    sqlda_ptr = (sqldatype*) (sqlda_handle);
    API_ASSERT_PTR(sqlda_ptr);
    stmt_block_ptr->input_sqlda_ptr = sqlda_ptr;

    apd_ptr = pa60GetAPD( stmt_block_ptr );
    API_ASSERT_PTR( apd_ptr );
    ipd_ptr = &stmt_block_ptr->ipd;
    API_ASSERT_PTR( ipd_ptr );
    
    if (number_parms > 0) {       /* use of host variable markers */

        parm_size = stmt_block_ptr -> parm_size;
        parm_handle = stmt_block_ptr -> parm_handle;
        parm_ptr = (UCHAR *) (parm_handle);
        API_ASSERT_PTR(parm_ptr);

        /* set sqlda-information in the attribute-block */
        api_retcode = pa20SetAttr( sqlda_ptr,
                                   ipd_ptr,
                                   number_parms,
                                   parm_ptr,
                                   parm_size,
                                   CPR_INFO_INPUT );
        if (api_retcode != API_OK) {
            retcode = SQL_ERROR;
            pa41apmmker( API_SQLRUNTIME_9803, &dbc_block_ptr->esqblk );
            pa60PutError( hstmt,
                          API_ODBC_S1000, /* general ODBC error */
                          &dbc_block_ptr->esqblk);
            goto lock_exit;
        }
    }
    /* multiple value */
    if (number_parms > 0) {
        crow = stmt_block_ptr -> apdPtr->header.arraySize;
    } else {
        crow=1;
    }; /* else */
    if ((crow > 1) || (stmt_block_ptr -> rowset_pos > 0)) { 
        /* pirow = stmt_block_ptr -> parm_pirow_ptr; */
        pirow = stmt_block_ptr -> ipd.header.rowsProcessedPtr;
        /* get copy of api_attr_block */
        local_apd_ptr = pa20CloneDesc( apd_ptr );
        local_ipd_ptr = pa20CloneDesc( ipd_ptr );
        if (local_apd_ptr == NULL || local_ipd_ptr == NULL) {
            retcode = SQL_ERROR;
            pa60PutError( hstmt, API_ODBC_S1001, NULL );
            goto lock_exit;
        }; /* if */
        use_local_desc = true;
    } else {
        local_apd_ptr = apd_ptr;
        local_ipd_ptr = ipd_ptr;
    }; /* else */
   
    for (i=1; i <= crow; i++) {
        if (number_parms > 0) {       /* use of host variable markers */
            if (stmt_block_ptr -> rowset_pos > 0) {
                /* we are called by SQLSetPos */
                pos  = stmt_block_ptr->rowset_pos-1;
                irow = 0;
            } else {
                pos  = i-1;
                irow = i;
            };
            if (crow > 1 && pirow != NULL) {
                *pirow = i;
            };
            pa20SetAttrAddr( apd_ptr,
                             local_apd_ptr,
                             local_ipd_ptr,
                             number_parms,
                             apd_ptr->header.bindType,
                             pos,
                             0 /* irow */ );
            /* process host variable markers */
            conv_retcode = pa20PutDesc( local_apd_ptr,
                                        local_ipd_ptr,
                                        number_parms,   /* PTS 1122478 */
                                        stmt_block_ptr->stmtopt.sqlmode);
            retcode = pa60PutESQError( hstmt, conv_retcode );
        }
    
        if (retcode == SQL_NEED_DATA) {
            stmt_block_ptr -> next_param = -1;
            stmt_block_ptr -> state = API_STMT_PREPARED;
        }
   
        if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO ) {
            RETCODE ret;
            ret = pa10execute( env_block_ptr,
                               dbc_block_ptr,
                               stmt_block_ptr,
                               hstmt);
            if (ret != SQL_SUCCESS ) {
                retcode = ret;
                break;
            }
            else {
                /* check if we have to send more putvals PTS 1002071 */
                if (dbc_block_ptr->esqblk.number_rows_modified > 0) {
                    /* process more longvalues */
                    api_retcode = pa10PutLongData( &dbc_block_ptr->esqblk,
                                                   dbc_block_ptr, 
                                                   stmt_block_ptr,
                                                   local_apd_ptr,
                                                   local_ipd_ptr );
                };
                if (PA_ENV_SQLCODE != PA_OK) {
                    retcode = SQL_ERROR;
                    pa60PutError( hstmt, 
                                  API_ODBC_S1000,
                                  &dbc_block_ptr->esqblk );
                    goto lock_exit;	    
                }
                /* process outputparameter */
                if (stmt_block_ptr -> number_rows != 0) {
                    api_retcode = pa20Move( apd_ptr,
                                            ipd_ptr,
                                            number_parms,
                                            dbc_special_ptr );
                    if (api_retcode > conv_retcode
                        || api_retcode == API_NOT_OK) {
                        retcode = pa60PutESQError( hstmt, api_retcode );
                    }; /* if */
                    if ( retcode == SQL_SUCCESS
                         || retcode == SQL_SUCCESS_WITH_INFO) {
                        RETCODE ret = retcode;
                        conv_retcode = pa60MoveLong( dbc_block_ptr,
                                                     stmt_block_ptr,
                                                     apd_ptr,
                                                     ipd_ptr,
                                                     0,
                                                     number_parms);
                        retcode = pa60PutESQError( hstmt, conv_retcode );
                        if (retcode == SQL_SUCCESS) {
                            retcode = ret;
                        }; /* if */
                    }; /* if */
                }; /* if */
            }; /* else */
        }; /* if */
    }/* for */

    if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
        pa10eNumberOfRows( hstmt,
                           stmt_block_ptr,
                           &dbc_block_ptr->esqblk,
                           &retcode);
        if (pa40UseOldAutocommit( dbc_block_ptr )) {
            if (dbc_block_ptr->set_autocommit_flag && number_cols == 0)
                api_retcode = pa30commit( &dbc_block_ptr->esqblk,
                                          dbc_block_ptr);
        }; /* if */
    }; /* if */

    if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
        stmt_block_ptr -> state = API_STMT_EXECUTED;

        /* dbproc with result set: describe result set after exection */
        if (stmt_block_ptr->stmt_function_code == csp1_cursor_pl_sql_execute_fc) {
            int ret;
            api_retcode = apedesc( &dbc_block_ptr->esqblk,
                                   stmt_block_ptr->stmt_parsid,
                                   dbc_block_ptr,
                                   stmt_block_ptr);
            if (api_retcode != API_OK) { 
              retcode = SQL_ERROR;
              pa60PutError( hstmt, API_ODBC_S1000, NULL);
              /* general error */
            }
            else
              ret = pa10ProcessParseResult (dbc_block_ptr, stmt_block_ptr);
        }
    }
   
lock_exit:
    if (number_parms > 0) { 
        if (retcode != SQL_NEED_DATA) {
            /* this would be unlocked in SQLParamData */
            pa20Unset( ipd_ptr, number_parms);
        }
    }	
   
exit_1_lock:   
    if(dbc_block_ptr->status == API_STMT_RECONNECTED) {
        dbc_block_ptr->status = API_DBC_CONNECTED;
        if (retcode == SQL_SUCCESS)
            retcode = SQL_SUCCESS_WITH_INFO;
        pa41apmmker(API_SQLODBC_22005, &dbc_block_ptr->esqblk);
        pa60PutError( hstmt, API_ODBC_01000, &dbc_block_ptr->esqblk);
    }
    if (use_local_desc) {
        /* we have to free cloned descriptors */
        pa20FreeCopiedDesc( local_apd_ptr );
        pa20FreeCopiedDesc( local_ipd_ptr );        
    }; /* if */
    
    PA09LEAVEASYNCFUNCTION();
   
no_lock_exit:
    API_TRACE(API_TR_EXIT,PA10_FN_SQLEXECUTE,0);
    API_TRACE(API_TR_RETCODE,"retcode",&retcode);

    /*
#if defined(WIN32)
    if (dbc_block_ptr->esqblk.esq_sql_code != 0)
        pa10_CallErrorBox ("SQLExecute", dbc_block_ptr, stmt_block_ptr);
#endif
    */

    return (retcode);
} /* SQLExecute */


RETCODE pa10execute( tpa50Env  *env_block_ptr,
                     tpa40DBC  *dbc_block_ptr,
                     tpa60Stmt *stmt_block_ptr,
                     SQLHSTMT   hstmt)
{
    RETCODE retcode;
    API_HANDLE stmt_str_handle;
    tpr05_String* SqlStmt;
    UCHAR * parsid_ptr;
    SWORD trans;
   
    API_TRACE(API_TR_ENTRY, "pa10execute", 0);
    retcode = SQL_SUCCESS;
    stmt_str_handle = stmt_block_ptr -> stmt_str_handle;
    SqlStmt = (tpr05_String *)   (stmt_str_handle);	     
    API_ASSERT_PTR(SqlStmt);
    API_TRACE(API_TR_SDWORD,"stmt_str_len", &stmt_block_ptr->stmt_str_len);
    parsid_ptr = stmt_block_ptr -> stmt_parsid;

    if (stmt_block_ptr -> stmtopt.passthrough != TRUE) {
        pa01anstm( SqlStmt,
                   &stmt_block_ptr->dbc_special.order_type);
    }
    else {
        stmt_block_ptr->dbc_special.order_type = API_CMD_PARSE;
    }
   
    trans = pa01TransactionSearch (SqlStmt);   
    if (trans) {
        SqlStmt = pa10PushSubtrans (trans,
                                    dbc_block_ptr,
                                    SqlStmt);
        stmt_block_ptr->stmt_str_handle = SqlStmt;
    }
	 
    switch (stmt_block_ptr->dbc_special.order_type) {
    case (API_CMD_EXECUTE) : {
        if (apeimme( &dbc_block_ptr->esqblk,
                     SqlStmt, 
                     dbc_block_ptr,
                     stmt_block_ptr) != API_OK) {
            retcode = SQL_ERROR;
            pa60PutError( hstmt, API_ODBC_S1000, NULL);
        }
        break;
    }	
    case (API_CMD_DESCRIBE) : {}
    case (API_CMD_PARSE): {
        if (apeexec( &dbc_block_ptr->esqblk,
                     SqlStmt,
                     parsid_ptr,
                     dbc_block_ptr,
                     stmt_block_ptr ) != API_OK) {
            retcode = SQL_ERROR;
            pa60PutError( hstmt, API_ODBC_S1000, NULL );
        }	
        API_TRACE(API_TR_SWORD, "sql_code", &PA_ENV_SQLCODE);
        break;
    }
    case (API_CMD_ERROR): {
        retcode = SQL_ERROR;
        pa41apmmker(API_SQLRUNTIME_3008, &dbc_block_ptr->esqblk);
        pa60PutError( hstmt,
                      pa41apmercv( &dbc_block_ptr->esqblk ),
                      &dbc_block_ptr->esqblk);
    }       
    default : {
        retcode = SQL_ERROR;
        pa60PutError( hstmt, API_ODBC_42000, NULL); /* dosn't support */
        break;
    }
    }

    if (PA_ENV_SQLCODE != PA_OK) { /* ESQ execute ok? */
        if (PA_ENV_SQLCODE == PA_ROW_NOT_FOUND ) {
            /* PTS 1103839: Return SQL_NO_DATA_FOUND for DB-Procedures */
            if (stmt_block_ptr->stmt_function_code == csp1_pl_sql_execute_fc ||
                stmt_block_ptr->stmt_function_code == csp1_select_direct_fc) {
                retcode = SQL_NO_DATA_FOUND;
            } else {
                PA_ENV_SQLCODE = PA_OK;
            }; /* else */
        } else {
            retcode = SQL_ERROR;
            pa60PutError( hstmt, 
                          pa41apmercv(&dbc_block_ptr->esqblk),
                          &dbc_block_ptr->esqblk);
        }
    }
    stmt_block_ptr -> number_rows = dbc_block_ptr->esqblk.number_rows_modified;
    API_TRACE(API_TR_SDWORD, "number_rows", &stmt_block_ptr->number_rows);
   
    API_TRACE(API_TR_EXIT, "pa10execute", 0);
    API_TRACE(API_TR_RETCODE, "retcode", &retcode);
    return(retcode);
} /* pa10Execute */


static char pa10subtransbegin[]    = "SUBTRANS BEGIN";
static char pa10subtransrollback[] = "SUBTRANS ROLLBACK";
static char pa10subtransend[]      = "SUBTRANS END";

tpr05_String* pa10PushSubtrans (SWORD     trans, 
                                tpa40DBC *dbc_block_ptr, 
                                tpr05_String    *SqlStmt)
{
  /* if SqlStmt is filled and too short, build new one */
  if ((trans == PA01_BEGIN_TRANS || trans == PA01_COMMIT_TRANS
                                 || trans == PA01_ROLLBACK_TRANS) && 
      SqlStmt->cbMaxLen / SqlStmt->encodingType->fixedCharacterSize < sizeof (pa10subtransrollback)-1) {
    unsigned int length = sizeof (pa10subtransrollback)-1;
    tpr05_String *h;
                                                     
    length *= SqlStmt->encodingType->fixedCharacterSize;
    h = pr05IfCom_String_NewDynString (length, SqlStmt->encodingType);
    pr05IfCom_String_DeleteString (SqlStmt);
    SqlStmt = h;
  }

    switch (trans) {
    case PA01_BEGIN_TRANS: {
        /*
        if (dbc_block_ptr -> subtranscount == 0)
            dbc_block_ptr -> retautocommit = dbc_block_ptr->autocommit;
        */
        dbc_block_ptr->set_autocommit_flag = 0;
        pr05IfCom_String_ConvertP (SqlStmt,
                                   pa10subtransbegin,
                                   sizeof(pa10subtransbegin)-1,
                                   sp77encodingAscii);
        break;
    }
    case PA01_COMMIT_TRANS: {
        pr05IfCom_String_ConvertP (SqlStmt,
                                   pa10subtransend,
                                   sizeof (pa10subtransend)-1,
                                   sp77encodingAscii);
        break;
    }
    case PA01_ROLLBACK_TRANS: {
        pr05IfCom_String_ConvertP (SqlStmt,
                                   pa10subtransrollback,
                                   sizeof (pa10subtransrollback)-1,
                                   sp77encodingAscii);
        break;
    }	     
    }
    return (SqlStmt);
} /* pa10PushSubTrans */


VOID pa10PopSubtrans( SWORD     trans, 
                      tpa40DBC *dbc_block_ptr, 
                      RETCODE   retcode)
{   
    if (trans) {
        switch (trans) {
        case PA01_BEGIN_TRANS: {
            if (retcode == SQL_SUCCESS)
                dbc_block_ptr -> subtranscount++;
            else
                dbc_block_ptr -> set_autocommit_flag =
                    dbc_block_ptr->autocommit;
            break;
        }
        case PA01_ROLLBACK_TRANS: {}
        case PA01_COMMIT_TRANS: {
            if (retcode == SQL_SUCCESS) {
                dbc_block_ptr -> subtranscount--;		
	       if (dbc_block_ptr -> subtranscount == 0)
               dbc_block_ptr -> set_autocommit_flag = dbc_block_ptr->autocommit;
            }
            break;
        }
        case PA01_COMMIT_ROLLBACK: {
            if (retcode == SQL_SUCCESS) {
                dbc_block_ptr -> subtranscount = 0;
                dbc_block_ptr -> set_autocommit_flag =
                    dbc_block_ptr->autocommit;		
            }
            break;
        }	  
        }; /* switch */
    }; /* if */
} /* pa10PopSubTrans */


/* get one row from the resultant set */
ODBC_PROC(SQLFetch,
          (SQLHSTMT   hstmt),
          (hstmt))
{
    RETCODE           retcode = SQL_SUCCESS;
    API_RETCODE       api_retcode;
    UWORD             state;
    tpa62DBCSpecial  *dbc_special_ptr;
    UWORD             number_cols;
    SQLROWOFFSET      fetch_pos;
    SQLROWOFFSET      max_select;
    tpa60Stmt        *stmt_block_ptr;
    sqldatype        *sqlda_ptr;
    API_HANDLE        sqlda_handle;
    API_HANDLE        tuple_handle;
    UCHAR            *tuple_ptr;
    UDWORD            tuple_size;
    SQLHDBC           hdbc;
    tpa40DBC         *dbc_block_ptr;
    SQLHENV           henv;
    tpa50Env         *env_block_ptr;
    API_RETCODE       conv_retcode;

    API_TRACE(API_TR_ENTRY,PA10_FN_SQLFETCH,0);
    API_TRACE(API_TR_HANDLE,"hstmt",&hstmt);

    api_retcode = apmstfc(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt, 
                          SQL_API_SQLFETCH);
    if (api_retcode != API_OK) {
        retcode = pa06stfcerror(api_retcode, hstmt);
        goto no_lock_exit;
    }      

    if (pa60VerifyStmt( hstmt ) != API_OK) { /* hstmt valid? */
        retcode = SQL_INVALID_HANDLE;
        goto no_lock_exit;
    }
    state = ((tpa60Stmt*) hstmt)->state;
    if (state != API_STMT_POSITIONED && state != API_STMT_EXECUTED) {
        retcode = SQL_ERROR;
        pa60PutError( hstmt, API_ODBC_S1010, NULL);
        goto no_lock_exit;
    }

    apmlocp( &hstmt, &stmt_block_ptr, &hdbc, &dbc_block_ptr,
             &henv, &env_block_ptr);

    if (stmt_block_ptr->row_not_found) {
        retcode = SQL_NO_DATA_FOUND;
        goto no_lock_exit;
    }; /* if */
    
    PA09ENTERASYNCFUNCTION(dbc_block_ptr, stmt_block_ptr);
    dbc_special_ptr = &stmt_block_ptr -> dbc_special;
    number_cols = stmt_block_ptr -> number_cols;
    fetch_pos = stmt_block_ptr -> fetch_pos;
    max_select = stmt_block_ptr -> stmtopt.max_select;

    sqlda_handle = stmt_block_ptr ->output_sqlda_handle;
    sqlda_ptr = (sqldatype *)  (sqlda_handle);
    API_ASSERT_PTR(sqlda_ptr);
    stmt_block_ptr->output_sqlda_ptr = sqlda_ptr;

    tuple_handle = stmt_block_ptr -> col_handle;
    tuple_size = stmt_block_ptr -> col_size;
  
    if ((tuple_handle == 0 && tuple_size == 0) || number_cols == 0) {
        retcode = SQL_ERROR;
        pa60PutError( hstmt,
                      API_ODBC_24000, NULL);
        goto lock2_exit;
    }
    tuple_ptr = (UCHAR *) (tuple_handle);
    API_ASSERT_PTR(tuple_ptr);

    api_retcode = pa20SetAttr( sqlda_ptr,
                               &stmt_block_ptr->ird,
                               number_cols,
                               tuple_ptr,
                               tuple_size,
                               CPR_INFO_OUTPUT );

    if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa41apmmker(API_SQLRUNTIME_9803, &dbc_block_ptr->esqblk);
        pa60PutError( hstmt, API_ODBC_S1000,	&dbc_block_ptr->esqblk);
        goto lock_exit;
    }
    /* **** check SQL_MAX_ROWS */
    if (max_select != SQL_MAX_ROWS_DEFAULT) {
        if (fetch_pos >= max_select) {
            retcode = SQL_NO_DATA_FOUND;
            goto lock_exit;
        }
    }
  
    api_retcode = apefetc( &dbc_block_ptr->esqblk,
                           dbc_block_ptr,
                           stmt_block_ptr,
                           SQL_FETCH_NEXT,
                           0 );
    if (api_retcode != API_OK) { 
        retcode = SQL_ERROR;
        pa60PutError( hstmt, API_ODBC_S1001, NULL);
        goto lock_exit;
    }
  
    if (PA_ENV_SQLCODE == PA_ROW_NOT_FOUND) { /* end of data? */
        retcode = SQL_NO_DATA_FOUND;
        goto lock_exit;
    }
  
    if (PA_ENV_SQLCODE != 0) { /* ESQ fetch ok? */
        retcode = SQL_ERROR;
        pa60PutError( hstmt,
                      pa41apmercv(&dbc_block_ptr->esqblk),
                      &dbc_block_ptr->esqblk);
        goto lock_exit;
    }
    stmt_block_ptr -> number_rows = dbc_block_ptr->esqblk.number_rows_modified;
    if (stmt_block_ptr->stmtopt.retrieve_data == SQL_RD_ON) {
        conv_retcode = pa20Move( stmt_block_ptr->ardPtr,
                                 &stmt_block_ptr->ird,
                                 number_cols,
                                 dbc_special_ptr );
        retcode = pa60PutESQError( hstmt, conv_retcode );
    }; /* if */
  
    if ((retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
        && (stmt_block_ptr->stmtopt.retrieve_data == SQL_RD_ON)) {
        RETCODE ret = retcode;
        conv_retcode = pa60MoveLong( dbc_block_ptr,
                                     stmt_block_ptr,
                                     stmt_block_ptr->ardPtr,
                                     &stmt_block_ptr->ird,
                                     0,
                                     number_cols);
        retcode = pa60PutESQError(hstmt, conv_retcode);
        if (retcode == SQL_SUCCESS) {
            retcode = ret;
        }
    }
	  
    if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
        stmt_block_ptr -> state = API_STMT_POSITIONED;
        stmt_block_ptr -> fetch_pos += 1;
        if (stmt_block_ptr->ird.header.rowsProcessedPtr != NULL) {
            /* we fetched one row */
            *stmt_block_ptr->ird.header.rowsProcessedPtr = (SQLUINTEGER) 1;
        }; /* if */
    }; /* if */
        
lock_exit:

    pa20Unset( &stmt_block_ptr->ird, number_cols );

lock2_exit:
  
    PA09LEAVEASYNCFUNCTION();

no_lock_exit:

    API_TRACE(API_TR_EXIT,PA10_FN_SQLFETCH,0);
    API_TRACE(API_TR_RETCODE,"retcode",&retcode);

    return(retcode);
} /* SQLFetch */


/* ODBC 3.0 */
ODBC_PROC(SQLFetchScroll, (SQLHSTMT     hstmt,
                           SQLSMALLINT  orientation,
                           SQLROWOFFSET offset),
          (hstmt, orientation, offset))
{
    RETCODE    retcode = SQL_SUCCESS;
    tpa20Desc *ard_ptr;
    tpa60Stmt *stmt_block_ptr;
    SQLROWOFFSET   fetchOffset;
    
    API_TRACE( API_TR_ENTRY, PA10_FN_SQLFETCHSCROLL, 0);
    API_TRACE( API_TR_HANDLE, "hstmt", &hstmt);
    API_TRACE( API_TR_SWORD, "orientation", &orientation);
    API_TRACE( API_TR_SDWORD, "offset", &offset);

    if (pa60VerifyStmt( hstmt ) != API_OK) { /* hstmt valid? */
        retcode = SQL_INVALID_HANDLE;
    } else {
        stmt_block_ptr = (tpa60Stmt*) hstmt;

        ard_ptr = pa60GetARD( stmt_block_ptr );
        fetchOffset = offset;
        if (orientation == SQL_FETCH_BOOKMARK) {
            if (stmt_block_ptr->stmtopt.fetchBookmarkPtr != NULL) {
                fetchOffset +=
                    *((SDWORD*)stmt_block_ptr->stmtopt.fetchBookmarkPtr);
            } else {
                /* invalid bookmark value */
                retcode = SQL_ERROR;
                pa60PutError( hstmt, API_ODBC_HY111, NULL );
            }; /* else */
        }; /* if */
        if (retcode == SQL_SUCCESS) {
            SQLROWSETSIZE row = 0, *prow = NULL;

            if (ard_ptr->header.rowsProcessedPtr != NULL)
                {
                row = (SQLROWSETSIZE) *ard_ptr->header.rowsProcessedPtr;
                prow = &row;
                }
                
            retcode = CALL_ODBC( SQLExtendedFetch,
                                 ( hstmt,
                                   orientation,
                                   fetchOffset,
                                   prow,
                                   ard_ptr->header.arrayStatusPtr ) );

            if (ard_ptr->header.rowsProcessedPtr != NULL)
                *ard_ptr->header.rowsProcessedPtr = (SQLUINTEGER) row;
            
        }; /* if */
#if 0        
        if (orientation == SQL_FETCH_BOOKMARK
            && offset != 0) {
            retcode = SQL_SUCCESS_WITH_INFO;
            pa60PutError( hstmt, API_ODBC_01S10, NULL );
            /* Attempt to fetch by a bookmark offset, offset value ignored */
        }; /* if */
#endif        
    }; /* else */
    
    API_TRACE( API_TR_EXIT, PA10_FN_SQLFETCHSCROLL, 0);
    API_TRACE( API_TR_RETCODE,"retcode",&retcode);

    return(retcode);
} /* SQLFetchScroll */


API_RETCODE pa10PutLongData ( tpa41ESQBlock  *api_cb_ptr,
                              tpa40DBC       *api_dbc_ptr,
                              tpa60Stmt      *api_stmt_ptr,
                              tpa20Desc      *appl_desc_ptr,
                              tpa20Desc      *impl_desc_ptr )
{
    sqldatype       *sqlda_ptr;
    sqlcatype       *sqlcap;
    SWORD            sqln, varno, col;
    tpa21DescRecord *appl_desc_rec_ptr;
    tpa21DescRecord *impl_desc_rec_ptr;
    UCHAR           *parsid_ptr;
    API_RETCODE      retcode, conv_retcode;
    BOOLEAN          firstlong = TRUE;
    BOOLEAN          firstpartmoved = TRUE;

    API_TRACE(API_TR_ENTRY, "pa10PutLongData",0);
    API_TRACE(API_TR_SWORD, "dbno",&api_dbc_ptr->dbno);
    retcode = API_OK;
    sqlda_ptr = api_stmt_ptr->input_sqlda_ptr;
    parsid_ptr = api_stmt_ptr->stmt_parsid;
    API_TRACE( API_TR_SWORD, "sqln", &sqlda_ptr->sqln );
    sqln   = sqlda_ptr->sqln;
    sqlcap = &api_cb_ptr->sqlca;
    varno  = 0;
    /* ignore the first column */
    for (col=1; col <= sqln; col++) {
        appl_desc_rec_ptr = pa20GetRecord( appl_desc_ptr, col );
        impl_desc_rec_ptr = pa20GetRecord( impl_desc_ptr, col );
        API_ASSERT_PTR( appl_desc_rec_ptr );
        API_ASSERT_PTR( impl_desc_rec_ptr );
        if ( impl_desc_rec_ptr->esqIO == CPR_INFO_OUTPUT)
            continue;
        if (apgislong( impl_desc_rec_ptr->type )) {
            if ( impl_desc_rec_ptr->isNull == API_TRUE)
                continue;
            else {
                if (impl_desc_rec_ptr->convRetcode == API_TRUNCATE) {
                    varno = (SWORD) (col-1);
                }
                else {
                    varno = (SWORD) col;
                    col++;
                    firstlong = FALSE;
                }
                break;
            }
        }
    }
    for (; col <= sqln && api_cb_ptr -> esq_sql_code == PA_OK; col++) {
        if (!firstlong)
            firstpartmoved = FALSE;
        else
            firstlong = FALSE;
        appl_desc_rec_ptr = pa20GetRecord( appl_desc_ptr, col );
        impl_desc_rec_ptr = pa20GetRecord( impl_desc_ptr, col );
        API_ASSERT_PTR( appl_desc_rec_ptr );
        API_ASSERT_PTR( impl_desc_rec_ptr );
        if ( apgislong( impl_desc_rec_ptr->type )) {
            SQLLEN *pcbValue, cbValue;
            UCHAR  *rgbValue;
            if ( impl_desc_rec_ptr->isNull == API_TRUE)
                continue;
            pcbValue = appl_desc_rec_ptr->octetLengthPtr;
            rgbValue = appl_desc_rec_ptr->dataPtr;
            appl_desc_rec_ptr->octetLengthPtr = &cbValue;
            if  ( (pcbValue && *pcbValue == SQL_NTS) || (!pcbValue)) {
              /* http://pts:1080/webpts?wptsdetail=yes&ErrorType=0&ErrorID=1132181 */
              if (appl_desc_rec_ptr->type == SQL_C_WCHAR)
                cbValue = (SDWORD) sp81UCS2strlen ((tsp81_UCS2Char*) rgbValue) * sizeof(SQLWCHAR);
              else
                cbValue = (SDWORD) API_STRLEN(rgbValue);
            }
            else
                cbValue = *pcbValue;
            /* 	cbValue = (pcbValue) ? *pcbValue : desc_rec_ptr->cbValue; */
            for(;;) {
                if (impl_desc_rec_ptr->convRetcode == API_TRUNCATE) {	   
                    UDWORD moved_len;
                    if (firstpartmoved) {
                        moved_len = impl_desc_rec_ptr -> movedLen;
                        API_TRACE( API_TR_UDWORD, "moved_len", &moved_len );
                        appl_desc_rec_ptr->dataPtr
                            += impl_desc_rec_ptr -> movedLen;
                        cbValue -= impl_desc_rec_ptr -> movedLen;
                        impl_desc_rec_ptr -> movedLen = 0;	      
                        conv_retcode = pa20PutRec( appl_desc_rec_ptr,
                                                   impl_desc_rec_ptr,  /* PTS 1122478 */
                                                   api_stmt_ptr->stmtopt.sqlmode );
                    }
                    firstpartmoved = TRUE;
                }
                varno = (SWORD) col;
                API_TRACE(API_TR_SWORD, "varno", &varno);
                API_TRACE(API_TR_MSG, "p10putlongdata", 0);
                p10putlongdata( &api_cb_ptr->sqlca,
				api_dbc_ptr->ConDesc->ga,
                                &api_dbc_ptr->dbno,
                                &varno,
                                sqlda_ptr,
                                parsid_ptr);
                API_TRACE( API_TR_SWORD, "varno", &varno);
                apereconn( api_cb_ptr, api_dbc_ptr);
                aperetg ( api_cb_ptr);
                if (api_cb_ptr -> esq_sql_code != PA_OK ) {
                    /* putval failed PTS 1103215 */
                    break;
                }; /* if */
                if ( impl_desc_rec_ptr->convRetcode == API_TRUNCATE )
                    continue;
                else 
                    break;
            }; /* for */
            appl_desc_rec_ptr->octetLengthPtr = pcbValue;
            appl_desc_rec_ptr->dataPtr = rgbValue;
        }; /* if apgislong */
    }; /* for col */
    if (varno > 0 && api_cb_ptr -> esq_sql_code == PA_OK) {
        sqlda_ptr->sqlvar[varno-1].collength = 0;;     
        API_TRACE(API_TR_SWORD, "varno", &varno);
        API_TRACE(API_TR_MSG, "p10putlongdata last", 0);
        p10putlongdata( &api_cb_ptr->sqlca,
			api_dbc_ptr->ConDesc->ga,
                        &api_dbc_ptr->dbno,
                        &varno,
                        sqlda_ptr,
                        parsid_ptr);
        API_TRACE(API_TR_SWORD, "varno", &varno);
        apereconn(api_cb_ptr, api_dbc_ptr);
        aperetg (api_cb_ptr);
    }
    API_TRACE(API_TR_EXIT, "pa10PutLongData", 0);   
    API_TRACE(API_TR_API_RETCODE, "retcode", &retcode);
  
    return (retcode);
} /* pa10PutLongData */


RETCODE pa10GetADBSParameter( SQLHSTMT hstmt )
{
    tpa40DBC    *dbc_block_ptr;
    tpa60Stmt   *stmt_block_ptr;
    RETCODE      retcode=SQL_SUCCESS;
    API_RETCODE  api_retcode, conv_retcode=API_OK;
    struct       tpr_sqlloop looprec;
    UCHAR       *parm_ptr=NULL;
    
    API_TRACE(API_TR_ENTRY, "pa10GetADBSParameter", 0);   
    stmt_block_ptr = (tpa60Stmt *)  (hstmt);
    if (stmt_block_ptr->number_parms > 0) {
        parm_ptr = (UCHAR*) (stmt_block_ptr -> parm_handle);
        api_retcode = pa20SetAttr( stmt_block_ptr->input_sqlda_ptr,
                                   &stmt_block_ptr->ipd,
                                   stmt_block_ptr->number_parms,
                                   parm_ptr,
                                   stmt_block_ptr->parm_size,
                                   CPR_INFO_OUTPUT);
        if (api_retcode != API_OK) {
            retcode = SQL_ERROR;
        } 
        else {
            dbc_block_ptr = (tpa40DBC*)  (stmt_block_ptr->parent_hdbc);
            p11initlooprec ( &looprec);
            pr04LongInitLD (&dbc_block_ptr->esqblk.sqlca,
                         (sqlxatype*) dbc_block_ptr->esqblk.sqlca.sqlcxap );
            p04sqldout( &dbc_block_ptr->esqblk.sqlca,
                        dbc_block_ptr->esqblk.sqlca.sqlcxap,
                        stmt_block_ptr->input_sqlda_ptr,
                        &looprec );
            api_retcode = pa20Move( stmt_block_ptr->apdPtr,
                                    &stmt_block_ptr->ipd,
                                    stmt_block_ptr->number_parms,
                                    &stmt_block_ptr -> dbc_special );
            if (api_retcode > conv_retcode || api_retcode == API_NOT_OK) 
                retcode = pa60PutESQError( hstmt, api_retcode );
            if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
                RETCODE ret = retcode;
                conv_retcode = pa60MoveLong( dbc_block_ptr,
                                             stmt_block_ptr,
                                             stmt_block_ptr->apdPtr,
                                             &stmt_block_ptr->ipd,
                                             0,
                                             stmt_block_ptr->number_parms );
                retcode = pa60PutESQError( hstmt, conv_retcode );
                if (retcode == SQL_SUCCESS) {
                    retcode = ret;
                }
            }
        }
    }
    API_TRACE(API_TR_EXIT, "pa10GetADBSParameter", 0);   
    API_TRACE(API_TR_RETCODE, "retcode", &retcode);   
    return(retcode);
} /* pa10GetADBSParameter */


extern FCALL p03find_part( sqlratype  *sqlrap,
                           char        part_kind,
                           tsp1_part **part_ptr);

API_RETCODE pa10ShortFieldParamGet( tpa40DBC  *dbc_block_ptr,
                                    tpa60Stmt *stmt_block_ptr )
{
    tsp1_part *part;
    API_RETCODE api_retcode;
    API_TRACE(API_TR_ENTRY, "pa10ShortFieldParamGet", 0);   
    p03find_part (dbc_block_ptr->esqblk.sqlca.sqlrap, sp1pk_shortinfo, &part);
    if (part) {
        api_retcode=API_OK;
        dbc_block_ptr->esqblk.sqlca.sqlcode = 0;
        dbc_block_ptr->esqblk.sqlca.sqlemp->ereturncode = 0;
        dbc_block_ptr->esqblk.sqlca.sqlemp->etextlen = 0;
        p11shortfieldparameterput( &dbc_block_ptr->esqblk.sqlca,
                                   dbc_block_ptr
                                   ->esqblk.sqlca.sqlgap
                                   ->gaentry[dbc_block_ptr->dbno-1],
                                   stmt_block_ptr->input_sqlda_ptr,
                                   TRUE);
        aperetg (&dbc_block_ptr->esqblk);
        if (PA_ENV_SQLCODE == PA_ERR_TOO_MANY_HOSTVAR) {
            pa01vfwtrace( &dbc_block_ptr->esqblk, (UCHAR*)
                          "TREATING ABOVE ERROR AS WARNING (RESIZE SQLMAX).");
            dbc_block_ptr->esqblk.sqlca.sqlcode = 0;
            api_retcode=API_TRUNCATE;
        }
    }
    else
        api_retcode=API_NO_DATA_FOUND;
    API_TRACE(API_TR_EXIT, "pa10ShortFieldParamGet", 0);   
    API_TRACE(API_TR_API_RETCODE, "api_retcode", &api_retcode);   

    return(api_retcode);
} /* pa10ShortFieldParamGet */


void pa10eNumberOfRows( SQLHSTMT       hstmt,
                        tpa60Stmt     *stmt_block_ptr, 
                        tpa41ESQBlock *esqblk_ptr,
                        RETCODE       *retcode)
{
    SQLUINTEGER odbcVersion = SQL_OV_ODBC3;     /* PTS 1111632 */

    API_TRACE(API_TR_ENTRY, "pa10eNumberOfRows", 0);   

    pa10GetODBCVersion (SQL_HANDLE_STMT, hstmt, &odbcVersion);
    
    if (odbcVersion == SQL_OV_ODBC2) {
        switch(stmt_block_ptr->stmt_function_code) {
        case (csp1_insert_fc) :
        case (csp1_update_fc) :
        case (csp1_delete_fc) : {
          if (stmt_block_ptr->number_rows == 0) {
              pa60PutError( hstmt, API_ODBC_01S03, esqblk_ptr);
              if (*retcode == SQL_SUCCESS) 
                  *retcode = SQL_SUCCESS_WITH_INFO;
          }
          else
              if (stmt_block_ptr->number_rows > 1
                  || stmt_block_ptr->number_rows < 0) {
                  pa60PutError( hstmt, API_ODBC_01S04, esqblk_ptr);      
                  if (*retcode == SQL_SUCCESS) 
                      *retcode = SQL_SUCCESS_WITH_INFO;
              }
        }
        break;
        }
    }
    else {  /* ODBC3, does not distinguish: 01S03,04 -> 01001 */
        switch(stmt_block_ptr->stmt_function_code) {
        case (csp1_insert_fc) :
        case (csp1_update_fc) :
        case (csp1_delete_fc) :
          if (stmt_block_ptr->number_rows != 1) {
            pa60PutError( hstmt, API_ODBC_01001, esqblk_ptr);
            if (*retcode == SQL_SUCCESS) 
                *retcode = SQL_SUCCESS_WITH_INFO;
        }
    }
    }
    API_TRACE(API_TR_EXIT, "pa10eNumberOfRows", 0);   
} /* pa10eNumberOfRows */


int pa10ProcessParseResult (tpa40DBC *dbc_block_ptr, tpa60Stmt *stmt_block_ptr)
{
    RETCODE retcode=SQL_SUCCESS;
    API_RETCODE api_retcode;
    UWORD number_parms;
    UWORD number_cols;
    UWORD sqlda_parms;
    UWORD sqlda_cols;
    UDWORD tuple_size;
    API_HANDLE tuple_handle;
    tpa62DBCSpecial *dbc_special_ptr = &stmt_block_ptr -> dbc_special;
    tpr05_String    *stmt_str_ptr = (tpr05_String*) (stmt_block_ptr->stmt_str_handle);
    UCHAR           *parsid_ptr = stmt_block_ptr -> stmt_parsid;

    SWORD newparse = TRUE;
    tpr05_String *SqlStmt = NULL;
    SQLHSTMT hstmt = (SQLHSTMT) stmt_block_ptr;

    /* calculate number of parameters */
    sqlda_parms = (UWORD)stmt_block_ptr->input_sqlda_ptr -> sqlmax;
    
    number_parms = pa70NumParam( stmt_block_ptr->input_sqlda_ptr );
    stmt_block_ptr -> number_parms = number_parms;
    
    /* calculate number of columns */
    sqlda_cols = (UWORD) stmt_block_ptr->output_sqlda_ptr->sqlmax;
    if (sqlda_cols > (UWORD) stmt_block_ptr->output_sqlda_ptr->sqln) {
      number_cols = pa70NumCol( stmt_block_ptr->output_sqlda_ptr );
    }
    else
      number_cols = stmt_block_ptr->output_sqlda_ptr -> sqln;
    stmt_block_ptr -> number_cols = number_cols;
    
    API_TRACE(API_TR_UWORD,"number_parms",&number_parms);
    API_TRACE(API_TR_UWORD,"sqlda_parms",&sqlda_parms);
    API_TRACE(API_TR_UWORD,"number_cols",&number_cols);
    API_TRACE(API_TR_UWORD,"sqlda_cols",&sqlda_cols);
    /* free to check sqlda sizes  */
    /* verify size of input_sqlda */
    /* and output_sqlda           */
    if (number_parms > sqlda_parms) { /* sqlda too small? */
      /* free and re-allocate */
      api_retcode =
        pa70FreeSQLDA( stmt_block_ptr -> input_sqlda_handle );
      if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa60PutError( hstmt,
                      API_ODBC_S1000, NULL); /* general error */
        goto exit_1_lock;
      }
      api_retcode =
        pa70AllocSQLDA( &(stmt_block_ptr -> input_sqlda_handle),
                        number_parms );
      if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa60PutError( hstmt, API_ODBC_S1001, NULL);
        /* allocation error */
        goto exit_1_lock;
      }
    }
    if (number_cols > sqlda_cols) { /* sqlda too small? */
      /* free and re-allocate */
      api_retcode =
        pa70FreeSQLDA( stmt_block_ptr -> output_sqlda_handle );
      if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa60PutError( hstmt,
                      API_ODBC_S1000, NULL); /* general error */
        goto exit_1_lock;
      }
      api_retcode =
        pa70AllocSQLDA( &(stmt_block_ptr->output_sqlda_handle),
                        number_cols );
      if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa60PutError( hstmt,
                      API_ODBC_S1001, NULL); /* allocation error */
        goto exit_1_lock;
      }
    }				  /* re-lock SQLDAs */
    stmt_block_ptr->input_sqlda_ptr = (sqldatype *)
      (stmt_block_ptr->input_sqlda_handle);
    API_ASSERT_PTR(stmt_block_ptr->input_sqlda_ptr);
    stmt_block_ptr->output_sqlda_ptr = (sqldatype *)
      (stmt_block_ptr->output_sqlda_handle);
    API_ASSERT_PTR(stmt_block_ptr->output_sqlda_ptr);

    if ((number_parms > sqlda_parms) ||
        (number_cols > sqlda_cols) ) { /* did we reallocated? */
      if (number_parms > sqlda_parms) {
        if(dbc_special_ptr->order_type == API_CMD_EXECUTE) {
          pa10ShortFieldParamGet(dbc_block_ptr, stmt_block_ptr);
        }
        else {
          apedrprs( &dbc_block_ptr->esqblk,
                    parsid_ptr,
                    dbc_block_ptr,
                    stmt_block_ptr);
          if (PA_ENV_SQLCODE != PA_OK) { /* DROP PARSID ok? */
            retcode = SQL_ERROR;
            pa60PutError( hstmt,
                          pa41apmercv(&dbc_block_ptr->esqblk),
                          &dbc_block_ptr->esqblk);
            goto exit_4_lock;
          }
          if (apeprep( &dbc_block_ptr->esqblk,
                       stmt_str_ptr,
                       parsid_ptr,
                       dbc_block_ptr,
                       stmt_block_ptr) != API_OK) {
            /* ESQ prepare function ok? */
            retcode = SQL_ERROR;
            pa60PutError( hstmt, API_ODBC_S1000, NULL);
            /* general error */
            goto exit_4_lock;
          }
          if (PA_ENV_SQLCODE != PA_OK) { /* ESQ prepare ok? */
            retcode = SQL_ERROR;
            pa60PutError( hstmt,
                          pa41apmercv(&dbc_block_ptr->esqblk),
                          &dbc_block_ptr->esqblk);
            goto exit_4_lock;
          }
          newparse = TRUE;   
        }
        /* do the DESCRIBE */
      } /* new prepare */
      if ((number_cols > sqlda_cols) || (newparse)) {
        /* did we reallocated? */
        if ( dbc_special_ptr->order_type == API_CMD_DESCRIBE ) {
          api_retcode = apedesc( &dbc_block_ptr->esqblk,
                                 parsid_ptr,
                                 dbc_block_ptr,
                                 stmt_block_ptr );
          if (api_retcode != API_OK) { 
            retcode = SQL_ERROR;
            pa60PutError( hstmt, API_ODBC_S1000, NULL);
            /* general error */		   
            goto exit_4_lock;
          }
          if (PA_ENV_SQLCODE != PA_OK) { /* ESQ prepare ok? */
            retcode = SQL_ERROR;
            pa60PutError( hstmt,
                          pa41apmercv(&dbc_block_ptr->esqblk),
                          &dbc_block_ptr->esqblk);
            goto exit_4_lock;
          }	
        } /* order_type */
      } /* new describe */
      sqlda_parms = stmt_block_ptr->input_sqlda_ptr->sqln;
      sqlda_cols = stmt_block_ptr->output_sqlda_ptr->sqln;
    } /* realloc da's */
    /* resize the attribute block */
    /* areas allocated when the   */
    /* statement was allocated if */
    /* needed                     */

    api_retcode = pa20ReallocRecords( pa60GetARD( stmt_block_ptr ),
                                      number_cols );
    pa20SetCount( pa60GetARD( stmt_block_ptr ), number_cols );
    if (api_retcode != API_OK) {
      retcode = SQL_ERROR;
      pa60PutError( hstmt, API_ODBC_S1001, NULL);
      /* memory allocation failure */
      goto exit_4_lock;
    }; /* if */
    api_retcode = pa20ReallocRecords( &stmt_block_ptr->ird,
                                      number_cols );
    pa20SetCount( &stmt_block_ptr->ird, number_cols );
    if (api_retcode != API_OK) {
      retcode = SQL_ERROR;
      pa60PutError( hstmt, API_ODBC_S1001, NULL);
      /* memory allocation failure */
      goto exit_4_lock;
    }; /* if */            
    api_retcode = pa20ReallocRecords( pa60GetAPD( stmt_block_ptr ),
                                      number_parms );
    pa20SetCount( pa60GetAPD( stmt_block_ptr ), number_parms );
    if (api_retcode != API_OK) {
      retcode = SQL_ERROR;
      pa60PutError( hstmt, API_ODBC_S1001, NULL);
      /* memory allocation failure */
      goto exit_4_lock;
    }; /* if */
    api_retcode = pa20ReallocRecords( &stmt_block_ptr->ipd,
                                      number_parms );
    pa20SetCount( &stmt_block_ptr->ipd, number_parms );
    if (api_retcode != API_OK) {
      retcode = SQL_ERROR;
      pa60PutError( hstmt, API_ODBC_S1001, NULL);
      /* memory allocation failure */
      goto exit_4_lock;
    }; /* if */
    
    if (number_cols > 0) {
      UDWORD odbcVersion = 0;
      pa10GetODBCVersion( SQL_HANDLE_STMT,
                          (SQLHSTMT) stmt_block_ptr,
                          &odbcVersion );
      api_retcode = pa70patch( stmt_block_ptr->output_sqlda_ptr,
                               number_cols,
                               dbc_special_ptr->special,
                               odbcVersion );
      api_retcode =
        pa20PopulateDesc( stmt_block_ptr->output_sqlda_ptr,
                          &stmt_block_ptr->ird,
                          number_cols,
                          &tuple_size,
                          dbc_special_ptr,
                          dbc_block_ptr->unicode_catalog);
      if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa41apmmker( API_SQLRUNTIME_9803, &dbc_block_ptr->esqblk);
        pa60PutError( hstmt,
                      pa41apmercv(&dbc_block_ptr->esqblk),
                      &dbc_block_ptr->esqblk); /* general error */
        goto exit_5_lock;
      }
      if (stmt_block_ptr -> col_size > 0) {
        if (tuple_size > stmt_block_ptr -> col_size) {
          apdfree( stmt_block_ptr -> col_handle );
          stmt_block_ptr -> col_handle = API_NULL_HANDLE;
          stmt_block_ptr -> col_size = 0;
        }
      }
      if (stmt_block_ptr -> col_size == 0) {
        tuple_handle = apdallo( (DWORD) tuple_size);
        if (tuple_handle == 0) {
          retcode = SQL_ERROR;
          pa60PutError( hstmt, API_ODBC_S1001, NULL);
          /* allocation error */
          goto exit_5_lock;
        }
        stmt_block_ptr -> col_size = tuple_size;
        stmt_block_ptr -> col_handle = tuple_handle;       
      }
      api_retcode = pa20AllocLong( &stmt_block_ptr->ird,
                                   number_cols );
      if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa60PutError( hstmt, API_ODBC_S1001, NULL);
        /* allocation error */
        goto exit_5_lock;
      }
    }    
    if (number_parms > 0) {
      api_retcode =
        pa20PopulateDesc( stmt_block_ptr->input_sqlda_ptr,
                          &stmt_block_ptr->ipd,
                          number_parms,
                          &tuple_size,
                          dbc_special_ptr,
                          dbc_block_ptr->unicode_catalog);
      if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa41apmmker( API_SQLRUNTIME_9803,
                     &dbc_block_ptr->esqblk );
        pa60PutError( hstmt,
                      pa41apmercv(&dbc_block_ptr->esqblk),
                      &dbc_block_ptr->esqblk); /* general error */
        goto exit_6_lock;
      }
      if (stmt_block_ptr -> parm_size > 0) {
        if (tuple_size > stmt_block_ptr -> parm_size) {
          apdfree(stmt_block_ptr -> parm_handle);
          stmt_block_ptr -> parm_size = 0;
        }
      }
      if (stmt_block_ptr -> parm_size == 0) {
        tuple_handle = apdallo( (DWORD) tuple_size);
        if (tuple_handle == 0) {
          retcode = SQL_ERROR;
          pa60PutError( hstmt, API_ODBC_S1001, NULL);
          /* allocation error */
          goto exit_6_lock;
        }
        stmt_block_ptr -> parm_size = tuple_size;
        stmt_block_ptr -> parm_handle = tuple_handle;
      }       
      api_retcode = pa20AllocLong( &stmt_block_ptr->ipd,
                                   number_parms );
      if (api_retcode != API_OK) {
        retcode = SQL_ERROR;
        pa60PutError( hstmt, API_ODBC_S1001, NULL);
        /* allocation error */
        goto exit_6_lock;
      }
    }

    return 0;

 exit_1_lock:  return 1;
 exit_4_lock:  return 4;
 exit_5_lock:  return 5;
 exit_6_lock:  return 6;

}

#if defined(WIN32)
void pa10_CallErrorBox (const char *fun,
                        tpa40DBC *dbc_block_ptr, tpa60Stmt *stmt_block_ptr)
{
  static int ignore = 0;
  int r;
  char buffer1[2048], buffer2[2348];

  if (!ignore) {
    tpr05_String *str = stmt_block_ptr->stmt_str_handle;
    tsp00_Uint4 destBytesWritten, srcBytesParsed;

    sp78convertString (sp77encodingAscii, buffer1, sizeof(buffer1),
                       &destBytesWritten,
                       TRUE,
                       str->encodingType, str->rawString,
                       str->cbLen,
                       &srcBytesParsed);

    API_SPRINTF (buffer2, "%s\n%d: %s",
                 buffer1,
                 dbc_block_ptr->esqblk.esq_sql_code,
                 dbc_block_ptr->esqblk.sql_err_text);

    r = MessageBox (NULL, buffer2, "SQLExecDirect",
                    MB_ABORTRETRYIGNORE | MB_ICONSTOP |
                    MB_DEFBUTTON2 | MB_APPLMODAL);

    if (r == IDIGNORE)
      ignore = 1;
    if (r == IDABORT)
      sqlabort();
  }
}
#endif  /* of WIN32 */


#endif   /* of _UNICODE_ODBC */

.CM *-END-* code ----------------------------------------
.SP 2 
***********************************************************
