src/interfaces/odbc/odbcapi.c

   1 /*-------
   2  * Module:                      odbcapi.c
   3  *
   4  * Description:         This module contains routines related to
   5  *                                      preparing and executing an SQL statement.
   6  *
   7  * Classes:                     n/a
   8  *
   9  * API functions:       SQLAllocConnect, SQLAllocEnv, SQLAllocStmt,
  10                         SQLBindCol, SQLCancel, SQLColumns, SQLConnect,
  11                         SQLDataSources, SQLDescribeCol, SQLDisconnect,
  12                         SQLError, SQLExecDirect, SQLExecute, SQLFetch,
  13                         SQLFreeConnect, SQLFreeEnv, SQLFreeStmt,
  14                         SQLGetConnectOption, SQLGetCursorName, SQLGetData,
  15                         SQLGetFunctions, SQLGetInfo, SQLGetStmtOption,
  16                         SQLGetTypeInfo, SQLNumResultCols, SQLParamData,
  17                         SQLPrepare, SQLPutData, SQLRowCount,
  18                         SQLSetConnectOption, SQLSetCursorName, SQLSetParam,
  19                         SQLSetStmtOption, SQLSpecialColumns, SQLStatistics,
  20                         SQLTables, SQLTransact, SQLColAttributes,
  21                         SQLColumnPrivileges, SQLDescribeParam, SQLExtendedFetch,
  22                         SQLForeignKeys, SQLMoreResults, SQLNativeSql,
  23                         SQLNumParams, SQLParamOptions, SQLPrimaryKeys,
  24                         SQLProcedureColumns, SQLProcedures, SQLSetPos,
  25                         SQLTablePrivileges, SQLBindParameter
  26  *-------
  27  */
  28
  29 #ifdef  WIN32
  30 #define ODBCVER_REP 0x3000
  31 #endif
  32 #include "psqlodbc.h"
  33 #include <stdio.h>
  34 #include <string.h>
  35
  36 #include "pgapifunc.h"
  37 #include "connection.h"
  38 #include "statement.h"
  39
  40 RETCODE         SQL_API
  41 SQLAllocConnect(HENV EnvironmentHandle,
  42                                 HDBC FAR * ConnectionHandle)
  43 {
  44         mylog("[SQLAllocConnect]");
  45         return PGAPI_AllocConnect(EnvironmentHandle, ConnectionHandle);
  46 }
  47
  48 RETCODE         SQL_API
  49 SQLAllocEnv(HENV FAR * EnvironmentHandle)
  50 {
  51         mylog("[SQLAllocEnv]");
  52         return PGAPI_AllocEnv(EnvironmentHandle);
  53 }
  54
  55 RETCODE         SQL_API
  56 SQLAllocStmt(HDBC ConnectionHandle,
  57                          HSTMT *StatementHandle)
  58 {
  59         mylog("[SQLAllocStmt]");
  60         return PGAPI_AllocStmt(ConnectionHandle, StatementHandle);
  61 }
  62
  63 RETCODE         SQL_API
  64 SQLBindCol(HSTMT StatementHandle,
  65                    SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
  66                    PTR TargetValue, SQLINTEGER BufferLength,
  67                    SQLINTEGER *StrLen_or_Ind)
  68 {
  69         mylog("[SQLBindCol]");
  70         return PGAPI_BindCol(StatementHandle, ColumnNumber,
  71                                    TargetType, TargetValue, BufferLength, StrLen_or_Ind);
  72 }
  73
  74 RETCODE         SQL_API
  75 SQLCancel(HSTMT StatementHandle)
  76 {
  77         mylog("[SQLCancel]");
  78         return PGAPI_Cancel(StatementHandle);
  79 }
  80
  81 RETCODE         SQL_API
  82 SQLColumns(HSTMT StatementHandle,
  83                    SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
  84                    SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
  85                    SQLCHAR *TableName, SQLSMALLINT NameLength3,
  86                    SQLCHAR *ColumnName, SQLSMALLINT NameLength4)
  87 {
  88         mylog("[SQLColumns]");
  89         return PGAPI_Columns(StatementHandle, CatalogName, NameLength1,
  90                                                  SchemaName, NameLength2, TableName, NameLength3,
  91                                                  ColumnName, NameLength4);
  92 }
  93
  94
  95 RETCODE         SQL_API
  96 SQLConnect(HDBC ConnectionHandle,
  97                    SQLCHAR *ServerName, SQLSMALLINT NameLength1,
  98                    SQLCHAR *UserName, SQLSMALLINT NameLength2,
  99                    SQLCHAR *Authentication, SQLSMALLINT NameLength3)
 100 {
 101         mylog("[SQLConnect]");
 102         return PGAPI_Connect(ConnectionHandle, ServerName, NameLength1,
 103                                          UserName, NameLength2, Authentication, NameLength3);
 104 }
 105
 106 RETCODE         SQL_API
 107 SQLDriverConnect(HDBC hdbc,
 108                                  HWND hwnd,
 109                                  UCHAR FAR * szConnStrIn,
 110                                  SWORD cbConnStrIn,
 111                                  UCHAR FAR * szConnStrOut,
 112                                  SWORD cbConnStrOutMax,
 113                                  SWORD FAR * pcbConnStrOut,
 114                                  UWORD fDriverCompletion)
 115 {
 116         mylog("[SQLDriverConnect]");
 117         return PGAPI_DriverConnect(hdbc, hwnd, szConnStrIn, cbConnStrIn,
 118                 szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion);
 119 }
 120 RETCODE         SQL_API
 121 SQLBrowseConnect(
 122                                  HDBC hdbc,
 123                                  SQLCHAR *szConnStrIn,
 124                                  SQLSMALLINT cbConnStrIn,
 125                                  SQLCHAR *szConnStrOut,
 126                                  SQLSMALLINT cbConnStrOutMax,
 127                                  SQLSMALLINT *pcbConnStrOut)
 128 {
 129         mylog("[SQLBrowseConnect]");
 130         return PGAPI_BrowseConnect(hdbc, szConnStrIn, cbConnStrIn,
 131                                                    szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
 132 }
 133
 134 RETCODE         SQL_API
 135 SQLDataSources(HENV EnvironmentHandle,
 136                            SQLUSMALLINT Direction, SQLCHAR *ServerName,
 137                            SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
 138                            SQLCHAR *Description, SQLSMALLINT BufferLength2,
 139                            SQLSMALLINT *NameLength2)
 140 {
 141         mylog("[SQLDataSources]");
 142
 143         /*
 144          * return PGAPI_DataSources(EnvironmentHandle, Direction, ServerName,
 145          * BufferLength1, NameLength1, Description, BufferLength2,
 146          * NameLength2);
 147          */
 148         return SQL_ERROR;
 149 }
 150
 151 RETCODE         SQL_API
 152 SQLDescribeCol(HSTMT StatementHandle,
 153                            SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
 154                            SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
 155                            SQLSMALLINT *DataType, SQLUINTEGER *ColumnSize,
 156                            SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
 157 {
 158         mylog("[SQLDescribeCol]");
 159         return PGAPI_DescribeCol(StatementHandle, ColumnNumber,
 160                                                          ColumnName, BufferLength, NameLength,
 161                                                   DataType, ColumnSize, DecimalDigits, Nullable);
 162 }
 163
 164 RETCODE         SQL_API
 165 SQLDisconnect(HDBC ConnectionHandle)
 166 {
 167         mylog("[SQLDisconnect]");
 168         return PGAPI_Disconnect(ConnectionHandle);
 169 }
 170
 171 RETCODE         SQL_API
 172 SQLError(HENV EnvironmentHandle,
 173                  HDBC ConnectionHandle, HSTMT StatementHandle,
 174                  SQLCHAR *Sqlstate, SQLINTEGER *NativeError,
 175                  SQLCHAR *MessageText, SQLSMALLINT BufferLength,
 176                  SQLSMALLINT *TextLength)
 177 {
 178         mylog("[SQLError]");
 179         return PGAPI_Error(EnvironmentHandle, ConnectionHandle, StatementHandle,
 180                    Sqlstate, NativeError, MessageText, BufferLength, TextLength);
 181 }
 182
 183 RETCODE         SQL_API
 184 SQLExecDirect(HSTMT StatementHandle,
 185                           SQLCHAR *StatementText, SQLINTEGER TextLength)
 186 {
 187         mylog("[SQLExecDirect]");
 188         return PGAPI_ExecDirect(StatementHandle, StatementText, TextLength);
 189 }
 190
 191 RETCODE         SQL_API
 192 SQLExecute(HSTMT StatementHandle)
 193 {
 194         mylog("[SQLExecute]");
 195         return PGAPI_Execute(StatementHandle);
 196 }
 197
 198 RETCODE         SQL_API
 199 SQLFetch(HSTMT StatementHandle)
 200 {
 201         static char *func = "SQLFetch";
 202
 203 #if (ODBCVER >= 0x3000)
 204         StatementClass *stmt = (StatementClass *) StatementHandle;
 205         ConnectionClass *conn = SC_get_conn(stmt);
 206
 207         if (conn->driver_version >= 0x0300)
 208         {
 209                 SQLUSMALLINT *rowStatusArray = stmt->options.rowStatusArray;
 210                 SQLINTEGER *pcRow = stmt->options.rowsFetched;
 211
 212                 mylog("[[%s]]", func);
 213                 return PGAPI_ExtendedFetch(StatementHandle, SQL_FETCH_NEXT, 0,
 214                                                                    pcRow, rowStatusArray);
 215         }
 216 #endif
 217         mylog("[%s]", func);
 218         return PGAPI_Fetch(StatementHandle);
 219 }
 220
 221 RETCODE         SQL_API
 222 SQLFreeConnect(HDBC ConnectionHandle)
 223 {
 224         mylog("[SQLFreeStmt]");
 225         return PGAPI_FreeConnect(ConnectionHandle);
 226 }
 227
 228 RETCODE         SQL_API
 229 SQLFreeEnv(HENV EnvironmentHandle)
 230 {
 231         mylog("[SQLFreeEnv]");
 232         return PGAPI_FreeEnv(EnvironmentHandle);
 233 }
 234
 235 RETCODE         SQL_API
 236 SQLFreeStmt(HSTMT StatementHandle,
 237                         SQLUSMALLINT Option)
 238 {
 239         mylog("[SQLFreeStmt]");
 240         return PGAPI_FreeStmt(StatementHandle, Option);
 241 }
 242
 243 RETCODE         SQL_API
 244 SQLGetConnectOption(HDBC ConnectionHandle,
 245                                         SQLUSMALLINT Option, PTR Value)
 246 {
 247         mylog("[SQLGetConnectOption]");
 248         return PGAPI_GetConnectOption(ConnectionHandle, Option, Value);
 249 }
 250 RETCODE         SQL_API
 251 SQLGetCursorName(HSTMT StatementHandle,
 252                                  SQLCHAR *CursorName, SQLSMALLINT BufferLength,
 253                                  SQLSMALLINT *NameLength)
 254 {
 255         mylog("[SQLGetCursorName]");
 256         return PGAPI_GetCursorName(StatementHandle, CursorName, BufferLength,
 257                                                            NameLength);
 258 }
 259
 260 RETCODE         SQL_API
 261 SQLGetData(HSTMT StatementHandle,
 262                    SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
 263                    PTR TargetValue, SQLINTEGER BufferLength,
 264                    SQLINTEGER *StrLen_or_Ind)
 265 {
 266         mylog("[SQLGetData]");
 267         return PGAPI_GetData(StatementHandle, ColumnNumber, TargetType,
 268                                                  TargetValue, BufferLength, StrLen_or_Ind);
 269 }
 270
 271 RETCODE         SQL_API
 272 SQLGetFunctions(HDBC ConnectionHandle,
 273                                 SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported)
 274 {
 275         mylog("[SQLGetFunctions]");
 276 #if (ODBCVER >= 0x3000)
 277         if (FunctionId == SQL_API_ODBC3_ALL_FUNCTIONS)
 278                 return PGAPI_GetFunctions30(ConnectionHandle, FunctionId, Supported);
 279 #endif
 280         return PGAPI_GetFunctions(ConnectionHandle, FunctionId, Supported);
 281 }
 282 RETCODE         SQL_API
 283 SQLGetInfo(HDBC ConnectionHandle,
 284                    SQLUSMALLINT InfoType, PTR InfoValue,
 285                    SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
 286 {
 287 #if (ODBCVER >= 0x3000)
 288         RETCODE         ret;
 289
 290         mylog("[SQLGetInfo(30)]");
 291         if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
 292                                                          BufferLength, StringLength)) == SQL_ERROR)
 293         {
 294                 if (((ConnectionClass *) ConnectionHandle)->driver_version >= 0x3000)
 295                         return PGAPI_GetInfo30(ConnectionHandle, InfoType, InfoValue,
 296                                                                    BufferLength, StringLength);
 297         }
 298         return ret;
 299 #else
 300         mylog("[SQLGetInfo]");
 301         return PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
 302                                                  BufferLength, StringLength);
 303 #endif
 304 }
 305
 306 RETCODE         SQL_API
 307 SQLGetStmtOption(HSTMT StatementHandle,
 308                                  SQLUSMALLINT Option, PTR Value)
 309 {
 310         mylog("[SQLGetStmtOption]");
 311         return PGAPI_GetStmtOption(StatementHandle, Option, Value);
 312 }
 313
 314 RETCODE         SQL_API
 315 SQLGetTypeInfo(HSTMT StatementHandle,
 316                            SQLSMALLINT DataType)
 317 {
 318         mylog("[SQLGetTypeInfo]");
 319         return PGAPI_GetTypeInfo(StatementHandle, DataType);
 320 }
 321
 322 RETCODE         SQL_API
 323 SQLNumResultCols(HSTMT StatementHandle,
 324                                  SQLSMALLINT *ColumnCount)
 325 {
 326         mylog("[SQLNumResultCols]");
 327         return PGAPI_NumResultCols(StatementHandle, ColumnCount);
 328 }
 329
 330 RETCODE         SQL_API
 331 SQLParamData(HSTMT StatementHandle,
 332                          PTR *Value)
 333 {
 334         mylog("[SQLParamData]");
 335         return PGAPI_ParamData(StatementHandle, Value);
 336 }
 337
 338 RETCODE         SQL_API
 339 SQLPrepare(HSTMT StatementHandle,
 340                    SQLCHAR *StatementText, SQLINTEGER TextLength)
 341 {
 342         mylog("[SQLPrepare]");
 343         return PGAPI_Prepare(StatementHandle, StatementText, TextLength);
 344 }
 345
 346 RETCODE         SQL_API
 347 SQLPutData(HSTMT StatementHandle,
 348                    PTR Data, SQLINTEGER StrLen_or_Ind)
 349 {
 350         mylog("[SQLPutData]");
 351         return PGAPI_PutData(StatementHandle, Data, StrLen_or_Ind);
 352 }
 353
 354 RETCODE         SQL_API
 355 SQLRowCount(HSTMT StatementHandle,
 356                         SQLINTEGER *RowCount)
 357 {
 358         mylog("[SQLRowCount]");
 359         return PGAPI_RowCount(StatementHandle, RowCount);
 360 }
 361
 362 RETCODE         SQL_API
 363 SQLSetConnectOption(HDBC ConnectionHandle,
 364                                         SQLUSMALLINT Option, SQLUINTEGER Value)
 365 {
 366         mylog("[SQLSetConnectionOption]");
 367         return PGAPI_SetConnectOption(ConnectionHandle, Option, Value);
 368 }
 369
 370 RETCODE         SQL_API
 371 SQLSetCursorName(HSTMT StatementHandle,
 372                                  SQLCHAR *CursorName, SQLSMALLINT NameLength)
 373 {
 374         mylog("[SQLSetCursorName]");
 375         return PGAPI_SetCursorName(StatementHandle, CursorName, NameLength);
 376 }
 377
 378 RETCODE         SQL_API
 379 SQLSetParam(HSTMT StatementHandle,
 380                         SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
 381                         SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
 382                         SQLSMALLINT ParameterScale, PTR ParameterValue,
 383                         SQLINTEGER *StrLen_or_Ind)
 384 {
 385         mylog("[SQLSetParam]");
 386
 387         /*
 388          * return PGAPI_SetParam(StatementHandle, ParameterNumber, ValueType,
 389          * ParameterType, LengthPrecision, ParameterScale, ParameterValue,
 390          * StrLen_or_Ind);
 391          */
 392         return SQL_ERROR;
 393 }
 394
 395 RETCODE         SQL_API
 396 SQLSetStmtOption(HSTMT StatementHandle,
 397                                  SQLUSMALLINT Option, SQLUINTEGER Value)
 398 {
 399         mylog("[SQLSetStmtOption]");
 400         return PGAPI_SetStmtOption(StatementHandle, Option, Value);
 401 }
 402
 403 RETCODE         SQL_API
 404 SQLSpecialColumns(HSTMT StatementHandle,
 405                                   SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,
 406                                   SQLSMALLINT NameLength1, SQLCHAR *SchemaName,
 407                                   SQLSMALLINT NameLength2, SQLCHAR *TableName,
 408                                   SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
 409                                   SQLUSMALLINT Nullable)
 410 {
 411         mylog("[SQLSpecialColumns]");
 412         return PGAPI_SpecialColumns(StatementHandle, IdentifierType, CatalogName,
 413                         NameLength1, SchemaName, NameLength2, TableName, NameLength3,
 414                                                                 Scope, Nullable);
 415 }
 416
 417 RETCODE         SQL_API
 418 SQLStatistics(HSTMT StatementHandle,
 419                           SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
 420                           SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
 421                           SQLCHAR *TableName, SQLSMALLINT NameLength3,
 422                           SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
 423 {
 424         mylog("[SQLStatistics]");
 425         return PGAPI_Statistics(StatementHandle, CatalogName, NameLength1,
 426                                  SchemaName, NameLength2, TableName, NameLength3, Unique,
 427                                                         Reserved);
 428 }
 429
 430 RETCODE         SQL_API
 431 SQLTables(HSTMT StatementHandle,
 432                   SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
 433                   SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
 434                   SQLCHAR *TableName, SQLSMALLINT NameLength3,
 435                   SQLCHAR *TableType, SQLSMALLINT NameLength4)
 436 {
 437         mylog("[SQLTables]");
 438         return PGAPI_Tables(StatementHandle, CatalogName, NameLength1,
 439                                                 SchemaName, NameLength2, TableName, NameLength3,
 440                                                 TableType, NameLength4);
 441 }
 442
 443 RETCODE         SQL_API
 444 SQLTransact(HENV EnvironmentHandle,
 445                         HDBC ConnectionHandle, SQLUSMALLINT CompletionType)
 446 {
 447         mylog("[SQLTransact]");
 448         return PGAPI_Transact(EnvironmentHandle, ConnectionHandle, CompletionType);
 449 }
 450
 451 RETCODE         SQL_API
 452 SQLColAttributes(
 453                                  HSTMT hstmt,
 454                                  SQLUSMALLINT icol,
 455                                  SQLUSMALLINT fDescType,
 456                                  PTR rgbDesc,
 457                                  SQLSMALLINT cbDescMax,
 458                                  SQLSMALLINT *pcbDesc,
 459                                  SQLINTEGER *pfDesc)
 460 {
 461         mylog("[SQLColAttributes]");
 462         return PGAPI_ColAttributes(hstmt, icol, fDescType, rgbDesc,
 463                                                            cbDescMax, pcbDesc, pfDesc);
 464 }
 465
 466 RETCODE         SQL_API
 467 SQLColumnPrivileges(
 468                                         HSTMT hstmt,
 469                                         SQLCHAR *szCatalogName,
 470                                         SQLSMALLINT cbCatalogName,
 471                                         SQLCHAR *szSchemaName,
 472                                         SQLSMALLINT cbSchemaName,
 473                                         SQLCHAR *szTableName,
 474                                         SQLSMALLINT cbTableName,
 475                                         SQLCHAR *szColumnName,
 476                                         SQLSMALLINT cbColumnName)
 477 {
 478         mylog("[SQLColumnPrivileges]");
 479         return PGAPI_ColumnPrivileges(hstmt, szCatalogName, cbCatalogName,
 480                                         szSchemaName, cbSchemaName, szTableName, cbTableName,
 481                                                                   szColumnName, cbColumnName);
 482 }
 483
 484 RETCODE         SQL_API
 485 SQLDescribeParam(
 486                                  HSTMT hstmt,
 487                                  SQLUSMALLINT ipar,
 488                                  SQLSMALLINT *pfSqlType,
 489                                  SQLUINTEGER *pcbParamDef,
 490                                  SQLSMALLINT *pibScale,
 491                                  SQLSMALLINT *pfNullable)
 492 {
 493         mylog("[SQLDescribeParam]");
 494         return PGAPI_DescribeParam(hstmt, ipar, pfSqlType, pcbParamDef,
 495                                                            pibScale, pfNullable);
 496 }
 497
 498 RETCODE         SQL_API
 499 SQLExtendedFetch(
 500                                  HSTMT hstmt,
 501                                  SQLUSMALLINT fFetchType,
 502                                  SQLINTEGER irow,
 503                                  SQLUINTEGER *pcrow,
 504                                  SQLUSMALLINT *rgfRowStatus)
 505 {
 506         mylog("[SQLExtendedFetch]");
 507         return PGAPI_ExtendedFetch(hstmt, fFetchType, irow, pcrow, rgfRowStatus);
 508 }
 509
 510 RETCODE         SQL_API
 511 SQLForeignKeys(
 512                            HSTMT hstmt,
 513                            SQLCHAR *szPkCatalogName,
 514                            SQLSMALLINT cbPkCatalogName,
 515                            SQLCHAR *szPkSchemaName,
 516                            SQLSMALLINT cbPkSchemaName,
 517                            SQLCHAR *szPkTableName,
 518                            SQLSMALLINT cbPkTableName,
 519                            SQLCHAR *szFkCatalogName,
 520                            SQLSMALLINT cbFkCatalogName,
 521                            SQLCHAR *szFkSchemaName,
 522                            SQLSMALLINT cbFkSchemaName,
 523                            SQLCHAR *szFkTableName,
 524                            SQLSMALLINT cbFkTableName)
 525 {
 526         mylog("[SQLForeignKeys]");
 527         return PGAPI_ForeignKeys(hstmt, szPkCatalogName, cbPkCatalogName,
 528                                                    szPkSchemaName, cbPkSchemaName, szPkTableName,
 529                                                  cbPkTableName, szFkCatalogName, cbFkCatalogName,
 530                    szFkSchemaName, cbFkSchemaName, szFkTableName, cbFkTableName);
 531 }
 532
 533 RETCODE         SQL_API
 534 SQLMoreResults(HSTMT hstmt)
 535 {
 536         mylog("[SQLMoreResults]");
 537         return PGAPI_MoreResults(hstmt);
 538 }
 539
 540 RETCODE         SQL_API
 541 SQLNativeSql(
 542                          HDBC hdbc,
 543                          SQLCHAR *szSqlStrIn,
 544                          SQLINTEGER cbSqlStrIn,
 545                          SQLCHAR *szSqlStr,
 546                          SQLINTEGER cbSqlStrMax,
 547                          SQLINTEGER *pcbSqlStr)
 548 {
 549         mylog("[SQLNativeSql]");
 550         return PGAPI_NativeSql(hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr,
 551                                                    cbSqlStrMax, pcbSqlStr);
 552 }
 553
 554 RETCODE         SQL_API
 555 SQLNumParams(
 556                          HSTMT hstmt,
 557                          SQLSMALLINT *pcpar)
 558 {
 559         mylog("[SQLNumParams]");
 560         return PGAPI_NumParams(hstmt, pcpar);
 561 }
 562
 563 RETCODE         SQL_API
 564 SQLParamOptions(
 565                                 HSTMT hstmt,
 566                                 SQLUINTEGER crow,
 567                                 SQLUINTEGER *pirow)
 568 {
 569         mylog("[SQLParamOptions]");
 570         return PGAPI_ParamOptions(hstmt, crow, pirow);
 571 }
 572
 573 RETCODE         SQL_API
 574 SQLPrimaryKeys(
 575                            HSTMT hstmt,
 576                            SQLCHAR *szCatalogName,
 577                            SQLSMALLINT cbCatalogName,
 578                            SQLCHAR *szSchemaName,
 579                            SQLSMALLINT cbSchemaName,
 580                            SQLCHAR *szTableName,
 581                            SQLSMALLINT cbTableName)
 582 {
 583         mylog("[SQLPrimaryKeys]");
 584         return PGAPI_PrimaryKeys(hstmt, szCatalogName, cbCatalogName,
 585                                    szSchemaName, cbSchemaName, szTableName, cbTableName);
 586 }
 587
 588 RETCODE         SQL_API
 589 SQLProcedureColumns(
 590                                         HSTMT hstmt,
 591                                         SQLCHAR *szCatalogName,
 592                                         SQLSMALLINT cbCatalogName,
 593                                         SQLCHAR *szSchemaName,
 594                                         SQLSMALLINT cbSchemaName,
 595                                         SQLCHAR *szProcName,
 596                                         SQLSMALLINT cbProcName,
 597                                         SQLCHAR *szColumnName,
 598                                         SQLSMALLINT cbColumnName)
 599 {
 600         mylog("[SQLProcedureColumns]");
 601         return PGAPI_ProcedureColumns(hstmt, szCatalogName, cbCatalogName,
 602                                           szSchemaName, cbSchemaName, szProcName, cbProcName,
 603                                                                   szColumnName, cbColumnName);
 604 }
 605
 606 RETCODE         SQL_API
 607 SQLProcedures(
 608                           HSTMT hstmt,
 609                           SQLCHAR *szCatalogName,
 610                           SQLSMALLINT cbCatalogName,
 611                           SQLCHAR *szSchemaName,
 612                           SQLSMALLINT cbSchemaName,
 613                           SQLCHAR *szProcName,
 614                           SQLSMALLINT cbProcName)
 615 {
 616         mylog("[SQLProcedures]");
 617         return PGAPI_Procedures(hstmt, szCatalogName, cbCatalogName,
 618                                          szSchemaName, cbSchemaName, szProcName, cbProcName);
 619 }
 620
 621 RETCODE         SQL_API
 622 SQLSetPos(
 623                   HSTMT hstmt,
 624                   SQLUSMALLINT irow,
 625                   SQLUSMALLINT fOption,
 626                   SQLUSMALLINT fLock)
 627 {
 628         mylog("[SQLSetPos]");
 629         return PGAPI_SetPos(hstmt, irow, fOption, fLock);
 630 }
 631
 632 RETCODE         SQL_API
 633 SQLTablePrivileges(
 634                                    HSTMT hstmt,
 635                                    SQLCHAR *szCatalogName,
 636                                    SQLSMALLINT cbCatalogName,
 637                                    SQLCHAR *szSchemaName,
 638                                    SQLSMALLINT cbSchemaName,
 639                                    SQLCHAR *szTableName,
 640                                    SQLSMALLINT cbTableName)
 641 {
 642         mylog("[SQLTablePrivileges]");
 643         return PGAPI_TablePrivileges(hstmt, szCatalogName, cbCatalogName,
 644                                    szSchemaName, cbSchemaName, szTableName, cbTableName);
 645 }
 646
 647 RETCODE         SQL_API
 648 SQLBindParameter(
 649                                  HSTMT hstmt,
 650                                  SQLUSMALLINT ipar,
 651                                  SQLSMALLINT fParamType,
 652                                  SQLSMALLINT fCType,
 653                                  SQLSMALLINT fSqlType,
 654                                  SQLUINTEGER cbColDef,
 655                                  SQLSMALLINT ibScale,
 656                                  PTR rgbValue,
 657                                  SQLINTEGER cbValueMax,
 658                                  SQLINTEGER *pcbValue)
 659 {
 660         mylog("[SQLBindParameter]");
 661         return PGAPI_BindParameter(hstmt, ipar, fParamType, fCType,
 662                                            fSqlType, cbColDef, ibScale, rgbValue, cbValueMax,
 663                                                            pcbValue);
 664 }