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