Line data Source code
1 : #ifdef ENABLE_ODBC_WIDE
2 : static SQLRETURN odbc_SQLDriverConnect(SQLHDBC hdbc,
3 : SQLHWND hwnd,
4 : ODBC_CHAR * szConnStrIn, SQLSMALLINT cbConnStrIn,
5 : ODBC_CHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR* pcbConnStrOut,
6 : SQLUSMALLINT fDriverCompletion, int wide);
7 :
8 : SQLRETURN ODBC_PUBLIC ODBC_API SQLDriverConnectW(
9 : SQLHDBC hdbc,
10 : SQLHWND hwnd,
11 : SQLWCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn,
12 : SQLWCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR* pcbConnStrOut,
13 : SQLUSMALLINT fDriverCompletion)
14 : {
15 79 : if (TDS_UNLIKELY(tds_write_dump)) {
16 0 : SQLWSTR_BUFS(1);
17 0 : tdsdump_log_impl(TDS_DBG_FUNC, "SQLDriverConnectW(%p, %p, %ls, %d, %p, %d, %p, %u)\n",
18 : hdbc,
19 : hwnd,
20 : SQLWSTR(szConnStrIn), (int) cbConnStrIn,
21 : szConnStrOut, (int) cbConnStrOutMax, pcbConnStrOut,
22 : (unsigned int) fDriverCompletion);
23 0 : SQLWSTR_FREE();
24 : }
25 79 : return odbc_SQLDriverConnect(hdbc,
26 : hwnd,
27 : (ODBC_CHAR*) szConnStrIn, cbConnStrIn,
28 : (ODBC_CHAR*) szConnStrOut, cbConnStrOutMax, pcbConnStrOut,
29 : fDriverCompletion, 1);
30 : }
31 : #endif
32 :
33 : SQLRETURN ODBC_PUBLIC ODBC_API SQLDriverConnect(
34 : SQLHDBC hdbc,
35 : SQLHWND hwnd,
36 : SQLCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn,
37 : SQLCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR* pcbConnStrOut,
38 : SQLUSMALLINT fDriverCompletion)
39 : {
40 89 : tdsdump_log(TDS_DBG_FUNC, "SQLDriverConnect(%p, %p, %s, %d, %p, %d, %p, %u)\n",
41 : hdbc,
42 : hwnd,
43 : (const char*) szConnStrIn, (int) cbConnStrIn,
44 : szConnStrOut, (int) cbConnStrOutMax, pcbConnStrOut,
45 : (unsigned int) fDriverCompletion);
46 : #ifdef ENABLE_ODBC_WIDE
47 89 : return odbc_SQLDriverConnect(hdbc,
48 : hwnd,
49 : (ODBC_CHAR*) szConnStrIn, cbConnStrIn,
50 : (ODBC_CHAR*) szConnStrOut, cbConnStrOutMax, pcbConnStrOut,
51 : fDriverCompletion, 0);
52 : #else
53 : return odbc_SQLDriverConnect(hdbc,
54 : hwnd,
55 : szConnStrIn, cbConnStrIn,
56 : szConnStrOut, cbConnStrOutMax, pcbConnStrOut,
57 : fDriverCompletion);
58 : #endif
59 : }
60 :
61 : #ifdef ENABLE_ODBC_WIDE
62 : static SQLRETURN odbc_SQLNativeSql(SQLHDBC hdbc,
63 : ODBC_CHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn,
64 : ODBC_CHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER FAR* pcbSqlStr, int wide);
65 :
66 : SQLRETURN ODBC_PUBLIC ODBC_API SQLNativeSqlW(
67 : SQLHDBC hdbc,
68 : SQLWCHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn,
69 : SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER FAR* pcbSqlStr)
70 : {
71 0 : if (TDS_UNLIKELY(tds_write_dump)) {
72 0 : SQLWSTR_BUFS(1);
73 0 : tdsdump_log_impl(TDS_DBG_FUNC, "SQLNativeSqlW(%p, %ls, %d, %p, %d, %p)\n",
74 : hdbc,
75 : SQLWSTR(szSqlStrIn), (int) cbSqlStrIn,
76 : szSqlStr, (int) cbSqlStrMax, pcbSqlStr);
77 0 : SQLWSTR_FREE();
78 : }
79 0 : return odbc_SQLNativeSql(hdbc,
80 : (ODBC_CHAR*) szSqlStrIn, cbSqlStrIn,
81 : (ODBC_CHAR*) szSqlStr, cbSqlStrMax, pcbSqlStr, 1);
82 : }
83 : #endif
84 :
85 : SQLRETURN ODBC_PUBLIC ODBC_API SQLNativeSql(
86 : SQLHDBC hdbc,
87 : SQLCHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn,
88 : SQLCHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER FAR* pcbSqlStr)
89 : {
90 0 : tdsdump_log(TDS_DBG_FUNC, "SQLNativeSql(%p, %s, %d, %p, %d, %p)\n",
91 : hdbc,
92 : (const char*) szSqlStrIn, (int) cbSqlStrIn,
93 : szSqlStr, (int) cbSqlStrMax, pcbSqlStr);
94 : #ifdef ENABLE_ODBC_WIDE
95 0 : return odbc_SQLNativeSql(hdbc,
96 : (ODBC_CHAR*) szSqlStrIn, cbSqlStrIn,
97 : (ODBC_CHAR*) szSqlStr, cbSqlStrMax, pcbSqlStr, 0);
98 : #else
99 : return odbc_SQLNativeSql(hdbc,
100 : szSqlStrIn, cbSqlStrIn,
101 : szSqlStr, cbSqlStrMax, pcbSqlStr);
102 : #endif
103 : }
104 :
105 : #ifdef ENABLE_ODBC_WIDE
106 : static SQLRETURN odbc_SQLConnect(SQLHDBC hdbc,
107 : ODBC_CHAR * szDSN, SQLSMALLINT cbDSN,
108 : ODBC_CHAR * szUID, SQLSMALLINT cbUID,
109 : ODBC_CHAR * szAuthStr, SQLSMALLINT cbAuthStr, int wide);
110 :
111 : SQLRETURN ODBC_PUBLIC ODBC_API SQLConnectW(
112 : SQLHDBC hdbc,
113 : SQLWCHAR * szDSN, SQLSMALLINT cbDSN,
114 : SQLWCHAR * szUID, SQLSMALLINT cbUID,
115 : SQLWCHAR * szAuthStr, SQLSMALLINT cbAuthStr)
116 : {
117 514 : if (TDS_UNLIKELY(tds_write_dump)) {
118 0 : SQLWSTR_BUFS(3);
119 0 : tdsdump_log_impl(TDS_DBG_FUNC, "SQLConnectW(%p, %ls, %d, %ls, %d, %ls, %d)\n",
120 : hdbc,
121 : SQLWSTR(szDSN), (int) cbDSN,
122 : SQLWSTR(szUID), (int) cbUID,
123 : SQLWSTR(szAuthStr), (int) cbAuthStr);
124 0 : SQLWSTR_FREE();
125 : }
126 514 : return odbc_SQLConnect(hdbc,
127 : (ODBC_CHAR*) szDSN, cbDSN,
128 : (ODBC_CHAR*) szUID, cbUID,
129 : (ODBC_CHAR*) szAuthStr, cbAuthStr, 1);
130 : }
131 : #endif
132 :
133 : SQLRETURN ODBC_PUBLIC ODBC_API SQLConnect(
134 : SQLHDBC hdbc,
135 : SQLCHAR * szDSN, SQLSMALLINT cbDSN,
136 : SQLCHAR * szUID, SQLSMALLINT cbUID,
137 : SQLCHAR * szAuthStr, SQLSMALLINT cbAuthStr)
138 : {
139 514 : tdsdump_log(TDS_DBG_FUNC, "SQLConnect(%p, %s, %d, %s, %d, %s, %d)\n",
140 : hdbc,
141 : (const char*) szDSN, (int) cbDSN,
142 : (const char*) szUID, (int) cbUID,
143 : (const char*) szAuthStr, (int) cbAuthStr);
144 : #ifdef ENABLE_ODBC_WIDE
145 514 : return odbc_SQLConnect(hdbc,
146 : (ODBC_CHAR*) szDSN, cbDSN,
147 : (ODBC_CHAR*) szUID, cbUID,
148 : (ODBC_CHAR*) szAuthStr, cbAuthStr, 0);
149 : #else
150 : return odbc_SQLConnect(hdbc,
151 : szDSN, cbDSN,
152 : szUID, cbUID,
153 : szAuthStr, cbAuthStr);
154 : #endif
155 : }
156 :
157 : #ifdef ENABLE_ODBC_WIDE
158 : static SQLRETURN odbc_SQLDescribeCol(SQLHSTMT hstmt,
159 : SQLUSMALLINT icol,
160 : ODBC_CHAR * szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT FAR* pcbColName,
161 : SQLSMALLINT * pfSqlType,
162 : SQLULEN * pcbColDef,
163 : SQLSMALLINT * pibScale,
164 : SQLSMALLINT * pfNullable, int wide);
165 :
166 : SQLRETURN ODBC_PUBLIC ODBC_API SQLDescribeColW(
167 : SQLHSTMT hstmt,
168 : SQLUSMALLINT icol,
169 : SQLWCHAR * szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT FAR* pcbColName,
170 : SQLSMALLINT * pfSqlType,
171 : SQLULEN * pcbColDef,
172 : SQLSMALLINT * pibScale,
173 : SQLSMALLINT * pfNullable)
174 : {
175 1177 : tdsdump_log(TDS_DBG_FUNC, "SQLDescribeColW(%p, %u, %p, %d, %p, %p, %p, %p, %p)\n",
176 : hstmt,
177 : (unsigned int) icol,
178 : szColName, (int) cbColNameMax, pcbColName,
179 : pfSqlType,
180 : pcbColDef,
181 : pibScale,
182 : pfNullable);
183 1177 : return odbc_SQLDescribeCol(hstmt,
184 : icol,
185 : (ODBC_CHAR*) szColName, cbColNameMax, pcbColName,
186 : pfSqlType,
187 : pcbColDef,
188 : pibScale,
189 : pfNullable, 1);
190 : }
191 : #endif
192 :
193 : SQLRETURN ODBC_PUBLIC ODBC_API SQLDescribeCol(
194 : SQLHSTMT hstmt,
195 : SQLUSMALLINT icol,
196 : SQLCHAR * szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT FAR* pcbColName,
197 : SQLSMALLINT * pfSqlType,
198 : SQLULEN * pcbColDef,
199 : SQLSMALLINT * pibScale,
200 : SQLSMALLINT * pfNullable)
201 : {
202 1177 : tdsdump_log(TDS_DBG_FUNC, "SQLDescribeCol(%p, %u, %p, %d, %p, %p, %p, %p, %p)\n",
203 : hstmt,
204 : (unsigned int) icol,
205 : szColName, (int) cbColNameMax, pcbColName,
206 : pfSqlType,
207 : pcbColDef,
208 : pibScale,
209 : pfNullable);
210 : #ifdef ENABLE_ODBC_WIDE
211 1177 : return odbc_SQLDescribeCol(hstmt,
212 : icol,
213 : (ODBC_CHAR*) szColName, cbColNameMax, pcbColName,
214 : pfSqlType,
215 : pcbColDef,
216 : pibScale,
217 : pfNullable, 0);
218 : #else
219 : return odbc_SQLDescribeCol(hstmt,
220 : icol,
221 : szColName, cbColNameMax, pcbColName,
222 : pfSqlType,
223 : pcbColDef,
224 : pibScale,
225 : pfNullable);
226 : #endif
227 : }
228 :
229 : #ifdef ENABLE_ODBC_WIDE
230 : static SQLRETURN odbc_SQLGetDescRec(SQLHDESC hdesc,
231 : SQLSMALLINT RecordNumber,
232 : ODBC_CHAR * szName, SQLSMALLINT cbNameMax, SQLSMALLINT FAR* pcbName,
233 : SQLSMALLINT * Type,
234 : SQLSMALLINT * SubType,
235 : SQLLEN * Length,
236 : SQLSMALLINT * Precision,
237 : SQLSMALLINT * Scale,
238 : SQLSMALLINT * Nullable, int wide);
239 :
240 : SQLRETURN ODBC_PUBLIC ODBC_API SQLGetDescRecW(
241 : SQLHDESC hdesc,
242 : SQLSMALLINT RecordNumber,
243 : SQLWCHAR * szName, SQLSMALLINT cbNameMax, SQLSMALLINT FAR* pcbName,
244 : SQLSMALLINT * Type,
245 : SQLSMALLINT * SubType,
246 : SQLLEN * Length,
247 : SQLSMALLINT * Precision,
248 : SQLSMALLINT * Scale,
249 : SQLSMALLINT * Nullable)
250 : {
251 15 : tdsdump_log(TDS_DBG_FUNC, "SQLGetDescRecW(%p, %d, %p, %d, %p, %p, %p, %p, %p, %p, %p)\n",
252 : hdesc,
253 : (int) RecordNumber,
254 : szName, (int) cbNameMax, pcbName,
255 : Type,
256 : SubType,
257 : Length,
258 : Precision,
259 : Scale,
260 : Nullable);
261 15 : return odbc_SQLGetDescRec(hdesc,
262 : RecordNumber,
263 : (ODBC_CHAR*) szName, cbNameMax, pcbName,
264 : Type,
265 : SubType,
266 : Length,
267 : Precision,
268 : Scale,
269 : Nullable, 1);
270 : }
271 : #endif
272 :
273 : SQLRETURN ODBC_PUBLIC ODBC_API SQLGetDescRec(
274 : SQLHDESC hdesc,
275 : SQLSMALLINT RecordNumber,
276 : SQLCHAR * szName, SQLSMALLINT cbNameMax, SQLSMALLINT FAR* pcbName,
277 : SQLSMALLINT * Type,
278 : SQLSMALLINT * SubType,
279 : SQLLEN * Length,
280 : SQLSMALLINT * Precision,
281 : SQLSMALLINT * Scale,
282 : SQLSMALLINT * Nullable)
283 : {
284 15 : tdsdump_log(TDS_DBG_FUNC, "SQLGetDescRec(%p, %d, %p, %d, %p, %p, %p, %p, %p, %p, %p)\n",
285 : hdesc,
286 : (int) RecordNumber,
287 : szName, (int) cbNameMax, pcbName,
288 : Type,
289 : SubType,
290 : Length,
291 : Precision,
292 : Scale,
293 : Nullable);
294 : #ifdef ENABLE_ODBC_WIDE
295 15 : return odbc_SQLGetDescRec(hdesc,
296 : RecordNumber,
297 : (ODBC_CHAR*) szName, cbNameMax, pcbName,
298 : Type,
299 : SubType,
300 : Length,
301 : Precision,
302 : Scale,
303 : Nullable, 0);
304 : #else
305 : return odbc_SQLGetDescRec(hdesc,
306 : RecordNumber,
307 : szName, cbNameMax, pcbName,
308 : Type,
309 : SubType,
310 : Length,
311 : Precision,
312 : Scale,
313 : Nullable);
314 : #endif
315 : }
316 :
317 : #ifdef ENABLE_ODBC_WIDE
318 : static SQLRETURN odbc_SQLGetDescField(SQLHDESC hdesc,
319 : SQLSMALLINT icol,
320 : SQLSMALLINT fDescType,
321 : SQLPOINTER Value,
322 : SQLINTEGER BufferLength,
323 : SQLINTEGER * StringLength, int wide);
324 :
325 : SQLRETURN ODBC_PUBLIC ODBC_API SQLGetDescFieldW(
326 : SQLHDESC hdesc,
327 : SQLSMALLINT icol,
328 : SQLSMALLINT fDescType,
329 : SQLPOINTER Value,
330 : SQLINTEGER BufferLength,
331 : SQLINTEGER * StringLength)
332 : {
333 1071 : tdsdump_log(TDS_DBG_FUNC, "SQLGetDescFieldW(%p, %d, %d, %p, %d, %p)\n",
334 : hdesc,
335 : (int) icol,
336 : (int) fDescType,
337 : Value,
338 : (int) BufferLength,
339 : StringLength);
340 1071 : return odbc_SQLGetDescField(hdesc,
341 : icol,
342 : fDescType,
343 : Value,
344 : BufferLength,
345 : StringLength, 1);
346 : }
347 : #endif
348 :
349 : SQLRETURN ODBC_PUBLIC ODBC_API SQLGetDescField(
350 : SQLHDESC hdesc,
351 : SQLSMALLINT icol,
352 : SQLSMALLINT fDescType,
353 : SQLPOINTER Value,
354 : SQLINTEGER BufferLength,
355 : SQLINTEGER * StringLength)
356 : {
357 1071 : tdsdump_log(TDS_DBG_FUNC, "SQLGetDescField(%p, %d, %d, %p, %d, %p)\n",
358 : hdesc,
359 : (int) icol,
360 : (int) fDescType,
361 : Value,
362 : (int) BufferLength,
363 : StringLength);
364 : #ifdef ENABLE_ODBC_WIDE
365 1071 : return odbc_SQLGetDescField(hdesc,
366 : icol,
367 : fDescType,
368 : Value,
369 : BufferLength,
370 : StringLength, 0);
371 : #else
372 : return odbc_SQLGetDescField(hdesc,
373 : icol,
374 : fDescType,
375 : Value,
376 : BufferLength,
377 : StringLength);
378 : #endif
379 : }
380 :
381 : #ifdef ENABLE_ODBC_WIDE
382 : static SQLRETURN odbc_SQLSetDescField(SQLHDESC hdesc,
383 : SQLSMALLINT icol,
384 : SQLSMALLINT fDescType,
385 : SQLPOINTER Value,
386 : SQLINTEGER BufferLength, int wide);
387 :
388 : SQLRETURN ODBC_PUBLIC ODBC_API SQLSetDescFieldW(
389 : SQLHDESC hdesc,
390 : SQLSMALLINT icol,
391 : SQLSMALLINT fDescType,
392 : SQLPOINTER Value,
393 : SQLINTEGER BufferLength)
394 : {
395 355 : tdsdump_log(TDS_DBG_FUNC, "SQLSetDescFieldW(%p, %d, %d, %p, %d)\n",
396 : hdesc,
397 : (int) icol,
398 : (int) fDescType,
399 : Value,
400 : (int) BufferLength);
401 355 : return odbc_SQLSetDescField(hdesc,
402 : icol,
403 : fDescType,
404 : Value,
405 : BufferLength, 1);
406 : }
407 : #endif
408 :
409 : SQLRETURN ODBC_PUBLIC ODBC_API SQLSetDescField(
410 : SQLHDESC hdesc,
411 : SQLSMALLINT icol,
412 : SQLSMALLINT fDescType,
413 : SQLPOINTER Value,
414 : SQLINTEGER BufferLength)
415 : {
416 355 : tdsdump_log(TDS_DBG_FUNC, "SQLSetDescField(%p, %d, %d, %p, %d)\n",
417 : hdesc,
418 : (int) icol,
419 : (int) fDescType,
420 : Value,
421 : (int) BufferLength);
422 : #ifdef ENABLE_ODBC_WIDE
423 355 : return odbc_SQLSetDescField(hdesc,
424 : icol,
425 : fDescType,
426 : Value,
427 : BufferLength, 0);
428 : #else
429 : return odbc_SQLSetDescField(hdesc,
430 : icol,
431 : fDescType,
432 : Value,
433 : BufferLength);
434 : #endif
435 : }
436 :
437 : #ifdef ENABLE_ODBC_WIDE
438 : static SQLRETURN odbc_SQLExecDirect(SQLHSTMT hstmt,
439 : ODBC_CHAR * szSqlStr, SQLINTEGER cbSqlStr, int wide);
440 :
441 : SQLRETURN ODBC_PUBLIC ODBC_API SQLExecDirectW(
442 : SQLHSTMT hstmt,
443 : SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStr)
444 : {
445 13850 : if (TDS_UNLIKELY(tds_write_dump)) {
446 0 : SQLWSTR_BUFS(1);
447 0 : tdsdump_log_impl(TDS_DBG_FUNC, "SQLExecDirectW(%p, %ls, %d)\n",
448 : hstmt,
449 : SQLWSTR(szSqlStr), (int) cbSqlStr);
450 0 : SQLWSTR_FREE();
451 : }
452 13850 : return odbc_SQLExecDirect(hstmt,
453 : (ODBC_CHAR*) szSqlStr, cbSqlStr, 1);
454 : }
455 : #endif
456 :
457 : SQLRETURN ODBC_PUBLIC ODBC_API SQLExecDirect(
458 : SQLHSTMT hstmt,
459 : SQLCHAR * szSqlStr, SQLINTEGER cbSqlStr)
460 : {
461 14165 : tdsdump_log(TDS_DBG_FUNC, "SQLExecDirect(%p, %s, %d)\n",
462 : hstmt,
463 : (const char*) szSqlStr, (int) cbSqlStr);
464 : #ifdef ENABLE_ODBC_WIDE
465 14165 : return odbc_SQLExecDirect(hstmt,
466 : (ODBC_CHAR*) szSqlStr, cbSqlStr, 0);
467 : #else
468 : return odbc_SQLExecDirect(hstmt,
469 : szSqlStr, cbSqlStr);
470 : #endif
471 : }
472 :
473 : #ifdef ENABLE_ODBC_WIDE
474 : static SQLRETURN odbc_SQLPrepare(SQLHSTMT hstmt,
475 : ODBC_CHAR * szSqlStr, SQLINTEGER cbSqlStr, int wide);
476 :
477 : SQLRETURN ODBC_PUBLIC ODBC_API SQLPrepareW(
478 : SQLHSTMT hstmt,
479 : SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStr)
480 : {
481 2074 : if (TDS_UNLIKELY(tds_write_dump)) {
482 0 : SQLWSTR_BUFS(1);
483 0 : tdsdump_log_impl(TDS_DBG_FUNC, "SQLPrepareW(%p, %ls, %d)\n",
484 : hstmt,
485 : SQLWSTR(szSqlStr), (int) cbSqlStr);
486 0 : SQLWSTR_FREE();
487 : }
488 2074 : return odbc_SQLPrepare(hstmt,
489 : (ODBC_CHAR*) szSqlStr, cbSqlStr, 1);
490 : }
491 : #endif
492 :
493 : SQLRETURN ODBC_PUBLIC ODBC_API SQLPrepare(
494 : SQLHSTMT hstmt,
495 : SQLCHAR * szSqlStr, SQLINTEGER cbSqlStr)
496 : {
497 2093 : tdsdump_log(TDS_DBG_FUNC, "SQLPrepare(%p, %s, %d)\n",
498 : hstmt,
499 : (const char*) szSqlStr, (int) cbSqlStr);
500 : #ifdef ENABLE_ODBC_WIDE
501 2093 : return odbc_SQLPrepare(hstmt,
502 : (ODBC_CHAR*) szSqlStr, cbSqlStr, 0);
503 : #else
504 : return odbc_SQLPrepare(hstmt,
505 : szSqlStr, cbSqlStr);
506 : #endif
507 : }
508 :
509 : #ifdef ENABLE_ODBC_WIDE
510 : static SQLRETURN odbc_SQLSetCursorName(SQLHSTMT hstmt,
511 : ODBC_CHAR * szCursor, SQLSMALLINT cbCursor, int wide);
512 :
513 : SQLRETURN ODBC_PUBLIC ODBC_API SQLSetCursorNameW(
514 : SQLHSTMT hstmt,
515 : SQLWCHAR * szCursor, SQLSMALLINT cbCursor)
516 : {
517 52 : if (TDS_UNLIKELY(tds_write_dump)) {
518 0 : SQLWSTR_BUFS(1);
519 0 : tdsdump_log_impl(TDS_DBG_FUNC, "SQLSetCursorNameW(%p, %ls, %d)\n",
520 : hstmt,
521 : SQLWSTR(szCursor), (int) cbCursor);
522 0 : SQLWSTR_FREE();
523 : }
524 52 : return odbc_SQLSetCursorName(hstmt,
525 : (ODBC_CHAR*) szCursor, cbCursor, 1);
526 : }
527 : #endif
528 :
529 : SQLRETURN ODBC_PUBLIC ODBC_API SQLSetCursorName(
530 : SQLHSTMT hstmt,
531 : SQLCHAR * szCursor, SQLSMALLINT cbCursor)
532 : {
533 52 : tdsdump_log(TDS_DBG_FUNC, "SQLSetCursorName(%p, %s, %d)\n",
534 : hstmt,
535 : (const char*) szCursor, (int) cbCursor);
536 : #ifdef ENABLE_ODBC_WIDE
537 52 : return odbc_SQLSetCursorName(hstmt,
538 : (ODBC_CHAR*) szCursor, cbCursor, 0);
539 : #else
540 : return odbc_SQLSetCursorName(hstmt,
541 : szCursor, cbCursor);
542 : #endif
543 : }
544 :
545 : #ifdef ENABLE_ODBC_WIDE
546 : static SQLRETURN odbc_SQLGetCursorName(SQLHSTMT hstmt,
547 : ODBC_CHAR * szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT FAR* pcbCursor, int wide);
548 :
549 : SQLRETURN ODBC_PUBLIC ODBC_API SQLGetCursorNameW(
550 : SQLHSTMT hstmt,
551 : SQLWCHAR * szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT FAR* pcbCursor)
552 : {
553 0 : tdsdump_log(TDS_DBG_FUNC, "SQLGetCursorNameW(%p, %p, %d, %p)\n",
554 : hstmt,
555 : szCursor, (int) cbCursorMax, pcbCursor);
556 0 : return odbc_SQLGetCursorName(hstmt,
557 : (ODBC_CHAR*) szCursor, cbCursorMax, pcbCursor, 1);
558 : }
559 : #endif
560 :
561 : SQLRETURN ODBC_PUBLIC ODBC_API SQLGetCursorName(
562 : SQLHSTMT hstmt,
563 : SQLCHAR * szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT FAR* pcbCursor)
564 : {
565 0 : tdsdump_log(TDS_DBG_FUNC, "SQLGetCursorName(%p, %p, %d, %p)\n",
566 : hstmt,
567 : szCursor, (int) cbCursorMax, pcbCursor);
568 : #ifdef ENABLE_ODBC_WIDE
569 0 : return odbc_SQLGetCursorName(hstmt,
570 : (ODBC_CHAR*) szCursor, cbCursorMax, pcbCursor, 0);
571 : #else
572 : return odbc_SQLGetCursorName(hstmt,
573 : szCursor, cbCursorMax, pcbCursor);
574 : #endif
575 : }
576 :
577 : #ifdef ENABLE_ODBC_WIDE
578 : static SQLRETURN odbc_SQLGetConnectAttr(SQLHDBC hdbc,
579 : SQLINTEGER Attribute,
580 : SQLPOINTER Value,
581 : SQLINTEGER BufferLength,
582 : SQLINTEGER * StringLength, int wide);
583 :
584 : SQLRETURN ODBC_PUBLIC ODBC_API SQLGetConnectAttrW(
585 : SQLHDBC hdbc,
586 : SQLINTEGER Attribute,
587 : SQLPOINTER Value,
588 : SQLINTEGER BufferLength,
589 : SQLINTEGER * StringLength)
590 : {
591 39 : tdsdump_log(TDS_DBG_FUNC, "SQLGetConnectAttrW(%p, %d, %p, %d, %p)\n",
592 : hdbc,
593 : (int) Attribute,
594 : Value,
595 : (int) BufferLength,
596 : StringLength);
597 39 : return odbc_SQLGetConnectAttr(hdbc,
598 : Attribute,
599 : Value,
600 : BufferLength,
601 : StringLength, 1);
602 : }
603 : #endif
604 :
605 : SQLRETURN ODBC_PUBLIC ODBC_API SQLGetConnectAttr(
606 : SQLHDBC hdbc,
607 : SQLINTEGER Attribute,
608 : SQLPOINTER Value,
609 : SQLINTEGER BufferLength,
610 : SQLINTEGER * StringLength)
611 : {
612 39 : tdsdump_log(TDS_DBG_FUNC, "SQLGetConnectAttr(%p, %d, %p, %d, %p)\n",
613 : hdbc,
614 : (int) Attribute,
615 : Value,
616 : (int) BufferLength,
617 : StringLength);
618 : #ifdef ENABLE_ODBC_WIDE
619 39 : return odbc_SQLGetConnectAttr(hdbc,
620 : Attribute,
621 : Value,
622 : BufferLength,
623 : StringLength, 0);
624 : #else
625 : return odbc_SQLGetConnectAttr(hdbc,
626 : Attribute,
627 : Value,
628 : BufferLength,
629 : StringLength);
630 : #endif
631 : }
632 :
633 : #ifdef ENABLE_ODBC_WIDE
634 : static SQLRETURN odbc_SQLSetConnectAttr(SQLHDBC hdbc,
635 : SQLINTEGER Attribute,
636 : SQLPOINTER ValuePtr,
637 : SQLINTEGER StringLength, int wide);
638 :
639 : SQLRETURN ODBC_PUBLIC ODBC_API SQLSetConnectAttrW(
640 : SQLHDBC hdbc,
641 : SQLINTEGER Attribute,
642 : SQLPOINTER ValuePtr,
643 : SQLINTEGER StringLength)
644 : {
645 678 : tdsdump_log(TDS_DBG_FUNC, "SQLSetConnectAttrW(%p, %d, %p, %d)\n",
646 : hdbc,
647 : (int) Attribute,
648 : ValuePtr,
649 : (int) StringLength);
650 678 : return odbc_SQLSetConnectAttr(hdbc,
651 : Attribute,
652 : ValuePtr,
653 : StringLength, 1);
654 : }
655 : #endif
656 :
657 : SQLRETURN ODBC_PUBLIC ODBC_API SQLSetConnectAttr(
658 : SQLHDBC hdbc,
659 : SQLINTEGER Attribute,
660 : SQLPOINTER ValuePtr,
661 : SQLINTEGER StringLength)
662 : {
663 1228 : tdsdump_log(TDS_DBG_FUNC, "SQLSetConnectAttr(%p, %d, %p, %d)\n",
664 : hdbc,
665 : (int) Attribute,
666 : ValuePtr,
667 : (int) StringLength);
668 : #ifdef ENABLE_ODBC_WIDE
669 1228 : return odbc_SQLSetConnectAttr(hdbc,
670 : Attribute,
671 : ValuePtr,
672 : StringLength, 0);
673 : #else
674 : return odbc_SQLSetConnectAttr(hdbc,
675 : Attribute,
676 : ValuePtr,
677 : StringLength);
678 : #endif
679 : }
680 :
|
