dlls/odbc32/proxyodbc.c

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