QODBCResult Class Reference

#include <qsql_odbc.h>

Inheritance diagram for QODBCResult:

[legend]Collaboration diagram for QODBCResult:

[legend]List of all members.

---

Detailed Description

Definition at line 73 of file qsql_odbc.h.

Public Member Functions
	QODBCResult (const QODBCDriver *db, QODBCDriverPrivate *p)
virtual	~QODBCResult ()
bool	prepare (const QString &query)
bool	exec ()
QVariant	handle () const
Protected Member Functions
bool	fetchNext ()
bool	fetchFirst ()
bool	fetchLast ()
bool	fetchPrior ()
bool	fetch (int i)
bool	reset (const QString &query)
QVariant	data (int field)
bool	isNull (int field)
int	size ()
int	numRowsAffected ()
QSqlRecord	record () const
Private Attributes
QODBCPrivate *	d

---

Constructor & Destructor Documentation

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

Definition at line 642 of file qsql_odbc.cpp.

References d, QODBCPrivate::hDbc, QODBCPrivate::hEnv, p, QODBCPrivate::sql_char_type, QODBCPrivate::sql_longvarchar_type, QODBCPrivate::sql_varchar_type, QODBCPrivate::unicode, and QODBCPrivate::useSchema.

: QSqlResult(db)
{
    d = new QODBCPrivate();
    d->hEnv = p->hEnv;
    d->hDbc = p->hDbc;
    d->unicode = p->unicode;
    d->useSchema = p->useSchema;
    d->sql_char_type = p->sql_char_type;
    d->sql_varchar_type = p->sql_varchar_type;
    d->sql_longvarchar_type = p->sql_longvarchar_type;
}

QODBCResult::~QODBCResult

(

)

[virtual]

Definition at line 655 of file qsql_odbc.cpp.

References d, QSqlResult::driver(), QODBCPrivate::hStmt, QString::number(), and qSqlWarning().

{
    if (d->hStmt && driver()->isOpen()) {
        SQLRETURN r = SQLFreeHandle(SQL_HANDLE_STMT, d->hStmt);
        if (r != SQL_SUCCESS)
            qSqlWarning(QLatin1String("QODBCDriver: Unable to free statement handle ")
                         + QString::number(r), d);
    }

    delete d;
}

Here is the call graph for this function:

---

Member Function Documentation

bool QODBCResult::prepare

(

const QString &

query

)

[virtual]

Prepares the given query for execution; the query will normally use placeholders so that it can be executed repeatedly. Returns true if the query is prepared successfully; otherwise returns false.

See also:

exec()

Reimplemented from QSqlResult.

Definition at line 973 of file qsql_odbc.cpp.

References QSql::BeforeFirstRow, QSqlRecord::clear(), d, QODBCPrivate::hDbc, QODBCPrivate::hStmt, QSqlResult::isForwardOnly(), QString::length(), qMakeError(), qSqlWarning(), QODBCPrivate::rInf, QSqlResult::setActive(), QSqlResult::setAt(), QSqlResult::setLastError(), QSqlError::StatementError, QString::toLocal8Bit(), QCoreApplication::translate(), and QString::unicode().

{
    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;
}

Here is the call graph for this function:

bool QODBCResult::exec

(

)

[virtual]

Executes the query, returning true if successful; otherwise returns false.

See also:

prepare()

Reimplemented from QSqlResult.

Definition at line 1032 of file qsql_odbc.cpp.

References QSqlRecord::append(), QList< T >::append(), QSql::BeforeFirstRow, QSqlResult::bindValueType(), QSqlResult::boundValues(), QVariant::ByteArray, QString::capacity(), QSqlRecord::clear(), constData(), QString::constData(), QByteArray::constData(), d, QVarLengthArray< T, Prealloc >::data(), QVariant::Date, QDateTime::date(), QVariant::DateTime, QDate::day(), QVariant::Double, QODBCPrivate::fieldCache, QODBCPrivate::fieldCacheIdx, QString::fromAscii(), QString::fromUtf16(), QSqlResult::hasOutValues(), QTime::hour(), QODBCPrivate::hStmt, i, QSql::InOut, QVariant::Int, QSqlResult::isSelect(), QString::length(), QByteArray::length(), QTime::minute(), QDate::month(), QTime::msec(), NULL, QSql::Out, qMakeError(), qMakeFieldInfo(), qODBCWarn(), qParamType, QSQLLEN, qSqlWarning(), qWarning(), QByteArray::resize(), QVector< T >::resize(), QODBCPrivate::rInf, QTime::second(), QSqlResult::setActive(), QSqlResult::setAt(), QSqlResult::setLastError(), QSqlResult::setSelect(), QVarLengthArray< T, Prealloc >::size(), QByteArray::size(), QSqlError::StatementError, QVariant::String, QList< T >::takeFirst(), QDateTime::time(), QVariant::Time, QCoreApplication::translate(), type, QODBCPrivate::unicode, QString::utf16(), val, values, and QDate::year().

