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