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