{
    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;
            case QVariant::ByteArray:
                if (*ind != SQL_NULL_DATA) {
                    *ind = val.toByteArray().size();
                }
                r = SQLBindParameter(d->hStmt,
                                      i + 1,
                                      qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],
                                      SQL_C_BINARY,
                                      SQL_LONGVARBINARY,
                                      val.toByteArray().size(),
                                      0,
                                      (void *) val.toByteArray().constData(),
                                      val.toByteArray().size(),
                                      ind);
                break;
#ifndef Q_ODBC_VERSION_2
            case QVariant::String:
                if (d->unicode) {
                    QString str = val.toString();
                    str.utf16();
                    if (*ind != SQL_NULL_DATA)
                        *ind = str.length() * sizeof(QChar);
                    if (bindValueType(i) & QSql::Out) {
                        QByteArray ba((char*)str.constData(), str.capacity() * sizeof(QChar));
                        r = SQLBindParameter(d->hStmt,
                                            i + 1,
                                            qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],
                                            SQL_C_WCHAR,
                                            str.length() > 4000 ? SQL_WLONGVARCHAR : SQL_WVARCHAR,
                                            0, // god knows... don't change this!
                                            0,
                                            (void *)ba.constData(),
                                            ba.size(),
                                            ind);
                        tmpStorage.append(ba);
                        break;
                    }

                    r = SQLBindParameter(d->hStmt,
                                          i + 1,
                                          qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],
                                          SQL_C_WCHAR,
                                          str.length() > 4000 ? SQL_WLONGVARCHAR : SQL_WVARCHAR,
                                          str.length() * sizeof(QChar),
                                          0,
                                          (void *)str.constData(),
                                          str.length() * sizeof(QChar),
                                          ind);
                    break;
                }
#endif
            // fall through
            default: {
                QByteArray ba = val.toString().toAscii();
                if (*ind != SQL_NULL_DATA)
                    *ind = ba.size();
                r = SQLBindParameter(d->hStmt,
                                      i + 1,
                                      qParamType[(QFlag)(bindValueType(i)) & QSql::InOut],
                                      SQL_C_CHAR,
                                      ba.length() > 4000 ? SQL_LONGVARCHAR : SQL_VARCHAR,
                                      ba.length() + 1,
                                      0,
                                      (void *) ba.constData(),
                                      ba.length() + 1,
                                      ind);
                tmpStorage.append(ba);
                break; }
        }
        if (r != SQL_SUCCESS) {
            qWarning("QODBCResult::exec: unable to bind variable: %s",
                     qODBCWarn(d).toLocal8Bit().constData());
            setLastError(qMakeError(QCoreApplication::translate("QODBCResult",
                         "Unable to bind variable"), QSqlError::StatementError, d));
            return false;
        }
    }
    r = SQLExecute(d->hStmt);
    if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
        qWarning("QODBCResult::exec: Unable to execute statement: %s",
                 qODBCWarn(d).toLocal8Bit().constData());
        setLastError(qMakeError(QCoreApplication::translate("QODBCResult",
                     "Unable to execute statement"), QSqlError::StatementError, d));
        return false;
    }
    SQLSMALLINT count;
    r = SQLNumResultCols(d->hStmt, &count);
    if (count) {
        setSelect(true);
        for (int i = 0; i < count; ++i) {
            d->rInf.append(qMakeFieldInfo(d, i));
        }
  d->fieldCache.resize(count);
    } else {
        setSelect(false);
    }
    setActive(true);

    //get out parameters
    if (!hasOutValues())
        return true;

    for (i = 0; i < values.count(); ++i) {
        switch (values.at(i).type()) {
            case QVariant::Date: {
                DATE_STRUCT ds = *((DATE_STRUCT *)tmpStorage.takeFirst().constData());
                values[i] = QVariant(QDate(ds.year, ds.month, ds.day));
                break; }
            case QVariant::Time: {
                TIME_STRUCT dt = *((TIME_STRUCT *)tmpStorage.takeFirst().constData());
                values[i] = QVariant(QTime(dt.hour, dt.minute, dt.second));
                break; }
            case QVariant::DateTime: {
                TIMESTAMP_STRUCT dt = *((TIMESTAMP_STRUCT*)
                                        tmpStorage.takeFirst().constData());
                values[i] = QVariant(QDateTime(QDate(dt.year, dt.month, dt.day),
                               QTime(dt.hour, dt.minute, dt.second, dt.fraction / 1000000)));
                break; }
            case QVariant::Int:
            case QVariant::Double:
            case QVariant::ByteArray:
                //nothing to do
                break;
            case QVariant::String:
                if (d->unicode) {
                    if (bindValueType(i) & QSql::Out)
                        values[i] = QString::fromUtf16((ushort*)tmpStorage.takeFirst().constData());
                    break;
                }
                // fall through
            default: {
                QByteArray ba = tmpStorage.takeFirst();
                if (bindValueType(i) & QSql::Out)
                    values[i] = QString::fromAscii(tmpStorage.takeFirst().constData());
                break; }
        }
        if (indicators[i] == SQL_NULL_DATA)
            values[i] = QVariant(values[i].type());
    }
    return true;
}

