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