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