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