git.oblomov.eu Git - wine/blob - dlls/odbc32/proxyodbc.c

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