Here is the call graph for this function:

QVariant QODBCResult::handle

(

)

const [virtual]

Returns the low-level database handle for this result set wrapped in a QVariant or an invalid QVariant if there is no handle.

Warning:

Use this with uttermost care and only if you know what you're doing.

The handle returned here can become a stale pointer if the result is modified (for example, if you clear it).

The handle can be NULL if the result was not executed yet.

The handle returned here is database-dependent, you should query the type name of the variant before accessing it.

This example retrieves the handle for a sqlite result:

    QSqlQuery query = ...
    QVariant v = query.result()->handle();
    if (v.isValid() && v.typeName() == "sqlite3_stmt*") {
        // v.data() returns a pointer to the handle
        sqlite3_stmt *handle = *static_cast<sqlite3_stmt **>(v.data());
        if (handle != 0) { // check that it is not NULL
            ...
        }
    }

This snippet returns the handle for PostgreSQL or MySQL:

    if (v.typeName() == "PGresult*") {
        PGresult *handle = *static_cast<PGresult **>(v.data());
        if (handle != 0) ...
    }

    if (v.typeName() == "MYSQL_STMT*") {
        MYSQL_STMT *handle = *static_cast<MYSQL_STMT **>(v.data());
        if (handle != 0) ...
    }

See also:

QSqlDriver::handle()

Reimplemented from QSqlResult.

Definition at line 1299 of file qsql_odbc.cpp.

References d, and QODBCPrivate::hStmt.

{
    return QVariant(qRegisterMetaType<SQLHANDLE>("SQLHANDLE"), &d->hStmt);
}

bool QODBCResult::fetchNext

(

)

[protected, virtual]

Positions the result to the next available record (row) in the result.

This function is only called if the result is in an active state. The default implementation calls fetch() with the next index. Derived classes can reimplement this function and position the result to the next record in some other way, and call setAt() with an appropriate value. Return true to indicate success, or false to signify failure.

See also:

fetch(), fetchPrevious()

Reimplemented from QSqlResult.

Definition at line 771 of file qsql_odbc.cpp.

References QSqlResult::at(), QODBCPrivate::clearValues(), QSqlError::ConnectionError, d, QODBCPrivate::hStmt, qMakeError(), QSqlResult::setAt(), QSqlResult::setLastError(), and QCoreApplication::translate().

Referenced by fetch(), fetchFirst(), and fetchLast().

{
    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;
}

Here is the call graph for this function:

bool QODBCResult::fetchFirst

(

)

[protected, virtual]

Positions the result to the first record (row 0) in the result.

This function is only called if the result is in an active state. Derived classes must reimplement this function and position the result to the first record, and call setAt() with an appropriate value. Return true to indicate success, or false to signify failure.

See also:

fetch(), fetchLast()

Implements QSqlResult.

Definition at line 788 of file qsql_odbc.cpp.

References QSqlResult::at(), QSql::BeforeFirstRow, QODBCPrivate::clearValues(), d, fetchNext(), QODBCPrivate::hStmt, QSqlResult::isForwardOnly(), and QSqlResult::setAt().

