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