1 //
2 // Unicode.cpp
3 //
4 // Library: Data/ODBC
5 // Package: ODBC
6 // Module: Unicode
7 //
8 // Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
9 // and Contributors.
10 //
11 // SPDX-License-Identifier: BSL-1.0
12 //
13
14
15 #include "Poco/Data/ODBC/ODBC.h"
16 #include "Poco/Data/ODBC/Unicode_UNIXODBC.h"
17 #include "Poco/TextConverter.h"
18 #include "Poco/UTF8Encoding.h"
19 #include "Poco/UTF16Encoding.h"
20 #include "Poco/Buffer.h"
21 #include "Poco/Exception.h"
22 #include <iostream>
23
24
25 using Poco::Buffer;
26 using Poco::UTF8Encoding;
27 using Poco::UTF16Encoding;
28 using Poco::TextConverter;
29 using Poco::InvalidArgumentException;
30 using Poco::NotImplementedException;
31
32
33 namespace Poco {
34 namespace Data {
35 namespace ODBC {
36
37
makeUTF16(SQLCHAR * pSQLChar,SQLINTEGER length,std::string & target)38 void makeUTF16(SQLCHAR* pSQLChar, SQLINTEGER length, std::string& target)
39 {
40 int len = length;
41 if (SQL_NTS == len)
42 len = (int) std::strlen((const char *) pSQLChar);
43
44 UTF8Encoding utf8Encoding;
45 UTF16Encoding utf16Encoding;
46 TextConverter converter(utf8Encoding, utf16Encoding);
47
48 if (0 != converter.convert(pSQLChar, len, target))
49 throw DataFormatException("Error converting UTF-8 to UTF-16");
50 }
51
52
makeUTF8(Poco::Buffer<SQLWCHAR> & buffer,SQLINTEGER length,SQLPOINTER pTarget,SQLINTEGER targetLength)53 void makeUTF8(Poco::Buffer<SQLWCHAR>& buffer, SQLINTEGER length, SQLPOINTER pTarget, SQLINTEGER targetLength)
54 {
55 UTF8Encoding utf8Encoding;
56 UTF16Encoding utf16Encoding;
57 TextConverter converter(utf16Encoding, utf8Encoding);
58
59 std::string result;
60 if (0 != converter.convert(buffer.begin(), length, result))
61 throw DataFormatException("Error converting UTF-16 to UTF-8");
62
63 std::memset(pTarget, 0, targetLength);
64 std::strncpy((char*) pTarget, result.c_str(), result.size() < targetLength ? result.size() : targetLength);
65 }
66
67
SQLColAttribute(SQLHSTMT hstmt,SQLUSMALLINT iCol,SQLUSMALLINT iField,SQLPOINTER pCharAttr,SQLSMALLINT cbCharAttrMax,SQLSMALLINT * pcbCharAttr,NumAttrPtrType pNumAttr)68 SQLRETURN SQLColAttribute(SQLHSTMT hstmt,
69 SQLUSMALLINT iCol,
70 SQLUSMALLINT iField,
71 SQLPOINTER pCharAttr,
72 SQLSMALLINT cbCharAttrMax,
73 SQLSMALLINT* pcbCharAttr,
74 NumAttrPtrType pNumAttr)
75 {
76 if (isString(pCharAttr, cbCharAttrMax))
77 {
78 Buffer<SQLWCHAR> buffer(stringLength(pCharAttr, cbCharAttrMax));
79
80 SQLRETURN rc = SQLColAttributeW(hstmt,
81 iCol,
82 iField,
83 buffer.begin(),
84 (SQLSMALLINT) buffer.sizeBytes(),
85 pcbCharAttr,
86 pNumAttr);
87
88 makeUTF8(buffer, *pcbCharAttr, pCharAttr, cbCharAttrMax);
89 return rc;
90 }
91
92 return SQLColAttributeW(hstmt,
93 iCol,
94 iField,
95 pCharAttr,
96 cbCharAttrMax,
97 pcbCharAttr,
98 pNumAttr);
99 }
100
101
SQLColAttributes(SQLHSTMT hstmt,SQLUSMALLINT icol,SQLUSMALLINT fDescType,SQLPOINTER rgbDesc,SQLSMALLINT cbDescMax,SQLSMALLINT * pcbDesc,SQLLEN * pfDesc)102 SQLRETURN SQLColAttributes(SQLHSTMT hstmt,
103 SQLUSMALLINT icol,
104 SQLUSMALLINT fDescType,
105 SQLPOINTER rgbDesc,
106 SQLSMALLINT cbDescMax,
107 SQLSMALLINT* pcbDesc,
108 SQLLEN* pfDesc)
109 {
110 return SQLColAttribute(hstmt,
111 icol,
112 fDescType,
113 rgbDesc,
114 cbDescMax,
115 pcbDesc,
116 pfDesc);
117 }
118
119
SQLConnect(SQLHDBC hdbc,SQLCHAR * szDSN,SQLSMALLINT cbDSN,SQLCHAR * szUID,SQLSMALLINT cbUID,SQLCHAR * szAuthStr,SQLSMALLINT cbAuthStr)120 SQLRETURN SQLConnect(SQLHDBC hdbc,
121 SQLCHAR* szDSN,
122 SQLSMALLINT cbDSN,
123 SQLCHAR* szUID,
124 SQLSMALLINT cbUID,
125 SQLCHAR* szAuthStr,
126 SQLSMALLINT cbAuthStr)
127 {
128 std::string sqlDSN;
129 makeUTF16(szDSN, cbDSN, sqlDSN);
130
131 std::string sqlUID;
132 makeUTF16(szUID, cbUID, sqlUID);
133
134 std::string sqlPWD;
135 makeUTF16(szAuthStr, cbAuthStr, sqlPWD);
136
137 return SQLConnectW(hdbc,
138 (SQLWCHAR*) sqlDSN.c_str(), cbDSN,
139 (SQLWCHAR*) sqlUID.c_str(), cbUID,
140 (SQLWCHAR*) sqlPWD.c_str(), cbAuthStr);
141 }
142
143
SQLDescribeCol(SQLHSTMT hstmt,SQLUSMALLINT icol,SQLCHAR * szColName,SQLSMALLINT cbColNameMax,SQLSMALLINT * pcbColName,SQLSMALLINT * pfSqlType,SQLULEN * pcbColDef,SQLSMALLINT * pibScale,SQLSMALLINT * pfNullable)144 SQLRETURN SQLDescribeCol(SQLHSTMT hstmt,
145 SQLUSMALLINT icol,
146 SQLCHAR* szColName,
147 SQLSMALLINT cbColNameMax,
148 SQLSMALLINT* pcbColName,
149 SQLSMALLINT* pfSqlType,
150 SQLULEN* pcbColDef,
151 SQLSMALLINT* pibScale,
152 SQLSMALLINT* pfNullable)
153 {
154 Buffer<SQLWCHAR> buffer(cbColNameMax);
155 SQLRETURN rc = SQLDescribeColW(hstmt,
156 icol,
157 (SQLWCHAR*) buffer.begin(),
158 (SQLSMALLINT) buffer.size(),
159 pcbColName,
160 pfSqlType,
161 pcbColDef,
162 pibScale,
163 pfNullable);
164
165 makeUTF8(buffer, *pcbColName * sizeof(SQLWCHAR), szColName, cbColNameMax);
166 return rc;
167 }
168
169
SQLError(SQLHENV henv,SQLHDBC hdbc,SQLHSTMT hstmt,SQLCHAR * szSqlState,SQLINTEGER * pfNativeError,SQLCHAR * szErrorMsg,SQLSMALLINT cbErrorMsgMax,SQLSMALLINT * pcbErrorMsg)170 SQLRETURN SQLError(SQLHENV henv,
171 SQLHDBC hdbc,
172 SQLHSTMT hstmt,
173 SQLCHAR* szSqlState,
174 SQLINTEGER* pfNativeError,
175 SQLCHAR* szErrorMsg,
176 SQLSMALLINT cbErrorMsgMax,
177 SQLSMALLINT* pcbErrorMsg)
178 {
179 throw NotImplementedException("SQLError is obsolete. "
180 "Use SQLGetDiagRec instead.");
181 }
182
183
SQLExecDirect(SQLHSTMT hstmt,SQLCHAR * szSqlStr,SQLINTEGER cbSqlStr)184 SQLRETURN SQLExecDirect(SQLHSTMT hstmt,
185 SQLCHAR* szSqlStr,
186 SQLINTEGER cbSqlStr)
187 {
188 std::string sqlStr;
189 makeUTF16(szSqlStr, cbSqlStr, sqlStr);
190
191 return SQLExecDirectW(hstmt, (SQLWCHAR*) sqlStr.c_str(), cbSqlStr);
192 }
193
194
SQLGetConnectAttr(SQLHDBC hdbc,SQLINTEGER fAttribute,SQLPOINTER rgbValue,SQLINTEGER cbValueMax,SQLINTEGER * pcbValue)195 SQLRETURN SQLGetConnectAttr(SQLHDBC hdbc,
196 SQLINTEGER fAttribute,
197 SQLPOINTER rgbValue,
198 SQLINTEGER cbValueMax,
199 SQLINTEGER* pcbValue)
200 {
201 if (isString(rgbValue, cbValueMax))
202 {
203 Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
204
205 SQLRETURN rc = SQLGetConnectAttrW(hdbc,
206 fAttribute,
207 buffer.begin(),
208 (SQLINTEGER) buffer.sizeBytes(),
209 pcbValue);
210
211 makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
212 return rc;
213 }
214
215
216 return SQLGetConnectAttrW(hdbc,
217 fAttribute,
218 rgbValue,
219 cbValueMax,
220 pcbValue);
221 }
222
223
SQLGetCursorName(SQLHSTMT hstmt,SQLCHAR * szCursor,SQLSMALLINT cbCursorMax,SQLSMALLINT * pcbCursor)224 SQLRETURN SQLGetCursorName(SQLHSTMT hstmt,
225 SQLCHAR* szCursor,
226 SQLSMALLINT cbCursorMax,
227 SQLSMALLINT* pcbCursor)
228 {
229 throw NotImplementedException("Not implemented");
230 }
231
232
SQLSetDescField(SQLHDESC hdesc,SQLSMALLINT iRecord,SQLSMALLINT iField,SQLPOINTER rgbValue,SQLINTEGER cbValueMax)233 SQLRETURN SQLSetDescField(SQLHDESC hdesc,
234 SQLSMALLINT iRecord,
235 SQLSMALLINT iField,
236 SQLPOINTER rgbValue,
237 SQLINTEGER cbValueMax)
238 {
239 if (isString(rgbValue, cbValueMax))
240 {
241 std::string str;
242 makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
243
244 return SQLSetDescFieldW(hdesc,
245 iRecord,
246 iField,
247 (SQLPOINTER) str.c_str(),
248 (SQLINTEGER) str.size() * sizeof(SQLWCHAR));
249 }
250
251 return SQLSetDescFieldW(hdesc,
252 iRecord,
253 iField,
254 rgbValue,
255 cbValueMax);
256 }
257
258
SQLGetDescField(SQLHDESC hdesc,SQLSMALLINT iRecord,SQLSMALLINT iField,SQLPOINTER rgbValue,SQLINTEGER cbValueMax,SQLINTEGER * pcbValue)259 SQLRETURN SQLGetDescField(SQLHDESC hdesc,
260 SQLSMALLINT iRecord,
261 SQLSMALLINT iField,
262 SQLPOINTER rgbValue,
263 SQLINTEGER cbValueMax,
264 SQLINTEGER* pcbValue)
265 {
266 if (isString(rgbValue, cbValueMax))
267 {
268 Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
269
270 SQLRETURN rc = SQLGetDescFieldW(hdesc,
271 iRecord,
272 iField,
273 buffer.begin(),
274 (SQLINTEGER) buffer.sizeBytes(),
275 pcbValue);
276
277 makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
278
279 return rc;
280 }
281
282 return SQLGetDescFieldW(hdesc,
283 iRecord,
284 iField,
285 rgbValue,
286 cbValueMax,
287 pcbValue);
288 }
289
290
SQLGetDescRec(SQLHDESC hdesc,SQLSMALLINT iRecord,SQLCHAR * szName,SQLSMALLINT cbNameMax,SQLSMALLINT * pcbName,SQLSMALLINT * pfType,SQLSMALLINT * pfSubType,SQLLEN * pLength,SQLSMALLINT * pPrecision,SQLSMALLINT * pScale,SQLSMALLINT * pNullable)291 SQLRETURN SQLGetDescRec(SQLHDESC hdesc,
292 SQLSMALLINT iRecord,
293 SQLCHAR* szName,
294 SQLSMALLINT cbNameMax,
295 SQLSMALLINT* pcbName,
296 SQLSMALLINT* pfType,
297 SQLSMALLINT* pfSubType,
298 SQLLEN* pLength,
299 SQLSMALLINT* pPrecision,
300 SQLSMALLINT* pScale,
301 SQLSMALLINT* pNullable)
302 {
303 throw NotImplementedException();
304 }
305
306
SQLGetDiagField(SQLSMALLINT fHandleType,SQLHANDLE handle,SQLSMALLINT iRecord,SQLSMALLINT fDiagField,SQLPOINTER rgbDiagInfo,SQLSMALLINT cbDiagInfoMax,SQLSMALLINT * pcbDiagInfo)307 SQLRETURN SQLGetDiagField(SQLSMALLINT fHandleType,
308 SQLHANDLE handle,
309 SQLSMALLINT iRecord,
310 SQLSMALLINT fDiagField,
311 SQLPOINTER rgbDiagInfo,
312 SQLSMALLINT cbDiagInfoMax,
313 SQLSMALLINT* pcbDiagInfo)
314 {
315 if (isString(rgbDiagInfo, cbDiagInfoMax))
316 {
317 Buffer<SQLWCHAR> buffer(stringLength(rgbDiagInfo, cbDiagInfoMax));
318
319 SQLRETURN rc = SQLGetDiagFieldW(fHandleType,
320 handle,
321 iRecord,
322 fDiagField,
323 buffer.begin(),
324 (SQLSMALLINT) buffer.sizeBytes(),
325 pcbDiagInfo);
326
327 makeUTF8(buffer, *pcbDiagInfo, rgbDiagInfo, cbDiagInfoMax);
328
329 return rc;
330 }
331
332 return SQLGetDiagFieldW(fHandleType,
333 handle,
334 iRecord,
335 fDiagField,
336 rgbDiagInfo,
337 cbDiagInfoMax,
338 pcbDiagInfo);
339 }
340
341
SQLGetDiagRec(SQLSMALLINT fHandleType,SQLHANDLE handle,SQLSMALLINT iRecord,SQLCHAR * szSqlState,SQLINTEGER * pfNativeError,SQLCHAR * szErrorMsg,SQLSMALLINT cbErrorMsgMax,SQLSMALLINT * pcbErrorMsg)342 SQLRETURN SQLGetDiagRec(SQLSMALLINT fHandleType,
343 SQLHANDLE handle,
344 SQLSMALLINT iRecord,
345 SQLCHAR* szSqlState,
346 SQLINTEGER* pfNativeError,
347 SQLCHAR* szErrorMsg,
348 SQLSMALLINT cbErrorMsgMax,
349 SQLSMALLINT* pcbErrorMsg)
350 {
351 const SQLINTEGER stateLen = SQL_SQLSTATE_SIZE + 1;
352 Buffer<SQLWCHAR> bufState(stateLen);
353 Buffer<SQLWCHAR> bufErr(cbErrorMsgMax);
354
355 SQLRETURN rc = SQLGetDiagRecW(fHandleType,
356 handle,
357 iRecord,
358 bufState.begin(),
359 pfNativeError,
360 bufErr.begin(),
361 (SQLSMALLINT) bufErr.size(),
362 pcbErrorMsg);
363
364 makeUTF8(bufState, stateLen * sizeof(SQLWCHAR), szSqlState, stateLen);
365 makeUTF8(bufErr, *pcbErrorMsg * sizeof(SQLWCHAR), szErrorMsg, cbErrorMsgMax);
366
367 return rc;
368 }
369
370
SQLPrepare(SQLHSTMT hstmt,SQLCHAR * szSqlStr,SQLINTEGER cbSqlStr)371 SQLRETURN SQLPrepare(SQLHSTMT hstmt,
372 SQLCHAR* szSqlStr,
373 SQLINTEGER cbSqlStr)
374 {
375 std::string sqlStr;
376 makeUTF16(szSqlStr, cbSqlStr, sqlStr);
377
378 return SQLPrepareW(hstmt, (SQLWCHAR*) sqlStr.c_str(), (SQLINTEGER) sqlStr.size());
379 }
380
381
SQLSetConnectAttr(SQLHDBC hdbc,SQLINTEGER fAttribute,SQLPOINTER rgbValue,SQLINTEGER cbValue)382 SQLRETURN SQLSetConnectAttr(SQLHDBC hdbc,
383 SQLINTEGER fAttribute,
384 SQLPOINTER rgbValue,
385 SQLINTEGER cbValue)
386 {
387 if (isString(rgbValue, cbValue))
388 {
389 std::string str;
390 makeUTF16((SQLCHAR*) rgbValue, cbValue, str);
391
392 return SQLSetConnectAttrW(hdbc,
393 fAttribute,
394 (SQLWCHAR*) str.c_str(),
395 (SQLINTEGER) str.size() * sizeof(SQLWCHAR));
396 }
397
398 return SQLSetConnectAttrW(hdbc, fAttribute, rgbValue, cbValue);
399 }
400
401
SQLSetCursorName(SQLHSTMT hstmt,SQLCHAR * szCursor,SQLSMALLINT cbCursor)402 SQLRETURN SQLSetCursorName(SQLHSTMT hstmt,
403 SQLCHAR* szCursor,
404 SQLSMALLINT cbCursor)
405 {
406 throw NotImplementedException("Not implemented");
407 }
408
409
SQLSetStmtAttr(SQLHSTMT hstmt,SQLINTEGER fAttribute,SQLPOINTER rgbValue,SQLINTEGER cbValueMax)410 SQLRETURN SQLSetStmtAttr(SQLHSTMT hstmt,
411 SQLINTEGER fAttribute,
412 SQLPOINTER rgbValue,
413 SQLINTEGER cbValueMax)
414 {
415 if (isString(rgbValue, cbValueMax))
416 {
417 std::string str;
418 makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
419
420 return SQLSetStmtAttrW(hstmt,
421 fAttribute,
422 (SQLWCHAR*) str.c_str(),
423 (SQLINTEGER) str.size());
424 }
425
426 return SQLSetStmtAttrW(hstmt, fAttribute, rgbValue, cbValueMax);
427 }
428
429
SQLGetStmtAttr(SQLHSTMT hstmt,SQLINTEGER fAttribute,SQLPOINTER rgbValue,SQLINTEGER cbValueMax,SQLINTEGER * pcbValue)430 SQLRETURN SQLGetStmtAttr(SQLHSTMT hstmt,
431 SQLINTEGER fAttribute,
432 SQLPOINTER rgbValue,
433 SQLINTEGER cbValueMax,
434 SQLINTEGER* pcbValue)
435 {
436 if (isString(rgbValue, cbValueMax))
437 {
438 Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
439
440 return SQLGetStmtAttrW(hstmt,
441 fAttribute,
442 (SQLPOINTER) buffer.begin(),
443 (SQLINTEGER) buffer.sizeBytes(),
444 pcbValue);
445 }
446
447 return SQLGetStmtAttrW(hstmt, fAttribute, rgbValue, cbValueMax, pcbValue);
448 }
449
450
SQLColumns(SQLHSTMT hstmt,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szTableName,SQLSMALLINT cbTableName,SQLCHAR * szColumnName,SQLSMALLINT cbColumnName)451 SQLRETURN SQLColumns(SQLHSTMT hstmt,
452 SQLCHAR* szCatalogName,
453 SQLSMALLINT cbCatalogName,
454 SQLCHAR* szSchemaName,
455 SQLSMALLINT cbSchemaName,
456 SQLCHAR* szTableName,
457 SQLSMALLINT cbTableName,
458 SQLCHAR* szColumnName,
459 SQLSMALLINT cbColumnName)
460 {
461 throw NotImplementedException();
462 }
463
464
SQLGetConnectOption(SQLHDBC hdbc,SQLUSMALLINT fOption,SQLPOINTER pvParam)465 SQLRETURN SQLGetConnectOption(SQLHDBC hdbc,
466 SQLUSMALLINT fOption,
467 SQLPOINTER pvParam)
468 {
469 throw NotImplementedException();
470 }
471
472
SQLGetInfo(SQLHDBC hdbc,SQLUSMALLINT fInfoType,SQLPOINTER rgbInfoValue,SQLSMALLINT cbInfoValueMax,SQLSMALLINT * pcbInfoValue)473 SQLRETURN SQLGetInfo(SQLHDBC hdbc,
474 SQLUSMALLINT fInfoType,
475 SQLPOINTER rgbInfoValue,
476 SQLSMALLINT cbInfoValueMax,
477 SQLSMALLINT* pcbInfoValue)
478 {
479 if (cbInfoValueMax)
480 {
481 Buffer<SQLWCHAR> buffer(cbInfoValueMax);
482
483 SQLRETURN rc = SQLGetInfoW(hdbc,
484 fInfoType,
485 (SQLPOINTER) buffer.begin(),
486 (SQLSMALLINT) buffer.sizeBytes(),
487 pcbInfoValue);
488
489 makeUTF8(buffer, *pcbInfoValue, rgbInfoValue, cbInfoValueMax);
490
491 return rc;
492 }
493
494 return SQLGetInfoW(hdbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
495 }
496
497
SQLGetTypeInfo(SQLHSTMT StatementHandle,SQLSMALLINT DataType)498 SQLRETURN SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
499 {
500 return SQLGetTypeInfoW(StatementHandle, DataType);
501 }
502
503
SQLSetConnectOption(SQLHDBC hdbc,SQLUSMALLINT fOption,SQLULEN vParam)504 SQLRETURN SQLSetConnectOption(SQLHDBC hdbc,
505 SQLUSMALLINT fOption,
506 SQLULEN vParam)
507 {
508 throw NotImplementedException();
509 }
510
511
SQLSpecialColumns(SQLHSTMT hstmt,SQLUSMALLINT fColType,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szTableName,SQLSMALLINT cbTableName,SQLUSMALLINT fScope,SQLUSMALLINT fNullable)512 SQLRETURN SQLSpecialColumns(SQLHSTMT hstmt,
513 SQLUSMALLINT fColType,
514 SQLCHAR* szCatalogName,
515 SQLSMALLINT cbCatalogName,
516 SQLCHAR* szSchemaName,
517 SQLSMALLINT cbSchemaName,
518 SQLCHAR* szTableName,
519 SQLSMALLINT cbTableName,
520 SQLUSMALLINT fScope,
521 SQLUSMALLINT fNullable)
522 {
523 throw NotImplementedException();
524 }
525
526
SQLStatistics(SQLHSTMT hstmt,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szTableName,SQLSMALLINT cbTableName,SQLUSMALLINT fUnique,SQLUSMALLINT fAccuracy)527 SQLRETURN SQLStatistics(SQLHSTMT hstmt,
528 SQLCHAR* szCatalogName,
529 SQLSMALLINT cbCatalogName,
530 SQLCHAR* szSchemaName,
531 SQLSMALLINT cbSchemaName,
532 SQLCHAR* szTableName,
533 SQLSMALLINT cbTableName,
534 SQLUSMALLINT fUnique,
535 SQLUSMALLINT fAccuracy)
536 {
537 throw NotImplementedException();
538 }
539
540
SQLTables(SQLHSTMT hstmt,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szTableName,SQLSMALLINT cbTableName,SQLCHAR * szTableType,SQLSMALLINT cbTableType)541 SQLRETURN SQLTables(SQLHSTMT hstmt,
542 SQLCHAR* szCatalogName,
543 SQLSMALLINT cbCatalogName,
544 SQLCHAR* szSchemaName,
545 SQLSMALLINT cbSchemaName,
546 SQLCHAR* szTableName,
547 SQLSMALLINT cbTableName,
548 SQLCHAR* szTableType,
549 SQLSMALLINT cbTableType)
550 {
551 throw NotImplementedException();
552 }
553
554
SQLDataSources(SQLHENV henv,SQLUSMALLINT fDirection,SQLCHAR * szDSN,SQLSMALLINT cbDSNMax,SQLSMALLINT * pcbDSN,SQLCHAR * szDesc,SQLSMALLINT cbDescMax,SQLSMALLINT * pcbDesc)555 SQLRETURN SQLDataSources(SQLHENV henv,
556 SQLUSMALLINT fDirection,
557 SQLCHAR* szDSN,
558 SQLSMALLINT cbDSNMax,
559 SQLSMALLINT* pcbDSN,
560 SQLCHAR* szDesc,
561 SQLSMALLINT cbDescMax,
562 SQLSMALLINT* pcbDesc)
563 {
564 Buffer<SQLWCHAR> bufDSN(cbDSNMax);
565 Buffer<SQLWCHAR> bufDesc(cbDescMax);
566
567 SQLRETURN rc = SQLDataSourcesW(henv,
568 fDirection,
569 bufDSN.begin(),
570 (SQLSMALLINT) bufDSN.size(),
571 pcbDSN,
572 bufDesc.begin(),
573 (SQLSMALLINT) bufDesc.size(),
574 pcbDesc);
575
576 makeUTF8(bufDSN, *pcbDSN * sizeof(SQLWCHAR), szDSN, cbDSNMax);
577 makeUTF8(bufDesc, *pcbDesc * sizeof(SQLWCHAR), szDesc, cbDescMax);
578
579 return rc;
580 }
581
582
SQLDriverConnect(SQLHDBC hdbc,SQLHWND hwnd,SQLCHAR * szConnStrIn,SQLSMALLINT cbConnStrIn,SQLCHAR * szConnStrOut,SQLSMALLINT cbConnStrOutMax,SQLSMALLINT * pcbConnStrOut,SQLUSMALLINT fDriverCompletion)583 SQLRETURN SQLDriverConnect(SQLHDBC hdbc,
584 SQLHWND hwnd,
585 SQLCHAR* szConnStrIn,
586 SQLSMALLINT cbConnStrIn,
587 SQLCHAR* szConnStrOut,
588 SQLSMALLINT cbConnStrOutMax,
589 SQLSMALLINT* pcbConnStrOut,
590 SQLUSMALLINT fDriverCompletion)
591 {
592 SQLSMALLINT len = cbConnStrIn;
593 if (SQL_NTS == len)
594 len = (SQLSMALLINT) std::strlen((const char*) szConnStrIn) + 1;
595
596 std::string connStrIn;
597 makeUTF16(szConnStrIn, len, connStrIn);
598
599 Buffer<SQLWCHAR> out(cbConnStrOutMax);
600 SQLRETURN rc = SQLDriverConnectW(hdbc,
601 hwnd,
602 (SQLWCHAR*) connStrIn.c_str(),
603 (SQLSMALLINT) connStrIn.size(),
604 out.begin(),
605 cbConnStrOutMax,
606 pcbConnStrOut,
607 fDriverCompletion);
608
609 makeUTF8(out, *pcbConnStrOut * sizeof(SQLWCHAR), pcbConnStrOut, cbConnStrOutMax);
610
611 return rc;
612 }
613
614
SQLBrowseConnect(SQLHDBC hdbc,SQLCHAR * szConnStrIn,SQLSMALLINT cbConnStrIn,SQLCHAR * szConnStrOut,SQLSMALLINT cbConnStrOutMax,SQLSMALLINT * pcbConnStrOut)615 SQLRETURN SQLBrowseConnect(SQLHDBC hdbc,
616 SQLCHAR* szConnStrIn,
617 SQLSMALLINT cbConnStrIn,
618 SQLCHAR* szConnStrOut,
619 SQLSMALLINT cbConnStrOutMax,
620 SQLSMALLINT* pcbConnStrOut)
621 {
622 std::string str;
623 makeUTF16(szConnStrIn, cbConnStrIn, str);
624
625 Buffer<SQLWCHAR> bufConnStrOut(cbConnStrOutMax);
626
627 SQLRETURN rc = SQLBrowseConnectW(hdbc,
628 (SQLWCHAR*) str.c_str(),
629 (SQLSMALLINT) str.size(),
630 bufConnStrOut.begin(),
631 (SQLSMALLINT) bufConnStrOut.size(),
632 pcbConnStrOut);
633
634 makeUTF8(bufConnStrOut, *pcbConnStrOut * sizeof(SQLWCHAR), szConnStrOut, cbConnStrOutMax);
635
636 return rc;
637 }
638
639
SQLColumnPrivileges(SQLHSTMT hstmt,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szTableName,SQLSMALLINT cbTableName,SQLCHAR * szColumnName,SQLSMALLINT cbColumnName)640 SQLRETURN SQLColumnPrivileges(SQLHSTMT hstmt,
641 SQLCHAR* szCatalogName,
642 SQLSMALLINT cbCatalogName,
643 SQLCHAR* szSchemaName,
644 SQLSMALLINT cbSchemaName,
645 SQLCHAR* szTableName,
646 SQLSMALLINT cbTableName,
647 SQLCHAR* szColumnName,
648 SQLSMALLINT cbColumnName)
649 {
650 throw NotImplementedException();
651 }
652
653
SQLForeignKeys(SQLHSTMT hstmt,SQLCHAR * szPkCatalogName,SQLSMALLINT cbPkCatalogName,SQLCHAR * szPkSchemaName,SQLSMALLINT cbPkSchemaName,SQLCHAR * szPkTableName,SQLSMALLINT cbPkTableName,SQLCHAR * szFkCatalogName,SQLSMALLINT cbFkCatalogName,SQLCHAR * szFkSchemaName,SQLSMALLINT cbFkSchemaName,SQLCHAR * szFkTableName,SQLSMALLINT cbFkTableName)654 SQLRETURN SQLForeignKeys(SQLHSTMT hstmt,
655 SQLCHAR* szPkCatalogName,
656 SQLSMALLINT cbPkCatalogName,
657 SQLCHAR* szPkSchemaName,
658 SQLSMALLINT cbPkSchemaName,
659 SQLCHAR* szPkTableName,
660 SQLSMALLINT cbPkTableName,
661 SQLCHAR* szFkCatalogName,
662 SQLSMALLINT cbFkCatalogName,
663 SQLCHAR* szFkSchemaName,
664 SQLSMALLINT cbFkSchemaName,
665 SQLCHAR* szFkTableName,
666 SQLSMALLINT cbFkTableName)
667 {
668 throw NotImplementedException();
669 }
670
671
SQLNativeSql(SQLHDBC hdbc,SQLCHAR * szSqlStrIn,SQLINTEGER cbSqlStrIn,SQLCHAR * szSqlStr,SQLINTEGER cbSqlStrMax,SQLINTEGER * pcbSqlStr)672 SQLRETURN SQLNativeSql(SQLHDBC hdbc,
673 SQLCHAR* szSqlStrIn,
674 SQLINTEGER cbSqlStrIn,
675 SQLCHAR* szSqlStr,
676 SQLINTEGER cbSqlStrMax,
677 SQLINTEGER* pcbSqlStr)
678 {
679 std::string str;
680 makeUTF16(szSqlStrIn, cbSqlStrIn, str);
681
682 Buffer<SQLWCHAR> bufSQLOut(cbSqlStrMax);
683
684 SQLRETURN rc = SQLNativeSqlW(hdbc,
685 (SQLWCHAR*) str.c_str(),
686 (SQLINTEGER) str.size(),
687 bufSQLOut.begin(),
688 (SQLINTEGER) bufSQLOut.size(),
689 pcbSqlStr);
690
691 makeUTF8(bufSQLOut, *pcbSqlStr * sizeof(SQLWCHAR), szSqlStr, cbSqlStrMax);
692
693 return rc;
694 }
695
696
SQLPrimaryKeys(SQLHSTMT hstmt,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szTableName,SQLSMALLINT cbTableName)697 SQLRETURN SQLPrimaryKeys(SQLHSTMT hstmt,
698 SQLCHAR* szCatalogName,
699 SQLSMALLINT cbCatalogName,
700 SQLCHAR* szSchemaName,
701 SQLSMALLINT cbSchemaName,
702 SQLCHAR* szTableName,
703 SQLSMALLINT cbTableName)
704 {
705 throw NotImplementedException();
706 }
707
708
SQLProcedureColumns(SQLHSTMT hstmt,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szProcName,SQLSMALLINT cbProcName,SQLCHAR * szColumnName,SQLSMALLINT cbColumnName)709 SQLRETURN SQLProcedureColumns(SQLHSTMT hstmt,
710 SQLCHAR* szCatalogName,
711 SQLSMALLINT cbCatalogName,
712 SQLCHAR* szSchemaName,
713 SQLSMALLINT cbSchemaName,
714 SQLCHAR* szProcName,
715 SQLSMALLINT cbProcName,
716 SQLCHAR* szColumnName,
717 SQLSMALLINT cbColumnName)
718 {
719 throw NotImplementedException();
720 }
721
722
SQLProcedures(SQLHSTMT hstmt,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szProcName,SQLSMALLINT cbProcName)723 SQLRETURN SQLProcedures(SQLHSTMT hstmt,
724 SQLCHAR* szCatalogName,
725 SQLSMALLINT cbCatalogName,
726 SQLCHAR* szSchemaName,
727 SQLSMALLINT cbSchemaName,
728 SQLCHAR* szProcName,
729 SQLSMALLINT cbProcName)
730 {
731 throw NotImplementedException();
732 }
733
734
SQLTablePrivileges(SQLHSTMT hstmt,SQLCHAR * szCatalogName,SQLSMALLINT cbCatalogName,SQLCHAR * szSchemaName,SQLSMALLINT cbSchemaName,SQLCHAR * szTableName,SQLSMALLINT cbTableName)735 SQLRETURN SQLTablePrivileges(SQLHSTMT hstmt,
736 SQLCHAR* szCatalogName,
737 SQLSMALLINT cbCatalogName,
738 SQLCHAR* szSchemaName,
739 SQLSMALLINT cbSchemaName,
740 SQLCHAR* szTableName,
741 SQLSMALLINT cbTableName)
742 {
743 throw NotImplementedException();
744 }
745
746
SQLDrivers(SQLHENV henv,SQLUSMALLINT fDirection,SQLCHAR * szDriverDesc,SQLSMALLINT cbDriverDescMax,SQLSMALLINT * pcbDriverDesc,SQLCHAR * szDriverAttributes,SQLSMALLINT cbDrvrAttrMax,SQLSMALLINT * pcbDrvrAttr)747 SQLRETURN SQLDrivers(SQLHENV henv,
748 SQLUSMALLINT fDirection,
749 SQLCHAR* szDriverDesc,
750 SQLSMALLINT cbDriverDescMax,
751 SQLSMALLINT* pcbDriverDesc,
752 SQLCHAR* szDriverAttributes,
753 SQLSMALLINT cbDrvrAttrMax,
754 SQLSMALLINT* pcbDrvrAttr)
755 {
756 Buffer<SQLWCHAR> bufDriverDesc(cbDriverDescMax);
757 Buffer<SQLWCHAR> bufDriverAttr(cbDrvrAttrMax);
758
759 SQLRETURN rc = SQLDriversW(henv,
760 fDirection,
761 bufDriverDesc.begin(),
762 (SQLSMALLINT) bufDriverDesc.size(),
763 pcbDriverDesc,
764 bufDriverAttr.begin(),
765 (SQLSMALLINT) bufDriverAttr.size(),
766 pcbDrvrAttr);
767
768 makeUTF8(bufDriverDesc, *pcbDriverDesc * sizeof(SQLWCHAR), szDriverDesc, cbDriverDescMax);
769 makeUTF8(bufDriverAttr, *pcbDrvrAttr * sizeof(SQLWCHAR), szDriverAttributes, cbDrvrAttrMax);
770
771 return rc;
772 }
773
774
775 } } } // namespace Poco::Data::ODBC
776