reactos/dll/win32/odbc32/proxyodbc.c

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