git.oblomov.eu Git - wine/blob - dlls/odbc32/proxyodbc.c

   1 /*
   2  * Win32 ODBC functions
   3  *
   4  * Proxy ODBC driver manager.  This manager delegates all ODBC calls to a real ODBC driver manager which is either:
   5  *      1) its name is defined in the environment variable LIB_ODBC_DRIVER_MANAGER
   6  *      2) if LIB_ODBC_DRIVER_MANAGER is not defined, a default library libodbc.so will be used.
   7  *
   8  * Xiang Li, Corel Corporation, Nov. 12, 1999
   9  *
  10  */
  11
  12 #include "config.h"
  13 #include "wine/port.h"
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <assert.h>
  19
  20 #include "winbase.h"
  21 #include "debugtools.h"
  22
  23 #include "sql.h"
  24 #include "sqltypes.h"
  25 #include "sqlext.h"
  26
  27 #include "proxyodbc.h"
  28
  29 static BOOL ODBC_LoadDriverManager(void);
  30 static BOOL ODBC_LoadDMFunctions(void);
  31
  32 DEFAULT_DEBUG_CHANNEL(odbc);
  33
  34 static const DM_FUNC template_func[] =
  35 {
  36     /* 00 */ { SQL_API_SQLALLOCCONNECT,      "SQLAllocConnect", SQLAllocConnect, NULL },
  37     /* 01 */ { SQL_API_SQLALLOCENV,          "SQLAllocEnv", SQLAllocEnv, NULL  },
  38     /* 02 */ { SQL_API_SQLALLOCHANDLE,       "SQLAllocHandle", SQLAllocHandle, NULL },
  39     /* 03 */ { SQL_API_SQLALLOCSTMT,         "SQLAllocStmt", SQLAllocStmt, NULL },
  40     /* 04 */ { SQL_API_SQLALLOCHANDLESTD,    "SQLAllocHandleStd", SQLAllocHandleStd, NULL },
  41     /* 05 */ { SQL_API_SQLBINDCOL,           "SQLBindCol", SQLBindCol, NULL },
  42     /* 06 */ { SQL_API_SQLBINDPARAM,         "SQLBindParam", SQLBindParam, NULL },
  43     /* 07 */ { SQL_API_SQLBINDPARAMETER,     "SQLBindParameter", SQLBindParameter, NULL },
  44     /* 08 */ { SQL_API_SQLBROWSECONNECT,     "SQLBrowseConnect", SQLBrowseConnect, NULL },
  45     /* 09 */ { SQL_API_SQLBULKOPERATIONS,    "SQLBulkOperations", SQLBulkOperations, NULL },
  46     /* 10 */ { SQL_API_SQLCANCEL,            "SQLCancel", SQLCancel, NULL },
  47     /* 11 */ { SQL_API_SQLCLOSECURSOR,       "SQLCloseCursor", SQLCloseCursor, NULL },
  48     /* 12 */ { SQL_API_SQLCOLATTRIBUTE,      "SQLColAttribute", SQLColAttribute, NULL },
  49     /* 13 */ { SQL_API_SQLCOLATTRIBUTES,     "SQLColAttributes", SQLColAttributes, NULL },
  50     /* 14 */ { SQL_API_SQLCOLUMNPRIVILEGES,  "SQLColumnPrivileges", SQLColumnPrivileges, NULL },
  51     /* 15 */ { SQL_API_SQLCOLUMNS,           "SQLColumns", SQLColumns, NULL },
  52     /* 16 */ { SQL_API_SQLCONNECT,           "SQLConnect", SQLConnect, NULL },
  53     /* 17 */ { SQL_API_SQLCOPYDESC,          "SQLCopyDesc", SQLCopyDesc, NULL },
  54     /* 18 */ { SQL_API_SQLDATASOURCES,       "SQLDataSources", SQLDataSources, NULL },
  55     /* 19 */ { SQL_API_SQLDESCRIBECOL,       "SQLDescribeCol", SQLDescribeCol, NULL },
  56     /* 20 */ { SQL_API_SQLDESCRIBEPARAM,     "SQLDescribeParam", SQLDescribeParam, NULL },
  57     /* 21 */ { SQL_API_SQLDISCONNECT,        "SQLDisconnect", SQLDisconnect, NULL },
  58     /* 22 */ { SQL_API_SQLDRIVERCONNECT,     "SQLDriverConnect", SQLDriverConnect, NULL },
  59     /* 23 */ { SQL_API_SQLDRIVERS,           "SQLDrivers", SQLDrivers, NULL },
  60     /* 24 */ { SQL_API_SQLENDTRAN,           "SQLEndTran", SQLEndTran, NULL },
  61     /* 25 */ { SQL_API_SQLERROR,             "SQLError", SQLError, NULL },
  62     /* 26 */ { SQL_API_SQLEXECDIRECT,        "SQLExecDirect", SQLExecDirect, NULL },
  63     /* 27 */ { SQL_API_SQLEXECUTE,           "SQLExecute", SQLExecute, NULL },
  64     /* 28 */ { SQL_API_SQLEXTENDEDFETCH,     "SQLExtendedFetch", SQLExtendedFetch, NULL },
  65     /* 29 */ { SQL_API_SQLFETCH,             "SQLFetch", SQLFetch, NULL },
  66     /* 30 */ { SQL_API_SQLFETCHSCROLL,       "SQLFetchScroll", SQLFetchScroll, NULL },
  67     /* 31 */ { SQL_API_SQLFOREIGNKEYS,       "SQLForeignKeys", SQLForeignKeys, NULL },
  68     /* 32 */ { SQL_API_SQLFREEENV,           "SQLFreeEnv", SQLFreeEnv, NULL },
  69     /* 33 */ { SQL_API_SQLFREEHANDLE,        "SQLFreeHandle", SQLFreeHandle, NULL },
  70     /* 34 */ { SQL_API_SQLFREESTMT,          "SQLFreeStmt", SQLFreeStmt, NULL },
  71     /* 35 */ { SQL_API_SQLFREECONNECT,       "SQLFreeConnect", SQLFreeConnect, NULL },
  72     /* 36 */ { SQL_API_SQLGETCONNECTATTR,    "SQLGetConnectAttr", SQLGetConnectAttr, NULL },
  73     /* 37 */ { SQL_API_SQLGETCONNECTOPTION,  "SQLGetConnectOption", SQLGetConnectOption, NULL },
  74     /* 38 */ { SQL_API_SQLGETCURSORNAME,     "SQLGetCursorName", SQLGetCursorName, NULL },
  75     /* 39 */ { SQL_API_SQLGETDATA,           "SQLGetData", SQLGetData, NULL },
  76     /* 40 */ { SQL_API_SQLGETDESCFIELD,      "SQLGetDescField", SQLGetDescField, NULL },
  77     /* 41 */ { SQL_API_SQLGETDESCREC,        "SQLGetDescRec", SQLGetDescRec, NULL },
  78     /* 42 */ { SQL_API_SQLGETDIAGFIELD,      "SQLGetDiagField", SQLGetDiagField, NULL },
  79     /* 43 */ { SQL_API_SQLGETENVATTR,        "SQLGetEnvAttr", SQLGetEnvAttr, NULL },
  80     /* 44 */ { SQL_API_SQLGETFUNCTIONS,      "SQLGetFunctions", SQLGetFunctions, NULL },
  81     /* 45 */ { SQL_API_SQLGETINFO,           "SQLGetInfo", SQLGetInfo, NULL },
  82     /* 46 */ { SQL_API_SQLGETSTMTATTR,       "SQLGetStmtAttr", SQLGetStmtAttr, NULL },
  83     /* 47 */ { SQL_API_SQLGETSTMTOPTION,     "SQLGetStmtOption", SQLGetStmtOption, NULL },
  84     /* 48 */ { SQL_API_SQLGETTYPEINFO,       "SQLGetTypeInfo", SQLGetTypeInfo, NULL },
  85     /* 49 */ { SQL_API_SQLMORERESULTS,       "SQLMoreResults", SQLMoreResults, NULL },
  86     /* 50 */ { SQL_API_SQLNATIVESQL,         "SQLNativeSql", SQLNativeSql, NULL },
  87     /* 51 */ { SQL_API_SQLNUMPARAMS,         "SQLNumParams", SQLNumParams, NULL },
  88     /* 52 */ { SQL_API_SQLNUMRESULTCOLS,     "SQLNumResultCols", SQLNumResultCols, NULL },
  89     /* 53 */ { SQL_API_SQLPARAMDATA,         "SQLParamData", SQLParamData, NULL },
  90     /* 54 */ { SQL_API_SQLPARAMOPTIONS,      "SQLParamOptions", SQLParamOptions, NULL },
  91     /* 55 */ { SQL_API_SQLPREPARE,           "SQLPrepare", SQLPrepare, NULL },
  92     /* 56 */ { SQL_API_SQLPRIMARYKEYS,       "SQLPrimaryKeys", SQLPrimaryKeys, NULL },
  93     /* 57 */ { SQL_API_SQLPROCEDURECOLUMNS,  "SQLProcedureColumns", SQLProcedureColumns, NULL },
  94     /* 58 */ { SQL_API_SQLPROCEDURES,        "SQLProcedures", SQLProcedures, NULL },
  95     /* 59 */ { SQL_API_SQLPUTDATA,           "SQLPutData", SQLPutData, NULL },
  96     /* 60 */ { SQL_API_SQLROWCOUNT,          "SQLRowCount", SQLRowCount, NULL },
  97     /* 61 */ { SQL_API_SQLSETCONNECTATTR,    "SQLSetConnectAttr", SQLSetConnectAttr, NULL },
  98     /* 62 */ { SQL_API_SQLSETCONNECTOPTION,  "SQLSetConnectOption", SQLSetConnectOption, NULL },
  99     /* 63 */ { SQL_API_SQLSETCURSORNAME,     "SQLSetCursorName", SQLSetCursorName, NULL },
 100     /* 64 */ { SQL_API_SQLSETDESCFIELD,      "SQLSetDescField", SQLSetDescField, NULL },
 101     /* 65 */ { SQL_API_SQLSETDESCREC,        "SQLSetDescRec", SQLSetDescRec, NULL },
 102     /* 66 */ { SQL_API_SQLSETENVATTR,        "SQLSetEnvAttr", SQLSetEnvAttr, NULL },
 103     /* 67 */ { SQL_API_SQLSETPARAM,          "SQLSetParam", SQLSetParam, NULL },
 104     /* 68 */ { SQL_API_SQLSETPOS,            "SQLSetPos", SQLSetPos, NULL },
 105     /* 69 */ { SQL_API_SQLSETSCROLLOPTIONS,  "SQLSetScrollOptions", SQLSetScrollOptions, NULL },
 106     /* 70 */ { SQL_API_SQLSETSTMTATTR,       "SQLSetStmtAttr", SQLSetStmtAttr, NULL },
 107     /* 71 */ { SQL_API_SQLSETSTMTOPTION,     "SQLSetStmtOption", SQLSetStmtOption, NULL },
 108     /* 72 */ { SQL_API_SQLSPECIALCOLUMNS,    "SQLSpecialColumns", SQLSpecialColumns, NULL },
 109     /* 73 */ { SQL_API_SQLSTATISTICS,        "SQLStatistics", SQLStatistics, NULL },
 110     /* 74 */ { SQL_API_SQLTABLEPRIVILEGES,   "SQLTablePrivileges", SQLTablePrivileges, NULL },
 111     /* 75 */ { SQL_API_SQLTABLES,            "SQLTables", SQLTables, NULL },
 112     /* 76 */ { SQL_API_SQLTRANSACT,          "SQLTransact", SQLTransact, NULL },
 113     /* 77 */ { SQL_API_SQLGETDIAGREC,        "SQLGetDiagRec", SQLGetDiagRec, NULL },
 114 };
 115
 116 static PROXYHANDLE gProxyHandle = {
 117   NULL,
 118   FALSE,
 119   FALSE,
 120   FALSE,
 121   ERROR_LIBRARY_NOT_FOUND,
 122   { },
 123   "",
 124   "",
 125   "",
 126   ""
 127 };
 128
 129 /* What is the difference between these two (dmHandle cf READY_AND_dmHandle)? When does one use one and when the other? */
 130
 131 #define CHECK_dmHandle() \
 132 { \
 133         if (gProxyHandle.dmHandle == NULL) \
 134         { \
 135                 TRACE ("Not ready\n"); \
 136                 return SQL_ERROR; \
 137         } \
 138 }
 139
 140 #define CHECK_READY_AND_dmHandle() \
 141 { \
 142         if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) \
 143         { \
 144                 TRACE ("Not ready\n"); \
 145                 return SQL_ERROR; \
 146         } \
 147 }
 148
 149 SQLRETURN SQLDummyFunc()
 150 {
 151     TRACE("SQLDummyFunc: \n");
 152     return SQL_SUCCESS;
 153 }
 154
 155 /***********************************************************************
 156  * MAIN_OdbcInit [Internal] Initializes the internal 'ODBC32.DLL'.
 157  *
 158  * PARAMS
 159  *     hinstDLL    [I] handle to the DLL's instance
 160  *     fdwReason   [I]
 161  *     lpvReserved [I] reserved, must be NULL
 162  *
 163  * RETURNS
 164  *     Success: TRUE
 165  *     Failure: FALSE
 166  */
 167
 168 BOOL WINAPI
 169 MAIN_OdbcInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 170 {
 171     int i;
 172     TRACE("Initializing or Finalizing proxy ODBC: %x,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
 173
 174     if (fdwReason == DLL_PROCESS_ATTACH)
 175     {
 176        TRACE("Loading ODBC...\n");
 177        if (ODBC_LoadDriverManager())
 178           ODBC_LoadDMFunctions();
 179     }
 180     else if (fdwReason == DLL_PROCESS_DETACH)
 181     {
 182       TRACE("Unloading ODBC...\n");
 183       if (gProxyHandle.bFunctionReady)
 184       {
 185          for ( i = 0; i < NUM_SQLFUNC; i ++ )
 186          {
 187             gProxyHandle.functions[i].func = SQLDummyFunc;
 188          }
 189       }
 190
 191       if (gProxyHandle.dmHandle)
 192       {
 193          wine_dlclose(gProxyHandle.dmHandle,NULL,0);
 194          gProxyHandle.dmHandle = NULL;
 195       }
 196     }
 197
 198     return TRUE;
 199 }
 200
 201
 202 /***********************************************************************
 203  * ODBC_LoadDriverManager [Internal] Load ODBC library.
 204  *
 205  * PARAMS
 206  *
 207  * RETURNS
 208  *     Success: TRUE
 209  *     Failure: FALSE
 210  */
 211
 212 static BOOL ODBC_LoadDriverManager(void)
 213 {
 214    const char *s = getenv("LIB_ODBC_DRIVER_MANAGER");
 215    char error[256];
 216
 217    TRACE("\n");
 218
 219    gProxyHandle.bFunctionReady = FALSE;
 220
 221    if (s!= NULL && strlen (s) >= sizeof(gProxyHandle.dmLibName))
 222    {
 223           ERR("Driver name too long (%s)\n",s);
 224           return FALSE;
 225    }
 226    if (s == NULL || strlen(s) == 0)
 227           s = "libodbc.so";
 228    strcpy(gProxyHandle.dmLibName, s);
 229
 230    gProxyHandle.dmHandle = wine_dlopen(gProxyHandle.dmLibName, RTLD_LAZY, error, sizeof(error));
 231
 232    if (gProxyHandle.dmHandle == NULL)           /* fail to load unixODBC driver manager */
 233    {
 234            WARN("failed to open library %s: %s\n", gProxyHandle.dmLibName, error);
 235            gProxyHandle.dmLibName[0] = '\0';
 236            gProxyHandle.nErrorType = ERROR_LIBRARY_NOT_FOUND;
 237            return FALSE;
 238    }
 239    else
 240    {
 241       gProxyHandle.nErrorType = ERROR_FREE;
 242       return TRUE;
 243    }
 244 }
 245
 246
 247 /***********************************************************************
 248  * ODBC_LoadDMFunctions [Internal] Populate function table.
 249  *
 250  * PARAMS
 251  *
 252  * RETURNS
 253  *     Success: TRUE
 254  *     Failure: FALSE
 255  */
 256
 257 static BOOL ODBC_LoadDMFunctions(void)
 258 {
 259     int i;
 260     char error[256];
 261
 262     if (gProxyHandle.dmHandle == NULL)
 263         return FALSE;
 264
 265     for ( i = 0; i < NUM_SQLFUNC; i ++ )
 266     {
 267         gProxyHandle.functions[i] = template_func[i];
 268         gProxyHandle.functions[i].func = wine_dlsym(gProxyHandle.dmHandle,
 269                 gProxyHandle.functions[i].name, error, sizeof(error));
 270
 271         if (error[0])
 272         {
 273             ERR("Failed to load function %s\n",gProxyHandle.functions[i].name);
 274             gProxyHandle.functions[i].func = SQLDummyFunc;
 275         }
 276     }
 277
 278     gProxyHandle.bFunctionReady = TRUE;
 279
 280     return TRUE;
 281 }
 282
 283
 284 /*************************************************************************
 285  *                              SQLAllocConnect           [ODBC32.001]
 286  */
 287 SQLRETURN WINAPI SQLAllocConnect(SQLHENV EnvironmentHandle, SQLHDBC *ConnectionHandle)
 288 {
 289         SQLRETURN ret;
 290         TRACE("Env=%lx\n",EnvironmentHandle);
 291
 292         if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
 293         {
 294            *ConnectionHandle = SQL_NULL_HDBC;
 295            TRACE("Not ready\n");
 296            return SQL_ERROR;
 297         }
 298
 299         assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCCONNECT].func);
 300         ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCCONNECT].func)
 301             (EnvironmentHandle, ConnectionHandle);
 302         TRACE("Returns ret=%d, Handle %lx\n",ret, *ConnectionHandle);
 303         return ret;
 304 }
 305
 306
 307 /*************************************************************************
 308  *                              SQLAllocEnv           [ODBC32.002]
 309  */
 310 SQLRETURN WINAPI  SQLAllocEnv(SQLHENV *EnvironmentHandle)
 311 {
 312         SQLRETURN ret;
 313         TRACE("\n");
 314
 315         if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
 316         {
 317            *EnvironmentHandle = SQL_NULL_HENV;
 318            TRACE("Not ready\n");
 319            return SQL_ERROR;
 320         }
 321
 322         assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCENV].func);
 323         ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCENV].func) (EnvironmentHandle);
 324         TRACE("Returns ret=%d, Env=%lx\n",ret, *EnvironmentHandle);
 325         return ret;
 326 }
 327
 328
 329 /*************************************************************************
 330  *                              SQLAllocHandle           [ODBC32.024]
 331  */
 332 SQLRETURN WINAPI SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
 333 {
 334         SQLRETURN ret;
 335         TRACE("(Type=%d, Handle=%lx)\n",HandleType,InputHandle);
 336
 337         if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
 338         {
 339             if (gProxyHandle.nErrorType == ERROR_LIBRARY_NOT_FOUND)
 340                 WARN("ProxyODBC: Can not load ODBC driver manager library.\n");
 341
 342             if (HandleType == SQL_HANDLE_ENV)
 343                 *OutputHandle = SQL_NULL_HENV;
 344             else if (HandleType == SQL_HANDLE_DBC)
 345                 *OutputHandle = SQL_NULL_HDBC;
 346             else if (HandleType == SQL_HANDLE_STMT)
 347                 *OutputHandle = SQL_NULL_HSTMT;
 348             else if (HandleType == SQL_HANDLE_DESC)
 349                 *OutputHandle = SQL_NULL_HDESC;
 350
 351             TRACE ("Not ready\n");
 352             return SQL_ERROR;
 353         }
 354
 355         assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLE].func);
 356         ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLE].func)
 357                    (HandleType, InputHandle, OutputHandle);
 358         TRACE("Returns ret=%d, Handle=%lx\n",ret, *OutputHandle);
 359         return ret;
 360 }
 361
 362
 363 /*************************************************************************
 364  *                              SQLAllocStmt           [ODBC32.003]
 365  */
 366 SQLRETURN WINAPI SQLAllocStmt(SQLHDBC ConnectionHandle, SQLHSTMT *StatementHandle)
 367 {
 368         SQLRETURN ret;
 369
 370         TRACE("(Connection=%lx)\n",ConnectionHandle);
 371
 372         if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
 373         {
 374            *StatementHandle = SQL_NULL_HSTMT;
 375            TRACE ("Not ready\n");
 376            return SQL_ERROR;
 377         }
 378
 379         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCSTMT].func);
 380         ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCSTMT].func)
 381             (ConnectionHandle, StatementHandle);
 382         TRACE ("Returns ret=%d, Handle=%lx\n", ret, *StatementHandle);
 383         return ret;
 384 }
 385
 386
 387 /*************************************************************************
 388  *                              SQLAllocHandleStd           [ODBC32.077]
 389  */
 390 SQLRETURN WINAPI SQLAllocHandleStd( SQLSMALLINT HandleType,
 391                                                          SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
 392 {
 393         TRACE("ProxyODBC: SQLAllocHandelStd.\n");
 394
 395         if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
 396         {
 397             if (gProxyHandle.nErrorType == ERROR_LIBRARY_NOT_FOUND)
 398                 WARN("ProxyODBC: Can not load ODBC driver manager library.\n");
 399
 400             if (HandleType == SQL_HANDLE_ENV)
 401                 *OutputHandle = SQL_NULL_HENV;
 402             else if (HandleType == SQL_HANDLE_DBC)
 403                 *OutputHandle = SQL_NULL_HDBC;
 404             else if (HandleType == SQL_HANDLE_STMT)
 405                 *OutputHandle = SQL_NULL_HSTMT;
 406             else if (HandleType == SQL_HANDLE_DESC)
 407                 *OutputHandle = SQL_NULL_HDESC;
 408
 409             return SQL_ERROR;
 410         }
 411
 412         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLESTD].func);
 413         return (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLESTD].func)
 414                    (HandleType, InputHandle, OutputHandle);
 415 }
 416
 417
 418 /*************************************************************************
 419  *                              SQLBindCol           [ODBC32.004]
 420  */
 421 SQLRETURN WINAPI SQLBindCol(SQLHSTMT StatementHandle,
 422                      SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
 423                      SQLPOINTER TargetValue, SQLINTEGER BufferLength,
 424                      SQLINTEGER *StrLen_or_Ind)
 425 {
 426         TRACE("\n");
 427
 428         if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
 429         {
 430                 TRACE ("Not ready\n");
 431                 return SQL_ERROR;
 432         }
 433
 434         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDCOL].func);
 435         return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDCOL].func)
 436             (StatementHandle, ColumnNumber, TargetType,
 437             TargetValue, BufferLength, StrLen_or_Ind);
 438 }
 439
 440
 441 /*************************************************************************
 442  *                              SQLBindParam           [ODBC32.025]
 443  */
 444 SQLRETURN WINAPI SQLBindParam(SQLHSTMT StatementHandle,
 445              SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
 446              SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
 447              SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
 448              SQLINTEGER *StrLen_or_Ind)
 449 {
 450         TRACE("\n");
 451
 452         CHECK_READY_AND_dmHandle();
 453
 454         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAM].func);
 455         return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAM].func)
 456                    (StatementHandle, ParameterNumber, ValueType,
 457                     ParameterScale, ParameterValue, StrLen_or_Ind);
 458 }
 459
 460
 461 /*************************************************************************
 462  *                              SQLCancel           [ODBC32.005]
 463  */
 464 SQLRETURN WINAPI SQLCancel(SQLHSTMT StatementHandle)
 465 {
 466         TRACE("\n");
 467
 468         CHECK_READY_AND_dmHandle();
 469
 470         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCANCEL].func);
 471         return (gProxyHandle.functions[SQLAPI_INDEX_SQLCANCEL].func) (StatementHandle);
 472 }
 473
 474
 475 /*************************************************************************
 476  *                              SQLCloseCursor           [ODBC32.026]
 477  */
 478 SQLRETURN WINAPI  SQLCloseCursor(SQLHSTMT StatementHandle)
 479 {
 480         SQLRETURN ret;
 481         TRACE("(Handle=%lx)\n",StatementHandle);
 482
 483         CHECK_READY_AND_dmHandle();
 484
 485         assert(gProxyHandle.functions[SQLAPI_INDEX_SQLCLOSECURSOR].func);
 486         ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLCLOSECURSOR].func) (StatementHandle);
 487         TRACE("returns %d\n",ret);
 488         return ret;
 489 }
 490
 491
 492 /*************************************************************************
 493  *                              SQLColAttribute           [ODBC32.027]
 494  */
 495 SQLRETURN WINAPI SQLColAttribute (SQLHSTMT StatementHandle,
 496              SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
 497              SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength,
 498              SQLSMALLINT *StringLength, SQLPOINTER NumericAttribute)
 499 {
 500         TRACE("\n");
 501
 502         CHECK_READY_AND_dmHandle();
 503
 504         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTE].func);
 505         return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTE].func)
 506             (StatementHandle, ColumnNumber, FieldIdentifier,
 507             CharacterAttribute, BufferLength, StringLength, NumericAttribute);
 508 }
 509
 510
 511 /*************************************************************************
 512  *                              SQLColumns           [ODBC32.040]
 513  */
 514 SQLRETURN WINAPI SQLColumns(SQLHSTMT StatementHandle,
 515              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
 516              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
 517              SQLCHAR *TableName, SQLSMALLINT NameLength3,
 518              SQLCHAR *ColumnName, SQLSMALLINT NameLength4)
 519 {
 520         TRACE("\n");
 521
 522         CHECK_READY_AND_dmHandle();
 523
 524         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNS].func);
 525         return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNS].func)
 526             (StatementHandle, CatalogName, NameLength1,
 527             SchemaName, NameLength2, TableName, NameLength3, ColumnName, NameLength4);
 528 }
 529
 530
 531 /*************************************************************************
 532  *                              SQLConnect           [ODBC32.007]
 533  */
 534 SQLRETURN WINAPI SQLConnect(SQLHDBC ConnectionHandle,
 535              SQLCHAR *ServerName, SQLSMALLINT NameLength1,
 536              SQLCHAR *UserName, SQLSMALLINT NameLength2,
 537              SQLCHAR *Authentication, SQLSMALLINT NameLength3)
 538 {
 539         SQLRETURN ret;
 540         TRACE("(Server=%.*s)\n",NameLength1, ServerName);
 541
 542         CHECK_READY_AND_dmHandle();
 543
 544         strcpy(gProxyHandle.ServerName, ServerName);
 545         strcpy(gProxyHandle.UserName, UserName);
 546
 547         assert(gProxyHandle.functions[SQLAPI_INDEX_SQLCONNECT].func);
 548         ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLCONNECT].func)
 549             (ConnectionHandle, ServerName, NameLength1,
 550             UserName, NameLength2, Authentication, NameLength3);
 551
 552         TRACE("returns %d\n",ret);
 553         return ret;
 554 }
 555
 556
 557 /*************************************************************************
 558  *                              SQLCopyDesc           [ODBC32.028]
 559  */
 560 SQLRETURN WINAPI SQLCopyDesc(SQLHDESC SourceDescHandle, SQLHDESC TargetDescHandle)
 561 {
 562         TRACE("\n");
 563
 564         CHECK_READY_AND_dmHandle();
 565
 566         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOPYDESC].func);
 567         return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOPYDESC].func)
 568             (SourceDescHandle, TargetDescHandle);
 569 }
 570
 571
 572 /*************************************************************************
 573  *                              SQLDataSources           [ODBC32.057]
 574  */
 575 SQLRETURN WINAPI SQLDataSources(SQLHENV EnvironmentHandle,
 576              SQLUSMALLINT Direction, SQLCHAR *ServerName,
 577              SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
 578              SQLCHAR *Description, SQLSMALLINT BufferLength2,
 579              SQLSMALLINT *NameLength2)
 580 {
 581         SQLRETURN ret;
 582
 583         TRACE("EnvironmentHandle = %p\n", (LPVOID)EnvironmentHandle);
 584
 585         if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
 586         {
 587             ERR("Error: empty dm handle (gProxyHandle.dmHandle == NULL)\n");
 588             return SQL_ERROR;
 589         }
 590
 591         assert(gProxyHandle.functions[SQLAPI_INDEX_SQLDATASOURCES].func);
 592         ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLDATASOURCES].func)
 593             (EnvironmentHandle, Direction, ServerName,
 594             BufferLength1, NameLength1, Description, BufferLength2, NameLength2);
 595
 596         if (TRACE_ON(odbc))
 597         {
 598            TRACE("returns: %d \t", ret);
 599            if (*NameLength1 > 0)
 600              DPRINTF("DataSource = %s,", ServerName);
 601            if (*NameLength2 > 0)
 602              DPRINTF(" Description = %s", Description);
 603            DPRINTF("\n");
 604         }
 605
 606         return ret;
 607 }
 608
 609
 610 /*************************************************************************
 611  *                              SQLDescribeCol           [ODBC32.008]
 612  */
 613 SQLRETURN WINAPI SQLDescribeCol(SQLHSTMT StatementHandle,
 614              SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
 615              SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
 616              SQLSMALLINT *DataType, SQLUINTEGER *ColumnSize,
 617              SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
 618 {
 619         TRACE("\n");
 620
 621         CHECK_READY_AND_dmHandle();
 622
 623         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBECOL].func);
 624         return (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBECOL].func)
 625             (StatementHandle, ColumnNumber, ColumnName,
 626             BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable);
 627 }
 628
 629
 630 /*************************************************************************
 631  *                              SQLDisconnect           [ODBC32.009]
 632  */
 633 SQLRETURN WINAPI SQLDisconnect(SQLHDBC ConnectionHandle)
 634 {
 635         SQLRETURN ret;
 636         TRACE("(Handle=%lx)\n", ConnectionHandle);
 637
 638         CHECK_READY_AND_dmHandle();
 639
 640         gProxyHandle.ServerName[0] = '\0';
 641         gProxyHandle.UserName[0]   = '\0';
 642
 643         assert(gProxyHandle.functions[SQLAPI_INDEX_SQLDISCONNECT].func);
 644         ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLDISCONNECT].func) (ConnectionHandle);
 645         TRACE("returns %d\n",ret);
 646         return ret;
 647 }
 648
 649
 650 /*************************************************************************
 651  *                              SQLEndTran           [ODBC32.029]
 652  */
 653 SQLRETURN WINAPI SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT CompletionType)
 654 {
 655         TRACE("\n");
 656
 657         CHECK_READY_AND_dmHandle();
 658
 659         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLENDTRAN].func);
 660         return (gProxyHandle.functions[SQLAPI_INDEX_SQLENDTRAN].func) (HandleType, Handle, CompletionType);
 661 }
 662
 663
 664 /*************************************************************************
 665  *                              SQLError           [ODBC32.010]
 666  */
 667 SQLRETURN WINAPI SQLError(SQLHENV EnvironmentHandle,
 668              SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle,
 669              SQLCHAR *Sqlstate, SQLINTEGER *NativeError,
 670              SQLCHAR *MessageText, SQLSMALLINT BufferLength,
 671              SQLSMALLINT *TextLength)
 672 {
 673         TRACE("\n");
 674
 675         CHECK_READY_AND_dmHandle();
 676
 677         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLERROR].func);
 678         return (gProxyHandle.functions[SQLAPI_INDEX_SQLERROR].func)
 679             (EnvironmentHandle, ConnectionHandle, StatementHandle,
 680             Sqlstate, NativeError, MessageText, BufferLength, TextLength);
 681 }
 682
 683
 684 /*************************************************************************
 685  *                              SQLExecDirect           [ODBC32.011]
 686  */
 687 SQLRETURN WINAPI SQLExecDirect(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
 688 {
 689         TRACE("\n");
 690
 691         CHECK_READY_AND_dmHandle();
 692
 693         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECDIRECT].func);
 694         return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECDIRECT].func)
 695             (StatementHandle, StatementText, TextLength);
 696 }
 697
 698
 699 /*************************************************************************
 700  *                              SQLExecute           [ODBC32.012]
 701  */
 702 SQLRETURN WINAPI SQLExecute(SQLHSTMT StatementHandle)
 703 {
 704         TRACE("\n");
 705
 706         CHECK_READY_AND_dmHandle();
 707
 708         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECUTE].func);
 709         return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECUTE].func) (StatementHandle);
 710 }
 711
 712
 713 /*************************************************************************
 714  *                              SQLFetch           [ODBC32.013]
 715  */
 716 SQLRETURN WINAPI SQLFetch(SQLHSTMT StatementHandle)
 717 {
 718         TRACE("\n");
 719
 720         CHECK_READY_AND_dmHandle();
 721
 722         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCH].func);
 723         return (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCH].func) (StatementHandle);
 724 }
 725
 726
 727 /*************************************************************************
 728  *                              SQLFetchScroll          [ODBC32.030]
 729  */
 730 SQLRETURN WINAPI SQLFetchScroll(SQLHSTMT StatementHandle, SQLSMALLINT FetchOrientation, SQLINTEGER FetchOffset)
 731 {
 732         TRACE("\n");
 733
 734         CHECK_dmHandle();
 735
 736         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCHSCROLL].func);
 737         return (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCHSCROLL].func)
 738             (StatementHandle, FetchOrientation, FetchOffset);
 739 }
 740
 741
 742 /*************************************************************************
 743  *                              SQLFreeConnect           [ODBC32.014]
 744  */
 745 SQLRETURN WINAPI SQLFreeConnect(SQLHDBC ConnectionHandle)
 746 {
 747         SQLRETURN ret;
 748         TRACE("(Handle=%lx)\n",ConnectionHandle);
 749
 750         CHECK_dmHandle();
 751
 752         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREECONNECT].func);
 753         ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLFREECONNECT].func) (ConnectionHandle);
 754         TRACE("Returns %d\n",ret);
 755         return ret;
 756 }
 757
 758
 759 /*************************************************************************
 760  *                              SQLFreeEnv           [ODBC32.015]
 761  */
 762 SQLRETURN WINAPI SQLFreeEnv(SQLHENV EnvironmentHandle)
 763 {
 764         SQLRETURN ret;
 765         TRACE("(Env=%lx)\n",EnvironmentHandle);
 766
 767         CHECK_dmHandle();
 768
 769         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEENV].func);
 770         ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEENV].func) (EnvironmentHandle);
 771         TRACE("Returns %d\n",ret);
 772         return ret;
 773 }
 774
 775
 776 /*************************************************************************
 777  *                              SQLFreeHandle           [ODBC32.031]
 778  */
 779 SQLRETURN WINAPI SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
 780 {
 781         SQLRETURN ret;
 782         TRACE("(Type=%d, Handle=%lx)\n",HandleType,Handle);
 783
 784         CHECK_dmHandle();
 785
 786         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEHANDLE].func);
 787         ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEHANDLE].func)
 788             (HandleType, Handle);
 789         TRACE ("Returns %d\n",ret);
 790         return ret;
 791 }
 792
 793
 794 /*************************************************************************
 795  *                              SQLFreeStmt           [ODBC32.016]
 796  */
 797 SQLRETURN WINAPI SQLFreeStmt(SQLHSTMT StatementHandle, SQLUSMALLINT Option)
 798 {
 799         SQLRETURN ret;
 800         TRACE("(Handle %lx, Option=%d)\n",StatementHandle, Option);
 801
 802         CHECK_dmHandle();
 803
 804         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREESTMT].func);
 805         ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLFREESTMT].func)
 806             (StatementHandle, Option);
 807         TRACE("Returns %d\n",ret);
 808         return ret;
 809 }
 810
 811
 812 /*************************************************************************
 813  *                              SQLGetConnectAttr           [ODBC32.032]
 814  */
 815 SQLRETURN WINAPI SQLGetConnectAttr(SQLHDBC ConnectionHandle,
 816              SQLINTEGER Attribute, SQLPOINTER Value,
 817              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
 818 {
 819         TRACE("\n");
 820
 821         CHECK_dmHandle();
 822
 823         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTATTR].func);
 824         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTATTR].func)
 825             (ConnectionHandle, Attribute, Value,
 826             BufferLength, StringLength);
 827 }
 828
 829
 830 /*************************************************************************
 831  *                              SQLGetConnectOption       [ODBC32.042]
 832  */
 833 SQLRETURN WINAPI SQLGetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value)
 834 {
 835         TRACE("\n");
 836
 837         CHECK_dmHandle();
 838
 839         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTOPTION].func);
 840         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTOPTION].func)
 841             (ConnectionHandle, Option, Value);
 842 }
 843
 844
 845 /*************************************************************************
 846  *                              SQLGetCursorName           [ODBC32.017]
 847  */
 848 SQLRETURN WINAPI SQLGetCursorName(SQLHSTMT StatementHandle,
 849              SQLCHAR *CursorName, SQLSMALLINT BufferLength,
 850              SQLSMALLINT *NameLength)
 851 {
 852         TRACE("\n");
 853
 854         CHECK_dmHandle();
 855
 856         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCURSORNAME].func);
 857         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCURSORNAME].func)
 858             (StatementHandle, CursorName, BufferLength, NameLength);
 859 }
 860
 861
 862 /*************************************************************************
 863  *                              SQLGetData           [ODBC32.043]
 864  */
 865 SQLRETURN WINAPI SQLGetData(SQLHSTMT StatementHandle,
 866              SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
 867              SQLPOINTER TargetValue, SQLINTEGER BufferLength,
 868              SQLINTEGER *StrLen_or_Ind)
 869 {
 870         TRACE("\n");
 871
 872         CHECK_dmHandle();
 873
 874         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDATA].func);
 875         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDATA].func)
 876             (StatementHandle, ColumnNumber, TargetType,
 877             TargetValue, BufferLength, StrLen_or_Ind);
 878 }
 879
 880
 881 /*************************************************************************
 882  *                              SQLGetDescField           [ODBC32.033]
 883  */
 884 SQLRETURN WINAPI SQLGetDescField(SQLHDESC DescriptorHandle,
 885              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
 886              SQLPOINTER Value, SQLINTEGER BufferLength,
 887              SQLINTEGER *StringLength)
 888 {
 889         TRACE("\n");
 890
 891         CHECK_dmHandle();
 892
 893         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCFIELD].func);
 894         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCFIELD].func)
 895             (DescriptorHandle, RecNumber, FieldIdentifier,
 896             Value, BufferLength, StringLength);
 897 }
 898
 899
 900 /*************************************************************************
 901  *                              SQLGetDescRec           [ODBC32.034]
 902  */
 903 SQLRETURN WINAPI SQLGetDescRec(SQLHDESC DescriptorHandle,
 904              SQLSMALLINT RecNumber, SQLCHAR *Name,
 905              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
 906              SQLSMALLINT *Type, SQLSMALLINT *SubType,
 907              SQLINTEGER *Length, SQLSMALLINT *Precision,
 908              SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
 909 {
 910         TRACE("\n");
 911
 912         CHECK_dmHandle();
 913
 914         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCREC].func);
 915         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCREC].func)
 916             (DescriptorHandle, RecNumber, Name, BufferLength,
 917             StringLength, Type, SubType, Length, Precision, Scale, Nullable);
 918 }
 919
 920
 921 /*************************************************************************
 922  *                              SQLGetDiagField           [ODBC32.035]
 923  */
 924 SQLRETURN WINAPI SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
 925              SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
 926              SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
 927              SQLSMALLINT *StringLength)
 928 {
 929         TRACE("\n");
 930
 931         CHECK_dmHandle();
 932
 933         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGFIELD].func);
 934         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGFIELD].func)
 935             (HandleType, Handle, RecNumber, DiagIdentifier,
 936             DiagInfo, BufferLength, StringLength);
 937 }
 938
 939
 940 /*************************************************************************
 941  *                              SQLGetDiagRec           [ODBC32.036]
 942  */
 943 SQLRETURN WINAPI SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
 944              SQLSMALLINT RecNumber, SQLCHAR *Sqlstate,
 945              SQLINTEGER *NativeError, SQLCHAR *MessageText,
 946              SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
 947 {
 948         TRACE("\n");
 949
 950         CHECK_dmHandle();
 951
 952         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGREC].func);
 953         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGREC].func)
 954             (HandleType, Handle, RecNumber, Sqlstate, NativeError,
 955             MessageText, BufferLength, TextLength);
 956 }
 957
 958
 959 /*************************************************************************
 960  *                              SQLGetEnvAttr           [ODBC32.037]
 961  */
 962 SQLRETURN WINAPI SQLGetEnvAttr(SQLHENV EnvironmentHandle,
 963              SQLINTEGER Attribute, SQLPOINTER Value,
 964              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
 965 {
 966         TRACE("\n");
 967
 968         CHECK_dmHandle();
 969
 970         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETENVATTR].func);
 971         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETENVATTR].func)
 972             (EnvironmentHandle, Attribute, Value, BufferLength, StringLength);
 973 }
 974
 975
 976 /*************************************************************************
 977  *                              SQLGetFunctions           [ODBC32.044]
 978  */
 979 SQLRETURN WINAPI SQLGetFunctions(SQLHDBC ConnectionHandle, SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported)
 980 {
 981         TRACE("\n");
 982
 983         CHECK_dmHandle();
 984
 985         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETFUNCTIONS].func);
 986         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETFUNCTIONS].func)
 987             (ConnectionHandle, FunctionId, Supported);
 988 }
 989
 990
 991 /*************************************************************************
 992  *                              SQLGetInfo           [ODBC32.045]
 993  */
 994 SQLRETURN WINAPI SQLGetInfo(SQLHDBC ConnectionHandle,
 995              SQLUSMALLINT InfoType, SQLPOINTER InfoValue,
 996              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
 997 {
 998         TRACE("\n");
 999
1000         CHECK_dmHandle();
1001
1002         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETINFO].func);
1003         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETINFO].func)
1004             (ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength);
1005 }
1006
1007
1008 /*************************************************************************
1009  *                              SQLGetStmtAttr           [ODBC32.038]
1010  */
1011 SQLRETURN WINAPI SQLGetStmtAttr(SQLHSTMT StatementHandle,
1012              SQLINTEGER Attribute, SQLPOINTER Value,
1013              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1014 {
1015         TRACE("\n");
1016
1017         CHECK_dmHandle();
1018
1019         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTATTR].func);
1020         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTATTR].func)
1021             (StatementHandle, Attribute, Value, BufferLength, StringLength);
1022 }
1023
1024
1025 /*************************************************************************
1026  *                              SQLGetStmtOption           [ODBC32.046]
1027  */
1028 SQLRETURN WINAPI SQLGetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLPOINTER Value)
1029 {
1030         TRACE("\n");
1031
1032         CHECK_dmHandle();
1033
1034         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTOPTION].func);
1035         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTOPTION].func)
1036                 (StatementHandle, Option, Value);
1037 }
1038
1039
1040 /*************************************************************************
1041  *                              SQLGetTypeInfo           [ODBC32.047]
1042  */
1043 SQLRETURN WINAPI SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
1044 {
1045         TRACE("\n");
1046
1047         CHECK_dmHandle();
1048
1049         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETTYPEINFO].func);
1050         return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETTYPEINFO].func)
1051             (StatementHandle, DataType);
1052 }
1053
1054
1055 /*************************************************************************
1056  *                              SQLNumResultCols           [ODBC32.018]
1057  */
1058 SQLRETURN WINAPI SQLNumResultCols(SQLHSTMT StatementHandle, SQLSMALLINT *ColumnCount)
1059 {
1060         TRACE("\n");
1061
1062         CHECK_dmHandle();
1063
1064         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMRESULTCOLS].func);
1065         return (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMRESULTCOLS].func)
1066             (StatementHandle, ColumnCount);
1067 }
1068
1069
1070 /*************************************************************************
1071  *                              SQLParamData           [ODBC32.048]
1072  */
1073 SQLRETURN WINAPI SQLParamData(SQLHSTMT StatementHandle, SQLPOINTER *Value)
1074 {
1075         TRACE("\n");
1076
1077         CHECK_dmHandle();
1078
1079         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMDATA].func);
1080         return (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMDATA].func)
1081             (StatementHandle, Value);
1082 }
1083
1084
1085 /*************************************************************************
1086  *                              SQLPrepare           [ODBC32.019]
1087  */
1088 SQLRETURN WINAPI SQLPrepare(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
1089 {
1090         TRACE("\n");
1091
1092         CHECK_dmHandle();
1093
1094         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPREPARE].func);
1095         return (gProxyHandle.functions[SQLAPI_INDEX_SQLPREPARE].func)
1096             (StatementHandle, StatementText, TextLength);
1097 }
1098
1099
1100 /*************************************************************************
1101  *                              SQLPutData           [ODBC32.049]
1102  */
1103 SQLRETURN WINAPI SQLPutData(SQLHSTMT StatementHandle, SQLPOINTER Data, SQLINTEGER StrLen_or_Ind)
1104 {
1105         TRACE("\n");
1106
1107         CHECK_dmHandle();
1108
1109         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPUTDATA].func);
1110         return (gProxyHandle.functions[SQLAPI_INDEX_SQLPUTDATA].func)
1111             (StatementHandle, Data, StrLen_or_Ind);
1112 }
1113
1114
1115 /*************************************************************************
1116  *                              SQLRowCount           [ODBC32.020]
1117  */
1118 SQLRETURN WINAPI SQLRowCount(SQLHSTMT StatementHandle, SQLINTEGER *RowCount)
1119 {
1120         TRACE("\n");
1121
1122         CHECK_dmHandle();
1123
1124         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLROWCOUNT].func);
1125         return (gProxyHandle.functions[SQLAPI_INDEX_SQLROWCOUNT].func)
1126             (StatementHandle, RowCount);
1127 }
1128
1129
1130 /*************************************************************************
1131  *                              SQLSetConnectAttr           [ODBC32.039]
1132  */
1133 SQLRETURN WINAPI SQLSetConnectAttr(SQLHDBC ConnectionHandle, SQLINTEGER Attribute,
1134         SQLPOINTER Value, SQLINTEGER StringLength)
1135 {
1136         TRACE("\n");
1137
1138         CHECK_dmHandle();
1139
1140         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTATTR].func);
1141         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTATTR].func)
1142             (ConnectionHandle, Attribute, Value, StringLength);
1143 }
1144
1145
1146 /*************************************************************************
1147  *                              SQLSetConnectOption           [ODBC32.050]
1148  */
1149 SQLRETURN WINAPI SQLSetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLUINTEGER Value)
1150 {
1151         TRACE("\n");
1152
1153         CHECK_dmHandle();
1154
1155         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTOPTION].func);
1156         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTOPTION].func)
1157             (ConnectionHandle, Option, Value);
1158 }
1159
1160
1161 /*************************************************************************
1162  *                              SQLSetCursorName           [ODBC32.021]
1163  */
1164 SQLRETURN WINAPI SQLSetCursorName(SQLHSTMT StatementHandle, SQLCHAR *CursorName, SQLSMALLINT NameLength)
1165 {
1166         TRACE("\n");
1167
1168         CHECK_dmHandle();
1169
1170         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCURSORNAME].func);
1171         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCURSORNAME].func)
1172             (StatementHandle, CursorName, NameLength);
1173 }
1174
1175
1176 /*************************************************************************
1177  *                              SQLSetDescField           [ODBC32.073]
1178  */
1179 SQLRETURN WINAPI SQLSetDescField(SQLHDESC DescriptorHandle,
1180              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
1181              SQLPOINTER Value, SQLINTEGER BufferLength)
1182 {
1183         TRACE("\n");
1184
1185         CHECK_dmHandle();
1186
1187         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCFIELD].func);
1188         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCFIELD].func)
1189             (DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength);
1190 }
1191
1192
1193 /*************************************************************************
1194  *                              SQLSetDescRec           [ODBC32.074]
1195  */
1196 SQLRETURN WINAPI SQLSetDescRec(SQLHDESC DescriptorHandle,
1197              SQLSMALLINT RecNumber, SQLSMALLINT Type,
1198              SQLSMALLINT SubType, SQLINTEGER Length,
1199              SQLSMALLINT Precision, SQLSMALLINT Scale,
1200              SQLPOINTER Data, SQLINTEGER *StringLength,
1201              SQLINTEGER *Indicator)
1202 {
1203         TRACE("\n");
1204
1205         CHECK_dmHandle();
1206
1207         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCREC].func);
1208         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCREC].func)
1209             (DescriptorHandle, RecNumber, Type, SubType, Length,
1210             Precision, Scale, Data, StringLength, Indicator);
1211 }
1212
1213
1214 /*************************************************************************
1215  *                              SQLSetEnvAttr           [ODBC32.075]
1216  */
1217 SQLRETURN WINAPI SQLSetEnvAttr(SQLHENV EnvironmentHandle,
1218              SQLINTEGER Attribute, SQLPOINTER Value,
1219              SQLINTEGER StringLength)
1220 {
1221         TRACE("\n");
1222
1223         CHECK_dmHandle();
1224
1225         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETENVATTR].func);
1226         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETENVATTR].func)
1227             (EnvironmentHandle, Attribute, Value, StringLength);
1228 }
1229
1230
1231 /*************************************************************************
1232  *                              SQLSetParam           [ODBC32.022]
1233  */
1234 SQLRETURN WINAPI SQLSetParam(SQLHSTMT StatementHandle,
1235              SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
1236              SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
1237              SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
1238              SQLINTEGER *StrLen_or_Ind)
1239 {
1240         TRACE("\n");
1241
1242         CHECK_dmHandle();
1243
1244         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPARAM].func);
1245         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPARAM].func)
1246             (StatementHandle, ParameterNumber, ValueType, ParameterType, LengthPrecision,
1247              ParameterScale, ParameterValue, StrLen_or_Ind);
1248 }
1249
1250
1251 /*************************************************************************
1252  *                              SQLSetStmtAttr           [ODBC32.076]
1253  */
1254 SQLRETURN WINAPI SQLSetStmtAttr(SQLHSTMT StatementHandle,
1255                  SQLINTEGER Attribute, SQLPOINTER Value,
1256                  SQLINTEGER StringLength)
1257 {
1258         TRACE("\n");
1259
1260         CHECK_dmHandle();
1261
1262         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTATTR].func);
1263         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTATTR].func)
1264             (StatementHandle, Attribute, Value, StringLength);
1265 }
1266
1267
1268 /*************************************************************************
1269  *                              SQLSetStmtOption           [ODBC32.051]
1270  */
1271 SQLRETURN WINAPI SQLSetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLUINTEGER Value)
1272 {
1273         TRACE("\n");
1274
1275         CHECK_dmHandle();
1276
1277         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTOPTION].func);
1278         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTOPTION].func)
1279             (StatementHandle, Option, Value);
1280 }
1281
1282
1283 /*************************************************************************
1284  *                              SQLSpecialColumns           [ODBC32.052]
1285  */
1286 SQLRETURN WINAPI SQLSpecialColumns(SQLHSTMT StatementHandle,
1287              SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,
1288              SQLSMALLINT NameLength1, SQLCHAR *SchemaName,
1289              SQLSMALLINT NameLength2, SQLCHAR *TableName,
1290              SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
1291              SQLUSMALLINT Nullable)
1292 {
1293
1294         CHECK_dmHandle();
1295
1296         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSPECIALCOLUMNS].func);
1297         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSPECIALCOLUMNS].func)
1298             (StatementHandle, IdentifierType, CatalogName, NameLength1, SchemaName,
1299              NameLength2, TableName, NameLength3, Scope, Nullable);
1300 }
1301
1302
1303 /*************************************************************************
1304  *                              SQLStatistics           [ODBC32.053]
1305  */
1306 SQLRETURN WINAPI SQLStatistics(SQLHSTMT StatementHandle,
1307              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
1308              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
1309              SQLCHAR *TableName, SQLSMALLINT NameLength3,
1310              SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
1311 {
1312         TRACE("\n");
1313
1314         CHECK_dmHandle();
1315
1316         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSTATISTICS].func);
1317         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSTATISTICS].func)
1318             (StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
1319              TableName, NameLength3, Unique, Reserved);
1320 }
1321
1322
1323 /*************************************************************************
1324  *                              SQLTables           [ODBC32.054]
1325  */
1326 SQLRETURN WINAPI SQLTables(SQLHSTMT StatementHandle,
1327              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
1328              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
1329              SQLCHAR *TableName, SQLSMALLINT NameLength3,
1330              SQLCHAR *TableType, SQLSMALLINT NameLength4)
1331 {
1332         TRACE("\n");
1333
1334         CHECK_dmHandle();
1335
1336         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLES].func);
1337         return (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLES].func)
1338                 (StatementHandle, CatalogName, NameLength1,
1339                 SchemaName, NameLength2, TableName, NameLength3, TableType, NameLength4);
1340 }
1341
1342
1343 /*************************************************************************
1344  *                              SQLTransact           [ODBC32.023]
1345  */
1346 SQLRETURN WINAPI SQLTransact(SQLHENV EnvironmentHandle, SQLHDBC ConnectionHandle,
1347         SQLUSMALLINT CompletionType)
1348 {
1349         TRACE("\n");
1350
1351         CHECK_dmHandle();
1352
1353         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTRANSACT].func);
1354         return (gProxyHandle.functions[SQLAPI_INDEX_SQLTRANSACT].func)
1355             (EnvironmentHandle, ConnectionHandle, CompletionType);
1356 }
1357
1358
1359 /*************************************************************************
1360  *                              SQLBrowseConnect           [ODBC32.055]
1361  */
1362 SQLRETURN WINAPI SQLBrowseConnect(
1363     SQLHDBC            hdbc,
1364     SQLCHAR               *szConnStrIn,
1365     SQLSMALLINT        cbConnStrIn,
1366     SQLCHAR               *szConnStrOut,
1367     SQLSMALLINT        cbConnStrOutMax,
1368     SQLSMALLINT       *pcbConnStrOut)
1369 {
1370         TRACE("\n");
1371
1372         CHECK_dmHandle();
1373
1374         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBROWSECONNECT].func);
1375         return (gProxyHandle.functions[SQLAPI_INDEX_SQLBROWSECONNECT].func)
1376                 (hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
1377 }
1378
1379
1380 /*************************************************************************
1381  *                              SQLBulkOperations           [ODBC32.078]
1382  */
1383 SQLRETURN WINAPI  SQLBulkOperations(
1384         SQLHSTMT                        StatementHandle,
1385         SQLSMALLINT                     Operation)
1386 {
1387         TRACE("\n");
1388
1389         CHECK_dmHandle();
1390
1391         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBULKOPERATIONS].func);
1392         return (gProxyHandle.functions[SQLAPI_INDEX_SQLBULKOPERATIONS].func)
1393                    (StatementHandle, Operation);
1394 }
1395
1396
1397 /*************************************************************************
1398  *                              SQLColAttributes           [ODBC32.006]
1399  */
1400 SQLRETURN WINAPI SQLColAttributes(
1401     SQLHSTMT           hstmt,
1402     SQLUSMALLINT       icol,
1403     SQLUSMALLINT       fDescType,
1404     SQLPOINTER         rgbDesc,
1405     SQLSMALLINT        cbDescMax,
1406     SQLSMALLINT           *pcbDesc,
1407     SQLINTEGER            *pfDesc)
1408 {
1409         TRACE("\n");
1410
1411         CHECK_dmHandle();
1412
1413         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTES].func);
1414         return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTES].func)
1415                    (hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
1416 }
1417
1418
1419 /*************************************************************************
1420  *                              SQLColumnPrivileges           [ODBC32.056]
1421  */
1422 SQLRETURN WINAPI SQLColumnPrivileges(
1423     SQLHSTMT           hstmt,
1424     SQLCHAR               *szCatalogName,
1425     SQLSMALLINT        cbCatalogName,
1426     SQLCHAR               *szSchemaName,
1427     SQLSMALLINT        cbSchemaName,
1428     SQLCHAR               *szTableName,
1429     SQLSMALLINT        cbTableName,
1430     SQLCHAR               *szColumnName,
1431     SQLSMALLINT        cbColumnName)
1432 {
1433         TRACE("\n");
1434
1435         CHECK_dmHandle();
1436
1437         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNPRIVILEGES].func);
1438         return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNPRIVILEGES].func)
1439                    (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1440                     szTableName, cbTableName, szColumnName, cbColumnName);
1441 }
1442
1443
1444 /*************************************************************************
1445  *                              SQLDescribeParam          [ODBC32.058]
1446  */
1447 SQLRETURN WINAPI SQLDescribeParam(
1448     SQLHSTMT           hstmt,
1449     SQLUSMALLINT       ipar,
1450     SQLSMALLINT           *pfSqlType,
1451     SQLUINTEGER           *pcbParamDef,
1452     SQLSMALLINT           *pibScale,
1453     SQLSMALLINT           *pfNullable)
1454 {
1455         TRACE("\n");
1456
1457         CHECK_dmHandle();
1458
1459         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBEPARAM].func);
1460         return (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBEPARAM].func)
1461                    (hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable);
1462 }
1463
1464
1465 /*************************************************************************
1466  *                              SQLExtendedFetch           [ODBC32.059]
1467  */
1468 SQLRETURN WINAPI SQLExtendedFetch(
1469     SQLHSTMT           hstmt,
1470     SQLUSMALLINT       fFetchType,
1471     SQLINTEGER         irow,
1472     SQLUINTEGER           *pcrow,
1473     SQLUSMALLINT          *rgfRowStatus)
1474 {
1475         TRACE("\n");
1476
1477         CHECK_dmHandle();
1478
1479         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXTENDEDFETCH].func);
1480         return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXTENDEDFETCH].func)
1481                    (hstmt, fFetchType, irow, pcrow, rgfRowStatus);
1482 }
1483
1484
1485 /*************************************************************************
1486  *                              SQLForeignKeys           [ODBC32.060]
1487  */
1488 SQLRETURN WINAPI SQLForeignKeys(
1489     SQLHSTMT           hstmt,
1490     SQLCHAR               *szPkCatalogName,
1491     SQLSMALLINT        cbPkCatalogName,
1492     SQLCHAR               *szPkSchemaName,
1493     SQLSMALLINT        cbPkSchemaName,
1494     SQLCHAR               *szPkTableName,
1495     SQLSMALLINT        cbPkTableName,
1496     SQLCHAR               *szFkCatalogName,
1497     SQLSMALLINT        cbFkCatalogName,
1498     SQLCHAR               *szFkSchemaName,
1499     SQLSMALLINT        cbFkSchemaName,
1500     SQLCHAR               *szFkTableName,
1501     SQLSMALLINT        cbFkTableName)
1502 {
1503         TRACE("\n");
1504
1505         CHECK_dmHandle();
1506
1507         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFOREIGNKEYS].func);
1508         return (gProxyHandle.functions[SQLAPI_INDEX_SQLFOREIGNKEYS].func)
1509                    (hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName, cbPkSchemaName,
1510                     szPkTableName, cbPkTableName, szFkCatalogName, cbFkCatalogName, szFkSchemaName,
1511                         cbFkSchemaName, szFkTableName, cbFkTableName);
1512 }
1513
1514
1515 /*************************************************************************
1516  *                              SQLMoreResults           [ODBC32.061]
1517  */
1518 SQLRETURN WINAPI SQLMoreResults(SQLHSTMT hstmt)
1519 {
1520         TRACE("\n");
1521
1522         CHECK_dmHandle();
1523
1524         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLMORERESULTS].func);
1525         return (gProxyHandle.functions[SQLAPI_INDEX_SQLMORERESULTS].func) (hstmt);
1526 }
1527
1528
1529 /*************************************************************************
1530  *                              SQLNativeSql           [ODBC32.062]
1531  */
1532 SQLRETURN WINAPI SQLNativeSql(
1533     SQLHDBC            hdbc,
1534     SQLCHAR               *szSqlStrIn,
1535     SQLINTEGER         cbSqlStrIn,
1536     SQLCHAR               *szSqlStr,
1537     SQLINTEGER         cbSqlStrMax,
1538     SQLINTEGER            *pcbSqlStr)
1539 {
1540         TRACE("\n");
1541
1542         CHECK_dmHandle();
1543
1544         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNATIVESQL].func);
1545         return (gProxyHandle.functions[SQLAPI_INDEX_SQLNATIVESQL].func)
1546                    (hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr);
1547 }
1548
1549
1550 /*************************************************************************
1551  *                              SQLNumParams           [ODBC32.063]
1552  */
1553 SQLRETURN WINAPI SQLNumParams(
1554     SQLHSTMT           hstmt,
1555     SQLSMALLINT           *pcpar)
1556 {
1557         TRACE("\n");
1558
1559         CHECK_dmHandle();
1560
1561         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMPARAMS].func);
1562         return (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMPARAMS].func) (hstmt, pcpar);
1563 }
1564
1565
1566 /*************************************************************************
1567  *                              SQLParamOptions           [ODBC32.064]
1568  */
1569 SQLRETURN WINAPI SQLParamOptions(
1570     SQLHSTMT           hstmt,
1571     SQLUINTEGER        crow,
1572     SQLUINTEGER           *pirow)
1573 {
1574         TRACE("\n");
1575
1576         CHECK_dmHandle();
1577
1578         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMOPTIONS].func);
1579         return (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMOPTIONS].func) (hstmt, crow, pirow);
1580 }
1581
1582
1583 /*************************************************************************
1584  *                              SQLPrimaryKeys           [ODBC32.065]
1585  */
1586 SQLRETURN WINAPI SQLPrimaryKeys(
1587     SQLHSTMT           hstmt,
1588     SQLCHAR               *szCatalogName,
1589     SQLSMALLINT        cbCatalogName,
1590     SQLCHAR               *szSchemaName,
1591     SQLSMALLINT        cbSchemaName,
1592     SQLCHAR               *szTableName,
1593     SQLSMALLINT        cbTableName)
1594 {
1595         TRACE("\n");
1596
1597         CHECK_dmHandle();
1598
1599         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPRIMARYKEYS].func);
1600         return (gProxyHandle.functions[SQLAPI_INDEX_SQLPRIMARYKEYS].func)
1601                    (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1602                     szTableName, cbTableName);
1603 }
1604
1605
1606 /*************************************************************************
1607  *                              SQLProcedureColumns           [ODBC32.066]
1608  */
1609 SQLRETURN WINAPI SQLProcedureColumns(
1610     SQLHSTMT           hstmt,
1611     SQLCHAR               *szCatalogName,
1612     SQLSMALLINT        cbCatalogName,
1613     SQLCHAR               *szSchemaName,
1614     SQLSMALLINT        cbSchemaName,
1615     SQLCHAR               *szProcName,
1616     SQLSMALLINT        cbProcName,
1617     SQLCHAR               *szColumnName,
1618     SQLSMALLINT        cbColumnName)
1619 {
1620         TRACE("\n");
1621
1622         CHECK_dmHandle();
1623
1624         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURECOLUMNS].func);
1625         return (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURECOLUMNS].func)
1626                    (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1627                     szProcName, cbProcName, szColumnName, cbColumnName);
1628 }
1629
1630
1631 /*************************************************************************
1632  *                              SQLProcedures           [ODBC32.067]
1633  */
1634 SQLRETURN WINAPI SQLProcedures(
1635     SQLHSTMT           hstmt,
1636     SQLCHAR               *szCatalogName,
1637     SQLSMALLINT        cbCatalogName,
1638     SQLCHAR               *szSchemaName,
1639     SQLSMALLINT        cbSchemaName,
1640     SQLCHAR               *szProcName,
1641     SQLSMALLINT        cbProcName)
1642 {
1643         TRACE("\n");
1644
1645         CHECK_dmHandle();
1646
1647         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURES].func);
1648         return (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURES].func)
1649                    (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1650                     szProcName, cbProcName);
1651 }
1652
1653
1654 /*************************************************************************
1655  *                              SQLSetPos           [ODBC32.068]
1656  */
1657 SQLRETURN WINAPI SQLSetPos(
1658     SQLHSTMT           hstmt,
1659     SQLUSMALLINT       irow,
1660     SQLUSMALLINT       fOption,
1661     SQLUSMALLINT       fLock)
1662 {
1663         TRACE("\n");
1664
1665         CHECK_dmHandle();
1666
1667         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPOS].func);
1668         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPOS].func)
1669                    (hstmt, irow, fOption, fLock);
1670 }
1671
1672
1673 /*************************************************************************
1674  *                              SQLTablePrivileges           [ODBC32.070]
1675  */
1676 SQLRETURN WINAPI SQLTablePrivileges(
1677     SQLHSTMT           hstmt,
1678     SQLCHAR               *szCatalogName,
1679     SQLSMALLINT        cbCatalogName,
1680     SQLCHAR               *szSchemaName,
1681     SQLSMALLINT        cbSchemaName,
1682     SQLCHAR               *szTableName,
1683     SQLSMALLINT        cbTableName)
1684 {
1685         TRACE("\n");
1686
1687         CHECK_dmHandle();
1688
1689         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLEPRIVILEGES].func);
1690         return (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLEPRIVILEGES].func)
1691                    (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1692                     szTableName, cbTableName);
1693 }
1694
1695
1696 /*************************************************************************
1697  *                              SQLDrivers           [ODBC32.071]
1698  */
1699 SQLRETURN WINAPI SQLDrivers(
1700     SQLHENV            henv,
1701     SQLUSMALLINT       fDirection,
1702     SQLCHAR               *szDriverDesc,
1703     SQLSMALLINT        cbDriverDescMax,
1704     SQLSMALLINT           *pcbDriverDesc,
1705     SQLCHAR               *szDriverAttributes,
1706     SQLSMALLINT        cbDriverAttrMax,
1707     SQLSMALLINT           *pcbDriverAttr)
1708 {
1709         TRACE("\n");
1710
1711         CHECK_dmHandle();
1712
1713         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERS].func);
1714         return (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERS].func)
1715                 (henv, fDirection, szDriverDesc, cbDriverDescMax, pcbDriverDesc,
1716                  szDriverAttributes, cbDriverAttrMax, pcbDriverAttr);
1717 }
1718
1719
1720 /*************************************************************************
1721  *                              SQLBindParameter           [ODBC32.072]
1722  */
1723 SQLRETURN WINAPI SQLBindParameter(
1724     SQLHSTMT           hstmt,
1725     SQLUSMALLINT       ipar,
1726     SQLSMALLINT        fParamType,
1727     SQLSMALLINT        fCType,
1728     SQLSMALLINT        fSqlType,
1729     SQLUINTEGER        cbColDef,
1730     SQLSMALLINT        ibScale,
1731     SQLPOINTER         rgbValue,
1732     SQLINTEGER         cbValueMax,
1733     SQLINTEGER            *pcbValue)
1734 {
1735         TRACE("\n");
1736
1737         CHECK_dmHandle();
1738
1739         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAMETER].func);
1740         return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAMETER].func)
1741                 (hstmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale,
1742                  rgbValue, cbValueMax, pcbValue);
1743 }
1744
1745
1746 /*************************************************************************
1747  *                              SQLDriverConnect           [ODBC32.041]
1748  */
1749 SQLRETURN WINAPI SQLDriverConnect(
1750     SQLHDBC            hdbc,
1751     SQLHWND            hwnd,
1752     SQLCHAR            *conn_str_in,
1753     SQLSMALLINT        len_conn_str_in,
1754     SQLCHAR            *conn_str_out,
1755     SQLSMALLINT        conn_str_out_max,
1756     SQLSMALLINT        *ptr_conn_str_out,
1757     SQLUSMALLINT       driver_completion )
1758 {
1759         TRACE("\n");
1760
1761         CHECK_dmHandle();
1762
1763         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERCONNECT].func);
1764         return (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERCONNECT].func)
1765                  (hdbc, hwnd, conn_str_in, len_conn_str_in, conn_str_out,
1766                   conn_str_out_max, ptr_conn_str_out, driver_completion);
1767 }
1768
1769
1770 /*************************************************************************
1771  *                              SQLSetScrollOptions           [ODBC32.069]
1772  */
1773 SQLRETURN WINAPI SQLSetScrollOptions(
1774     SQLHSTMT           statement_handle,
1775     SQLUSMALLINT       f_concurrency,
1776     SQLINTEGER         crow_keyset,
1777     SQLUSMALLINT       crow_rowset )
1778 {
1779         TRACE("\n");
1780
1781         CHECK_dmHandle();
1782
1783         assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSCROLLOPTIONS].func);
1784         return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSCROLLOPTIONS].func)
1785                    (statement_handle, f_concurrency, crow_keyset, crow_rowset);
1786 }
1787
1788 /* End of file */