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