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