vxodbc/odbcapi30.cc

   1 /*
   2  * Description: This module contains routines related to ODBC 3.0
   3  *              most of their implementations are temporary
   4  *              and must be rewritten properly.
   5  *              2001/07/23      inoue
   6  */
   7 #include "psqlodbc.h"
   8 #include "misc.h"
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12
  13 #include "environ.h"
  14 #include "connection.h"
  15 #include "statement.h"
  16 #include "pgapifunc.h"
  17
  18 /*      SQLAllocConnect/SQLAllocEnv/SQLAllocStmt -> SQLAllocHandle */
  19 RETCODE SQL_API
  20 SQLAllocHandle(SQLSMALLINT HandleType,
  21                SQLHANDLE InputHandle, SQLHANDLE * OutputHandle)
  22 {
  23     RETCODE ret;
  24     ConnectionClass *conn;
  25     mylog("Start\n");
  26
  27     switch (HandleType)
  28     {
  29     case SQL_HANDLE_ENV:
  30         ret = PGAPI_AllocEnv(OutputHandle);
  31         break;
  32     case SQL_HANDLE_DBC:
  33         ENTER_ENV_CS((EnvironmentClass *) InputHandle);
  34         ret = PGAPI_AllocConnect(InputHandle, OutputHandle);
  35         LEAVE_ENV_CS((EnvironmentClass *) InputHandle);
  36         break;
  37     case SQL_HANDLE_STMT:
  38         ENTER_CONN_CS((ConnectionClass *) InputHandle);
  39         ret = PGAPI_AllocStmt(InputHandle, OutputHandle);
  40         LEAVE_CONN_CS((ConnectionClass *) InputHandle);
  41         break;
  42     case SQL_HANDLE_DESC:
  43         conn = (ConnectionClass *) InputHandle;
  44         ENTER_CONN_CS(conn);
  45         ret = PGAPI_AllocDesc(InputHandle, OutputHandle);
  46         LEAVE_CONN_CS(conn);
  47         inolog("OutputHandle=%p\n", *OutputHandle);
  48         break;
  49     default:
  50         ret = SQL_ERROR;
  51         break;
  52     }
  53     return ret;
  54 }
  55
  56 /*      SQLBindParameter/SQLSetParam -> SQLBindParam */
  57 RETCODE SQL_API
  58 SQLBindParam(HSTMT StatementHandle,
  59              SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
  60              SQLSMALLINT ParameterType, SQLULEN LengthPrecision,
  61              SQLSMALLINT ParameterScale, PTR ParameterValue,
  62              SQLLEN * StrLen_or_Ind)
  63 {
  64     RETCODE ret;
  65     StatementClass *stmt = (StatementClass *) StatementHandle;
  66     int BufferLength = 512;     /* Is it OK ? */
  67     mylog("Start\n");
  68
  69     ENTER_STMT_CS(stmt);
  70     SC_clear_error(stmt);
  71     StartRollbackState(stmt);
  72     ret =
  73         PGAPI_BindParameter(StatementHandle, ParameterNumber,
  74                             SQL_PARAM_INPUT, ValueType, ParameterType,
  75                             LengthPrecision, ParameterScale,
  76                             ParameterValue, BufferLength,
  77                             StrLen_or_Ind);
  78     ret = DiscardStatementSvp(stmt, ret, FALSE);
  79     LEAVE_STMT_CS(stmt);
  80     return ret;
  81 }
  82
  83 /*      New function */
  84 RETCODE SQL_API SQLCloseCursor(HSTMT StatementHandle)
  85 {
  86     StatementClass *stmt = (StatementClass *) StatementHandle;
  87     RETCODE ret;
  88     mylog("Start\n");
  89
  90     ENTER_STMT_CS(stmt);
  91     SC_clear_error(stmt);
  92     StartRollbackState(stmt);
  93     ret = PGAPI_FreeStmt(StatementHandle, SQL_CLOSE);
  94     ret = DiscardStatementSvp(stmt, ret, FALSE);
  95     LEAVE_STMT_CS(stmt);
  96     return ret;
  97 }
  98
  99 /*      SQLColAttributes -> SQLColAttribute */
 100 SQLRETURN SQL_API
 101 SQLColAttribute(SQLHSTMT StatementHandle,
 102                 SQLUSMALLINT ColumnNumber,
 103                 SQLUSMALLINT FieldIdentifier,
 104                 SQLPOINTER CharacterAttribute,
 105                 SQLSMALLINT BufferLength, SQLSMALLINT * StringLength,
 106 #if defined(_WIN64)
 107                 SQLLEN * NumericAttribute
 108 #elif defined(WITH_UNIXODBC) || defined(WIN32)
 109                 SQLPOINTER NumericAttribute
 110 #else
 111                 SQLLEN * NumericAttribute
 112 #endif
 113     )
 114 {
 115     RETCODE ret;
 116     StatementClass *stmt = (StatementClass *) StatementHandle;
 117     mylog("Start\n");
 118
 119     ENTER_STMT_CS(stmt);
 120     SC_clear_error(stmt);
 121     StartRollbackState(stmt);
 122     ret = PGAPI_ColAttributes(StatementHandle, ColumnNumber,
 123                               FieldIdentifier, CharacterAttribute,
 124                               BufferLength, StringLength,
 125                               (SQLINTEGER *)NumericAttribute);
 126     ret = DiscardStatementSvp(stmt, ret, FALSE);
 127     LEAVE_STMT_CS(stmt);
 128     return ret;
 129 }
 130
 131 /*      new function */
 132 RETCODE SQL_API
 133 SQLCopyDesc(SQLHDESC SourceDescHandle, SQLHDESC TargetDescHandle)
 134 {
 135     RETCODE ret;
 136     mylog("Start\n");
 137
 138     ret = PGAPI_CopyDesc(SourceDescHandle, TargetDescHandle);
 139     return ret;
 140 }
 141
 142 /*      SQLTransact -> SQLEndTran */
 143 RETCODE SQL_API
 144 SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle,
 145            SQLSMALLINT CompletionType)
 146 {
 147     RETCODE ret;
 148     mylog("Start\n");
 149
 150     switch (HandleType)
 151     {
 152     case SQL_HANDLE_ENV:
 153         ENTER_ENV_CS((EnvironmentClass *) Handle);
 154         ret = PGAPI_Transact(Handle, SQL_NULL_HDBC, CompletionType);
 155         LEAVE_ENV_CS((EnvironmentClass *) Handle);
 156         break;
 157     case SQL_HANDLE_DBC:
 158         ENTER_CONN_CS((ConnectionClass *) Handle);
 159         CC_clear_error((ConnectionClass *) Handle);
 160         ret = PGAPI_Transact(SQL_NULL_HENV, Handle, CompletionType);
 161         LEAVE_CONN_CS((ConnectionClass *) Handle);
 162         break;
 163     default:
 164         ret = SQL_ERROR;
 165         break;
 166     }
 167     return ret;
 168 }
 169
 170 /*      SQLExtendedFetch -> SQLFetchScroll */
 171 RETCODE SQL_API
 172 SQLFetchScroll(HSTMT StatementHandle,
 173                SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
 174 {
 175     CSTR func = "SQLFetchScroll";
 176     StatementClass *stmt = (StatementClass *) StatementHandle;
 177     RETCODE ret = SQL_SUCCESS;
 178     IRDFields *irdopts = SC_get_IRDF(stmt);
 179     SQLUSMALLINT *rowStatusArray = irdopts->rowStatusArray;
 180     SQLUINTEGER *pcRow = irdopts->rowsFetched, bkmarkoff = 0;
 181     mylog("Start\n");
 182
 183     mylog("%d,%d\n", FetchOrientation, FetchOffset);
 184     ENTER_STMT_CS(stmt);
 185     SC_clear_error(stmt);
 186     StartRollbackState(stmt);
 187     if (FetchOrientation == SQL_FETCH_BOOKMARK)
 188     {
 189         if (stmt->options.bookmark_ptr)
 190         {
 191             bkmarkoff = FetchOffset;
 192             FetchOffset = *((Int4 *) stmt->options.bookmark_ptr);
 193             mylog("bookmark=%u FetchOffset = %d\n", FetchOffset,
 194                   bkmarkoff);
 195         } else
 196         {
 197             SC_set_error(stmt, STMT_SEQUENCE_ERROR,
 198                          "Bookmark isn't specifed yet", func);
 199             ret = SQL_ERROR;
 200         }
 201     }
 202     if (SQL_SUCCESS == ret)
 203     {
 204         ARDFields *opts = SC_get_ARDF(stmt);
 205
 206         ret =
 207             PGAPI_ExtendedFetch(StatementHandle, FetchOrientation,
 208                                 FetchOffset, pcRow, rowStatusArray,
 209                                 bkmarkoff, opts->size_of_rowset);
 210         stmt->transition_status = 6;
 211     }
 212     ret = DiscardStatementSvp(stmt, ret, FALSE);
 213     LEAVE_STMT_CS(stmt);
 214     if (ret != SQL_SUCCESS)
 215         mylog("%s return = %d\n", func, ret);
 216     return ret;
 217 }
 218
 219 /*      SQLFree(Connect/Env/Stmt) -> SQLFreeHandle */
 220 RETCODE SQL_API SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
 221 {
 222     RETCODE ret;
 223     mylog("Start\n");
 224     switch (HandleType)
 225     {
 226     case SQL_HANDLE_ENV:
 227         ret = PGAPI_FreeEnv(Handle);
 228         break;
 229     case SQL_HANDLE_DBC:
 230         ret = PGAPI_FreeConnect(Handle);
 231         break;
 232     case SQL_HANDLE_STMT:
 233         ret = PGAPI_FreeStmt(Handle, SQL_DROP);
 234         break;
 235     case SQL_HANDLE_DESC:
 236         ret = PGAPI_FreeDesc(Handle);
 237         break;
 238     default:
 239         ret = SQL_ERROR;
 240         break;
 241     }
 242     return ret;
 243 }
 244
 245 /*      new function */
 246 RETCODE SQL_API
 247 SQLGetDescField(SQLHDESC DescriptorHandle,
 248                 SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
 249                 PTR Value, SQLINTEGER BufferLength,
 250                 SQLINTEGER * StringLength)
 251 {
 252     RETCODE ret;
 253     mylog("Start\n");
 254
 255     ret =
 256         PGAPI_GetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
 257                            Value, BufferLength, StringLength);
 258     return ret;
 259 }
 260
 261 /*      new function */
 262 RETCODE SQL_API
 263 SQLGetDescRec(SQLHDESC DescriptorHandle,
 264               SQLSMALLINT RecNumber, SQLCHAR * Name,
 265               SQLSMALLINT BufferLength, SQLSMALLINT * StringLength,
 266               SQLSMALLINT * Type, SQLSMALLINT * SubType,
 267               SQLLEN * Length, SQLSMALLINT * Precision,
 268               SQLSMALLINT * Scale, SQLSMALLINT * Nullable)
 269 {
 270     mylog("Start\n");
 271     mylog("Not implemented!\n");
 272     return SQL_ERROR;
 273 }
 274
 275 /*      new function */
 276 RETCODE SQL_API
 277 SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
 278                 SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
 279                 PTR DiagInfo, SQLSMALLINT BufferLength,
 280                 SQLSMALLINT * StringLength)
 281 {
 282     RETCODE ret;
 283     mylog("Start\n");
 284
 285     mylog("Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n",
 286           HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo,
 287           BufferLength);
 288     ret =
 289         PGAPI_GetDiagField(HandleType, Handle, RecNumber,
 290                            DiagIdentifier, DiagInfo, BufferLength,
 291                            StringLength);
 292     return ret;
 293 }
 294
 295 /*      SQLError -> SQLDiagRec */
 296 RETCODE SQL_API
 297 SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
 298               SQLSMALLINT RecNumber, SQLCHAR * Sqlstate,
 299               SQLINTEGER * NativeError, SQLCHAR * MessageText,
 300               SQLSMALLINT BufferLength, SQLSMALLINT * TextLength)
 301 {
 302     RETCODE ret;
 303     mylog("Start\n");
 304
 305     ret = PGAPI_GetDiagRec(HandleType, Handle, RecNumber, Sqlstate,
 306                            NativeError, MessageText, BufferLength,
 307                            TextLength);
 308     return ret;
 309 }
 310
 311 /*      new function */
 312 RETCODE SQL_API
 313 SQLGetEnvAttr(HENV EnvironmentHandle,
 314               SQLINTEGER Attribute, PTR Value,
 315               SQLINTEGER BufferLength, SQLINTEGER * StringLength)
 316 {
 317     RETCODE ret;
 318     EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;
 319     mylog("Start\n");
 320
 321     ENTER_ENV_CS(env);
 322     ret = SQL_SUCCESS;
 323     switch (Attribute)
 324     {
 325     case SQL_ATTR_CONNECTION_POOLING:
 326         *((unsigned int *) Value) =
 327             EN_is_pooling(env) ? SQL_CP_ONE_PER_DRIVER : SQL_CP_OFF;
 328         break;
 329     case SQL_ATTR_CP_MATCH:
 330         *((unsigned int *) Value) = SQL_CP_RELAXED_MATCH;
 331         break;
 332     case SQL_ATTR_ODBC_VERSION:
 333         *((unsigned int *) Value) =
 334             EN_is_odbc2(env) ? SQL_OV_ODBC2 : SQL_OV_ODBC3;
 335         break;
 336     case SQL_ATTR_OUTPUT_NTS:
 337         *((unsigned int *) Value) = SQL_TRUE;
 338         break;
 339     default:
 340         env->errornumber = CONN_INVALID_ARGUMENT_NO;
 341         ret = SQL_ERROR;
 342     }
 343     LEAVE_ENV_CS(env);
 344     return ret;
 345 }
 346
 347 /*      SQLGetConnectOption -> SQLGetconnectAttr */
 348 RETCODE SQL_API
 349 SQLGetConnectAttr(HDBC ConnectionHandle,
 350                   SQLINTEGER Attribute, PTR Value,
 351                   SQLINTEGER BufferLength, SQLINTEGER * StringLength)
 352 {
 353     RETCODE ret;
 354     mylog("Start\n");
 355
 356     ENTER_CONN_CS((ConnectionClass *) ConnectionHandle);
 357     CC_clear_error((ConnectionClass *) ConnectionHandle);
 358     ret = PGAPI_GetConnectAttr(ConnectionHandle, Attribute, Value,
 359                                BufferLength, StringLength);
 360     LEAVE_CONN_CS((ConnectionClass *) ConnectionHandle);
 361     return ret;
 362 }
 363
 364 /*      SQLGetStmtOption -> SQLGetStmtAttr */
 365 RETCODE SQL_API
 366 SQLGetStmtAttr(HSTMT StatementHandle,
 367                SQLINTEGER Attribute, PTR Value,
 368                SQLINTEGER BufferLength, SQLINTEGER * StringLength)
 369 {
 370     RETCODE ret;
 371     StatementClass *stmt = (StatementClass *) StatementHandle;
 372     mylog("Start\n");
 373
 374     mylog("Handle=%u %d\n", StatementHandle, Attribute);
 375     ENTER_STMT_CS(stmt);
 376     SC_clear_error(stmt);
 377     StartRollbackState(stmt);
 378     ret = PGAPI_GetStmtAttr(StatementHandle, Attribute, Value,
 379                             BufferLength, StringLength);
 380     ret = DiscardStatementSvp(stmt, ret, FALSE);
 381     LEAVE_STMT_CS(stmt);
 382     return ret;
 383 }
 384
 385 /*      SQLSetConnectOption -> SQLSetConnectAttr */
 386 RETCODE SQL_API
 387 SQLSetConnectAttr(HDBC ConnectionHandle,
 388                   SQLINTEGER Attribute, PTR Value,
 389                   SQLINTEGER StringLength)
 390 {
 391     mylog("Start\n");
 392     RETCODE ret;
 393     ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
 394
 395     ENTER_CONN_CS(conn);
 396     CC_clear_error(conn);
 397     ret = PGAPI_SetConnectAttr(ConnectionHandle, Attribute, Value,
 398                                StringLength);
 399     LEAVE_CONN_CS(conn);
 400     return ret;
 401 }
 402
 403 /*      new function */
 404 RETCODE SQL_API
 405 SQLSetDescField(SQLHDESC DescriptorHandle,
 406                 SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
 407                 PTR Value, SQLINTEGER BufferLength)
 408 {
 409     RETCODE ret;
 410
 411     mylog("Start\n");
 412     mylog("h=%p rec=%d field=%d val=%p\n",
 413           DescriptorHandle, RecNumber, FieldIdentifier, Value);
 414     ret =
 415         PGAPI_SetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
 416                            Value, BufferLength);
 417     return ret;
 418 }
 419
 420 /*      new fucntion */
 421 RETCODE SQL_API
 422 SQLSetDescRec(SQLHDESC DescriptorHandle,
 423               SQLSMALLINT RecNumber, SQLSMALLINT Type,
 424               SQLSMALLINT SubType, SQLLEN Length,
 425               SQLSMALLINT Precision, SQLSMALLINT Scale,
 426               PTR Data, SQLLEN * StringLength, SQLLEN * Indicator)
 427 {
 428     mylog("Start\n");
 429     mylog("Not implemented!\n");
 430     return SQL_ERROR;
 431 }
 432
 433 /*      new function */
 434 RETCODE SQL_API
 435 SQLSetEnvAttr(HENV EnvironmentHandle,
 436               SQLINTEGER Attribute, PTR Value, SQLINTEGER StringLength)
 437 {
 438     RETCODE ret;
 439     EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;
 440     mylog("Start\n");
 441
 442     ENTER_ENV_CS(env);
 443     switch (Attribute)
 444     {
 445     case SQL_ATTR_CONNECTION_POOLING:
 446         switch ((ULONG_PTR) Value)
 447         {
 448         case SQL_CP_OFF:
 449             EN_unset_pooling(env);
 450             ret = SQL_SUCCESS;
 451             break;
 452 #if defined(WIN_MULTITHREAD_SUPPORT) || defined(POSIX_MULTITHREAD_SUPPORT)
 453         case SQL_CP_ONE_PER_DRIVER:
 454             EN_set_pooling(env);
 455             ret = SQL_SUCCESS;
 456             break;
 457 #endif                          /* WIN_MULTITHREAD_SUPPORT */
 458         default:
 459             ret = SQL_SUCCESS_WITH_INFO;
 460         }
 461         break;
 462     case SQL_ATTR_CP_MATCH:
 463         /* *((unsigned int *) Value) = SQL_CP_RELAXED_MATCH; */
 464         ret = SQL_SUCCESS;
 465         break;
 466     case SQL_ATTR_ODBC_VERSION:
 467         if (SQL_OV_ODBC2 == CAST_UPTR(SQLUINTEGER, Value))
 468             EN_set_odbc2(env);
 469         else
 470             EN_set_odbc3(env);
 471         ret = SQL_SUCCESS;
 472         break;
 473     case SQL_ATTR_OUTPUT_NTS:
 474         if (SQL_TRUE == CAST_UPTR(SQLUINTEGER, Value))
 475             ret = SQL_SUCCESS;
 476         else
 477             ret = SQL_SUCCESS_WITH_INFO;
 478
 479         break;
 480     default:
 481         env->errornumber = CONN_INVALID_ARGUMENT_NO;
 482         ret = SQL_ERROR;
 483     }
 484     if (SQL_SUCCESS_WITH_INFO == ret)
 485     {
 486         env->errornumber = CONN_OPTION_VALUE_CHANGED;
 487         env->errormsg = "SetEnv changed to ";
 488     }
 489     LEAVE_ENV_CS(env);
 490     return ret;
 491 }
 492
 493 /*      SQLSet(Param/Scroll/Stmt)Option -> SQLSetStmtAttr */
 494 RETCODE SQL_API
 495 SQLSetStmtAttr(HSTMT StatementHandle,
 496                SQLINTEGER Attribute, PTR Value, SQLINTEGER StringLength)
 497 {
 498     StatementClass *stmt = (StatementClass *) StatementHandle;
 499     RETCODE ret;
 500     mylog("Start\n");
 501
 502     mylog("Handle=%p %d,%u\n", StatementHandle, Attribute, Value);
 503     ENTER_STMT_CS(stmt);
 504     SC_clear_error(stmt);
 505     StartRollbackState(stmt);
 506     ret =
 507         PGAPI_SetStmtAttr(StatementHandle, Attribute, Value,
 508                           StringLength);
 509     ret = DiscardStatementSvp(stmt, ret, FALSE);
 510     LEAVE_STMT_CS(stmt);
 511     return ret;
 512 }
 513
 514 #define SQL_FUNC_ESET(pfExists, uwAPI) \
 515                 (*(((UWORD*) (pfExists)) + ((uwAPI) >> 4)) \
 516                         |= (1 << ((uwAPI) & 0x000F)) \
 517                                 )
 518 RETCODE SQL_API
 519 PGAPI_GetFunctions30(HDBC hdbc, SQLUSMALLINT fFunction,
 520                      SQLUSMALLINT FAR * pfExists)
 521 {
 522     ConnectionClass *conn = (ConnectionClass *) hdbc;
 523     ConnInfo *ci = &(conn->connInfo);
 524     mylog("Start\n");
 525
 526     CC_clear_error(conn);
 527     if (fFunction != SQL_API_ODBC3_ALL_FUNCTIONS)
 528         return SQL_ERROR;
 529     memset(pfExists, 0,
 530            sizeof(UWORD) * SQL_API_ODBC3_ALL_FUNCTIONS_SIZE);
 531
 532     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCCONNECT); 1 deprecated */
 533     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCENV); 2 deprecated */
 534     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCSTMT); 3 deprecated */
 535
 536     /*
 537      * for (i = SQL_API_SQLBINDCOL; i <= 23; i++) SQL_FUNC_ESET(pfExists,
 538      * i);
 539      */
 540     SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDCOL);        /* 4 */
 541     SQL_FUNC_ESET(pfExists, SQL_API_SQLCANCEL); /* 5 */
 542     SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLATTRIBUTE);   /* 6 */
 543     SQL_FUNC_ESET(pfExists, SQL_API_SQLCONNECT);        /* 7 */
 544     SQL_FUNC_ESET(pfExists, SQL_API_SQLDESCRIBECOL);    /* 8 */
 545     SQL_FUNC_ESET(pfExists, SQL_API_SQLDISCONNECT);     /* 9 */
 546     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLERROR);  10 deprecated */
 547     SQL_FUNC_ESET(pfExists, SQL_API_SQLEXECDIRECT);     /* 11 */
 548     SQL_FUNC_ESET(pfExists, SQL_API_SQLEXECUTE);        /* 12 */
 549     SQL_FUNC_ESET(pfExists, SQL_API_SQLFETCH);  /* 13 */
 550     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLFREECONNECT); 14 deprecated */
 551     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLFREEENV); 15 deprecated */
 552     SQL_FUNC_ESET(pfExists, SQL_API_SQLFREESTMT);       /* 16 */
 553     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCURSORNAME);  /* 17 */
 554     SQL_FUNC_ESET(pfExists, SQL_API_SQLNUMRESULTCOLS);  /* 18 */
 555     SQL_FUNC_ESET(pfExists, SQL_API_SQLPREPARE);        /* 19 */
 556     SQL_FUNC_ESET(pfExists, SQL_API_SQLROWCOUNT);       /* 20 */
 557     SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCURSORNAME);  /* 21 */
 558     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETPARAM); 22 deprecated */
 559     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLTRANSACT); 23 deprecated */
 560
 561     /*
 562      * for (i = 40; i < SQL_API_SQLEXTENDEDFETCH; i++)
 563      * SQL_FUNC_ESET(pfExists, i);
 564      */
 565     SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLUMNS);        /* 40 */
 566     SQL_FUNC_ESET(pfExists, SQL_API_SQLDRIVERCONNECT);  /* 41 */
 567     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCONNECTOPTION); 42 deprecated */
 568     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDATA);        /* 43 */
 569     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETFUNCTIONS);   /* 44 */
 570     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETINFO);        /* 45 */
 571     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLGETSTMTOPTION); 46 deprecated */
 572     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETTYPEINFO);    /* 47 */
 573     SQL_FUNC_ESET(pfExists, SQL_API_SQLPARAMDATA);      /* 48 */
 574     SQL_FUNC_ESET(pfExists, SQL_API_SQLPUTDATA);        /* 49 */
 575
 576     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCONNECTIONOPTION); 50 deprecated */
 577     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSTMTOPTION); 51 deprecated */
 578     SQL_FUNC_ESET(pfExists, SQL_API_SQLSPECIALCOLUMNS); /* 52 */
 579     SQL_FUNC_ESET(pfExists, SQL_API_SQLSTATISTICS);     /* 53 */
 580     SQL_FUNC_ESET(pfExists, SQL_API_SQLTABLES); /* 54 */
 581     SQL_FUNC_ESET(pfExists, SQL_API_SQLDATASOURCES);    /* 57 */
 582     if (SUPPORT_DESCRIBE_PARAM(ci))
 583         SQL_FUNC_ESET(pfExists, SQL_API_SQLDESCRIBEPARAM);      /* 58 */
 584     SQL_FUNC_ESET(pfExists, SQL_API_SQLEXTENDEDFETCH);  /* 59 deprecated ? */
 585
 586     /*
 587      * for (++i; i < SQL_API_SQLBINDPARAMETER; i++)
 588      * SQL_FUNC_ESET(pfExists, i);
 589      */
 590     SQL_FUNC_ESET(pfExists, SQL_API_SQLFOREIGNKEYS);    /* 60 */
 591     SQL_FUNC_ESET(pfExists, SQL_API_SQLMORERESULTS);    /* 61 */
 592     SQL_FUNC_ESET(pfExists, SQL_API_SQLNATIVESQL);      /* 62 */
 593     SQL_FUNC_ESET(pfExists, SQL_API_SQLNUMPARAMS);      /* 63 */
 594     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLPARAMOPTIONS); 64 deprecated */
 595     SQL_FUNC_ESET(pfExists, SQL_API_SQLPRIMARYKEYS);    /* 65 */
 596     SQL_FUNC_ESET(pfExists, SQL_API_SQLPROCEDURECOLUMNS);       /* 66 */
 597     SQL_FUNC_ESET(pfExists, SQL_API_SQLPROCEDURES);     /* 67 */
 598     SQL_FUNC_ESET(pfExists, SQL_API_SQLSETPOS); /* 68 */
 599     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSCROLLOPTIONS); 69 deprecated */
 600     SQL_FUNC_ESET(pfExists, SQL_API_SQLTABLEPRIVILEGES);        /* 70 */
 601     /* SQL_FUNC_ESET(pfExists, SQL_API_SQLDRIVERS); *//* 71 */
 602     SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDPARAMETER);  /* 72 */
 603
 604     SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCHANDLE);    /* 1001 */
 605     SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDPARAM);      /* 1002 */
 606     SQL_FUNC_ESET(pfExists, SQL_API_SQLCLOSECURSOR);    /* 1003 */
 607     SQL_FUNC_ESET(pfExists, SQL_API_SQLCOPYDESC);       /* 1004 */
 608     SQL_FUNC_ESET(pfExists, SQL_API_SQLENDTRAN);        /* 1005 */
 609     SQL_FUNC_ESET(pfExists, SQL_API_SQLFREEHANDLE);     /* 1006 */
 610     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCONNECTATTR); /* 1007 */
 611     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDESCFIELD);   /* 1008 */
 612     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDIAGFIELD);   /* 1010 minimal implementation */
 613     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDIAGREC);     /* 1011 */
 614     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETENVATTR);     /* 1012 */
 615     SQL_FUNC_ESET(pfExists, SQL_API_SQLGETSTMTATTR);    /* 1014 */
 616     SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCONNECTATTR); /* 1016 */
 617     SQL_FUNC_ESET(pfExists, SQL_API_SQLSETDESCFIELD);   /* 1017 */
 618     SQL_FUNC_ESET(pfExists, SQL_API_SQLSETENVATTR);     /* 1019 */
 619     SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSTMTATTR);    /* 1020 */
 620     SQL_FUNC_ESET(pfExists, SQL_API_SQLFETCHSCROLL);    /* 1021 */
 621     if (0 != (ALLOW_BULK_OPERATIONS & ci->updatable_cursors))
 622         SQL_FUNC_ESET(pfExists, SQL_API_SQLBULKOPERATIONS);     /* 24 */
 623
 624     return SQL_SUCCESS;
 625 }
 626
 627 RETCODE SQL_API SQLBulkOperations(HSTMT hstmt, SQLSMALLINT operation)
 628 {
 629     RETCODE ret;
 630     StatementClass *stmt = (StatementClass *) hstmt;
 631     mylog("Start\n");
 632
 633     ENTER_STMT_CS(stmt);
 634     mylog("Handle=%p %d\n", hstmt, operation);
 635     SC_clear_error(stmt);
 636     StartRollbackState(stmt);
 637     ret = PGAPI_BulkOperations(hstmt, operation);
 638     ret = DiscardStatementSvp(stmt, ret, FALSE);
 639     LEAVE_STMT_CS(stmt);
 640     return ret;
 641 }