{
    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;
}

Here is the call graph for this function:

bool QODBCResult::fetchLast

(

)

[protected, virtual]

Positions the result to the last record (last row) in the result.

This function is only called if the result is in an active state. Derived classes must reimplement this function and position the result to the last record, and call setAt() with an appropriate value. Return true to indicate success, or false to signify failure.

See also:

fetch(), fetchFirst()

Implements QSqlResult.

Definition at line 821 of file qsql_odbc.cpp.

References QSql::AfterLastRow, QSqlResult::at(), QSql::BeforeFirstRow, QODBCPrivate::clearValues(), d, fetchNext(), QODBCPrivate::hStmt, i, QSqlResult::isForwardOnly(), and QSqlResult::setAt().

{
    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;
}

Here is the call graph for this function:

bool QODBCResult::fetchPrior

(

)

[protected]

Definition at line 806 of file qsql_odbc.cpp.

References QSqlResult::at(), QODBCPrivate::clearValues(), d, QODBCPrivate::hStmt, QSqlResult::isForwardOnly(), and QSqlResult::setAt().

{
    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;
}

Here is the call graph for this function:

bool QODBCResult::fetch

(

int

i

)

[protected, virtual]

Positions the result to an arbitrary (zero-based) row index.

This function is only called if the result is in an active state. Derived classes must reimplement this function and position the result to the row index, and call setAt() with an appropriate value. Return true to indicate success, or false to signify failure.

See also:

isActive(), fetchFirst(), fetchLast(), fetchNext(), fetchPrevious()

Implements QSqlResult.

Definition at line 741 of file qsql_odbc.cpp.

References QSqlResult::at(), QSql::BeforeFirstRow, QODBCPrivate::clearValues(), d, fetchNext(), QODBCPrivate::hStmt, QSqlResult::isForwardOnly(), and QSqlResult::setAt().

{
    if (isForwardOnly() && i < at())
        return false;
    if (i == at())
        return true;
    d->clearValues();
    int actualIdx = i + 1;
    if (actualIdx <= 0) {
        setAt(QSql::BeforeFirstRow);
        return false;
    }
    SQLRETURN r;
    if (isForwardOnly()) {
        bool ok = true;
        while (ok && i > at())
            ok = fetchNext();
        return ok;
    } else {
        r = SQLFetchScroll(d->hStmt,
                            SQL_FETCH_ABSOLUTE,
                            actualIdx);
    }
    if (r != SQL_SUCCESS){
        return false;
    }
    setAt(i);
    return true;
}

Here is the call graph for this function:

bool QODBCResult::reset

(

const QString &

query

)

[protected, virtual]

Sets the result to use the SQL statement query for subsequent data retrieval.

Derived classes must reimplement this function and apply the query to the database. This function is only called after the result is set to an inactive state and is positioned before the first record of the new result. Derived classes should return true if the query was successful and ready to be used, or false otherwise.

See also:

setQuery()

Implements QSqlResult.

Definition at line 667 of file qsql_odbc.cpp.

References QSqlRecord::append(), QSql::BeforeFirstRow, QSqlRecord::clear(), QVector< T >::clear(), d, QODBCPrivate::fieldCache, QODBCPrivate::fieldCacheIdx, QODBCPrivate::hDbc, QODBCPrivate::hStmt, i, QSqlResult::isForwardOnly(), QString::length(), qMakeError(), qMakeFieldInfo(), qSqlWarning(), QVector< T >::resize(), QODBCPrivate::rInf, QSqlResult::setActive(), QSqlResult::setAt(), QSqlResult::setLastError(), QSqlResult::setSelect(), QSqlError::StatementError, QString::toLocal8Bit(), QCoreApplication::translate(), and QString::unicode().

