1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtSql module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    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 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    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 

    60 QT_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 

    68 enum { QIBaseChunkSize = SHRT_MAX / 2 };

    69 

    70 #if defined(FB_API_VER) && FB_API_VER >= 20

    71 static bool getIBaseError(QString& msg, const ISC_STATUS* status, ISC_LONG &sqlcode, QTextCodec *tc)

    72 #else

    73 static 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 

    97 static 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 

   108 static 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 

   118 static 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 

   155 static 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 

   167 static 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 

   199 static 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 

   228 static 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 

   238 static 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 

   252 static 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 

   258 static 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 

   268 static 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 

   277 static 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 

   289 static QByteArray encodeString(QTextCodec *tc, const QString &str)

   290 {

   291     if (tc)

   292         return tc->fromUnicode(str);

   293     return str.toUtf8();

   294 }

   295 

   296 struct 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 

   311 class QIBaseDriverPrivate

   312 {

   313 public:

   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 

   328 public:

   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 

   337 typedef QMap<void *, QIBaseDriver *> QIBaseBufferDriverMap;

   338 Q_GLOBAL_STATIC(QIBaseBufferDriverMap, qBufferDriverMap)

   339 Q_GLOBAL_STATIC(QMutex, qMutex);

   340 

   341 static void qFreeEventBuffer(QIBaseEventBuffer* eBuffer)

   342 {

   343     qMutex()->lock();

   344     qBufferDriverMap()->remove(reinterpret_cast<void *>(eBuffer->resultBuffer));

   345     qMutex()->unlock();

   346     delete eBuffer;

   347 }

   348 

   349 class QIBaseResultPrivate

   350 {

   351 public:

   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 

   377 public:

   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 

   393 QIBaseResultPrivate::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 

   399 void 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 

   417 bool 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 

   437 QVariant 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 

   471 template<typename T>

   472 static 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 ... */

   482 template<>

   483 QList<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 

   496 static 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 

   571 QVariant 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 

   624 template<typename T>

   625 static 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 

   636 template<>

   637 char* 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 

   650 static 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 

   675 static 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 

   760 bool 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 

   820 bool 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 

   833 bool 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

   854 bool 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 

   870 QIBaseResult::QIBaseResult(const QIBaseDriver* db):

   871     QSqlCachedResult(db)

   872 {

   873     d = new QIBaseResultPrivate(this, db);

   874 }

   875 

   876 QIBaseResult::~QIBaseResult()

   877 {

   878     delete d;

   879 }

   880 

   881 bool 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 

   957 bool 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 

  1083 bool QIBaseResult::reset (const QString& query)

  1084 {

  1085     if (!prepare(query))

  1086         return false;

  1087     return exec();

  1088 }

  1089 

  1090 bool 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: