setAt(i);    return true;}bool QODBCResult::fetchNext(){    SQLRETURN r;    d->clearValues();    r = SQLFetchScroll(d->hStmt,                       SQL_FETCH_NEXT,                       0);    if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {        if (r != SQL_NO_DATA)            setLastError(qMakeError(QCoreApplication::translate("QODBCResult",                "Unable to fetch next"), QSqlError::ConnectionError, d));        return false;    }    setAt(at() + 1);    return true;}bool QODBCResult::fetchFirst(){    if (isForwardOnly() && at() != QSql::BeforeFirstRow)        return false;    SQLRETURN r;    d->clearValues();    if (isForwardOnly()) {        return fetchNext();    }    r = SQLFetchScroll(d->hStmt,                       SQL_FETCH_FIRST,                       0);    if (r != SQL_SUCCESS)        return false;    setAt(0);    return true;}bool QODBCResult::fetchPrior(){    if (isForwardOnly())        return false;    SQLRETURN r;    d->clearValues();    r = SQLFetchScroll(d->hStmt,                       SQL_FETCH_PRIOR,                       0);    if (r != SQL_SUCCESS)        return false;    setAt(at() - 1);    return true;}bool QODBCResult::fetchLast(){    SQLRETURN r;    d->clearValues();    if (isForwardOnly()) {        // cannot seek to last row in forwardOnly mode, so we have to use brute force        int i = at();        if (i == QSql::AfterLastRow)            return false;        if (i == QSql::BeforeFirstRow)            i = 0;        while (fetchNext())            ++i;        setAt(i);        return true;    }    r = SQLFetchScroll(d->hStmt,                       SQL_FETCH_LAST,                       0);    if (r != SQL_SUCCESS) {        return false;    }    SQLINTEGER currRow;    r = SQLGetStmtAttr(d->hStmt,                        SQL_ROW_NUMBER,                        &currRow,                        SQL_IS_INTEGER,                        0);    if (r != SQL_SUCCESS)        return false;    setAt(currRow-1);    return true;}QVariant QODBCResult::data(int field){    if (field >= d->rInf.count() || field < 0) {        qWarning("QODBCResult::data: column %d out of range", field);        return QVariant();    }    if (field < d->fieldCacheIdx)        return d->fieldCache.at(field);    SQLRETURN r(0);    QSQLLEN lengthIndicator = 0;    for (int i = d->fieldCacheIdx; i <= field; ++i) {        // some servers do not support fetching column n after we already        // fetched column n+1, so cache all previous columns here        const QSqlField info = d->rInf.field(i);        switch (info.type()) {        case QVariant::LongLong:            d->fieldCache[i] = qGetBigIntData(d->hStmt, i);        break;        case QVariant::Int:            d->fieldCache[i] = qGetIntData(d->hStmt, i);        break;        case QVariant::Date:            DATE_STRUCT dbuf;            r = SQLGetData(d->hStmt,                            i + 1,                            SQL_C_DATE,                            (SQLPOINTER)&dbuf,                            0,                            &lengthIndicator);            if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA))                d->fieldCache[i] = QVariant(QDate(dbuf.year, dbuf.month, dbuf.day));            else                d->fieldCache[i] = QVariant(QVariant::Date);        break;        case QVariant::Time:            TIME_STRUCT tbuf;            r = SQLGetData(d->hStmt,                            i + 1,                            SQL_C_TIME,                            (SQLPOINTER)&tbuf,                            0,                            &lengthIndicator);            if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA))                d->fieldCache[i] = QVariant(QTime(tbuf.hour, tbuf.minute, tbuf.second));            else                d->fieldCache[i] = QVariant(QVariant::Time);        break;        case QVariant::DateTime:            TIMESTAMP_STRUCT dtbuf;            r = SQLGetData(d->hStmt,                            i + 1,                            SQL_C_TIMESTAMP,                            (SQLPOINTER)&dtbuf,                            0,                            &lengthIndicator);            if ((r == SQL_SUCCESS || r == SQL_SUCCESS_WITH_INFO) && (lengthIndicator != SQL_NULL_DATA))                d->fieldCache[i] = QVariant(QDateTime(QDate(dtbuf.year, dtbuf.month, dtbuf.day),                       QTime(dtbuf.hour, dtbuf.minute, dtbuf.second, dtbuf.fraction / 1000000)));            else                d->fieldCache[i] = QVariant(QVariant::DateTime);            break;        case QVariant::ByteArray:            d->fieldCache[i] = qGetBinaryData(d->hStmt, i);            break;        case QVariant::String:            d->fieldCache[i] = qGetStringData(d->hStmt, i, info.length(), true);            break;        case QVariant::Double:            if (info.typeID() == SQL_DECIMAL || info.typeID() == SQL_NUMERIC)                // bind Double values as string to prevent loss of precision                d->fieldCache[i] = qGetStringData(d->hStmt, i,                                       info.length() + 1, false); // length + 1 for the comma            else                d->fieldCache[i] = qGetDoubleData(d->hStmt, i);            break;        default:            d->fieldCache[i] = QVariant(qGetStringData(d->hStmt, i,                                                           info.length(), false));            break;        }        d->fieldCacheIdx = field + 1;    }    return d->fieldCache[field];}bool QODBCResult::isNull(int field){    if (field < 0 || field > d->fieldCache.size())        return true;    if (field <= d->fieldCacheIdx) {        // since there is no good way to find out whether the value is NULL        // without fetching the field we'll fetch it here.        // (data() also sets the NULL flag)        data(field);    }    return d->fieldCache.at(field).isNull();}int QODBCResult::size(){    return -1;}int QODBCResult::numRowsAffected(){    QSQLLEN affectedRowCount = 0;    SQLRETURN r = SQLRowCount(d->hStmt, &affectedRowCount);    if (r == SQL_SUCCESS)        return affectedRowCount;    else        qSqlWarning(QLatin1String("QODBCResult::numRowsAffected: Unable to count affected rows"), d);    return -1;}bool QODBCResult::prepare(const QString& query){    setActive(false);    setAt(QSql::BeforeFirstRow);    SQLRETURN r;    d->rInf.clear();    if (d->hStmt) {        r = SQLFreeHandle(SQL_HANDLE_STMT, d->hStmt);        if (r != SQL_SUCCESS) {            qSqlWarning(QLatin1String("QODBCResult::prepare: Unable to close statement"), d);            return false;        }    }    r  = SQLAllocHandle(SQL_HANDLE_STMT,                         d->hDbc,                         &d->hStmt);    if (r != SQL_SUCCESS) {        qSqlWarning(QLatin1String("QODBCResult::prepare: Unable to allocate statement handle"), d);        return false;    }    if (isForwardOnly()) {        r = SQLSetStmtAttr(d->hStmt,                            SQL_ATTR_CURSOR_TYPE,                            (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,                            SQL_IS_UINTEGER);    } else {        r = SQLSetStmtAttr(d->hStmt,                            SQL_ATTR_CURSOR_TYPE,                            (SQLPOINTER)SQL_CURSOR_STATIC,                            SQL_IS_UINTEGER);    }    if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {        setLastError(qMakeError(QCoreApplication::translate("QODBCResult",            "QODBCResult::reset: Unable to set 'SQL_CURSOR_STATIC' as statement attribute. "            "Please check your ODBC driver configuration"), QSqlError::StatementError, d));        return false;    }#ifdef UNICODE    r = SQLPrepare(d->hStmt,                    (SQLWCHAR*) query.unicode(),                    (SQLINTEGER) query.length());#else    QByteArray query8 = query.toLocal8Bit();    r = SQLPrepare(d->hStmt,                    (SQLCHAR*) query8.constData(),                    (SQLINTEGER) query8.length());#endif    if (r != SQL_SUCCESS) {        setLastError(qMakeError(QCoreApplication::translate("QODBCResult",                     "Unable to prepare statement"), QSqlError::StatementError, d));        return false;    }    return true;}bool QODBCResult::exec(){    SQLRETURN r;    QList<QByteArray> tmpStorage; // holds temporary buffers    QVarLengthArray<QSQLLEN, 32> indicators(boundValues().count());    memset(indicators.data(), 0, indicators.size() * sizeof(QSQLLEN));    setActive(false);    setAt(QSql::BeforeFirstRow);    d->rInf.clear();    d->fieldCacheIdx = 0;    if (!d->hStmt) {        qSqlWarning(QLatin1String("QODBCResult::exec: No statement handle available"), d);        return false;    }    if (isSelect())        SQLCloseCursor(d->hStmt);    // bind parameters - only positional binding allowed    QVector<QVariant>& values = boundValues();    int i;    for (i = 0; i < values.count(); ++i) {        if (bindValueType(i) & QSql::Out)            values[i].detach();        const QVariant &val = values.at(i);        QSQLLEN *ind = &indicators[i];        if (val.isNull())            *ind = SQL_NULL_DATA;        switch (val.type()) {            case QVariant::Date: {                QByteArray ba;                ba.resize(sizeof(DATE_STRUCT));                DATE_STRUCT *dt = (DATE_STRUCT *)ba.constData();                QDate qdt = val.toDate();                dt->year = qdt.year();                dt->month = qdt.month();                dt->day = qdt.day();                r = SQLBindParameter(d->hStmt,                                      i + 1,                                      qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],                                      SQL_C_DATE,                                      SQL_DATE,                                      0,                                      0,                                      (void *) dt,                                      0,                                      *ind == SQL_NULL_DATA ? ind : NULL);                tmpStorage.append(ba);                break; }            case QVariant::Time: {                QByteArray ba;                ba.resize(sizeof(TIME_STRUCT));                TIME_STRUCT *dt = (TIME_STRUCT *)ba.constData();                QTime qdt = val.toTime();                dt->hour = qdt.hour();                dt->minute = qdt.minute();                dt->second = qdt.second();                r = SQLBindParameter(d->hStmt,                                      i + 1,                                      qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],                                      SQL_C_TIME,                                      SQL_TIME,                                      0,                                      0,                                      (void *) dt,                                      0,                                      *ind == SQL_NULL_DATA ? ind : NULL);                tmpStorage.append(ba);                break; }            case QVariant::DateTime: {                QByteArray ba;                ba.resize(sizeof(TIMESTAMP_STRUCT));                TIMESTAMP_STRUCT * dt = (TIMESTAMP_STRUCT *)ba.constData();                QDateTime qdt = val.toDateTime();                dt->year = qdt.date().year();                dt->month = qdt.date().month();                dt->day = qdt.date().day();                dt->hour = qdt.time().hour();                dt->minute = qdt.time().minute();                dt->second = qdt.time().second();                dt->fraction = qdt.time().msec() * 1000000;                r = SQLBindParameter(d->hStmt,                                      i + 1,                                      qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],                                      SQL_C_TIMESTAMP,                                      SQL_TIMESTAMP,                                      19,                                      0,                                      (void *) dt,                                      0,                                      *ind == SQL_NULL_DATA ? ind : NULL);                tmpStorage.append(ba);                break; }            case QVariant::Int:                r = SQLBindParameter(d->hStmt,                                      i + 1,                                      qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],                                      SQL_C_SLONG,                                      SQL_INTEGER,                                      0,                                      0,                                      (void *) val.constData(),                                      0,                                      *ind == SQL_NULL_DATA ? ind : NULL);                break;            case QVariant::Double:                r = SQLBindParameter(d->hStmt,                                      i + 1,                                      qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],                                      SQL_C_DOUBLE,                                      SQL_DOUBLE,                                      0,                                      0,                                      (void *) val.constData(),                                      0,                                      *ind == SQL_NULL_DATA ? ind : NULL);                break;