{
    setActive(false);
    setAt(QSql::BeforeFirstRow);
    SQLRETURN r;

    d->rInf.clear();
    d->fieldCache.clear();
    d->fieldCacheIdx = 0;
    // Always reallocate the statement handle - the statement attributes
    // are not reset if SQLFreeStmt() is called which causes some problems.
    if (d->hStmt) {
        r = SQLFreeHandle(SQL_HANDLE_STMT, d->hStmt);
        if (r != SQL_SUCCESS) {
            qSqlWarning(QLatin1String("QODBCResult::reset: Unable to free statement handle"), d);
            return false;
        }
    }
    r  = SQLAllocHandle(SQL_HANDLE_STMT,
                         d->hDbc,
                         &d->hStmt);
    if (r != SQL_SUCCESS) {
        qSqlWarning(QLatin1String("QODBCResult::reset: 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 = SQLExecDirect(d->hStmt,
                       (SQLWCHAR*) query.unicode(),
                       (SQLINTEGER) query.length());
#else
    QByteArray query8 = query.toLocal8Bit();
    r = SQLExecDirect(d->hStmt,
                       (SQLCHAR*) query8.constData(),
                       (SQLINTEGER) query8.length());
#endif
    if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
        setLastError(qMakeError(QCoreApplication::translate("QODBCResult",
                     "Unable to execute statement"), QSqlError::StatementError, d));
        return false;
    }
    SQLSMALLINT count;
    r = SQLNumResultCols(d->hStmt, &count);
    if (count) {
        setSelect(true);
        for (int i = 0; i < count; ++i) {
            d->rInf.append(qMakeFieldInfo(d, i));
        }
        d->fieldCache.resize(count);
    } else {
        setSelect(false);
    }
    setActive(true);
    return true;
}

Here is the call graph for this function:

QVariant QODBCResult::data

(

int

field

)

[protected, virtual]

Returns the data for field index in the current row as a QVariant. This function is only called if the result is in an active state and is positioned on a valid record and index is non-negative. Derived classes must reimplement this function and return the value of field index, or QVariant() if it cannot be determined.

Implements QSqlResult.

Definition at line 857 of file qsql_odbc.cpp.

References QVector< T >::at(), QVariant::ByteArray, QSqlRecord::count(), d, QVariant::Date, QVariant::DateTime, QVariant::Double, QSqlRecord::field(), QODBCPrivate::fieldCache, QODBCPrivate::fieldCacheIdx, QODBCPrivate::hStmt, i, info, QVariant::Int, QVariant::LongLong, qGetBigIntData(), qGetBinaryData(), qGetDoubleData(), qGetIntData(), qGetStringData(), QSQLLEN, qWarning(), QODBCPrivate::rInf, QVariant::String, and QVariant::Time.

Referenced by isNull().

{
    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];
}

Here is the call graph for this function:

bool QODBCResult::isNull

(

int

field

)

[protected, virtual]

Returns true if the field at position index in the current row is null; otherwise returns false.

Implements QSqlResult.

Definition at line 944 of file qsql_odbc.cpp.

References QVector< T >::at(), d, data(), QODBCPrivate::fieldCache, QVariant::isNull(), and QVector< T >::size().

{
    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();
}

Here is the call graph for this function:

int QODBCResult::size

(

)

[protected, virtual]

Returns the size of the SELECT result, or -1 if it cannot be determined or if the query is not a SELECT statement.

See also:

numRowsAffected()

Implements QSqlResult.

Definition at line 957 of file qsql_odbc.cpp.

{
    return -1;
}

int QODBCResult::numRowsAffected

(

)

[protected, virtual]

Returns the number of rows affected by the last query executed, or -1 if it cannot be determined or if the query is a SELECT statement.

See also:

size()

Implements QSqlResult.

Definition at line 962 of file qsql_odbc.cpp.

References d, QODBCPrivate::hStmt, QSQLLEN, and qSqlWarning().

{
    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;
}

Here is the call graph for this function:

QSqlRecord QODBCResult::record

(

)

const [protected, virtual]

Returns the current record if the query is active; otherwise returns an empty QSqlRecord.

The default implementation always returns an empty QSqlRecord.

See also:

isActive()

Reimplemented from QSqlResult.

Definition at line 1292 of file qsql_odbc.cpp.

References d, QSqlResult::isActive(), QSqlResult::isSelect(), and QODBCPrivate::rInf.

{
    if (!isActive() || !isSelect())
        return QSqlRecord();
    return d->rInf;
}

Here is the call graph for this function:

---

Member Data Documentation

QODBCPrivate* QODBCResult::d [private]

Reimplemented from QSqlResult.

Definition at line 98 of file qsql_odbc.h.

Referenced by data(), exec(), fetch(), fetchFirst(), fetchLast(), fetchNext(), fetchPrior(), handle(), isNull(), numRowsAffected(), prepare(), QODBCResult(), record(), reset(), and ~QODBCResult().

---

The documentation for this class was generated from the following files:

• src/sql/drivers/odbc/qsql_odbc.h
• src/sql/drivers/odbc/qsql_odbc.cpp

---