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

     2 **

     3 ** Copyright (C) 2010 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_TCHAR 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 static const int COLNAMESIZE = 256;

    82 //Map Qt parameter types to ODBC types

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

    84 

    85 inline static QString fromSQLTCHAR(const QVarLengthArray<SQLTCHAR>& input, int size=-1)

    86 {

    87     QString result;

    88 

    89     int realsize = qMin(size, input.size());

    90     if(realsize > 0 && input[realsize-1] == 0)

    91         realsize--;

    92     switch(sizeof(SQLTCHAR)) {

    93         case 1:

    94             result=QString::fromUtf8((const char *)input.constData(), realsize);

    95             break;

    96         case 2:

    97             result=QString::fromUtf16((const ushort *)input.constData(), realsize);

    98             break;

    99         case 4:

   100             result=QString::fromUcs4((const uint *)input.constData(), realsize);

   101             break;

   102         default:

   103             qCritical() << "sizeof(SQLTCHAR) is " << sizeof(SQLTCHAR) << "Don't know how to handle this";

   104     }

   105     return result;

   106 }

   107 

   108 inline static QVarLengthArray<SQLTCHAR> toSQLTCHAR(const QString &input)

   109 {

   110     QVarLengthArray<SQLTCHAR> result;

   111     result.resize(input.size());

   112     switch(sizeof(SQLTCHAR)) {

   113         case 1:

   114             memcpy(result.data(), input.toUtf8().data(), input.size());

   115             break;

   116         case 2:

   117             memcpy(result.data(), input.unicode(), input.size() * 2);

   118             break;

   119         case 4:

   120             memcpy(result.data(), input.toUcs4().data(), input.size() * 4);

   121             break;

   122         default:

   123             qCritical() << "sizeof(SQLTCHAR) is " << sizeof(SQLTCHAR) << "Don't know how to handle this";

   124     }

   125     result.append(0); // make sure it's null terminated, doesn't matter if it already is, it does if it isn't.

   126     return result;

   127 }

   128 

   129 class QODBCDriverPrivate

   130 {

   131 public:

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

   133     QODBCDriverPrivate()

   134     : hEnv(0), hDbc(0), unicode(false), useSchema(false), disconnectCount(0), isMySqlServer(false),

   135            isMSSqlServer(false), isFreeTDSDriver(false), hasSQLFetchScroll(true),

   136            hasMultiResultSets(false), isQuoteInitialized(false), quote(QLatin1Char('"'))

   137     {

   138     }

   139 

   140     SQLHANDLE hEnv;

   141     SQLHANDLE hDbc;

   142 

   143     bool unicode;

   144     bool useSchema;

   145     int disconnectCount;

   146     bool isMySqlServer;

   147     bool isMSSqlServer;

   148     bool isFreeTDSDriver;

   149     bool hasSQLFetchScroll;

   150     bool hasMultiResultSets;

   151 

   152     bool checkDriver() const;

   153     void checkUnicode();

   154     void checkSqlServer();

   155     void checkHasSQLFetchScroll();

   156     void checkHasMultiResults();

   157     void checkSchemaUsage();

   158     bool setConnectionOptions(const QString& connOpts);

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

   160                              QString &schema, QString &table);

   161     DefaultCase defaultCase() const;

   162     QString adjustCase(const QString&) const;

   163     QChar quoteChar();

   164 private:

   165     bool isQuoteInitialized;

   166     QChar quote;

   167 };

   168 

   169 class QODBCPrivate

   170 {

   171 public:

   172     QODBCPrivate(QODBCDriverPrivate *dpp)

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

   174     {

   175         unicode = dpp->unicode;

   176         useSchema = dpp->useSchema;

   177         disconnectCount = dpp->disconnectCount;

   178         hasSQLFetchScroll = dpp->hasSQLFetchScroll;

   179     }

   180 

   181     inline void clearValues()

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

   183 

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

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

   186     SQLHANDLE hStmt;

   187 

   188     bool unicode;

   189     bool useSchema;

   190 

   191     QSqlRecord rInf;

   192     QVector<QVariant> fieldCache;

   193     int fieldCacheIdx;

   194     int disconnectCount;

   195     bool hasSQLFetchScroll;

   196     QODBCDriverPrivate *driverPrivate;

   197     bool userForwardOnly;

   198 

   199     bool isStmtHandleValid(const QSqlDriver *driver);

   200     void updateStmtHandleState(const QSqlDriver *driver);

   201 };

   202 

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

   204 {

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

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

   207 }

   208 

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

   210 {

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

   212     disconnectCount = odbcdriver->d->disconnectCount;

   213 }

   214 

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

   216 {

   217     SQLINTEGER nativeCode_ = 0;

   218     SQLSMALLINT msgLen = 0;

   219     SQLRETURN r = SQL_NO_DATA;

   220     SQLTCHAR state_[SQL_SQLSTATE_SIZE+1];

   221     QVarLengthArray<SQLTCHAR> description_(SQL_MAX_MESSAGE_LENGTH);

   222     QString result;

   223     int i = 1;

   224 

   225     description_[0] = 0;

   226     do {

   227         r = SQLGetDiagRec(handleType,

   228                           handle,

   229                           i,

   230                           state_,

   231                           &nativeCode_,

   232                           0,

   233                           NULL,

   234                           &msgLen);

   235         if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && msgLen > 0)

   236             description_.resize(msgLen+1);

   237         r = SQLGetDiagRec(handleType,

   238                             handle,

   239                             i,

   240                             state_,

   241                             &nativeCode_,

   242                             description_.data(),

   243                             description_.size(),

   244                             &msgLen);

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

   246             if (nativeCode)

   247                 *nativeCode = nativeCode_;

   248             QString tmpstore;

   249 #ifdef UNICODE

   250             tmpstore = fromSQLTCHAR(description_, msgLen);

   251 #else

   252             tmpstore = QString::fromUtf8((const char*)description_.constData(), msgLen);

   253 #endif

   254             if(result != tmpstore) {

   255                 if(!result.isEmpty())

   256                     result += QLatin1Char(' ');

   257                 result += tmpstore;

   258             }

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

   260             return result;

   261         }

   262         ++i;

   263     } while (r != SQL_NO_DATA);

   264     return result;

   265 }

   266 

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

   268 {

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

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

   271              + qWarnODBCHandle(SQL_HANDLE_STMT, odbc->hStmt, nativeCode)).simplified();

   272 }

   273 

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

   275 {

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

   277              + qWarnODBCHandle(SQL_HANDLE_DBC, odbc->hDbc, nativeCode)).simplified();

   278 }

   279 

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

   281 {

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

   283 }

   284 

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

   286 {

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

   288 }

   289 

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

   291 {

   292     int nativeCode = -1;

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

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

   295 }

   296 

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

   298                             const QODBCDriverPrivate* p)

   299 {

   300     int nativeCode = -1;

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

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

   303 }

   304 

   305 template<class T>

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

   307 {

   308     Q_UNUSED(p);

   309     QVariant::Type type = QVariant::Invalid;

   310     switch (sqltype) {

   311     case SQL_DECIMAL:

   312     case SQL_NUMERIC:

   313     case SQL_REAL:

   314     case SQL_FLOAT:

   315     case SQL_DOUBLE:

   316         type = QVariant::Double;

   317         break;

   318     case SQL_SMALLINT:

   319     case SQL_INTEGER:

   320     case SQL_BIT:

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

   322         break;

   323     case SQL_TINYINT:

   324         type = QVariant::UInt;

   325         break;

   326     case SQL_BIGINT:

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

   328         break;

   329     case SQL_BINARY:

   330     case SQL_VARBINARY:

   331     case SQL_LONGVARBINARY:

   332         type = QVariant::ByteArray;

   333         break;

   334     case SQL_DATE:

   335     case SQL_TYPE_DATE:

   336         type = QVariant::Date;

   337         break;

   338     case SQL_TIME:

   339     case SQL_TYPE_TIME:

   340         type = QVariant::Time;

   341         break;

   342     case SQL_TIMESTAMP:

   343     case SQL_TYPE_TIMESTAMP:

   344         type = QVariant::DateTime;

   345         break;

   346 #ifndef Q_ODBC_VERSION_2

   347     case SQL_WCHAR:

   348     case SQL_WVARCHAR:

   349     case SQL_WLONGVARCHAR:

   350         type = QVariant::String;

   351         break;

   352 #endif

   353     case SQL_CHAR:

   354     case SQL_VARCHAR:

   355 #if (ODBCVER >= 0x0350)

   356     case SQL_GUID:

   357 #endif

   358     case SQL_LONGVARCHAR:

   359         type = QVariant::String;

   360         break;

   361     default:

   362         type = QVariant::ByteArray;

   363         break;

   364     }

   365     return type;

   366 }

   367 

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

   369 {

   370     QString fieldVal;

   371     SQLRETURN r = SQL_ERROR;

   372     QSQLLEN lengthIndicator = 0;

   373 

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

   375     if (colSize <= 0) {

   376         colSize = 256;

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

   378         colSize = 65536;

   379     } else {

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

   381     }

   382     if(unicode) {

   383         r = SQLGetData(hStmt,

   384                         column+1,

   385                         SQL_C_TCHAR,

   386                         NULL,

   387                         0,

   388                         &lengthIndicator);

   389         if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && lengthIndicator > 0)

   390             colSize = lengthIndicator/sizeof(SQLTCHAR) + 1;

   391         QVarLengthArray<SQLTCHAR> buf(colSize);

   392         memset(buf.data(), 0, colSize*sizeof(SQLTCHAR));

   393         while (true) {

   394             r = SQLGetData(hStmt,

   395                             column+1,

   396                             SQL_C_TCHAR,

   397                             (SQLPOINTER)buf.data(),

   398                             colSize*sizeof(SQLTCHAR),

   399                             &lengthIndicator);

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

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

   402                     fieldVal.clear();

   403                     break;

   404                 }

   405                 // if SQL_SUCCESS_WITH_INFO is returned, indicating that

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

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

   408                 // total number of bytes that CAN be fetched

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

   410                 int rSize = (r == SQL_SUCCESS_WITH_INFO) ? colSize : lengthIndicator/sizeof(SQLTCHAR);

   411                     fieldVal += fromSQLTCHAR(buf, rSize);

   412                 if (lengthIndicator < (unsigned int)colSize*sizeof(SQLTCHAR)) {

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

   414                     break;

   415                 }

   416             } else if (r == SQL_NO_DATA) {

   417                 break;

   418             } else {

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

   420                 fieldVal.clear();

   421                 break;

   422             }

   423         }

   424     } else {

   425         r = SQLGetData(hStmt,

   426                         column+1,

   427                         SQL_C_CHAR,

   428                         NULL,

   429                         0,

   430                         &lengthIndicator);

   431         if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && lengthIndicator > 0)

   432             colSize = lengthIndicator + 1;

   433         QVarLengthArray<SQLCHAR> buf(colSize);

   434         while (true) {

   435             r = SQLGetData(hStmt,

   436                             column+1,

   437                             SQL_C_CHAR,

   438                             (SQLPOINTER)buf.data(),

   439                             colSize,

   440                             &lengthIndicator);

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

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

   443                     fieldVal.clear();

   444                     break;

   445                 }

   446                 // if SQL_SUCCESS_WITH_INFO is returned, indicating that

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

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

   449                 // total number of bytes that CAN be fetched

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

   451                 int rSize = (r == SQL_SUCCESS_WITH_INFO) ? colSize : lengthIndicator;

   452                     fieldVal += QString::fromUtf8((const char *)buf.constData(), rSize);

   453                 if (lengthIndicator < (unsigned int)colSize) {

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

   455                     break;

   456                 }

   457             } else if (r == SQL_NO_DATA) {

   458                 break;

   459             } else {

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

   461                 fieldVal.clear();

   462                 break;

   463             }

   464         }

   465     }

   466     return fieldVal;

   467 }

   468 

   469 static QVariant qGetBinaryData(SQLHANDLE hStmt, int column)

   470 {

   471     QByteArray fieldVal;

   472     SQLSMALLINT colNameLen;

   473     SQLSMALLINT colType;

   474     QSQLULEN colSize;

   475     SQLSMALLINT colScale;

   476     SQLSMALLINT nullable;

   477     QSQLLEN lengthIndicator = 0;

   478     SQLRETURN r = SQL_ERROR;

   479 

   480     QVarLengthArray<SQLTCHAR> colName(COLNAMESIZE);

   481 

   482     r = SQLDescribeCol(hStmt,

   483                        column + 1,

   484                        colName.data(),

   485                        COLNAMESIZE,

   486                        &colNameLen,

   487                        &colType,

   488                        &colSize,

   489                        &colScale,

   490                        &nullable);

   491     if (r != SQL_SUCCESS)

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

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

   494     if (!colSize)

   495         colSize = 255;

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

   497         colSize = 65536;

   498     fieldVal.resize(colSize);

   499     ulong read = 0;

   500     while (true) {

   501         r = SQLGetData(hStmt,

   502                         column+1,

   503                         SQL_C_BINARY,

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

   505                         colSize,

   506                         &lengthIndicator);

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

   508             break;

   509         if (lengthIndicator == SQL_NULL_DATA)

   510             return QVariant(QVariant::ByteArray);

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

   512             read += colSize;

   513             colSize = 65536;

   514         } else {

   515             read += lengthIndicator;

   516         }

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

   518             fieldVal.resize(read);

   519             break;

   520         }

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

   522     }

   523     return fieldVal;

   524 }

   525 

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

   527 {

   528     SQLINTEGER intbuf = 0;

   529     QSQLLEN lengthIndicator = 0;

   530     SQLRETURN r = SQLGetData(hStmt,

   531                               column+1,

   532                               isSigned ? SQL_C_SLONG : SQL_C_ULONG,

   533                               (SQLPOINTER)&intbuf,

   534                               sizeof(intbuf),

   535                               &lengthIndicator);

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

   537         return QVariant(QVariant::Invalid);

   538     if (lengthIndicator == SQL_NULL_DATA)

   539         return QVariant(QVariant::Int);

   540     if (isSigned)

   541         return int(intbuf);

   542     else

   543         return uint(intbuf);

   544 }

   545 

   546 static QVariant qGetDoubleData(SQLHANDLE hStmt, int column)

   547 {

   548     SQLDOUBLE dblbuf;

   549     QSQLLEN lengthIndicator = 0;

   550     SQLRETURN r = SQLGetData(hStmt,

   551                               column+1,

   552                               SQL_C_DOUBLE,

   553                               (SQLPOINTER) &dblbuf,

   554                               0,

   555                               &lengthIndicator);

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

   557         return QVariant(QVariant::Invalid);

   558     }

   559     if(lengthIndicator == SQL_NULL_DATA)

   560         return QVariant(QVariant::Double);

   561 

   562     return (double) dblbuf;

   563 }

   564 

   565 

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

   567 {

   568     SQLBIGINT lngbuf = 0;

   569     QSQLLEN lengthIndicator = 0;

   570     SQLRETURN r = SQLGetData(hStmt,

   571                               column+1,

   572                               isSigned ? SQL_C_SBIGINT : SQL_C_UBIGINT,

   573                               (SQLPOINTER) &lngbuf,

   574                               sizeof(lngbuf),

   575                               &lengthIndicator);

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

   577         return QVariant(QVariant::Invalid);

   578     if (lengthIndicator == SQL_NULL_DATA)

   579         return QVariant(QVariant::LongLong);

   580 

   581     if (isSigned)

   582         return qint64(lngbuf);

   583     else

   584         return quint64(lngbuf);

   585 }

   586 

   587 // creates a QSqlField from a valid hStmt generated

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

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

   590 {

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

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

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

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

   595     // required can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN

   596     if (required == SQL_NO_NULLS)

   597         f.setRequired(true);

   598     else if (required == SQL_NULLABLE)

   599         f.setRequired(false);

   600     // else we don't know

   601     QVariant var = qGetIntData(hStmt, 6);

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

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

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

   605     f.setSqlType(type);

   606     return f;

   607 }

   608 

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

   610 {

   611     SQLSMALLINT colNameLen;

   612     SQLSMALLINT colType;

   613     QSQLULEN colSize;

   614     SQLSMALLINT colScale;

   615     SQLSMALLINT nullable;

   616     SQLRETURN r = SQL_ERROR;

   617     QVarLengthArray<SQLTCHAR> colName(COLNAMESIZE);

   618     r = SQLDescribeCol(p->hStmt,

   619                         i+1,

   620                         colName.data(),

   621                         (SQLSMALLINT)COLNAMESIZE,

   622                         &colNameLen,

   623                         &colType,

   624                         &colSize,

   625                         &colScale,

   626                         &nullable);

   627 

   628     if (r != SQL_SUCCESS) {

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

   630         return QSqlField();

   631     }

   632 

   633     QSQLLEN unsignedFlag = SQL_FALSE;

   634     r = SQLColAttribute (p->hStmt,

   635                          i + 1,

   636                          SQL_DESC_UNSIGNED,

   637                          0,

   638                          0,

   639                          0,

   640                          &unsignedFlag);

   641     if (r != SQL_SUCCESS) {

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

   643     }

   644 

   645 #ifdef UNICODE

   646     QString qColName(fromSQLTCHAR(colName, colNameLen));

   647 #else

   648     QString qColName = QString::fromUtf8((const char *)colName.constData());

   649 #endif

   650     // nullable can be SQL_NO_NULLS, SQL_NULLABLE or SQL_NULLABLE_UNKNOWN

   651     int required = -1;

   652     if (nullable == SQL_NO_NULLS) {

   653         required = 1;

   654     } else if (nullable == SQL_NULLABLE) {

   655         required = 0;

   656     }

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

   658     QSqlField f(qColName, type);

   659     f.setSqlType(colType);

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

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

   662     if (nullable == SQL_NO_NULLS)

   663         f.setRequired(true);

   664     else if (nullable == SQL_NULLABLE)

   665         f.setRequired(false);

   666     // else we don't know

   667     return f;

   668 }

   669 

   670 static int qGetODBCVersion(const QString &connOpts)

   671 {

   672 #ifndef Q_ODBC_VERSION_2

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

   674         return SQL_OV_ODBC3;

   675 #endif

   676     if (connOpts.contains(QLatin1String("SQL_ATTR_ODBC_VERSION=SQL_OV_ODBC2"), Qt::CaseInsensitive))

   677         return SQL_OV_ODBC2;

   678 #ifdef _IODBCUNIX_H

   679     return SQL_OV_ODBC3;

   680 #else

   681     return SQL_OV_ODBC2;

   682 #endif

   683 }

   684 

   685 QChar QODBCDriverPrivate::quoteChar()

   686 {

   687     if (!isQuoteInitialized) {

   688         SQLTCHAR driverResponse[4];

   689         SQLSMALLINT length;

   690         int r = SQLGetInfo(hDbc,

   691                 SQL_IDENTIFIER_QUOTE_CHAR,

   692                 &driverResponse,

   693                 sizeof(driverResponse),

   694                 &length);

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

   696 #ifdef UNICODE

   697             quote = QChar(driverResponse[0]);

   698 #else

   699             quote = QLatin1Char(driverResponse[0]);

   700 #endif

   701         else

   702             quote = QLatin1Char('"');

   703         isQuoteInitialized = true;

   704     }

   705     return quote;

   706 }

   707 

   708 

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

   710 {

   711     // Set any connection attributes

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

   713     SQLRETURN r = SQL_SUCCESS;

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

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

   716         int idx;

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

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

   719             continue;

   720         }

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

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

   723         SQLUINTEGER v = 0;

   724 

   725         r = SQL_SUCCESS;

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

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

   728                 v = SQL_MODE_READ_ONLY;

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

   730                 v = SQL_MODE_READ_WRITE;

   731             } else {

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

   733                 continue;

   734             }

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

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

   737             v = val.toUInt();

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

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

   740             v = val.toUInt();

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

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

   743             val.utf16(); // 0 terminate

   744             r = SQLSetConnectAttr(hDbc, SQL_ATTR_CURRENT_CATALOG,

   745 #ifdef UNICODE

   746                                     toSQLTCHAR(val).data(),

   747 #else

   748                                     (SQLCHAR*) val.toUtf8().data(),

   749 #endif

   750                                     val.length()*sizeof(SQLTCHAR));

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

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

   753                 v = SQL_TRUE;

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

   755                 v = SQL_FALSE;

   756             } else {

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

   758                 continue;

   759             }

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

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

   762             v = val.toUInt();

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

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

   765             val.utf16(); // 0 terminate

   766             r = SQLSetConnectAttr(hDbc, SQL_ATTR_TRACEFILE,

   767 #ifdef UNICODE

   768                                     toSQLTCHAR(val).data(),

   769 #else

   770                                     (SQLCHAR*) val.toUtf8().data(),

   771 #endif

   772                                     val.length()*sizeof(SQLTCHAR));

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

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

   775                 v = SQL_OPT_TRACE_OFF;

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

   777                 v = SQL_OPT_TRACE_ON;

   778             } else {

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

   780                 continue;

   781             }

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

   783 #ifndef Q_ODBC_VERSION_2

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

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

   786                 v = SQL_CP_OFF;

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

   788                 v = SQL_CP_ONE_PER_DRIVER;

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

   790                 v = SQL_CP_ONE_PER_HENV;

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

   792                 v = SQL_CP_DEFAULT;

   793             else {

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

   795                 continue;

   796             }

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

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

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

   800                 v = SQL_CP_STRICT_MATCH;

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

   802                 v = SQL_CP_RELAXED_MATCH;

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

   804                 v = SQL_CP_MATCH_DEFAULT;

   805             else {

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

   807                 continue;

   808             }

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

   810 #endif

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

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

   813             continue;

   814         } else {

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

   816         }

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

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

   819                         opt), this);

   820     }

   821     return true;

   822 }

   823 

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

   825                                        QString &schema, QString &table)

   826 {

   827     if (!useSchema) {

   828         table = qualifier;

   829         return;

   830     }

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

   832     if (l.count() > 3)

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

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

   835     if (n == 1) {

   836         table = qualifier;

   837     } else {

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

   839             if (n == 3) {

   840                 if (i == 0) {

   841                     catalog = *it;

   842                 } else if (i == 1) {

   843                     schema = *it;

   844                 } else if (i == 2) {

   845                     table = *it;

   846                 }

   847             } else if (n == 2) {

   848                 if (i == 0) {

   849                     schema = *it;

   850                 } else if (i == 1) {

   851                     table = *it;

   852                 }

   853             }

   854             i++;

   855         }

   856     }

   857 }

   858 

   859 QODBCDriverPrivate::DefaultCase QODBCDriverPrivate::defaultCase() const

   860 {

   861     DefaultCase ret;

   862     SQLUSMALLINT casing;

   863     int r = SQLGetInfo(hDbc,

   864             SQL_IDENTIFIER_CASE,

   865             &casing,

   866             sizeof(casing),

   867             NULL);

   868     if ( r != SQL_SUCCESS)

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

   870     else {

   871         switch (casing) {

   872             case (SQL_IC_UPPER):

   873                 ret = Upper;

   874                 break;

   875             case (SQL_IC_LOWER):

   876                 ret = Lower;

   877                 break;

   878             case (SQL_IC_SENSITIVE):

   879                 ret = Sensitive;

   880                 break;

   881             case (SQL_IC_MIXED):

   882             default:

   883                 ret = Mixed;

   884                 break;

   885         }

   886     }

   887     return ret;

   888 }

   889 

   890 /*

   891    Adjust the casing of an identifier to match what the

   892    database engine would have done to it.

   893 */

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

   895 {

   896     QString ret = identifier;

   897     switch(defaultCase()) {

   898         case (Lower):

   899             ret = identifier.toLower();

   900             break;

   901         case (Upper):

   902             ret = identifier.toUpper();

   903             break;

   904         case(Mixed):

   905         case(Sensitive):

   906         default:

   907             ret = identifier;

   908     }

   909     return ret;

   910 }

   911 

   912 ////////////////////////////////////////////////////////////////////////////

   913 

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

   915 : QSqlResult(db)

   916 {

   917     d = new QODBCPrivate(p);

   918 }

   919 

   920 QODBCResult::~QODBCResult()

   921 {

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

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

   924         if (r != SQL_SUCCESS)

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

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

   927     }

   928 

   929     delete d;

   930 }

   931 

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

   933 {

   934     setActive(false);

   935     setAt(QSql::BeforeFirstRow);

   936     d->rInf.clear();

   937     d->fieldCache.clear();

   938     d->fieldCacheIdx = 0;

   939 

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

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

   942     SQLRETURN r;

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

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

   945         if (r != SQL_SUCCESS) {

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

   947             return false;

   948         }

   949     }

   950     r  = SQLAllocHandle(SQL_HANDLE_STMT,

   951                          d->dpDbc(),

   952                          &d->hStmt);

   953     if (r != SQL_SUCCESS) {

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

   955         return false;

   956     }

   957 

   958     d->updateStmtHandleState(driver());

   959 

   960     if (d->userForwardOnly) {

   961         r = SQLSetStmtAttr(d->hStmt,

   962                             SQL_ATTR_CURSOR_TYPE,

   963                             (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,

   964                             SQL_IS_UINTEGER);

   965     } else {

   966         r = SQLSetStmtAttr(d->hStmt,

   967                             SQL_ATTR_CURSOR_TYPE,

   968                             (SQLPOINTER)SQL_CURSOR_STATIC,

   969                             SQL_IS_UINTEGER);

   970     }

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

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

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

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

   975         return false;

   976     }

   977 

   978 #ifdef UNICODE

   979     r = SQLExecDirect(d->hStmt,

   980                        toSQLTCHAR(query).data(),

   981                        (SQLINTEGER) query.length());

   982 #else

   983     QByteArray query8 = query.toUtf8();

   984     r = SQLExecDirect(d->hStmt,

   985                        (SQLCHAR*) query8.data(),

   986                        (SQLINTEGER) query8.length());

   987 #endif

   988     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO && r!= SQL_NO_DATA) {

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

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

   991         return false;

   992     }

   993 

   994     if(r == SQL_NO_DATA) {

   995         setSelect(false);

   996         return true;

   997     }

   998 

   999     SQLINTEGER isScrollable, bufferLength;

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

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

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

  1003 

  1004     SQLSMALLINT count;

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

  1006     if (count) {

  1007         setSelect(true);

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

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

  1010         }

  1011         d->fieldCache.resize(count);

  1012     } else {

  1013         setSelect(false);

  1014     }

  1015     setActive(true);

  1016 

  1017     return true;

  1018 }

  1019 

  1020 bool QODBCResult::fetch(int i)

  1021 {

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

  1023         return false;

  1024 

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

  1026         return false;

  1027     if (i == at())

  1028         return true;

  1029     d->clearValues();

  1030     int actualIdx = i + 1;

  1031     if (actualIdx <= 0) {

  1032         setAt(QSql::BeforeFirstRow);

  1033         return false;

  1034     }

  1035     SQLRETURN r;

  1036     if (isForwardOnly()) {

  1037         bool ok = true;

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

  1039             ok = fetchNext();

  1040         return ok;

  1041     } else {

  1042         r = SQLFetchScroll(d->hStmt,

  1043                             SQL_FETCH_ABSOLUTE,

  1044                             actualIdx);

  1045     }

  1046     if (r != SQL_SUCCESS) {

  1047         if (r != SQL_NO_DATA)

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

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

  1050         return false;

  1051     }

  1052     setAt(i);

  1053     return true;

  1054 }

  1055 

  1056 bool QODBCResult::fetchNext()

  1057 {

  1058     SQLRETURN r;

  1059     d->clearValues();

  1060 

  1061     if (d->hasSQLFetchScroll)

  1062         r = SQLFetchScroll(d->hStmt,

  1063                            SQL_FETCH_NEXT,

  1064                            0);

  1065     else

  1066         r = SQLFetch(d->hStmt);

  1067 

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

  1069         if (r != SQL_NO_DATA)

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

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

  1072         return false;

  1073     }

  1074     setAt(at() + 1);

  1075     return true;

  1076 }

  1077 

  1078 bool QODBCResult::fetchFirst()

  1079 {

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

  1081         return false;

  1082     SQLRETURN r;

  1083     d->clearValues();

  1084     if (isForwardOnly()) {

  1085         return fetchNext();

  1086     }

  1087     r = SQLFetchScroll(d->hStmt,

  1088                        SQL_FETCH_FIRST,

  1089                        0);

  1090     if (r != SQL_SUCCESS) {

  1091         if (r != SQL_NO_DATA)

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

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

  1094         return false;

  1095     }

  1096     setAt(0);

  1097     return true;

  1098 }

  1099 

  1100 bool QODBCResult::fetchPrevious()

  1101 {

  1102     if (isForwardOnly())

  1103         return false;

  1104     SQLRETURN r;

  1105     d->clearValues();

  1106     r = SQLFetchScroll(d->hStmt,

  1107                        SQL_FETCH_PRIOR,

  1108                        0);

  1109     if (r != SQL_SUCCESS) {

  1110         if (r != SQL_NO_DATA)

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

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

  1113         return false;

  1114     }

  1115     setAt(at() - 1);

  1116     return true;

  1117 }

  1118 

  1119 bool QODBCResult::fetchLast()

  1120 {

  1121     SQLRETURN r;

  1122     d->clearValues();

  1123 

  1124     if (isForwardOnly()) {

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

  1126         int i = at();

  1127         if (i == QSql::AfterLastRow)

  1128             return false;

  1129         if (i == QSql::BeforeFirstRow)

  1130             i = 0;

  1131         while (fetchNext())

  1132             ++i;

  1133         setAt(i);

  1134         return true;

  1135     }