dll/win32/odbc32/proxyodbc.c

   1 /*
   2  * Win32 ODBC functions
   3  *
   4  * Copyright 1999 Xiang Li, Corel Corporation
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * NOTES:
  21  *   Proxy ODBC driver manager.  This manager delegates all ODBC
  22  *   calls to a real ODBC driver manager named by the environment
  23  *   variable LIB_ODBC_DRIVER_MANAGER, or to libodbc.so if the
  24  *   variable is not set.
  25  *
  26  */
  27
  28 #include "config.h"
  29 #include "wine/port.h"
  30
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <assert.h>
  36
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winreg.h"
  40 #ifndef __REACTOS__
  41 #include "wine/debug.h"
  42 #endif
  43 #include "wine/library.h"
  44 #include "wine/unicode.h"
  45
  46 #include "sql.h"
  47 #include "sqltypes.h"
  48 #include "sqlext.h"
  49
  50 #ifdef __REACTOS__
  51 #undef TRACE_ON
  52 #include <wine/debug.h>
  53 #endif
  54
  55 static BOOL ODBC_LoadDriverManager(void);
  56 static BOOL ODBC_LoadDMFunctions(void);
  57
  58 WINE_DEFAULT_DEBUG_CHANNEL(odbc);
  59 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  60
  61 static SQLRETURN (*pSQLAllocConnect)(SQLHENV,SQLHDBC*);
  62 static SQLRETURN (*pSQLAllocEnv)(SQLHENV*);
  63 static SQLRETURN (*pSQLAllocHandle)(SQLSMALLINT,SQLHANDLE,SQLHANDLE*);
  64 static SQLRETURN (*pSQLAllocHandleStd)(SQLSMALLINT,SQLHANDLE,SQLHANDLE*);
  65 static SQLRETURN (*pSQLAllocStmt)(SQLHDBC,SQLHSTMT*);
  66 static SQLRETURN (*pSQLBindCol)(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLPOINTER,SQLLEN,SQLLEN*);
  67 static SQLRETURN (*pSQLBindParam)(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLULEN,SQLSMALLINT,SQLPOINTER,SQLLEN*);
  68 static SQLRETURN (*pSQLBindParameter)(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLULEN,SQLSMALLINT,SQLPOINTER,SQLLEN,SQLLEN*);
  69 static SQLRETURN (*pSQLBrowseConnect)(SQLHDBC,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*);
  70 static SQLRETURN (*pSQLBrowseConnectW)(SQLHDBC,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*);
  71 static SQLRETURN (*pSQLBulkOperations)(SQLHSTMT,SQLSMALLINT);
  72 static SQLRETURN (*pSQLCancel)(SQLHSTMT);
  73 static SQLRETURN (*pSQLCloseCursor)(SQLHSTMT);
  74 static SQLRETURN (*pSQLColAttribute)(SQLHSTMT,SQLUSMALLINT,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*,SQLLEN*);
  75 static SQLRETURN (*pSQLColAttributeW)(SQLHSTMT,SQLUSMALLINT,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*,SQLLEN*);
  76 static SQLRETURN (*pSQLColAttributes)(SQLHSTMT,SQLUSMALLINT,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*,SQLLEN*);
  77 static SQLRETURN (*pSQLColAttributesW)(SQLHSTMT,SQLUSMALLINT,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*,SQLLEN*);
  78 static SQLRETURN (*pSQLColumnPrivileges)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
  79 static SQLRETURN (*pSQLColumnPrivilegesW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
  80 static SQLRETURN (*pSQLColumns)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
  81 static SQLRETURN (*pSQLColumnsW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
  82 static SQLRETURN (*pSQLConnect)(SQLHDBC,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
  83 static SQLRETURN (*pSQLConnectW)(SQLHDBC,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
  84 static SQLRETURN (*pSQLCopyDesc)(SQLHDESC,SQLHDESC);
  85 static SQLRETURN (*pSQLDataSources)(SQLHENV,SQLUSMALLINT,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*);
  86 static SQLRETURN (*pSQLDataSourcesA)(SQLHENV,SQLUSMALLINT,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*);
  87 static SQLRETURN (*pSQLDataSourcesW)(SQLHENV,SQLUSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*);
  88 static SQLRETURN (*pSQLDescribeCol)(SQLHSTMT,SQLUSMALLINT,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLSMALLINT*,SQLULEN*,SQLSMALLINT*,SQLSMALLINT*);
  89 static SQLRETURN (*pSQLDescribeColW)(SQLHSTMT,SQLUSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLSMALLINT*,SQLULEN*,SQLSMALLINT*,SQLSMALLINT*);
  90 static SQLRETURN (*pSQLDescribeParam)(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT*,SQLULEN*,SQLSMALLINT*,SQLSMALLINT*);
  91 static SQLRETURN (*pSQLDisconnect)(SQLHDBC);
  92 static SQLRETURN (*pSQLDriverConnect)(SQLHDBC,SQLHWND,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLUSMALLINT);
  93 static SQLRETURN (*pSQLDriverConnectW)(SQLHDBC,SQLHWND,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLUSMALLINT);
  94 static SQLRETURN (*pSQLDrivers)(SQLHENV,SQLUSMALLINT,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*);
  95 static SQLRETURN (*pSQLDriversW)(SQLHENV,SQLUSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*);
  96 static SQLRETURN (*pSQLEndTran)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT);
  97 static SQLRETURN (*pSQLError)(SQLHENV,SQLHDBC,SQLHSTMT,SQLCHAR*,SQLINTEGER*,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*);
  98 static SQLRETURN (*pSQLErrorW)(SQLHENV,SQLHDBC,SQLHSTMT,SQLWCHAR*,SQLINTEGER*,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*);
  99 static SQLRETURN (*pSQLExecDirect)(SQLHSTMT,SQLCHAR*,SQLINTEGER);
 100 static SQLRETURN (*pSQLExecDirectW)(SQLHSTMT,SQLWCHAR*,SQLINTEGER);
 101 static SQLRETURN (*pSQLExecute)(SQLHSTMT);
 102 static SQLRETURN (*pSQLExtendedFetch)(SQLHSTMT,SQLUSMALLINT,SQLLEN,SQLULEN*,SQLUSMALLINT*);
 103 static SQLRETURN (*pSQLFetch)(SQLHSTMT);
 104 static SQLRETURN (*pSQLFetchScroll)(SQLHSTMT,SQLSMALLINT,SQLLEN);
 105 static SQLRETURN (*pSQLForeignKeys)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
 106 static SQLRETURN (*pSQLForeignKeysW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
 107 static SQLRETURN (*pSQLFreeConnect)(SQLHDBC);
 108 static SQLRETURN (*pSQLFreeEnv)(SQLHENV);
 109 static SQLRETURN (*pSQLFreeHandle)(SQLSMALLINT,SQLHANDLE);
 110 static SQLRETURN (*pSQLFreeStmt)(SQLHSTMT,SQLUSMALLINT);
 111 static SQLRETURN (*pSQLGetConnectAttr)(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*);
 112 static SQLRETURN (*pSQLGetConnectAttrW)(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*);
 113 static SQLRETURN (*pSQLGetConnectOption)(SQLHDBC,SQLUSMALLINT,SQLPOINTER);
 114 static SQLRETURN (*pSQLGetConnectOptionW)(SQLHDBC,SQLUSMALLINT,SQLPOINTER);
 115 static SQLRETURN (*pSQLGetCursorName)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*);
 116 static SQLRETURN (*pSQLGetCursorNameW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*);
 117 static SQLRETURN (*pSQLGetData)(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLPOINTER,SQLLEN,SQLLEN*);
 118 static SQLRETURN (*pSQLGetDescField)(SQLHDESC,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLINTEGER,SQLINTEGER*);
 119 static SQLRETURN (*pSQLGetDescFieldW)(SQLHDESC,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLINTEGER,SQLINTEGER*);
 120 static SQLRETURN (*pSQLGetDescRec)(SQLHDESC,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLSMALLINT*,SQLSMALLINT*,SQLLEN*,SQLSMALLINT*,SQLSMALLINT*,SQLSMALLINT*);
 121 static SQLRETURN (*pSQLGetDescRecW)(SQLHDESC,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*,SQLSMALLINT*,SQLSMALLINT*,SQLLEN*,SQLSMALLINT*,SQLSMALLINT*,SQLSMALLINT*);
 122 static SQLRETURN (*pSQLGetDiagField)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*);
 123 static SQLRETURN (*pSQLGetDiagFieldW)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*);
 124 static SQLRETURN (*pSQLGetDiagRec)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLCHAR*,SQLINTEGER*,SQLCHAR*,SQLSMALLINT,SQLSMALLINT*);
 125 static SQLRETURN (*pSQLGetDiagRecW)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLWCHAR*,SQLINTEGER*,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*);
 126 static SQLRETURN (*pSQLGetEnvAttr)(SQLHENV,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*);
 127 static SQLRETURN (*pSQLGetFunctions)(SQLHDBC,SQLUSMALLINT,SQLUSMALLINT*);
 128 static SQLRETURN (*pSQLGetInfo)(SQLHDBC,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*);
 129 static SQLRETURN (*pSQLGetInfoW)(SQLHDBC,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*);
 130 static SQLRETURN (*pSQLGetStmtAttr)(SQLHSTMT,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*);
 131 static SQLRETURN (*pSQLGetStmtAttrW)(SQLHSTMT,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*);
 132 static SQLRETURN (*pSQLGetStmtOption)(SQLHSTMT,SQLUSMALLINT,SQLPOINTER);
 133 static SQLRETURN (*pSQLGetTypeInfo)(SQLHSTMT,SQLSMALLINT);
 134 static SQLRETURN (*pSQLGetTypeInfoW)(SQLHSTMT,SQLSMALLINT);
 135 static SQLRETURN (*pSQLMoreResults)(SQLHSTMT);
 136 static SQLRETURN (*pSQLNativeSql)(SQLHDBC,SQLCHAR*,SQLINTEGER,SQLCHAR*,SQLINTEGER,SQLINTEGER*);
 137 static SQLRETURN (*pSQLNativeSqlW)(SQLHDBC,SQLWCHAR*,SQLINTEGER,SQLWCHAR*,SQLINTEGER,SQLINTEGER*);
 138 static SQLRETURN (*pSQLNumParams)(SQLHSTMT,SQLSMALLINT*);
 139 static SQLRETURN (*pSQLNumResultCols)(SQLHSTMT,SQLSMALLINT*);
 140 static SQLRETURN (*pSQLParamData)(SQLHSTMT,SQLPOINTER*);
 141 static SQLRETURN (*pSQLParamOptions)(SQLHSTMT,SQLULEN,SQLULEN*);
 142 static SQLRETURN (*pSQLPrepare)(SQLHSTMT,SQLCHAR*,SQLINTEGER);
 143 static SQLRETURN (*pSQLPrepareW)(SQLHSTMT,SQLWCHAR*,SQLINTEGER);
 144 static SQLRETURN (*pSQLPrimaryKeys)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
 145 static SQLRETURN (*pSQLPrimaryKeysW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
 146 static SQLRETURN (*pSQLProcedureColumns)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
 147 static SQLRETURN (*pSQLProcedureColumnsW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
 148 static SQLRETURN (*pSQLProcedures)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
 149 static SQLRETURN (*pSQLProceduresW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
 150 static SQLRETURN (*pSQLPutData)(SQLHSTMT,SQLPOINTER,SQLLEN);
 151 static SQLRETURN (*pSQLRowCount)(SQLHSTMT,SQLLEN*);
 152 static SQLRETURN (*pSQLSetConnectAttr)(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER);
 153 static SQLRETURN (*pSQLSetConnectAttrW)(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER);
 154 static SQLRETURN (*pSQLSetConnectOption)(SQLHDBC,SQLUSMALLINT,SQLULEN);
 155 static SQLRETURN (*pSQLSetConnectOptionW)(SQLHDBC,SQLUSMALLINT,SQLULEN);
 156 static SQLRETURN (*pSQLSetCursorName)(SQLHSTMT,SQLCHAR*,SQLSMALLINT);
 157 static SQLRETURN (*pSQLSetCursorNameW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT);
 158 static SQLRETURN (*pSQLSetDescField)(SQLHDESC,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLINTEGER);
 159 static SQLRETURN (*pSQLSetDescFieldW)(SQLHDESC,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLINTEGER);
 160 static SQLRETURN (*pSQLSetDescRec)(SQLHDESC,SQLSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLLEN,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLLEN*,SQLLEN*);
 161 static SQLRETURN (*pSQLSetEnvAttr)(SQLHENV,SQLINTEGER,SQLPOINTER,SQLINTEGER);
 162 static SQLRETURN (*pSQLSetParam)(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLULEN,SQLSMALLINT,SQLPOINTER,SQLLEN*);
 163 static SQLRETURN (*pSQLSetPos)(SQLHSTMT,SQLSETPOSIROW,SQLUSMALLINT,SQLUSMALLINT);
 164 static SQLRETURN (*pSQLSetScrollOptions)(SQLHSTMT,SQLUSMALLINT,SQLLEN,SQLUSMALLINT);
 165 static SQLRETURN (*pSQLSetStmtAttr)(SQLHSTMT,SQLINTEGER,SQLPOINTER,SQLINTEGER);
 166 static SQLRETURN (*pSQLSetStmtAttrW)(SQLHSTMT,SQLINTEGER,SQLPOINTER,SQLINTEGER);
 167 static SQLRETURN (*pSQLSetStmtOption)(SQLHSTMT,SQLUSMALLINT,SQLULEN);
 168 static SQLRETURN (*pSQLSpecialColumns)(SQLHSTMT,SQLUSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLUSMALLINT,SQLUSMALLINT);
 169 static SQLRETURN (*pSQLSpecialColumnsW)(SQLHSTMT,SQLUSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLUSMALLINT,SQLUSMALLINT);
 170 static SQLRETURN (*pSQLStatistics)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLUSMALLINT,SQLUSMALLINT);
 171 static SQLRETURN (*pSQLStatisticsW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLUSMALLINT,SQLUSMALLINT);
 172 static SQLRETURN (*pSQLTablePrivileges)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
 173 static SQLRETURN (*pSQLTablePrivilegesW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
 174 static SQLRETURN (*pSQLTables)(SQLHSTMT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);
 175 static SQLRETURN (*pSQLTablesW)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT);
 176 static SQLRETURN (*pSQLTransact)(SQLHENV,SQLHDBC,SQLUSMALLINT);
 177 static SQLRETURN (*pSQLGetDiagRecA)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLCHAR*,SQLINTEGER*,
 178                                     SQLCHAR*,SQLSMALLINT,SQLSMALLINT*);
 179
 180 #define ERROR_FREE 0
 181 #define ERROR_SQLERROR  1
 182 #define ERROR_LIBRARY_NOT_FOUND 2
 183
 184 static void *dmHandle;
 185 static int nErrorType;
 186
 187 SQLRETURN WINAPI ODBC32_SQLAllocEnv(SQLHENV *);
 188 SQLRETURN WINAPI ODBC32_SQLFreeEnv(SQLHENV);
 189 SQLRETURN WINAPI ODBC32_SQLDataSources(SQLHENV, SQLUSMALLINT, SQLCHAR *, SQLSMALLINT,
 190                                        SQLSMALLINT *, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *);
 191 SQLRETURN WINAPI ODBC32_SQLDrivers(SQLHENV, SQLUSMALLINT, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *,
 192                                    SQLCHAR *, SQLSMALLINT, SQLSMALLINT *);
 193
 194 /***********************************************************************
 195  * ODBC_ReplicateODBCInstToRegistry
 196  *
 197  * PARAMS
 198  *
 199  * RETURNS
 200  *
 201  * Utility to ODBC_ReplicateToRegistry to replicate the drivers of the
 202  * ODBCINST.INI settings
 203  *
 204  * The driver settings are not replicated to the registry.  If we were to
 205  * replicate them we would need to decide whether to replicate all settings
 206  * or to do some translation; whether to remove any entries present only in
 207  * the windows registry, etc.
 208  */
 209
 210 static void ODBC_ReplicateODBCInstToRegistry (SQLHENV hEnv)
 211 {
 212     HKEY hODBCInst;
 213     LONG reg_ret;
 214     BOOL success;
 215
 216     success = FALSE;
 217     TRACE ("Driver settings are not currently replicated to the registry\n");
 218     if ((reg_ret = RegCreateKeyExA (HKEY_LOCAL_MACHINE,
 219             "Software\\ODBC\\ODBCINST.INI", 0, NULL,
 220             REG_OPTION_NON_VOLATILE,
 221             KEY_ALL_ACCESS /* a couple more than we need */, NULL,
 222             &hODBCInst, NULL)) == ERROR_SUCCESS)
 223     {
 224         HKEY hDrivers;
 225         if ((reg_ret = RegCreateKeyExA (hODBCInst, "ODBC Drivers", 0,
 226                 NULL, REG_OPTION_NON_VOLATILE,
 227                 KEY_ALL_ACCESS /* overkill */, NULL, &hDrivers, NULL))
 228                 == ERROR_SUCCESS)
 229         {
 230             SQLRETURN sql_ret;
 231             SQLUSMALLINT dirn;
 232             CHAR desc [256];
 233             SQLSMALLINT sizedesc;
 234
 235             success = TRUE;
 236             dirn = SQL_FETCH_FIRST;
 237             while ((sql_ret = ODBC32_SQLDrivers (hEnv, dirn, (SQLCHAR*)desc, sizeof(desc),
 238                     &sizedesc, NULL, 0, NULL)) == SQL_SUCCESS ||
 239                     sql_ret == SQL_SUCCESS_WITH_INFO)
 240             {
 241                 /* FIXME Do some proper handling of the SUCCESS_WITH_INFO */
 242                 dirn = SQL_FETCH_NEXT;
 243                 if (sizedesc == lstrlenA(desc))
 244                 {
 245                     HKEY hThis;
 246                     if ((reg_ret = RegQueryValueExA (hDrivers, desc, NULL,
 247                             NULL, NULL, NULL)) == ERROR_FILE_NOT_FOUND)
 248                     {
 249                         if ((reg_ret = RegSetValueExA (hDrivers, desc, 0,
 250                                 REG_SZ, (const BYTE *)"Installed", 10)) != ERROR_SUCCESS)
 251                         {
 252                             TRACE ("Error %d replicating driver %s\n",
 253                                     reg_ret, desc);
 254                             success = FALSE;
 255                         }
 256                     }
 257                     else if (reg_ret != ERROR_SUCCESS)
 258                     {
 259                         TRACE ("Error %d checking for %s in drivers\n",
 260                                 reg_ret, desc);
 261                         success = FALSE;
 262                     }
 263                     if ((reg_ret = RegCreateKeyExA (hODBCInst, desc, 0,
 264                             NULL, REG_OPTION_NON_VOLATILE,
 265                             KEY_ALL_ACCESS, NULL, &hThis, NULL))
 266                             == ERROR_SUCCESS)
 267                     {
 268                         /* FIXME This is where the settings go.
 269                          * I suggest that if the disposition says it
 270                          * exists then we leave it alone.  Alternatively
 271                          * include an extra value to flag that it is
 272                          * a replication of the unixODBC/iODBC/...
 273                          */
 274                         if ((reg_ret = RegCloseKey (hThis)) !=
 275                                 ERROR_SUCCESS)
 276                             TRACE ("Error %d closing %s key\n", reg_ret,
 277                                     desc);
 278                     }
 279                     else
 280                     {
 281                         TRACE ("Error %d ensuring driver key %s\n",
 282                                 reg_ret, desc);
 283                         success = FALSE;
 284                     }
 285                 }
 286                 else
 287                 {
 288                     WARN ("Unusually long driver name %s not replicated\n",
 289                             desc);
 290                     success = FALSE;
 291                 }
 292             }
 293             if (sql_ret != SQL_NO_DATA)
 294             {
 295                 TRACE ("Error %d enumerating drivers\n", (int)sql_ret);
 296                 success = FALSE;
 297             }
 298             if ((reg_ret = RegCloseKey (hDrivers)) != ERROR_SUCCESS)
 299             {
 300                 TRACE ("Error %d closing hDrivers\n", reg_ret);
 301             }
 302         }
 303         else
 304         {
 305             TRACE ("Error %d opening HKLM\\S\\O\\OI\\Drivers\n", reg_ret);
 306         }
 307         if ((reg_ret = RegCloseKey (hODBCInst)) != ERROR_SUCCESS)
 308         {
 309             TRACE ("Error %d closing HKLM\\S\\O\\ODBCINST.INI\n", reg_ret);
 310         }
 311     }
 312     else
 313     {
 314         TRACE ("Error %d opening HKLM\\S\\O\\ODBCINST.INI\n", reg_ret);
 315     }
 316     if (!success)
 317     {
 318         WARN ("May not have replicated all ODBC drivers to the registry\n");
 319     }
 320 }
 321
 322 /***********************************************************************
 323  * ODBC_ReplicateODBCToRegistry
 324  *
 325  * PARAMS
 326  *
 327  * RETURNS
 328  *
 329  * Utility to ODBC_ReplicateToRegistry to replicate either the USER or
 330  * SYSTEM dsns
 331  *
 332  * For now simply place the "Driver description" (as returned by SQLDataSources)
 333  * into the registry as the driver.  This is enough to satisfy Crystal's
 334  * requirement that there be a driver entry.  (It doesn't seem to care what
 335  * the setting is).
 336  * A slightly more accurate setting would be to access the registry to find
 337  * the actual driver library for the given description (which appears to map
 338  * to one of the HKLM/Software/ODBC/ODBCINST.INI keys).  (If you do this note
 339  * that this will add a requirement that this function be called after
 340  * ODBC_ReplicateODBCInstToRegistry)
 341  */
 342 static void ODBC_ReplicateODBCToRegistry (BOOL is_user, SQLHENV hEnv)
 343 {
 344     HKEY hODBC;
 345     LONG reg_ret;
 346     SQLRETURN sql_ret;
 347     SQLUSMALLINT dirn;
 348     CHAR dsn [SQL_MAX_DSN_LENGTH + 1];
 349     SQLSMALLINT sizedsn;
 350     CHAR desc [256];
 351     SQLSMALLINT sizedesc;
 352     BOOL success;
 353     const char *which = is_user ? "user" : "system";
 354
 355     success = FALSE;
 356     if ((reg_ret = RegCreateKeyExA (
 357             is_user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
 358             "Software\\ODBC\\ODBC.INI", 0, NULL, REG_OPTION_NON_VOLATILE,
 359             KEY_ALL_ACCESS /* a couple more than we need */, NULL, &hODBC,
 360             NULL)) == ERROR_SUCCESS)
 361     {
 362         success = TRUE;
 363         dirn = is_user ? SQL_FETCH_FIRST_USER : SQL_FETCH_FIRST_SYSTEM;
 364         while ((sql_ret = ODBC32_SQLDataSources (hEnv, dirn,
 365                 (SQLCHAR*)dsn, sizeof(dsn), &sizedsn,
 366                 (SQLCHAR*)desc, sizeof(desc), &sizedesc)) == SQL_SUCCESS
 367                 || sql_ret == SQL_SUCCESS_WITH_INFO)
 368         {
 369             /* FIXME Do some proper handling of the SUCCESS_WITH_INFO */
 370             dirn = SQL_FETCH_NEXT;
 371             if (sizedsn == lstrlenA(dsn) && sizedesc == lstrlenA(desc))
 372             {
 373                 HKEY hDSN;
 374                 if ((reg_ret = RegCreateKeyExA (hODBC, dsn, 0,
 375                         NULL, REG_OPTION_NON_VOLATILE,
 376                         KEY_ALL_ACCESS, NULL, &hDSN, NULL))
 377                         == ERROR_SUCCESS)
 378                 {
 379                     static const char DRIVERKEY[] = "Driver";
 380                     if ((reg_ret = RegQueryValueExA (hDSN, DRIVERKEY,
 381                             NULL, NULL, NULL, NULL))
 382                             == ERROR_FILE_NOT_FOUND)
 383                     {
 384                         if ((reg_ret = RegSetValueExA (hDSN, DRIVERKEY, 0,
 385                                 REG_SZ, (LPBYTE)desc, sizedesc)) != ERROR_SUCCESS)
 386                         {
 387                             TRACE ("Error %d replicating description of "
 388                                     "%s(%s)\n", reg_ret, dsn, desc);
 389                             success = FALSE;
 390                         }
 391                     }
 392                     else if (reg_ret != ERROR_SUCCESS)
 393                     {
 394                         TRACE ("Error %d checking for description of %s\n",
 395                                 reg_ret, dsn);
 396                         success = FALSE;
 397                     }
 398                     if ((reg_ret = RegCloseKey (hDSN)) != ERROR_SUCCESS)
 399                     {
 400                         TRACE ("Error %d closing %s DSN key %s\n",
 401                                 reg_ret, which, dsn);
 402                     }
 403                 }
 404                 else
 405                 {
 406                     TRACE ("Error %d opening %s DSN key %s\n",
 407                             reg_ret, which, dsn);
 408                     success = FALSE;
 409                 }
 410             }
 411             else
 412             {
 413                 WARN ("Unusually long %s data source name %s (%s) not "
 414                         "replicated\n", which, dsn, desc);
 415                 success = FALSE;
 416             }
 417         }
 418         if (sql_ret != SQL_NO_DATA)
 419         {
 420             TRACE ("Error %d enumerating %s datasources\n",
 421                     (int)sql_ret, which);
 422             success = FALSE;
 423         }
 424         if ((reg_ret = RegCloseKey (hODBC)) != ERROR_SUCCESS)
 425         {
 426             TRACE ("Error %d closing %s ODBC.INI registry key\n", reg_ret,
 427                     which);
 428         }
 429     }
 430     else
 431     {
 432         TRACE ("Error %d creating/opening %s ODBC.INI registry key\n",
 433                 reg_ret, which);
 434     }
 435     if (!success)
 436     {
 437         WARN ("May not have replicated all %s ODBC DSNs to the registry\n",
 438                 which);
 439     }
 440 }
 441
 442 /***********************************************************************
 443  * ODBC_ReplicateToRegistry
 444  *
 445  * PARAMS
 446  *
 447  * RETURNS
 448  *
 449  * Unfortunately some of the functions that Windows documents as being part
 450  * of the ODBC API it implements directly during compilation or something
 451  * in terms of registry access functions.
 452  * e.g. SQLGetInstalledDrivers queries the list at
 453  * HKEY_LOCAL_MACHINE\Software\ODBC\ODBCINST.INI\ODBC Drivers
 454  *
 455  * This function is called when the driver manager is loaded and is used
 456  * to replicate the appropriate details into the Wine registry
 457  */
 458
 459 static void ODBC_ReplicateToRegistry (void)
 460 {
 461     SQLRETURN sql_ret;
 462     SQLHENV hEnv;
 463
 464     if ((sql_ret = ODBC32_SQLAllocEnv (&hEnv)) == SQL_SUCCESS)
 465     {
 466         ODBC_ReplicateODBCInstToRegistry (hEnv);
 467         ODBC_ReplicateODBCToRegistry (FALSE /* system dsns */, hEnv);
 468         ODBC_ReplicateODBCToRegistry (TRUE /* user dsns */, hEnv);
 469
 470         if ((sql_ret = ODBC32_SQLFreeEnv (hEnv)) != SQL_SUCCESS)
 471         {
 472             TRACE ("Error %d freeing the SQL environment.\n", (int)sql_ret);
 473         }
 474     }
 475     else
 476     {
 477         TRACE ("Error %d opening an SQL environment.\n", (int)sql_ret);
 478         WARN ("The external ODBC settings have not been replicated to the"
 479                 " Wine registry\n");
 480     }
 481 }
 482
 483 /***********************************************************************
 484  * DllMain [Internal] Initializes the internal 'ODBC32.DLL'.
 485  */
 486 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID reserved)
 487 {
 488     TRACE("proxy ODBC: %p,%x,%p\n", hinstDLL, reason, reserved);
 489
 490     switch (reason)
 491     {
 492     case DLL_PROCESS_ATTACH:
 493        DisableThreadLibraryCalls(hinstDLL);
 494        if (ODBC_LoadDriverManager())
 495        {
 496           ODBC_LoadDMFunctions();
 497           ODBC_ReplicateToRegistry();
 498        }
 499        break;
 500
 501     case DLL_PROCESS_DETACH:
 502       if (reserved) break;
 503       if (dmHandle) wine_dlclose(dmHandle,NULL,0);
 504     }
 505
 506     return TRUE;
 507 }
 508
 509 /***********************************************************************
 510  * ODBC_LoadDriverManager [Internal] Load ODBC library.
 511  *
 512  * PARAMS
 513  *
 514  * RETURNS
 515  *     Success: TRUE
 516  *     Failure: FALSE
 517  */
 518
 519 static BOOL ODBC_LoadDriverManager(void)
 520 {
 521    const char *s = getenv("LIB_ODBC_DRIVER_MANAGER");
 522    char error[256];
 523
 524 #ifdef SONAME_LIBODBC
 525    if (!s || !s[0]) s = SONAME_LIBODBC;
 526 #endif
 527    if (!s || !s[0]) goto failed;
 528
 529    dmHandle = wine_dlopen(s, RTLD_LAZY | RTLD_GLOBAL, error, sizeof(error));
 530
 531    if (dmHandle != NULL)
 532    {
 533       TRACE("Opened library %s\n", s);
 534       nErrorType = ERROR_FREE;
 535       return TRUE;
 536    }
 537 failed:
 538    ERR_(winediag)("failed to open library %s: %s\n", debugstr_a(s), error);
 539    nErrorType = ERROR_LIBRARY_NOT_FOUND;
 540    return FALSE;
 541 }
 542
 543
 544 /***********************************************************************
 545  * ODBC_LoadDMFunctions [Internal] Populate function table.
 546  *
 547  * PARAMS
 548  *
 549  * RETURNS
 550  *     Success: TRUE
 551  *     Failure: FALSE
 552  */
 553
 554 static BOOL ODBC_LoadDMFunctions(void)
 555 {
 556     char error[256];
 557
 558     if (dmHandle == NULL)
 559         return FALSE;
 560
 561 #define LOAD_FUNC(name) \
 562     if ((p##name = wine_dlsym( dmHandle, #name, error, sizeof(error) ))); \
 563     else WARN( "Failed to load %s: %s\n", #name, error )
 564
 565     LOAD_FUNC(SQLAllocConnect);
 566     LOAD_FUNC(SQLAllocEnv);
 567     LOAD_FUNC(SQLAllocHandle);
 568     LOAD_FUNC(SQLAllocHandleStd);
 569     LOAD_FUNC(SQLAllocStmt);
 570     LOAD_FUNC(SQLBindCol);
 571     LOAD_FUNC(SQLBindParam);
 572     LOAD_FUNC(SQLBindParameter);
 573     LOAD_FUNC(SQLBrowseConnect);
 574     LOAD_FUNC(SQLBrowseConnectW);
 575     LOAD_FUNC(SQLBulkOperations);
 576     LOAD_FUNC(SQLCancel);
 577     LOAD_FUNC(SQLCloseCursor);
 578     LOAD_FUNC(SQLColAttribute);
 579     LOAD_FUNC(SQLColAttributeW);
 580     LOAD_FUNC(SQLColAttributes);
 581     LOAD_FUNC(SQLColAttributesW);
 582     LOAD_FUNC(SQLColumnPrivileges);
 583     LOAD_FUNC(SQLColumnPrivilegesW);
 584     LOAD_FUNC(SQLColumns);
 585     LOAD_FUNC(SQLColumnsW);
 586     LOAD_FUNC(SQLConnect);
 587     LOAD_FUNC(SQLConnectW);
 588     LOAD_FUNC(SQLCopyDesc);
 589     LOAD_FUNC(SQLDataSources);
 590     LOAD_FUNC(SQLDataSourcesA);
 591     LOAD_FUNC(SQLDataSourcesW);
 592     LOAD_FUNC(SQLDescribeCol);
 593     LOAD_FUNC(SQLDescribeColW);
 594     LOAD_FUNC(SQLDescribeParam);
 595     LOAD_FUNC(SQLDisconnect);
 596     LOAD_FUNC(SQLDriverConnect);
 597     LOAD_FUNC(SQLDriverConnectW);
 598     LOAD_FUNC(SQLDrivers);
 599     LOAD_FUNC(SQLDriversW);
 600     LOAD_FUNC(SQLEndTran);
 601     LOAD_FUNC(SQLError);
 602     LOAD_FUNC(SQLErrorW);
 603     LOAD_FUNC(SQLExecDirect);
 604     LOAD_FUNC(SQLExecDirectW);
 605     LOAD_FUNC(SQLExecute);
 606     LOAD_FUNC(SQLExtendedFetch);
 607     LOAD_FUNC(SQLFetch);
 608     LOAD_FUNC(SQLFetchScroll);
 609     LOAD_FUNC(SQLForeignKeys);
 610     LOAD_FUNC(SQLForeignKeysW);
 611     LOAD_FUNC(SQLFreeConnect);
 612     LOAD_FUNC(SQLFreeEnv);
 613     LOAD_FUNC(SQLFreeHandle);
 614     LOAD_FUNC(SQLFreeStmt);
 615     LOAD_FUNC(SQLGetConnectAttr);
 616     LOAD_FUNC(SQLGetConnectAttrW);
 617     LOAD_FUNC(SQLGetConnectOption);
 618     LOAD_FUNC(SQLGetConnectOptionW);
 619     LOAD_FUNC(SQLGetCursorName);
 620     LOAD_FUNC(SQLGetCursorNameW);
 621     LOAD_FUNC(SQLGetData);
 622     LOAD_FUNC(SQLGetDescField);
 623     LOAD_FUNC(SQLGetDescFieldW);
 624     LOAD_FUNC(SQLGetDescRec);
 625     LOAD_FUNC(SQLGetDescRecW);
 626     LOAD_FUNC(SQLGetDiagField);
 627     LOAD_FUNC(SQLGetDiagFieldW);
 628     LOAD_FUNC(SQLGetDiagRec);
 629     LOAD_FUNC(SQLGetDiagRecA);
 630     LOAD_FUNC(SQLGetDiagRecW);
 631     LOAD_FUNC(SQLGetEnvAttr);
 632     LOAD_FUNC(SQLGetFunctions);
 633     LOAD_FUNC(SQLGetInfo);
 634     LOAD_FUNC(SQLGetInfoW);
 635     LOAD_FUNC(SQLGetStmtAttr);
 636     LOAD_FUNC(SQLGetStmtAttrW);
 637     LOAD_FUNC(SQLGetStmtOption);
 638     LOAD_FUNC(SQLGetTypeInfo);
 639     LOAD_FUNC(SQLGetTypeInfoW);
 640     LOAD_FUNC(SQLMoreResults);
 641     LOAD_FUNC(SQLNativeSql);
 642     LOAD_FUNC(SQLNativeSqlW);
 643     LOAD_FUNC(SQLNumParams);
 644     LOAD_FUNC(SQLNumResultCols);
 645     LOAD_FUNC(SQLParamData);
 646     LOAD_FUNC(SQLParamOptions);
 647     LOAD_FUNC(SQLPrepare);
 648     LOAD_FUNC(SQLPrepareW);
 649     LOAD_FUNC(SQLPrimaryKeys);
 650     LOAD_FUNC(SQLPrimaryKeysW);
 651     LOAD_FUNC(SQLProcedureColumns);
 652     LOAD_FUNC(SQLProcedureColumnsW);
 653     LOAD_FUNC(SQLProcedures);
 654     LOAD_FUNC(SQLProceduresW);
 655     LOAD_FUNC(SQLPutData);
 656     LOAD_FUNC(SQLRowCount);
 657     LOAD_FUNC(SQLSetConnectAttr);
 658     LOAD_FUNC(SQLSetConnectAttrW);
 659     LOAD_FUNC(SQLSetConnectOption);
 660     LOAD_FUNC(SQLSetConnectOptionW);
 661     LOAD_FUNC(SQLSetCursorName);
 662     LOAD_FUNC(SQLSetCursorNameW);
 663     LOAD_FUNC(SQLSetDescField);
 664     LOAD_FUNC(SQLSetDescFieldW);
 665     LOAD_FUNC(SQLSetDescRec);
 666     LOAD_FUNC(SQLSetEnvAttr);
 667     LOAD_FUNC(SQLSetParam);
 668     LOAD_FUNC(SQLSetPos);
 669     LOAD_FUNC(SQLSetScrollOptions);
 670     LOAD_FUNC(SQLSetStmtAttr);
 671     LOAD_FUNC(SQLSetStmtAttrW);
 672     LOAD_FUNC(SQLSetStmtOption);
 673     LOAD_FUNC(SQLSpecialColumns);
 674     LOAD_FUNC(SQLSpecialColumnsW);
 675     LOAD_FUNC(SQLStatistics);
 676     LOAD_FUNC(SQLStatisticsW);
 677     LOAD_FUNC(SQLTablePrivileges);
 678     LOAD_FUNC(SQLTablePrivilegesW);
 679     LOAD_FUNC(SQLTables);
 680     LOAD_FUNC(SQLTablesW);
 681     LOAD_FUNC(SQLTransact);
 682 #undef LOAD_FUNC
 683
 684     return TRUE;
 685 }
 686
 687
 688 /*************************************************************************
 689  *                              SQLAllocConnect           [ODBC32.001]
 690  */
 691 SQLRETURN WINAPI ODBC32_SQLAllocConnect(SQLHENV EnvironmentHandle, SQLHDBC *ConnectionHandle)
 692 {
 693         SQLRETURN ret;
 694         TRACE("(EnvironmentHandle %p)\n",EnvironmentHandle);
 695
 696         if (!pSQLAllocConnect)
 697         {
 698            *ConnectionHandle = SQL_NULL_HDBC;
 699            TRACE("Not ready\n");
 700            return SQL_ERROR;
 701         }
 702
 703         ret = pSQLAllocConnect(EnvironmentHandle, ConnectionHandle);
 704         TRACE("Returns %d, Handle %p\n", ret, *ConnectionHandle);
 705         return ret;
 706 }
 707
 708
 709 /*************************************************************************
 710  *                              SQLAllocEnv           [ODBC32.002]
 711  */
 712 SQLRETURN WINAPI ODBC32_SQLAllocEnv(SQLHENV *EnvironmentHandle)
 713 {
 714         SQLRETURN ret;
 715         TRACE("\n");
 716
 717         if (!pSQLAllocEnv)
 718         {
 719            *EnvironmentHandle = SQL_NULL_HENV;
 720            TRACE("Not ready\n");
 721            return SQL_ERROR;
 722         }
 723
 724         ret = pSQLAllocEnv(EnvironmentHandle);
 725         TRACE("Returns %d, EnvironmentHandle %p\n", ret, *EnvironmentHandle);
 726         return ret;
 727 }
 728
 729
 730 /*************************************************************************
 731  *                              SQLAllocHandle           [ODBC32.024]
 732  */
 733 SQLRETURN WINAPI ODBC32_SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
 734 {
 735         SQLRETURN ret;
 736         TRACE("(Type %d, Handle %p)\n", HandleType, InputHandle);
 737
 738         if (!pSQLAllocHandle)
 739         {
 740             if (nErrorType == ERROR_LIBRARY_NOT_FOUND)
 741                 WARN("ProxyODBC: Cannot load ODBC driver manager library.\n");
 742
 743             if (HandleType == SQL_HANDLE_ENV)
 744                 *OutputHandle = SQL_NULL_HENV;
 745             else if (HandleType == SQL_HANDLE_DBC)
 746                 *OutputHandle = SQL_NULL_HDBC;
 747             else if (HandleType == SQL_HANDLE_STMT)
 748                 *OutputHandle = SQL_NULL_HSTMT;
 749             else if (HandleType == SQL_HANDLE_DESC)
 750                 *OutputHandle = SQL_NULL_HDESC;
 751
 752             TRACE ("Not ready\n");
 753             return SQL_ERROR;
 754         }
 755
 756         ret = pSQLAllocHandle(HandleType, InputHandle, OutputHandle);
 757         TRACE("Returns %d, Handle %p\n", ret, *OutputHandle);
 758         return ret;
 759 }
 760
 761
 762 /*************************************************************************
 763  *                              SQLAllocStmt           [ODBC32.003]
 764  */
 765 SQLRETURN WINAPI ODBC32_SQLAllocStmt(SQLHDBC ConnectionHandle, SQLHSTMT *StatementHandle)
 766 {
 767         SQLRETURN ret;
 768
 769         TRACE("(Connection %p)\n", ConnectionHandle);
 770
 771         if (!pSQLAllocStmt)
 772         {
 773            *StatementHandle = SQL_NULL_HSTMT;
 774            TRACE ("Not ready\n");
 775            return SQL_ERROR;
 776         }
 777
 778         ret = pSQLAllocStmt(ConnectionHandle, StatementHandle);
 779         TRACE ("Returns %d, Handle %p\n", ret, *StatementHandle);
 780         return ret;
 781 }
 782
 783
 784 /*************************************************************************
 785  *                              SQLAllocHandleStd           [ODBC32.077]
 786  */
 787 SQLRETURN WINAPI ODBC32_SQLAllocHandleStd( SQLSMALLINT HandleType,
 788                                     SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
 789 {
 790         TRACE("ProxyODBC: SQLAllocHandleStd.\n");
 791
 792         if (!pSQLAllocHandleStd)
 793         {
 794             if (nErrorType == ERROR_LIBRARY_NOT_FOUND)
 795                 WARN("ProxyODBC: Cannot load ODBC driver manager library.\n");
 796
 797             if (HandleType == SQL_HANDLE_ENV)
 798                 *OutputHandle = SQL_NULL_HENV;
 799             else if (HandleType == SQL_HANDLE_DBC)
 800                 *OutputHandle = SQL_NULL_HDBC;
 801             else if (HandleType == SQL_HANDLE_STMT)
 802                 *OutputHandle = SQL_NULL_HSTMT;
 803             else if (HandleType == SQL_HANDLE_DESC)
 804                 *OutputHandle = SQL_NULL_HDESC;
 805
 806             return SQL_ERROR;
 807         }
 808
 809         return pSQLAllocHandleStd(HandleType, InputHandle, OutputHandle);
 810 }
 811
 812
 813 /*************************************************************************
 814  *                              SQLBindCol           [ODBC32.004]
 815  */
 816 SQLRETURN WINAPI ODBC32_SQLBindCol(SQLHSTMT StatementHandle,
 817                      SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
 818                      SQLPOINTER TargetValue, SQLLEN BufferLength,
 819                      SQLLEN *StrLen_or_Ind)
 820 {
 821         TRACE("\n");
 822
 823         if (!pSQLBindCol)
 824         {
 825                 TRACE ("Not ready\n");
 826                 return SQL_ERROR;
 827         }
 828
 829         return pSQLBindCol(StatementHandle, ColumnNumber, TargetType,
 830                            TargetValue, BufferLength, StrLen_or_Ind);
 831 }
 832
 833
 834 /*************************************************************************
 835  *                              SQLBindParam           [ODBC32.025]
 836  */
 837 SQLRETURN WINAPI ODBC32_SQLBindParam(SQLHSTMT StatementHandle,
 838              SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
 839              SQLSMALLINT ParameterType, SQLULEN LengthPrecision,
 840              SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
 841              SQLLEN *StrLen_or_Ind)
 842 {
 843         TRACE("\n");
 844
 845         if (!pSQLBindParam) return SQL_ERROR;
 846         return pSQLBindParam(StatementHandle, ParameterNumber, ValueType,
 847                              ParameterType, LengthPrecision, ParameterScale,
 848                              ParameterValue, StrLen_or_Ind);
 849 }
 850
 851
 852 /*************************************************************************
 853  *                              SQLCancel           [ODBC32.005]
 854  */
 855 SQLRETURN WINAPI ODBC32_SQLCancel(SQLHSTMT StatementHandle)
 856 {
 857         TRACE("\n");
 858
 859         if (!pSQLCancel) return SQL_ERROR;
 860         return pSQLCancel(StatementHandle);
 861 }
 862
 863
 864 /*************************************************************************
 865  *                              SQLCloseCursor           [ODBC32.026]
 866  */
 867 SQLRETURN WINAPI ODBC32_SQLCloseCursor(SQLHSTMT StatementHandle)
 868 {
 869         SQLRETURN ret;
 870         TRACE("(Handle %p)\n", StatementHandle);
 871
 872         if (!pSQLCloseCursor) return SQL_ERROR;
 873
 874         ret = pSQLCloseCursor(StatementHandle);
 875         TRACE("Returns %d\n", ret);
 876         return ret;
 877 }
 878
 879
 880 /*************************************************************************
 881  *                              SQLColAttribute           [ODBC32.027]
 882  */
 883 SQLRETURN WINAPI ODBC32_SQLColAttribute (SQLHSTMT StatementHandle,
 884              SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
 885              SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength,
 886              SQLSMALLINT *StringLength, SQLLEN *NumericAttribute)
 887 {
 888         TRACE("\n");
 889
 890         if (!pSQLColAttribute) return SQL_ERROR;
 891         return pSQLColAttribute(StatementHandle, ColumnNumber, FieldIdentifier,
 892                                 CharacterAttribute, BufferLength, StringLength, NumericAttribute);
 893 }
 894
 895
 896 /*************************************************************************
 897  *                              SQLColumns           [ODBC32.040]
 898  */
 899 SQLRETURN WINAPI ODBC32_SQLColumns(SQLHSTMT StatementHandle,
 900              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
 901              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
 902              SQLCHAR *TableName, SQLSMALLINT NameLength3,
 903              SQLCHAR *ColumnName, SQLSMALLINT NameLength4)
 904 {
 905         TRACE("\n");
 906
 907         if (!pSQLColumns) return SQL_ERROR;
 908         return pSQLColumns(StatementHandle, CatalogName, NameLength1,
 909                            SchemaName, NameLength2, TableName, NameLength3, ColumnName, NameLength4);
 910 }
 911
 912
 913 /*************************************************************************
 914  *                              SQLConnect           [ODBC32.007]
 915  */
 916 SQLRETURN WINAPI ODBC32_SQLConnect(SQLHDBC ConnectionHandle,
 917              SQLCHAR *ServerName, SQLSMALLINT NameLength1,
 918              SQLCHAR *UserName, SQLSMALLINT NameLength2,
 919              SQLCHAR *Authentication, SQLSMALLINT NameLength3)
 920 {
 921         SQLRETURN ret;
 922         TRACE("(Server=%.*s)\n",NameLength1, ServerName);
 923
 924         if (!pSQLConnect) return SQL_ERROR;
 925
 926         ret = pSQLConnect(ConnectionHandle, ServerName, NameLength1,
 927                           UserName, NameLength2, Authentication, NameLength3);
 928
 929         TRACE("Returns %d\n", ret);
 930         return ret;
 931 }
 932
 933
 934 /*************************************************************************
 935  *                              SQLCopyDesc           [ODBC32.028]
 936  */
 937 SQLRETURN WINAPI ODBC32_SQLCopyDesc(SQLHDESC SourceDescHandle, SQLHDESC TargetDescHandle)
 938 {
 939         TRACE("\n");
 940
 941         if (!pSQLCopyDesc) return SQL_ERROR;
 942         return pSQLCopyDesc(SourceDescHandle, TargetDescHandle);
 943 }
 944
 945
 946 /*************************************************************************
 947  *                              SQLDataSources           [ODBC32.057]
 948  */
 949 SQLRETURN WINAPI ODBC32_SQLDataSources(SQLHENV EnvironmentHandle,
 950              SQLUSMALLINT Direction, SQLCHAR *ServerName,
 951              SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
 952              SQLCHAR *Description, SQLSMALLINT BufferLength2,
 953              SQLSMALLINT *NameLength2)
 954 {
 955         SQLRETURN ret;
 956
 957         TRACE("(EnvironmentHandle %p)\n", EnvironmentHandle);
 958
 959         if (!pSQLDataSources) return SQL_ERROR;
 960
 961         ret = pSQLDataSources(EnvironmentHandle, Direction, ServerName,
 962                               BufferLength1, NameLength1, Description, BufferLength2, NameLength2);
 963
 964         if (TRACE_ON(odbc))
 965         {
 966            TRACE("Returns %d \t", ret);
 967            if (NameLength1 && *NameLength1 > 0)
 968              TRACE("DataSource = %s,", ServerName);
 969            if (NameLength2 && *NameLength2 > 0)
 970              TRACE(" Description = %s", Description);
 971            TRACE("\n");
 972         }
 973
 974         return ret;
 975 }
 976
 977 SQLRETURN WINAPI ODBC32_SQLDataSourcesA(SQLHENV EnvironmentHandle,
 978              SQLUSMALLINT Direction, SQLCHAR *ServerName,
 979              SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
 980              SQLCHAR *Description, SQLSMALLINT BufferLength2,
 981              SQLSMALLINT *NameLength2)
 982 {
 983     SQLRETURN ret;
 984
 985     TRACE("EnvironmentHandle = %p\n", EnvironmentHandle);
 986
 987     if (!pSQLDataSourcesA) return SQL_ERROR;
 988
 989     ret = pSQLDataSourcesA(EnvironmentHandle, Direction, ServerName,
 990                            BufferLength1, NameLength1, Description, BufferLength2, NameLength2);
 991     if (TRACE_ON(odbc))
 992     {
 993        TRACE("Returns %d \t", ret);
 994        if (NameLength1 && *NameLength1 > 0)
 995          TRACE("DataSource = %s,", ServerName);
 996        if (NameLength2 && *NameLength2 > 0)
 997          TRACE(" Description = %s", Description);
 998        TRACE("\n");
 999     }
1000
1001     return ret;
1002 }
1003
1004 /*************************************************************************
1005  *                              SQLDescribeCol           [ODBC32.008]
1006  */
1007 SQLRETURN WINAPI ODBC32_SQLDescribeCol(SQLHSTMT StatementHandle,
1008              SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
1009              SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
1010              SQLSMALLINT *DataType, SQLULEN *ColumnSize,
1011              SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
1012 {
1013         TRACE("\n");
1014
1015         if (!pSQLDescribeCol) return SQL_ERROR;
1016         return pSQLDescribeCol(StatementHandle, ColumnNumber, ColumnName,
1017                                BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable);
1018 }
1019
1020
1021 /*************************************************************************
1022  *                              SQLDisconnect           [ODBC32.009]
1023  */
1024 SQLRETURN WINAPI ODBC32_SQLDisconnect(SQLHDBC ConnectionHandle)
1025 {
1026         SQLRETURN ret;
1027         TRACE("(Handle %p)\n", ConnectionHandle);
1028
1029         if (!pSQLDisconnect) return SQL_ERROR;
1030
1031         ret = pSQLDisconnect(ConnectionHandle);
1032         TRACE("Returns %d\n", ret);
1033         return ret;
1034 }
1035
1036
1037 /*************************************************************************
1038  *                              SQLEndTran           [ODBC32.029]
1039  */
1040 SQLRETURN WINAPI ODBC32_SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT CompletionType)
1041 {
1042         TRACE("\n");
1043
1044         if (!pSQLEndTran) return SQL_ERROR;
1045         return pSQLEndTran(HandleType, Handle, CompletionType);
1046 }
1047
1048
1049 /*************************************************************************
1050  *                              SQLError           [ODBC32.010]
1051  */
1052 SQLRETURN WINAPI ODBC32_SQLError(SQLHENV EnvironmentHandle,
1053              SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle,
1054              SQLCHAR *Sqlstate, SQLINTEGER *NativeError,
1055              SQLCHAR *MessageText, SQLSMALLINT BufferLength,
1056              SQLSMALLINT *TextLength)
1057 {
1058         SQLRETURN ret;
1059
1060         TRACE("(EnvironmentHandle %p, ConnectionHandle %p, StatementHandle %p, BufferLength %d)\n",
1061               EnvironmentHandle, ConnectionHandle, StatementHandle, BufferLength);
1062
1063         if (!pSQLError) return SQL_ERROR;
1064         ret = pSQLError(EnvironmentHandle, ConnectionHandle, StatementHandle,
1065                         Sqlstate, NativeError, MessageText, BufferLength, TextLength);
1066         if (ret == SQL_SUCCESS)
1067                 TRACE("SQLState %s, Error %d, Text %s, Textlen %d\n",
1068                        debugstr_an((char *)Sqlstate, 5), *NativeError,
1069                        debugstr_an((char *)MessageText, *TextLength), *TextLength);
1070         else
1071                 TRACE("Returns %d\n", ret);
1072         return ret;
1073 }
1074
1075
1076 /*************************************************************************
1077  *                              SQLExecDirect           [ODBC32.011]
1078  */
1079 SQLRETURN WINAPI ODBC32_SQLExecDirect(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
1080 {
1081         TRACE("\n");
1082
1083         if (!pSQLExecDirect) return SQL_ERROR;
1084         return pSQLExecDirect(StatementHandle, StatementText, TextLength);
1085 }
1086
1087
1088 /*************************************************************************
1089  *                              SQLExecute           [ODBC32.012]
1090  */
1091 SQLRETURN WINAPI ODBC32_SQLExecute(SQLHSTMT StatementHandle)
1092 {
1093         TRACE("\n");
1094
1095         if (!pSQLExecute) return SQL_ERROR;
1096         return pSQLExecute(StatementHandle);
1097 }
1098
1099
1100 /*************************************************************************
1101  *                              SQLFetch           [ODBC32.013]
1102  */
1103 SQLRETURN WINAPI ODBC32_SQLFetch(SQLHSTMT StatementHandle)
1104 {
1105         TRACE("\n");
1106
1107         if (!pSQLFetch) return SQL_ERROR;
1108         return pSQLFetch(StatementHandle);
1109 }
1110
1111
1112 /*************************************************************************
1113  *                              SQLFetchScroll          [ODBC32.030]
1114  */
1115 SQLRETURN WINAPI ODBC32_SQLFetchScroll(SQLHSTMT StatementHandle, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
1116 {
1117         TRACE("\n");
1118
1119         if (!pSQLFetchScroll) return SQL_ERROR;
1120         return pSQLFetchScroll(StatementHandle, FetchOrientation, FetchOffset);
1121 }
1122
1123
1124 /*************************************************************************
1125  *                              SQLFreeConnect           [ODBC32.014]
1126  */
1127 SQLRETURN WINAPI ODBC32_SQLFreeConnect(SQLHDBC ConnectionHandle)
1128 {
1129         SQLRETURN ret;
1130         TRACE("(Handle %p)\n", ConnectionHandle);
1131
1132         if (!pSQLFreeConnect) return SQL_ERROR;
1133
1134         ret = pSQLFreeConnect(ConnectionHandle);
1135         TRACE("Returns %d\n", ret);
1136         return ret;
1137 }
1138
1139
1140 /*************************************************************************
1141  *                              SQLFreeEnv           [ODBC32.015]
1142  */
1143 SQLRETURN WINAPI ODBC32_SQLFreeEnv(SQLHENV EnvironmentHandle)
1144 {
1145         SQLRETURN ret;
1146         TRACE("(EnvironmentHandle %p)\n",EnvironmentHandle);
1147
1148         if (!pSQLFreeEnv) return SQL_ERROR;
1149
1150         ret = pSQLFreeEnv(EnvironmentHandle);
1151         TRACE("Returns %d\n", ret);
1152         return ret;
1153 }
1154
1155
1156 /*************************************************************************
1157  *                              SQLFreeHandle           [ODBC32.031]
1158  */
1159 SQLRETURN WINAPI ODBC32_SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
1160 {
1161         SQLRETURN ret;
1162         TRACE("(Type %d, Handle %p)\n", HandleType, Handle);
1163
1164         if (!pSQLFreeHandle) return SQL_ERROR;
1165
1166         ret = pSQLFreeHandle(HandleType, Handle);
1167         TRACE ("Returns %d\n", ret);
1168         return ret;
1169 }
1170
1171
1172 /*************************************************************************
1173  *                              SQLFreeStmt           [ODBC32.016]
1174  */
1175 SQLRETURN WINAPI ODBC32_SQLFreeStmt(SQLHSTMT StatementHandle, SQLUSMALLINT Option)
1176 {
1177         SQLRETURN ret;
1178         TRACE("(Handle %p, Option %d)\n", StatementHandle, Option);
1179
1180         if (!pSQLFreeStmt) return SQL_ERROR;
1181
1182         ret = pSQLFreeStmt(StatementHandle, Option);
1183         TRACE("Returns %d\n", ret);
1184         return ret;
1185 }
1186
1187
1188 /*************************************************************************
1189  *                              SQLGetConnectAttr           [ODBC32.032]
1190  */
1191 SQLRETURN WINAPI ODBC32_SQLGetConnectAttr(SQLHDBC ConnectionHandle,
1192              SQLINTEGER Attribute, SQLPOINTER Value,
1193              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1194 {
1195         TRACE("\n");
1196
1197         if (!pSQLGetConnectAttr) return SQL_ERROR;
1198         return pSQLGetConnectAttr(ConnectionHandle, Attribute, Value,
1199                                   BufferLength, StringLength);
1200 }
1201
1202
1203 /*************************************************************************
1204  *                              SQLGetConnectOption       [ODBC32.042]
1205  */
1206 SQLRETURN WINAPI ODBC32_SQLGetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value)
1207 {
1208         TRACE("\n");
1209
1210         if (!pSQLGetConnectOption) return SQL_ERROR;
1211         return pSQLGetConnectOption(ConnectionHandle, Option, Value);
1212 }
1213
1214
1215 /*************************************************************************
1216  *                              SQLGetCursorName           [ODBC32.017]
1217  */
1218 SQLRETURN WINAPI ODBC32_SQLGetCursorName(SQLHSTMT StatementHandle,
1219              SQLCHAR *CursorName, SQLSMALLINT BufferLength,
1220              SQLSMALLINT *NameLength)
1221 {
1222         TRACE("\n");
1223
1224         if (!pSQLGetCursorName) return SQL_ERROR;
1225         return pSQLGetCursorName(StatementHandle, CursorName, BufferLength, NameLength);
1226 }
1227
1228
1229 /*************************************************************************
1230  *                              SQLGetData           [ODBC32.043]
1231  */
1232 SQLRETURN WINAPI ODBC32_SQLGetData(SQLHSTMT StatementHandle,
1233              SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
1234              SQLPOINTER TargetValue, SQLLEN BufferLength,
1235              SQLLEN *StrLen_or_Ind)
1236 {
1237         TRACE("\n");
1238
1239         if (!pSQLGetData) return SQL_ERROR;
1240         return pSQLGetData(StatementHandle, ColumnNumber, TargetType,
1241                            TargetValue, BufferLength, StrLen_or_Ind);
1242 }
1243
1244
1245 /*************************************************************************
1246  *                              SQLGetDescField           [ODBC32.033]
1247  */
1248 SQLRETURN WINAPI ODBC32_SQLGetDescField(SQLHDESC DescriptorHandle,
1249              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
1250              SQLPOINTER Value, SQLINTEGER BufferLength,
1251              SQLINTEGER *StringLength)
1252 {
1253         TRACE("\n");
1254
1255         if (!pSQLGetDescField) return SQL_ERROR;
1256         return pSQLGetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
1257                                 Value, BufferLength, StringLength);
1258 }
1259
1260
1261 /*************************************************************************
1262  *                              SQLGetDescRec           [ODBC32.034]
1263  */
1264 SQLRETURN WINAPI ODBC32_SQLGetDescRec(SQLHDESC DescriptorHandle,
1265              SQLSMALLINT RecNumber, SQLCHAR *Name,
1266              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
1267              SQLSMALLINT *Type, SQLSMALLINT *SubType,
1268              SQLLEN *Length, SQLSMALLINT *Precision,
1269              SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
1270 {
1271         TRACE("\n");
1272
1273         if (!pSQLGetDescRec) return SQL_ERROR;
1274         return pSQLGetDescRec(DescriptorHandle, RecNumber, Name, BufferLength,
1275                               StringLength, Type, SubType, Length, Precision, Scale, Nullable);
1276 }
1277
1278
1279 /*************************************************************************
1280  *                              SQLGetDiagField           [ODBC32.035]
1281  */
1282 SQLRETURN WINAPI ODBC32_SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
1283              SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
1284              SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
1285              SQLSMALLINT *StringLength)
1286 {
1287         TRACE("\n");
1288
1289         if (!pSQLGetDiagField) return SQL_ERROR;
1290         return pSQLGetDiagField(HandleType, Handle, RecNumber, DiagIdentifier,
1291                                 DiagInfo, BufferLength, StringLength);
1292 }
1293
1294
1295 /*************************************************************************
1296  *                              SQLGetDiagRec           [ODBC32.036]
1297  */
1298 SQLRETURN WINAPI ODBC32_SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
1299              SQLSMALLINT RecNumber, SQLCHAR *Sqlstate,
1300              SQLINTEGER *NativeError, SQLCHAR *MessageText,
1301              SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
1302 {
1303         TRACE("\n");
1304
1305         if (!pSQLGetDiagRec) return SQL_ERROR;
1306         return pSQLGetDiagRec(HandleType, Handle, RecNumber, Sqlstate, NativeError,
1307                               MessageText, BufferLength, TextLength);
1308 }
1309
1310
1311 /*************************************************************************
1312  *                              SQLGetEnvAttr           [ODBC32.037]
1313  */
1314 SQLRETURN WINAPI ODBC32_SQLGetEnvAttr(SQLHENV EnvironmentHandle,
1315              SQLINTEGER Attribute, SQLPOINTER Value,
1316              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1317 {
1318         TRACE("\n");
1319
1320         if (!pSQLGetEnvAttr) return SQL_ERROR;
1321         return pSQLGetEnvAttr(EnvironmentHandle, Attribute, Value, BufferLength, StringLength);
1322 }
1323
1324
1325 /*************************************************************************
1326  *                              SQLGetFunctions           [ODBC32.044]
1327  */
1328 SQLRETURN WINAPI ODBC32_SQLGetFunctions(SQLHDBC ConnectionHandle, SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported)
1329 {
1330         TRACE("\n");
1331
1332         if (!pSQLGetFunctions) return SQL_ERROR;
1333         return pSQLGetFunctions(ConnectionHandle, FunctionId, Supported);
1334 }
1335
1336
1337 /*************************************************************************
1338  *                              SQLGetInfo           [ODBC32.045]
1339  */
1340 SQLRETURN WINAPI ODBC32_SQLGetInfo(SQLHDBC ConnectionHandle,
1341              SQLUSMALLINT InfoType, SQLPOINTER InfoValue,
1342              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
1343 {
1344         TRACE("\n");
1345
1346         if (!pSQLGetInfo) return SQL_ERROR;
1347         return pSQLGetInfo(ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength);
1348 }
1349
1350
1351 /*************************************************************************
1352  *                              SQLGetStmtAttr           [ODBC32.038]
1353  */
1354 SQLRETURN WINAPI ODBC32_SQLGetStmtAttr(SQLHSTMT StatementHandle,
1355              SQLINTEGER Attribute, SQLPOINTER Value,
1356              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1357 {
1358         TRACE("\n");
1359
1360         if (!pSQLGetStmtAttr) return SQL_ERROR;
1361         return pSQLGetStmtAttr(StatementHandle, Attribute, Value, BufferLength, StringLength);
1362 }
1363
1364
1365 /*************************************************************************
1366  *                              SQLGetStmtOption           [ODBC32.046]
1367  */
1368 SQLRETURN WINAPI ODBC32_SQLGetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLPOINTER Value)
1369 {
1370         TRACE("\n");
1371
1372         if (!pSQLGetStmtOption) return SQL_ERROR;
1373         return pSQLGetStmtOption(StatementHandle, Option, Value);
1374 }
1375
1376
1377 /*************************************************************************
1378  *                              SQLGetTypeInfo           [ODBC32.047]
1379  */
1380 SQLRETURN WINAPI ODBC32_SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
1381 {
1382         TRACE("\n");
1383
1384         if (!pSQLGetTypeInfo) return SQL_ERROR;
1385         return pSQLGetTypeInfo(StatementHandle, DataType);
1386 }
1387
1388
1389 /*************************************************************************
1390  *                              SQLNumResultCols           [ODBC32.018]
1391  */
1392 SQLRETURN WINAPI ODBC32_SQLNumResultCols(SQLHSTMT StatementHandle, SQLSMALLINT *ColumnCount)
1393 {
1394         TRACE("\n");
1395
1396         if (!pSQLNumResultCols) return SQL_ERROR;
1397         return pSQLNumResultCols(StatementHandle, ColumnCount);
1398 }
1399
1400
1401 /*************************************************************************
1402  *                              SQLParamData           [ODBC32.048]
1403  */
1404 SQLRETURN WINAPI ODBC32_SQLParamData(SQLHSTMT StatementHandle, SQLPOINTER *Value)
1405 {
1406         TRACE("\n");
1407
1408         if (!pSQLParamData) return SQL_ERROR;
1409         return pSQLParamData(StatementHandle, Value);
1410 }
1411
1412
1413 /*************************************************************************
1414  *                              SQLPrepare           [ODBC32.019]
1415  */
1416 SQLRETURN WINAPI ODBC32_SQLPrepare(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
1417 {
1418         TRACE("\n");
1419
1420         if (!pSQLPrepare) return SQL_ERROR;
1421         return pSQLPrepare(StatementHandle, StatementText, TextLength);
1422 }
1423
1424
1425 /*************************************************************************
1426  *                              SQLPutData           [ODBC32.049]
1427  */
1428 SQLRETURN WINAPI ODBC32_SQLPutData(SQLHSTMT StatementHandle, SQLPOINTER Data, SQLLEN StrLen_or_Ind)
1429 {
1430         TRACE("\n");
1431
1432         if (!pSQLPutData) return SQL_ERROR;
1433         return pSQLPutData(StatementHandle, Data, StrLen_or_Ind);
1434 }
1435
1436
1437 /*************************************************************************
1438  *                              SQLRowCount           [ODBC32.020]
1439  */
1440 SQLRETURN WINAPI ODBC32_SQLRowCount(SQLHSTMT StatementHandle, SQLLEN *RowCount)
1441 {
1442         TRACE("\n");
1443
1444         if (!pSQLRowCount) return SQL_ERROR;
1445         return pSQLRowCount(StatementHandle, RowCount);
1446 }
1447
1448
1449 /*************************************************************************
1450  *                              SQLSetConnectAttr           [ODBC32.039]
1451  */
1452 SQLRETURN WINAPI ODBC32_SQLSetConnectAttr(SQLHDBC ConnectionHandle, SQLINTEGER Attribute,
1453         SQLPOINTER Value, SQLINTEGER StringLength)
1454 {
1455         TRACE("\n");
1456
1457         if (!pSQLSetConnectAttr) return SQL_ERROR;
1458         return pSQLSetConnectAttr(ConnectionHandle, Attribute, Value, StringLength);
1459 }
1460
1461
1462 /*************************************************************************
1463  *                              SQLSetConnectOption           [ODBC32.050]
1464  */
1465 SQLRETURN WINAPI ODBC32_SQLSetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLULEN Value)
1466 {
1467         TRACE("\n");
1468
1469         if (!pSQLSetConnectOption) return SQL_ERROR;
1470         return pSQLSetConnectOption(ConnectionHandle, Option, Value);
1471 }
1472
1473
1474 /*************************************************************************
1475  *                              SQLSetCursorName           [ODBC32.021]
1476  */
1477 SQLRETURN WINAPI ODBC32_SQLSetCursorName(SQLHSTMT StatementHandle, SQLCHAR *CursorName, SQLSMALLINT NameLength)
1478 {
1479         TRACE("\n");
1480
1481         if (!pSQLSetCursorName) return SQL_ERROR;
1482         return pSQLSetCursorName(StatementHandle, CursorName, NameLength);
1483 }
1484
1485
1486 /*************************************************************************
1487  *                              SQLSetDescField           [ODBC32.073]
1488  */
1489 SQLRETURN WINAPI ODBC32_SQLSetDescField(SQLHDESC DescriptorHandle,
1490              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
1491              SQLPOINTER Value, SQLINTEGER BufferLength)
1492 {
1493         TRACE("\n");
1494
1495         if (!pSQLSetDescField) return SQL_ERROR;
1496         return pSQLSetDescField(DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength);
1497 }
1498
1499
1500 /*************************************************************************
1501  *                              SQLSetDescRec           [ODBC32.074]
1502  */
1503 SQLRETURN WINAPI ODBC32_SQLSetDescRec(SQLHDESC DescriptorHandle,
1504              SQLSMALLINT RecNumber, SQLSMALLINT Type,
1505              SQLSMALLINT SubType, SQLLEN Length,
1506              SQLSMALLINT Precision, SQLSMALLINT Scale,
1507              SQLPOINTER Data, SQLLEN *StringLength,
1508              SQLLEN *Indicator)
1509 {
1510         TRACE("\n");
1511
1512         if (!pSQLSetDescRec) return SQL_ERROR;
1513         return pSQLSetDescRec(DescriptorHandle, RecNumber, Type, SubType, Length,
1514                               Precision, Scale, Data, StringLength, Indicator);
1515 }
1516
1517
1518 /*************************************************************************
1519  *                              SQLSetEnvAttr           [ODBC32.075]
1520  */
1521 SQLRETURN WINAPI ODBC32_SQLSetEnvAttr(SQLHENV EnvironmentHandle,
1522              SQLINTEGER Attribute, SQLPOINTER Value,
1523              SQLINTEGER StringLength)
1524 {
1525         TRACE("\n");
1526
1527         if (!pSQLSetEnvAttr) return SQL_ERROR;
1528         return pSQLSetEnvAttr(EnvironmentHandle, Attribute, Value, StringLength);
1529 }
1530
1531
1532 /*************************************************************************
1533  *                              SQLSetParam           [ODBC32.022]
1534  */
1535 SQLRETURN WINAPI ODBC32_SQLSetParam(SQLHSTMT StatementHandle,
1536              SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
1537              SQLSMALLINT ParameterType, SQLULEN LengthPrecision,
1538              SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
1539              SQLLEN *StrLen_or_Ind)
1540 {
1541         TRACE("\n");
1542
1543         if (!pSQLSetParam) return SQL_ERROR;
1544         return pSQLSetParam(StatementHandle, ParameterNumber, ValueType, ParameterType, LengthPrecision,
1545                             ParameterScale, ParameterValue, StrLen_or_Ind);
1546 }
1547
1548
1549 /*************************************************************************
1550  *                              SQLSetStmtAttr           [ODBC32.076]
1551  */
1552 SQLRETURN WINAPI ODBC32_SQLSetStmtAttr(SQLHSTMT StatementHandle,
1553                  SQLINTEGER Attribute, SQLPOINTER Value,
1554                  SQLINTEGER StringLength)
1555 {
1556         TRACE("\n");
1557
1558         if (!pSQLSetStmtAttr) return SQL_ERROR;
1559         return pSQLSetStmtAttr(StatementHandle, Attribute, Value, StringLength);
1560 }
1561
1562
1563 /*************************************************************************
1564  *                              SQLSetStmtOption           [ODBC32.051]
1565  */
1566 SQLRETURN WINAPI ODBC32_SQLSetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLULEN Value)
1567 {
1568         TRACE("\n");
1569
1570         if (!pSQLSetStmtOption) return SQL_ERROR;
1571         return pSQLSetStmtOption(StatementHandle, Option, Value);
1572 }
1573
1574
1575 /*************************************************************************
1576  *                              SQLSpecialColumns           [ODBC32.052]
1577  */
1578 SQLRETURN WINAPI ODBC32_SQLSpecialColumns(SQLHSTMT StatementHandle,
1579              SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,
1580              SQLSMALLINT NameLength1, SQLCHAR *SchemaName,
1581              SQLSMALLINT NameLength2, SQLCHAR *TableName,
1582              SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
1583              SQLUSMALLINT Nullable)
1584 {
1585
1586         if (!pSQLSpecialColumns) return SQL_ERROR;
1587         return pSQLSpecialColumns(StatementHandle, IdentifierType, CatalogName, NameLength1, SchemaName,
1588                                   NameLength2, TableName, NameLength3, Scope, Nullable);
1589 }
1590
1591
1592 /*************************************************************************
1593  *                              SQLStatistics           [ODBC32.053]
1594  */
1595 SQLRETURN WINAPI ODBC32_SQLStatistics(SQLHSTMT StatementHandle,
1596              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
1597              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
1598              SQLCHAR *TableName, SQLSMALLINT NameLength3,
1599              SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
1600 {
1601         TRACE("\n");
1602
1603         if (!pSQLStatistics) return SQL_ERROR;
1604         return pSQLStatistics(StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
1605                               TableName, NameLength3, Unique, Reserved);
1606 }
1607
1608
1609 /*************************************************************************
1610  *                              SQLTables           [ODBC32.054]
1611  */
1612 SQLRETURN WINAPI ODBC32_SQLTables(SQLHSTMT StatementHandle,
1613              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
1614              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
1615              SQLCHAR *TableName, SQLSMALLINT NameLength3,
1616              SQLCHAR *TableType, SQLSMALLINT NameLength4)
1617 {
1618         TRACE("\n");
1619
1620         if (!pSQLTables) return SQL_ERROR;
1621         return pSQLTables(StatementHandle, CatalogName, NameLength1,
1622                           SchemaName, NameLength2, TableName, NameLength3, TableType, NameLength4);
1623 }
1624
1625
1626 /*************************************************************************
1627  *                              SQLTransact           [ODBC32.023]
1628  */
1629 SQLRETURN WINAPI ODBC32_SQLTransact(SQLHENV EnvironmentHandle, SQLHDBC ConnectionHandle,
1630         SQLUSMALLINT CompletionType)
1631 {
1632         TRACE("\n");
1633
1634         if (!pSQLTransact) return SQL_ERROR;
1635         return pSQLTransact(EnvironmentHandle, ConnectionHandle, CompletionType);
1636 }
1637
1638
1639 /*************************************************************************
1640  *                              SQLBrowseConnect           [ODBC32.055]
1641  */
1642 SQLRETURN WINAPI ODBC32_SQLBrowseConnect(
1643     SQLHDBC            hdbc,
1644     SQLCHAR               *szConnStrIn,
1645     SQLSMALLINT        cbConnStrIn,
1646     SQLCHAR               *szConnStrOut,
1647     SQLSMALLINT        cbConnStrOutMax,
1648     SQLSMALLINT       *pcbConnStrOut)
1649 {
1650         TRACE("\n");
1651
1652         if (!pSQLBrowseConnect) return SQL_ERROR;
1653         return pSQLBrowseConnect(hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
1654 }
1655
1656
1657 /*************************************************************************
1658  *                              SQLBulkOperations           [ODBC32.078]
1659  */
1660 SQLRETURN WINAPI ODBC32_SQLBulkOperations(
1661         SQLHSTMT                        StatementHandle,
1662         SQLSMALLINT                     Operation)
1663 {
1664         TRACE("\n");
1665
1666         if (!pSQLBulkOperations) return SQL_ERROR;
1667         return pSQLBulkOperations(StatementHandle, Operation);
1668 }
1669
1670
1671 /*************************************************************************
1672  *                              SQLColAttributes           [ODBC32.006]
1673  */
1674 SQLRETURN WINAPI ODBC32_SQLColAttributes(
1675     SQLHSTMT           hstmt,
1676     SQLUSMALLINT       icol,
1677     SQLUSMALLINT       fDescType,
1678     SQLPOINTER         rgbDesc,
1679     SQLSMALLINT        cbDescMax,
1680     SQLSMALLINT           *pcbDesc,
1681     SQLLEN                *pfDesc)
1682 {
1683         TRACE("\n");
1684
1685         if (!pSQLColAttributes) return SQL_ERROR;
1686         return pSQLColAttributes(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
1687 }
1688
1689
1690 /*************************************************************************
1691  *                              SQLColumnPrivileges           [ODBC32.056]
1692  */
1693 SQLRETURN WINAPI ODBC32_SQLColumnPrivileges(
1694     SQLHSTMT           hstmt,
1695     SQLCHAR               *szCatalogName,
1696     SQLSMALLINT        cbCatalogName,
1697     SQLCHAR               *szSchemaName,
1698     SQLSMALLINT        cbSchemaName,
1699     SQLCHAR               *szTableName,
1700     SQLSMALLINT        cbTableName,
1701     SQLCHAR               *szColumnName,
1702     SQLSMALLINT        cbColumnName)
1703 {
1704         TRACE("\n");
1705
1706         if (!pSQLColumnPrivileges) return SQL_ERROR;
1707         return pSQLColumnPrivileges(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1708                                     szTableName, cbTableName, szColumnName, cbColumnName);
1709 }
1710
1711
1712 /*************************************************************************
1713  *                              SQLDescribeParam          [ODBC32.058]
1714  */
1715 SQLRETURN WINAPI ODBC32_SQLDescribeParam(
1716     SQLHSTMT           hstmt,
1717     SQLUSMALLINT       ipar,
1718     SQLSMALLINT           *pfSqlType,
1719     SQLULEN               *pcbParamDef,
1720     SQLSMALLINT           *pibScale,
1721     SQLSMALLINT           *pfNullable)
1722 {
1723         TRACE("\n");
1724
1725         if (!pSQLDescribeParam) return SQL_ERROR;
1726         return pSQLDescribeParam(hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable);
1727 }
1728
1729
1730 /*************************************************************************
1731  *                              SQLExtendedFetch           [ODBC32.059]
1732  */
1733 SQLRETURN WINAPI ODBC32_SQLExtendedFetch(
1734     SQLHSTMT           hstmt,
1735     SQLUSMALLINT       fFetchType,
1736     SQLLEN             irow,
1737     SQLULEN               *pcrow,
1738     SQLUSMALLINT          *rgfRowStatus)
1739 {
1740         TRACE("\n");
1741
1742         if (!pSQLExtendedFetch) return SQL_ERROR;
1743         return pSQLExtendedFetch(hstmt, fFetchType, irow, pcrow, rgfRowStatus);
1744 }
1745
1746
1747 /*************************************************************************
1748  *                              SQLForeignKeys           [ODBC32.060]
1749  */
1750 SQLRETURN WINAPI ODBC32_SQLForeignKeys(
1751     SQLHSTMT           hstmt,
1752     SQLCHAR               *szPkCatalogName,
1753     SQLSMALLINT        cbPkCatalogName,
1754     SQLCHAR               *szPkSchemaName,
1755     SQLSMALLINT        cbPkSchemaName,
1756     SQLCHAR               *szPkTableName,
1757     SQLSMALLINT        cbPkTableName,
1758     SQLCHAR               *szFkCatalogName,
1759     SQLSMALLINT        cbFkCatalogName,
1760     SQLCHAR               *szFkSchemaName,
1761     SQLSMALLINT        cbFkSchemaName,
1762     SQLCHAR               *szFkTableName,
1763     SQLSMALLINT        cbFkTableName)
1764 {
1765         TRACE("\n");
1766
1767         if (!pSQLForeignKeys) return SQL_ERROR;
1768         return pSQLForeignKeys(hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName, cbPkSchemaName,
1769                                szPkTableName, cbPkTableName, szFkCatalogName, cbFkCatalogName,
1770                                szFkSchemaName, cbFkSchemaName, szFkTableName, cbFkTableName);
1771 }
1772
1773
1774 /*************************************************************************
1775  *                              SQLMoreResults           [ODBC32.061]
1776  */
1777 SQLRETURN WINAPI ODBC32_SQLMoreResults(SQLHSTMT hstmt)
1778 {
1779         TRACE("\n");
1780
1781         if (!pSQLMoreResults) return SQL_ERROR;
1782         return pSQLMoreResults(hstmt);
1783 }
1784
1785
1786 /*************************************************************************
1787  *                              SQLNativeSql           [ODBC32.062]
1788  */
1789 SQLRETURN WINAPI ODBC32_SQLNativeSql(
1790     SQLHDBC            hdbc,
1791     SQLCHAR               *szSqlStrIn,
1792     SQLINTEGER         cbSqlStrIn,
1793     SQLCHAR               *szSqlStr,
1794     SQLINTEGER         cbSqlStrMax,
1795     SQLINTEGER            *pcbSqlStr)
1796 {
1797         TRACE("\n");
1798
1799         if (!pSQLNativeSql) return SQL_ERROR;
1800         return pSQLNativeSql(hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr);
1801 }
1802
1803
1804 /*************************************************************************
1805  *                              SQLNumParams           [ODBC32.063]
1806  */
1807 SQLRETURN WINAPI ODBC32_SQLNumParams(
1808     SQLHSTMT           hstmt,
1809     SQLSMALLINT           *pcpar)
1810 {
1811         TRACE("\n");
1812
1813         if (!pSQLNumParams) return SQL_ERROR;
1814         return pSQLNumParams(hstmt, pcpar);
1815 }
1816
1817
1818 /*************************************************************************
1819  *                              SQLParamOptions           [ODBC32.064]
1820  */
1821 SQLRETURN WINAPI ODBC32_SQLParamOptions(
1822     SQLHSTMT           hstmt,
1823     SQLULEN            crow,
1824     SQLULEN               *pirow)
1825 {
1826         TRACE("\n");
1827
1828         if (!pSQLParamOptions) return SQL_ERROR;
1829         return pSQLParamOptions(hstmt, crow, pirow);
1830 }
1831
1832
1833 /*************************************************************************
1834  *                              SQLPrimaryKeys           [ODBC32.065]
1835  */
1836 SQLRETURN WINAPI ODBC32_SQLPrimaryKeys(
1837     SQLHSTMT           hstmt,
1838     SQLCHAR               *szCatalogName,
1839     SQLSMALLINT        cbCatalogName,
1840     SQLCHAR               *szSchemaName,
1841     SQLSMALLINT        cbSchemaName,
1842     SQLCHAR               *szTableName,
1843     SQLSMALLINT        cbTableName)
1844 {
1845         TRACE("\n");
1846
1847         if (!pSQLPrimaryKeys) return SQL_ERROR;
1848         return pSQLPrimaryKeys(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1849                                szTableName, cbTableName);
1850 }
1851
1852
1853 /*************************************************************************
1854  *                              SQLProcedureColumns           [ODBC32.066]
1855  */
1856 SQLRETURN WINAPI ODBC32_SQLProcedureColumns(
1857     SQLHSTMT           hstmt,
1858     SQLCHAR               *szCatalogName,
1859     SQLSMALLINT        cbCatalogName,
1860     SQLCHAR               *szSchemaName,
1861     SQLSMALLINT        cbSchemaName,
1862     SQLCHAR               *szProcName,
1863     SQLSMALLINT        cbProcName,
1864     SQLCHAR               *szColumnName,
1865     SQLSMALLINT        cbColumnName)
1866 {
1867         TRACE("\n");
1868
1869         if (!pSQLProcedureColumns) return SQL_ERROR;
1870         return pSQLProcedureColumns(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1871                                     szProcName, cbProcName, szColumnName, cbColumnName);
1872 }
1873
1874
1875 /*************************************************************************
1876  *                              SQLProcedures           [ODBC32.067]
1877  */
1878 SQLRETURN WINAPI ODBC32_SQLProcedures(
1879     SQLHSTMT           hstmt,
1880     SQLCHAR               *szCatalogName,
1881     SQLSMALLINT        cbCatalogName,
1882     SQLCHAR               *szSchemaName,
1883     SQLSMALLINT        cbSchemaName,
1884     SQLCHAR               *szProcName,
1885     SQLSMALLINT        cbProcName)
1886 {
1887         TRACE("\n");
1888
1889         if (!pSQLProcedures) return SQL_ERROR;
1890         return pSQLProcedures(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1891                               szProcName, cbProcName);
1892 }
1893
1894
1895 /*************************************************************************
1896  *                              SQLSetPos           [ODBC32.068]
1897  */
1898 SQLRETURN WINAPI ODBC32_SQLSetPos(
1899     SQLHSTMT           hstmt,
1900         SQLSETPOSIROW      irow,
1901     SQLUSMALLINT       fOption,
1902     SQLUSMALLINT       fLock)
1903 {
1904         TRACE("\n");
1905
1906         if (!pSQLSetPos) return SQL_ERROR;
1907         return pSQLSetPos(hstmt, irow, fOption, fLock);
1908 }
1909
1910
1911 /*************************************************************************
1912  *                              SQLTablePrivileges           [ODBC32.070]
1913  */
1914 SQLRETURN WINAPI ODBC32_SQLTablePrivileges(
1915     SQLHSTMT           hstmt,
1916     SQLCHAR               *szCatalogName,
1917     SQLSMALLINT        cbCatalogName,
1918     SQLCHAR               *szSchemaName,
1919     SQLSMALLINT        cbSchemaName,
1920     SQLCHAR               *szTableName,
1921     SQLSMALLINT        cbTableName)
1922 {
1923         TRACE("\n");
1924
1925         if (!pSQLTablePrivileges) return SQL_ERROR;
1926         return pSQLTablePrivileges(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1927                                    szTableName, cbTableName);
1928 }
1929
1930
1931 /*************************************************************************
1932  *                              SQLDrivers           [ODBC32.071]
1933  */
1934 SQLRETURN WINAPI ODBC32_SQLDrivers(
1935     SQLHENV            henv,
1936     SQLUSMALLINT       fDirection,
1937     SQLCHAR               *szDriverDesc,
1938     SQLSMALLINT        cbDriverDescMax,
1939     SQLSMALLINT           *pcbDriverDesc,
1940     SQLCHAR               *szDriverAttributes,
1941     SQLSMALLINT        cbDriverAttrMax,
1942     SQLSMALLINT           *pcbDriverAttr)
1943 {
1944         SQLRETURN ret;
1945
1946         TRACE("(Direction %d)\n", fDirection);
1947
1948         if (!pSQLDrivers) return SQL_ERROR;
1949         ret = pSQLDrivers(henv, fDirection, szDriverDesc, cbDriverDescMax, pcbDriverDesc,
1950                           szDriverAttributes, cbDriverAttrMax, pcbDriverAttr);
1951
1952         if (ret == SQL_NO_DATA && fDirection == SQL_FETCH_FIRST)
1953             ERR_(winediag)("No ODBC drivers could be found. "
1954                            "Check the settings for your libodbc provider.\n");
1955
1956         return ret;
1957 }
1958
1959
1960 /*************************************************************************
1961  *                              SQLBindParameter           [ODBC32.072]
1962  */
1963 SQLRETURN WINAPI ODBC32_SQLBindParameter(
1964     SQLHSTMT           hstmt,
1965     SQLUSMALLINT       ipar,
1966     SQLSMALLINT        fParamType,
1967     SQLSMALLINT        fCType,
1968     SQLSMALLINT        fSqlType,
1969     SQLULEN            cbColDef,
1970     SQLSMALLINT        ibScale,
1971     SQLPOINTER         rgbValue,
1972     SQLLEN             cbValueMax,
1973     SQLLEN                *pcbValue)
1974 {
1975         TRACE("\n");
1976
1977         if (!pSQLBindParameter) return SQL_ERROR;
1978         return pSQLBindParameter(hstmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale,
1979                                  rgbValue, cbValueMax, pcbValue);
1980 }
1981
1982
1983 /*************************************************************************
1984  *                              SQLDriverConnect           [ODBC32.041]
1985  */
1986 SQLRETURN WINAPI ODBC32_SQLDriverConnect(
1987     SQLHDBC            hdbc,
1988     SQLHWND            hwnd,
1989     SQLCHAR            *conn_str_in,
1990     SQLSMALLINT        len_conn_str_in,
1991     SQLCHAR            *conn_str_out,
1992     SQLSMALLINT        conn_str_out_max,
1993     SQLSMALLINT        *ptr_conn_str_out,
1994     SQLUSMALLINT       driver_completion )
1995 {
1996         SQLRETURN ret;
1997
1998         TRACE("(ConnectionString %s, Length %d)\n",
1999               debugstr_a((char *)conn_str_in), len_conn_str_in);
2000
2001         if (!pSQLDriverConnect) return SQL_ERROR;
2002         ret = pSQLDriverConnect(hdbc, hwnd, conn_str_in, len_conn_str_in, conn_str_out,
2003                                  conn_str_out_max, ptr_conn_str_out, driver_completion);
2004         TRACE("Returns %d\n", ret);
2005         return ret;
2006 }
2007
2008
2009 /*************************************************************************
2010  *                              SQLSetScrollOptions           [ODBC32.069]
2011  */
2012 SQLRETURN WINAPI ODBC32_SQLSetScrollOptions(
2013     SQLHSTMT           statement_handle,
2014     SQLUSMALLINT       f_concurrency,
2015     SQLLEN             crow_keyset,
2016     SQLUSMALLINT       crow_rowset )
2017 {
2018         TRACE("\n");
2019
2020         if (!pSQLSetScrollOptions) return SQL_ERROR;
2021         return pSQLSetScrollOptions(statement_handle, f_concurrency, crow_keyset, crow_rowset);
2022 }
2023
2024 static BOOL SQLColAttributes_KnownStringAttribute(SQLUSMALLINT fDescType)
2025 {
2026     static const SQLUSMALLINT attrList[] =
2027     {
2028         SQL_COLUMN_OWNER_NAME,
2029         SQL_COLUMN_QUALIFIER_NAME,
2030         SQL_COLUMN_LABEL,
2031         SQL_COLUMN_NAME,
2032         SQL_COLUMN_TABLE_NAME,
2033         SQL_COLUMN_TYPE_NAME,
2034         SQL_DESC_BASE_COLUMN_NAME,
2035         SQL_DESC_BASE_TABLE_NAME,
2036         SQL_DESC_CATALOG_NAME,
2037         SQL_DESC_LABEL,
2038         SQL_DESC_LITERAL_PREFIX,
2039         SQL_DESC_LITERAL_SUFFIX,
2040         SQL_DESC_LOCAL_TYPE_NAME,
2041         SQL_DESC_NAME,
2042         SQL_DESC_SCHEMA_NAME,
2043         SQL_DESC_TABLE_NAME,
2044         SQL_DESC_TYPE_NAME,
2045     };
2046     unsigned int i;
2047
2048     for (i = 0; i < ARRAY_SIZE(attrList); i++) {
2049         if (attrList[i] == fDescType) return TRUE;
2050     }
2051     return FALSE;
2052 }
2053
2054 /*************************************************************************
2055  *                              SQLColAttributesW          [ODBC32.106]
2056  */
2057 SQLRETURN WINAPI ODBC32_SQLColAttributesW(
2058     SQLHSTMT           hstmt,
2059     SQLUSMALLINT       icol,
2060     SQLUSMALLINT       fDescType,
2061     SQLPOINTER         rgbDesc,
2062     SQLSMALLINT        cbDescMax,
2063     SQLSMALLINT           *pcbDesc,
2064     SQLLEN                *pfDesc)
2065 {
2066         SQLRETURN iResult;
2067
2068         TRACE("hstmt=%p icol=%d fDescType=%d rgbDesc=%p cbDescMax=%d pcbDesc=%p pfDesc=%p\n",
2069             hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
2070
2071         if (!pSQLColAttributesW) return SQL_ERROR;
2072
2073         iResult = pSQLColAttributesW(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
2074         if (iResult == SQL_SUCCESS && rgbDesc != NULL && SQLColAttributes_KnownStringAttribute(fDescType)) {
2075         /*
2076             TRACE("Dumping values fetched via SQLColAttributesW:\n");
2077             TRACE("    Attribute name : %s\n", debugstr_w(rgbDesc));
2078             TRACE("    Declared length: %d\n", *pcbDesc);
2079         */
2080             if (*pcbDesc != lstrlenW(rgbDesc) * 2) {
2081                 TRACE("CHEAT: resetting name length for ADO\n");
2082                 *pcbDesc = lstrlenW(rgbDesc) * 2;
2083             }
2084         }
2085         return iResult;
2086 }
2087
2088 /*************************************************************************
2089  *                              SQLConnectW          [ODBC32.107]
2090  */
2091 SQLRETURN WINAPI ODBC32_SQLConnectW(SQLHDBC ConnectionHandle,
2092              WCHAR *ServerName, SQLSMALLINT NameLength1,
2093              WCHAR *UserName, SQLSMALLINT NameLength2,
2094              WCHAR *Authentication, SQLSMALLINT NameLength3)
2095 {
2096         SQLRETURN ret;
2097         TRACE("(Server=%.*s)\n",NameLength1+3, debugstr_w(ServerName));
2098
2099         if (!pSQLConnectW) return SQL_ERROR;
2100
2101         ret = pSQLConnectW(ConnectionHandle, ServerName, NameLength1,
2102                            UserName, NameLength2, Authentication, NameLength3);
2103
2104         TRACE("Returns %d\n", ret);
2105         return ret;
2106 }
2107
2108 /*************************************************************************
2109  *                              SQLDescribeColW          [ODBC32.108]
2110  */
2111 SQLRETURN WINAPI ODBC32_SQLDescribeColW(SQLHSTMT StatementHandle,
2112              SQLUSMALLINT ColumnNumber, WCHAR *ColumnName,
2113              SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
2114              SQLSMALLINT *DataType, SQLULEN *ColumnSize,
2115              SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
2116 {
2117         SQLRETURN iResult;
2118         TRACE("\n");
2119
2120         if (!pSQLDescribeColW) return SQL_ERROR;
2121
2122         iResult = pSQLDescribeColW(StatementHandle, ColumnNumber, ColumnName,
2123                                    BufferLength, NameLength, DataType, ColumnSize,
2124                                    DecimalDigits, Nullable);
2125         if (iResult >= 0) {
2126             TRACE("Successfully recovered the following column information:\n");
2127             TRACE("\tRequested column index: %d\n", ColumnNumber);
2128             TRACE("\tAvailable length for column name: %d\n", BufferLength);
2129             if (NameLength != NULL)
2130                 TRACE("\tActual length for column name: %d\n", *NameLength);
2131             else TRACE("\tActual length for column name: (null)\n");
2132             TRACE("\tReturned column name: %s\n", debugstr_w(ColumnName));
2133         }
2134         return iResult;
2135 }
2136
2137 /*************************************************************************
2138  *                              SQLErrorW          [ODBC32.110]
2139  */
2140 SQLRETURN WINAPI ODBC32_SQLErrorW(SQLHENV EnvironmentHandle,
2141              SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle,
2142              WCHAR *Sqlstate, SQLINTEGER *NativeError,
2143              WCHAR *MessageText, SQLSMALLINT BufferLength,
2144              SQLSMALLINT *TextLength)
2145 {
2146         TRACE("\n");
2147
2148         if (!pSQLErrorW) return SQL_ERROR;
2149         return pSQLErrorW(EnvironmentHandle, ConnectionHandle, StatementHandle,
2150                           Sqlstate, NativeError, MessageText, BufferLength, TextLength);
2151 }
2152
2153 /*************************************************************************
2154  *                              SQLExecDirectW          [ODBC32.111]
2155  */
2156 SQLRETURN WINAPI ODBC32_SQLExecDirectW(SQLHSTMT StatementHandle,
2157     WCHAR *StatementText, SQLINTEGER TextLength)
2158 {
2159         TRACE("\n");
2160
2161         if (!pSQLExecDirectW) return SQL_ERROR;
2162         return pSQLExecDirectW(StatementHandle, StatementText, TextLength);
2163 }
2164
2165 /*************************************************************************
2166  *                              SQLGetCursorNameW          [ODBC32.117]
2167  */
2168 SQLRETURN WINAPI ODBC32_SQLGetCursorNameW(SQLHSTMT StatementHandle,
2169              WCHAR *CursorName, SQLSMALLINT BufferLength,
2170              SQLSMALLINT *NameLength)
2171 {
2172         TRACE("\n");
2173
2174         if (!pSQLGetCursorNameW) return SQL_ERROR;
2175         return pSQLGetCursorNameW(StatementHandle, CursorName, BufferLength, NameLength);
2176 }
2177
2178 /*************************************************************************
2179  *                              SQLPrepareW          [ODBC32.119]
2180  */
2181 SQLRETURN WINAPI ODBC32_SQLPrepareW(SQLHSTMT StatementHandle,
2182     WCHAR *StatementText, SQLINTEGER TextLength)
2183 {
2184         TRACE("\n");
2185
2186         if (!pSQLPrepareW) return SQL_ERROR;
2187         return pSQLPrepareW(StatementHandle, StatementText, TextLength);
2188 }
2189
2190 /*************************************************************************
2191  *                              SQLSetCursorNameW          [ODBC32.121]
2192  */
2193 SQLRETURN WINAPI ODBC32_SQLSetCursorNameW(SQLHSTMT StatementHandle, WCHAR *CursorName, SQLSMALLINT NameLength)
2194 {
2195         TRACE("\n");
2196
2197         if (!pSQLSetCursorNameW) return SQL_ERROR;
2198         return pSQLSetCursorNameW(StatementHandle, CursorName, NameLength);
2199 }
2200
2201 /*************************************************************************
2202  *                              SQLColAttributeW          [ODBC32.127]
2203  */
2204 SQLRETURN WINAPI ODBC32_SQLColAttributeW (SQLHSTMT StatementHandle,
2205              SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
2206              SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength,
2207              SQLSMALLINT *StringLength, SQLLEN *NumericAttribute)
2208 {
2209         SQLRETURN iResult;
2210
2211         TRACE("StatementHandle=%p ColumnNumber=%d FieldIdentifier=%d CharacterAttribute=%p BufferLength=%d StringLength=%p NumericAttribute=%p\n",
2212             StatementHandle, ColumnNumber, FieldIdentifier,
2213             CharacterAttribute, BufferLength, StringLength, NumericAttribute);
2214
2215         if (!pSQLColAttributeW) return SQL_ERROR;
2216
2217         iResult = pSQLColAttributeW(StatementHandle, ColumnNumber, FieldIdentifier,
2218                                     CharacterAttribute, BufferLength, StringLength, NumericAttribute);
2219         if (iResult == SQL_SUCCESS && CharacterAttribute != NULL && SQLColAttributes_KnownStringAttribute(FieldIdentifier)) {
2220         /*
2221             TRACE("Dumping values fetched via SQLColAttributeW:\n");
2222             TRACE("    Attribute name : %s\n", debugstr_w(rgbDesc));
2223             TRACE("    Declared length: %d\n", *pcbDesc);
2224         */
2225             if (*StringLength != lstrlenW(CharacterAttribute) * 2) {
2226                 TRACE("CHEAT: resetting name length for ADO\n");
2227                 *StringLength = lstrlenW(CharacterAttribute) * 2;
2228             }
2229         }
2230         return iResult;
2231 }
2232
2233 /*************************************************************************
2234  *                              SQLGetConnectAttrW          [ODBC32.132]
2235  */
2236 SQLRETURN WINAPI ODBC32_SQLGetConnectAttrW(SQLHDBC ConnectionHandle,
2237              SQLINTEGER Attribute, SQLPOINTER Value,
2238              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
2239 {
2240         TRACE("\n");
2241
2242         if (!pSQLGetConnectAttrW) return SQL_ERROR;
2243         return pSQLGetConnectAttrW(ConnectionHandle, Attribute, Value,
2244                                    BufferLength, StringLength);
2245 }
2246
2247 /*************************************************************************
2248  *                              SQLGetDescFieldW          [ODBC32.133]
2249  */
2250 SQLRETURN WINAPI ODBC32_SQLGetDescFieldW(SQLHDESC DescriptorHandle,
2251              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
2252              SQLPOINTER Value, SQLINTEGER BufferLength,
2253              SQLINTEGER *StringLength)
2254 {
2255         TRACE("\n");
2256
2257         if (!pSQLGetDescFieldW) return SQL_ERROR;
2258         return pSQLGetDescFieldW(DescriptorHandle, RecNumber, FieldIdentifier,
2259                                  Value, BufferLength, StringLength);
2260 }
2261
2262 /*************************************************************************
2263  *                              SQLGetDescRecW          [ODBC32.134]
2264  */
2265 SQLRETURN WINAPI ODBC32_SQLGetDescRecW(SQLHDESC DescriptorHandle,
2266              SQLSMALLINT RecNumber, WCHAR *Name,
2267              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
2268              SQLSMALLINT *Type, SQLSMALLINT *SubType,
2269              SQLLEN *Length, SQLSMALLINT *Precision,
2270              SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
2271 {
2272         TRACE("\n");
2273
2274         if (!pSQLGetDescRecW) return SQL_ERROR;
2275         return pSQLGetDescRecW(DescriptorHandle, RecNumber, Name, BufferLength,
2276                                StringLength, Type, SubType, Length, Precision, Scale, Nullable);
2277 }
2278
2279 /*************************************************************************
2280  *                              SQLGetDiagFieldW          [ODBC32.135]
2281  */
2282 SQLRETURN WINAPI ODBC32_SQLGetDiagFieldW(SQLSMALLINT HandleType, SQLHANDLE Handle,
2283              SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
2284              SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
2285              SQLSMALLINT *StringLength)
2286 {
2287         TRACE("\n");
2288
2289         if (!pSQLGetDiagFieldW) return SQL_ERROR;
2290         return pSQLGetDiagFieldW(HandleType, Handle, RecNumber, DiagIdentifier,
2291                                  DiagInfo, BufferLength, StringLength);
2292 }
2293
2294 /*************************************************************************
2295  *                              SQLGetDiagRecW           [ODBC32.136]
2296  */
2297 SQLRETURN WINAPI ODBC32_SQLGetDiagRecW(SQLSMALLINT HandleType, SQLHANDLE Handle,
2298              SQLSMALLINT RecNumber, WCHAR *Sqlstate,
2299              SQLINTEGER *NativeError, WCHAR *MessageText,
2300              SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
2301 {
2302         TRACE("\n");
2303
2304         if (!pSQLGetDiagRecW) return SQL_ERROR;
2305         return pSQLGetDiagRecW(HandleType, Handle, RecNumber, Sqlstate, NativeError,
2306                                MessageText, BufferLength, TextLength);
2307 }
2308
2309 /*************************************************************************
2310  *                              SQLGetStmtAttrW          [ODBC32.138]
2311  */
2312 SQLRETURN WINAPI ODBC32_SQLGetStmtAttrW(SQLHSTMT StatementHandle,
2313              SQLINTEGER Attribute, SQLPOINTER Value,
2314              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
2315 {
2316         SQLRETURN iResult;
2317
2318         TRACE("Attribute = (%02d) Value = %p BufferLength = (%d) StringLength = %p\n",
2319             Attribute, Value, BufferLength, StringLength);
2320
2321         if (Value == NULL) {
2322             WARN("Unexpected NULL in Value return address\n");
2323             iResult = SQL_ERROR;
2324 /*
2325         } else if (StringLength == NULL) {
2326             WARN("Unexpected NULL in StringLength return address\n");
2327             iResult = SQL_ERROR;
2328 */
2329         } else {
2330             if (!pSQLGetStmtAttrW) return SQL_ERROR;
2331             iResult = pSQLGetStmtAttrW(StatementHandle, Attribute, Value, BufferLength, StringLength);
2332             TRACE("returning %d...\n", iResult);
2333         }
2334         return iResult;
2335 }
2336
2337 /*************************************************************************
2338  *                              SQLSetConnectAttrW          [ODBC32.139]
2339  */
2340 SQLRETURN WINAPI ODBC32_SQLSetConnectAttrW(SQLHDBC ConnectionHandle, SQLINTEGER Attribute,
2341         SQLPOINTER Value, SQLINTEGER StringLength)
2342 {
2343         TRACE("\n");
2344
2345         if (!pSQLSetConnectAttrW) return SQL_ERROR;
2346         return pSQLSetConnectAttrW(ConnectionHandle, Attribute, Value, StringLength);
2347 }
2348
2349 /*************************************************************************
2350  *                              SQLColumnsW          [ODBC32.140]
2351  */
2352 SQLRETURN WINAPI ODBC32_SQLColumnsW(SQLHSTMT StatementHandle,
2353              WCHAR *CatalogName, SQLSMALLINT NameLength1,
2354              WCHAR *SchemaName, SQLSMALLINT NameLength2,
2355              WCHAR *TableName, SQLSMALLINT NameLength3,
2356              WCHAR *ColumnName, SQLSMALLINT NameLength4)
2357 {
2358         TRACE("\n");
2359
2360         if (!pSQLColumnsW) return SQL_ERROR;
2361         return pSQLColumnsW(StatementHandle, CatalogName, NameLength1,
2362                             SchemaName, NameLength2, TableName, NameLength3, ColumnName, NameLength4);
2363 }
2364
2365 /*************************************************************************
2366  *                              SQLDriverConnectW          [ODBC32.141]
2367  */
2368 SQLRETURN WINAPI ODBC32_SQLDriverConnectW(
2369     SQLHDBC            hdbc,
2370     SQLHWND            hwnd,
2371     WCHAR              *conn_str_in,
2372     SQLSMALLINT        len_conn_str_in,
2373     WCHAR              *conn_str_out,
2374     SQLSMALLINT        conn_str_out_max,
2375     SQLSMALLINT        *ptr_conn_str_out,
2376     SQLUSMALLINT       driver_completion )
2377 {
2378         TRACE("(ConnectionString %s, Length %d)\n",
2379               debugstr_w(conn_str_in), len_conn_str_in);
2380
2381         if (!pSQLDriverConnectW) return SQL_ERROR;
2382         return pSQLDriverConnectW(hdbc, hwnd, conn_str_in, len_conn_str_in, conn_str_out,
2383                                   conn_str_out_max, ptr_conn_str_out, driver_completion);
2384 }
2385
2386 /*************************************************************************
2387  *                              SQLGetConnectOptionW      [ODBC32.142]
2388  */
2389 SQLRETURN WINAPI ODBC32_SQLGetConnectOptionW(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value)
2390 {
2391         TRACE("\n");
2392
2393         if (!pSQLGetConnectOptionW) return SQL_ERROR;
2394         return pSQLGetConnectOptionW(ConnectionHandle, Option, Value);
2395 }
2396
2397 /*************************************************************************
2398  *                              SQLGetInfoW          [ODBC32.145]
2399  */
2400 SQLRETURN WINAPI ODBC32_SQLGetInfoW(SQLHDBC ConnectionHandle,
2401              SQLUSMALLINT InfoType, SQLPOINTER InfoValue,
2402              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
2403 {
2404         SQLRETURN iResult;
2405
2406         TRACE("InfoType = (%02u), InfoValue = %p, BufferLength = %d bytes\n", InfoType, InfoValue, BufferLength);
2407         if (InfoValue == NULL) {
2408                 WARN("Unexpected NULL in InfoValue address\n");
2409                 iResult = SQL_ERROR;
2410         } else {
2411                 if (!pSQLGetInfoW) return SQL_ERROR;
2412                 iResult = pSQLGetInfoW(ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength);
2413                 TRACE("returning %d...\n", iResult);
2414         }
2415         return iResult;
2416 }
2417
2418 /*************************************************************************
2419  *                              SQLGetTypeInfoW          [ODBC32.147]
2420  */
2421 SQLRETURN WINAPI ODBC32_SQLGetTypeInfoW(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
2422 {
2423         TRACE("\n");
2424
2425         if (!pSQLGetTypeInfoW) return SQL_ERROR;
2426         return pSQLGetTypeInfoW(StatementHandle, DataType);
2427 }
2428
2429 /*************************************************************************
2430  *                              SQLSetConnectOptionW          [ODBC32.150]
2431  */
2432 SQLRETURN WINAPI ODBC32_SQLSetConnectOptionW(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLULEN Value)
2433 {
2434         TRACE("\n");
2435
2436         if (!pSQLSetConnectOptionW) return SQL_ERROR;
2437         return pSQLSetConnectOptionW(ConnectionHandle, Option, Value);
2438 }
2439
2440 /*************************************************************************
2441  *                              SQLSpecialColumnsW          [ODBC32.152]
2442  */
2443 SQLRETURN WINAPI ODBC32_SQLSpecialColumnsW(SQLHSTMT StatementHandle,
2444              SQLUSMALLINT IdentifierType, SQLWCHAR *CatalogName,
2445              SQLSMALLINT NameLength1, SQLWCHAR *SchemaName,
2446              SQLSMALLINT NameLength2, SQLWCHAR *TableName,
2447              SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
2448              SQLUSMALLINT Nullable)
2449 {
2450         if (!pSQLSpecialColumnsW) return SQL_ERROR;
2451         return pSQLSpecialColumnsW(StatementHandle, IdentifierType, CatalogName, NameLength1, SchemaName,
2452                                    NameLength2, TableName, NameLength3, Scope, Nullable);
2453 }
2454
2455 /*************************************************************************
2456  *                              SQLStatisticsW          [ODBC32.153]
2457  */
2458 SQLRETURN WINAPI ODBC32_SQLStatisticsW(SQLHSTMT StatementHandle,
2459              SQLWCHAR *CatalogName, SQLSMALLINT NameLength1,
2460              SQLWCHAR *SchemaName, SQLSMALLINT NameLength2,
2461              SQLWCHAR *TableName, SQLSMALLINT NameLength3,
2462              SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
2463 {
2464         TRACE("\n");
2465
2466         if (!pSQLStatisticsW) return SQL_ERROR;
2467         return pSQLStatisticsW(StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
2468                                TableName, NameLength3, Unique, Reserved);
2469 }
2470
2471 /*************************************************************************
2472  *                              SQLTablesW          [ODBC32.154]
2473  */
2474 SQLRETURN WINAPI ODBC32_SQLTablesW(SQLHSTMT StatementHandle,
2475              SQLWCHAR *CatalogName, SQLSMALLINT NameLength1,
2476              SQLWCHAR *SchemaName, SQLSMALLINT NameLength2,
2477              SQLWCHAR *TableName, SQLSMALLINT NameLength3,
2478              SQLWCHAR *TableType, SQLSMALLINT NameLength4)
2479 {
2480         TRACE("\n");
2481
2482         if (!pSQLTablesW) return SQL_ERROR;
2483         return pSQLTablesW(StatementHandle, CatalogName, NameLength1,
2484                            SchemaName, NameLength2, TableName, NameLength3, TableType, NameLength4);
2485 }
2486
2487 /*************************************************************************
2488  *                              SQLBrowseConnectW          [ODBC32.155]
2489  */
2490 SQLRETURN WINAPI ODBC32_SQLBrowseConnectW(
2491     SQLHDBC            hdbc,
2492     SQLWCHAR               *szConnStrIn,
2493     SQLSMALLINT        cbConnStrIn,
2494     SQLWCHAR               *szConnStrOut,
2495     SQLSMALLINT        cbConnStrOutMax,
2496     SQLSMALLINT       *pcbConnStrOut)
2497 {
2498         TRACE("\n");
2499
2500         if (!pSQLBrowseConnectW) return SQL_ERROR;
2501         return pSQLBrowseConnectW(hdbc, szConnStrIn, cbConnStrIn, szConnStrOut,
2502                                   cbConnStrOutMax, pcbConnStrOut);
2503 }
2504
2505 /*************************************************************************
2506  *                              SQLColumnPrivilegesW          [ODBC32.156]
2507  */
2508 SQLRETURN WINAPI ODBC32_SQLColumnPrivilegesW(
2509     SQLHSTMT           hstmt,
2510     SQLWCHAR               *szCatalogName,
2511     SQLSMALLINT        cbCatalogName,
2512     SQLWCHAR               *szSchemaName,
2513     SQLSMALLINT        cbSchemaName,
2514     SQLWCHAR               *szTableName,
2515     SQLSMALLINT        cbTableName,
2516     SQLWCHAR               *szColumnName,
2517     SQLSMALLINT        cbColumnName)
2518 {
2519         TRACE("\n");
2520
2521         if (!pSQLColumnPrivilegesW) return SQL_ERROR;
2522         return pSQLColumnPrivilegesW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2523                                      szTableName, cbTableName, szColumnName, cbColumnName);
2524 }
2525
2526 /*************************************************************************
2527  *                              SQLDataSourcesW          [ODBC32.157]
2528  */
2529 SQLRETURN WINAPI ODBC32_SQLDataSourcesW(SQLHENV EnvironmentHandle,
2530              SQLUSMALLINT Direction, WCHAR *ServerName,
2531              SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
2532              WCHAR *Description, SQLSMALLINT BufferLength2,
2533              SQLSMALLINT *NameLength2)
2534 {
2535         SQLRETURN ret;
2536
2537         TRACE("EnvironmentHandle = %p\n", EnvironmentHandle);
2538
2539         if (!pSQLDataSourcesW) return SQL_ERROR;
2540
2541         ret = pSQLDataSourcesW(EnvironmentHandle, Direction, ServerName,
2542                                BufferLength1, NameLength1, Description, BufferLength2, NameLength2);
2543
2544         if (TRACE_ON(odbc))
2545         {
2546            TRACE("Returns %d \t", ret);
2547            if (*NameLength1 > 0)
2548              TRACE("DataSource = %s,", debugstr_w(ServerName));
2549            if (*NameLength2 > 0)
2550              TRACE(" Description = %s", debugstr_w(Description));
2551            TRACE("\n");
2552         }
2553
2554         return ret;
2555 }
2556
2557 /*************************************************************************
2558  *                              SQLForeignKeysW          [ODBC32.160]
2559  */
2560 SQLRETURN WINAPI ODBC32_SQLForeignKeysW(
2561     SQLHSTMT           hstmt,
2562     SQLWCHAR               *szPkCatalogName,
2563     SQLSMALLINT        cbPkCatalogName,
2564     SQLWCHAR               *szPkSchemaName,
2565     SQLSMALLINT        cbPkSchemaName,
2566     SQLWCHAR               *szPkTableName,
2567     SQLSMALLINT        cbPkTableName,
2568     SQLWCHAR               *szFkCatalogName,
2569     SQLSMALLINT        cbFkCatalogName,
2570     SQLWCHAR               *szFkSchemaName,
2571     SQLSMALLINT        cbFkSchemaName,
2572     SQLWCHAR               *szFkTableName,
2573     SQLSMALLINT        cbFkTableName)
2574 {
2575         TRACE("\n");
2576
2577         if (!pSQLForeignKeysW) return SQL_ERROR;
2578         return pSQLForeignKeysW(hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName, cbPkSchemaName,
2579                                 szPkTableName, cbPkTableName, szFkCatalogName, cbFkCatalogName,
2580                                 szFkSchemaName, cbFkSchemaName, szFkTableName, cbFkTableName);
2581 }
2582
2583 /*************************************************************************
2584  *                              SQLNativeSqlW          [ODBC32.162]
2585  */
2586 SQLRETURN WINAPI ODBC32_SQLNativeSqlW(
2587     SQLHDBC            hdbc,
2588     SQLWCHAR               *szSqlStrIn,
2589     SQLINTEGER         cbSqlStrIn,
2590     SQLWCHAR               *szSqlStr,
2591     SQLINTEGER         cbSqlStrMax,
2592     SQLINTEGER            *pcbSqlStr)
2593 {
2594         TRACE("\n");
2595
2596         if (!pSQLNativeSqlW) return SQL_ERROR;
2597         return pSQLNativeSqlW(hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr);
2598 }
2599
2600 /*************************************************************************
2601  *                              SQLPrimaryKeysW          [ODBC32.165]
2602  */
2603 SQLRETURN WINAPI ODBC32_SQLPrimaryKeysW(
2604     SQLHSTMT           hstmt,
2605     SQLWCHAR               *szCatalogName,
2606     SQLSMALLINT        cbCatalogName,
2607     SQLWCHAR               *szSchemaName,
2608     SQLSMALLINT        cbSchemaName,
2609     SQLWCHAR               *szTableName,
2610     SQLSMALLINT        cbTableName)
2611 {
2612         TRACE("\n");
2613
2614         if (!pSQLPrimaryKeysW) return SQL_ERROR;
2615         return pSQLPrimaryKeysW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2616                                 szTableName, cbTableName);
2617 }
2618
2619 /*************************************************************************
2620  *                              SQLProcedureColumnsW          [ODBC32.166]
2621  */
2622 SQLRETURN WINAPI ODBC32_SQLProcedureColumnsW(
2623     SQLHSTMT           hstmt,
2624     SQLWCHAR               *szCatalogName,
2625     SQLSMALLINT        cbCatalogName,
2626     SQLWCHAR               *szSchemaName,
2627     SQLSMALLINT        cbSchemaName,
2628     SQLWCHAR               *szProcName,
2629     SQLSMALLINT        cbProcName,
2630     SQLWCHAR               *szColumnName,
2631     SQLSMALLINT        cbColumnName)
2632 {
2633         TRACE("\n");
2634
2635         if (!pSQLProcedureColumnsW) return SQL_ERROR;
2636         return pSQLProcedureColumnsW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2637                                      szProcName, cbProcName, szColumnName, cbColumnName);
2638 }
2639
2640 /*************************************************************************
2641  *                              SQLProceduresW          [ODBC32.167]
2642  */
2643 SQLRETURN WINAPI ODBC32_SQLProceduresW(
2644     SQLHSTMT           hstmt,
2645     SQLWCHAR               *szCatalogName,
2646     SQLSMALLINT        cbCatalogName,
2647     SQLWCHAR               *szSchemaName,
2648     SQLSMALLINT        cbSchemaName,
2649     SQLWCHAR               *szProcName,
2650     SQLSMALLINT        cbProcName)
2651 {
2652         TRACE("\n");
2653
2654         if (!pSQLProceduresW) return SQL_ERROR;
2655         return pSQLProceduresW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2656                                szProcName, cbProcName);
2657 }
2658
2659 /*************************************************************************
2660  *                              SQLTablePrivilegesW          [ODBC32.170]
2661  */
2662 SQLRETURN WINAPI ODBC32_SQLTablePrivilegesW(
2663     SQLHSTMT           hstmt,
2664     SQLWCHAR               *szCatalogName,
2665     SQLSMALLINT        cbCatalogName,
2666     SQLWCHAR               *szSchemaName,
2667     SQLSMALLINT        cbSchemaName,
2668     SQLWCHAR               *szTableName,
2669     SQLSMALLINT        cbTableName)
2670 {
2671         TRACE("\n");
2672
2673         if (!pSQLTablePrivilegesW) return SQL_ERROR;
2674         return pSQLTablePrivilegesW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2675                                     szTableName, cbTableName);
2676 }
2677
2678 /*************************************************************************
2679  *                              SQLDriversW          [ODBC32.171]
2680  */
2681 SQLRETURN WINAPI ODBC32_SQLDriversW(
2682     SQLHENV            henv,
2683     SQLUSMALLINT       fDirection,
2684     SQLWCHAR               *szDriverDesc,
2685     SQLSMALLINT        cbDriverDescMax,
2686     SQLSMALLINT           *pcbDriverDesc,
2687     SQLWCHAR               *szDriverAttributes,
2688     SQLSMALLINT        cbDriverAttrMax,
2689     SQLSMALLINT           *pcbDriverAttr)
2690 {
2691         SQLRETURN ret;
2692
2693         TRACE("(Direction %d)\n", fDirection);
2694
2695         if (!pSQLDriversW) return SQL_ERROR;
2696         ret = pSQLDriversW(henv, fDirection, szDriverDesc, cbDriverDescMax, pcbDriverDesc,
2697                            szDriverAttributes, cbDriverAttrMax, pcbDriverAttr);
2698
2699         if (ret == SQL_NO_DATA && fDirection == SQL_FETCH_FIRST)
2700             ERR_(winediag)("No ODBC drivers could be found. "
2701                            "Check the settings for your libodbc provider.\n");
2702
2703         return ret;
2704 }
2705
2706 /*************************************************************************
2707  *                              SQLSetDescFieldW          [ODBC32.173]
2708  */
2709 SQLRETURN WINAPI ODBC32_SQLSetDescFieldW(SQLHDESC DescriptorHandle,
2710              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
2711              SQLPOINTER Value, SQLINTEGER BufferLength)
2712 {
2713         TRACE("\n");
2714
2715         if (!pSQLSetDescFieldW) return SQL_ERROR;
2716         return pSQLSetDescFieldW(DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength);
2717 }
2718
2719 /*************************************************************************
2720  *                              SQLSetStmtAttrW          [ODBC32.176]
2721  */
2722 SQLRETURN WINAPI ODBC32_SQLSetStmtAttrW(SQLHSTMT StatementHandle,
2723                  SQLINTEGER Attribute, SQLPOINTER Value,
2724                  SQLINTEGER StringLength)
2725 {
2726         SQLRETURN iResult;
2727         TRACE("Attribute = (%02d) Value = %p StringLength = (%d)\n",
2728             Attribute, Value, StringLength);
2729
2730         if (!pSQLSetStmtAttrW) return SQL_ERROR;
2731         iResult = pSQLSetStmtAttrW(StatementHandle, Attribute, Value, StringLength);
2732         if (iResult == SQL_ERROR && (Attribute == SQL_ROWSET_SIZE || Attribute == SQL_ATTR_ROW_ARRAY_SIZE)) {
2733             TRACE("CHEAT: returning SQL_SUCCESS to ADO...\n");
2734             iResult = SQL_SUCCESS;
2735         } else {
2736             TRACE("returning %d...\n", iResult);
2737         }
2738         return iResult;
2739 }
2740
2741 /*************************************************************************
2742  *                              SQLGetDiagRecA           [ODBC32.236]
2743  */
2744 SQLRETURN WINAPI ODBC32_SQLGetDiagRecA(SQLSMALLINT handle_type, SQLHANDLE handle, SQLSMALLINT record,
2745                                        SQLCHAR *sql_state, SQLINTEGER *native_error,
2746                                        SQLCHAR *error_msg, SQLSMALLINT error_msg_max,
2747                                        SQLSMALLINT *error_msg_size)
2748 {
2749     TRACE("\n");
2750
2751     if (!pSQLGetDiagRecA) return SQL_ERROR;
2752     return pSQLGetDiagRecA(handle_type, handle, record, sql_state, native_error, error_msg,
2753                            error_msg_max, error_msg_size);
2754 }
2755
2756 /* End of file */