Context Navigation

source: trunk/src/sql/drivers/db2/qsql_db2.cpp@ 840

Last change on this file since 840 was 651, checked in by Dmitry A. Kuminov, 16 years ago
trunk: Merged in qt 4.6.2 sources.
File size: 53.5 KB

Line
1	/****************************************************************************
2	**
3	** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4	** All rights reserved.
5	** Contact: Nokia Corporation ([email protected])
6	**
7	** This file is part of the QtSql module of the Qt Toolkit.
8	**
9	** $QT_BEGIN_LICENSE:LGPL$
10	** Commercial Usage
11	** Licensees holding valid Qt Commercial licenses may use this file in
12	** accordance with the Qt Commercial License Agreement provided with the
13	** Software or, alternatively, in accordance with the terms contained in
14	** a written agreement between you and Nokia.
15	**
16	** GNU Lesser General Public License Usage
17	** Alternatively, this file may be used under the terms of the GNU Lesser
18	** General Public License version 2.1 as published by the Free Software
19	** Foundation and appearing in the file LICENSE.LGPL included in the
20	** packaging of this file. Please review the following information to
21	** ensure the GNU Lesser General Public License version 2.1 requirements
22	** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23	**
24	** In addition, as a special exception, Nokia gives you certain additional
25	** rights. These rights are described in the Nokia Qt LGPL Exception
26	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27	**
28	** GNU General Public License Usage
29	** Alternatively, this file may be used under the terms of the GNU
30	** General Public License version 3.0 as published by the Free Software
31	** Foundation and appearing in the file LICENSE.GPL included in the
32	** packaging of this file. Please review the following information to
33	** ensure the GNU General Public License version 3.0 requirements will be
34	** met: http://www.gnu.org/copyleft/gpl.html.
35	**
36	** If you have questions regarding the use of this file, please contact
37	** Nokia at [email protected].
38	** $QT_END_LICENSE$
39	**
40	****************************************************************************/
41
42	#include "qsql_db2.h"
43	#include <qcoreapplication.h>
44	#include <qdatetime.h>
45	#include <qsqlfield.h>
46	#include <qsqlerror.h>
47	#include <qsqlindex.h>
48	#include <qsqlrecord.h>
49	#include <qstringlist.h>
50	#include <qvarlengtharray.h>
51	#include <qvector.h>
52	#include <QDebug>
53
54	#if defined(Q_CC_BOR)
55	// DB2's sqlsystm.h (included through sqlcli1.h) defines the SQL_BIGINT_TYPE
56	// and SQL_BIGUINT_TYPE to wrong the types for Borland; so do the defines to
57	// the right type before including the header
58	#define SQL_BIGINT_TYPE qint64
59	#define SQL_BIGUINT_TYPE quint64
60	#endif
61
62	#define UNICODE
63
64	#include <sqlcli1.h>
65
66	#include <string.h>
67
68	QT_BEGIN_NAMESPACE
69
70	static const int COLNAMESIZE = 255;
71	static const SQLSMALLINT qParamType[4] = { SQL_PARAM_INPUT, SQL_PARAM_INPUT, SQL_PARAM_OUTPUT, SQL_PARAM_INPUT_OUTPUT };
72
73	class QDB2DriverPrivate
74	{
75	public:
76	QDB2DriverPrivate(): hEnv(0), hDbc(0) {}
77	SQLHANDLE hEnv;
78	SQLHANDLE hDbc;
79	QString user;
80	};
81
82	class QDB2ResultPrivate
83	{
84	public:
85	QDB2ResultPrivate(const QDB2DriverPrivate* d): dp(d), hStmt(0)
86	{}
87	~QDB2ResultPrivate()
88	{
89	emptyValueCache();
90	}
91	void clearValueCache()
92	{
93	for (int i = 0; i < valueCache.count(); ++i) {
94	delete valueCache[i];
95	valueCache[i] = NULL;
96	}
97	}
98	void emptyValueCache()
99	{
100	clearValueCache();
101	valueCache.clear();
102	}
103
104	const QDB2DriverPrivate* dp;
105	SQLHANDLE hStmt;
106	QSqlRecord recInf;
107	QVector<QVariant*> valueCache;
108	};
109
110	static QString qFromTChar(SQLTCHAR* str)
111	{
112	return QString::fromUtf16(str);
113	}
114
115	// dangerous!! (but fast). Don't use in functions that
116	// require out parameters!
117	static SQLTCHAR* qToTChar(const QString& str)
118	{
119	return (SQLTCHAR*)str.utf16();
120	}
121
122	static QString qWarnDB2Handle(int handleType, SQLHANDLE handle)
123	{
124	SQLINTEGER nativeCode;
125	SQLSMALLINT msgLen;
126	SQLRETURN r = SQL_ERROR;
127	SQLTCHAR state[SQL_SQLSTATE_SIZE + 1];
128	SQLTCHAR description[SQL_MAX_MESSAGE_LENGTH];
129	r = SQLGetDiagRec(handleType,
130	handle,
131	1,
132	(SQLTCHAR*) state,
133	&nativeCode,
134	(SQLTCHAR*) description,
135	SQL_MAX_MESSAGE_LENGTH - 1, /* in bytes, not in characters */
136	&msgLen);
137	if (r == SQL_SUCCESS \|\| r == SQL_SUCCESS_WITH_INFO)
138	return QString(qFromTChar(description));
139	return QString();
140	}
141
142	static QString qDB2Warn(const QDB2DriverPrivate* d)
143	{
144	return (qWarnDB2Handle(SQL_HANDLE_ENV, d->hEnv) + QLatin1Char(' ')
145	+ qWarnDB2Handle(SQL_HANDLE_DBC, d->hDbc));
146	}
147
148	static QString qDB2Warn(const QDB2ResultPrivate* d)
149	{
150	return (qWarnDB2Handle(SQL_HANDLE_ENV, d->dp->hEnv) + QLatin1Char(' ')
151	+ qWarnDB2Handle(SQL_HANDLE_DBC, d->dp->hDbc)
152	+ qWarnDB2Handle(SQL_HANDLE_STMT, d->hStmt));
153	}
154
155	static void qSqlWarning(const QString& message, const QDB2DriverPrivate* d)
156	{
157	qWarning("%s\tError: %s", message.toLocal8Bit().constData(),
158	qDB2Warn(d).toLocal8Bit().constData());
159	}
160
161	static void qSqlWarning(const QString& message, const QDB2ResultPrivate* d)
162	{
163	qWarning("%s\tError: %s", message.toLocal8Bit().constData(),
164	qDB2Warn(d).toLocal8Bit().constData());
165	}
166
167	static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,
168	const QDB2DriverPrivate* p)
169	{
170	return QSqlError(QLatin1String("QDB2: ") + err, qDB2Warn(p), type);
171	}
172
173	static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,
174	const QDB2ResultPrivate* p)
175	{
176	return QSqlError(QLatin1String("QDB2: ") + err, qDB2Warn(p), type);
177	}
178
179	static QVariant::Type qDecodeDB2Type(SQLSMALLINT sqltype)
180	{
181	QVariant::Type type = QVariant::Invalid;
182	switch (sqltype) {
183	case SQL_REAL:
184	case SQL_FLOAT:
185	case SQL_DOUBLE:
186	case SQL_DECIMAL:
187	case SQL_NUMERIC:
188	type = QVariant::Double;
189	break;
190	case SQL_SMALLINT:
191	case SQL_INTEGER:
192	case SQL_BIT:
193	case SQL_TINYINT:
194	type = QVariant::Int;
195	break;
196	case SQL_BIGINT:
197	type = QVariant::LongLong;
198	break;
199	case SQL_BLOB:
200	case SQL_BINARY:
201	case SQL_VARBINARY:
202	case SQL_LONGVARBINARY:
203	case SQL_CLOB:
204	case SQL_DBCLOB:
205	type = QVariant::ByteArray;
206	break;
207	case SQL_DATE:
208	case SQL_TYPE_DATE:
209	type = QVariant::Date;
210	break;
211	case SQL_TIME:
212	case SQL_TYPE_TIME:
213	type = QVariant::Time;
214	break;
215	case SQL_TIMESTAMP:
216	case SQL_TYPE_TIMESTAMP:
217	type = QVariant::DateTime;
218	break;
219	case SQL_WCHAR:
220	case SQL_WVARCHAR:
221	case SQL_WLONGVARCHAR:
222	case SQL_CHAR:
223	case SQL_VARCHAR:
224	case SQL_LONGVARCHAR:
225	type = QVariant::String;
226	break;
227	default:
228	type = QVariant::ByteArray;
229	break;
230	}
231	return type;
232	}
233
234	static QSqlField qMakeFieldInfo(const QDB2ResultPrivate* d, int i)
235	{
236	SQLSMALLINT colNameLen;
237	SQLSMALLINT colType;
238	SQLUINTEGER colSize;
239	SQLSMALLINT colScale;
240	SQLSMALLINT nullable;
241	SQLRETURN r = SQL_ERROR;
242	SQLTCHAR colName[COLNAMESIZE];
243	r = SQLDescribeCol(d->hStmt,
244	i+1,
245	colName,
246	(SQLSMALLINT) COLNAMESIZE,
247	&colNameLen,
248	&colType,
249	&colSize,
250	&colScale,
251	&nullable);
252
253	if (r != SQL_SUCCESS) {
254	qSqlWarning(QString::fromLatin1("qMakeFieldInfo: Unable to describe column %1").arg(i), d);
255	return QSqlField();
256	}
257	QSqlField f(qFromTChar(colName), qDecodeDB2Type(colType));
258	// nullable can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN
259	if (nullable == SQL_NO_NULLS)
260	f.setRequired(true);
261	else if (nullable == SQL_NULLABLE)
262	f.setRequired(false);
263	// else required is unknown
264	f.setLength(colSize == 0 ? -1 : int(colSize));
265	f.setPrecision(colScale == 0 ? -1 : int(colScale));
266	f.setSqlType(int(colType));
267	return f;
268	}
269
270	static int qGetIntData(SQLHANDLE hStmt, int column, bool& isNull)
271	{
272	SQLINTEGER intbuf;
273	isNull = false;
274	SQLINTEGER lengthIndicator = 0;
275	SQLRETURN r = SQLGetData(hStmt,
276	column + 1,
277	SQL_C_SLONG,
278	(SQLPOINTER) &intbuf,
279	0,
280	&lengthIndicator);
281	if ((r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) \|\| lengthIndicator == SQL_NULL_DATA) {
282	isNull = true;
283	return 0;
284	}
285	return int(intbuf);
286	}
287
288	static double qGetDoubleData(SQLHANDLE hStmt, int column, bool& isNull)
289	{
290	SQLDOUBLE dblbuf;
291	isNull = false;
292	SQLINTEGER lengthIndicator = 0;
293	SQLRETURN r = SQLGetData(hStmt,
294	column+1,
295	SQL_C_DOUBLE,
296	(SQLPOINTER) &dblbuf,
297	0,
298	&lengthIndicator);
299	if ((r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) \|\| lengthIndicator == SQL_NULL_DATA) {
300	isNull = true;
301	return 0.0;
302	}
303
304	return (double) dblbuf;
305	}
306
307	static SQLBIGINT qGetBigIntData(SQLHANDLE hStmt, int column, bool& isNull)
308	{
309	SQLBIGINT lngbuf = Q_INT64_C(0);
310	isNull = false;
311	SQLINTEGER lengthIndicator = 0;
312	SQLRETURN r = SQLGetData(hStmt,
313	column+1,
314	SQL_C_SBIGINT,
315	(SQLPOINTER) &lngbuf,
316	0,
317	&lengthIndicator);
318	if ((r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) \|\| lengthIndicator == SQL_NULL_DATA)
319	isNull = true;
320
321	return lngbuf;
322	}
323
324	static QString qGetStringData(SQLHANDLE hStmt, int column, int colSize, bool& isNull)
325	{
326	QString fieldVal;
327	SQLRETURN r = SQL_ERROR;
328	SQLINTEGER lengthIndicator = 0;
329
330	if (colSize <= 0)
331	colSize = 255;
332	else if (colSize > 65536) // limit buffer size to 64 KB
333	colSize = 65536;
334	else
335	colSize++; // make sure there is room for more than the 0 termination
336	SQLTCHAR* buf = new SQLTCHAR[colSize];
337
338	while (true) {
339	r = SQLGetData(hStmt,
340	column + 1,
341	SQL_C_WCHAR,
342	(SQLPOINTER)buf,
343	colSize * sizeof(SQLTCHAR),
344	&lengthIndicator);
345	if (r == SQL_SUCCESS \|\| r == SQL_SUCCESS_WITH_INFO) {
346	if (lengthIndicator == SQL_NULL_DATA \|\| lengthIndicator == SQL_NO_TOTAL) {
347	fieldVal.clear();
348	isNull = true;
349	break;
350	}
351	fieldVal += qFromTChar(buf);
352	} else if (r == SQL_NO_DATA) {
353	break;
354	} else {
355	qWarning("qGetStringData: Error while fetching data (%d)", r);
356	fieldVal.clear();
357	break;
358	}
359	}
360	delete[] buf;
361	return fieldVal;
362	}
363
364	static QByteArray qGetBinaryData(SQLHANDLE hStmt, int column, SQLINTEGER& lengthIndicator, bool& isNull)
365	{
366	QByteArray fieldVal;
367	SQLSMALLINT colNameLen;
368	SQLSMALLINT colType;
369	SQLUINTEGER colSize;
370	SQLSMALLINT colScale;
371	SQLSMALLINT nullable;
372	SQLRETURN r = SQL_ERROR;
373
374	SQLTCHAR colName[COLNAMESIZE];
375	r = SQLDescribeCol(hStmt,
376	column+1,
377	colName,
378	COLNAMESIZE,
379	&colNameLen,
380	&colType,
381	&colSize,
382	&colScale,
383	&nullable);
384	if (r != SQL_SUCCESS)
385	qWarning("qGetBinaryData: Unable to describe column %d", column);
386	// SQLDescribeCol may return 0 if size cannot be determined
387	if (!colSize)
388	colSize = 255;
389	else if (colSize > 65536) // read the field in 64 KB chunks
390	colSize = 65536;
391	char * buf = new char[colSize];
392	while (true) {
393	r = SQLGetData(hStmt,
394	column+1,
395	colType == SQL_DBCLOB ? SQL_C_CHAR : SQL_C_BINARY,
396	(SQLPOINTER) buf,
397	colSize,
398	&lengthIndicator);
399	if (r == SQL_SUCCESS \|\| r == SQL_SUCCESS_WITH_INFO) {
400	if (lengthIndicator == SQL_NULL_DATA) {
401	isNull = true;
402	break;
403	} else {
404	int rSize;
405	r == SQL_SUCCESS ? rSize = lengthIndicator : rSize = colSize;
406	if (lengthIndicator == SQL_NO_TOTAL) // size cannot be determined
407	rSize = colSize;
408	fieldVal.append(QByteArray(buf, rSize));
409	if (r == SQL_SUCCESS) // the whole field was read in one chunk
410	break;
411	}
412	} else {
413	break;
414	}
415	}
416	delete [] buf;
417	return fieldVal;
418	}
419
420	static void qSplitTableQualifier(const QString & qualifier, QString * catalog,
421	QString * schema, QString * table)
422	{
423	if (!catalog \|\| !schema \|\| !table)
424	return;
425	QStringList l = qualifier.split(QLatin1Char('.'));
426	if (l.count() > 3)
427	return; // can't possibly be a valid table qualifier
428	int i = 0, n = l.count();
429	if (n == 1) {
430	*table = qualifier;
431	} else {
432	for (QStringList::Iterator it = l.begin(); it != l.end(); ++it) {
433	if (n == 3) {
434	if (i == 0)
435	catalog = it;
436	else if (i == 1)
437	schema = it;
438	else if (i == 2)
439	table = it;
440	} else if (n == 2) {
441	if (i == 0)
442	schema = it;
443	else if (i == 1)
444	table = it;
445	}
446	i++;
447	}
448	}
449	}
450
451	// creates a QSqlField from a valid hStmt generated
452	// by SQLColumns. The hStmt has to point to a valid position.
453	static QSqlField qMakeFieldInfo(const SQLHANDLE hStmt)
454	{
455	bool isNull;
456	int type = qGetIntData(hStmt, 4, isNull);
457	QSqlField f(qGetStringData(hStmt, 3, -1, isNull), qDecodeDB2Type(type));
458	int required = qGetIntData(hStmt, 10, isNull); // nullable-flag
459	// required can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN
460	if (required == SQL_NO_NULLS)
461	f.setRequired(true);
462	else if (required == SQL_NULLABLE)
463	f.setRequired(false);
464	// else we don't know.
465	f.setLength(qGetIntData(hStmt, 6, isNull)); // column size
466	f.setPrecision(qGetIntData(hStmt, 8, isNull)); // precision
467	f.setSqlType(type);
468	return f;
469	}
470
471	static bool qMakeStatement(QDB2ResultPrivate* d, bool forwardOnly, bool setForwardOnly = true)
472	{
473	SQLRETURN r;
474	if (!d->hStmt) {
475	r = SQLAllocHandle(SQL_HANDLE_STMT,
476	d->dp->hDbc,
477	&d->hStmt);
478	if (r != SQL_SUCCESS) {
479	qSqlWarning(QLatin1String("QDB2Result::reset: Unable to allocate statement handle"), d);
480	return false;
481	}
482	} else {
483	r = SQLFreeStmt(d->hStmt, SQL_CLOSE);
484	if (r != SQL_SUCCESS) {
485	qSqlWarning(QLatin1String("QDB2Result::reset: Unable to close statement handle"), d);
486	return false;
487	}
488	}
489
490	if (!setForwardOnly)
491	return true;
492
493	if (forwardOnly) {
494	r = SQLSetStmtAttr(d->hStmt,
495	SQL_ATTR_CURSOR_TYPE,
496	(SQLPOINTER) SQL_CURSOR_FORWARD_ONLY,
497	SQL_IS_UINTEGER);
498	} else {
499	r = SQLSetStmtAttr(d->hStmt,
500	SQL_ATTR_CURSOR_TYPE,
501	(SQLPOINTER) SQL_CURSOR_STATIC,
502	SQL_IS_UINTEGER);
503	}
504	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
505	qSqlWarning(QString::fromLatin1("QDB2Result::reset: Unable to set %1 attribute.").arg(
506	forwardOnly ? QLatin1String("SQL_CURSOR_FORWARD_ONLY")
507	: QLatin1String("SQL_CURSOR_STATIC")), d);
508	return false;
509	}
510	return true;
511	}
512
513	QVariant QDB2Result::handle() const
514	{
515	return QVariant(qRegisterMetaType<SQLHANDLE>("SQLHANDLE"), &d->hStmt);
516	}
517
518	/************************************/
519
520	QDB2Result::QDB2Result(const QDB2Driver* dr, const QDB2DriverPrivate* dp)
521	: QSqlResult(dr)
522	{
523	d = new QDB2ResultPrivate(dp);
524	}
525
526	QDB2Result::~QDB2Result()
527	{
528	if (d->hStmt) {
529	SQLRETURN r = SQLFreeHandle(SQL_HANDLE_STMT, d->hStmt);
530	if (r != SQL_SUCCESS)
531	qSqlWarning(QLatin1String("QDB2Driver: Unable to free statement handle ")
532	+ QString::number(r), d);
533	}
534	delete d;
535	}
536
537	bool QDB2Result::reset (const QString& query)
538	{
539	setActive(false);
540	setAt(QSql::BeforeFirstRow);
541	SQLRETURN r;
542
543	d->recInf.clear();
544	d->emptyValueCache();
545
546	if (!qMakeStatement(d, isForwardOnly()))
547	return false;
548
549	r = SQLExecDirect(d->hStmt,
550	qToTChar(query),
551	(SQLINTEGER) query.length());
552	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
553	setLastError(qMakeError(QCoreApplication::translate("QDB2Result",
554	"Unable to execute statement"), QSqlError::StatementError, d));
555	return false;
556	}
557	SQLSMALLINT count;
558	r = SQLNumResultCols(d->hStmt, &count);
559	if (count) {
560	setSelect(true);
561	for (int i = 0; i < count; ++i) {
562	d->recInf.append(qMakeFieldInfo(d, i));
563	}
564	} else {
565	setSelect(false);
566	}
567	d->valueCache.resize(count);
568	d->valueCache.fill(NULL);
569	setActive(true);
570	return true;
571	}
572
573	bool QDB2Result::prepare(const QString& query)
574	{
575	setActive(false);
576	setAt(QSql::BeforeFirstRow);
577	SQLRETURN r;
578
579	d->recInf.clear();
580	d->emptyValueCache();
581
582	if (!qMakeStatement(d, isForwardOnly()))
583	return false;
584
585	r = SQLPrepare(d->hStmt,
586	qToTChar(query),
587	(SQLINTEGER) query.length());
588
589	if (r != SQL_SUCCESS) {
590	setLastError(qMakeError(QCoreApplication::translate("QDB2Result",
591	"Unable to prepare statement"), QSqlError::StatementError, d));
592	return false;
593	}
594	return true;
595	}
596
597	bool QDB2Result::exec()
598	{
599	QList<QByteArray> tmpStorage; // holds temporary ptrs
600	QVarLengthArray<SQLINTEGER, 32> indicators(boundValues().count());
601
602	memset(indicators.data(), 0, indicators.size() * sizeof(SQLINTEGER));
603	setActive(false);
604	setAt(QSql::BeforeFirstRow);
605	SQLRETURN r;
606
607	d->recInf.clear();
608	d->emptyValueCache();
609
610	if (!qMakeStatement(d, isForwardOnly(), false))
611	return false;
612
613
614	QVector<QVariant> &values = boundValues();
615	int i;
616	for (i = 0; i < values.count(); ++i) {
617	// bind parameters - only positional binding allowed
618	SQLINTEGER *ind = &indicators[i];
619	if (values.at(i).isNull())
620	*ind = SQL_NULL_DATA;
621	if (bindValueType(i) & QSql::Out)
622	values[i].detach();
623
624	switch (values.at(i).type()) {
625	case QVariant::Date: {
626	QByteArray ba;
627	ba.resize(sizeof(DATE_STRUCT));
628	DATE_STRUCT dt = (DATE_STRUCT )ba.constData();
629	QDate qdt = values.at(i).toDate();
630	dt->year = qdt.year();
631	dt->month = qdt.month();
632	dt->day = qdt.day();
633	r = SQLBindParameter(d->hStmt,
634	i + 1,
635	qParamType[(QFlag)(bindValueType(i)) & 3],
636	SQL_C_DATE,
637	SQL_DATE,
638	0,
639	0,
640	(void *) dt,
641	0,
642	*ind == SQL_NULL_DATA ? ind : NULL);
643	tmpStorage.append(ba);
644	break; }
645	case QVariant::Time: {
646	QByteArray ba;
647	ba.resize(sizeof(TIME_STRUCT));
648	TIME_STRUCT dt = (TIME_STRUCT )ba.constData();
649	QTime qdt = values.at(i).toTime();
650	dt->hour = qdt.hour();
651	dt->minute = qdt.minute();
652	dt->second = qdt.second();
653	r = SQLBindParameter(d->hStmt,
654	i + 1,
655	qParamType[(QFlag)(bindValueType(i)) & 3],
656	SQL_C_TIME,
657	SQL_TIME,
658	0,
659	0,
660	(void *) dt,
661	0,
662	*ind == SQL_NULL_DATA ? ind : NULL);
663	tmpStorage.append(ba);
664	break; }
665	case QVariant::DateTime: {
666	QByteArray ba;
667	ba.resize(sizeof(TIMESTAMP_STRUCT));
668	TIMESTAMP_STRUCT * dt = (TIMESTAMP_STRUCT *)ba.constData();
669	QDateTime qdt = values.at(i).toDateTime();
670	dt->year = qdt.date().year();
671	dt->month = qdt.date().month();
672	dt->day = qdt.date().day();
673	dt->hour = qdt.time().hour();
674	dt->minute = qdt.time().minute();
675	dt->second = qdt.time().second();
676	dt->fraction = qdt.time().msec() * 1000000;
677	r = SQLBindParameter(d->hStmt,
678	i + 1,
679	qParamType[(QFlag)(bindValueType(i)) & 3],
680	SQL_C_TIMESTAMP,
681	SQL_TIMESTAMP,
682	0,
683	0,
684	(void *) dt,
685	0,
686	*ind == SQL_NULL_DATA ? ind : NULL);
687	tmpStorage.append(ba);
688	break; }
689	case QVariant::Int:
690	r = SQLBindParameter(d->hStmt,
691	i + 1,
692	qParamType[(QFlag)(bindValueType(i)) & 3],
693	SQL_C_SLONG,
694	SQL_INTEGER,
695	0,
696	0,
697	(void *)values.at(i).constData(),
698	0,
699	*ind == SQL_NULL_DATA ? ind : NULL);
700	break;
701	case QVariant::Double:
702	r = SQLBindParameter(d->hStmt,
703	i + 1,
704	qParamType[(QFlag)(bindValueType(i)) & 3],
705	SQL_C_DOUBLE,
706	SQL_DOUBLE,
707	0,
708	0,
709	(void *)values.at(i).constData(),
710	0,
711	*ind == SQL_NULL_DATA ? ind : NULL);
712	break;
713	case QVariant::ByteArray: {
714	int len = values.at(i).toByteArray().size();
715	if (*ind != SQL_NULL_DATA)
716	*ind = len;
717	r = SQLBindParameter(d->hStmt,
718	i + 1,
719	qParamType[(QFlag)(bindValueType(i)) & 3],
720	SQL_C_BINARY,
721	SQL_LONGVARBINARY,
722	len,
723	0,
724	(void *)values.at(i).toByteArray().constData(),
725	len,
726	ind);
727	break; }
728	case QVariant::String:
729	{
730	QString str(values.at(i).toString());
731	if (*ind != SQL_NULL_DATA)
732	ind = str.length() sizeof(QChar);
733	if (bindValueType(i) & QSql::Out) {
734	QByteArray ba((char)str.utf16(), str.capacity() sizeof(QChar));
735	r = SQLBindParameter(d->hStmt,
736	i + 1,
737	qParamType[(QFlag)(bindValueType(i)) & 3],
738	SQL_C_WCHAR,
739	SQL_WVARCHAR,
740	str.length(),
741	0,
742	(void *)ba.constData(),
743	ba.size(),
744	ind);
745	tmpStorage.append(ba);
746	} else {
747	void data = (void)str.utf16();
748	int len = str.length();
749	r = SQLBindParameter(d->hStmt,
750	i + 1,
751	qParamType[(QFlag)(bindValueType(i)) & 3],
752	SQL_C_WCHAR,
753	SQL_WVARCHAR,
754	len,
755	0,
756	data,
757	len * sizeof(QChar),
758	ind);
759	}
760	break;
761	}
762	default: {
763	QByteArray ba = values.at(i).toString().toAscii();
764	int len = ba.length() + 1;
765	if (*ind != SQL_NULL_DATA)
766	*ind = ba.length();
767	r = SQLBindParameter(d->hStmt,
768	i + 1,
769	qParamType[(QFlag)(bindValueType(i)) & 3],
770	SQL_C_CHAR,
771	SQL_VARCHAR,
772	len,
773	0,
774	(void *) ba.constData(),
775	len,
776	ind);
777	tmpStorage.append(ba);
778	break; }
779	}
780	if (r != SQL_SUCCESS) {
781	qWarning("QDB2Result::exec: unable to bind variable: %s",
782	qDB2Warn(d).toLocal8Bit().constData());
783	setLastError(qMakeError(QCoreApplication::translate("QDB2Result",
784	"Unable to bind variable"), QSqlError::StatementError, d));
785	return false;
786	}
787	}
788
789	r = SQLExecute(d->hStmt);
790	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
791	qWarning("QDB2Result::exec: Unable to execute statement: %s",
792	qDB2Warn(d).toLocal8Bit().constData());
793	setLastError(qMakeError(QCoreApplication::translate("QDB2Result",
794	"Unable to execute statement"), QSqlError::StatementError, d));
795	return false;
796	}
797	SQLSMALLINT count;
798	r = SQLNumResultCols(d->hStmt, &count);
799	if (count) {
800	setSelect(true);
801	for (int i = 0; i < count; ++i) {
802	d->recInf.append(qMakeFieldInfo(d, i));
803	}
804	} else {
805	setSelect(false);
806	}
807	setActive(true);
808	d->valueCache.resize(count);
809	d->valueCache.fill(NULL);
810
811	//get out parameters
812	if (!hasOutValues())
813	return true;
814
815	for (i = 0; i < values.count(); ++i) {
816	switch (values[i].type()) {
817	case QVariant::Date: {
818	DATE_STRUCT ds = ((DATE_STRUCT )tmpStorage.takeFirst().constData());
819	values[i] = QVariant(QDate(ds.year, ds.month, ds.day));
820	break; }
821	case QVariant::Time: {
822	TIME_STRUCT dt = ((TIME_STRUCT )tmpStorage.takeFirst().constData());
823	values[i] = QVariant(QTime(dt.hour, dt.minute, dt.second));
824	break; }
825	case QVariant::DateTime: {
826	TIMESTAMP_STRUCT dt = ((TIMESTAMP_STRUCT )tmpStorage.takeFirst().constData());
827	values[i] = QVariant(QDateTime(QDate(dt.year, dt.month, dt.day),
828	QTime(dt.hour, dt.minute, dt.second, dt.fraction / 1000000)));
829	break; }
830	case QVariant::Int:
831	case QVariant::Double:
832	case QVariant::ByteArray:
833	break;
834	case QVariant::String:
835	if (bindValueType(i) & QSql::Out)
836	values[i] = QString::fromUtf16((ushort*)tmpStorage.takeFirst().constData());
837	break;
838	default: {
839	values[i] = QString::fromAscii(tmpStorage.takeFirst().constData());
840	break; }
841	}
842	if (indicators[i] == SQL_NULL_DATA)
843	values[i] = QVariant(values[i].type());
844	}
845	return true;
846	}
847
848	bool QDB2Result::fetch(int i)
849	{
850	if (isForwardOnly() && i < at())
851	return false;
852	if (i == at())
853	return true;
854	d->clearValueCache();
855	int actualIdx = i + 1;
856	if (actualIdx <= 0) {
857	setAt(QSql::BeforeFirstRow);
858	return false;
859	}
860	SQLRETURN r;
861	if (isForwardOnly()) {
862	bool ok = true;
863	while (ok && i > at())
864	ok = fetchNext();
865	return ok;
866	} else {
867	r = SQLFetchScroll(d->hStmt,
868	SQL_FETCH_ABSOLUTE,
869	actualIdx);
870	}
871	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO && r != SQL_NO_DATA) {
872	setLastError(qMakeError(QCoreApplication::translate("QDB2Result",
873	"Unable to fetch record %1").arg(i), QSqlError::StatementError, d));
874	return false;
875	}
876	else if (r == SQL_NO_DATA)
877	return false;
878	setAt(i);
879	return true;
880	}
881
882	bool QDB2Result::fetchNext()
883	{
884	SQLRETURN r;
885	d->clearValueCache();
886	r = SQLFetchScroll(d->hStmt,
887	SQL_FETCH_NEXT,
888	0);
889	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
890	if (r != SQL_NO_DATA)
891	setLastError(qMakeError(QCoreApplication::translate("QDB2Result",
892	"Unable to fetch next"), QSqlError::StatementError, d));
893	return false;
894	}
895	setAt(at() + 1);
896	return true;
897	}
898
899	bool QDB2Result::fetchFirst()
900	{
901	if (isForwardOnly() && at() != QSql::BeforeFirstRow)
902	return false;
903	if (isForwardOnly())
904	return fetchNext();
905	d->clearValueCache();
906	SQLRETURN r;
907	r = SQLFetchScroll(d->hStmt,
908	SQL_FETCH_FIRST,
909	0);
910	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
911	if(r!= SQL_NO_DATA)
912	setLastError(qMakeError(QCoreApplication::translate("QDB2Result", "Unable to fetch first"),
913	QSqlError::StatementError, d));
914	return false;
915	}
916	setAt(0);
917	return true;
918	}
919
920	bool QDB2Result::fetchLast()
921	{
922	d->clearValueCache();
923
924	int i = at();
925	if (i == QSql::AfterLastRow) {
926	if (isForwardOnly()) {
927	return false;
928	} else {
929	if (!fetch(0))
930	return false;
931	i = at();
932	}
933	}
934
935	while (fetchNext())
936	++i;
937
938	if (i == QSql::BeforeFirstRow) {
939	setAt(QSql::AfterLastRow);
940	return false;
941	}
942
943	if (!isForwardOnly())
944	return fetch(i);
945
946	setAt(i);
947	return true;
948	}
949
950
951	QVariant QDB2Result::data(int field)
952	{
953	if (field >= d->recInf.count()) {
954	qWarning("QDB2Result::data: column %d out of range", field);
955	return QVariant();
956	}
957	SQLRETURN r = 0;
958	SQLINTEGER lengthIndicator = 0;
959	bool isNull = false;
960	const QSqlField info = d->recInf.field(field);
961
962	if (!info.isValid() \|\| field >= d->valueCache.size())
963	return QVariant();
964
965	if (d->valueCache[field])
966	return *d->valueCache[field];
967
968
969	QVariant* v = 0;
970	switch (info.type()) {
971	case QVariant::LongLong:
972	v = new QVariant((qint64) qGetBigIntData(d->hStmt, field, isNull));
973	break;
974	case QVariant::Int:
975	v = new QVariant(qGetIntData(d->hStmt, field, isNull));
976	break;
977	case QVariant::Date: {
978	DATE_STRUCT dbuf;
979	r = SQLGetData(d->hStmt,
980	field + 1,
981	SQL_C_DATE,
982	(SQLPOINTER) &dbuf,
983	0,
984	&lengthIndicator);
985	if ((r == SQL_SUCCESS \|\| r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA)) {
986	v = new QVariant(QDate(dbuf.year, dbuf.month, dbuf.day));
987	} else {
988	v = new QVariant(QDate());
989	isNull = true;
990	}
991	break; }
992	case QVariant::Time: {
993	TIME_STRUCT tbuf;
994	r = SQLGetData(d->hStmt,
995	field + 1,
996	SQL_C_TIME,
997	(SQLPOINTER) &tbuf,
998	0,
999	&lengthIndicator);
1000	if ((r == SQL_SUCCESS \|\| r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA)) {
1001	v = new QVariant(QTime(tbuf.hour, tbuf.minute, tbuf.second));
1002	} else {
1003	v = new QVariant(QTime());
1004	isNull = true;
1005	}
1006	break; }
1007	case QVariant::DateTime: {
1008	TIMESTAMP_STRUCT dtbuf;
1009	r = SQLGetData(d->hStmt,
1010	field + 1,
1011	SQL_C_TIMESTAMP,
1012	(SQLPOINTER) &dtbuf,
1013	0,
1014	&lengthIndicator);
1015	if ((r == SQL_SUCCESS \|\| r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA)) {
1016	v = new QVariant(QDateTime(QDate(dtbuf.year, dtbuf.month, dtbuf.day),
1017	QTime(dtbuf.hour, dtbuf.minute, dtbuf.second, dtbuf.fraction / 1000000)));
1018	} else {
1019	v = new QVariant(QDateTime());
1020	isNull = true;
1021	}
1022	break; }
1023	case QVariant::ByteArray:
1024	v = new QVariant(qGetBinaryData(d->hStmt, field, lengthIndicator, isNull));
1025	break;
1026	case QVariant::Double:
1027	{
1028	switch(numericalPrecisionPolicy()) {
1029	case QSql::LowPrecisionInt32:
1030	v = new QVariant(qGetIntData(d->hStmt, field, isNull));
1031	break;
1032	case QSql::LowPrecisionInt64:
1033	v = new QVariant(qGetBigIntData(d->hStmt, field, isNull));
1034	break;
1035	case QSql::LowPrecisionDouble:
1036	v = new QVariant(qGetDoubleData(d->hStmt, field, isNull));
1037	break;
1038	case QSql::HighPrecision:
1039	default:
1040	// length + 1 for the comma
1041	v = new QVariant(qGetStringData(d->hStmt, field, info.length() + 1, isNull));
1042	break;
1043	}
1044	break;
1045	}
1046	case QVariant::String:
1047	default:
1048	v = new QVariant(qGetStringData(d->hStmt, field, info.length(), isNull));
1049	break;
1050	}
1051	if (isNull)
1052	*v = QVariant(info.type());
1053	d->valueCache[field] = v;
1054	return *v;
1055	}
1056
1057	bool QDB2Result::isNull(int i)
1058	{
1059	if (i >= d->valueCache.size())
1060	return true;
1061
1062	if (d->valueCache[i])
1063	return d->valueCache[i]->isNull();
1064	return data(i).isNull();
1065	}
1066
1067	int QDB2Result::numRowsAffected()
1068	{
1069	SQLINTEGER affectedRowCount = 0;
1070	SQLRETURN r = SQLRowCount(d->hStmt, &affectedRowCount);
1071	if (r == SQL_SUCCESS \|\| r == SQL_SUCCESS_WITH_INFO)
1072	return affectedRowCount;
1073	else
1074	qSqlWarning(QLatin1String("QDB2Result::numRowsAffected: Unable to count affected rows"), d);
1075	return -1;
1076	}
1077
1078	int QDB2Result::size()
1079	{
1080	return -1;
1081	}
1082
1083	QSqlRecord QDB2Result::record() const
1084	{
1085	if (isActive())
1086	return d->recInf;
1087	return QSqlRecord();
1088	}
1089
1090	bool QDB2Result::nextResult()
1091	{
1092	setActive(false);
1093	setAt(QSql::BeforeFirstRow);
1094	d->recInf.clear();
1095	d->emptyValueCache();
1096	setSelect(false);
1097
1098	SQLRETURN r = SQLMoreResults(d->hStmt);
1099	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
1100	if (r != SQL_NO_DATA) {
1101	setLastError(qMakeError(QCoreApplication::translate("QODBCResult",
1102	"Unable to fetch last"), QSqlError::ConnectionError, d));
1103	}
1104	return false;
1105	}
1106
1107	SQLSMALLINT fieldCount;
1108	r = SQLNumResultCols(d->hStmt, &fieldCount);
1109	setSelect(fieldCount > 0);
1110	for (int i = 0; i < fieldCount; ++i)
1111	d->recInf.append(qMakeFieldInfo(d, i));
1112
1113	d->valueCache.resize(fieldCount);
1114	d->valueCache.fill(NULL);
1115	setActive(true);
1116
1117	return true;
1118	}
1119
1120	void QDB2Result::virtual_hook(int id, void *data)
1121	{
1122	switch (id) {
1123	case QSqlResult::NextResult:
1124	Q_ASSERT(data);
1125	static_cast<bool>(data) = nextResult();
1126	break;
1127	case QSqlResult::DetachFromResultSet:
1128	if (d->hStmt)
1129	SQLCloseCursor(d->hStmt);
1130	break;
1131	default:
1132	QSqlResult::virtual_hook(id, data);
1133	}
1134	}
1135
1136	/************************************/
1137
1138	QDB2Driver::QDB2Driver(QObject* parent)
1139	: QSqlDriver(parent)
1140	{
1141	d = new QDB2DriverPrivate;
1142	}
1143
1144	QDB2Driver::QDB2Driver(Qt::HANDLE env, Qt::HANDLE con, QObject* parent)
1145	: QSqlDriver(parent)
1146	{
1147	d = new QDB2DriverPrivate;
1148	d->hEnv = (SQLHANDLE)env;
1149	d->hDbc = (SQLHANDLE)con;
1150	if (env && con) {
1151	setOpen(true);
1152	setOpenError(false);
1153	}
1154	}
1155
1156	QDB2Driver::~QDB2Driver()
1157	{
1158	close();
1159	delete d;
1160	}
1161
1162	bool QDB2Driver::open(const QString& db, const QString& user, const QString& password, const QString& host, int port,
1163	const QString& connOpts)
1164	{
1165	if (isOpen())
1166	close();
1167	SQLRETURN r;
1168	r = SQLAllocHandle(SQL_HANDLE_ENV,
1169	SQL_NULL_HANDLE,
1170	&d->hEnv);
1171	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
1172	qSqlWarning(QLatin1String("QDB2Driver::open: Unable to allocate environment"), d);
1173	setOpenError(true);
1174	return false;
1175	}
1176
1177	r = SQLAllocHandle(SQL_HANDLE_DBC,
1178	d->hEnv,
1179	&d->hDbc);
1180	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
1181	qSqlWarning(QLatin1String("QDB2Driver::open: Unable to allocate connection"), d);
1182	setOpenError(true);
1183	return false;
1184	}
1185
1186	QString protocol;
1187	// Set connection attributes
1188	const QStringList opts(connOpts.split(QLatin1Char(';'), QString::SkipEmptyParts));
1189	for (int i = 0; i < opts.count(); ++i) {
1190	const QString tmp(opts.at(i));
1191	int idx;
1192	if ((idx = tmp.indexOf(QLatin1Char('='))) == -1) {
1193	qWarning("QDB2Driver::open: Illegal connect option value '%s'",
1194	tmp.toLocal8Bit().constData());
1195	continue;
1196	}
1197
1198	const QString opt(tmp.left(idx));
1199	const QString val(tmp.mid(idx + 1).simplified());
1200
1201	SQLUINTEGER v = 0;
1202	r = SQL_SUCCESS;
1203	if (opt == QLatin1String("SQL_ATTR_ACCESS_MODE")) {
1204	if (val == QLatin1String("SQL_MODE_READ_ONLY")) {
1205	v = SQL_MODE_READ_ONLY;
1206	} else if (val == QLatin1String("SQL_MODE_READ_WRITE")) {
1207	v = SQL_MODE_READ_WRITE;
1208	} else {
1209	qWarning("QDB2Driver::open: Unknown option value '%s'",
1210	tmp.toLocal8Bit().constData());
1211	continue;
1212	}
1213	r = SQLSetConnectAttr(d->hDbc, SQL_ATTR_ACCESS_MODE, (SQLPOINTER) v, 0);
1214	} else if (opt == QLatin1String("SQL_ATTR_LOGIN_TIMEOUT")) {
1215	v = val.toUInt();
1216	r = SQLSetConnectAttr(d->hDbc, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER) v, 0);
1217	} else if (opt.compare(QLatin1String("PROTOCOL"), Qt::CaseInsensitive) == 0) {
1218	protocol = tmp;
1219	}
1220	else {
1221	qWarning("QDB2Driver::open: Unknown connection attribute '%s'",
1222	tmp.toLocal8Bit().constData());
1223	}
1224	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)
1225	qSqlWarning(QString::fromLatin1("QDB2Driver::open: "
1226	"Unable to set connection attribute '%1'").arg(opt), d);
1227	}
1228
1229	if (protocol.isEmpty())
1230	protocol = QLatin1String("PROTOCOL=TCPIP");
1231
1232	if (port < 0 )
1233	port = 50000;
1234
1235	QString connQStr;
1236	connQStr = protocol + QLatin1String(";DATABASE=") + db + QLatin1String(";HOSTNAME=") + host
1237	+ QLatin1String(";PORT=") + QString::number(port) + QLatin1String(";UID=") + user
1238	+ QLatin1String(";PWD=") + password;
1239
1240
1241	SQLTCHAR connOut[SQL_MAX_OPTION_STRING_LENGTH];
1242	SQLSMALLINT cb;
1243
1244	r = SQLDriverConnect(d->hDbc,
1245	NULL,
1246	qToTChar(connQStr),
1247	(SQLSMALLINT) connQStr.length(),
1248	connOut,
1249	SQL_MAX_OPTION_STRING_LENGTH,
1250	&cb,
1251	SQL_DRIVER_NOPROMPT);
1252	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
1253	setLastError(qMakeError(tr("Unable to connect"),
1254	QSqlError::ConnectionError, d));
1255	setOpenError(true);
1256	return false;
1257	}
1258
1259	d->user = user;
1260	setOpen(true);
1261	setOpenError(false);
1262	return true;
1263	}
1264
1265	void QDB2Driver::close()
1266	{
1267	SQLRETURN r;
1268	if (d->hDbc) {
1269	// Open statements/descriptors handles are automatically cleaned up by SQLDisconnect
1270	if (isOpen()) {
1271	r = SQLDisconnect(d->hDbc);
1272	if (r != SQL_SUCCESS)
1273	qSqlWarning(QLatin1String("QDB2Driver::close: Unable to disconnect datasource"), d);
1274	}
1275	r = SQLFreeHandle(SQL_HANDLE_DBC, d->hDbc);
1276	if (r != SQL_SUCCESS)
1277	qSqlWarning(QLatin1String("QDB2Driver::close: Unable to free connection handle"), d);
1278	d->hDbc = 0;
1279	}
1280
1281	if (d->hEnv) {
1282	r = SQLFreeHandle(SQL_HANDLE_ENV, d->hEnv);
1283	if (r != SQL_SUCCESS)
1284	qSqlWarning(QLatin1String("QDB2Driver::close: Unable to free environment handle"), d);
1285	d->hEnv = 0;
1286	}
1287	setOpen(false);
1288	setOpenError(false);
1289	}
1290
1291	QSqlResult *QDB2Driver::createResult() const
1292	{
1293	return new QDB2Result(this, d);
1294	}
1295
1296	QSqlRecord QDB2Driver::record(const QString& tableName) const
1297	{
1298	QSqlRecord fil;
1299	if (!isOpen())
1300	return fil;
1301
1302	SQLHANDLE hStmt;
1303	QString catalog, schema, table;
1304	qSplitTableQualifier(tableName, &catalog, &schema, &table);
1305	if (schema.isEmpty())
1306	schema = d->user;
1307
1308	if (isIdentifierEscaped(catalog, QSqlDriver::TableName))
1309	catalog = stripDelimiters(catalog, QSqlDriver::TableName);
1310	else
1311	catalog = catalog.toUpper();
1312
1313	if (isIdentifierEscaped(schema, QSqlDriver::TableName))
1314	schema = stripDelimiters(schema, QSqlDriver::TableName);
1315	else
1316	schema = schema.toUpper();
1317
1318	if (isIdentifierEscaped(table, QSqlDriver::TableName))
1319	table = stripDelimiters(table, QSqlDriver::TableName);
1320	else
1321	table = table.toUpper();
1322
1323	SQLRETURN r = SQLAllocHandle(SQL_HANDLE_STMT,
1324	d->hDbc,
1325	&hStmt);
1326	if (r != SQL_SUCCESS) {
1327	qSqlWarning(QLatin1String("QDB2Driver::record: Unable to allocate handle"), d);
1328	return fil;
1329	}
1330
1331	r = SQLSetStmtAttr(hStmt,
1332	SQL_ATTR_CURSOR_TYPE,
1333	(SQLPOINTER) SQL_CURSOR_FORWARD_ONLY,
1334	SQL_IS_UINTEGER);
1335
1336
1337	//Aside: szSchemaName and szTableName parameters of SQLColumns
1338	//are case sensitive search patterns, so no escaping is used.
1339	r = SQLColumns(hStmt,
1340	NULL,
1341	0,
1342	qToTChar(schema),
1343	schema.length(),
1344	qToTChar(table),
1345	table.length(),
1346	NULL,
1347	0);
1348
1349	if (r != SQL_SUCCESS)
1350	qSqlWarning(QLatin1String("QDB2Driver::record: Unable to execute column list"), d);
1351	r = SQLFetchScroll(hStmt,
1352	SQL_FETCH_NEXT,
1353	0);
1354	while (r == SQL_SUCCESS) {
1355	fil.append(qMakeFieldInfo(hStmt));
1356	r = SQLFetchScroll(hStmt,
1357	SQL_FETCH_NEXT,
1358	0);
1359	}
1360
1361	r = SQLFreeHandle(SQL_HANDLE_STMT, hStmt);
1362	if (r != SQL_SUCCESS)
1363	qSqlWarning(QLatin1String("QDB2Driver: Unable to free statement handle ")
1364	+ QString::number(r), d);
1365
1366	return fil;
1367	}
1368
1369	QStringList QDB2Driver::tables(QSql::TableType type) const
1370	{
1371	QStringList tl;
1372	if (!isOpen())
1373	return tl;
1374
1375	SQLHANDLE hStmt;
1376
1377	SQLRETURN r = SQLAllocHandle(SQL_HANDLE_STMT,
1378	d->hDbc,
1379	&hStmt);
1380	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
1381	qSqlWarning(QLatin1String("QDB2Driver::tables: Unable to allocate handle"), d);
1382	return tl;
1383	}
1384	r = SQLSetStmtAttr(hStmt,
1385	SQL_ATTR_CURSOR_TYPE,
1386	(SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,
1387	SQL_IS_UINTEGER);
1388
1389	QString tableType;
1390	if (type & QSql::Tables)
1391	tableType += QLatin1String("TABLE,");
1392	if (type & QSql::Views)
1393	tableType += QLatin1String("VIEW,");
1394	if (type & QSql::SystemTables)
1395	tableType += QLatin1String("SYSTEM TABLE,");
1396	if (tableType.isEmpty())
1397	return tl;
1398	tableType.chop(1);
1399
1400	r = SQLTables(hStmt,
1401	NULL,
1402	0,
1403	NULL,
1404	0,
1405	NULL,
1406	0,
1407	qToTChar(tableType),
1408	tableType.length());
1409
1410	if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)
1411	qSqlWarning(QLatin1String("QDB2Driver::tables: Unable to execute table list"), d);
1412	r = SQLFetchScroll(hStmt,
1413	SQL_FETCH_NEXT,
1414	0);
1415	while (r == SQL_SUCCESS) {
1416	bool isNull;
1417	QString fieldVal = qGetStringData(hStmt, 2, -1, isNull);
1418	QString userVal = qGetStringData(hStmt, 1, -1, isNull);
1419	QString user = d->user;
1420	if ( isIdentifierEscaped(user, QSqlDriver::TableName))
1421	user = stripDelimiters(user, QSqlDriver::TableName);
1422	else
1423	user = user.toUpper();
1424
1425	if (userVal != user)
1426	fieldVal = userVal + QLatin1Char('.') + fieldVal;
1427	tl.append(fieldVal);
1428	r = SQLFetchScroll(hStmt,
1429	SQL_FETCH_NEXT,
1430	0);
1431	}
1432
1433	r = SQLFreeHandle(SQL_HANDLE_STMT, hStmt);
1434	if (r != SQL_SUCCESS)
1435	qSqlWarning(QLatin1String("QDB2Driver::tables: Unable to free statement handle ")
1436	+ QString::number(r), d);
1437	return tl;
1438	}
1439
1440	QSqlIndex QDB2Driver::primaryIndex(const QString& tablename) const
1441	{
1442	QSqlIndex index(tablename);
1443	if (!isOpen())
1444	return index;
1445	QSqlRecord rec = record(tablename);
1446
1447	SQLHANDLE hStmt;
1448	SQLRETURN r = SQLAllocHandle(SQL_HANDLE_STMT,
1449	d->hDbc,
1450	&hStmt);
1451	if (r != SQL_SUCCESS) {
1452	qSqlWarning(QLatin1String("QDB2Driver::primaryIndex: Unable to list primary key"), d);
1453	return index;
1454	}
1455	QString catalog, schema, table;
1456	qSplitTableQualifier(tablename, &catalog, &schema, &table);
1457
1458	if (isIdentifierEscaped(catalog, QSqlDriver::TableName))
1459	catalog = stripDelimiters(catalog, QSqlDriver::TableName);
1460	else
1461	catalog = catalog.toUpper();
1462
1463	if (isIdentifierEscaped(schema, QSqlDriver::TableName))
1464	schema = stripDelimiters(schema, QSqlDriver::TableName);
1465	else
1466	schema = schema.toUpper();
1467
1468	if (isIdentifierEscaped(table, QSqlDriver::TableName))
1469	table = stripDelimiters(table, QSqlDriver::TableName);
1470	else
1471	table = table.toUpper();
1472
1473	r = SQLSetStmtAttr(hStmt,
1474	SQL_ATTR_CURSOR_TYPE,
1475	(SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,
1476	SQL_IS_UINTEGER);
1477
1478	r = SQLPrimaryKeys(hStmt,
1479	NULL,
1480	0,
1481	qToTChar(schema),
1482	schema.length(),
1483	qToTChar(table),
1484	table.length());
1485	r = SQLFetchScroll(hStmt,
1486	SQL_FETCH_NEXT,
1487	0);
1488
1489	bool isNull;
1490	QString cName, idxName;
1491	// Store all fields in a StringList because the driver can't detail fields in this FETCH loop
1492	while (r == SQL_SUCCESS) {
1493	cName = qGetStringData(hStmt, 3, -1, isNull); // column name
1494	idxName = qGetStringData(hStmt, 5, -1, isNull); // pk index name
1495	index.append(rec.field(cName));
1496	index.setName(idxName);
1497	r = SQLFetchScroll(hStmt,
1498	SQL_FETCH_NEXT,
1499	0);
1500	}
1501	r = SQLFreeHandle(SQL_HANDLE_STMT, hStmt);
1502	if (r!= SQL_SUCCESS)
1503	qSqlWarning(QLatin1String("QDB2Driver: Unable to free statement handle ")
1504	+ QString::number(r), d);
1505	return index;
1506	}
1507
1508	bool QDB2Driver::hasFeature(DriverFeature f) const
1509	{
1510	switch (f) {
1511	case QuerySize:
1512	case NamedPlaceholders:
1513	case BatchOperations:
1514	case LastInsertId:
1515	case SimpleLocking:
1516	case EventNotifications:
1517	return false;
1518	case BLOB:
1519	case Transactions:
1520	case MultipleResultSets:
1521	case PreparedQueries:
1522	case PositionalPlaceholders:
1523	case LowPrecisionNumbers:
1524	case FinishQuery:
1525	return true;
1526	case Unicode:
1527	return true;
1528	}
1529	return false;
1530	}
1531
1532	bool QDB2Driver::beginTransaction()
1533	{
1534	if (!isOpen()) {
1535	qWarning("QDB2Driver::beginTransaction: Database not open");
1536	return false;
1537	}
1538	return setAutoCommit(false);
1539	}
1540
1541	bool QDB2Driver::commitTransaction()
1542	{
1543	if (!isOpen()) {
1544	qWarning("QDB2Driver::commitTransaction: Database not open");
1545	return false;
1546	}
1547	SQLRETURN r = SQLEndTran(SQL_HANDLE_DBC,
1548	d->hDbc,
1549	SQL_COMMIT);
1550	if (r != SQL_SUCCESS) {
1551	setLastError(qMakeError(tr("Unable to commit transaction"),
1552	QSqlError::TransactionError, d));
1553	return false;
1554	}
1555	return setAutoCommit(true);
1556	}
1557
1558	bool QDB2Driver::rollbackTransaction()
1559	{
1560	if (!isOpen()) {
1561	qWarning("QDB2Driver::rollbackTransaction: Database not open");
1562	return false;
1563	}
1564	SQLRETURN r = SQLEndTran(SQL_HANDLE_DBC,
1565	d->hDbc,
1566	SQL_ROLLBACK);
1567	if (r != SQL_SUCCESS) {
1568	setLastError(qMakeError(tr("Unable to rollback transaction"),
1569	QSqlError::TransactionError, d));
1570	return false;
1571	}
1572	return setAutoCommit(true);
1573	}
1574
1575	bool QDB2Driver::setAutoCommit(bool autoCommit)
1576	{
1577	SQLUINTEGER ac = autoCommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
1578	SQLRETURN r = SQLSetConnectAttr(d->hDbc,
1579	SQL_ATTR_AUTOCOMMIT,
1580	(SQLPOINTER)ac,
1581	sizeof(ac));
1582	if (r != SQL_SUCCESS) {
1583	setLastError(qMakeError(tr("Unable to set autocommit"),
1584	QSqlError::TransactionError, d));
1585	return false;
1586	}
1587	return true;
1588	}
1589
1590	QString QDB2Driver::formatValue(const QSqlField &field, bool trimStrings) const
1591	{
1592	if (field.isNull())
1593	return QLatin1String("NULL");
1594
1595	switch (field.type()) {
1596	case QVariant::DateTime: {
1597	// Use an escape sequence for the datetime fields
1598	if (field.value().toDateTime().isValid()) {
1599	QDate dt = field.value().toDateTime().date();
1600	QTime tm = field.value().toDateTime().time();
1601	// Dateformat has to be "yyyy-MM-dd hh:mm:ss", with leading zeroes if month or day < 10
1602	return QLatin1Char('\'') + QString::number(dt.year()) + QLatin1Char('-')
1603	+ QString::number(dt.month()) + QLatin1Char('-')
1604	+ QString::number(dt.day()) + QLatin1Char('-')
1605	+ QString::number(tm.hour()) + QLatin1Char('.')
1606	+ QString::number(tm.minute()).rightJustified(2, QLatin1Char('0'), true)
1607	+ QLatin1Char('.')
1608	+ QString::number(tm.second()).rightJustified(2, QLatin1Char('0'), true)
1609	+ QLatin1Char('.')
1610	+ QString::number(tm.msec() * 1000).rightJustified(6, QLatin1Char('0'), true)
1611	+ QLatin1Char('\'');
1612	} else {
1613	return QLatin1String("NULL");
1614	}
1615	}
1616	case QVariant::ByteArray: {
1617	QByteArray ba = field.value().toByteArray();
1618	QString res = QString::fromLatin1("BLOB(X'");
1619	static const char hexchars[] = "0123456789abcdef";
1620	for (int i = 0; i < ba.size(); ++i) {
1621	uchar s = (uchar) ba[i];
1622	res += QLatin1Char(hexchars[s >> 4]);
1623	res += QLatin1Char(hexchars[s & 0x0f]);
1624	}
1625	res += QLatin1String("')");
1626	return res;
1627	}
1628	default:
1629	return QSqlDriver::formatValue(field, trimStrings);
1630	}
1631	}
1632
1633	QVariant QDB2Driver::handle() const
1634	{
1635	return QVariant(qRegisterMetaType<SQLHANDLE>("SQLHANDLE"), &d->hDbc);
1636	}
1637
1638	QString QDB2Driver::escapeIdentifier(const QString &identifier, IdentifierType) const
1639	{
1640	QString res = identifier;
1641	if(!identifier.isEmpty() && !identifier.startsWith(QLatin1Char('"')) && !identifier.endsWith(QLatin1Char('"')) ) {
1642	res.replace(QLatin1Char('"'), QLatin1String("\"\""));
1643	res.prepend(QLatin1Char('"')).append(QLatin1Char('"'));
1644	res.replace(QLatin1Char('.'), QLatin1String("\".\""));
1645	}
1646	return res;
1647	}
1648
1649	QT_END_NAMESPACE

Note: See TracBrowser for help on using the repository browser.

Download in other formats: