dlls/odbc32/proxyodbc.c

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