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_oci.h"

    43 

    44 #include <qcoreapplication.h>

    45 #include <qvariant.h>

    46 #include <qdatetime.h>

    47 #include <qmetatype.h>

    48 #include <qregexp.h>

    49 #include <qshareddata.h>

    50 #include <qsqlerror.h>

    51 #include <qsqlfield.h>

    52 #include <qsqlindex.h>

    53 #include <qsqlquery.h>

    54 #include <qstringlist.h>

    55 #include <qvarlengtharray.h>

    56 #include <qvector.h>

    57 #include <qdebug.h>

    58 

    59 #include <oci.h>

    60 #ifdef max

    61 #undef max

    62 #endif

    63 #ifdef min

    64 #undef min

    65 #endif

    66 

    67 #include <stdlib.h>

    68 

    69 #define QOCI_DYNAMIC_CHUNK_SIZE 65535

    70 #define QOCI_PREFETCH_MEM  10240

    71 

    72 // setting this define will allow using a query from a different

    73 // thread than its database connection.

    74 // warning - this is not fully tested and can lead to race conditions

    75 #define QOCI_THREADED

    76 

    77 //#define QOCI_DEBUG

    78 

    79 Q_DECLARE_METATYPE(OCIEnv*)

    80 Q_DECLARE_METATYPE(OCIStmt*)

    81 

    82 QT_BEGIN_NAMESPACE

    83 

    84 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN

    85 enum { QOCIEncoding = 2002 }; // AL16UTF16LE

    86 #else

    87 enum { QOCIEncoding = 2000 }; // AL16UTF16

    88 #endif

    89 

    90 static const ub1 CSID_NCHAR = SQLCS_NCHAR;

    91 static const ub2 qOraCharset = OCI_UCS2ID;

    92 

    93 typedef QVarLengthArray<sb2, 32> IndicatorArray;

    94 typedef QVarLengthArray<ub2, 32> SizeArray;

    95 

    96 static QByteArray qMakeOraDate(const QDateTime& dt);

    97 static QDateTime qMakeDate(const char* oraDate);

    98 static QString qOraWarn(OCIError *err, int *errorCode = 0);

    99 #ifndef Q_CC_SUN

   100 static // for some reason, Sun CC can't use qOraWarning when it's declared static

   101 #endif

   102 void qOraWarning(const char* msg, OCIError *err);

   103 static QSqlError qMakeError(const QString& errString, QSqlError::ErrorType type, OCIError *err);

   104 

   105 class QOCIRowId: public QSharedData

   106 {

   107 public:

   108     QOCIRowId(OCIEnv *env);

   109     ~QOCIRowId();

   110 

   111     OCIRowid *id;

   112 

   113 private:

   114     QOCIRowId(const QOCIRowId &other): QSharedData(other) { Q_ASSERT(false); }

   115 };

   116 

   117 QOCIRowId::QOCIRowId(OCIEnv *env)

   118     : id(0)

   119 {

   120     OCIDescriptorAlloc (env, reinterpret_cast<dvoid **>(&id),

   121                         OCI_DTYPE_ROWID, 0, 0);

   122 }

   123 

   124 QOCIRowId::~QOCIRowId()

   125 {

   126     if (id)

   127         OCIDescriptorFree(id, OCI_DTYPE_ROWID);

   128 }

   129 

   130 typedef QSharedDataPointer<QOCIRowId> QOCIRowIdPointer;

   131 QT_BEGIN_INCLUDE_NAMESPACE

   132 Q_DECLARE_METATYPE(QOCIRowIdPointer)

   133 QT_END_INCLUDE_NAMESPACE

   134 

   135 class QOCICols;

   136 

   137 struct QOCIResultPrivate

   138 {

   139     QOCIResultPrivate(QOCIResult *result, const QOCIDriverPrivate *driver);

   140     ~QOCIResultPrivate();

   141 

   142     QOCICols *cols;

   143     QOCIResult *q;

   144     OCIEnv *env;

   145     OCIError *err;

   146     OCISvcCtx *&svc;

   147     OCIStmt *sql;

   148     bool transaction;

   149     int serverVersion;

   150     int prefetchRows, prefetchMem;

   151 

   152     void setCharset(OCIBind* hbnd);

   153     void setStatementAttributes();

   154     int bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, int pos,

   155                   const QVariant &val, dvoid *indPtr, ub2 *tmpSize, QList<QByteArray> &tmpStorage);

   156     int bindValues(QVector<QVariant> &values, IndicatorArray &indicators, SizeArray &tmpSizes,

   157                    QList<QByteArray> &tmpStorage);

   158     void outValues(QVector<QVariant> &values, IndicatorArray &indicators,

   159                    QList<QByteArray> &tmpStorage);

   160     inline bool isOutValue(int i) const

   161     { return q->bindValueType(i) & QSql::Out; }

   162     inline bool isBinaryValue(int i) const

   163     { return q->bindValueType(i) & QSql::Binary; }

   164 };

   165 

   166 void QOCIResultPrivate::setStatementAttributes()

   167 {

   168     Q_ASSERT(sql);

   169 

   170     int r = 0;

   171 

   172     if (prefetchRows >= 0) {

   173         r = OCIAttrSet(sql,

   174                        OCI_HTYPE_STMT,

   175                        &prefetchRows,

   176                        0,

   177                        OCI_ATTR_PREFETCH_ROWS,

   178                        err);

   179         if (r != 0)

   180             qOraWarning("QOCIResultPrivate::setStatementAttributes:"

   181                         " Couldn't set OCI_ATTR_PREFETCH_ROWS: ", err);

   182     }

   183     if (prefetchMem >= 0) {

   184         r = OCIAttrSet(sql,

   185                        OCI_HTYPE_STMT,

   186                        &prefetchMem,

   187                        0,

   188                        OCI_ATTR_PREFETCH_MEMORY,

   189                        err);

   190         if (r != 0)

   191             qOraWarning("QOCIResultPrivate::setStatementAttributes:"

   192                         " Couldn't set OCI_ATTR_PREFETCH_MEMORY: ", err);

   193     }

   194 }

   195 

   196 void QOCIResultPrivate::setCharset(OCIBind* hbnd)

   197 {

   198     int r = 0;

   199 

   200     Q_ASSERT(hbnd);

   201 

   202     r = OCIAttrSet(hbnd,

   203                    OCI_HTYPE_BIND,

   204                    // this const cast is safe since OCI doesn't touch

   205                    // the charset.

   206                    const_cast<void *>(static_cast<const void *>(&qOraCharset)),

   207                    0,

   208                    OCI_ATTR_CHARSET_ID,

   209                    err);

   210     if (r != 0)

   211         qOraWarning("QOCIResultPrivate::setCharset: Couldn't set OCI_ATTR_CHARSET_ID: ", err);

   212 }

   213 

   214 int QOCIResultPrivate::bindValue(OCIStmt *sql, OCIBind **hbnd, OCIError *err, int pos,

   215                    const QVariant &val, dvoid *indPtr, ub2 *tmpSize, QList<QByteArray> &tmpStorage)

   216 {

   217     int r = OCI_SUCCESS;

   218     void *data = const_cast<void *>(val.constData());

   219 

   220     switch (val.type()) {

   221     case QVariant::ByteArray:

   222         r = OCIBindByPos(sql, hbnd, err,

   223                          pos + 1,

   224                          isOutValue(pos)

   225                             ?  const_cast<char *>(reinterpret_cast<QByteArray *>(data)->constData())

   226                             : reinterpret_cast<QByteArray *>(data)->data(),

   227                          reinterpret_cast<QByteArray *>(data)->size(),

   228                          SQLT_BIN, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   229         break;

   230     case QVariant::Time:

   231     case QVariant::Date:

   232     case QVariant::DateTime: {

   233         QByteArray ba = qMakeOraDate(val.toDateTime());

   234         r = OCIBindByPos(sql, hbnd, err,

   235                          pos + 1,

   236                          ba.data(),

   237                          ba.size(),

   238                          SQLT_DAT, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   239         tmpStorage.append(ba);

   240         break; }

   241     case QVariant::Int:

   242         r = OCIBindByPos(sql, hbnd, err,

   243                          pos + 1,

   244                          // if it's an out value, the data is already detached

   245                          // so the const cast is safe.

   246                          const_cast<void *>(data),

   247                          sizeof(int),

   248                          SQLT_INT, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   249         break;

   250     case QVariant::UInt:

   251         r = OCIBindByPos(sql, hbnd, err,

   252                          pos + 1,

   253                          // if it's an out value, the data is already detached

   254                          // so the const cast is safe.

   255                          const_cast<void *>(data),

   256                          sizeof(uint),

   257                          SQLT_UIN, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   258         break;

   259     case QVariant::Double:

   260         r = OCIBindByPos(sql, hbnd, err,

   261                          pos + 1,

   262                          // if it's an out value, the data is already detached

   263                          // so the const cast is safe.

   264                          const_cast<void *>(data),

   265                          sizeof(double),

   266                          SQLT_FLT, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   267         break;

   268     case QVariant::UserType:

   269         if (qVariantCanConvert<QOCIRowIdPointer>(val) && !isOutValue(pos)) {

   270             // use a const pointer to prevent a detach

   271             const QOCIRowIdPointer rptr = qVariantValue<QOCIRowIdPointer>(val);

   272             r = OCIBindByPos(sql, hbnd, err,

   273                              pos + 1,

   274                              // it's an IN value, so const_cast is ok

   275                              const_cast<OCIRowid **>(&rptr->id),

   276                              -1,

   277                              SQLT_RDD, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   278         } else {

   279             qWarning("Unknown bind variable");

   280             r = OCI_ERROR;

   281         }

   282         break;

   283     case QVariant::String: {

   284         const QString s = val.toString();

   285         if (isBinaryValue(pos)) {

   286             r = OCIBindByPos(sql, hbnd, err,

   287                              pos + 1,

   288                              const_cast<ushort *>(s.utf16()),

   289                              s.length() * sizeof(QChar),

   290                              SQLT_LNG, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   291             break;

   292         } else if (!isOutValue(pos)) {

   293             // don't detach the string

   294             r = OCIBindByPos(sql, hbnd, err,

   295                              pos + 1,

   296                              // safe since oracle doesn't touch OUT values

   297                              const_cast<ushort *>(s.utf16()),

   298                              (s.length() + 1) * sizeof(QChar),

   299                              SQLT_STR, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   300             if (r == OCI_SUCCESS)

   301                 setCharset(*hbnd);

   302             break;

   303         }

   304     } // fall through for OUT values

   305     default: {

   306         const QString s = val.toString();

   307         // create a deep-copy

   308         QByteArray ba(reinterpret_cast<const char *>(s.utf16()), (s.length() + 1) * sizeof(QChar));

   309         if (isOutValue(pos)) {

   310             ba.reserve((s.capacity() + 1) * sizeof(QChar));

   311             *tmpSize = ba.size();

   312             r = OCIBindByPos(sql, hbnd, err,

   313                              pos + 1,

   314                              ba.data(),

   315                              ba.capacity(),

   316                              SQLT_STR, indPtr, tmpSize, 0, 0, 0, OCI_DEFAULT);

   317         } else {

   318             r = OCIBindByPos(sql, hbnd, err,

   319                              pos + 1,

   320                              ba.data(),

   321                              ba.size(),

   322                              SQLT_STR, indPtr, 0, 0, 0, 0, OCI_DEFAULT);

   323         }

   324         if (r == OCI_SUCCESS)

   325             setCharset(*hbnd);

   326         tmpStorage.append(ba);

   327         break;

   328     } // default case

   329     } // switch

   330     if (r != OCI_SUCCESS)

   331         qOraWarning("QOCIResultPrivate::bindValue:", err);

   332     return r;

   333 }

   334 

   335 int QOCIResultPrivate::bindValues(QVector<QVariant> &values, IndicatorArray &indicators,

   336                             SizeArray &tmpSizes, QList<QByteArray> &tmpStorage)

   337 {

   338     int r = OCI_SUCCESS;

   339     for (int i = 0; i < values.count(); ++i) {

   340         if (isOutValue(i))

   341             values[i].detach();

   342         const QVariant &val = values.at(i);

   343 

   344         OCIBind * hbnd = 0; // Oracle handles these automatically

   345         sb2 *indPtr = &indicators[i];

   346         *indPtr = val.isNull() ? -1 : 0;

   347 

   348         bindValue(sql, &hbnd, err, i, val, indPtr, &tmpSizes[i], tmpStorage);

   349     }

   350     return r;

   351 }

   352 

   353 // will assign out value and remove its temp storage.

   354 static void qOraOutValue(QVariant &value, QList<QByteArray> &storage)

   355 {

   356     switch (value.type()) {

   357     case QVariant::Time:

   358         value = qMakeDate(storage.takeFirst()).time();

   359         break;

   360     case QVariant::Date:

   361         value = qMakeDate(storage.takeFirst()).date();

   362         break;

   363     case QVariant::DateTime:

   364         value = qMakeDate(storage.takeFirst());

   365         break;

   366     case QVariant::String:

   367         value = QString::fromUtf16(

   368                 reinterpret_cast<const ushort *>(storage.takeFirst().constData()));

   369         break;

   370     default:

   371         break; //nothing

   372     }

   373 }

   374 

   375 void QOCIResultPrivate::outValues(QVector<QVariant> &values, IndicatorArray &indicators,

   376                             QList<QByteArray> &tmpStorage)

   377 {

   378     for (int i = 0; i < values.count(); ++i) {

   379 

   380         if (!isOutValue(i))

   381             continue;

   382 

   383         qOraOutValue(values[i], tmpStorage);

   384 

   385         QVariant::Type typ = values.at(i).type();

   386         if (indicators[i] == -1) // NULL

   387             values[i] = QVariant(typ);

   388         else

   389             values[i] = QVariant(typ, values.at(i).constData());

   390     }

   391 }

   392 

   393 

   394 struct QOCIDriverPrivate

   395 {

   396     QOCIDriverPrivate();

   397 

   398     OCIEnv *env;

   399     OCISvcCtx *svc;

   400     OCIServer *srvhp;

   401     OCISession *authp;

   402     OCIError *err;

   403     bool transaction;

   404     int serverVersion;

   405     ub4 prefetchRows;

   406     ub2 prefetchMem;

   407     QString user;

   408 

   409     void allocErrorHandle();

   410 };

   411 

   412 QOCIDriverPrivate::QOCIDriverPrivate()

   413     : env(0), svc(0), srvhp(0), authp(0), err(0), transaction(false), serverVersion(-1),

   414       prefetchRows(-1), prefetchMem(QOCI_PREFETCH_MEM)

   415 {

   416 }

   417 

   418 void QOCIDriverPrivate::allocErrorHandle()

   419 {

   420     int r = OCIHandleAlloc(env,

   421                            reinterpret_cast<void **>(&err),

   422                            OCI_HTYPE_ERROR,

   423                            0,

   424                            0);

   425     if (r != 0)

   426         qWarning("QOCIDriver: unable to allocate error handle");

   427 }

   428 

   429 struct OraFieldInfo

   430 {

   431     QString name;

   432     QVariant::Type type;

   433     ub1 oraIsNull;

   434     ub4 oraType;

   435     sb1 oraScale;

   436     ub4 oraLength; // size in bytes

   437     ub4 oraFieldLength; // amount of characters

   438     sb2 oraPrecision;

   439 };

   440 

   441 QString qOraWarn(OCIError *err, int *errorCode)

   442 {

   443     sb4 errcode;

   444     text errbuf[1024];

   445     errbuf[0] = 0;

   446     errbuf[1] = 0;

   447 

   448     OCIErrorGet(err,

   449                 1,

   450                 0,

   451                 &errcode,

   452                 errbuf,

   453                 sizeof(errbuf),

   454                 OCI_HTYPE_ERROR);

   455     if (errorCode)

   456         *errorCode = errcode;

   457     return QString::fromUtf16(reinterpret_cast<const ushort *>(errbuf));

   458 }

   459 

   460 void qOraWarning(const char* msg, OCIError *err)

   461 {

   462 #ifdef QOCI_DEBUG

   463     qWarning("%s %s", msg, qPrintable(qOraWarn(err)));

   464 #else

   465     Q_UNUSED(msg);

   466     Q_UNUSED(err);

   467 #endif

   468 }

   469 

   470 static int qOraErrorNumber(OCIError *err)

   471 {

   472     sb4 errcode;

   473     OCIErrorGet(err,

   474                 1,

   475                 0,

   476                 &errcode,

   477                 0,

   478                 0,

   479                 OCI_HTYPE_ERROR);

   480     return errcode;

   481 }

   482 

   483 QSqlError qMakeError(const QString& errString, QSqlError::ErrorType type, OCIError *err)

   484 {

   485     int errorCode = 0;

   486     const QString oraErrorString = qOraWarn(err, &errorCode);

   487     return QSqlError(errString, oraErrorString, type, errorCode);

   488 }

   489 

   490 QVariant::Type qDecodeOCIType(const QString& ocitype, QSql::NumericalPrecisionPolicy precisionPolicy)

   491 {

   492     QVariant::Type type = QVariant::Invalid;

   493     if (ocitype == QLatin1String("VARCHAR2") || ocitype == QLatin1String("VARCHAR")

   494          || ocitype.startsWith(QLatin1String("INTERVAL"))

   495          || ocitype == QLatin1String("CHAR") || ocitype == QLatin1String("NVARCHAR2")

   496          || ocitype == QLatin1String("NCHAR"))

   497         type = QVariant::String;

   498     else if (ocitype == QLatin1String("NUMBER")

   499              || ocitype == QLatin1String("FLOAT")

   500              || ocitype == QLatin1String("BINARY_FLOAT")

   501              || ocitype == QLatin1String("BINARY_DOUBLE")) {

   502         switch(precisionPolicy) {

   503             case QSql::LowPrecisionInt32:

   504                 type = QVariant::Int;

   505                 break;

   506             case QSql::LowPrecisionInt64:

   507                 type = QVariant::LongLong;

   508                 break;

   509             case QSql::LowPrecisionDouble:

   510                 type = QVariant::Double;

   511                 break;

   512             case QSql::HighPrecision:

   513             default:

   514                 type = QVariant::String;

   515                 break;

   516         }

   517     }

   518     else if (ocitype == QLatin1String("LONG") || ocitype == QLatin1String("NCLOB")

   519              || ocitype == QLatin1String("CLOB"))

   520         type = QVariant::ByteArray;

   521     else if (ocitype == QLatin1String("RAW") || ocitype == QLatin1String("LONG RAW")

   522              || ocitype == QLatin1String("ROWID") || ocitype == QLatin1String("BLOB")

   523              || ocitype == QLatin1String("CFILE") || ocitype == QLatin1String("BFILE"))

   524         type = QVariant::ByteArray;

   525     else if (ocitype == QLatin1String("DATE") ||  ocitype.startsWith(QLatin1String("TIME")))

   526         type = QVariant::DateTime;

   527     else if (ocitype == QLatin1String("UNDEFINED"))

   528         type = QVariant::Invalid;

   529     if (type == QVariant::Invalid)

   530         qWarning("qDecodeOCIType: unknown type: %s", ocitype.toLocal8Bit().constData());

   531     return type;

   532 }

   533 

   534 QVariant::Type qDecodeOCIType(int ocitype, QSql::NumericalPrecisionPolicy precisionPolicy)

   535 {

   536     QVariant::Type type = QVariant::Invalid;

   537     switch (ocitype) {

   538     case SQLT_STR:

   539     case SQLT_VST:

   540     case SQLT_CHR:

   541     case SQLT_AFC:

   542     case SQLT_VCS:

   543     case SQLT_AVC:

   544     case SQLT_RDD:

   545     case SQLT_LNG:

   546 #ifdef SQLT_INTERVAL_YM

   547     case SQLT_INTERVAL_YM:

   548 #endif

   549 #ifdef SQLT_INTERVAL_DS

   550     case SQLT_INTERVAL_DS:

   551 #endif

   552         type = QVariant::String;

   553         break;

   554     case SQLT_INT:

   555         type = QVariant::Int;

   556         break;

   557     case SQLT_FLT:

   558     case SQLT_NUM:

   559     case SQLT_VNU:

   560     case SQLT_UIN:

   561         switch(precisionPolicy) {

   562             case QSql::LowPrecisionInt32:

   563                 type = QVariant::Int;

   564                 break;

   565             case QSql::LowPrecisionInt64:

   566                 type = QVariant::LongLong;

   567                 break;

   568             case QSql::LowPrecisionDouble:

   569                 type = QVariant::Double;

   570                 break;

   571             case QSql::HighPrecision:

   572             default:

   573                 type = QVariant::String;

   574                 break;

   575         }

   576         break;

   577     case SQLT_VBI:

   578     case SQLT_BIN:

   579     case SQLT_LBI:

   580     case SQLT_LVC:

   581     case SQLT_LVB:

   582     case SQLT_BLOB:

   583     case SQLT_FILE:

   584     case SQLT_NTY:

   585     case SQLT_REF:

   586     case SQLT_RID:

   587     case SQLT_CLOB:

   588         type = QVariant::ByteArray;

   589         break;

   590     case SQLT_DAT:

   591     case SQLT_ODT:

   592 #ifdef SQLT_TIMESTAMP

   593     case SQLT_TIMESTAMP:

   594     case SQLT_TIMESTAMP_TZ:

   595     case SQLT_TIMESTAMP_LTZ:

   596 #endif

   597         type = QVariant::DateTime;

   598         break;

   599     default:

   600         type = QVariant::Invalid;

   601         qWarning("qDecodeOCIType: unknown OCI datatype: %d", ocitype);

   602         break;

   603     }

   604         return type;

   605 }

   606 

   607 static QSqlField qFromOraInf(const OraFieldInfo &ofi)

   608 {

   609     QSqlField f(ofi.name, ofi.type);

   610     f.setRequired(ofi.oraIsNull == 0);

   611 

   612     if (ofi.type == QVariant::String && ofi.oraType != SQLT_NUM && ofi.oraType != SQLT_VNU)

   613         f.setLength(ofi.oraFieldLength);

   614     else

   615         f.setLength(ofi.oraPrecision == 0 ? 38 : int(ofi.oraPrecision));

   616 

   617     f.setPrecision(ofi.oraScale);

   618     f.setSqlType(int(ofi.oraType));

   619     return f;

   620 }

   621 

   622 /*!

   623     \internal

   624 

   625     Convert QDateTime to the internal Oracle DATE format NB!

   626     It does not handle BCE dates.

   627 */

   628 QByteArray qMakeOraDate(const QDateTime& dt)

   629 {

   630     QByteArray ba;

   631     ba.resize(7);

   632     int year = dt.date().year();

   633     ba[0]= (year / 100) + 100; // century

   634     ba[1]= (year % 100) + 100; // year

   635     ba[2]= dt.date().month();

   636     ba[3]= dt.date().day();

   637     ba[4]= dt.time().hour() + 1;

   638     ba[5]= dt.time().minute() + 1;

   639     ba[6]= dt.time().second() + 1;

   640     return ba;

   641 }

   642 

   643 QDateTime qMakeDate(const char* oraDate)

   644 {

   645     int century = oraDate[0];

   646     if(century >= 100){

   647         int year    = uchar(oraDate[1]);

   648         year = ((century-100)*100) + (year-100);

   649         int month = oraDate[2];

   650         int day   = oraDate[3];

   651         int hour  = oraDate[4] - 1;

   652         int min   = oraDate[5] - 1;

   653         int sec   = oraDate[6] - 1;

   654         return QDateTime(QDate(year,month,day), QTime(hour,min,sec));

   655     }

   656     return QDateTime();

   657 }

   658 

   659 class QOCICols

   660 {

   661 public:

   662     QOCICols(int size, QOCIResultPrivate* dp);

   663     ~QOCICols();

   664     void setCharset(OCIDefine* dfn);

   665     int readPiecewise(QVector<QVariant> &values, int index = 0);

   666     int readLOBs(QVector<QVariant> &values, int index = 0);

   667     int fieldFromDefine(OCIDefine* d);

   668     void getValues(QVector<QVariant> &v, int index);

   669     inline int size() { return fieldInf.size(); }

   670     static bool execBatch(QOCIResultPrivate *d, QVector<QVariant> &boundValues, bool arrayBind);

   671 

   672     QSqlRecord rec;

   673 

   674 private:

   675     char* create(int position, int size);

   676     OCILobLocator ** createLobLocator(int position, OCIEnv* env);

   677     OraFieldInfo qMakeOraField(const QOCIResultPrivate* p, OCIParam* param) const;

   678 

   679     class OraFieldInf

   680     {

   681     public:

   682         OraFieldInf(): data(0), len(0), ind(0), typ(QVariant::Invalid), oraType(0), def(0), lob(0)

   683         {}

   684         ~OraFieldInf();

   685         char *data;

   686         int len;

   687         sb2 ind;

   688         QVariant::Type typ;

   689         ub4 oraType;

   690         OCIDefine *def;

   691         OCILobLocator *lob;

   692     };

   693 

   694     QVector<OraFieldInf> fieldInf;

   695     const QOCIResultPrivate *const d;

   696 };

   697 

   698 QOCICols::OraFieldInf::~OraFieldInf()

   699 {

   700     delete [] data;

   701     if (lob) {

   702         int r = OCIDescriptorFree(lob, OCI_DTYPE_LOB);

   703         if (r != 0)

   704             qWarning("QOCICols: Cannot free LOB descriptor");

   705     }

   706 }

   707 

   708 QOCICols::QOCICols(int size, QOCIResultPrivate* dp)

   709     : fieldInf(size), d(dp)

   710 {

   711     ub4 dataSize = 0;

   712     OCIDefine* dfn = 0;

   713     int r;

   714 

   715     OCIParam* param = 0;

   716     sb4 parmStatus = 0;

   717     ub4 count = 1;

   718     int idx = 0;

   719     parmStatus = OCIParamGet(d->sql,

   720                              OCI_HTYPE_STMT,

   721                              d->err,

   722                              reinterpret_cast<void **>(&param),

   723                              count);

   724 

   725     while (parmStatus == OCI_SUCCESS) {

   726         OraFieldInfo ofi = qMakeOraField(d, param);

   727         if (ofi.oraType == SQLT_RDD)

   728             dataSize = 50;

   729 #ifdef SQLT_INTERVAL_YM

   730 #ifdef SQLT_INTERVAL_DS

   731         else if (ofi.oraType == SQLT_INTERVAL_YM || ofi.oraType == SQLT_INTERVAL_DS)

   732             // since we are binding interval datatype as string,

   733             // we are not interested in the number of bytes but characters.

   734             dataSize = 50;  // magic number

   735 #endif //SQLT_INTERVAL_DS

   736 #endif //SQLT_INTERVAL_YM

   737         else if (ofi.oraType == SQLT_NUM || ofi.oraType == SQLT_VNU){

   738             if (ofi.oraPrecision > 0)

   739                 dataSize = (ofi.oraPrecision + 1) * sizeof(utext);

   740             else

   741                 dataSize = (38 + 1) * sizeof(utext);

   742         }

   743         else

   744             dataSize = ofi.oraLength;

   745 

   746         fieldInf[idx].typ = ofi.type;

   747         fieldInf[idx].oraType = ofi.oraType;

   748         rec.append(qFromOraInf(ofi));

   749 

   750         switch (ofi.type) {

   751         case QVariant::DateTime:

   752             r = OCIDefineByPos(d->sql,

   753                                &dfn,

   754                                d->err,

   755                                count,

   756                                create(idx, dataSize+1),

   757                                dataSize+1,

   758                                SQLT_DAT,

   759                                &(fieldInf[idx].ind),

   760                                0, 0, OCI_DEFAULT);

   761             break;

   762         case QVariant::Double:

   763             r = OCIDefineByPos(d->sql,

   764                                &dfn,

   765                                d->err,

   766                                count,

   767                                create(idx, sizeof(double) - 1),

   768                                sizeof(double),

   769                                SQLT_FLT,

   770                                &(fieldInf[idx].ind),

   771                                0, 0, OCI_DEFAULT);

   772             break;

   773         case QVariant::Int:

   774             r = OCIDefineByPos(d->sql,

   775                                &dfn,

   776                                d->err,

   777                                count,

   778                                create(idx, sizeof(qint32) - 1),

   779                                sizeof(qint32),

   780                                SQLT_INT,

   781                                &(fieldInf[idx].ind),

   782                                0, 0, OCI_DEFAULT);

   783             break;

   784         case QVariant::LongLong:

   785             r = OCIDefineByPos(d->sql,

   786                                &dfn,

   787                                d->err,

   788                                count,

   789                                create(idx, sizeof(OCINumber)),

   790                                sizeof(OCINumber),

   791                                SQLT_VNU,

   792                                &(fieldInf[idx].ind),

   793                                0, 0, OCI_DEFAULT);

   794             break;

   795         case QVariant::ByteArray:

   796             // RAW and LONG RAW fields can't be bound to LOB locators

   797             if (ofi.oraType == SQLT_BIN) {

   798 //                                qDebug("binding SQLT_BIN");

   799                 r = OCIDefineByPos(d->sql,

   800                                    &dfn,

   801                                    d->err,

   802                                    count,

   803                                    create(idx, dataSize),

   804                                    dataSize,

   805                                    SQLT_BIN,

   806                                    &(fieldInf[idx].ind),

   807                                    0, 0, OCI_DYNAMIC_FETCH);

   808             } else if (ofi.oraType == SQLT_LBI) {

   809 //                                    qDebug("binding SQLT_LBI");

   810                 r = OCIDefineByPos(d->sql,

   811                                    &dfn,

   812                                    d->err,

   813                                    count,

   814                                    0,

   815                                    SB4MAXVAL,

   816                                    SQLT_LBI,

   817                                    &(fieldInf[idx].ind),

   818                                    0, 0, OCI_DYNAMIC_FETCH);

   819             } else if (ofi.oraType == SQLT_CLOB) {

   820                 r = OCIDefineByPos(d->sql,

   821                                    &dfn,

   822                                    d->err,

   823                                    count,

   824                                    createLobLocator(idx, d->env),

   825                                    -1,

   826                                    SQLT_CLOB,

   827                                    &(fieldInf[idx].ind),

   828                                    0, 0, OCI_DEFAULT);

   829             } else {

   830 //                 qDebug("binding SQLT_BLOB");

   831                 r = OCIDefineByPos(d->sql,

   832                                    &dfn,

   833                                    d->err,

   834                                    count,

   835                                    createLobLocator(idx, d->env),

   836                                    -1,

   837                                    SQLT_BLOB,

   838                                    &(fieldInf[idx].ind),

   839                                    0, 0, OCI_DEFAULT);

   840             }

   841             break;

   842         case QVariant::String:

   843             if (ofi.oraType == SQLT_LNG) {

   844                 r = OCIDefineByPos(d->sql,

   845                         &dfn,

   846                         d->err,

   847                         count,

   848                         0,

   849                         SB4MAXVAL,

   850                         SQLT_LNG,

   851                         &(fieldInf[idx].ind),

   852                         0, 0, OCI_DYNAMIC_FETCH);

   853             } else {

   854                 dataSize += dataSize + sizeof(QChar);

   855                 //qDebug("OCIDefineByPosStr(%d): %d", count, dataSize);

   856                 r = OCIDefineByPos(d->sql,

   857                         &dfn,

   858                         d->err,

   859                         count,

   860                         create(idx, dataSize),

   861                         dataSize,

   862                         SQLT_STR,

   863                         &(fieldInf[idx].ind),

   864                         0, 0, OCI_DEFAULT);

   865                 if (r == 0)

   866                     setCharset(dfn);

   867             }

   868            break;

   869         default:

   870             // this should make enough space even with character encoding

   871             dataSize = (dataSize + 1) * sizeof(utext) ;

   872             //qDebug("OCIDefineByPosDef(%d): %d", count, dataSize);

   873             r = OCIDefineByPos(d->sql,

   874                                 &dfn,

   875                                 d->err,

   876                                 count,

   877                                 create(idx, dataSize),

   878                                 dataSize+1,

   879                                 SQLT_STR,

   880                                 &(fieldInf[idx].ind),

   881                                 0, 0, OCI_DEFAULT);

   882             break;

   883         }

   884         if (r != 0)

   885             qOraWarning("QOCICols::bind:", d->err);

   886         fieldInf[idx].def = dfn;

   887         ++count;

   888         ++idx;

   889         parmStatus = OCIParamGet(d->sql,

   890                                   OCI_HTYPE_STMT,

   891                                   d->err,

   892                                   reinterpret_cast<void **>(&param),

   893                                   count);

   894     }

   895 }

   896 

   897 QOCICols::~QOCICols()

   898 {

   899 }

   900 

   901 char* QOCICols::create(int position, int size)

   902 {

   903     char* c = new char[size+1];

   904     // Oracle may not fill fixed width fields

   905     memset(c, 0, size+1);

   906     fieldInf[position].data = c;

   907     fieldInf[position].len = size;

   908     return c;

   909 }

   910 

   911 OCILobLocator **QOCICols::createLobLocator(int position, OCIEnv* env)

   912 {

   913     OCILobLocator *& lob = fieldInf[position].lob;

   914     int r = OCIDescriptorAlloc(env,

   915                                reinterpret_cast<void **>(&lob),

   916                                OCI_DTYPE_LOB,

   917                                0,

   918                                0);

   919     if (r != 0) {

   920         qWarning("QOCICols: Cannot create LOB locator");

   921         lob = 0;

   922     }

   923     return &lob;

   924 }

   925 

   926 void QOCICols::setCharset(OCIDefine* dfn)

   927 {

   928     int r = 0;

   929 

   930     Q_ASSERT(dfn);

   931 

   932     r = OCIAttrSet(dfn,

   933                    OCI_HTYPE_DEFINE,

   934                    // this const cast is safe since OCI doesn't touch

   935                    // the charset.

   936                    const_cast<void *>(static_cast<const void *>(&qOraCharset)),

   937                    0,

   938                    OCI_ATTR_CHARSET_ID,

   939                    d->err);

   940         if (r != 0)

   941             qOraWarning("QOCICols::setCharset: Couldn't set OCI_ATTR_CHARSET_ID: ", d->err);

   942 }

   943 

   944 int QOCICols::readPiecewise(QVector<QVariant> &values, int index)

   945 {

   946     OCIDefine*     dfn;

   947     ub4            typep;

   948     ub1            in_outp;

   949     ub4            iterp;

   950     ub4            idxp;

   951     ub1            piecep;

   952     sword          status;

   953     text           col [QOCI_DYNAMIC_CHUNK_SIZE+1];

   954     int            fieldNum = -1;

   955     int            r = 0;

   956     bool           nullField;

   957 

   958     do {

   959         r = OCIStmtGetPieceInfo(d->sql, d->err, reinterpret_cast<void **>(&dfn), &typep,

   960                                  &in_outp, &iterp, &idxp, &piecep);

   961         if (r != OCI_SUCCESS)

   962             qOraWarning("OCIResultPrivate::readPiecewise: unable to get piece info:", d->err);

   963         fieldNum = fieldFromDefine(dfn);

   964         bool isStringField = fieldInf.at(fieldNum).oraType == SQLT_LNG;

   965         ub4 chunkSize = QOCI_DYNAMIC_CHUNK_SIZE;

   966         nullField = false;

   967         r  = OCIStmtSetPieceInfo(dfn, OCI_HTYPE_DEFINE,

   968                                  d->err, col,

   969                                  &chunkSize, piecep, NULL, NULL);

   970         if (r != OCI_SUCCESS)

   971             qOraWarning("OCIResultPrivate::readPiecewise: unable to set piece info:", d->err);

   972         status = OCIStmtFetch (d->sql, d->err, 1, OCI_FETCH_NEXT, OCI_DEFAULT);

   973         if (status == -1) {

   974             sb4 errcode;

   975             OCIErrorGet(d->err, 1, 0, &errcode, 0, 0,OCI_HTYPE_ERROR);

   976             switch (errcode) {

   977             case 1405: /* NULL */

   978                 nullField = true;

   979                 break;

   980             default:

   981                 qOraWarning("OCIResultPrivate::readPiecewise: unable to fetch next:", d->err);

   982                 break;

   983             }

   984         }

   985         if (status == OCI_NO_DATA)

   986             break;

   987         if (nullField || !chunkSize) {

   988             fieldInf[fieldNum].ind = -1;

   989         } else {

   990             if (isStringField) {

   991                 QString str = values.at(fieldNum + index).toString();

   992                 str += QString::fromUtf16(reinterpret_cast<const ushort *>(col),

   993                                           chunkSize / 2);

   994                 values[fieldNum + index] = str;

   995                 fieldInf[fieldNum].ind = 0;

   996             } else {

   997                 QByteArray ba = values.at(fieldNum + index).toByteArray();

   998                 int sz = ba.size();

   999                 ba.resize(sz + chunkSize);

  1000                 memcpy(ba.data() + sz, reinterpret_cast<char *>(col), chunkSize);

  1001                 values[fieldNum + index] = ba;

  1002                 fieldInf[fieldNum].ind = 0;

  1003             }

  1004         }

  1005     } while (status == OCI_SUCCESS_WITH_INFO || status == OCI_NEED_DATA);

  1006     return r;

  1007 }

  1008 

  1009 OraFieldInfo QOCICols::qMakeOraField(const QOCIResultPrivate* p, OCIParam* param) const

  1010 {

  1011     OraFieldInfo ofi;

  1012     ub2 colType(0);

  1013     text *colName = 0;

  1014     ub4 colNameLen(0);

  1015     sb1 colScale(0);

  1016     ub2 colLength(0);

  1017     ub2 colFieldLength(0);

  1018     sb2 colPrecision(0);

  1019     ub1 colIsNull(0);

  1020     int r(0);

  1021     QVariant::Type type(QVariant::Invalid);

  1022 

  1023     r = OCIAttrGet(param,

  1024                    OCI_DTYPE_PARAM,

  1025                    &colType,

  1026                    0,

  1027                    OCI_ATTR_DATA_TYPE,

  1028                    p->err);

  1029     if (r != 0)

  1030         qOraWarning("qMakeOraField:", p->err);

  1031 

  1032     r = OCIAttrGet(param,

  1033                    OCI_DTYPE_PARAM,

  1034                    &colName,

  1035                    &colNameLen,

  1036                    OCI_ATTR_NAME,

  1037                    p->err);

  1038     if (r != 0)

  1039         qOraWarning("qMakeOraField:", p->err);

  1040 

  1041     r = OCIAttrGet(param,

  1042                    OCI_DTYPE_PARAM,

  1043                    &colLength,

  1044                    0,

  1045                    OCI_ATTR_DATA_SIZE, /* in bytes */

  1046                    p->err);

  1047     if (r != 0)

  1048         qOraWarning("qMakeOraField:", p->err);

  1049 

  1050 #ifdef OCI_ATTR_CHAR_SIZE

  1051     r = OCIAttrGet(param,

  1052                    OCI_DTYPE_PARAM,

  1053                    &colFieldLength,

  1054                    0,

  1055                    OCI_ATTR_CHAR_SIZE,

  1056                    p->err);

  1057     if (r != 0)

  1058         qOraWarning("qMakeOraField:", p->err);

  1059 #else

  1060     // for Oracle8.

  1061     colFieldLength = colLength;

  1062 #endif

  1063 

  1064     r = OCIAttrGet(param,

  1065                    OCI_DTYPE_PARAM,

  1066                    &colPrecision,

  1067                    0,

  1068                    OCI_ATTR_PRECISION,

  1069                    p->err);

  1070     if (r != 0)

  1071         qOraWarning("qMakeOraField:", p->err);

  1072 

  1073     r = OCIAttrGet(param,

  1074                    OCI_DTYPE_PARAM,

  1075                    &colScale,

  1076                    0,

  1077                    OCI_ATTR_SCALE,

  1078                    p->err);

  1079     if (r != 0)

  1080         qOraWarning("qMakeOraField:", p->err);

  1081     r = OCIAttrGet(param,

  1082                    OCI_DTYPE_PARAM,

  1083                    &colType,

  1084                    0,

  1085                    OCI_ATTR_DATA_TYPE,

  1086                    p->err);

  1087     if (r != 0)

  1088         qOraWarning("qMakeOraField:", p->err);

  1089     r = OCIAttrGet(param,

  1090                    OCI_DTYPE_PARAM,

  1091                    &colIsNull,

  1092                    0,

  1093                    OCI_ATTR_IS_NULL,

  1094                    p->err);

  1095     if (r != 0)

  1096         qOraWarning("qMakeOraField:", p->err);

  1097 

  1098     type = qDecodeOCIType(colType, p->q->numericalPrecisionPolicy());

  1099 

  1100     if (type == QVariant::Int) {

  1101         if (colLength == 22 && colPrecision == 0 && colScale == 0)

  1102             type = QVariant::String;

  1103         if (colScale > 0)

  1104             type = QVariant::String;

  1105     }

  1106 

  1107     // bind as double if the precision policy asks for it

  1108     if (((colType == SQLT_FLT) || (colType == SQLT_NUM))

  1109             && (p->q->numericalPrecisionPolicy() == QSql::LowPrecisionDouble)) {

  1110         type = QVariant::Double;

  1111     }

  1112 

  1113     // bind as int32 or int64 if the precision policy asks for it

  1114     if ((colType == SQLT_NUM) || (colType == SQLT_VNU) || (colType == SQLT_UIN)

  1115             || (colType == SQLT_INT)) {

  1116         if (p->q->numericalPrecisionPolicy() == QSql::LowPrecisionInt64)

  1117             type = QVariant::LongLong;

  1118         else if (p->q->numericalPrecisionPolicy() == QSql::LowPrecisionInt32)

  1119             type = QVariant::Int;

  1120     }

  1121 

  1122     if (colType == SQLT_BLOB)

  1123         colLength = 0;

  1124 

  1125     // colNameLen is length in bytes

  1126     ofi.name = QString(reinterpret_cast<const QChar*>(colName), colNameLen / 2);

  1127     ofi.type = type;

  1128     ofi.oraType = colType;

  1129     ofi.oraFieldLength = colFieldLength;

  1130     ofi.oraLength = colLength;

  1131     ofi.oraScale = colScale;

  1132     ofi.oraPrecision = colPrecision;

  1133     ofi.oraIsNull = colIsNull;

  1134