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

    43 #include <qsqlrecord.h>

    44 

    45 #if defined (Q_OS_WIN32)

    46 #include <qt_windows.h>

    47 #endif

    48 #include <qcoreapplication.h>

    49 #include <qvariant.h>

    50 #include <qdatetime.h>

    51 #include <qsqlerror.h>

    52 #include <qsqlfield.h>

    53 #include <qsqlindex.h>

    54 #include <qstringlist.h>

    55 #include <qvarlengtharray.h>

    56 #include <qvector.h>

    57 #include <QDebug>

    58 #include <QSqlQuery>

    59 

    60 QT_BEGIN_NAMESPACE

    61 

    62 // undefine this to prevent initial check of the ODBC driver

    63 #define ODBC_CHECK_DRIVER

    64 

    65 #if defined(Q_ODBC_VERSION_2)

    66 //crude hack to get non-unicode capable driver managers to work

    67 # undef UNICODE

    68 # define SQLTCHAR SQLCHAR

    69 # define SQL_C_WCHAR SQL_C_CHAR

    70 #endif

    71 

    72 // newer platform SDKs use SQLLEN instead of SQLINTEGER

    73 #if defined(WIN32) && (_MSC_VER < 1300)

    74 # define QSQLLEN SQLINTEGER

    75 # define QSQLULEN SQLUINTEGER

    76 #else

    77 # define QSQLLEN SQLLEN

    78 # define QSQLULEN SQLULEN

    79 #endif

    80 

    81 

    82 static const int COLNAMESIZE = 256;

    83 //Map Qt parameter types to ODBC types

    84 static const SQLSMALLINT qParamType[4] = { SQL_PARAM_INPUT, SQL_PARAM_INPUT, SQL_PARAM_OUTPUT, SQL_PARAM_INPUT_OUTPUT };

    85 

    86 class QODBCDriverPrivate

    87 {

    88 public:

    89     enum DefaultCase{Lower, Mixed, Upper, Sensitive};

    90     QODBCDriverPrivate()

    91     : hEnv(0), hDbc(0), useSchema(false), disconnectCount(0), isMySqlServer(false),

    92            isMSSqlServer(false), hasSQLFetchScroll(true), hasMultiResultSets(false),

    93            isQuoteInitialized(false), quote(QLatin1Char('"'))

    94     {

    95         unicode = false;

    96     }

    97 

    98     SQLHANDLE hEnv;

    99     SQLHANDLE hDbc;

   100 

   101     uint unicode :1;

   102     uint useSchema :1;

   103     int disconnectCount;

   104     bool isMySqlServer;

   105     bool isMSSqlServer;

   106     bool hasSQLFetchScroll;

   107     bool hasMultiResultSets;

   108 

   109     bool checkDriver() const;

   110     void checkUnicode();

   111     void checkSqlServer();

   112     void checkHasSQLFetchScroll();

   113     void checkHasMultiResults();

   114     void checkSchemaUsage();

   115     bool setConnectionOptions(const QString& connOpts);

   116     void splitTableQualifier(const QString &qualifier, QString &catalog,

   117                              QString &schema, QString &table);

   118     DefaultCase defaultCase() const;

   119     QString adjustCase(const QString&) const;

   120     QChar quoteChar();

   121 private:

   122     bool isQuoteInitialized;

   123     QChar quote;

   124 };

   125 

   126 class QODBCPrivate

   127 {

   128 public:

   129     QODBCPrivate(QODBCDriverPrivate *dpp)

   130     : hStmt(0), useSchema(false), hasSQLFetchScroll(true), driverPrivate(dpp), userForwardOnly(false)

   131     {

   132         unicode = false;

   133     }

   134 

   135     inline void clearValues()

   136     { fieldCache.fill(QVariant()); fieldCacheIdx = 0; }

   137 

   138     SQLHANDLE dpEnv() const { return driverPrivate ? driverPrivate->hEnv : 0;}

   139     SQLHANDLE dpDbc() const { return driverPrivate ? driverPrivate->hDbc : 0;}

   140     SQLHANDLE hStmt;

   141 

   142     uint unicode :1;

   143     uint useSchema :1;

   144 

   145     QSqlRecord rInf;

   146     QVector<QVariant> fieldCache;

   147     int fieldCacheIdx;

   148     int disconnectCount;

   149     bool hasSQLFetchScroll;

   150     QODBCDriverPrivate *driverPrivate;

   151     bool userForwardOnly;

   152 

   153     bool isStmtHandleValid(const QSqlDriver *driver);

   154     void updateStmtHandleState(const QSqlDriver *driver);

   155 };

   156 

   157 bool QODBCPrivate::isStmtHandleValid(const QSqlDriver *driver)

   158 {

   159     const QODBCDriver *odbcdriver = static_cast<const QODBCDriver*> (driver);

   160     return disconnectCount == odbcdriver->d->disconnectCount;

   161 }

   162 

   163 void QODBCPrivate::updateStmtHandleState(const QSqlDriver *driver)

   164 {

   165     const QODBCDriver *odbcdriver = static_cast<const QODBCDriver*> (driver);

   166     disconnectCount = odbcdriver->d->disconnectCount;

   167 }

   168 

   169 static QString qWarnODBCHandle(int handleType, SQLHANDLE handle, int *nativeCode = 0)

   170 {

   171     SQLINTEGER nativeCode_ = 0;

   172     SQLSMALLINT msgLen = 0;

   173     SQLRETURN r = SQL_NO_DATA;

   174     SQLTCHAR state_[SQL_SQLSTATE_SIZE+1];

   175     SQLTCHAR description_[SQL_MAX_MESSAGE_LENGTH];

   176     QString result;

   177     int i = 1;

   178 

   179     description_[0] = 0;

   180     do {

   181         r = SQLGetDiagRec(handleType,

   182                             handle,

   183                             i,

   184                             (SQLTCHAR*)state_,

   185                             &nativeCode_,

   186                             (SQLTCHAR*)description_,

   187                             SQL_MAX_MESSAGE_LENGTH, /* in bytes, not in characters */

   188                             &msgLen);

   189         if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) {

   190             if (nativeCode)

   191                 *nativeCode = nativeCode_;

   192             QString tmpstore;

   193 #ifdef UNICODE

   194             tmpstore = QString((const QChar*)description_, msgLen);

   195 #else

   196             tmpstore = QString::fromLocal8Bit((const char*)description_, msgLen);

   197 #endif

   198             if(result != tmpstore) {

   199                 if(!result.isEmpty())

   200                     result += QLatin1Char(' ');

   201                 result += tmpstore;

   202             }

   203         } else if (r == SQL_ERROR || r == SQL_INVALID_HANDLE) {

   204             return result;

   205         }

   206         ++i;

   207     } while (r != SQL_NO_DATA);

   208     return result;

   209 }

   210 

   211 static QString qODBCWarn(const QODBCPrivate* odbc, int *nativeCode = 0)

   212 {

   213     return (qWarnODBCHandle(SQL_HANDLE_ENV, odbc->dpEnv()) + QLatin1Char(' ')

   214              + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->dpDbc()) + QLatin1Char(' ')

   215              + qWarnODBCHandle(SQL_HANDLE_STMT, odbc->hStmt, nativeCode));

   216 }

   217 

   218 static QString qODBCWarn(const QODBCDriverPrivate* odbc, int *nativeCode = 0)

   219 {

   220     return (qWarnODBCHandle(SQL_HANDLE_ENV, odbc->hEnv) + QLatin1Char(' ')

   221              + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->hDbc, nativeCode));

   222 }

   223 

   224 static void qSqlWarning(const QString& message, const QODBCPrivate* odbc)

   225 {

   226     qWarning() << message << "\tError:" << qODBCWarn(odbc);

   227 }

   228 

   229 static void qSqlWarning(const QString &message, const QODBCDriverPrivate *odbc)

   230 {

   231     qWarning() << message << "\tError:" << qODBCWarn(odbc);

   232 }

   233 

   234 static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type, const QODBCPrivate* p)

   235 {

   236     int nativeCode = -1;

   237     QString message = qODBCWarn(p, &nativeCode);

   238     return QSqlError(QLatin1String("QODBC3: ") + err, message, type, nativeCode);

   239 }

   240 

   241 static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,

   242                             const QODBCDriverPrivate* p)

   243 {

   244     int nativeCode = -1;

   245     QString message = qODBCWarn(p, &nativeCode);

   246     return QSqlError(QLatin1String("QODBC3: ") + err, qODBCWarn(p), type, nativeCode);

   247 }

   248 

   249 template<class T>

   250 static QVariant::Type qDecodeODBCType(SQLSMALLINT sqltype, const T* p, bool isSigned = true)

   251 {

   252     Q_UNUSED(p);

   253     QVariant::Type type = QVariant::Invalid;

   254     switch (sqltype) {

   255     case SQL_DECIMAL:

   256     case SQL_NUMERIC:

   257     case SQL_REAL:

   258     case SQL_FLOAT:

   259     case SQL_DOUBLE:

   260         type = QVariant::Double;

   261         break;

   262     case SQL_SMALLINT:

   263     case SQL_INTEGER:

   264     case SQL_BIT:

   265         type = isSigned ? QVariant::Int : QVariant::UInt;

   266         break;

   267     case SQL_TINYINT:

   268         type = QVariant::UInt;

   269         break;

   270     case SQL_BIGINT:

   271         type = isSigned ? QVariant::LongLong : QVariant::ULongLong;

   272         break;

   273     case SQL_BINARY:

   274     case SQL_VARBINARY:

   275     case SQL_LONGVARBINARY:

   276         type = QVariant::ByteArray;

   277         break;

   278     case SQL_DATE:

   279     case SQL_TYPE_DATE:

   280         type = QVariant::Date;

   281         break;

   282     case SQL_TIME:

   283     case SQL_TYPE_TIME:

   284         type = QVariant::Time;

   285         break;

   286     case SQL_TIMESTAMP:

   287     case SQL_TYPE_TIMESTAMP:

   288         type = QVariant::DateTime;

   289         break;

   290 #ifndef Q_ODBC_VERSION_2

   291     case SQL_WCHAR:

   292     case SQL_WVARCHAR:

   293     case SQL_WLONGVARCHAR:

   294         type = QVariant::String;

   295         break;

   296 #endif

   297     case SQL_CHAR:

   298     case SQL_VARCHAR:

   299     case SQL_GUID:

   300     case SQL_LONGVARCHAR:

   301         type = QVariant::String;

   302         break;

   303     default:

   304         type = QVariant::ByteArray;

   305         break;

   306     }

   307     return type;

   308 }

   309 

   310 static QString qGetStringData(SQLHANDLE hStmt, int column, int colSize, bool unicode = false)

   311 {

   312     QString fieldVal;

   313     SQLRETURN r = SQL_ERROR;

   314     QSQLLEN lengthIndicator = 0;

   315 

   316     // NB! colSize must be a multiple of 2 for unicode enabled DBs

   317     if (colSize <= 0) {

   318         colSize = 256;

   319     } else if (colSize > 65536) { // limit buffer size to 64 KB

   320         colSize = 65536;

   321     } else {

   322         colSize++; // make sure there is room for more than the 0 termination

   323         if (unicode) {

   324             colSize *= 2; // a tiny bit faster, since it saves a SQLGetData() call

   325         }

   326     }

   327     QVarLengthArray<char> buf(colSize);

   328     while (true) {

   329         r = SQLGetData(hStmt,

   330                         column+1,

   331                         unicode ? SQL_C_WCHAR : SQL_C_CHAR,

   332                         (SQLPOINTER)buf.data(),

   333                         colSize,

   334                         &lengthIndicator);

   335         if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) {

   336             if (lengthIndicator == SQL_NULL_DATA || lengthIndicator == SQL_NO_TOTAL) {

   337                 fieldVal.clear();

   338                 break;

   339             }

   340             // if SQL_SUCCESS_WITH_INFO is returned, indicating that

   341             // more data can be fetched, the length indicator does NOT

   342             // contain the number of bytes returned - it contains the

   343             // total number of bytes that CAN be fetched

   344             // colSize-1: remove 0 termination when there is more data to fetch

   345             int rSize = (r == SQL_SUCCESS_WITH_INFO) ? (unicode ? colSize-2 : colSize-1) : lengthIndicator;

   346             if (unicode) {

   347                 fieldVal += QString((const QChar*) buf.constData(), rSize / 2);

   348             } else {

   349                 fieldVal += QString::fromAscii(buf.constData(), rSize);

   350             }

   351             memset(buf.data(), 0, colSize);

   352             if (lengthIndicator < colSize) {

   353                 // workaround for Drivermanagers that don't return SQL_NO_DATA

   354                 break;

   355             }

   356         } else if (r == SQL_NO_DATA) {

   357             break;

   358         } else {

   359             qWarning() << "qGetStringData: Error while fetching data (" << qWarnODBCHandle(SQL_HANDLE_STMT, hStmt) << ')';

   360             fieldVal.clear();

   361             break;

   362         }

   363     }

   364     return fieldVal;

   365 }

   366 

   367 static QVariant qGetBinaryData(SQLHANDLE hStmt, int column)

   368 {

   369     QByteArray fieldVal;

   370     SQLSMALLINT colNameLen;

   371     SQLSMALLINT colType;

   372     QSQLULEN colSize;

   373     SQLSMALLINT colScale;

   374     SQLSMALLINT nullable;

   375     QSQLLEN lengthIndicator = 0;

   376     SQLRETURN r = SQL_ERROR;

   377 

   378     SQLTCHAR colName[COLNAMESIZE];

   379     r = SQLDescribeCol(hStmt,

   380                        column + 1,

   381                        colName,

   382                        COLNAMESIZE,

   383                        &colNameLen,

   384                        &colType,

   385                        &colSize,

   386                        &colScale,

   387                        &nullable);

   388     if (r != SQL_SUCCESS)

   389         qWarning() << "qGetBinaryData: Unable to describe column" << column;

   390     // SQLDescribeCol may return 0 if size cannot be determined

   391     if (!colSize)

   392         colSize = 255;

   393     else if (colSize > 65536) // read the field in 64 KB chunks

   394         colSize = 65536;

   395     fieldVal.resize(colSize);

   396     ulong read = 0;

   397     while (true) {

   398         r = SQLGetData(hStmt,

   399                         column+1,

   400                         SQL_C_BINARY,

   401                         (SQLPOINTER)(fieldVal.constData() + read),

   402                         colSize,

   403                         &lengthIndicator);

   404         if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)

   405             break;

   406         if (lengthIndicator == SQL_NULL_DATA)

   407             return QVariant(QVariant::ByteArray);

   408         if (lengthIndicator > QSQLLEN(colSize) || lengthIndicator == SQL_NO_TOTAL) {

   409             read += colSize;

   410             colSize = 65536;

   411         } else {

   412             read += lengthIndicator;

   413         }

   414         if (r == SQL_SUCCESS) { // the whole field was read in one chunk

   415             fieldVal.resize(read);

   416             break;

   417         }

   418         fieldVal.resize(fieldVal.size() + colSize);

   419     }

   420     return fieldVal;

   421 }

   422 

   423 static QVariant qGetIntData(SQLHANDLE hStmt, int column, bool isSigned = true)

   424 {

   425     SQLINTEGER intbuf = 0;

   426     QSQLLEN lengthIndicator = 0;

   427     SQLRETURN r = SQLGetData(hStmt,

   428                               column+1,

   429                               isSigned ? SQL_C_SLONG : SQL_C_ULONG,

   430                               (SQLPOINTER)&intbuf,

   431                               sizeof(intbuf),

   432                               &lengthIndicator);

   433     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)

   434         return QVariant(QVariant::Invalid);

   435     if (lengthIndicator == SQL_NULL_DATA)

   436         return QVariant(QVariant::Int);

   437     if (isSigned)

   438         return int(intbuf);

   439     else

   440         return uint(intbuf);

   441 }

   442 

   443 static QVariant qGetDoubleData(SQLHANDLE hStmt, int column)

   444 {

   445     SQLDOUBLE dblbuf;

   446     QSQLLEN lengthIndicator = 0;

   447     SQLRETURN r = SQLGetData(hStmt,

   448                               column+1,

   449                               SQL_C_DOUBLE,

   450                               (SQLPOINTER) &dblbuf,

   451                               0,

   452                               &lengthIndicator);

   453     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {

   454         return QVariant(QVariant::Invalid);

   455     }

   456     if(lengthIndicator == SQL_NULL_DATA)

   457         return QVariant(QVariant::Double);

   458 

   459     return (double) dblbuf;

   460 }

   461 

   462 

   463 static QVariant qGetBigIntData(SQLHANDLE hStmt, int column, bool isSigned = true)

   464 {

   465     SQLBIGINT lngbuf = 0;

   466     QSQLLEN lengthIndicator = 0;

   467     SQLRETURN r = SQLGetData(hStmt,

   468                               column+1,

   469                               isSigned ? SQL_C_SBIGINT : SQL_C_UBIGINT,

   470                               (SQLPOINTER) &lngbuf,

   471                               sizeof(lngbuf),

   472                               &lengthIndicator);

   473     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)

   474         return QVariant(QVariant::Invalid);

   475     if (lengthIndicator == SQL_NULL_DATA)

   476         return QVariant(QVariant::LongLong);

   477 

   478     if (isSigned)

   479         return qint64(lngbuf);

   480     else

   481         return quint64(lngbuf);

   482 }

   483 

   484 // creates a QSqlField from a valid hStmt generated

   485 // by SQLColumns. The hStmt has to point to a valid position.

   486 static QSqlField qMakeFieldInfo(const SQLHANDLE hStmt, const QODBCDriverPrivate* p)

   487 {

   488     QString fname = qGetStringData(hStmt, 3, -1, p->unicode);

   489     int type = qGetIntData(hStmt, 4).toInt(); // column type

   490     QSqlField f(fname, qDecodeODBCType(type, p));

   491     int required = qGetIntData(hStmt, 10).toInt(); // nullable-flag

   492     // required can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN

   493     if (required == SQL_NO_NULLS)

   494         f.setRequired(true);

   495     else if (required == SQL_NULLABLE)

   496         f.setRequired(false);

   497     // else we don't know

   498     QVariant var = qGetIntData(hStmt, 6);

   499     f.setLength(var.isNull() ? -1 : var.toInt()); // column size

   500     var = qGetIntData(hStmt, 8).toInt();

   501     f.setPrecision(var.isNull() ? -1 : var.toInt()); // precision

   502     f.setSqlType(type);

   503     return f;

   504 }

   505 

   506 static QSqlField qMakeFieldInfo(const QODBCPrivate* p, int i )

   507 {

   508     SQLSMALLINT colNameLen;

   509     SQLSMALLINT colType;

   510     QSQLULEN colSize;

   511     SQLSMALLINT colScale;

   512     SQLSMALLINT nullable;

   513     SQLRETURN r = SQL_ERROR;

   514     SQLTCHAR colName[COLNAMESIZE];

   515     r = SQLDescribeCol(p->hStmt,

   516                         i+1,

   517                         colName,

   518                         (SQLSMALLINT)COLNAMESIZE,

   519                         &colNameLen,

   520                         &colType,

   521                         &colSize,

   522                         &colScale,

   523                         &nullable);

   524 

   525     if (r != SQL_SUCCESS) {

   526         qSqlWarning(QString::fromLatin1("qMakeField: Unable to describe column %1").arg(i), p);

   527         return QSqlField();

   528     }

   529 

   530     QSQLLEN unsignedFlag = SQL_FALSE;

   531     r = SQLColAttribute (p->hStmt,

   532                          i + 1,

   533                          SQL_DESC_UNSIGNED,

   534                          0,

   535                          0,

   536                          0,

   537                          &unsignedFlag);

   538     if (r != SQL_SUCCESS) {

   539         qSqlWarning(QString::fromLatin1("qMakeField: Unable to get column attributes for column %1").arg(i), p);

   540     }

   541 

   542 #ifdef UNICODE

   543     QString qColName((const QChar*)colName, colNameLen);

   544 #else

   545     QString qColName = QString::fromLocal8Bit((const char*)colName);

   546 #endif

   547     // nullable can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN

   548     int required = -1;

   549     if (nullable == SQL_NO_NULLS) {

   550         required = 1;

   551     } else if (nullable == SQL_NULLABLE) {

   552         required = 0;

   553     }

   554     QVariant::Type type = qDecodeODBCType(colType, p, unsignedFlag == SQL_FALSE);

   555     QSqlField f(qColName, type);

   556     f.setSqlType(colType);

   557     f.setLength(colSize == 0 ? -1 : int(colSize));

   558     f.setPrecision(colScale == 0 ? -1 : int(colScale));

   559     if (nullable == SQL_NO_NULLS)

   560         f.setRequired(true);

   561     else if (nullable == SQL_NULLABLE)

   562         f.setRequired(false);

   563     // else we don't know

   564     return f;

   565 }

   566 

   567 static int qGetODBCVersion(const QString &connOpts)

   568 {

   569 #ifndef Q_ODBC_VERSION_2

   570     if (connOpts.contains(QLatin1String("SQL_ATTR_ODBC_VERSION=SQL_OV_ODBC3"), Qt::CaseInsensitive))

   571         return SQL_OV_ODBC3;

   572 #endif

   573     return SQL_OV_ODBC2;

   574 }

   575 

   576 QChar QODBCDriverPrivate::quoteChar()

   577 {

   578     if (!isQuoteInitialized) {

   579         char driverResponse[4];

   580         SQLSMALLINT length;

   581         int r = SQLGetInfo(hDbc,

   582                 SQL_IDENTIFIER_QUOTE_CHAR,

   583                 &driverResponse,

   584                 sizeof(driverResponse),

   585                 &length);

   586         if (r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) {

   587             quote = QLatin1Char(driverResponse[0]);

   588         } else {

   589             quote = QLatin1Char('"');

   590         }

   591         isQuoteInitialized = true;

   592     }

   593     return quote;

   594 }

   595 

   596 

   597 bool QODBCDriverPrivate::setConnectionOptions(const QString& connOpts)

   598 {

   599     // Set any connection attributes

   600     const QStringList opts(connOpts.split(QLatin1Char(';'), QString::SkipEmptyParts));

   601     SQLRETURN r = SQL_SUCCESS;

   602     for (int i = 0; i < opts.count(); ++i) {

   603         const QString tmp(opts.at(i));

   604         int idx;

   605         if ((idx = tmp.indexOf(QLatin1Char('='))) == -1) {

   606             qWarning() << "QODBCDriver::open: Illegal connect option value '" << tmp << '\'';

   607             continue;

   608         }

   609         const QString opt(tmp.left(idx));

   610         const QString val(tmp.mid(idx + 1).simplified());

   611         SQLUINTEGER v = 0;

   612 

   613         r = SQL_SUCCESS;

   614         if (opt.toUpper() == QLatin1String("SQL_ATTR_ACCESS_MODE")) {

   615             if (val.toUpper() == QLatin1String("SQL_MODE_READ_ONLY")) {

   616                 v = SQL_MODE_READ_ONLY;

   617             } else if (val.toUpper() == QLatin1String("SQL_MODE_READ_WRITE")) {

   618                 v = SQL_MODE_READ_WRITE;

   619             } else {

   620                 qWarning() << "QODBCDriver::open: Unknown option value '" << val << '\'';

   621                 continue;

   622             }

   623             r = SQLSetConnectAttr(hDbc, SQL_ATTR_ACCESS_MODE, (SQLPOINTER) v, 0);

   624         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_CONNECTION_TIMEOUT")) {

   625             v = val.toUInt();

   626             r = SQLSetConnectAttr(hDbc, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER) v, 0);

   627         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_LOGIN_TIMEOUT")) {

   628             v = val.toUInt();

   629             r = SQLSetConnectAttr(hDbc, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER) v, 0);

   630         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_CURRENT_CATALOG")) {

   631             val.utf16(); // 0 terminate

   632             r = SQLSetConnectAttr(hDbc, SQL_ATTR_CURRENT_CATALOG,

   633 #ifdef UNICODE

   634                                     (SQLWCHAR*) val.unicode(),

   635 #else

   636                                     (SQLCHAR*) val.toLatin1().constData(),

   637 #endif

   638                                     SQL_NTS);

   639         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_METADATA_ID")) {

   640             if (val.toUpper() == QLatin1String("SQL_TRUE")) {

   641                 v = SQL_TRUE;

   642             } else if (val.toUpper() == QLatin1String("SQL_FALSE")) {

   643                 v = SQL_FALSE;

   644             } else {

   645                 qWarning() << "QODBCDriver::open: Unknown option value '" << val << '\'';

   646                 continue;

   647             }

   648             r = SQLSetConnectAttr(hDbc, SQL_ATTR_METADATA_ID, (SQLPOINTER) v, 0);

   649         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_PACKET_SIZE")) {

   650             v = val.toUInt();

   651             r = SQLSetConnectAttr(hDbc, SQL_ATTR_PACKET_SIZE, (SQLPOINTER) v, 0);

   652         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_TRACEFILE")) {

   653             val.utf16(); // 0 terminate

   654             r = SQLSetConnectAttr(hDbc, SQL_ATTR_TRACEFILE,

   655 #ifdef UNICODE

   656                                     (SQLWCHAR*) val.unicode(),

   657 #else

   658                                     (SQLCHAR*) val.toLatin1().constData(),

   659 #endif

   660                                     SQL_NTS);

   661         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_TRACE")) {

   662             if (val.toUpper() == QLatin1String("SQL_OPT_TRACE_OFF")) {

   663                 v = SQL_OPT_TRACE_OFF;

   664             } else if (val.toUpper() == QLatin1String("SQL_OPT_TRACE_ON")) {

   665                 v = SQL_OPT_TRACE_ON;

   666             } else {

   667                 qWarning() << "QODBCDriver::open: Unknown option value '" << val << '\'';

   668                 continue;

   669             }

   670             r = SQLSetConnectAttr(hDbc, SQL_ATTR_TRACE, (SQLPOINTER) v, 0);

   671 #ifndef Q_ODBC_VERSION_2

   672         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_CONNECTION_POOLING")) {

   673             if (val == QLatin1String("SQL_CP_OFF"))

   674                 v = SQL_CP_OFF;

   675             else if (val.toUpper() == QLatin1String("SQL_CP_ONE_PER_DRIVER"))

   676                 v = SQL_CP_ONE_PER_DRIVER;

   677             else if (val.toUpper() == QLatin1String("SQL_CP_ONE_PER_HENV"))

   678                 v = SQL_CP_ONE_PER_HENV;

   679             else if (val.toUpper() == QLatin1String("SQL_CP_DEFAULT"))

   680                 v = SQL_CP_DEFAULT;

   681             else {

   682                 qWarning() << "QODBCDriver::open: Unknown option value '" << val << '\'';

   683                 continue;

   684             }

   685             r = SQLSetConnectAttr(hDbc, SQL_ATTR_CONNECTION_POOLING, (SQLPOINTER)v, 0);

   686         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_CP_MATCH")) {

   687             if (val.toUpper() == QLatin1String("SQL_CP_STRICT_MATCH"))

   688                 v = SQL_CP_STRICT_MATCH;

   689             else if (val.toUpper() == QLatin1String("SQL_CP_RELAXED_MATCH"))

   690                 v = SQL_CP_RELAXED_MATCH;

   691             else if (val.toUpper() == QLatin1String("SQL_CP_MATCH_DEFAULT"))

   692                 v = SQL_CP_MATCH_DEFAULT;

   693             else {

   694                 qWarning() << "QODBCDriver::open: Unknown option value '" << val << '\'';

   695                 continue;

   696             }

   697             r = SQLSetConnectAttr(hDbc, SQL_ATTR_CP_MATCH, (SQLPOINTER)v, 0);

   698 #endif

   699         } else if (opt.toUpper() == QLatin1String("SQL_ATTR_ODBC_VERSION")) {

   700             // Already handled in QODBCDriver::open()

   701             continue;

   702         } else {

   703                 qWarning() << "QODBCDriver::open: Unknown connection attribute '" << opt << '\'';

   704         }

   705         if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO)

   706             qSqlWarning(QString::fromLatin1("QODBCDriver::open: Unable to set connection attribute'%1'").arg(

   707                         opt), this);

   708     }

   709     return true;

   710 }

   711 

   712 void QODBCDriverPrivate::splitTableQualifier(const QString & qualifier, QString &catalog,

   713                                        QString &schema, QString &table)

   714 {

   715     if (!useSchema) {

   716         table = qualifier;

   717         return;

   718     }

   719     QStringList l = qualifier.split(QLatin1Char('.'));

   720     if (l.count() > 3)

   721         return; // can't possibly be a valid table qualifier

   722     int i = 0, n = l.count();

   723     if (n == 1) {

   724         table = qualifier;

   725     } else {

   726         for (QStringList::Iterator it = l.begin(); it != l.end(); ++it) {

   727             if (n == 3) {

   728                 if (i == 0) {

   729                     catalog = *it;

   730                 } else if (i == 1) {

   731                     schema = *it;

   732                 } else if (i == 2) {

   733                     table = *it;

   734                 }

   735             } else if (n == 2) {

   736                 if (i == 0) {

   737                     schema = *it;

   738                 } else if (i == 1) {

   739                     table = *it;

   740                 }

   741             }

   742             i++;

   743         }

   744     }

   745 }

   746 

   747 QODBCDriverPrivate::DefaultCase QODBCDriverPrivate::defaultCase() const

   748 {

   749     DefaultCase ret;

   750     SQLUSMALLINT casing;

   751     int r = SQLGetInfo(hDbc,

   752             SQL_IDENTIFIER_CASE,

   753             &casing,

   754             sizeof(casing),

   755             NULL);

   756     if ( r != SQL_SUCCESS)

   757         ret = Mixed;//arbitrary case if driver cannot be queried

   758     else {

   759         switch (casing) {

   760             case (SQL_IC_UPPER):

   761                 ret = Upper;

   762                 break;

   763             case (SQL_IC_LOWER):

   764                 ret = Lower;

   765                 break;

   766             case (SQL_IC_SENSITIVE):

   767                 ret = Sensitive;

   768                 break;

   769             case (SQL_IC_MIXED):

   770             default:

   771                 ret = Mixed;

   772                 break;

   773         }

   774     }

   775     return ret;

   776 }

   777 

   778 /*

   779    Adjust the casing of an identifier to match what the

   780    database engine would have done to it.

   781 */

   782 QString QODBCDriverPrivate::adjustCase(const QString &identifier) const

   783 {

   784     QString ret = identifier;

   785     switch(defaultCase()) {

   786         case (Lower):

   787             ret = identifier.toLower();

   788             break;

   789         case (Upper):

   790             ret = identifier.toUpper();

   791             break;

   792         case(Mixed):

   793         case(Sensitive):

   794         default:

   795             ret = identifier;

   796     }

   797     return ret;

   798 }

   799 

   800 ////////////////////////////////////////////////////////////////////////////

   801 

   802 QODBCResult::QODBCResult(const QODBCDriver * db, QODBCDriverPrivate* p)

   803 : QSqlResult(db)

   804 {

   805     d = new QODBCPrivate(p);

   806     d->unicode = p->unicode;

   807     d->useSchema = p->useSchema;

   808     d->disconnectCount = p->disconnectCount;

   809     d->hasSQLFetchScroll = p->hasSQLFetchScroll;

   810 }

   811 

   812 QODBCResult::~QODBCResult()

   813 {

   814     if (d->hStmt && d->isStmtHandleValid(driver()) && driver()->isOpen()) {

   815         SQLRETURN r = SQLFreeHandle(SQL_HANDLE_STMT, d->hStmt);

   816         if (r != SQL_SUCCESS)

   817             qSqlWarning(QLatin1String("QODBCDriver: Unable to free statement handle ")

   818                          + QString::number(r), d);

   819     }

   820 

   821     delete d;

   822 }

   823 

   824 bool QODBCResult::reset (const QString& query)

   825 {

   826     setActive(false);

   827     setAt(QSql::BeforeFirstRow);

   828     d->rInf.clear();

   829     d->fieldCache.clear();

   830     d->fieldCacheIdx = 0;

   831 

   832     // Always reallocate the statement handle - the statement attributes

   833     // are not reset if SQLFreeStmt() is called which causes some problems.

   834     SQLRETURN r;

   835     if (d->hStmt && d->isStmtHandleValid(driver())) {

   836         r = SQLFreeHandle(SQL_HANDLE_STMT, d->hStmt);

   837         if (r != SQL_SUCCESS) {

   838             qSqlWarning(QLatin1String("QODBCResult::reset: Unable to free statement handle"), d);

   839             return false;

   840         }

   841     }

   842     r  = SQLAllocHandle(SQL_HANDLE_STMT,

   843                          d->dpDbc(),

   844                          &d->hStmt);

   845     if (r != SQL_SUCCESS) {

   846         qSqlWarning(QLatin1String("QODBCResult::reset: Unable to allocate statement handle"), d);

   847         return false;

   848     }

   849 

   850     d->updateStmtHandleState(driver());

   851 

   852     if (d->userForwardOnly) {

   853         r = SQLSetStmtAttr(d->hStmt,

   854                             SQL_ATTR_CURSOR_TYPE,

   855                             (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,

   856                             SQL_IS_UINTEGER);

   857     } else {

   858         r = SQLSetStmtAttr(d->hStmt,

   859                             SQL_ATTR_CURSOR_TYPE,

   860                             (SQLPOINTER)SQL_CURSOR_STATIC,

   861                             SQL_IS_UINTEGER);

   862     }

   863     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {

   864         setLastError(qMakeError(QCoreApplication::translate("QODBCResult",

   865             "QODBCResult::reset: Unable to set 'SQL_CURSOR_STATIC' as statement attribute. "

   866             "Please check your ODBC driver configuration"), QSqlError::StatementError, d));

   867         return false;

   868     }

   869 

   870 #ifdef UNICODE

   871     r = SQLExecDirect(d->hStmt,

   872                        (SQLWCHAR*) query.unicode(),

   873                        (SQLINTEGER) query.length());

   874 #else

   875     QByteArray query8 = query.toLocal8Bit();

   876     r = SQLExecDirect(d->hStmt,

   877                        (SQLCHAR*) query8.constData(),

   878                        (SQLINTEGER) query8.length());

   879 #endif

   880     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {

   881         setLastError(qMakeError(QCoreApplication::translate("QODBCResult",

   882                      "Unable to execute statement"), QSqlError::StatementError, d));

   883         return false;

   884     }

   885 

   886     SQLINTEGER isScrollable, bufferLength;

   887     r = SQLGetStmtAttr(d->hStmt, SQL_ATTR_CURSOR_SCROLLABLE, &isScrollable, SQL_IS_INTEGER, &bufferLength);

   888     if(r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO)

   889         QSqlResult::setForwardOnly(isScrollable==SQL_NONSCROLLABLE);

   890 

   891     SQLSMALLINT count;

   892     SQLNumResultCols(d->hStmt, &count);

   893     if (count) {

   894         setSelect(true);

   895         for (int i = 0; i < count; ++i) {

   896             d->rInf.append(qMakeFieldInfo(d, i));

   897         }

   898         d->fieldCache.resize(count);

   899     } else {

   900         setSelect(false);

   901     }

   902     setActive(true);

   903 

   904     return true;

   905 }

   906 

   907 bool QODBCResult::fetch(int i)

   908 {

   909     if (!driver()->isOpen())

   910         return false;

   911 

   912     if (isForwardOnly() && i < at())

   913         return false;

   914     if (i == at())

   915         return true;

   916     d->clearValues();

   917     int actualIdx = i + 1;

   918     if (actualIdx <= 0) {

   919         setAt(QSql::BeforeFirstRow);

   920         return false;

   921     }

   922     SQLRETURN r;

   923     if (isForwardOnly()) {

   924         bool ok = true;

   925         while (ok && i > at())

   926             ok = fetchNext();

   927         return ok;

   928     } else {

   929         r = SQLFetchScroll(d->hStmt,

   930                             SQL_FETCH_ABSOLUTE,

   931                             actualIdx);

   932     }

   933     if (r != SQL_SUCCESS) {

   934         if (r != SQL_NO_DATA)

   935             setLastError(qMakeError(QCoreApplication::translate("QODBCResult",

   936                 "Unable to fetch"), QSqlError::ConnectionError, d));

   937         return false;

   938     }

   939     setAt(i);

   940     return true;

   941 }

   942 

   943 bool QODBCResult::fetchNext()

   944 {

   945     SQLRETURN r;

   946     d->clearValues();

   947 

   948     if (d->hasSQLFetchScroll)

   949         r = SQLFetchScroll(d->hStmt,

   950                            SQL_FETCH_NEXT,

   951                            0);

   952     else

   953         r = SQLFetch(d->hStmt);

   954 

   955     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {

   956         if (r != SQL_NO_DATA)

   957             setLastError(qMakeError(QCoreApplication::translate("QODBCResult",

   958                 "Unable to fetch next"), QSqlError::ConnectionError, d));

   959         return false;

   960     }

   961     setAt(at() + 1);

   962     return true;

   963 }

   964 

   965 bool QODBCResult::fetchFirst()

   966 {

   967     if (isForwardOnly() && at() != QSql::BeforeFirstRow)

   968         return false;

   969     SQLRETURN r;

   970     d->clearValues();

   971     if (isForwardOnly()) {

   972         return fetchNext();

   973     }

   974     r = SQLFetchScroll(d->hStmt,

   975                        SQL_FETCH_FIRST,

   976                        0);

   977     if (r != SQL_SUCCESS) {

   978         if (r != SQL_NO_DATA)

   979             setLastError(qMakeError(QCoreApplication::translate("QODBCResult",

   980                 "Unable to fetch first"), QSqlError::ConnectionError, d));

   981         return false;

   982     }

   983     setAt(0);

   984     return true;

   985 }

   986 

   987 bool QODBCResult::fetchPrevious()

   988 {

   989     if (isForwardOnly())

   990         return false;

   991     SQLRETURN r;

   992     d->clearValues();

   993     r = SQLFetchScroll(d->hStmt,

   994                        SQL_FETCH_PRIOR,

   995                        0);

   996     if (r != SQL_SUCCESS) {

   997         if (r != SQL_NO_DATA)

   998             setLastError(qMakeError(QCoreApplication::translate("QODBCResult",

   999                 "Unable to fetch previous"), QSqlError::ConnectionError, d));

  1000         return false;

  1001     }

  1002     setAt(at() - 1);

  1003     return true;

  1004 }

  1005 

  1006 bool QODBCResult::fetchLast()

  1007 {

  1008     SQLRETURN r;

  1009     d->clearValues();

  1010 

  1011     if (isForwardOnly()) {

  1012         // cannot seek to last row in forwardOnly mode, so we have to use brute force

  1013         int i = at();

  1014         if (i == QSql::AfterLastRow)

  1015             return false;

  1016         if (i == QSql::BeforeFirstRow)

  1017             i = 0;

  1018         while (fetchNext())

  1019             ++i;

  1020         setAt(i);

  1021         return true;

  1022     }

  1023 

  1024     r = SQLFetchScroll(d->hStmt,

  1025                        SQL_FETCH_LAST,

  1026                        0);

  1027     if (r != SQL_SUCCESS) {

  1028         if (r != SQL_NO_DATA)

  1029             setLastError(qMakeError(QCoreApplication::translate("QODBCResult",

  1030                 "Unable to fetch last"), QSqlError::ConnectionError, d));

  1031         return false;

  1032     }

  1033     SQLINTEGER currRow;

  1034     r = SQLGetStmtAttr(d->hStmt,

  1035                         SQL_ROW_NUMBER,

  1036                         &currRow,

  1037                         SQL_IS_INTEGER,

  1038                         0);

  1039     if (r != SQL_SUCCESS)

  1040         return false;

  1041     setAt(currRow-1);

  1042     return true;

  1043 }

  1044 

  1045 QVariant QODBCResult::data(int field)

  1046 {

  1047     if (field >= d->rInf.count() || field < 0) {

  1048         qWarning() << "QODBCResult::data: column" << field << "out of range";

  1049         return QVariant();

  1050     }

  1051     if (field < d->fieldCacheIdx)

  1052         return d->fieldCache.at(field);

  1053 

  1054     SQLRETURN r(0);

  1055     QSQLLEN lengthIndicator = 0;

  1056 

  1057     for (int i = d->fieldCacheIdx; i <= field; ++i) {

  1058         // some servers do not support fetching column n after we already

  1059         // fetched column n+1, so cache all previous columns here

  1060         const QSqlField info = d->rInf.field(i);

  1061         switch (info.type()) {

  1062         case QVariant::LongLong:

  1063             d->fieldCache[i] = qGetBigIntData(d->hStmt, i);

  1064         break;

  1065         case QVariant::ULongLong:

  1066             d->fieldCache[i] = qGetBigIntData(d->hStmt, i, false);

  1067             break;

  1068         case QVariant::Int:

  1069             d->fieldCache[i] = qGetIntData(d->hStmt, i);

  1070         break;

  1071         case QVariant::UInt:

  1072             d->fieldCache[i] = qGetIntData(d->hStmt, i, false);

  1073             break;

  1074         case QVariant::Date:

  1075             DATE_STRUCT dbuf;

  1076             r = SQLGetData(d->hStmt,

  1077                             i + 1,

  1078                             SQL_C_DATE,

  1079                             (SQLPOINTER)&dbuf,

  1080                             0,

  1081                             &lengthIndicator);

  1082             if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA))

  1083                 d->fieldCache[i] = QVariant(QDate(dbuf.year, dbuf.month, dbuf.day));

  1084             else

  1085                 d->fieldCache[i] = QVariant(QVariant::Date);

  1086         break;

  1087         case QVariant::Time:

  1088             TIME_STRUCT tbuf;

  1089             r = SQLGetData(d->hStmt,

  1090                             i + 1,

  1091                             SQL_C_TIME,

  1092                             (SQLPOINTER)&tbuf,

  1093                             0,

  1094                             &lengthIndicator);

  1095             if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA))

  1096                 d->fieldCache[i] = QVariant(QTime(tbuf.hour, tbuf.minute, tbuf.second));

  1097             else

  1098                 d->fieldCache[i] = QVariant(QVariant::Time);

  1099         break;

  1100         case QVariant::DateTime:

  1101             TIMESTAMP_STRUCT dtbuf;

  1102             r = SQLGetData(d->hStmt,

  1103                             i + 1,

  1104                             SQL_C_TIMESTAMP,

  1105                             (SQLPOINTER)&dtbuf,

  1106                             0,

  1107                             &lengthIndicator);

  1108             if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA))

  1109                 d->fieldCache[i] = QVariant(QDateTime(QDate(dtbuf.year, dtbuf.month, dtbuf.day),

  1110                        QTime(dtbuf.hour, dtbuf.minute, dtbuf.second, dtbuf.fraction / 1000000)));

  1111             else

  1112                 d->fieldCache[i] = QVariant(QVariant::DateTime);

  1113             break;

  1114         case QVariant::ByteArray:

  1115             d->fieldCache[i] = qGetBinaryData(d->hStmt, i);

  1116             break;

  1117         case QVariant::String:

  1118             d->fieldCache[i] = qGetStringData(d->hStmt, i, info.length(), d->unicode);

  1119             break;

  1120         case QVariant::Double:

  1121             switch(numericalPrecisionPolicy()) {

  1122                 case QSql::LowPrecisionInt32:

  1123                     d->fieldCache[i] = qGetIntData(d->hStmt, i);

  1124                     break;

  1125                 case QSql::LowPrecisionInt64:

  1126                     d->fieldCache[i] = qGetBigIntData(d->hStmt, i);

  1127                     break;

  1128                 case QSql::LowPrecisionDouble:

  1129                     d->fieldCache[i] = qGetDoubleData(d->hStmt, i);

  1130                     break;

  1131                 case QSql::HighPrecision:

  1132                     d->fieldCache[i] = qGetStringData(d->hStmt, i, info.length(), false);

  1133                     break;

  1134             }