source: trunk/src/sql/drivers/ibase/qsql_ibase.cpp@ 648

Last change on this file since 648 was 561, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.6.1 sources.
File size: 60.2 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 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_ibase.h"
43#include <qcoreapplication.h>
44#include <qdatetime.h>
45#include <qvariant.h>
46#include <qsqlerror.h>
47#include <qsqlfield.h>
48#include <qsqlindex.h>
49#include <qsqlquery.h>
50#include <qlist.h>
51#include <qvector.h>
52#include <qtextcodec.h>
53#include <qmutex.h>
54#include <stdlib.h>
55#include <limits.h>
56#include <math.h>
57#include <qdebug.h>
58#include <QVarLengthArray>
59
60QT_BEGIN_NAMESPACE
61
62#define FBVERSION SQL_DIALECT_V6
63
64#ifndef SQLDA_CURRENT_VERSION
65#define SQLDA_CURRENT_VERSION SQLDA_VERSION1
66#endif
67
68enum { QIBaseChunkSize = SHRT_MAX / 2 };
69
70#if defined(FB_API_VER) && FB_API_VER >= 20
71static bool getIBaseError(QString& msg, const ISC_STATUS* status, ISC_LONG &sqlcode, QTextCodec *tc)
72#else
73static bool getIBaseError(QString& msg, ISC_STATUS* status, ISC_LONG &sqlcode, QTextCodec *tc)
74#endif
75{
76 if (status[0] != 1 || status[1] <= 0)
77 return false;
78
79 msg.clear();
80 sqlcode = isc_sqlcode(status);
81 char buf[512];
82#if defined(FB_API_VER) && FB_API_VER >= 20
83 while(fb_interpret(buf, 512, &status)) {
84#else
85 while(isc_interprete(buf, &status)) {
86#endif
87 if(!msg.isEmpty())
88 msg += QLatin1String(" - ");
89 if (tc)
90 msg += tc->toUnicode(buf);
91 else
92 msg += QString::fromUtf8(buf);
93 }
94 return true;
95}
96
97static void createDA(XSQLDA *&sqlda)
98{
99 sqlda = (XSQLDA *) malloc(XSQLDA_LENGTH(1));
100 if (sqlda == (XSQLDA*)0) return;
101 sqlda->sqln = 1;
102 sqlda->sqld = 0;
103 sqlda->version = SQLDA_CURRENT_VERSION;
104 sqlda->sqlvar[0].sqlind = 0;
105 sqlda->sqlvar[0].sqldata = 0;
106}
107
108static void enlargeDA(XSQLDA *&sqlda, int n)
109{
110 if (sqlda != (XSQLDA*)0)
111 free(sqlda);
112 sqlda = (XSQLDA *) malloc(XSQLDA_LENGTH(n));
113 if (sqlda == (XSQLDA*)0) return;
114 sqlda->sqln = n;
115 sqlda->version = SQLDA_CURRENT_VERSION;
116}
117
118static void initDA(XSQLDA *sqlda)
119{
120 for (int i = 0; i < sqlda->sqld; ++i) {
121 switch (sqlda->sqlvar[i].sqltype & ~1) {
122 case SQL_INT64:
123 case SQL_LONG:
124 case SQL_SHORT:
125 case SQL_FLOAT:
126 case SQL_DOUBLE:
127 case SQL_TIMESTAMP:
128 case SQL_TYPE_TIME:
129 case SQL_TYPE_DATE:
130 case SQL_TEXT:
131 case SQL_BLOB:
132 sqlda->sqlvar[i].sqldata = new char[sqlda->sqlvar[i].sqllen];
133 break;
134 case SQL_ARRAY:
135 sqlda->sqlvar[i].sqldata = new char[sizeof(ISC_QUAD)];
136 memset(sqlda->sqlvar[i].sqldata, 0, sizeof(ISC_QUAD));
137 break;
138 case SQL_VARYING:
139 sqlda->sqlvar[i].sqldata = new char[sqlda->sqlvar[i].sqllen + sizeof(short)];
140 break;
141 default:
142 // not supported - do not bind.
143 sqlda->sqlvar[i].sqldata = 0;
144 break;
145 }
146 if (sqlda->sqlvar[i].sqltype & 1) {
147 sqlda->sqlvar[i].sqlind = new short[1];
148 *(sqlda->sqlvar[i].sqlind) = 0;
149 } else {
150 sqlda->sqlvar[i].sqlind = 0;
151 }
152 }
153}
154
155static void delDA(XSQLDA *&sqlda)
156{
157 if (!sqlda)
158 return;
159 for (int i = 0; i < sqlda->sqld; ++i) {
160 delete [] sqlda->sqlvar[i].sqlind;
161 delete [] sqlda->sqlvar[i].sqldata;
162 }
163 free(sqlda);
164 sqlda = 0;
165}
166
167static QVariant::Type qIBaseTypeName(int iType, bool hasScale)
168{
169 switch (iType) {
170 case blr_varying:
171 case blr_varying2:
172 case blr_text:
173 case blr_cstring:
174 case blr_cstring2:
175 return QVariant::String;
176 case blr_sql_time:
177 return QVariant::Time;
178 case blr_sql_date:
179 return QVariant::Date;
180 case blr_timestamp:
181 return QVariant::DateTime;
182 case blr_blob:
183 return QVariant::ByteArray;
184 case blr_quad:
185 case blr_short:
186 case blr_long:
187 return (hasScale ? QVariant::Double : QVariant::Int);
188 case blr_int64:
189 return (hasScale ? QVariant::Double : QVariant::LongLong);
190 case blr_float:
191 case blr_d_float:
192 case blr_double:
193 return QVariant::Double;
194 }
195 qWarning("qIBaseTypeName: unknown datatype: %d", iType);
196 return QVariant::Invalid;
197}
198
199static QVariant::Type qIBaseTypeName2(int iType, bool hasScale)
200{
201 switch(iType & ~1) {
202 case SQL_VARYING:
203 case SQL_TEXT:
204 return QVariant::String;
205 case SQL_LONG:
206 case SQL_SHORT:
207 return (hasScale ? QVariant::Double : QVariant::Int);
208 case SQL_INT64:
209 return (hasScale ? QVariant::Double : QVariant::LongLong);
210 case SQL_FLOAT:
211 case SQL_DOUBLE:
212 return QVariant::Double;
213 case SQL_TIMESTAMP:
214 return QVariant::DateTime;
215 case SQL_TYPE_TIME:
216 return QVariant::Time;
217 case SQL_TYPE_DATE:
218 return QVariant::Date;
219 case SQL_ARRAY:
220 return QVariant::List;
221 case SQL_BLOB:
222 return QVariant::ByteArray;
223 default:
224 return QVariant::Invalid;
225 }
226}
227
228static ISC_TIMESTAMP toTimeStamp(const QDateTime &dt)
229{
230 static const QTime midnight(0, 0, 0, 0);
231 static const QDate basedate(1858, 11, 17);
232 ISC_TIMESTAMP ts;
233 ts.timestamp_time = midnight.msecsTo(dt.time()) * 10;
234 ts.timestamp_date = basedate.daysTo(dt.date());
235 return ts;
236}
237
238static QDateTime fromTimeStamp(char *buffer)
239{
240 static const QDate bd(1858, 11, 17);
241 QTime t;
242 QDate d;
243
244 // have to demangle the structure ourselves because isc_decode_time
245 // strips the msecs
246 t = t.addMSecs(int(((ISC_TIMESTAMP*)buffer)->timestamp_time / 10));
247 d = bd.addDays(int(((ISC_TIMESTAMP*)buffer)->timestamp_date));
248
249 return QDateTime(d, t);
250}
251
252static ISC_TIME toTime(const QTime &t)
253{
254 static const QTime midnight(0, 0, 0, 0);
255 return (ISC_TIME)midnight.msecsTo(t) * 10;
256}
257
258static QTime fromTime(char *buffer)
259{
260 QTime t;
261 // have to demangle the structure ourselves because isc_decode_time
262 // strips the msecs
263 t = t.addMSecs(int((*(ISC_TIME*)buffer) / 10));
264
265 return t;
266}
267
268static ISC_DATE toDate(const QDate &t)
269{
270 static const QDate basedate(1858, 11, 17);
271 ISC_DATE date;
272
273 date = basedate.daysTo(t);
274 return date;
275}
276
277static QDate fromDate(char *buffer)
278{
279 static const QDate bd(1858, 11, 17);
280 QDate d;
281
282 // have to demangle the structure ourselves because isc_decode_time
283 // strips the msecs
284 d = bd.addDays(int(((ISC_TIMESTAMP*)buffer)->timestamp_date));
285
286 return d;
287}
288
289static QByteArray encodeString(QTextCodec *tc, const QString &str)
290{
291 if (tc)
292 return tc->fromUnicode(str);
293 return str.toUtf8();
294}
295
296struct QIBaseEventBuffer {
297#if defined(FB_API_VER) && FB_API_VER >= 20
298 ISC_UCHAR *eventBuffer;
299 ISC_UCHAR *resultBuffer;
300#else
301 char *eventBuffer;
302 char *resultBuffer;
303#endif
304 ISC_LONG bufferLength;
305 ISC_LONG eventId;
306
307 enum QIBaseSubscriptionState { Starting, Subscribed, Finished };
308 QIBaseSubscriptionState subscriptionState;
309};
310
311class QIBaseDriverPrivate
312{
313public:
314 QIBaseDriverPrivate(QIBaseDriver *d) : q(d), ibase(0), trans(0), tc(0) {}
315
316 bool isError(const char *msg, QSqlError::ErrorType typ = QSqlError::UnknownError)
317 {
318 QString imsg;
319 ISC_LONG sqlcode;
320 if (!getIBaseError(imsg, status, sqlcode, tc))
321 return false;
322
323 q->setLastError(QSqlError(QCoreApplication::translate("QIBaseDriver", msg),
324 imsg, typ, int(sqlcode)));
325 return true;
326 }
327
328public:
329 QIBaseDriver* q;
330 isc_db_handle ibase;
331 isc_tr_handle trans;
332 QTextCodec *tc;
333 ISC_STATUS status[20];
334 QMap<QString, QIBaseEventBuffer*> eventBuffers;
335};
336
337typedef QMap<void *, QIBaseDriver *> QIBaseBufferDriverMap;
338Q_GLOBAL_STATIC(QIBaseBufferDriverMap, qBufferDriverMap)
339Q_GLOBAL_STATIC(QMutex, qMutex);
340
341static void qFreeEventBuffer(QIBaseEventBuffer* eBuffer)
342{
343 qMutex()->lock();
344 qBufferDriverMap()->remove(reinterpret_cast<void *>(eBuffer->resultBuffer));
345 qMutex()->unlock();
346 delete eBuffer;
347}
348
349class QIBaseResultPrivate
350{
351public:
352 QIBaseResultPrivate(QIBaseResult *d, const QIBaseDriver *ddb);
353 ~QIBaseResultPrivate() { cleanup(); }
354
355 void cleanup();
356 bool isError(const char *msg, QSqlError::ErrorType typ = QSqlError::UnknownError)
357 {
358 QString imsg;
359 ISC_LONG sqlcode;
360 if (!getIBaseError(imsg, status, sqlcode, tc))
361 return false;
362
363 q->setLastError(QSqlError(QCoreApplication::translate("QIBaseResult", msg),
364 imsg, typ, int(sqlcode)));
365 return true;
366 }
367
368 bool transaction();
369 bool commit();
370
371 bool isSelect();
372 QVariant fetchBlob(ISC_QUAD *bId);
373 bool writeBlob(int i, const QByteArray &ba);
374 QVariant fetchArray(int pos, ISC_QUAD *arr);
375 bool writeArray(int i, const QList<QVariant> &list);
376
377public:
378 QIBaseResult *q;
379 const QIBaseDriver *db;
380 ISC_STATUS status[20];
381 isc_tr_handle trans;
382 //indicator whether we have a local transaction or a transaction on driver level
383 bool localTransaction;
384 isc_stmt_handle stmt;
385 isc_db_handle ibase;
386 XSQLDA *sqlda; // output sqlda
387 XSQLDA *inda; // input parameters
388 int queryType;
389 QTextCodec *tc;
390};
391
392
393QIBaseResultPrivate::QIBaseResultPrivate(QIBaseResult *d, const QIBaseDriver *ddb):
394 q(d), db(ddb), trans(0), stmt(0), ibase(ddb->d->ibase), sqlda(0), inda(0), queryType(-1), tc(ddb->d->tc)
395{
396 localTransaction = (ddb->d->ibase == 0);
397}
398
399void QIBaseResultPrivate::cleanup()
400{
401 commit();
402 if (!localTransaction)
403 trans = 0;
404
405 if (stmt) {
406 isc_dsql_free_statement(status, &stmt, DSQL_drop);
407 stmt = 0;
408 }
409
410 delDA(sqlda);
411 delDA(inda);
412
413 queryType = -1;
414 q->cleanup();
415}
416
417bool QIBaseResultPrivate::writeBlob(int i, const QByteArray &ba)
418{
419 isc_blob_handle handle = 0;
420 ISC_QUAD *bId = (ISC_QUAD*)inda->sqlvar[i].sqldata;
421 isc_create_blob2(status, &ibase, &trans, &handle, bId, 0, 0);
422 if (!isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to create BLOB"),
423 QSqlError::StatementError)) {
424 int i = 0;
425 while (i < ba.size()) {
426 isc_put_segment(status, &handle, qMin(ba.size() - i, int(QIBaseChunkSize)),
427 const_cast<char*>(ba.data()) + i);
428 if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to write BLOB")))
429 return false;
430 i += qMin(ba.size() - i, int(QIBaseChunkSize));
431 }
432 }
433 isc_close_blob(status, &handle);
434 return true;
435}
436
437QVariant QIBaseResultPrivate::fetchBlob(ISC_QUAD *bId)
438{
439 isc_blob_handle handle = 0;
440
441 isc_open_blob2(status, &ibase, &trans, &handle, bId, 0, 0);
442 if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to open BLOB"),
443 QSqlError::StatementError))
444 return QVariant();
445
446 unsigned short len = 0;
447 QByteArray ba;
448 int chunkSize = QIBaseChunkSize;
449 ba.resize(chunkSize);
450 int read = 0;
451 while (isc_get_segment(status, &handle, &len, chunkSize, ba.data() + read) == 0 || status[1] == isc_segment) {
452 read += len;
453 ba.resize(read + chunkSize);
454 }
455 ba.resize(read);
456
457 bool isErr = (status[1] == isc_segstr_eof ? false :
458 isError(QT_TRANSLATE_NOOP("QIBaseResult",
459 "Unable to read BLOB"),
460 QSqlError::StatementError));
461
462 isc_close_blob(status, &handle);
463
464 if (isErr)
465 return QVariant();
466
467 ba.resize(read);
468 return ba;
469}
470
471template<typename T>
472static QList<QVariant> toList(char** buf, int count, T* = 0)
473{
474 QList<QVariant> res;
475 for (int i = 0; i < count; ++i) {
476 res.append(*(T*)(*buf));
477 *buf += sizeof(T);
478 }
479 return res;
480}
481/* char** ? seems like bad influence from oracle ... */
482template<>
483QList<QVariant> toList<long>(char** buf, int count, long*)
484{
485 QList<QVariant> res;
486 for (int i = 0; i < count; ++i) {
487 if (sizeof(int) == sizeof(long))
488 res.append(int((*(long*)(*buf))));
489 else
490 res.append((qint64)(*(long*)(*buf)));
491 *buf += sizeof(long);
492 }
493 return res;
494}
495
496static char* readArrayBuffer(QList<QVariant>& list, char *buffer, short curDim,
497 short* numElements, ISC_ARRAY_DESC *arrayDesc,
498 QTextCodec *tc)
499{
500 const short dim = arrayDesc->array_desc_dimensions - 1;
501 const unsigned char dataType = arrayDesc->array_desc_dtype;
502 QList<QVariant> valList;
503 unsigned short strLen = arrayDesc->array_desc_length;
504
505 if (curDim != dim) {
506 for(int i = 0; i < numElements[curDim]; ++i)
507 buffer = readArrayBuffer(list, buffer, curDim + 1, numElements,
508 arrayDesc, tc);
509 } else {
510 switch(dataType) {
511 case blr_varying:
512 case blr_varying2:
513 strLen += 2; // for the two terminating null values
514 case blr_text:
515 case blr_text2: {
516 int o;
517 for (int i = 0; i < numElements[dim]; ++i) {
518 for(o = 0; o < strLen && buffer[o]!=0; ++o )
519 ;
520
521 if (tc)
522 valList.append(tc->toUnicode(buffer, o));
523 else
524 valList.append(QString::fromUtf8(buffer, o));
525
526 buffer += strLen;
527 }
528 break; }
529 case blr_long:
530 valList = toList<long>(&buffer, numElements[dim], static_cast<long *>(0));
531 break;
532 case blr_short:
533 valList = toList<short>(&buffer, numElements[dim]);
534 break;
535 case blr_int64:
536 valList = toList<qint64>(&buffer, numElements[dim]);
537 break;
538 case blr_float:
539 valList = toList<float>(&buffer, numElements[dim]);
540 break;
541 case blr_double:
542 valList = toList<double>(&buffer, numElements[dim]);
543 break;
544 case blr_timestamp:
545 for(int i = 0; i < numElements[dim]; ++i) {
546 valList.append(fromTimeStamp(buffer));
547 buffer += sizeof(ISC_TIMESTAMP);
548 }
549 break;
550 case blr_sql_time:
551 for(int i = 0; i < numElements[dim]; ++i) {
552 valList.append(fromTime(buffer));
553 buffer += sizeof(ISC_TIME);
554 }
555 break;
556 case blr_sql_date:
557 for(int i = 0; i < numElements[dim]; ++i) {
558 valList.append(fromDate(buffer));
559 buffer += sizeof(ISC_DATE);
560 }
561 break;
562 }
563 }
564 if (dim > 0)
565 list.append(valList);
566 else
567 list += valList;
568 return buffer;
569}
570
571QVariant QIBaseResultPrivate::fetchArray(int pos, ISC_QUAD *arr)
572{
573 QList<QVariant> list;
574 ISC_ARRAY_DESC desc;
575
576 if (!arr)
577 return list;
578
579 QByteArray relname(sqlda->sqlvar[pos].relname, sqlda->sqlvar[pos].relname_length);
580 QByteArray sqlname(sqlda->sqlvar[pos].aliasname, sqlda->sqlvar[pos].aliasname_length);
581
582 isc_array_lookup_bounds(status, &ibase, &trans, relname.data(), sqlname.data(), &desc);
583 if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not find array"),
584 QSqlError::StatementError))
585 return list;
586
587
588 int arraySize = 1, subArraySize;
589 short dimensions = desc.array_desc_dimensions;
590 QVarLengthArray<short> numElements(dimensions);
591
592 for(int i = 0; i < dimensions; ++i) {
593 subArraySize = (desc.array_desc_bounds[i].array_bound_upper -
594 desc.array_desc_bounds[i].array_bound_lower + 1);
595 numElements[i] = subArraySize;
596 arraySize = subArraySize * arraySize;
597 }
598
599 ISC_LONG bufLen;
600 QByteArray ba;
601 /* varying arrayelements are stored with 2 trailing null bytes
602 indicating the length of the string
603 */
604 if (desc.array_desc_dtype == blr_varying
605 || desc.array_desc_dtype == blr_varying2) {
606 desc.array_desc_length += 2;
607 bufLen = desc.array_desc_length * arraySize * sizeof(short);
608 } else {
609 bufLen = desc.array_desc_length * arraySize;
610 }
611
612
613 ba.resize(int(bufLen));
614 isc_array_get_slice(status, &ibase, &trans, arr, &desc, ba.data(), &bufLen);
615 if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not get array data"),
616 QSqlError::StatementError))
617 return list;
618
619 readArrayBuffer(list, ba.data(), 0, numElements.data(), &desc, tc);
620
621 return QVariant(list);
622}
623
624template<typename T>
625static char* fillList(char *buffer, const QList<QVariant> &list, T* = 0)
626{
627 for (int i = 0; i < list.size(); ++i) {
628 T val;
629 val = qvariant_cast<T>(list.at(i));
630 memcpy(buffer, &val, sizeof(T));
631 buffer += sizeof(T);
632 }
633 return buffer;
634}
635
636template<>
637char* fillList<float>(char *buffer, const QList<QVariant> &list, float*)
638{
639 for (int i = 0; i < list.size(); ++i) {
640 double val;
641 float val2 = 0;
642 val = qvariant_cast<double>(list.at(i));
643 val2 = (float)val;
644 memcpy(buffer, &val2, sizeof(float));
645 buffer += sizeof(float);
646 }
647 return buffer;
648}
649
650static char* qFillBufferWithString(char *buffer, const QString& string,
651 short buflen, bool varying, bool array,
652 QTextCodec *tc)
653{
654 QByteArray str = encodeString(tc, string); // keep a copy of the string alive in this scope
655 if (varying) {
656 short tmpBuflen = buflen;
657 if (str.length() < buflen)
658 buflen = str.length();
659 if (array) { // interbase stores varying arrayelements different than normal varying elements
660 memcpy(buffer, str.data(), buflen);
661 memset(buffer + buflen, 0, tmpBuflen - buflen);
662 } else {
663 *(short*)buffer = buflen; // first two bytes is the length
664 memcpy(buffer + sizeof(short), str.data(), buflen);
665 }
666 buffer += tmpBuflen;
667 } else {
668 str = str.leftJustified(buflen, ' ', true);
669 memcpy(buffer, str.data(), buflen);
670 buffer += buflen;
671 }
672 return buffer;
673}
674
675static char* createArrayBuffer(char *buffer, const QList<QVariant> &list,
676 QVariant::Type type, short curDim, ISC_ARRAY_DESC *arrayDesc,
677 QString& error, QTextCodec *tc)
678{
679 int i;
680 ISC_ARRAY_BOUND *bounds = arrayDesc->array_desc_bounds;
681 short dim = arrayDesc->array_desc_dimensions - 1;
682
683 int elements = (bounds[curDim].array_bound_upper -
684 bounds[curDim].array_bound_lower + 1);
685
686 if (list.size() != elements) { // size mismatch
687 error = QLatin1String("Expected size: %1. Supplied size: %2");
688 error = QLatin1String("Array size mismatch. Fieldname: %1 ")
689 + error.arg(elements).arg(list.size());
690 return 0;
691 }
692
693 if (curDim != dim) {
694 for(i = 0; i < list.size(); ++i) {
695
696 if (list.at(i).type() != QVariant::List) { // dimensions mismatch
697 error = QLatin1String("Array dimensons mismatch. Fieldname: %1");
698 return 0;
699 }
700
701 buffer = createArrayBuffer(buffer, list.at(i).toList(), type, curDim + 1,
702 arrayDesc, error, tc);
703 if (!buffer)
704 return 0;
705 }
706 } else {
707 switch(type) {
708 case QVariant::Int:
709 case QVariant::UInt:
710 if (arrayDesc->array_desc_dtype == blr_short)
711 buffer = fillList<short>(buffer, list);
712 else
713 buffer = fillList<int>(buffer, list);
714 break;
715 case QVariant::Double:
716 if (arrayDesc->array_desc_dtype == blr_float)
717 buffer = fillList<float>(buffer, list, static_cast<float *>(0));
718 else
719 buffer = fillList<double>(buffer, list);
720 break;
721 case QVariant::LongLong:
722 buffer = fillList<qint64>(buffer, list);
723 break;
724 case QVariant::ULongLong:
725 buffer = fillList<quint64>(buffer, list);
726 break;
727 case QVariant::String:
728 for (i = 0; i < list.size(); ++i)
729 buffer = qFillBufferWithString(buffer, list.at(i).toString(),
730 arrayDesc->array_desc_length,
731 arrayDesc->array_desc_dtype == blr_varying,
732 true, tc);
733 break;
734 case QVariant::Date:
735 for (i = 0; i < list.size(); ++i) {
736 *((ISC_DATE*)buffer) = toDate(list.at(i).toDate());
737 buffer += sizeof(ISC_DATE);
738 }
739 break;
740 case QVariant::Time:
741 for (i = 0; i < list.size(); ++i) {
742 *((ISC_TIME*)buffer) = toTime(list.at(i).toTime());
743 buffer += sizeof(ISC_TIME);
744 }
745 break;
746
747 case QVariant::DateTime:
748 for (i = 0; i < list.size(); ++i) {
749 *((ISC_TIMESTAMP*)buffer) = toTimeStamp(list.at(i).toDateTime());
750 buffer += sizeof(ISC_TIMESTAMP);
751 }
752 break;
753 default:
754 break;
755 }
756 }
757 return buffer;
758}
759
760bool QIBaseResultPrivate::writeArray(int column, const QList<QVariant> &list)
761{
762 QString error;
763 ISC_QUAD *arrayId = (ISC_QUAD*) inda->sqlvar[column].sqldata;
764 ISC_ARRAY_DESC desc;
765
766 QByteArray relname(inda->sqlvar[column].relname, inda->sqlvar[column].relname_length);
767 QByteArray sqlname(inda->sqlvar[column].aliasname, inda->sqlvar[column].aliasname_length);
768
769 isc_array_lookup_bounds(status, &ibase, &trans, relname.data(), sqlname.data(), &desc);
770 if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not find array"),
771 QSqlError::StatementError))
772 return false;
773
774 short arraySize = 1;
775 ISC_LONG bufLen;
776 QList<QVariant> subList = list;
777
778 short dimensions = desc.array_desc_dimensions;
779 for(int i = 0; i < dimensions; ++i) {
780 arraySize *= (desc.array_desc_bounds[i].array_bound_upper -
781 desc.array_desc_bounds[i].array_bound_lower + 1);
782 }
783
784 /* varying arrayelements are stored with 2 trailing null bytes
785 indicating the length of the string
786 */
787 if (desc.array_desc_dtype == blr_varying ||
788 desc.array_desc_dtype == blr_varying2)
789 desc.array_desc_length += 2;
790
791 bufLen = desc.array_desc_length * arraySize;
792 QByteArray ba;
793 ba.resize(int(bufLen));
794
795 if (list.size() > arraySize) {
796 error = QLatin1String("Array size missmatch: size of %1 is %2, size of provided list is %3");
797 error = error.arg(QLatin1String(sqlname)).arg(arraySize).arg(list.size());
798 q->setLastError(QSqlError(error, QLatin1String(""), QSqlError::StatementError));
799 return false;
800 }
801
802 if (!createArrayBuffer(ba.data(), list,
803 qIBaseTypeName(desc.array_desc_dtype, inda->sqlvar[column].sqlscale < 0),
804 0, &desc, error, tc)) {
805 q->setLastError(QSqlError(error.arg(QLatin1String(sqlname)), QLatin1String(""),
806 QSqlError::StatementError));
807 return false;
808 }
809
810 /* readjust the buffer size*/
811 if (desc.array_desc_dtype == blr_varying
812 || desc.array_desc_dtype == blr_varying2)
813 desc.array_desc_length -= 2;
814
815 isc_array_put_slice(status, &ibase, &trans, arrayId, &desc, ba.data(), &bufLen);
816 return true;
817}
818
819
820bool QIBaseResultPrivate::isSelect()
821{
822 char acBuffer[9];
823 char qType = isc_info_sql_stmt_type;
824 isc_dsql_sql_info(status, &stmt, 1, &qType, sizeof(acBuffer), acBuffer);
825 if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not get query info"),
826 QSqlError::StatementError))
827 return false;
828 int iLength = isc_vax_integer(&acBuffer[1], 2);
829 queryType = isc_vax_integer(&acBuffer[3], iLength);
830 return (queryType == isc_info_sql_stmt_select || queryType == isc_info_sql_stmt_exec_procedure);
831}
832
833bool QIBaseResultPrivate::transaction()
834{
835 if (trans)
836 return true;
837 if (db->d->trans) {
838 localTransaction = false;
839 trans = db->d->trans;
840 return true;
841 }
842 localTransaction = true;
843
844 isc_start_transaction(status, &trans, 1, &ibase, 0, NULL);
845 if (isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not start transaction"),
846 QSqlError::TransactionError))
847 return false;
848
849 return true;
850}
851
852// does nothing if the transaction is on the
853// driver level
854bool QIBaseResultPrivate::commit()
855{
856 if (!trans)
857 return false;
858 // don't commit driver's transaction, the driver will do it for us
859 if (!localTransaction)
860 return true;
861
862 isc_commit_transaction(status, &trans);
863 trans = 0;
864 return !isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to commit transaction"),
865 QSqlError::TransactionError);
866}
867
868//////////
869
870QIBaseResult::QIBaseResult(const QIBaseDriver* db):
871 QSqlCachedResult(db)
872{
873 d = new QIBaseResultPrivate(this, db);
874}
875
876QIBaseResult::~QIBaseResult()
877{
878 delete d;
879}
880
881bool QIBaseResult::prepare(const QString& query)
882{
883// qDebug("prepare: %s", qPrintable(query));
884 if (!driver() || !driver()->isOpen() || driver()->isOpenError())
885 return false;
886 d->cleanup();
887 setActive(false);
888 setAt(QSql::BeforeFirstRow);
889
890 createDA(d->sqlda);
891 if (d->sqlda == (XSQLDA*)0) {
892 qWarning()<<"QIOBaseResult: createDA(): failed to allocate memory";
893 return false;
894 }
895
896 createDA(d->inda);
897 if (d->inda == (XSQLDA*)0){
898 qWarning()<<"QIOBaseResult: createDA(): failed to allocate memory";
899 return false;
900 }
901
902 if (!d->transaction())
903 return false;
904
905 isc_dsql_allocate_statement(d->status, &d->ibase, &d->stmt);
906 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not allocate statement"),
907 QSqlError::StatementError))
908 return false;
909 isc_dsql_prepare(d->status, &d->trans, &d->stmt, 0,
910 const_cast<char*>(encodeString(d->tc, query).constData()), FBVERSION, d->sqlda);
911 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not prepare statement"),
912 QSqlError::StatementError))
913 return false;
914
915 isc_dsql_describe_bind(d->status, &d->stmt, FBVERSION, d->inda);
916 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult",
917 "Could not describe input statement"), QSqlError::StatementError))
918 return false;
919 if (d->inda->sqld > d->inda->sqln) {
920 enlargeDA(d->inda, d->inda->sqld);
921 if (d->inda == (XSQLDA*)0) {
922 qWarning()<<"QIOBaseResult: enlargeDA(): failed to allocate memory";
923 return false;
924 }
925
926 isc_dsql_describe_bind(d->status, &d->stmt, FBVERSION, d->inda);
927 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult",
928 "Could not describe input statement"), QSqlError::StatementError))
929 return false;
930 }
931 initDA(d->inda);
932 if (d->sqlda->sqld > d->sqlda->sqln) {
933 // need more field descriptors
934 enlargeDA(d->sqlda, d->sqlda->sqld);
935 if (d->sqlda == (XSQLDA*)0) {
936 qWarning()<<"QIOBaseResult: enlargeDA(): failed to allocate memory";
937 return false;
938 }
939
940 isc_dsql_describe(d->status, &d->stmt, FBVERSION, d->sqlda);
941 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not describe statement"),
942 QSqlError::StatementError))
943 return false;
944 }
945 initDA(d->sqlda);
946
947 setSelect(d->isSelect());
948 if (!isSelect()) {
949 free(d->sqlda);
950 d->sqlda = 0;
951 }
952
953 return true;
954}
955
956
957bool QIBaseResult::exec()
958{
959 bool ok = true;
960
961 if (!d->trans)
962 d->transaction();
963
964 if (!driver() || !driver()->isOpen() || driver()->isOpenError())
965 return false;
966 setActive(false);
967 setAt(QSql::BeforeFirstRow);
968
969 if (d->inda) {
970 QVector<QVariant>& values = boundValues();
971 int i;
972 if (values.count() > d->inda->sqld) {
973 qWarning("QIBaseResult::exec: Parameter mismatch, expected %d, got %d parameters",
974 d->inda->sqld, values.count());
975 return false;
976 }
977 int para = 0;
978 for (i = 0; i < values.count(); ++i) {
979 para = i;
980 if (!d->inda->sqlvar[para].sqldata)
981 // skip unknown datatypes
982 continue;
983 const QVariant val(values[i]);
984 if (d->inda->sqlvar[para].sqltype & 1) {
985 if (val.isNull()) {
986 // set null indicator
987 *(d->inda->sqlvar[para].sqlind) = -1;
988 // and set the value to 0, otherwise it would count as empty string.
989 // it seems to be working with just setting sqlind to -1
990 //*((char*)d->inda->sqlvar[para].sqldata) = 0;
991 continue;
992 }
993 // a value of 0 means non-null.
994 *(d->inda->sqlvar[para].sqlind) = 0;
995 }
996 switch(d->inda->sqlvar[para].sqltype & ~1) {
997 case SQL_INT64:
998 if (d->inda->sqlvar[para].sqlscale < 0)
999 *((qint64*)d->inda->sqlvar[para].sqldata) =
1000 (qint64)floor(0.5 + val.toDouble() * pow(10.0, d->inda->sqlvar[para].sqlscale * -1));
1001 else
1002 *((qint64*)d->inda->sqlvar[para].sqldata) = val.toLongLong();
1003 break;
1004 case SQL_LONG:
1005 if (d->inda->sqlvar[para].sqlscale < 0)
1006 *((long*)d->inda->sqlvar[para].sqldata) =
1007 (long)floor(0.5 + val.toDouble() * pow(10.0, d->inda->sqlvar[para].sqlscale * -1));
1008 else
1009 *((long*)d->inda->sqlvar[para].sqldata) = (long)val.toLongLong();
1010 break;
1011 case SQL_SHORT:
1012 if (d->inda->sqlvar[para].sqlscale < 0)
1013 *((short*)d->inda->sqlvar[para].sqldata) =
1014 (short)floor(0.5 + val.toDouble() * pow(10.0, d->inda->sqlvar[para].sqlscale * -1));
1015 else
1016 *((short*)d->inda->sqlvar[para].sqldata) = (short)val.toInt();
1017 break;
1018 case SQL_FLOAT:
1019 *((float*)d->inda->sqlvar[para].sqldata) = (float)val.toDouble();
1020 break;
1021 case SQL_DOUBLE:
1022 *((double*)d->inda->sqlvar[para].sqldata) = val.toDouble();
1023 break;
1024 case SQL_TIMESTAMP:
1025 *((ISC_TIMESTAMP*)d->inda->sqlvar[para].sqldata) = toTimeStamp(val.toDateTime());
1026 break;
1027 case SQL_TYPE_TIME:
1028 *((ISC_TIME*)d->inda->sqlvar[para].sqldata) = toTime(val.toTime());
1029 break;
1030 case SQL_TYPE_DATE:
1031 *((ISC_DATE*)d->inda->sqlvar[para].sqldata) = toDate(val.toDate());
1032 break;
1033 case SQL_VARYING:
1034 case SQL_TEXT:
1035 qFillBufferWithString(d->inda->sqlvar[para].sqldata, val.toString(),
1036 d->inda->sqlvar[para].sqllen,
1037 (d->inda->sqlvar[para].sqltype & ~1) == SQL_VARYING, false, d->tc);
1038 break;
1039 case SQL_BLOB:
1040 ok &= d->writeBlob(para, val.toByteArray());
1041 break;
1042 case SQL_ARRAY:
1043 ok &= d->writeArray(para, val.toList());
1044 break;
1045 default:
1046 qWarning("QIBaseResult::exec: Unknown datatype %d",
1047 d->inda->sqlvar[para].sqltype & ~1);
1048 break;
1049 }
1050 }
1051 }
1052
1053 if (ok) {
1054 if (colCount() && d->queryType != isc_info_sql_stmt_exec_procedure) {
1055 isc_dsql_free_statement(d->status, &d->stmt, DSQL_close);
1056 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to close statement")))
1057 return false;
1058 cleanup();
1059 }
1060 if (d->queryType == isc_info_sql_stmt_exec_procedure)
1061 isc_dsql_execute2(d->status, &d->trans, &d->stmt, FBVERSION, d->inda, d->sqlda);
1062 else
1063 isc_dsql_execute(d->status, &d->trans, &d->stmt, FBVERSION, d->inda);
1064 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to execute query")))
1065 return false;
1066
1067 // Not all stored procedures necessarily return values.
1068 if (d->queryType == isc_info_sql_stmt_exec_procedure && d->sqlda && d->sqlda->sqld == 0)
1069 delDA(d->sqlda);
1070
1071 if (d->sqlda)
1072 init(d->sqlda->sqld);
1073
1074 if (!isSelect())
1075 d->commit();
1076
1077 setActive(true);
1078 return true;
1079 }
1080 return false;
1081}
1082
1083bool QIBaseResult::reset (const QString& query)
1084{
1085 if (!prepare(query))
1086 return false;
1087 return exec();
1088}
1089
1090bool QIBaseResult::gotoNext(QSqlCachedResult::ValueCache& row, int rowIdx)
1091{
1092 ISC_STATUS stat = 0;
1093
1094 // Stored Procedures are special - they populate our d->sqlda when executing,
1095 // so we don't have to call isc_dsql_fetch
1096 if (d->queryType == isc_info_sql_stmt_exec_procedure) {
1097 // the first "fetch" shall succeed, all consecutive ones will fail since
1098 // we only have one row to fetch for stored procedures
1099 if (rowIdx != 0)
1100 stat = 100;
1101 } else {
1102 stat = isc_dsql_fetch(d->status, &d->stmt, FBVERSION, d->sqlda);
1103 }
1104
1105 if (stat == 100) {
1106 // no more rows
1107 setAt(QSql::AfterLastRow);
1108 return false;
1109 }
1110 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not fetch next item"),
1111 QSqlError::StatementError))
1112 return false;
1113 if (rowIdx < 0) // not interested in actual values
1114 return true;
1115
1116 for (int i = 0; i < d->sqlda->sqld; ++i) {
1117 int idx = rowIdx + i;
1118 char *buf = d->sqlda->sqlvar[i].sqldata;
1119 int size = d->sqlda->sqlvar[i].sqllen;
1120 Q_ASSERT(buf);
1121
1122 if ((d->sqlda->sqlvar[i].sqltype & 1) && *d->sqlda->sqlvar[i].sqlind) {
1123 // null value
1124 QVariant v;
1125 v.convert(qIBaseTypeName2(d->sqlda->sqlvar[i].sqltype, d->sqlda->sqlvar[i].sqlscale < 0));
1126 if(v.type() == QVariant::Double) {
1127 switch(numericalPrecisionPolicy()) {
1128 case QSql::LowPrecisionInt32:
1129 v.convert(QVariant::Int);
1130 break;
1131 case QSql::LowPrecisionInt64:
1132 v.convert(QVariant::LongLong);
1133 break;
1134 case QSql::HighPrecision:
1135 v.convert(QVariant::String);
1136 break;
1137 }
1138 }
1139 row[idx] = v;
1140 continue;
1141 }
1142
1143 switch(d->sqlda->sqlvar[i].sqltype & ~1) {
1144 case SQL_VARYING:
1145 // pascal strings - a short with a length information followed by the data
1146 if (d->tc)
1147 row[idx] = d->tc->toUnicode(buf + sizeof(short), *(short*)buf);
1148 else
1149 row[idx] = QString::fromUtf8(buf + sizeof(short), *(short*)buf);
1150 break;
1151 case SQL_INT64:
1152 if (d->sqlda->sqlvar[i].sqlscale < 0)
1153 row[idx] = *(qint64*)buf * pow(10.0, d->sqlda->sqlvar[i].sqlscale);
1154 else
1155 row[idx] = QVariant(*(qint64*)buf);
1156 break;
1157 case SQL_LONG:
1158 if (d->sqlda->sqlvar[i].sqllen == 4)
1159 if (d->sqlda->sqlvar[i].sqlscale < 0)
1160 row[idx] = QVariant(*(qint32*)buf * pow(10.0, d->sqlda->sqlvar[i].sqlscale));
1161 else
1162 row[idx] = QVariant(*(qint32*)buf);
1163 else
1164 row[idx] = QVariant(*(qint64*)buf);
1165 break;
1166 case SQL_SHORT:
1167 if (d->sqlda->sqlvar[i].sqlscale < 0)
1168 row[idx] = QVariant(long((*(short*)buf)) * pow(10.0, d->sqlda->sqlvar[i].sqlscale));
1169 else
1170 row[idx] = QVariant(int((*(short*)buf)));
1171 break;
1172 case SQL_FLOAT:
1173 row[idx] = QVariant(double((*(float*)buf)));
1174 break;
1175 case SQL_DOUBLE:
1176 row[idx] = QVariant(*(double*)buf);
1177 break;
1178 case SQL_TIMESTAMP:
1179 row[idx] = fromTimeStamp(buf);
1180 break;
1181 case SQL_TYPE_TIME:
1182 row[idx] = fromTime(buf);
1183 break;
1184 case SQL_TYPE_DATE:
1185 row[idx] = fromDate(buf);
1186 break;
1187 case SQL_TEXT:
1188 if (d->tc)
1189 row[idx] = d->tc->toUnicode(buf, size);
1190 else
1191 row[idx] = QString::fromUtf8(buf, size);
1192 break;
1193 case SQL_BLOB:
1194 row[idx] = d->fetchBlob((ISC_QUAD*)buf);
1195 break;
1196 case SQL_ARRAY:
1197 row[idx] = d->fetchArray(i, (ISC_QUAD*)buf);
1198 break;
1199 default:
1200 // unknown type - don't even try to fetch
1201 row[idx] = QVariant();
1202 break;
1203 }
1204 if (d->sqlda->sqlvar[i].sqlscale < 0) {
1205 QVariant v = row[idx];
1206 switch(numericalPrecisionPolicy()) {
1207 case QSql::LowPrecisionInt32:
1208 if(v.convert(QVariant::Int))
1209 row[idx]=v;
1210 break;
1211 case QSql::LowPrecisionInt64:
1212 if(v.convert(QVariant::LongLong))
1213 row[idx]=v;
1214 break;
1215 case QSql::LowPrecisionDouble:
1216 if(v.convert(QVariant::Double))
1217 row[idx]=v;
1218 break;
1219 case QSql::HighPrecision:
1220 if(v.convert(QVariant::String))
1221 row[idx]=v;
1222 break;
1223 }
1224 }
1225 }
1226
1227 return true;
1228}
1229
1230int QIBaseResult::size()
1231{
1232 return -1;
1233
1234#if 0 /// ### FIXME
1235 static char sizeInfo[] = {isc_info_sql_records};
1236 char buf[64];
1237
1238 //qDebug() << sizeInfo;
1239 if (!isActive() || !isSelect())
1240 return -1;
1241
1242 char ct;
1243 short len;
1244 int val = 0;
1245// while(val == 0) {
1246 isc_dsql_sql_info(d->status, &d->stmt, sizeof(sizeInfo), sizeInfo, sizeof(buf), buf);
1247// isc_database_info(d->status, &d->ibase, sizeof(sizeInfo), sizeInfo, sizeof(buf), buf);
1248
1249 for(int i = 0; i < 66; ++i)
1250 qDebug() << QString::number(buf[i]);
1251
1252 for (char* c = buf + 3; *c != isc_info_end; /*nothing*/) {
1253 ct = *(c++);
1254 len = isc_vax_integer(c, 2);
1255 c += 2;
1256 val = isc_vax_integer(c, len);
1257 c += len;
1258 qDebug() << "size" << val;
1259 if (ct == isc_info_req_select_count)
1260 return val;
1261 }
1262 //qDebug() << "size -1";
1263 return -1;
1264
1265 unsigned int i, result_size;
1266 if (buf[0] == isc_info_sql_records) {
1267 i = 3;
1268 result_size = isc_vax_integer(&buf[1],2);
1269 while (buf[i] != isc_info_end && i < result_size) {
1270 len = (short)isc_vax_integer(&buf[i+1],2);
1271 if (buf[i] == isc_info_req_select_count)
1272 return (isc_vax_integer(&buf[i+3],len));
1273 i += len+3;
1274 }
1275 }
1276// }
1277 return -1;
1278#endif
1279}
1280
1281int QIBaseResult::numRowsAffected()
1282{
1283 static char acCountInfo[] = {isc_info_sql_records};
1284 char cCountType;
1285
1286 switch (d->queryType) {
1287 case isc_info_sql_stmt_select:
1288 cCountType = isc_info_req_select_count;
1289 break;
1290 case isc_info_sql_stmt_update:
1291 cCountType = isc_info_req_update_count;
1292 break;
1293 case isc_info_sql_stmt_delete:
1294 cCountType = isc_info_req_delete_count;
1295 break;
1296 case isc_info_sql_stmt_insert:
1297 cCountType = isc_info_req_insert_count;
1298 break;
1299 default:
1300 qWarning() << "numRowsAffected: Unknown statement type (" << d->queryType << ")";
1301 return -1;
1302 }
1303
1304 char acBuffer[33];
1305 int iResult = -1;
1306 isc_dsql_sql_info(d->status, &d->stmt, sizeof(acCountInfo), acCountInfo, sizeof(acBuffer), acBuffer);
1307 if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult", "Could not get statement info"),
1308 QSqlError::StatementError))
1309 return -1;
1310 for (char *pcBuf = acBuffer + 3; *pcBuf != isc_info_end; /*nothing*/) {
1311 char cType = *pcBuf++;
1312 short sLength = isc_vax_integer (pcBuf, 2);
1313 pcBuf += 2;
1314 int iValue = isc_vax_integer (pcBuf, sLength);
1315 pcBuf += sLength;
1316
1317 if (cType == cCountType) {
1318 iResult = iValue;
1319 break;
1320 }
1321 }
1322 return iResult;
1323}
1324
1325QSqlRecord QIBaseResult::record() const
1326{
1327 QSqlRecord rec;
1328 if (!isActive() || !d->sqlda)
1329 return rec;
1330
1331 XSQLVAR v;
1332 for (int i = 0; i < d->sqlda->sqld; ++i) {
1333 v = d->sqlda->sqlvar[i];
1334 QSqlField f(QString::fromLatin1(v.aliasname, v.aliasname_length).simplified(),
1335 qIBaseTypeName2(v.sqltype, v.sqlscale < 0));
1336 f.setLength(v.sqllen);
1337 f.setPrecision(qAbs(v.sqlscale));
1338 f.setRequiredStatus((v.sqltype & 1) == 0 ? QSqlField::Required : QSqlField::Optional);
1339 if(v.sqlscale < 0) {
1340 QSqlQuery q(new QIBaseResult(d->db));
1341 q.setForwardOnly(true);
1342 q.exec(QLatin1String("select b.RDB$FIELD_PRECISION, b.RDB$FIELD_SCALE, b.RDB$FIELD_LENGTH, a.RDB$NULL_FLAG "
1343 "FROM RDB$RELATION_FIELDS a, RDB$FIELDS b "
1344 "WHERE b.RDB$FIELD_NAME = a.RDB$FIELD_SOURCE "
1345 "AND a.RDB$RELATION_NAME = '") + QString::fromAscii(v.relname, v.relname_length).toUpper() + QLatin1String("' "
1346 "AND a.RDB$FIELD_NAME = '") + QString::fromAscii(v.sqlname, v.sqlname_length).toUpper() + QLatin1String("' "));
1347 if(q.first()) {
1348 if(v.sqlscale < 0) {
1349 f.setLength(q.value(0).toInt());
1350 f.setPrecision(qAbs(q.value(1).toInt()));
1351 } else {
1352 f.setLength(q.value(2).toInt());
1353 f.setPrecision(0);
1354 }
1355 f.setRequiredStatus(q.value(3).toBool() ? QSqlField::Required : QSqlField::Optional);
1356 }
1357 }
1358 f.setSqlType(v.sqltype);
1359 rec.append(f);
1360 }
1361 return rec;
1362}
1363
1364QVariant QIBaseResult::handle() const
1365{
1366 return QVariant(qRegisterMetaType<isc_stmt_handle>("isc_stmt_handle"), &d->stmt);
1367}
1368
1369/*********************************/
1370
1371QIBaseDriver::QIBaseDriver(QObject * parent)
1372 : QSqlDriver(parent)
1373{
1374 d = new QIBaseDriverPrivate(this);
1375}
1376
1377QIBaseDriver::QIBaseDriver(isc_db_handle connection, QObject *parent)
1378 : QSqlDriver(parent)
1379{
1380 d = new QIBaseDriverPrivate(this);
1381 d->ibase = connection;
1382 setOpen(true);
1383 setOpenError(false);
1384}
1385
1386QIBaseDriver::~QIBaseDriver()
1387{
1388 delete d;
1389}
1390
1391bool QIBaseDriver::hasFeature(DriverFeature f) const
1392{
1393 switch (f) {
1394 case QuerySize:
1395 case NamedPlaceholders:
1396 case LastInsertId:
1397 case BatchOperations:
1398 case SimpleLocking:
1399 case FinishQuery:
1400 case MultipleResultSets:
1401 return false;
1402 case Transactions:
1403 case PreparedQueries:
1404 case PositionalPlaceholders:
1405 case Unicode:
1406 case BLOB:
1407 case EventNotifications:
1408 case LowPrecisionNumbers:
1409 return true;
1410 }
1411 return false;
1412}
1413
1414bool QIBaseDriver::open(const QString & db,
1415 const QString & user,
1416 const QString & password,
1417 const QString & host,
1418 int /*port*/,
1419 const QString & connOpts)
1420{
1421 if (isOpen())
1422 close();
1423
1424 const QStringList opts(connOpts.split(QLatin1Char(';'), QString::SkipEmptyParts));
1425
1426 QString encString;
1427 QByteArray role;
1428 for (int i = 0; i < opts.count(); ++i) {
1429 QString tmp(opts.at(i).simplified());
1430 int idx;
1431 if ((idx = tmp.indexOf(QLatin1Char('='))) != -1) {
1432 QString val = tmp.mid(idx + 1).simplified();
1433 QString opt = tmp.left(idx).simplified();
1434 if (opt.toUpper() == QLatin1String("ISC_DPB_LC_CTYPE"))
1435 encString = val;
1436 else if (opt.toUpper() == QLatin1String("ISC_DPB_SQL_ROLE_NAME")) {
1437 role = val.toLocal8Bit();
1438 role.truncate(255);
1439 }
1440 }
1441 }
1442
1443 // Use UNICODE_FSS when no ISC_DPB_LC_CTYPE is provided
1444 if (encString.isEmpty())
1445 encString = QLatin1String("UNICODE_FSS");
1446 else {
1447 d->tc = QTextCodec::codecForName(encString.toLocal8Bit());
1448 if (!d->tc) {
1449 qWarning("Unsupported encoding: %s. Using UNICODE_FFS for ISC_DPB_LC_CTYPE.", encString.toLocal8Bit().constData());
1450 encString = QLatin1String("UNICODE_FSS"); // Fallback to UNICODE_FSS
1451 }
1452 }
1453
1454 QByteArray enc = encString.toLocal8Bit();
1455 QByteArray usr = user.toLocal8Bit();
1456 QByteArray pass = password.toLocal8Bit();
1457 enc.truncate(255);
1458 usr.truncate(255);
1459 pass.truncate(255);
1460
1461 QByteArray ba;
1462 ba.resize(usr.length() + pass.length() + enc.length() + role.length() + 6);
1463 int i = -1;
1464 ba[++i] = isc_dpb_version1;
1465 ba[++i] = isc_dpb_user_name;
1466 ba[++i] = usr.length();
1467 memcpy(ba.data() + ++i, usr.data(), usr.length());
1468 i += usr.length();
1469 ba[i] = isc_dpb_password;
1470 ba[++i] = pass.length();
1471 memcpy(ba.data() + ++i, pass.data(), pass.length());
1472 i += pass.length();
1473 ba[i] = isc_dpb_lc_ctype;
1474 ba[++i] = enc.length();
1475 memcpy(ba.data() + ++i, enc.data(), enc.length());
1476 i += enc.length();
1477
1478 if (!role.isEmpty()) {
1479 ba[i] = isc_dpb_sql_role_name;
1480 ba[++i] = role.length();
1481 memcpy(ba.data() + ++i, role.data(), role.length());
1482 i += role.length();
1483 }
1484
1485 QString ldb;
1486 if (!host.isEmpty())
1487 ldb += host + QLatin1Char(':');
1488 ldb += db;
1489 isc_attach_database(d->status, 0, const_cast<char *>(ldb.toLocal8Bit().constData()),
1490 &d->ibase, i, ba.data());
1491 if (d->isError(QT_TRANSLATE_NOOP("QIBaseDriver", "Error opening database"),
1492 QSqlError::ConnectionError)) {
1493 setOpenError(true);
1494 return false;
1495 }
1496
1497 setOpen(true);
1498 return true;
1499}
1500
1501void QIBaseDriver::close()
1502{
1503 if (isOpen()) {
1504
1505 if (d->eventBuffers.size()) {
1506 ISC_STATUS status[20];
1507 QMap<QString, QIBaseEventBuffer *>::const_iterator i;
1508 for (i = d->eventBuffers.constBegin(); i != d->eventBuffers.constEnd(); ++i) {
1509 QIBaseEventBuffer *eBuffer = i.value();
1510 eBuffer->subscriptionState = QIBaseEventBuffer::Finished;
1511 isc_cancel_events(status, &d->ibase, &eBuffer->eventId);
1512 qFreeEventBuffer(eBuffer);
1513 }
1514 d->eventBuffers.clear();
1515
1516#if defined(FB_API_VER)
1517 // Workaround for Firebird crash
1518 QTime timer;
1519 timer.start();
1520 while (timer.elapsed() < 500)
1521 QCoreApplication::processEvents();
1522#endif
1523 }
1524
1525 isc_detach_database(d->status, &d->ibase);
1526 d->ibase = 0;
1527 setOpen(false);
1528 setOpenError(false);
1529 }
1530}
1531
1532QSqlResult *QIBaseDriver::createResult() const
1533{
1534 return new QIBaseResult(this);
1535}
1536
1537bool QIBaseDriver::beginTransaction()
1538{
1539 if (!isOpen() || isOpenError())
1540 return false;
1541 if (d->trans)
1542 return false;
1543
1544 isc_start_transaction(d->status, &d->trans, 1, &d->ibase, 0, NULL);
1545 return !d->isError(QT_TRANSLATE_NOOP("QIBaseDriver", "Could not start transaction"),
1546 QSqlError::TransactionError);
1547}
1548
1549bool QIBaseDriver::commitTransaction()
1550{
1551 if (!isOpen() || isOpenError())
1552 return false;
1553 if (!d->trans)
1554 return false;
1555
1556 isc_commit_transaction(d->status, &d->trans);
1557 d->trans = 0;
1558 return !d->isError(QT_TRANSLATE_NOOP("QIBaseDriver", "Unable to commit transaction"),
1559 QSqlError::TransactionError);
1560}
1561
1562bool QIBaseDriver::rollbackTransaction()
1563{
1564 if (!isOpen() || isOpenError())
1565 return false;
1566 if (!d->trans)
1567 return false;
1568
1569 isc_rollback_transaction(d->status, &d->trans);
1570 d->trans = 0;
1571 return !d->isError(QT_TRANSLATE_NOOP("QIBaseDriver", "Unable to rollback transaction"),
1572 QSqlError::TransactionError);
1573}
1574
1575QStringList QIBaseDriver::tables(QSql::TableType type) const
1576{
1577 QStringList res;
1578 if (!isOpen())
1579 return res;
1580
1581 QString typeFilter;
1582
1583 if (type == QSql::SystemTables) {
1584 typeFilter += QLatin1String("RDB$SYSTEM_FLAG != 0");
1585 } else if (type == (QSql::SystemTables | QSql::Views)) {
1586 typeFilter += QLatin1String("RDB$SYSTEM_FLAG != 0 OR RDB$VIEW_BLR NOT NULL");
1587 } else {
1588 if (!(type & QSql::SystemTables))
1589 typeFilter += QLatin1String("RDB$SYSTEM_FLAG = 0 AND ");
1590 if (!(type & QSql::Views))
1591 typeFilter += QLatin1String("RDB$VIEW_BLR IS NULL AND ");
1592 if (!(type & QSql::Tables))
1593 typeFilter += QLatin1String("RDB$VIEW_BLR IS NOT NULL AND ");
1594 if (!typeFilter.isEmpty())
1595 typeFilter.chop(5);
1596 }
1597 if (!typeFilter.isEmpty())
1598 typeFilter.prepend(QLatin1String("where "));
1599
1600 QSqlQuery q(createResult());
1601 q.setForwardOnly(true);
1602 if (!q.exec(QLatin1String("select rdb$relation_name from rdb$relations ") + typeFilter))
1603 return res;
1604 while(q.next())
1605 res << q.value(0).toString().simplified();
1606
1607 return res;
1608}
1609
1610QSqlRecord QIBaseDriver::record(const QString& tablename) const
1611{
1612 QSqlRecord rec;
1613 if (!isOpen())
1614 return rec;
1615
1616 QSqlQuery q(createResult());
1617 q.setForwardOnly(true);
1618 QString table = tablename;
1619 if (isIdentifierEscaped(table, QSqlDriver::TableName))
1620 table = stripDelimiters(table, QSqlDriver::TableName);
1621 else
1622 table = table.toUpper();
1623 q.exec(QLatin1String("SELECT a.RDB$FIELD_NAME, b.RDB$FIELD_TYPE, b.RDB$FIELD_LENGTH, "
1624 "b.RDB$FIELD_SCALE, b.RDB$FIELD_PRECISION, a.RDB$NULL_FLAG "
1625 "FROM RDB$RELATION_FIELDS a, RDB$FIELDS b "
1626 "WHERE b.RDB$FIELD_NAME = a.RDB$FIELD_SOURCE "
1627 "AND a.RDB$RELATION_NAME = '") + table + QLatin1String("' "
1628 "ORDER BY a.RDB$FIELD_POSITION"));
1629
1630 while (q.next()) {
1631 int type = q.value(1).toInt();
1632 bool hasScale = q.value(3).toInt() < 0;
1633 QSqlField f(q.value(0).toString().simplified(), qIBaseTypeName(type, hasScale));
1634 if(hasScale) {
1635 f.setLength(q.value(4).toInt());
1636 f.setPrecision(qAbs(q.value(3).toInt()));
1637 } else {
1638 f.setLength(q.value(2).toInt());
1639 f.setPrecision(0);
1640 }
1641 f.setRequired(q.value(5).toInt() > 0 ? true : false);
1642 f.setSqlType(type);
1643
1644 rec.append(f);
1645 }
1646 return rec;
1647}
1648
1649QSqlIndex QIBaseDriver::primaryIndex(const QString &table) const
1650{
1651 QSqlIndex index(table);
1652 if (!isOpen())
1653 return index;
1654
1655 QString tablename = table;
1656 if (isIdentifierEscaped(tablename, QSqlDriver::TableName))
1657 tablename = stripDelimiters(tablename, QSqlDriver::TableName);
1658 else
1659 tablename = tablename.toUpper();
1660
1661 QSqlQuery q(createResult());
1662 q.setForwardOnly(true);
1663 q.exec(QLatin1String("SELECT a.RDB$INDEX_NAME, b.RDB$FIELD_NAME, d.RDB$FIELD_TYPE, d.RDB$FIELD_SCALE "
1664 "FROM RDB$RELATION_CONSTRAINTS a, RDB$INDEX_SEGMENTS b, RDB$RELATION_FIELDS c, RDB$FIELDS d "
1665 "WHERE a.RDB$CONSTRAINT_TYPE = 'PRIMARY KEY' "
1666 "AND a.RDB$RELATION_NAME = '") + tablename +
1667 QLatin1String(" 'AND a.RDB$INDEX_NAME = b.RDB$INDEX_NAME "
1668 "AND c.RDB$RELATION_NAME = a.RDB$RELATION_NAME "
1669 "AND c.RDB$FIELD_NAME = b.RDB$FIELD_NAME "
1670 "AND d.RDB$FIELD_NAME = c.RDB$FIELD_SOURCE "
1671 "ORDER BY b.RDB$FIELD_POSITION"));
1672
1673 while (q.next()) {
1674 QSqlField field(q.value(1).toString().simplified(), qIBaseTypeName(q.value(2).toInt(), q.value(3).toInt() < 0));
1675 index.append(field); //TODO: asc? desc?
1676 index.setName(q.value(0).toString());
1677 }
1678
1679 return index;
1680}
1681
1682QString QIBaseDriver::formatValue(const QSqlField &field, bool trimStrings) const
1683{
1684 switch (field.type()) {
1685 case QVariant::DateTime: {
1686 QDateTime datetime = field.value().toDateTime();
1687 if (datetime.isValid())
1688 return QLatin1Char('\'') + QString::number(datetime.date().year()) + QLatin1Char('-') +
1689 QString::number(datetime.date().month()) + QLatin1Char('-') +
1690 QString::number(datetime.date().day()) + QLatin1Char(' ') +
1691 QString::number(datetime.time().hour()) + QLatin1Char(':') +
1692 QString::number(datetime.time().minute()) + QLatin1Char(':') +
1693 QString::number(datetime.time().second()) + QLatin1Char('.') +
1694 QString::number(datetime.time().msec()).rightJustified(3, QLatin1Char('0'), true) +
1695 QLatin1Char('\'');
1696 else
1697 return QLatin1String("NULL");
1698 }
1699 case QVariant::Time: {
1700 QTime time = field.value().toTime();
1701 if (time.isValid())
1702 return QLatin1Char('\'') + QString::number(time.hour()) + QLatin1Char(':') +
1703 QString::number(time.minute()) + QLatin1Char(':') +
1704 QString::number(time.second()) + QLatin1Char('.') +
1705 QString::number(time.msec()).rightJustified(3, QLatin1Char('0'), true) +
1706 QLatin1Char('\'');
1707 else
1708 return QLatin1String("NULL");
1709 }
1710 case QVariant::Date: {
1711 QDate date = field.value().toDate();
1712 if (date.isValid())
1713 return QLatin1Char('\'') + QString::number(date.year()) + QLatin1Char('-') +
1714 QString::number(date.month()) + QLatin1Char('-') +
1715 QString::number(date.day()) + QLatin1Char('\'');
1716 else
1717 return QLatin1String("NULL");
1718 }
1719 default:
1720 return QSqlDriver::formatValue(field, trimStrings);
1721 }
1722}
1723
1724QVariant QIBaseDriver::handle() const
1725{
1726 return QVariant(qRegisterMetaType<isc_db_handle>("isc_db_handle"), &d->ibase);
1727}
1728
1729#if defined(FB_API_VER) && FB_API_VER >= 20
1730static ISC_EVENT_CALLBACK qEventCallback(char *result, ISC_USHORT length, const ISC_UCHAR *updated)
1731#else
1732static isc_callback qEventCallback(char *result, short length, char *updated)
1733#endif
1734{
1735 if (!updated)
1736 return 0;
1737
1738
1739 memcpy(result, updated, length);
1740 qMutex()->lock();
1741 QIBaseDriver *driver = qBufferDriverMap()->value(result);
1742 qMutex()->unlock();
1743
1744 // We use an asynchronous call (i.e., queued connection) because the event callback
1745 // is executed in a different thread than the one in which the driver lives.
1746 if (driver)
1747 QMetaObject::invokeMethod(driver, "qHandleEventNotification", Qt::QueuedConnection, Q_ARG(void *, reinterpret_cast<void *>(result)));
1748
1749 return 0;
1750}
1751
1752bool QIBaseDriver::subscribeToNotificationImplementation(const QString &name)
1753{
1754 if (!isOpen()) {
1755 qWarning("QIBaseDriver::subscribeFromNotificationImplementation: database not open.");
1756 return false;
1757 }
1758
1759 if (d->eventBuffers.contains(name)) {
1760 qWarning("QIBaseDriver::subscribeToNotificationImplementation: already subscribing to '%s'.",
1761 qPrintable(name));
1762 return false;
1763 }
1764
1765 QIBaseEventBuffer *eBuffer = new QIBaseEventBuffer;
1766 eBuffer->subscriptionState = QIBaseEventBuffer::Starting;
1767 eBuffer->bufferLength = isc_event_block(&eBuffer->eventBuffer,
1768 &eBuffer->resultBuffer,
1769 1,
1770 name.toLocal8Bit().constData());
1771
1772 qMutex()->lock();
1773 qBufferDriverMap()->insert(eBuffer->resultBuffer, this);
1774 qMutex()->unlock();
1775
1776 d->eventBuffers.insert(name, eBuffer);
1777
1778 ISC_STATUS status[20];
1779 isc_que_events(status,
1780 &d->ibase,
1781 &eBuffer->eventId,
1782 eBuffer->bufferLength,
1783 eBuffer->eventBuffer,
1784#if defined (FB_API_VER) && FB_API_VER >= 20
1785 (ISC_EVENT_CALLBACK)qEventCallback,
1786#else
1787 (isc_callback)qEventCallback,
1788#endif
1789 eBuffer->resultBuffer);
1790
1791 if (status[0] == 1 && status[1]) {
1792 setLastError(QSqlError(QString::fromLatin1("Could not subscribe to event notifications for %1.").arg(name)));
1793 d->eventBuffers.remove(name);
1794 qFreeEventBuffer(eBuffer);
1795 return false;
1796 }
1797
1798 return true;
1799}
1800
1801bool QIBaseDriver::unsubscribeFromNotificationImplementation(const QString &name)
1802{
1803 if (!isOpen()) {
1804 qWarning("QIBaseDriver::unsubscribeFromNotificationImplementation: database not open.");
1805 return false;
1806 }
1807
1808 if (!d->eventBuffers.contains(name)) {
1809 qWarning("QIBaseDriver::QIBaseSubscriptionState not subscribed to '%s'.",
1810 qPrintable(name));
1811 return false;
1812 }
1813
1814 QIBaseEventBuffer *eBuffer = d->eventBuffers.value(name);
1815 ISC_STATUS status[20];
1816 eBuffer->subscriptionState = QIBaseEventBuffer::Finished;
1817 isc_cancel_events(status, &d->ibase, &eBuffer->eventId);
1818
1819 if (status[0] == 1 && status[1]) {
1820 setLastError(QSqlError(QString::fromLatin1("Could not unsubscribe from event notifications for %1.").arg(name)));
1821 return false;
1822 }
1823
1824 d->eventBuffers.remove(name);
1825 qFreeEventBuffer(eBuffer);
1826
1827 return true;
1828}
1829
1830QStringList QIBaseDriver::subscribedToNotificationsImplementation() const
1831{
1832 return QStringList(d->eventBuffers.keys());
1833}
1834
1835void QIBaseDriver::qHandleEventNotification(void *updatedResultBuffer)
1836{
1837 QMap<QString, QIBaseEventBuffer *>::const_iterator i;
1838 for (i = d->eventBuffers.constBegin(); i != d->eventBuffers.constEnd(); ++i) {
1839 QIBaseEventBuffer* eBuffer = i.value();
1840 if (reinterpret_cast<void *>(eBuffer->resultBuffer) != updatedResultBuffer)
1841 continue;
1842
1843 ISC_ULONG counts[20];
1844 memset(counts, 0, sizeof(counts));
1845 isc_event_counts(counts, eBuffer->bufferLength, eBuffer->eventBuffer, eBuffer->resultBuffer);
1846 if (counts[0]) {
1847
1848 if (eBuffer->subscriptionState == QIBaseEventBuffer::Subscribed)
1849 emit notification(i.key());
1850 else if (eBuffer->subscriptionState == QIBaseEventBuffer::Starting)
1851 eBuffer->subscriptionState = QIBaseEventBuffer::Subscribed;
1852
1853 ISC_STATUS status[20];
1854 isc_que_events(status,
1855 &d->ibase,
1856 &eBuffer->eventId,
1857 eBuffer->bufferLength,
1858 eBuffer->eventBuffer,
1859#if defined (FB_API_VER) && FB_API_VER >= 20
1860 (ISC_EVENT_CALLBACK)qEventCallback,
1861#else
1862 (isc_callback)qEventCallback,
1863#endif
1864 eBuffer->resultBuffer);
1865 if (status[0] == 1 && status[1]) {
1866 qCritical("QIBaseDriver::qHandleEventNotification: could not resubscribe to '%s'",
1867 qPrintable(i.key()));
1868 }
1869
1870 return;
1871 }
1872 }
1873}
1874
1875QString QIBaseDriver::escapeIdentifier(const QString &identifier, IdentifierType) const
1876{
1877 QString res = identifier;
1878 if(!identifier.isEmpty() && !identifier.startsWith(QLatin1Char('"')) && !identifier.endsWith(QLatin1Char('"')) ) {
1879 res.replace(QLatin1Char('"'), QLatin1String("\"\""));
1880 res.prepend(QLatin1Char('"')).append(QLatin1Char('"'));
1881 res.replace(QLatin1Char('.'), QLatin1String("\".\""));
1882 }
1883 return res;
1884}
1885
1886QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.