reactos/dll/win32/odbc32/proxyodbc.c

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