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    TRACE("\n");
 514
 515 #ifdef SONAME_LIBODBC
 516    if (!s || !s[0]) s = SONAME_LIBODBC;
 517 #endif
 518    if (!s || !s[0]) goto failed;
 519
 520    dmHandle = wine_dlopen(s, RTLD_LAZY | RTLD_GLOBAL, error, sizeof(error));
 521
 522    if (dmHandle != NULL)
 523    {
 524       nErrorType = ERROR_FREE;
 525       return TRUE;
 526    }
 527 failed:
 528    WARN("failed to open library %s: %s\n", debugstr_a(s), error);
 529    nErrorType = ERROR_LIBRARY_NOT_FOUND;
 530    return FALSE;
 531 }
 532
 533
 534 /***********************************************************************
 535  * ODBC_LoadDMFunctions [Internal] Populate function table.
 536  *
 537  * PARAMS
 538  *
 539  * RETURNS
 540  *     Success: TRUE
 541  *     Failure: FALSE
 542  */
 543
 544 static BOOL ODBC_LoadDMFunctions(void)
 545 {
 546     char error[256];
 547
 548     if (dmHandle == NULL)
 549         return FALSE;
 550
 551 #define LOAD_FUNC(name) \
 552     if ((p##name = wine_dlsym( dmHandle, #name, error, sizeof(error) ))); \
 553     else WARN( "Failed to load %s: %s\n", #name, error )
 554
 555     LOAD_FUNC(SQLAllocConnect);
 556     LOAD_FUNC(SQLAllocEnv);
 557     LOAD_FUNC(SQLAllocHandle);
 558     LOAD_FUNC(SQLAllocHandleStd);
 559     LOAD_FUNC(SQLAllocStmt);
 560     LOAD_FUNC(SQLBindCol);
 561     LOAD_FUNC(SQLBindParam);
 562     LOAD_FUNC(SQLBindParameter);
 563     LOAD_FUNC(SQLBrowseConnect);
 564     LOAD_FUNC(SQLBrowseConnectW);
 565     LOAD_FUNC(SQLBulkOperations);
 566     LOAD_FUNC(SQLCancel);
 567     LOAD_FUNC(SQLCloseCursor);
 568     LOAD_FUNC(SQLColAttribute);
 569     LOAD_FUNC(SQLColAttributeW);
 570     LOAD_FUNC(SQLColAttributes);
 571     LOAD_FUNC(SQLColAttributesW);
 572     LOAD_FUNC(SQLColumnPrivileges);
 573     LOAD_FUNC(SQLColumnPrivilegesW);
 574     LOAD_FUNC(SQLColumns);
 575     LOAD_FUNC(SQLColumnsW);
 576     LOAD_FUNC(SQLConnect);
 577     LOAD_FUNC(SQLConnectW);
 578     LOAD_FUNC(SQLCopyDesc);
 579     LOAD_FUNC(SQLDataSources);
 580     LOAD_FUNC(SQLDataSourcesA);
 581     LOAD_FUNC(SQLDataSourcesW);
 582     LOAD_FUNC(SQLDescribeCol);
 583     LOAD_FUNC(SQLDescribeColW);
 584     LOAD_FUNC(SQLDescribeParam);
 585     LOAD_FUNC(SQLDisconnect);
 586     LOAD_FUNC(SQLDriverConnect);
 587     LOAD_FUNC(SQLDriverConnectW);
 588     LOAD_FUNC(SQLDrivers);
 589     LOAD_FUNC(SQLDriversW);
 590     LOAD_FUNC(SQLEndTran);
 591     LOAD_FUNC(SQLError);
 592     LOAD_FUNC(SQLErrorW);
 593     LOAD_FUNC(SQLExecDirect);
 594     LOAD_FUNC(SQLExecDirectW);
 595     LOAD_FUNC(SQLExecute);
 596     LOAD_FUNC(SQLExtendedFetch);
 597     LOAD_FUNC(SQLFetch);
 598     LOAD_FUNC(SQLFetchScroll);
 599     LOAD_FUNC(SQLForeignKeys);
 600     LOAD_FUNC(SQLForeignKeysW);
 601     LOAD_FUNC(SQLFreeConnect);
 602     LOAD_FUNC(SQLFreeEnv);
 603     LOAD_FUNC(SQLFreeHandle);
 604     LOAD_FUNC(SQLFreeStmt);
 605     LOAD_FUNC(SQLGetConnectAttr);
 606     LOAD_FUNC(SQLGetConnectAttrW);
 607     LOAD_FUNC(SQLGetConnectOption);
 608     LOAD_FUNC(SQLGetConnectOptionW);
 609     LOAD_FUNC(SQLGetCursorName);
 610     LOAD_FUNC(SQLGetCursorNameW);
 611     LOAD_FUNC(SQLGetData);
 612     LOAD_FUNC(SQLGetDescField);
 613     LOAD_FUNC(SQLGetDescFieldW);
 614     LOAD_FUNC(SQLGetDescRec);
 615     LOAD_FUNC(SQLGetDescRecW);
 616     LOAD_FUNC(SQLGetDiagField);
 617     LOAD_FUNC(SQLGetDiagFieldW);
 618     LOAD_FUNC(SQLGetDiagRec);
 619     LOAD_FUNC(SQLGetDiagRecW);
 620     LOAD_FUNC(SQLGetEnvAttr);
 621     LOAD_FUNC(SQLGetFunctions);
 622     LOAD_FUNC(SQLGetInfo);
 623     LOAD_FUNC(SQLGetInfoW);
 624     LOAD_FUNC(SQLGetStmtAttr);
 625     LOAD_FUNC(SQLGetStmtAttrW);
 626     LOAD_FUNC(SQLGetStmtOption);
 627     LOAD_FUNC(SQLGetTypeInfo);
 628     LOAD_FUNC(SQLGetTypeInfoW);
 629     LOAD_FUNC(SQLMoreResults);
 630     LOAD_FUNC(SQLNativeSql);
 631     LOAD_FUNC(SQLNativeSqlW);
 632     LOAD_FUNC(SQLNumParams);
 633     LOAD_FUNC(SQLNumResultCols);
 634     LOAD_FUNC(SQLParamData);
 635     LOAD_FUNC(SQLParamOptions);
 636     LOAD_FUNC(SQLPrepare);
 637     LOAD_FUNC(SQLPrepareW);
 638     LOAD_FUNC(SQLPrimaryKeys);
 639     LOAD_FUNC(SQLPrimaryKeysW);
 640     LOAD_FUNC(SQLProcedureColumns);
 641     LOAD_FUNC(SQLProcedureColumnsW);
 642     LOAD_FUNC(SQLProcedures);
 643     LOAD_FUNC(SQLProceduresW);
 644     LOAD_FUNC(SQLPutData);
 645     LOAD_FUNC(SQLRowCount);
 646     LOAD_FUNC(SQLSetConnectAttr);
 647     LOAD_FUNC(SQLSetConnectAttrW);
 648     LOAD_FUNC(SQLSetConnectOption);
 649     LOAD_FUNC(SQLSetConnectOptionW);
 650     LOAD_FUNC(SQLSetCursorName);
 651     LOAD_FUNC(SQLSetCursorNameW);
 652     LOAD_FUNC(SQLSetDescField);
 653     LOAD_FUNC(SQLSetDescFieldW);
 654     LOAD_FUNC(SQLSetDescRec);
 655     LOAD_FUNC(SQLSetEnvAttr);
 656     LOAD_FUNC(SQLSetParam);
 657     LOAD_FUNC(SQLSetPos);
 658     LOAD_FUNC(SQLSetScrollOptions);
 659     LOAD_FUNC(SQLSetStmtAttr);
 660     LOAD_FUNC(SQLSetStmtAttrW);
 661     LOAD_FUNC(SQLSetStmtOption);
 662     LOAD_FUNC(SQLSpecialColumns);
 663     LOAD_FUNC(SQLSpecialColumnsW);
 664     LOAD_FUNC(SQLStatistics);
 665     LOAD_FUNC(SQLStatisticsW);
 666     LOAD_FUNC(SQLTablePrivileges);
 667     LOAD_FUNC(SQLTablePrivilegesW);
 668     LOAD_FUNC(SQLTables);
 669     LOAD_FUNC(SQLTablesW);
 670     LOAD_FUNC(SQLTransact);
 671 #undef LOAD_FUNC
 672
 673     return TRUE;
 674 }
 675
 676
 677 /*************************************************************************
 678  *                              SQLAllocConnect           [ODBC32.001]
 679  */
 680 SQLRETURN WINAPI SQLAllocConnect(SQLHENV EnvironmentHandle, SQLHDBC *ConnectionHandle)
 681 {
 682         SQLRETURN ret;
 683         TRACE("Env=%p\n",EnvironmentHandle);
 684
 685         if (!pSQLAllocConnect)
 686         {
 687            *ConnectionHandle = SQL_NULL_HDBC;
 688            TRACE("Not ready\n");
 689            return SQL_ERROR;
 690         }
 691
 692         ret = pSQLAllocConnect(EnvironmentHandle, ConnectionHandle);
 693         TRACE("Returns ret=%d, Handle %p\n",ret, *ConnectionHandle);
 694         return ret;
 695 }
 696
 697
 698 /*************************************************************************
 699  *                              SQLAllocEnv           [ODBC32.002]
 700  */
 701 SQLRETURN WINAPI  SQLAllocEnv(SQLHENV *EnvironmentHandle)
 702 {
 703         SQLRETURN ret;
 704         TRACE("\n");
 705
 706         if (!pSQLAllocEnv)
 707         {
 708            *EnvironmentHandle = SQL_NULL_HENV;
 709            TRACE("Not ready\n");
 710            return SQL_ERROR;
 711         }
 712
 713         ret = pSQLAllocEnv(EnvironmentHandle);
 714         TRACE("Returns ret=%d, Env=%p\n",ret, *EnvironmentHandle);
 715         return ret;
 716 }
 717
 718
 719 /*************************************************************************
 720  *                              SQLAllocHandle           [ODBC32.024]
 721  */
 722 SQLRETURN WINAPI SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
 723 {
 724         SQLRETURN ret;
 725         TRACE("(Type=%d, Handle=%p)\n",HandleType,InputHandle);
 726
 727         if (!pSQLAllocHandle)
 728         {
 729             if (nErrorType == ERROR_LIBRARY_NOT_FOUND)
 730                 WARN("ProxyODBC: Cannot load ODBC driver manager library.\n");
 731
 732             if (HandleType == SQL_HANDLE_ENV)
 733                 *OutputHandle = SQL_NULL_HENV;
 734             else if (HandleType == SQL_HANDLE_DBC)
 735                 *OutputHandle = SQL_NULL_HDBC;
 736             else if (HandleType == SQL_HANDLE_STMT)
 737                 *OutputHandle = SQL_NULL_HSTMT;
 738             else if (HandleType == SQL_HANDLE_DESC)
 739                 *OutputHandle = SQL_NULL_HDESC;
 740
 741             TRACE ("Not ready\n");
 742             return SQL_ERROR;
 743         }
 744
 745         ret = pSQLAllocHandle(HandleType, InputHandle, OutputHandle);
 746         TRACE("Returns ret=%d, Handle=%p\n",ret, *OutputHandle);
 747         return ret;
 748 }
 749
 750
 751 /*************************************************************************
 752  *                              SQLAllocStmt           [ODBC32.003]
 753  */
 754 SQLRETURN WINAPI SQLAllocStmt(SQLHDBC ConnectionHandle, SQLHSTMT *StatementHandle)
 755 {
 756         SQLRETURN ret;
 757
 758         TRACE("(Connection=%p)\n",ConnectionHandle);
 759
 760         if (!pSQLAllocStmt)
 761         {
 762            *StatementHandle = SQL_NULL_HSTMT;
 763            TRACE ("Not ready\n");
 764            return SQL_ERROR;
 765         }
 766
 767         ret = pSQLAllocStmt(ConnectionHandle, StatementHandle);
 768         TRACE ("Returns ret=%d, Handle=%p\n", ret, *StatementHandle);
 769         return ret;
 770 }
 771
 772
 773 /*************************************************************************
 774  *                              SQLAllocHandleStd           [ODBC32.077]
 775  */
 776 SQLRETURN WINAPI SQLAllocHandleStd( SQLSMALLINT HandleType,
 777                                     SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
 778 {
 779         TRACE("ProxyODBC: SQLAllocHandleStd.\n");
 780
 781         if (!pSQLAllocHandleStd)
 782         {
 783             if (nErrorType == ERROR_LIBRARY_NOT_FOUND)
 784                 WARN("ProxyODBC: Cannot load ODBC driver manager library.\n");
 785
 786             if (HandleType == SQL_HANDLE_ENV)
 787                 *OutputHandle = SQL_NULL_HENV;
 788             else if (HandleType == SQL_HANDLE_DBC)
 789                 *OutputHandle = SQL_NULL_HDBC;
 790             else if (HandleType == SQL_HANDLE_STMT)
 791                 *OutputHandle = SQL_NULL_HSTMT;
 792             else if (HandleType == SQL_HANDLE_DESC)
 793                 *OutputHandle = SQL_NULL_HDESC;
 794
 795             return SQL_ERROR;
 796         }
 797
 798         return pSQLAllocHandleStd(HandleType, InputHandle, OutputHandle);
 799 }
 800
 801
 802 /*************************************************************************
 803  *                              SQLBindCol           [ODBC32.004]
 804  */
 805 SQLRETURN WINAPI SQLBindCol(SQLHSTMT StatementHandle,
 806                      SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
 807                      SQLPOINTER TargetValue, SQLLEN BufferLength,
 808                      SQLLEN *StrLen_or_Ind)
 809 {
 810         TRACE("\n");
 811
 812         if (!pSQLBindCol)
 813         {
 814                 TRACE ("Not ready\n");
 815                 return SQL_ERROR;
 816         }
 817
 818         return pSQLBindCol(StatementHandle, ColumnNumber, TargetType,
 819                            TargetValue, BufferLength, StrLen_or_Ind);
 820 }
 821
 822
 823 /*************************************************************************
 824  *                              SQLBindParam           [ODBC32.025]
 825  */
 826 SQLRETURN WINAPI SQLBindParam(SQLHSTMT StatementHandle,
 827              SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
 828              SQLSMALLINT ParameterType, SQLULEN LengthPrecision,
 829              SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
 830              SQLLEN *StrLen_or_Ind)
 831 {
 832         TRACE("\n");
 833
 834         if (!pSQLBindParam) return SQL_ERROR;
 835         return pSQLBindParam(StatementHandle, ParameterNumber, ValueType,
 836                              ParameterType, LengthPrecision, ParameterScale,
 837                              ParameterValue, StrLen_or_Ind);
 838 }
 839
 840
 841 /*************************************************************************
 842  *                              SQLCancel           [ODBC32.005]
 843  */
 844 SQLRETURN WINAPI SQLCancel(SQLHSTMT StatementHandle)
 845 {
 846         TRACE("\n");
 847
 848         if (!pSQLCancel) return SQL_ERROR;
 849         return pSQLCancel(StatementHandle);
 850 }
 851
 852
 853 /*************************************************************************
 854  *                              SQLCloseCursor           [ODBC32.026]
 855  */
 856 SQLRETURN WINAPI  SQLCloseCursor(SQLHSTMT StatementHandle)
 857 {
 858         SQLRETURN ret;
 859         TRACE("(Handle=%p)\n",StatementHandle);
 860
 861         if (!pSQLCloseCursor) return SQL_ERROR;
 862
 863         ret = pSQLCloseCursor(StatementHandle);
 864         TRACE("returns %d\n",ret);
 865         return ret;
 866 }
 867
 868
 869 /*************************************************************************
 870  *                              SQLColAttribute           [ODBC32.027]
 871  */
 872 SQLRETURN WINAPI SQLColAttribute (SQLHSTMT StatementHandle,
 873              SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
 874              SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength,
 875              SQLSMALLINT *StringLength, SQLPOINTER NumericAttribute)
 876 {
 877         TRACE("\n");
 878
 879         if (!pSQLColAttribute) return SQL_ERROR;
 880         return pSQLColAttribute(StatementHandle, ColumnNumber, FieldIdentifier,
 881                                 CharacterAttribute, BufferLength, StringLength, NumericAttribute);
 882 }
 883
 884
 885 /*************************************************************************
 886  *                              SQLColumns           [ODBC32.040]
 887  */
 888 SQLRETURN WINAPI SQLColumns(SQLHSTMT StatementHandle,
 889              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
 890              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
 891              SQLCHAR *TableName, SQLSMALLINT NameLength3,
 892              SQLCHAR *ColumnName, SQLSMALLINT NameLength4)
 893 {
 894         TRACE("\n");
 895
 896         if (!pSQLColumns) return SQL_ERROR;
 897         return pSQLColumns(StatementHandle, CatalogName, NameLength1,
 898                            SchemaName, NameLength2, TableName, NameLength3, ColumnName, NameLength4);
 899 }
 900
 901
 902 /*************************************************************************
 903  *                              SQLConnect           [ODBC32.007]
 904  */
 905 SQLRETURN WINAPI SQLConnect(SQLHDBC ConnectionHandle,
 906              SQLCHAR *ServerName, SQLSMALLINT NameLength1,
 907              SQLCHAR *UserName, SQLSMALLINT NameLength2,
 908              SQLCHAR *Authentication, SQLSMALLINT NameLength3)
 909 {
 910         SQLRETURN ret;
 911         TRACE("(Server=%.*s)\n",NameLength1, ServerName);
 912
 913         if (!pSQLConnect) return SQL_ERROR;
 914
 915         ret = pSQLConnect(ConnectionHandle, ServerName, NameLength1,
 916                           UserName, NameLength2, Authentication, NameLength3);
 917
 918         TRACE("returns %d\n",ret);
 919         return ret;
 920 }
 921
 922
 923 /*************************************************************************
 924  *                              SQLCopyDesc           [ODBC32.028]
 925  */
 926 SQLRETURN WINAPI SQLCopyDesc(SQLHDESC SourceDescHandle, SQLHDESC TargetDescHandle)
 927 {
 928         TRACE("\n");
 929
 930         if (!pSQLCopyDesc) return SQL_ERROR;
 931         return pSQLCopyDesc(SourceDescHandle, TargetDescHandle);
 932 }
 933
 934
 935 /*************************************************************************
 936  *                              SQLDataSources           [ODBC32.057]
 937  */
 938 SQLRETURN WINAPI SQLDataSources(SQLHENV EnvironmentHandle,
 939              SQLUSMALLINT Direction, SQLCHAR *ServerName,
 940              SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
 941              SQLCHAR *Description, SQLSMALLINT BufferLength2,
 942              SQLSMALLINT *NameLength2)
 943 {
 944         SQLRETURN ret;
 945
 946         TRACE("EnvironmentHandle = %p\n", EnvironmentHandle);
 947
 948         if (!pSQLDataSources) return SQL_ERROR;
 949
 950         ret = pSQLDataSources(EnvironmentHandle, Direction, ServerName,
 951                               BufferLength1, NameLength1, Description, BufferLength2, NameLength2);
 952
 953         if (TRACE_ON(odbc))
 954         {
 955            TRACE("returns: %d \t", ret);
 956            if (NameLength1 && *NameLength1 > 0)
 957              TRACE("DataSource = %s,", ServerName);
 958            if (NameLength2 && *NameLength2 > 0)
 959              TRACE(" Description = %s", Description);
 960            TRACE("\n");
 961         }
 962
 963         return ret;
 964 }
 965
 966 SQLRETURN WINAPI SQLDataSourcesA(SQLHENV EnvironmentHandle,
 967              SQLUSMALLINT Direction, SQLCHAR *ServerName,
 968              SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
 969              SQLCHAR *Description, SQLSMALLINT BufferLength2,
 970              SQLSMALLINT *NameLength2)
 971 {
 972     SQLRETURN ret;
 973
 974     TRACE("EnvironmentHandle = %p\n", EnvironmentHandle);
 975
 976     if (!pSQLDataSourcesA) return SQL_ERROR;
 977
 978     ret = pSQLDataSourcesA(EnvironmentHandle, Direction, ServerName,
 979                            BufferLength1, NameLength1, Description, BufferLength2, NameLength2);
 980     if (TRACE_ON(odbc))
 981     {
 982        TRACE("returns: %d \t", ret);
 983        if (NameLength1 && *NameLength1 > 0)
 984          TRACE("DataSource = %s,", ServerName);
 985        if (NameLength2 && *NameLength2 > 0)
 986          TRACE(" Description = %s", Description);
 987        TRACE("\n");
 988     }
 989
 990     return ret;
 991 }
 992
 993 /*************************************************************************
 994  *                              SQLDescribeCol           [ODBC32.008]
 995  */
 996 SQLRETURN WINAPI SQLDescribeCol(SQLHSTMT StatementHandle,
 997              SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
 998              SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
 999              SQLSMALLINT *DataType, SQLULEN *ColumnSize,
1000              SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
1001 {
1002         TRACE("\n");
1003
1004         if (!pSQLDescribeCol) return SQL_ERROR;
1005         return pSQLDescribeCol(StatementHandle, ColumnNumber, ColumnName,
1006                                BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable);
1007 }
1008
1009
1010 /*************************************************************************
1011  *                              SQLDisconnect           [ODBC32.009]
1012  */
1013 SQLRETURN WINAPI SQLDisconnect(SQLHDBC ConnectionHandle)
1014 {
1015         SQLRETURN ret;
1016         TRACE("(Handle=%p)\n", ConnectionHandle);
1017
1018         if (!pSQLDisconnect) return SQL_ERROR;
1019
1020         ret = pSQLDisconnect(ConnectionHandle);
1021         TRACE("returns %d\n",ret);
1022         return ret;
1023 }
1024
1025
1026 /*************************************************************************
1027  *                              SQLEndTran           [ODBC32.029]
1028  */
1029 SQLRETURN WINAPI SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT CompletionType)
1030 {
1031         TRACE("\n");
1032
1033         if (!pSQLEndTran) return SQL_ERROR;
1034         return pSQLEndTran(HandleType, Handle, CompletionType);
1035 }
1036
1037
1038 /*************************************************************************
1039  *                              SQLError           [ODBC32.010]
1040  */
1041 SQLRETURN WINAPI SQLError(SQLHENV EnvironmentHandle,
1042              SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle,
1043              SQLCHAR *Sqlstate, SQLINTEGER *NativeError,
1044              SQLCHAR *MessageText, SQLSMALLINT BufferLength,
1045              SQLSMALLINT *TextLength)
1046 {
1047         TRACE("\n");
1048
1049         if (!pSQLError) return SQL_ERROR;
1050         return pSQLError(EnvironmentHandle, ConnectionHandle, StatementHandle,
1051                          Sqlstate, NativeError, MessageText, BufferLength, TextLength);
1052 }
1053
1054
1055 /*************************************************************************
1056  *                              SQLExecDirect           [ODBC32.011]
1057  */
1058 SQLRETURN WINAPI SQLExecDirect(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
1059 {
1060         TRACE("\n");
1061
1062         if (!pSQLExecDirect) return SQL_ERROR;
1063         return pSQLExecDirect(StatementHandle, StatementText, TextLength);
1064 }
1065
1066
1067 /*************************************************************************
1068  *                              SQLExecute           [ODBC32.012]
1069  */
1070 SQLRETURN WINAPI SQLExecute(SQLHSTMT StatementHandle)
1071 {
1072         TRACE("\n");
1073
1074         if (!pSQLExecute) return SQL_ERROR;
1075         return pSQLExecute(StatementHandle);
1076 }
1077
1078
1079 /*************************************************************************
1080  *                              SQLFetch           [ODBC32.013]
1081  */
1082 SQLRETURN WINAPI SQLFetch(SQLHSTMT StatementHandle)
1083 {
1084         TRACE("\n");
1085
1086         if (!pSQLFetch) return SQL_ERROR;
1087         return pSQLFetch(StatementHandle);
1088 }
1089
1090
1091 /*************************************************************************
1092  *                              SQLFetchScroll          [ODBC32.030]
1093  */
1094 SQLRETURN WINAPI SQLFetchScroll(SQLHSTMT StatementHandle, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
1095 {
1096         TRACE("\n");
1097
1098         if (!pSQLFetchScroll) return SQL_ERROR;
1099         return pSQLFetchScroll(StatementHandle, FetchOrientation, FetchOffset);
1100 }
1101
1102
1103 /*************************************************************************
1104  *                              SQLFreeConnect           [ODBC32.014]
1105  */
1106 SQLRETURN WINAPI SQLFreeConnect(SQLHDBC ConnectionHandle)
1107 {
1108         SQLRETURN ret;
1109         TRACE("(Handle=%p)\n",ConnectionHandle);
1110
1111         if (!pSQLFreeConnect) return SQL_ERROR;
1112
1113         ret = pSQLFreeConnect(ConnectionHandle);
1114         TRACE("Returns %d\n",ret);
1115         return ret;
1116 }
1117
1118
1119 /*************************************************************************
1120  *                              SQLFreeEnv           [ODBC32.015]
1121  */
1122 SQLRETURN WINAPI SQLFreeEnv(SQLHENV EnvironmentHandle)
1123 {
1124         SQLRETURN ret;
1125         TRACE("(Env=%p)\n",EnvironmentHandle);
1126
1127         if (!pSQLFreeEnv) return SQL_ERROR;
1128
1129         ret = pSQLFreeEnv(EnvironmentHandle);
1130         TRACE("Returns %d\n",ret);
1131         return ret;
1132 }
1133
1134
1135 /*************************************************************************
1136  *                              SQLFreeHandle           [ODBC32.031]
1137  */
1138 SQLRETURN WINAPI SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
1139 {
1140         SQLRETURN ret;
1141         TRACE("(Type=%d, Handle=%p)\n",HandleType,Handle);
1142
1143         if (!pSQLFreeHandle) return SQL_ERROR;
1144
1145         ret = pSQLFreeHandle(HandleType, Handle);
1146         TRACE ("Returns %d\n",ret);
1147         return ret;
1148 }
1149
1150
1151 /*************************************************************************
1152  *                              SQLFreeStmt           [ODBC32.016]
1153  */
1154 SQLRETURN WINAPI SQLFreeStmt(SQLHSTMT StatementHandle, SQLUSMALLINT Option)
1155 {
1156         SQLRETURN ret;
1157         TRACE("(Handle %p, Option=%d)\n",StatementHandle, Option);
1158
1159         if (!pSQLFreeStmt) return SQL_ERROR;
1160
1161         ret = pSQLFreeStmt(StatementHandle, Option);
1162         TRACE("Returns %d\n",ret);
1163         return ret;
1164 }
1165
1166
1167 /*************************************************************************
1168  *                              SQLGetConnectAttr           [ODBC32.032]
1169  */
1170 SQLRETURN WINAPI SQLGetConnectAttr(SQLHDBC ConnectionHandle,
1171              SQLINTEGER Attribute, SQLPOINTER Value,
1172              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1173 {
1174         TRACE("\n");
1175
1176         if (!pSQLGetConnectAttr) return SQL_ERROR;
1177         return pSQLGetConnectAttr(ConnectionHandle, Attribute, Value,
1178                                   BufferLength, StringLength);
1179 }
1180
1181
1182 /*************************************************************************
1183  *                              SQLGetConnectOption       [ODBC32.042]
1184  */
1185 SQLRETURN WINAPI SQLGetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value)
1186 {
1187         TRACE("\n");
1188
1189         if (!pSQLGetConnectOption) return SQL_ERROR;
1190         return pSQLGetConnectOption(ConnectionHandle, Option, Value);
1191 }
1192
1193
1194 /*************************************************************************
1195  *                              SQLGetCursorName           [ODBC32.017]
1196  */
1197 SQLRETURN WINAPI SQLGetCursorName(SQLHSTMT StatementHandle,
1198              SQLCHAR *CursorName, SQLSMALLINT BufferLength,
1199              SQLSMALLINT *NameLength)
1200 {
1201         TRACE("\n");
1202
1203         if (!pSQLGetCursorName) return SQL_ERROR;
1204         return pSQLGetCursorName(StatementHandle, CursorName, BufferLength, NameLength);
1205 }
1206
1207
1208 /*************************************************************************
1209  *                              SQLGetData           [ODBC32.043]
1210  */
1211 SQLRETURN WINAPI SQLGetData(SQLHSTMT StatementHandle,
1212              SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
1213              SQLPOINTER TargetValue, SQLLEN BufferLength,
1214              SQLLEN *StrLen_or_Ind)
1215 {
1216         TRACE("\n");
1217
1218         if (!pSQLGetData) return SQL_ERROR;
1219         return pSQLGetData(StatementHandle, ColumnNumber, TargetType,
1220                            TargetValue, BufferLength, StrLen_or_Ind);
1221 }
1222
1223
1224 /*************************************************************************
1225  *                              SQLGetDescField           [ODBC32.033]
1226  */
1227 SQLRETURN WINAPI SQLGetDescField(SQLHDESC DescriptorHandle,
1228              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
1229              SQLPOINTER Value, SQLINTEGER BufferLength,
1230              SQLINTEGER *StringLength)
1231 {
1232         TRACE("\n");
1233
1234         if (!pSQLGetDescField) return SQL_ERROR;
1235         return pSQLGetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
1236                                 Value, BufferLength, StringLength);
1237 }
1238
1239
1240 /*************************************************************************
1241  *                              SQLGetDescRec           [ODBC32.034]
1242  */
1243 SQLRETURN WINAPI SQLGetDescRec(SQLHDESC DescriptorHandle,
1244              SQLSMALLINT RecNumber, SQLCHAR *Name,
1245              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
1246              SQLSMALLINT *Type, SQLSMALLINT *SubType,
1247              SQLLEN *Length, SQLSMALLINT *Precision,
1248              SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
1249 {
1250         TRACE("\n");
1251
1252         if (!pSQLGetDescRec) return SQL_ERROR;
1253         return pSQLGetDescRec(DescriptorHandle, RecNumber, Name, BufferLength,
1254                               StringLength, Type, SubType, Length, Precision, Scale, Nullable);
1255 }
1256
1257
1258 /*************************************************************************
1259  *                              SQLGetDiagField           [ODBC32.035]
1260  */
1261 SQLRETURN WINAPI SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
1262              SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
1263              SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
1264              SQLSMALLINT *StringLength)
1265 {
1266         TRACE("\n");
1267
1268         if (!pSQLGetDiagField) return SQL_ERROR;
1269         return pSQLGetDiagField(HandleType, Handle, RecNumber, DiagIdentifier,
1270                                 DiagInfo, BufferLength, StringLength);
1271 }
1272
1273
1274 /*************************************************************************
1275  *                              SQLGetDiagRec           [ODBC32.036]
1276  */
1277 SQLRETURN WINAPI SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
1278              SQLSMALLINT RecNumber, SQLCHAR *Sqlstate,
1279              SQLINTEGER *NativeError, SQLCHAR *MessageText,
1280              SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
1281 {
1282         TRACE("\n");
1283
1284         if (!pSQLGetDiagRec) return SQL_ERROR;
1285         return pSQLGetDiagRec(HandleType, Handle, RecNumber, Sqlstate, NativeError,
1286                               MessageText, BufferLength, TextLength);
1287 }
1288
1289
1290 /*************************************************************************
1291  *                              SQLGetEnvAttr           [ODBC32.037]
1292  */
1293 SQLRETURN WINAPI SQLGetEnvAttr(SQLHENV EnvironmentHandle,
1294              SQLINTEGER Attribute, SQLPOINTER Value,
1295              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1296 {
1297         TRACE("\n");
1298
1299         if (!pSQLGetEnvAttr) return SQL_ERROR;
1300         return pSQLGetEnvAttr(EnvironmentHandle, Attribute, Value, BufferLength, StringLength);
1301 }
1302
1303
1304 /*************************************************************************
1305  *                              SQLGetFunctions           [ODBC32.044]
1306  */
1307 SQLRETURN WINAPI SQLGetFunctions(SQLHDBC ConnectionHandle, SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported)
1308 {
1309         TRACE("\n");
1310
1311         if (!pSQLGetFunctions) return SQL_ERROR;
1312         return pSQLGetFunctions(ConnectionHandle, FunctionId, Supported);
1313 }
1314
1315
1316 /*************************************************************************
1317  *                              SQLGetInfo           [ODBC32.045]
1318  */
1319 SQLRETURN WINAPI SQLGetInfo(SQLHDBC ConnectionHandle,
1320              SQLUSMALLINT InfoType, SQLPOINTER InfoValue,
1321              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
1322 {
1323         TRACE("\n");
1324
1325         if (!pSQLGetInfo) return SQL_ERROR;
1326         return pSQLGetInfo(ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength);
1327 }
1328
1329
1330 /*************************************************************************
1331  *                              SQLGetStmtAttr           [ODBC32.038]
1332  */
1333 SQLRETURN WINAPI SQLGetStmtAttr(SQLHSTMT StatementHandle,
1334              SQLINTEGER Attribute, SQLPOINTER Value,
1335              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1336 {
1337         TRACE("\n");
1338
1339         if (!pSQLGetStmtAttr) return SQL_ERROR;
1340         return pSQLGetStmtAttr(StatementHandle, Attribute, Value, BufferLength, StringLength);
1341 }
1342
1343
1344 /*************************************************************************
1345  *                              SQLGetStmtOption           [ODBC32.046]
1346  */
1347 SQLRETURN WINAPI SQLGetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLPOINTER Value)
1348 {
1349         TRACE("\n");
1350
1351         if (!pSQLGetStmtOption) return SQL_ERROR;
1352         return pSQLGetStmtOption(StatementHandle, Option, Value);
1353 }
1354
1355
1356 /*************************************************************************
1357  *                              SQLGetTypeInfo           [ODBC32.047]
1358  */
1359 SQLRETURN WINAPI SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
1360 {
1361         TRACE("\n");
1362
1363         if (!pSQLGetTypeInfo) return SQL_ERROR;
1364         return pSQLGetTypeInfo(StatementHandle, DataType);
1365 }
1366
1367
1368 /*************************************************************************
1369  *                              SQLNumResultCols           [ODBC32.018]
1370  */
1371 SQLRETURN WINAPI SQLNumResultCols(SQLHSTMT StatementHandle, SQLSMALLINT *ColumnCount)
1372 {
1373         TRACE("\n");
1374
1375         if (!pSQLNumResultCols) return SQL_ERROR;
1376         return pSQLNumResultCols(StatementHandle, ColumnCount);
1377 }
1378
1379
1380 /*************************************************************************
1381  *                              SQLParamData           [ODBC32.048]
1382  */
1383 SQLRETURN WINAPI SQLParamData(SQLHSTMT StatementHandle, SQLPOINTER *Value)
1384 {
1385         TRACE("\n");
1386
1387         if (!pSQLParamData) return SQL_ERROR;
1388         return pSQLParamData(StatementHandle, Value);
1389 }
1390
1391
1392 /*************************************************************************
1393  *                              SQLPrepare           [ODBC32.019]
1394  */
1395 SQLRETURN WINAPI SQLPrepare(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
1396 {
1397         TRACE("\n");
1398
1399         if (!pSQLPrepare) return SQL_ERROR;
1400         return pSQLPrepare(StatementHandle, StatementText, TextLength);
1401 }
1402
1403
1404 /*************************************************************************
1405  *                              SQLPutData           [ODBC32.049]
1406  */
1407 SQLRETURN WINAPI SQLPutData(SQLHSTMT StatementHandle, SQLPOINTER Data, SQLLEN StrLen_or_Ind)
1408 {
1409         TRACE("\n");
1410
1411         if (!pSQLPutData) return SQL_ERROR;
1412         return pSQLPutData(StatementHandle, Data, StrLen_or_Ind);
1413 }
1414
1415
1416 /*************************************************************************
1417  *                              SQLRowCount           [ODBC32.020]
1418  */
1419 SQLRETURN WINAPI SQLRowCount(SQLHSTMT StatementHandle, SQLLEN *RowCount)
1420 {
1421         TRACE("\n");
1422
1423         if (!pSQLRowCount) return SQL_ERROR;
1424         return pSQLRowCount(StatementHandle, RowCount);
1425 }
1426
1427
1428 /*************************************************************************
1429  *                              SQLSetConnectAttr           [ODBC32.039]
1430  */
1431 SQLRETURN WINAPI SQLSetConnectAttr(SQLHDBC ConnectionHandle, SQLINTEGER Attribute,
1432         SQLPOINTER Value, SQLINTEGER StringLength)
1433 {
1434         TRACE("\n");
1435
1436         if (!pSQLSetConnectAttr) return SQL_ERROR;
1437         return pSQLSetConnectAttr(ConnectionHandle, Attribute, Value, StringLength);
1438 }
1439
1440
1441 /*************************************************************************
1442  *                              SQLSetConnectOption           [ODBC32.050]
1443  */
1444 SQLRETURN WINAPI SQLSetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLULEN Value)
1445 {
1446         TRACE("\n");
1447
1448         if (!pSQLSetConnectOption) return SQL_ERROR;
1449         return pSQLSetConnectOption(ConnectionHandle, Option, Value);
1450 }
1451
1452
1453 /*************************************************************************
1454  *                              SQLSetCursorName           [ODBC32.021]
1455  */
1456 SQLRETURN WINAPI SQLSetCursorName(SQLHSTMT StatementHandle, SQLCHAR *CursorName, SQLSMALLINT NameLength)
1457 {
1458         TRACE("\n");
1459
1460         if (!pSQLSetCursorName) return SQL_ERROR;
1461         return pSQLSetCursorName(StatementHandle, CursorName, NameLength);
1462 }
1463
1464
1465 /*************************************************************************
1466  *                              SQLSetDescField           [ODBC32.073]
1467  */
1468 SQLRETURN WINAPI SQLSetDescField(SQLHDESC DescriptorHandle,
1469              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
1470              SQLPOINTER Value, SQLINTEGER BufferLength)
1471 {
1472         TRACE("\n");
1473
1474         if (!pSQLSetDescField) return SQL_ERROR;
1475         return pSQLSetDescField(DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength);
1476 }
1477
1478
1479 /*************************************************************************
1480  *                              SQLSetDescRec           [ODBC32.074]
1481  */
1482 SQLRETURN WINAPI SQLSetDescRec(SQLHDESC DescriptorHandle,
1483              SQLSMALLINT RecNumber, SQLSMALLINT Type,
1484              SQLSMALLINT SubType, SQLLEN Length,
1485              SQLSMALLINT Precision, SQLSMALLINT Scale,
1486              SQLPOINTER Data, SQLLEN *StringLength,
1487              SQLLEN *Indicator)
1488 {
1489         TRACE("\n");
1490
1491         if (!pSQLSetDescRec) return SQL_ERROR;
1492         return pSQLSetDescRec(DescriptorHandle, RecNumber, Type, SubType, Length,
1493                               Precision, Scale, Data, StringLength, Indicator);
1494 }
1495
1496
1497 /*************************************************************************
1498  *                              SQLSetEnvAttr           [ODBC32.075]
1499  */
1500 SQLRETURN WINAPI SQLSetEnvAttr(SQLHENV EnvironmentHandle,
1501              SQLINTEGER Attribute, SQLPOINTER Value,
1502              SQLINTEGER StringLength)
1503 {
1504         TRACE("\n");
1505
1506         if (!pSQLSetEnvAttr) return SQL_ERROR;
1507         return pSQLSetEnvAttr(EnvironmentHandle, Attribute, Value, StringLength);
1508 }
1509
1510
1511 /*************************************************************************
1512  *                              SQLSetParam           [ODBC32.022]
1513  */
1514 SQLRETURN WINAPI SQLSetParam(SQLHSTMT StatementHandle,
1515              SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
1516              SQLSMALLINT ParameterType, SQLULEN LengthPrecision,
1517              SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
1518              SQLLEN *StrLen_or_Ind)
1519 {
1520         TRACE("\n");
1521
1522         if (!pSQLSetParam) return SQL_ERROR;
1523         return pSQLSetParam(StatementHandle, ParameterNumber, ValueType, ParameterType, LengthPrecision,
1524                             ParameterScale, ParameterValue, StrLen_or_Ind);
1525 }
1526
1527
1528 /*************************************************************************
1529  *                              SQLSetStmtAttr           [ODBC32.076]
1530  */
1531 SQLRETURN WINAPI SQLSetStmtAttr(SQLHSTMT StatementHandle,
1532                  SQLINTEGER Attribute, SQLPOINTER Value,
1533                  SQLINTEGER StringLength)
1534 {
1535         TRACE("\n");
1536
1537         if (!pSQLSetStmtAttr) return SQL_ERROR;
1538         return pSQLSetStmtAttr(StatementHandle, Attribute, Value, StringLength);
1539 }
1540
1541
1542 /*************************************************************************
1543  *                              SQLSetStmtOption           [ODBC32.051]
1544  */
1545 SQLRETURN WINAPI SQLSetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLULEN Value)
1546 {
1547         TRACE("\n");
1548
1549         if (!pSQLSetStmtOption) return SQL_ERROR;
1550         return pSQLSetStmtOption(StatementHandle, Option, Value);
1551 }
1552
1553
1554 /*************************************************************************
1555  *                              SQLSpecialColumns           [ODBC32.052]
1556  */
1557 SQLRETURN WINAPI SQLSpecialColumns(SQLHSTMT StatementHandle,
1558              SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,
1559              SQLSMALLINT NameLength1, SQLCHAR *SchemaName,
1560              SQLSMALLINT NameLength2, SQLCHAR *TableName,
1561              SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
1562              SQLUSMALLINT Nullable)
1563 {
1564
1565         if (!pSQLSpecialColumns) return SQL_ERROR;
1566         return pSQLSpecialColumns(StatementHandle, IdentifierType, CatalogName, NameLength1, SchemaName,
1567                                   NameLength2, TableName, NameLength3, Scope, Nullable);
1568 }
1569
1570
1571 /*************************************************************************
1572  *                              SQLStatistics           [ODBC32.053]
1573  */
1574 SQLRETURN WINAPI SQLStatistics(SQLHSTMT StatementHandle,
1575              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
1576              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
1577              SQLCHAR *TableName, SQLSMALLINT NameLength3,
1578              SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
1579 {
1580         TRACE("\n");
1581
1582         if (!pSQLStatistics) return SQL_ERROR;
1583         return pSQLStatistics(StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
1584                               TableName, NameLength3, Unique, Reserved);
1585 }
1586
1587
1588 /*************************************************************************
1589  *                              SQLTables           [ODBC32.054]
1590  */
1591 SQLRETURN WINAPI SQLTables(SQLHSTMT StatementHandle,
1592              SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
1593              SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
1594              SQLCHAR *TableName, SQLSMALLINT NameLength3,
1595              SQLCHAR *TableType, SQLSMALLINT NameLength4)
1596 {
1597         TRACE("\n");
1598
1599         if (!pSQLTables) return SQL_ERROR;
1600         return pSQLTables(StatementHandle, CatalogName, NameLength1,
1601                           SchemaName, NameLength2, TableName, NameLength3, TableType, NameLength4);
1602 }
1603
1604
1605 /*************************************************************************
1606  *                              SQLTransact           [ODBC32.023]
1607  */
1608 SQLRETURN WINAPI SQLTransact(SQLHENV EnvironmentHandle, SQLHDBC ConnectionHandle,
1609         SQLUSMALLINT CompletionType)
1610 {
1611         TRACE("\n");
1612
1613         if (!pSQLTransact) return SQL_ERROR;
1614         return pSQLTransact(EnvironmentHandle, ConnectionHandle, CompletionType);
1615 }
1616
1617
1618 /*************************************************************************
1619  *                              SQLBrowseConnect           [ODBC32.055]
1620  */
1621 SQLRETURN WINAPI SQLBrowseConnect(
1622     SQLHDBC            hdbc,
1623     SQLCHAR               *szConnStrIn,
1624     SQLSMALLINT        cbConnStrIn,
1625     SQLCHAR               *szConnStrOut,
1626     SQLSMALLINT        cbConnStrOutMax,
1627     SQLSMALLINT       *pcbConnStrOut)
1628 {
1629         TRACE("\n");
1630
1631         if (!pSQLBrowseConnect) return SQL_ERROR;
1632         return pSQLBrowseConnect(hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
1633 }
1634
1635
1636 /*************************************************************************
1637  *                              SQLBulkOperations           [ODBC32.078]
1638  */
1639 SQLRETURN WINAPI  SQLBulkOperations(
1640         SQLHSTMT                        StatementHandle,
1641         SQLSMALLINT                     Operation)
1642 {
1643         TRACE("\n");
1644
1645         if (!pSQLBulkOperations) return SQL_ERROR;
1646         return pSQLBulkOperations(StatementHandle, Operation);
1647 }
1648
1649
1650 /*************************************************************************
1651  *                              SQLColAttributes           [ODBC32.006]
1652  */
1653 SQLRETURN WINAPI SQLColAttributes(
1654     SQLHSTMT           hstmt,
1655     SQLUSMALLINT       icol,
1656     SQLUSMALLINT       fDescType,
1657     SQLPOINTER         rgbDesc,
1658     SQLSMALLINT        cbDescMax,
1659     SQLSMALLINT           *pcbDesc,
1660     SQLLEN            *pfDesc)
1661 {
1662         TRACE("\n");
1663
1664         if (!pSQLColAttributes) return SQL_ERROR;
1665         return pSQLColAttributes(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
1666 }
1667
1668
1669 /*************************************************************************
1670  *                              SQLColumnPrivileges           [ODBC32.056]
1671  */
1672 SQLRETURN WINAPI SQLColumnPrivileges(
1673     SQLHSTMT           hstmt,
1674     SQLCHAR               *szCatalogName,
1675     SQLSMALLINT        cbCatalogName,
1676     SQLCHAR               *szSchemaName,
1677     SQLSMALLINT        cbSchemaName,
1678     SQLCHAR               *szTableName,
1679     SQLSMALLINT        cbTableName,
1680     SQLCHAR               *szColumnName,
1681     SQLSMALLINT        cbColumnName)
1682 {
1683         TRACE("\n");
1684
1685         if (!pSQLColumnPrivileges) return SQL_ERROR;
1686         return pSQLColumnPrivileges(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1687                                     szTableName, cbTableName, szColumnName, cbColumnName);
1688 }
1689
1690
1691 /*************************************************************************
1692  *                              SQLDescribeParam          [ODBC32.058]
1693  */
1694 SQLRETURN WINAPI SQLDescribeParam(
1695     SQLHSTMT           hstmt,
1696     SQLUSMALLINT       ipar,
1697     SQLSMALLINT           *pfSqlType,
1698     SQLULEN           *pcbParamDef,
1699     SQLSMALLINT           *pibScale,
1700     SQLSMALLINT           *pfNullable)
1701 {
1702         TRACE("\n");
1703
1704         if (!pSQLDescribeParam) return SQL_ERROR;
1705         return pSQLDescribeParam(hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable);
1706 }
1707
1708
1709 /*************************************************************************
1710  *                              SQLExtendedFetch           [ODBC32.059]
1711  */
1712 SQLRETURN WINAPI SQLExtendedFetch(
1713     SQLHSTMT           hstmt,
1714     SQLUSMALLINT       fFetchType,
1715     SQLINTEGER         irow,
1716     SQLUINTEGER           *pcrow,
1717     SQLUSMALLINT          *rgfRowStatus)
1718 {
1719         TRACE("\n");
1720
1721         if (!pSQLExtendedFetch) return SQL_ERROR;
1722         return pSQLExtendedFetch(hstmt, fFetchType, irow, pcrow, rgfRowStatus);
1723 }
1724
1725
1726 /*************************************************************************
1727  *                              SQLForeignKeys           [ODBC32.060]
1728  */
1729 SQLRETURN WINAPI SQLForeignKeys(
1730     SQLHSTMT           hstmt,
1731     SQLCHAR               *szPkCatalogName,
1732     SQLSMALLINT        cbPkCatalogName,
1733     SQLCHAR               *szPkSchemaName,
1734     SQLSMALLINT        cbPkSchemaName,
1735     SQLCHAR               *szPkTableName,
1736     SQLSMALLINT        cbPkTableName,
1737     SQLCHAR               *szFkCatalogName,
1738     SQLSMALLINT        cbFkCatalogName,
1739     SQLCHAR               *szFkSchemaName,
1740     SQLSMALLINT        cbFkSchemaName,
1741     SQLCHAR               *szFkTableName,
1742     SQLSMALLINT        cbFkTableName)
1743 {
1744         TRACE("\n");
1745
1746         if (!pSQLForeignKeys) return SQL_ERROR;
1747         return pSQLForeignKeys(hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName, cbPkSchemaName,
1748                                szPkTableName, cbPkTableName, szFkCatalogName, cbFkCatalogName,
1749                                szFkSchemaName, cbFkSchemaName, szFkTableName, cbFkTableName);
1750 }
1751
1752
1753 /*************************************************************************
1754  *                              SQLMoreResults           [ODBC32.061]
1755  */
1756 SQLRETURN WINAPI SQLMoreResults(SQLHSTMT hstmt)
1757 {
1758         TRACE("\n");
1759
1760         if (!pSQLMoreResults) return SQL_ERROR;
1761         return pSQLMoreResults(hstmt);
1762 }
1763
1764
1765 /*************************************************************************
1766  *                              SQLNativeSql           [ODBC32.062]
1767  */
1768 SQLRETURN WINAPI SQLNativeSql(
1769     SQLHDBC            hdbc,
1770     SQLCHAR               *szSqlStrIn,
1771     SQLINTEGER         cbSqlStrIn,
1772     SQLCHAR               *szSqlStr,
1773     SQLINTEGER         cbSqlStrMax,
1774     SQLINTEGER            *pcbSqlStr)
1775 {
1776         TRACE("\n");
1777
1778         if (!pSQLNativeSql) return SQL_ERROR;
1779         return pSQLNativeSql(hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr);
1780 }
1781
1782
1783 /*************************************************************************
1784  *                              SQLNumParams           [ODBC32.063]
1785  */
1786 SQLRETURN WINAPI SQLNumParams(
1787     SQLHSTMT           hstmt,
1788     SQLSMALLINT           *pcpar)
1789 {
1790         TRACE("\n");
1791
1792         if (!pSQLNumParams) return SQL_ERROR;
1793         return pSQLNumParams(hstmt, pcpar);
1794 }
1795
1796
1797 /*************************************************************************
1798  *                              SQLParamOptions           [ODBC32.064]
1799  */
1800 SQLRETURN WINAPI SQLParamOptions(
1801     SQLHSTMT           hstmt,
1802     SQLUINTEGER        crow,
1803     SQLUINTEGER           *pirow)
1804 {
1805         TRACE("\n");
1806
1807         if (!pSQLParamOptions) return SQL_ERROR;
1808         return pSQLParamOptions(hstmt, crow, pirow);
1809 }
1810
1811
1812 /*************************************************************************
1813  *                              SQLPrimaryKeys           [ODBC32.065]
1814  */
1815 SQLRETURN WINAPI SQLPrimaryKeys(
1816     SQLHSTMT           hstmt,
1817     SQLCHAR               *szCatalogName,
1818     SQLSMALLINT        cbCatalogName,
1819     SQLCHAR               *szSchemaName,
1820     SQLSMALLINT        cbSchemaName,
1821     SQLCHAR               *szTableName,
1822     SQLSMALLINT        cbTableName)
1823 {
1824         TRACE("\n");
1825
1826         if (!pSQLPrimaryKeys) return SQL_ERROR;
1827         return pSQLPrimaryKeys(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1828                                szTableName, cbTableName);
1829 }
1830
1831
1832 /*************************************************************************
1833  *                              SQLProcedureColumns           [ODBC32.066]
1834  */
1835 SQLRETURN WINAPI SQLProcedureColumns(
1836     SQLHSTMT           hstmt,
1837     SQLCHAR               *szCatalogName,
1838     SQLSMALLINT        cbCatalogName,
1839     SQLCHAR               *szSchemaName,
1840     SQLSMALLINT        cbSchemaName,
1841     SQLCHAR               *szProcName,
1842     SQLSMALLINT        cbProcName,
1843     SQLCHAR               *szColumnName,
1844     SQLSMALLINT        cbColumnName)
1845 {
1846         TRACE("\n");
1847
1848         if (!pSQLProcedureColumns) return SQL_ERROR;
1849         return pSQLProcedureColumns(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1850                                     szProcName, cbProcName, szColumnName, cbColumnName);
1851 }
1852
1853
1854 /*************************************************************************
1855  *                              SQLProcedures           [ODBC32.067]
1856  */
1857 SQLRETURN WINAPI SQLProcedures(
1858     SQLHSTMT           hstmt,
1859     SQLCHAR               *szCatalogName,
1860     SQLSMALLINT        cbCatalogName,
1861     SQLCHAR               *szSchemaName,
1862     SQLSMALLINT        cbSchemaName,
1863     SQLCHAR               *szProcName,
1864     SQLSMALLINT        cbProcName)
1865 {
1866         TRACE("\n");
1867
1868         if (!pSQLProcedures) return SQL_ERROR;
1869         return pSQLProcedures(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1870                               szProcName, cbProcName);
1871 }
1872
1873
1874 /*************************************************************************
1875  *                              SQLSetPos           [ODBC32.068]
1876  */
1877 SQLRETURN WINAPI SQLSetPos(
1878     SQLHSTMT           hstmt,
1879     SQLUSMALLINT       irow,
1880     SQLUSMALLINT       fOption,
1881     SQLUSMALLINT       fLock)
1882 {
1883         TRACE("\n");
1884
1885         if (!pSQLSetPos) return SQL_ERROR;
1886         return pSQLSetPos(hstmt, irow, fOption, fLock);
1887 }
1888
1889
1890 /*************************************************************************
1891  *                              SQLTablePrivileges           [ODBC32.070]
1892  */
1893 SQLRETURN WINAPI SQLTablePrivileges(
1894     SQLHSTMT           hstmt,
1895     SQLCHAR               *szCatalogName,
1896     SQLSMALLINT        cbCatalogName,
1897     SQLCHAR               *szSchemaName,
1898     SQLSMALLINT        cbSchemaName,
1899     SQLCHAR               *szTableName,
1900     SQLSMALLINT        cbTableName)
1901 {
1902         TRACE("\n");
1903
1904         if (!pSQLTablePrivileges) return SQL_ERROR;
1905         return pSQLTablePrivileges(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
1906                                    szTableName, cbTableName);
1907 }
1908
1909
1910 /*************************************************************************
1911  *                              SQLDrivers           [ODBC32.071]
1912  */
1913 SQLRETURN WINAPI SQLDrivers(
1914     SQLHENV            henv,
1915     SQLUSMALLINT       fDirection,
1916     SQLCHAR               *szDriverDesc,
1917     SQLSMALLINT        cbDriverDescMax,
1918     SQLSMALLINT           *pcbDriverDesc,
1919     SQLCHAR               *szDriverAttributes,
1920     SQLSMALLINT        cbDriverAttrMax,
1921     SQLSMALLINT           *pcbDriverAttr)
1922 {
1923         SQLRETURN ret;
1924
1925         TRACE("direction=%d\n", fDirection);
1926
1927         if (!pSQLDrivers) return SQL_ERROR;
1928         ret = pSQLDrivers(henv, fDirection, szDriverDesc, cbDriverDescMax, pcbDriverDesc,
1929                           szDriverAttributes, cbDriverAttrMax, pcbDriverAttr);
1930
1931         if (ret == SQL_NO_DATA && fDirection == SQL_FETCH_FIRST)
1932             ERR_(winediag)("No ODBC drivers could be found. "
1933                            "Check the settings for your libodbc provider.\n");
1934
1935         return ret;
1936 }
1937
1938
1939 /*************************************************************************
1940  *                              SQLBindParameter           [ODBC32.072]
1941  */
1942 SQLRETURN WINAPI SQLBindParameter(
1943     SQLHSTMT           hstmt,
1944     SQLUSMALLINT       ipar,
1945     SQLSMALLINT        fParamType,
1946     SQLSMALLINT        fCType,
1947     SQLSMALLINT        fSqlType,
1948     SQLULEN        cbColDef,
1949     SQLSMALLINT        ibScale,
1950     SQLPOINTER         rgbValue,
1951     SQLLEN         cbValueMax,
1952     SQLLEN            *pcbValue)
1953 {
1954         TRACE("\n");
1955
1956         if (!pSQLBindParameter) return SQL_ERROR;
1957         return pSQLBindParameter(hstmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale,
1958                                  rgbValue, cbValueMax, pcbValue);
1959 }
1960
1961
1962 /*************************************************************************
1963  *                              SQLDriverConnect           [ODBC32.041]
1964  */
1965 SQLRETURN WINAPI SQLDriverConnect(
1966     SQLHDBC            hdbc,
1967     SQLHWND            hwnd,
1968     SQLCHAR            *conn_str_in,
1969     SQLSMALLINT        len_conn_str_in,
1970     SQLCHAR            *conn_str_out,
1971     SQLSMALLINT        conn_str_out_max,
1972     SQLSMALLINT        *ptr_conn_str_out,
1973     SQLUSMALLINT       driver_completion )
1974 {
1975         TRACE("\n");
1976
1977         if (!pSQLDriverConnect) return SQL_ERROR;
1978         return pSQLDriverConnect(hdbc, hwnd, conn_str_in, len_conn_str_in, conn_str_out,
1979                                  conn_str_out_max, ptr_conn_str_out, driver_completion);
1980 }
1981
1982
1983 /*************************************************************************
1984  *                              SQLSetScrollOptions           [ODBC32.069]
1985  */
1986 SQLRETURN WINAPI SQLSetScrollOptions(
1987     SQLHSTMT           statement_handle,
1988     SQLUSMALLINT       f_concurrency,
1989     SQLLEN         crow_keyset,
1990     SQLUSMALLINT       crow_rowset )
1991 {
1992         TRACE("\n");
1993
1994         if (!pSQLSetScrollOptions) return SQL_ERROR;
1995         return pSQLSetScrollOptions(statement_handle, f_concurrency, crow_keyset, crow_rowset);
1996 }
1997
1998 static BOOL SQLColAttributes_KnownStringAttribute(SQLUSMALLINT fDescType)
1999 {
2000     static const SQLUSMALLINT attrList[] =
2001     {
2002         SQL_COLUMN_OWNER_NAME,
2003         SQL_COLUMN_QUALIFIER_NAME,
2004         SQL_COLUMN_LABEL,
2005         SQL_COLUMN_NAME,
2006         SQL_COLUMN_TABLE_NAME,
2007         SQL_COLUMN_TYPE_NAME,
2008         SQL_DESC_BASE_COLUMN_NAME,
2009         SQL_DESC_BASE_TABLE_NAME,
2010         SQL_DESC_CATALOG_NAME,
2011         SQL_DESC_LABEL,
2012         SQL_DESC_LITERAL_PREFIX,
2013         SQL_DESC_LITERAL_SUFFIX,
2014         SQL_DESC_LOCAL_TYPE_NAME,
2015         SQL_DESC_NAME,
2016         SQL_DESC_SCHEMA_NAME,
2017         SQL_DESC_TABLE_NAME,
2018         SQL_DESC_TYPE_NAME,
2019     };
2020     unsigned int i;
2021
2022     for (i = 0; i < sizeof(attrList) / sizeof(SQLUSMALLINT); i++) {
2023         if (attrList[i] == fDescType) return TRUE;
2024     }
2025     return FALSE;
2026 }
2027
2028 /*************************************************************************
2029  *                              SQLColAttributesW          [ODBC32.106]
2030  */
2031 SQLRETURN WINAPI SQLColAttributesW(
2032     SQLHSTMT           hstmt,
2033     SQLUSMALLINT       icol,
2034     SQLUSMALLINT       fDescType,
2035     SQLPOINTER         rgbDesc,
2036     SQLSMALLINT        cbDescMax,
2037     SQLSMALLINT           *pcbDesc,
2038     SQLLEN            *pfDesc)
2039 {
2040         SQLRETURN iResult;
2041
2042         TRACE("hstmt=%p icol=%d fDescType=%d rgbDesc=%p cbDescMax=%d pcbDesc=%p pfDesc=%p\n",
2043             hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
2044
2045         if (!pSQLColAttributesW) return SQL_ERROR;
2046
2047         iResult = pSQLColAttributesW(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
2048         if (iResult == SQL_SUCCESS && rgbDesc != NULL && SQLColAttributes_KnownStringAttribute(fDescType)) {
2049         /*
2050             TRACE("Dumping values fetched via SQLColAttributesW:\n");
2051             TRACE("    Attribute name : %s\n", debugstr_w(rgbDesc));
2052             TRACE("    Declared length: %d\n", *pcbDesc);
2053         */
2054             if (*pcbDesc != lstrlenW(rgbDesc) * 2) {
2055                 TRACE("CHEAT: resetting name length for ADO\n");
2056                 *pcbDesc = lstrlenW(rgbDesc) * 2;
2057             }
2058         }
2059         return iResult;
2060 }
2061
2062 /*************************************************************************
2063  *                              SQLConnectW          [ODBC32.107]
2064  */
2065 SQLRETURN WINAPI SQLConnectW(SQLHDBC ConnectionHandle,
2066              WCHAR *ServerName, SQLSMALLINT NameLength1,
2067              WCHAR *UserName, SQLSMALLINT NameLength2,
2068              WCHAR *Authentication, SQLSMALLINT NameLength3)
2069 {
2070         SQLRETURN ret;
2071         TRACE("(Server=%.*s)\n",NameLength1+3, debugstr_w(ServerName));
2072
2073         if (!pSQLConnectW) return SQL_ERROR;
2074
2075         ret = pSQLConnectW(ConnectionHandle, ServerName, NameLength1,
2076                            UserName, NameLength2, Authentication, NameLength3);
2077
2078         TRACE("returns %d\n",ret);
2079         return ret;
2080 }
2081
2082 /*************************************************************************
2083  *                              SQLDescribeColW          [ODBC32.108]
2084  */
2085 SQLRETURN WINAPI SQLDescribeColW(SQLHSTMT StatementHandle,
2086              SQLUSMALLINT ColumnNumber, WCHAR *ColumnName,
2087              SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
2088              SQLSMALLINT *DataType, SQLULEN *ColumnSize,
2089              SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
2090 {
2091         SQLRETURN iResult;
2092         TRACE("\n");
2093
2094         if (!pSQLDescribeColW) return SQL_ERROR;
2095
2096         iResult = pSQLDescribeColW(StatementHandle, ColumnNumber, ColumnName,
2097                                    BufferLength, NameLength, DataType, ColumnSize,
2098                                    DecimalDigits, Nullable);
2099         if (iResult >= 0) {
2100             TRACE("Successfully recovered the following column information:\n");
2101             TRACE("\tRequested column index: %d\n", ColumnNumber);
2102             TRACE("\tAvailable length for column name: %d\n", BufferLength);
2103             if (NameLength != NULL)
2104                 TRACE("\tActual length for column name: %d\n", *NameLength);
2105             else TRACE("\tActual length for column name: (null)\n");
2106             TRACE("\tReturned column name: %s\n", debugstr_w(ColumnName));
2107         }
2108         return iResult;
2109 }
2110
2111 /*************************************************************************
2112  *                              SQLErrorW          [ODBC32.110]
2113  */
2114 SQLRETURN WINAPI SQLErrorW(SQLHENV EnvironmentHandle,
2115              SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle,
2116              WCHAR *Sqlstate, SQLINTEGER *NativeError,
2117              WCHAR *MessageText, SQLSMALLINT BufferLength,
2118              SQLSMALLINT *TextLength)
2119 {
2120         TRACE("\n");
2121
2122         if (!pSQLErrorW) return SQL_ERROR;
2123         return pSQLErrorW(EnvironmentHandle, ConnectionHandle, StatementHandle,
2124                           Sqlstate, NativeError, MessageText, BufferLength, TextLength);
2125 }
2126
2127 /*************************************************************************
2128  *                              SQLExecDirectW          [ODBC32.111]
2129  */
2130 SQLRETURN WINAPI SQLExecDirectW(SQLHSTMT StatementHandle,
2131     WCHAR *StatementText, SQLINTEGER TextLength)
2132 {
2133         TRACE("\n");
2134
2135         if (!pSQLExecDirectW) return SQL_ERROR;
2136         return pSQLExecDirectW(StatementHandle, StatementText, TextLength);
2137 }
2138
2139 /*************************************************************************
2140  *                              SQLGetCursorNameW          [ODBC32.117]
2141  */
2142 SQLRETURN WINAPI SQLGetCursorNameW(SQLHSTMT StatementHandle,
2143              WCHAR *CursorName, SQLSMALLINT BufferLength,
2144              SQLSMALLINT *NameLength)
2145 {
2146         TRACE("\n");
2147
2148         if (!pSQLGetCursorNameW) return SQL_ERROR;
2149         return pSQLGetCursorNameW(StatementHandle, CursorName, BufferLength, NameLength);
2150 }
2151
2152 /*************************************************************************
2153  *                              SQLPrepareW          [ODBC32.119]
2154  */
2155 SQLRETURN WINAPI SQLPrepareW(SQLHSTMT StatementHandle,
2156     WCHAR *StatementText, SQLINTEGER TextLength)
2157 {
2158         TRACE("\n");
2159
2160         if (!pSQLPrepareW) return SQL_ERROR;
2161         return pSQLPrepareW(StatementHandle, StatementText, TextLength);
2162 }
2163
2164 /*************************************************************************
2165  *                              SQLSetCursorNameW          [ODBC32.121]
2166  */
2167 SQLRETURN WINAPI SQLSetCursorNameW(SQLHSTMT StatementHandle, WCHAR *CursorName, SQLSMALLINT NameLength)
2168 {
2169         TRACE("\n");
2170
2171         if (!pSQLSetCursorNameW) return SQL_ERROR;
2172         return pSQLSetCursorNameW(StatementHandle, CursorName, NameLength);
2173 }
2174
2175 /*************************************************************************
2176  *                              SQLColAttributeW          [ODBC32.127]
2177  */
2178 SQLRETURN WINAPI SQLColAttributeW (SQLHSTMT StatementHandle,
2179              SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
2180              SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength,
2181              SQLSMALLINT *StringLength, SQLPOINTER NumericAttribute)
2182 {
2183         SQLRETURN iResult;
2184
2185         TRACE("StatementHandle=%p ColumnNumber=%d FieldIdentifier=%d CharacterAttribute=%p BufferLength=%d StringLength=%p NumericAttribute=%p\n",
2186             StatementHandle, ColumnNumber, FieldIdentifier,
2187             CharacterAttribute, BufferLength, StringLength, NumericAttribute);
2188
2189         if (!pSQLColAttributeW) return SQL_ERROR;
2190
2191         iResult = pSQLColAttributeW(StatementHandle, ColumnNumber, FieldIdentifier,
2192                                     CharacterAttribute, BufferLength, StringLength, NumericAttribute);
2193         if (iResult == SQL_SUCCESS && CharacterAttribute != NULL && SQLColAttributes_KnownStringAttribute(FieldIdentifier)) {
2194         /*
2195             TRACE("Dumping values fetched via SQLColAttributeW:\n");
2196             TRACE("    Attribute name : %s\n", debugstr_w(rgbDesc));
2197             TRACE("    Declared length: %d\n", *pcbDesc);
2198         */
2199             if (*StringLength != lstrlenW(CharacterAttribute) * 2) {
2200                 TRACE("CHEAT: resetting name length for ADO\n");
2201                 *StringLength = lstrlenW(CharacterAttribute) * 2;
2202             }
2203         }
2204         return iResult;
2205 }
2206
2207 /*************************************************************************
2208  *                              SQLGetConnectAttrW          [ODBC32.132]
2209  */
2210 SQLRETURN WINAPI SQLGetConnectAttrW(SQLHDBC ConnectionHandle,
2211              SQLINTEGER Attribute, SQLPOINTER Value,
2212              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
2213 {
2214         TRACE("\n");
2215
2216         if (!pSQLGetConnectAttrW) return SQL_ERROR;
2217         return pSQLGetConnectAttrW(ConnectionHandle, Attribute, Value,
2218                                    BufferLength, StringLength);
2219 }
2220
2221 /*************************************************************************
2222  *                              SQLGetDescFieldW          [ODBC32.133]
2223  */
2224 SQLRETURN WINAPI SQLGetDescFieldW(SQLHDESC DescriptorHandle,
2225              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
2226              SQLPOINTER Value, SQLINTEGER BufferLength,
2227              SQLINTEGER *StringLength)
2228 {
2229         TRACE("\n");
2230
2231         if (!pSQLGetDescFieldW) return SQL_ERROR;
2232         return pSQLGetDescFieldW(DescriptorHandle, RecNumber, FieldIdentifier,
2233                                  Value, BufferLength, StringLength);
2234 }
2235
2236 /*************************************************************************
2237  *                              SQLGetDescRecW          [ODBC32.134]
2238  */
2239 SQLRETURN WINAPI SQLGetDescRecW(SQLHDESC DescriptorHandle,
2240              SQLSMALLINT RecNumber, WCHAR *Name,
2241              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
2242              SQLSMALLINT *Type, SQLSMALLINT *SubType,
2243              SQLLEN *Length, SQLSMALLINT *Precision,
2244              SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
2245 {
2246         TRACE("\n");
2247
2248         if (!pSQLGetDescRecW) return SQL_ERROR;
2249         return pSQLGetDescRecW(DescriptorHandle, RecNumber, Name, BufferLength,
2250                                StringLength, Type, SubType, Length, Precision, Scale, Nullable);
2251 }
2252
2253 /*************************************************************************
2254  *                              SQLGetDiagFieldW          [ODBC32.135]
2255  */
2256 SQLRETURN WINAPI SQLGetDiagFieldW(SQLSMALLINT HandleType, SQLHANDLE Handle,
2257              SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
2258              SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
2259              SQLSMALLINT *StringLength)
2260 {
2261         TRACE("\n");
2262
2263         if (!pSQLGetDiagFieldW) return SQL_ERROR;
2264         return pSQLGetDiagFieldW(HandleType, Handle, RecNumber, DiagIdentifier,
2265                                  DiagInfo, BufferLength, StringLength);
2266 }
2267
2268 /*************************************************************************
2269  *                              SQLGetDiagRecW           [ODBC32.136]
2270  */
2271 SQLRETURN WINAPI SQLGetDiagRecW(SQLSMALLINT HandleType, SQLHANDLE Handle,
2272              SQLSMALLINT RecNumber, WCHAR *Sqlstate,
2273              SQLINTEGER *NativeError, WCHAR *MessageText,
2274              SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
2275 {
2276         TRACE("\n");
2277
2278         if (!pSQLGetDiagRecW) return SQL_ERROR;
2279         return pSQLGetDiagRecW(HandleType, Handle, RecNumber, Sqlstate, NativeError,
2280                                MessageText, BufferLength, TextLength);
2281 }
2282
2283 /*************************************************************************
2284  *                              SQLGetStmtAttrW          [ODBC32.138]
2285  */
2286 SQLRETURN WINAPI SQLGetStmtAttrW(SQLHSTMT StatementHandle,
2287              SQLINTEGER Attribute, SQLPOINTER Value,
2288              SQLINTEGER BufferLength, SQLINTEGER *StringLength)
2289 {
2290         SQLRETURN iResult;
2291
2292         TRACE("Attribute = (%02d) Value = %p BufferLength = (%d) StringLength = %p\n",
2293             Attribute, Value, BufferLength, StringLength);
2294
2295         if (Value == NULL) {
2296             WARN("Unexpected NULL in Value return address\n");
2297             iResult = SQL_ERROR;
2298 /*
2299         } else if (StringLength == NULL) {
2300             WARN("Unexpected NULL in StringLength return address\n");
2301             iResult = SQL_ERROR;
2302 */
2303         } else {
2304             if (!pSQLGetStmtAttrW) return SQL_ERROR;
2305             iResult = pSQLGetStmtAttrW(StatementHandle, Attribute, Value, BufferLength, StringLength);
2306             TRACE("returning %d...\n", iResult);
2307         }
2308         return iResult;
2309 }
2310
2311 /*************************************************************************
2312  *                              SQLSetConnectAttrW          [ODBC32.139]
2313  */
2314 SQLRETURN WINAPI SQLSetConnectAttrW(SQLHDBC ConnectionHandle, SQLINTEGER Attribute,
2315         SQLPOINTER Value, SQLINTEGER StringLength)
2316 {
2317         TRACE("\n");
2318
2319         if (!pSQLSetConnectAttrW) return SQL_ERROR;
2320         return pSQLSetConnectAttrW(ConnectionHandle, Attribute, Value, StringLength);
2321 }
2322
2323 /*************************************************************************
2324  *                              SQLColumnsW          [ODBC32.140]
2325  */
2326 SQLRETURN WINAPI SQLColumnsW(SQLHSTMT StatementHandle,
2327              WCHAR *CatalogName, SQLSMALLINT NameLength1,
2328              WCHAR *SchemaName, SQLSMALLINT NameLength2,
2329              WCHAR *TableName, SQLSMALLINT NameLength3,
2330              WCHAR *ColumnName, SQLSMALLINT NameLength4)
2331 {
2332         TRACE("\n");
2333
2334         if (!pSQLColumnsW) return SQL_ERROR;
2335         return pSQLColumnsW(StatementHandle, CatalogName, NameLength1,
2336                             SchemaName, NameLength2, TableName, NameLength3, ColumnName, NameLength4);
2337 }
2338
2339 /*************************************************************************
2340  *                              SQLDriverConnectW          [ODBC32.141]
2341  */
2342 SQLRETURN WINAPI SQLDriverConnectW(
2343     SQLHDBC            hdbc,
2344     SQLHWND            hwnd,
2345     WCHAR              *conn_str_in,
2346     SQLSMALLINT        len_conn_str_in,
2347     WCHAR              *conn_str_out,
2348     SQLSMALLINT        conn_str_out_max,
2349     SQLSMALLINT        *ptr_conn_str_out,
2350     SQLUSMALLINT       driver_completion )
2351 {
2352         TRACE("ConnStrIn (%d bytes) --> %s\n", len_conn_str_in, debugstr_w(conn_str_in));
2353
2354         if (!pSQLDriverConnectW) return SQL_ERROR;
2355         return pSQLDriverConnectW(hdbc, hwnd, conn_str_in, len_conn_str_in, conn_str_out,
2356                                   conn_str_out_max, ptr_conn_str_out, driver_completion);
2357 }
2358
2359 /*************************************************************************
2360  *                              SQLGetConnectOptionW      [ODBC32.142]
2361  */
2362 SQLRETURN WINAPI SQLGetConnectOptionW(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value)
2363 {
2364         TRACE("\n");
2365
2366         if (!pSQLGetConnectOptionW) return SQL_ERROR;
2367         return pSQLGetConnectOptionW(ConnectionHandle, Option, Value);
2368 }
2369
2370 /*************************************************************************
2371  *                              SQLGetInfoW          [ODBC32.145]
2372  */
2373 SQLRETURN WINAPI SQLGetInfoW(SQLHDBC ConnectionHandle,
2374              SQLUSMALLINT InfoType, SQLPOINTER InfoValue,
2375              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
2376 {
2377         SQLRETURN iResult;
2378
2379         TRACE("InfoType = (%02u), InfoValue = %p, BufferLength = %d bytes\n", InfoType, InfoValue, BufferLength);
2380         if (InfoValue == NULL) {
2381                 WARN("Unexpected NULL in InfoValue address\n");
2382                 iResult = SQL_ERROR;
2383         } else {
2384                 if (!pSQLGetInfoW) return SQL_ERROR;
2385                 iResult = pSQLGetInfoW(ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength);
2386                 TRACE("returning %d...\n", iResult);
2387         }
2388         return iResult;
2389 }
2390
2391 /*************************************************************************
2392  *                              SQLGetTypeInfoW          [ODBC32.147]
2393  */
2394 SQLRETURN WINAPI SQLGetTypeInfoW(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
2395 {
2396         TRACE("\n");
2397
2398         if (!pSQLGetTypeInfoW) return SQL_ERROR;
2399         return pSQLGetTypeInfoW(StatementHandle, DataType);
2400 }
2401
2402 /*************************************************************************
2403  *                              SQLSetConnectOptionW          [ODBC32.150]
2404  */
2405 SQLRETURN WINAPI SQLSetConnectOptionW(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLULEN Value)
2406 {
2407         TRACE("\n");
2408
2409         if (!pSQLSetConnectOptionW) return SQL_ERROR;
2410         return pSQLSetConnectOptionW(ConnectionHandle, Option, Value);
2411 }
2412
2413 /*************************************************************************
2414  *                              SQLSpecialColumnsW          [ODBC32.152]
2415  */
2416 SQLRETURN WINAPI SQLSpecialColumnsW(SQLHSTMT StatementHandle,
2417              SQLUSMALLINT IdentifierType, SQLWCHAR *CatalogName,
2418              SQLSMALLINT NameLength1, SQLWCHAR *SchemaName,
2419              SQLSMALLINT NameLength2, SQLWCHAR *TableName,
2420              SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
2421              SQLUSMALLINT Nullable)
2422 {
2423         if (!pSQLSpecialColumnsW) return SQL_ERROR;
2424         return pSQLSpecialColumnsW(StatementHandle, IdentifierType, CatalogName, NameLength1, SchemaName,
2425                                    NameLength2, TableName, NameLength3, Scope, Nullable);
2426 }
2427
2428 /*************************************************************************
2429  *                              SQLStatisticsW          [ODBC32.153]
2430  */
2431 SQLRETURN WINAPI SQLStatisticsW(SQLHSTMT StatementHandle,
2432              SQLWCHAR *CatalogName, SQLSMALLINT NameLength1,
2433              SQLWCHAR *SchemaName, SQLSMALLINT NameLength2,
2434              SQLWCHAR *TableName, SQLSMALLINT NameLength3,
2435              SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
2436 {
2437         TRACE("\n");
2438
2439         if (!pSQLStatisticsW) return SQL_ERROR;
2440         return pSQLStatisticsW(StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
2441                                TableName, NameLength3, Unique, Reserved);
2442 }
2443
2444 /*************************************************************************
2445  *                              SQLTablesW          [ODBC32.154]
2446  */
2447 SQLRETURN WINAPI SQLTablesW(SQLHSTMT StatementHandle,
2448              SQLWCHAR *CatalogName, SQLSMALLINT NameLength1,
2449              SQLWCHAR *SchemaName, SQLSMALLINT NameLength2,
2450              SQLWCHAR *TableName, SQLSMALLINT NameLength3,
2451              SQLWCHAR *TableType, SQLSMALLINT NameLength4)
2452 {
2453         TRACE("\n");
2454
2455         if (!pSQLTablesW) return SQL_ERROR;
2456         return pSQLTablesW(StatementHandle, CatalogName, NameLength1,
2457                            SchemaName, NameLength2, TableName, NameLength3, TableType, NameLength4);
2458 }
2459
2460 /*************************************************************************
2461  *                              SQLBrowseConnectW          [ODBC32.155]
2462  */
2463 SQLRETURN WINAPI SQLBrowseConnectW(
2464     SQLHDBC            hdbc,
2465     SQLWCHAR               *szConnStrIn,
2466     SQLSMALLINT        cbConnStrIn,
2467     SQLWCHAR               *szConnStrOut,
2468     SQLSMALLINT        cbConnStrOutMax,
2469     SQLSMALLINT       *pcbConnStrOut)
2470 {
2471         TRACE("\n");
2472
2473         if (!pSQLBrowseConnectW) return SQL_ERROR;
2474         return pSQLBrowseConnectW(hdbc, szConnStrIn, cbConnStrIn, szConnStrOut,
2475                                   cbConnStrOutMax, pcbConnStrOut);
2476 }
2477
2478 /*************************************************************************
2479  *                              SQLColumnPrivilegesW          [ODBC32.156]
2480  */
2481 SQLRETURN WINAPI SQLColumnPrivilegesW(
2482     SQLHSTMT           hstmt,
2483     SQLWCHAR               *szCatalogName,
2484     SQLSMALLINT        cbCatalogName,
2485     SQLWCHAR               *szSchemaName,
2486     SQLSMALLINT        cbSchemaName,
2487     SQLWCHAR               *szTableName,
2488     SQLSMALLINT        cbTableName,
2489     SQLWCHAR               *szColumnName,
2490     SQLSMALLINT        cbColumnName)
2491 {
2492         TRACE("\n");
2493
2494         if (!pSQLColumnPrivilegesW) return SQL_ERROR;
2495         return pSQLColumnPrivilegesW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2496                                      szTableName, cbTableName, szColumnName, cbColumnName);
2497 }
2498
2499 /*************************************************************************
2500  *                              SQLDataSourcesW          [ODBC32.157]
2501  */
2502 SQLRETURN WINAPI SQLDataSourcesW(SQLHENV EnvironmentHandle,
2503              SQLUSMALLINT Direction, WCHAR *ServerName,
2504              SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
2505              WCHAR *Description, SQLSMALLINT BufferLength2,
2506              SQLSMALLINT *NameLength2)
2507 {
2508         SQLRETURN ret;
2509
2510         TRACE("EnvironmentHandle = %p\n", EnvironmentHandle);
2511
2512         if (!pSQLDataSourcesW) return SQL_ERROR;
2513
2514         ret = pSQLDataSourcesW(EnvironmentHandle, Direction, ServerName,
2515                                BufferLength1, NameLength1, Description, BufferLength2, NameLength2);
2516
2517         if (TRACE_ON(odbc))
2518         {
2519            TRACE("returns: %d \t", ret);
2520            if (*NameLength1 > 0)
2521              TRACE("DataSource = %s,", debugstr_w(ServerName));
2522            if (*NameLength2 > 0)
2523              TRACE(" Description = %s", debugstr_w(Description));
2524            TRACE("\n");
2525         }
2526
2527         return ret;
2528 }
2529
2530 /*************************************************************************
2531  *                              SQLForeignKeysW          [ODBC32.160]
2532  */
2533 SQLRETURN WINAPI SQLForeignKeysW(
2534     SQLHSTMT           hstmt,
2535     SQLWCHAR               *szPkCatalogName,
2536     SQLSMALLINT        cbPkCatalogName,
2537     SQLWCHAR               *szPkSchemaName,
2538     SQLSMALLINT        cbPkSchemaName,
2539     SQLWCHAR               *szPkTableName,
2540     SQLSMALLINT        cbPkTableName,
2541     SQLWCHAR               *szFkCatalogName,
2542     SQLSMALLINT        cbFkCatalogName,
2543     SQLWCHAR               *szFkSchemaName,
2544     SQLSMALLINT        cbFkSchemaName,
2545     SQLWCHAR               *szFkTableName,
2546     SQLSMALLINT        cbFkTableName)
2547 {
2548         TRACE("\n");
2549
2550         if (!pSQLForeignKeysW) return SQL_ERROR;
2551         return pSQLForeignKeysW(hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName, cbPkSchemaName,
2552                                 szPkTableName, cbPkTableName, szFkCatalogName, cbFkCatalogName,
2553                                 szFkSchemaName, cbFkSchemaName, szFkTableName, cbFkTableName);
2554 }
2555
2556 /*************************************************************************
2557  *                              SQLNativeSqlW          [ODBC32.162]
2558  */
2559 SQLRETURN WINAPI SQLNativeSqlW(
2560     SQLHDBC            hdbc,
2561     SQLWCHAR               *szSqlStrIn,
2562     SQLINTEGER         cbSqlStrIn,
2563     SQLWCHAR               *szSqlStr,
2564     SQLINTEGER         cbSqlStrMax,
2565     SQLINTEGER            *pcbSqlStr)
2566 {
2567         TRACE("\n");
2568
2569         if (!pSQLNativeSqlW) return SQL_ERROR;
2570         return pSQLNativeSqlW(hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr);
2571 }
2572
2573 /*************************************************************************
2574  *                              SQLPrimaryKeysW          [ODBC32.165]
2575  */
2576 SQLRETURN WINAPI SQLPrimaryKeysW(
2577     SQLHSTMT           hstmt,
2578     SQLWCHAR               *szCatalogName,
2579     SQLSMALLINT        cbCatalogName,
2580     SQLWCHAR               *szSchemaName,
2581     SQLSMALLINT        cbSchemaName,
2582     SQLWCHAR               *szTableName,
2583     SQLSMALLINT        cbTableName)
2584 {
2585         TRACE("\n");
2586
2587         if (!pSQLPrimaryKeysW) return SQL_ERROR;
2588         return pSQLPrimaryKeysW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2589                                 szTableName, cbTableName);
2590 }
2591
2592 /*************************************************************************
2593  *                              SQLProcedureColumnsW          [ODBC32.166]
2594  */
2595 SQLRETURN WINAPI SQLProcedureColumnsW(
2596     SQLHSTMT           hstmt,
2597     SQLWCHAR               *szCatalogName,
2598     SQLSMALLINT        cbCatalogName,
2599     SQLWCHAR               *szSchemaName,
2600     SQLSMALLINT        cbSchemaName,
2601     SQLWCHAR               *szProcName,
2602     SQLSMALLINT        cbProcName,
2603     SQLWCHAR               *szColumnName,
2604     SQLSMALLINT        cbColumnName)
2605 {
2606         TRACE("\n");
2607
2608         if (!pSQLProcedureColumnsW) return SQL_ERROR;
2609         return pSQLProcedureColumnsW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2610                                      szProcName, cbProcName, szColumnName, cbColumnName);
2611 }
2612
2613 /*************************************************************************
2614  *                              SQLProceduresW          [ODBC32.167]
2615  */
2616 SQLRETURN WINAPI SQLProceduresW(
2617     SQLHSTMT           hstmt,
2618     SQLWCHAR               *szCatalogName,
2619     SQLSMALLINT        cbCatalogName,
2620     SQLWCHAR               *szSchemaName,
2621     SQLSMALLINT        cbSchemaName,
2622     SQLWCHAR               *szProcName,
2623     SQLSMALLINT        cbProcName)
2624 {
2625         TRACE("\n");
2626
2627         if (!pSQLProceduresW) return SQL_ERROR;
2628         return pSQLProceduresW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2629                                szProcName, cbProcName);
2630 }
2631
2632 /*************************************************************************
2633  *                              SQLTablePrivilegesW          [ODBC32.170]
2634  */
2635 SQLRETURN WINAPI SQLTablePrivilegesW(
2636     SQLHSTMT           hstmt,
2637     SQLWCHAR               *szCatalogName,
2638     SQLSMALLINT        cbCatalogName,
2639     SQLWCHAR               *szSchemaName,
2640     SQLSMALLINT        cbSchemaName,
2641     SQLWCHAR               *szTableName,
2642     SQLSMALLINT        cbTableName)
2643 {
2644         TRACE("\n");
2645
2646         if (!pSQLTablePrivilegesW) return SQL_ERROR;
2647         return pSQLTablePrivilegesW(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
2648                                     szTableName, cbTableName);
2649 }
2650
2651 /*************************************************************************
2652  *                              SQLDriversW          [ODBC32.171]
2653  */
2654 SQLRETURN WINAPI SQLDriversW(
2655     SQLHENV            henv,
2656     SQLUSMALLINT       fDirection,
2657     SQLWCHAR               *szDriverDesc,
2658     SQLSMALLINT        cbDriverDescMax,
2659     SQLSMALLINT           *pcbDriverDesc,
2660     SQLWCHAR               *szDriverAttributes,
2661     SQLSMALLINT        cbDriverAttrMax,
2662     SQLSMALLINT           *pcbDriverAttr)
2663 {
2664         SQLRETURN ret;
2665
2666         TRACE("direction=%d\n", fDirection);
2667
2668         if (!pSQLDriversW) return SQL_ERROR;
2669         ret = pSQLDriversW(henv, fDirection, szDriverDesc, cbDriverDescMax, pcbDriverDesc,
2670                            szDriverAttributes, cbDriverAttrMax, pcbDriverAttr);
2671
2672         if (ret == SQL_NO_DATA && fDirection == SQL_FETCH_FIRST)
2673             ERR_(winediag)("No ODBC drivers could be found. "
2674                            "Check the settings for your libodbc provider.\n");
2675
2676         return ret;
2677 }
2678
2679 /*************************************************************************
2680  *                              SQLSetDescFieldW          [ODBC32.173]
2681  */
2682 SQLRETURN WINAPI SQLSetDescFieldW(SQLHDESC DescriptorHandle,
2683              SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
2684              SQLPOINTER Value, SQLINTEGER BufferLength)
2685 {
2686         TRACE("\n");
2687
2688         if (!pSQLSetDescFieldW) return SQL_ERROR;
2689         return pSQLSetDescFieldW(DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength);
2690 }
2691
2692 /*************************************************************************
2693  *                              SQLSetStmtAttrW          [ODBC32.176]
2694  */
2695 SQLRETURN WINAPI SQLSetStmtAttrW(SQLHSTMT StatementHandle,
2696                  SQLINTEGER Attribute, SQLPOINTER Value,
2697                  SQLINTEGER StringLength)
2698 {
2699         SQLRETURN iResult;
2700         TRACE("Attribute = (%02d) Value = %p StringLength = (%d)\n",
2701             Attribute, Value, StringLength);
2702
2703         if (!pSQLSetStmtAttrW) return SQL_ERROR;
2704         iResult = pSQLSetStmtAttrW(StatementHandle, Attribute, Value, StringLength);
2705         if (iResult == SQL_ERROR && (Attribute == SQL_ROWSET_SIZE || Attribute == SQL_ATTR_ROW_ARRAY_SIZE)) {
2706             TRACE("CHEAT: returning SQL_SUCCESS to ADO...\n");
2707             iResult = SQL_SUCCESS;
2708         } else {
2709             TRACE("returning %d...\n", iResult);
2710         }
2711         return iResult;
2712 }
2713
2714
2715 /* End of file */