QMYSQLResult Class Reference

#include <qsql_mysql.h>

Inheritance diagram for QMYSQLResult:

Public Functions
QVariant	handle () const
	Returns the low-level database handle for this result set wrapped in a QVariant or an invalid QVariant if there is no handle. More...
	QMYSQLResult (const QMYSQLDriver *db)
	~QMYSQLResult ()
Public Functions inherited from QSqlResult
virtual	~QSqlResult ()
	Destroys the object and frees any allocated resources. More...

Protected Functions
void	cleanup ()
QVariant	data (int field)
	Returns the data for field index in the current row as a QVariant. More...
bool	fetch (int i)
	Positions the result to an arbitrary (zero-based) row index. More...
bool	fetchFirst ()
	Positions the result to the first record (row 0) in the result. More...
bool	fetchLast ()
	Positions the result to the last record (last row) in the result. More...
bool	fetchNext ()
	Positions the result to the next available record (row) in the result. More...
bool	isNull (int field)
	Returns true if the field at position index in the current row is null; otherwise returns false. More...
QVariant	lastInsertId () const
	Returns the object ID of the most recent inserted row if the database supports it. More...
bool	nextResult ()
int	numRowsAffected ()
	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. More...
QSqlRecord	record () const
	Returns the current record if the query is active; otherwise returns an empty QSqlRecord. More...
bool	reset (const QString &query)
	Sets the result to use the SQL statement query for subsequent data retrieval. More...
int	size ()
	Returns the size of the SELECT result, or -1 if it cannot be determined or if the query is not a SELECT statement. More...
void	virtual_hook (int id, void *data)
Protected Functions inherited from QSqlResult
void	addBindValue (const QVariant &val, QSql::ParamType type)
	Binds the value val of parameter type paramType to the next available position in the current record (row). More...
int	at () const
	Returns the current (zero-based) row position of the result. More...
BindingSyntax	bindingSyntax () const
	Returns the binding syntax used by prepared queries. More...
virtual void	bindValue (int pos, const QVariant &val, QSql::ParamType type)
	Binds the value val of parameter type paramType to position index in the current record (row). More...
virtual void	bindValue (const QString &placeholder, const QVariant &val, QSql::ParamType type)
	Binds the value val of parameter type paramType to the placeholder name in the current record (row). More...
QSql::ParamType	bindValueType (const QString &placeholder) const
	Returns the parameter type for the value bound with the given placeholder name. More...
QSql::ParamType	bindValueType (int pos) const
	Returns the parameter type for the value bound at position index. More...
QVariant	boundValue (const QString &placeholder) const
	Returns the value bound by the given placeholder name in the current record (row). More...
QVariant	boundValue (int pos) const
	Returns the value bound at position index in the current record (row). More...
int	boundValueCount () const
	Returns the number of bound values in the result. More...
QString	boundValueName (int pos) const
	Returns the name of the bound value at position index in the current record (row). More...
QVector< QVariant > &	boundValues () const
	Returns a vector of the result's bound values for the current record (row). More...
void	clear ()
	Clears the entire result set and releases any associated resources. More...
void	detachFromResultSet ()
const QSqlDriver *	driver () const
	Returns the driver associated with the result. More...
virtual bool	exec ()
	Executes the query, returning true if successful; otherwise returns false. More...
bool	execBatch (bool arrayBind=false)
	Executes a prepared query in batch mode if the driver supports it, otherwise emulates a batch execution using bindValue() and exec(). More...
QString	executedQuery () const
	Returns the query that was actually executed. More...
virtual bool	fetchPrevious ()
	Positions the result to the previous record (row) in the result. More...
bool	hasOutValues () const
	Returns true if at least one of the query's bound values is a QSql::Out or a QSql::InOut; otherwise returns false. More...
bool	isActive () const
	Returns true if the result has records to be retrieved; otherwise returns false. More...
bool	isForwardOnly () const
	Returns true if you can only scroll forward through the result set; otherwise returns false. More...
bool	isSelect () const
	Returns true if the current result is from a SELECT statement; otherwise returns false. More...
bool	isValid () const
	Returns true if the result is positioned on a valid record (that is, the result is not positioned before the first or after the last record); otherwise returns false. More...
QSqlError	lastError () const
	Returns the last error associated with the result. More...
QString	lastQuery () const
	Returns the current SQL query text, or an empty string if there isn't one. More...
bool	nextResult ()
QSql::NumericalPrecisionPolicy	numericalPrecisionPolicy () const
virtual bool	prepare (const QString &query)
	Prepares the given query for execution; the query will normally use placeholders so that it can be executed repeatedly. More...
	QSqlResult (const QSqlDriver *db)
	Creates a QSqlResult using database driver db. More...
virtual bool	savePrepare (const QString &sqlquery)
	Prepares the given query, using the underlying database functionality where possible. More...
virtual void	setActive (bool a)
	This function is provided for derived classes to set the internal active state to active. More...
virtual void	setAt (int at)
	This function is provided for derived classes to set the internal (zero-based) row position to index. More...
virtual void	setForwardOnly (bool forward)
	Sets forward only mode to forward. More...
virtual void	setLastError (const QSqlError &e)
	This function is provided for derived classes to set the last error to error. More...
void	setNumericalPrecisionPolicy (QSql::NumericalPrecisionPolicy policy)
virtual void	setQuery (const QString &query)
	Sets the current query for the result to query. More...
virtual void	setSelect (bool s)
	This function is provided for derived classes to indicate whether or not the current statement is a SQL SELECT statement. More...

Properties
QMYSQLResultPrivate *	d

Friends
class	QMYSQLDriver
class	QMYSQLResultPrivate

Additional Inherited Members
Protected Types inherited from QSqlResult
enum	BindingSyntax { PositionalBinding, NamedBinding }
	This enum type specifies the different syntaxes for specifying placeholders in prepared queries. More...
enum	VirtualHookOperation { BatchOperation, DetachFromResultSet, SetNumericalPrecision, NextResult }

Detailed Description

Definition at line 69 of file qsql_mysql.h.

Constructors and Destructors

QMYSQLResult()

QMYSQLResult::QMYSQLResult ( const QMYSQLDriver *  db )

explicit

Definition at line 407 of file qsql_mysql.cpp.

: QSqlResult(db)
{
    d = new QMYSQLResultPrivate(db, this);
}

~QMYSQLResult()

QMYSQLResult::~QMYSQLResult

(

)

Definition at line 413 of file qsql_mysql.cpp.

{
    cleanup();
    delete d;
}

Functions

cleanup()

void QMYSQLResult::cleanup ( )

protected

Definition at line 429 of file qsql_mysql.cpp.

Referenced by reset(), virtual_hook(), and ~QMYSQLResult().

{
    if (d->result)
        mysql_free_result(d->result);

// must iterate trough leftover result sets from multi-selects or stored procedures
// if this isn't done subsequent queries will fail with "Commands out of sync"
#if MYSQL_VERSION_ID >= 40100
    while (d->driver && d->driver->d->mysql && mysql_next_result(d->driver->d->mysql) == 0) {
        MYSQL_RES *res = mysql_store_result(d->driver->d->mysql);
        if (res)
            mysql_free_result(res);
    }
#endif

#if MYSQL_VERSION_ID >= 40108
    if (d->stmt) {
        if (mysql_stmt_close(d->stmt))
            qWarning("QMYSQLResult::cleanup: unable to free statement handle");
        d->stmt = 0;
    }

    if (d->meta) {
        mysql_free_result(d->meta);
        d->meta = 0;
    }

    int i;
    for (i = 0; i < d->fields.count(); ++i)
        delete[] d->fields[i].outField;

    if (d->outBinds) {
        delete[] d->outBinds;
        d->outBinds = 0;
    }

    if (d->inBinds) {
        delete[] d->inBinds;
        d->inBinds = 0;
    }
#endif

    d->hasBlobs = false;
    d->fields.clear();
    d->result = NULL;
    d->row = NULL;
    setAt(-1);
    setActive(false);
}

data()

QVariant QMYSQLResult::data ( int  index )

protectedvirtual

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 589 of file qsql_mysql.cpp.

Referenced by virtual_hook().

{

    if (!isSelect() || field >= d->fields.count()) {
        qWarning("QMYSQLResult::data: column %d out of range", field);
        return QVariant();
    }

    if (!d->driver)
        return QVariant();

    int fieldLength = 0;
    const QMYSQLResultPrivate::QMyField &f = d->fields.at(field);
    QString val;
    if (d->preparedQuery) {
        if (f.nullIndicator)
            return QVariant(f.type);

        if (f.type != QVariant::ByteArray)
            val = toUnicode(d->driver->d->tc, f.outField, f.bufLength);
    } else {
        if (d->row[field] == NULL) {
            // NULL value
            return QVariant(f.type);
        }
        fieldLength = mysql_fetch_lengths(d->result)[field];
        if (f.type != QVariant::ByteArray)
            val = toUnicode(d->driver->d->tc, d->row[field], fieldLength);
    }

    switch(f.type) {
    case QVariant::LongLong:
        return QVariant(val.toLongLong());
    case QVariant::ULongLong:
        return QVariant(val.toULongLong());
    case QVariant::Int:
        return QVariant(val.toInt());
    case QVariant::UInt:
        return QVariant(val.toUInt());
    case QVariant::Double: {
        QVariant v;
        bool ok=false;
        double dbl = val.toDouble(&ok);
        switch(numericalPrecisionPolicy()) {
            case QSql::LowPrecisionInt32:
                v=QVariant(dbl).toInt();
                break;
            case QSql::LowPrecisionInt64:
                v = QVariant(dbl).toLongLong();
                break;
            case QSql::LowPrecisionDouble:
                v = QVariant(dbl);
                break;
            case QSql::HighPrecision:
            default:
                v = val;
                ok = true;
                break;
        }
        if(ok)
            return v;
        else
            return QVariant();
    }
        return QVariant(val.toDouble());
    case QVariant::Date:
        return qDateFromString(val);
    case QVariant::Time:
        return qTimeFromString(val);
    case QVariant::DateTime:
        return qDateTimeFromString(val);
    case QVariant::ByteArray: {

        QByteArray ba;
        if (d->preparedQuery) {
            ba = QByteArray(f.outField, f.bufLength);
        } else {
            ba = QByteArray(d->row[field], fieldLength);
        }
        return QVariant(ba);
    }
    default:
    case QVariant::String:
        return QVariant(val);
    }
    qWarning("QMYSQLResult::data: unknown data type");
    return QVariant();
}

fetch()

bool QMYSQLResult::fetch ( int  index )

protectedvirtual

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 479 of file qsql_mysql.cpp.

Referenced by fetchFirst(), and fetchLast().

{
    if(!d->driver)
        return false;
    if (isForwardOnly()) { // fake a forward seek
        if (at() < i) {
            int x = i - at();
            while (--x && fetchNext()) {};
            return fetchNext();
        } else {
            return false;
        }
    }
    if (at() == i)
        return true;
    if (d->preparedQuery) {
#if MYSQL_VERSION_ID >= 40108
        mysql_stmt_data_seek(d->stmt, i);

        int nRC = mysql_stmt_fetch(d->stmt);
        if (nRC) {
#ifdef MYSQL_DATA_TRUNCATED
            if (nRC == 1 || nRC == MYSQL_DATA_TRUNCATED)
#else
            if (nRC == 1)
#endif
                setLastError(qMakeStmtError(QCoreApplication::translate("QMYSQLResult",
                         "Unable to fetch data"), QSqlError::StatementError, d->stmt));
            return false;
        }
#else
        return false;
#endif
    } else {
        mysql_data_seek(d->result, i);
        d->row = mysql_fetch_row(d->result);
        if (!d->row)
            return false;
    }

    setAt(i);
    return true;
}

fetchFirst()

bool QMYSQLResult::fetchFirst ( )

protectedvirtual

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 579 of file qsql_mysql.cpp.

{
    if (at() == 0)
        return true;

    if (isForwardOnly())
        return (at() == QSql::BeforeFirstRow) ? fetchNext() : false;
    return fetch(0);
}

fetchLast()

bool QMYSQLResult::fetchLast ( )

protectedvirtual

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 552 of file qsql_mysql.cpp.

{
    if(!d->driver)
        return false;
    if (isForwardOnly()) { // fake this since MySQL can't seek on forward only queries
        bool success = fetchNext(); // did we move at all?
        while (fetchNext()) {};
        return success;
    }

    my_ulonglong numRows;
    if (d->preparedQuery) {
#if MYSQL_VERSION_ID >= 40108
        numRows = mysql_stmt_num_rows(d->stmt);
#else
        numRows = 0;
#endif
    } else {
        numRows = mysql_num_rows(d->result);
    }
    if (at() == int(numRows))
        return true;
    if (!numRows)
        return false;
    return fetch(numRows - 1);
}

fetchNext()

bool QMYSQLResult::fetchNext ( )

protectedvirtual

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 523 of file qsql_mysql.cpp.

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

{
    if(!d->driver)
        return false;
    if (d->preparedQuery) {
#if MYSQL_VERSION_ID >= 40108
        int nRC = mysql_stmt_fetch(d->stmt);
        if (nRC) {
#ifdef MYSQL_DATA_TRUNCATED
            if (nRC == 1 || nRC == MYSQL_DATA_TRUNCATED)
#else
            if (nRC == 1)
#endif // MYSQL_DATA_TRUNCATED
                setLastError(qMakeStmtError(QCoreApplication::translate("QMYSQLResult",
                                    "Unable to fetch data"), QSqlError::StatementError, d->stmt));
            return false;
        }
#else
        return false;
#endif
    } else {
        d->row = mysql_fetch_row(d->result);
        if (!d->row)
            return false;
    }
    setAt(at() + 1);
    return true;
}

handle()

QVariant QMYSQLResult::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() && qstrcmp(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 419 of file qsql_mysql.cpp.

{
#if MYSQL_VERSION_ID >= 40108
    if(d->preparedQuery)
        return d->meta ? QVariant::fromValue(d->meta) : qVariantFromValue(d->stmt);
    else
#endif
        return QVariant::fromValue(d->result);
}

isNull()

bool QMYSQLResult::isNull ( int  i )

protectedvirtual

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

Implements QSqlResult.

Definition at line 678 of file qsql_mysql.cpp.

{
   if (d->preparedQuery)
       return d->fields.at(field).nullIndicator;
   else
       return d->row[field] == NULL;
}

lastInsertId()

QVariant QMYSQLResult::lastInsertId ( ) const

protectedvirtual

Returns the object ID of the most recent inserted row if the database supports it.

An invalid QVariant will be returned if the query did not insert any value or if the database does not report the id back. If more than one row was touched by the insert, the behavior is undefined.

Note that for Oracle databases the row's ROWID will be returned, while for MySQL databases the row's auto-increment field will be returned.

See also

QSqlDriver::hasFeature()

Reimplemented from QSqlResult.

Definition at line 743 of file qsql_mysql.cpp.

{
    if (!isActive() || !d->driver)
        return QVariant();

    if (d->preparedQuery) {
#if MYSQL_VERSION_ID >= 40108
        quint64 id = mysql_stmt_insert_id(d->stmt);
        if (id)
            return QVariant(id);
#endif
    } else {
        quint64 id = mysql_insert_id(d->driver->d->mysql);
        if (id)
            return QVariant(id);
    }
    return QVariant();
}

nextResult()

bool QMYSQLResult::nextResult ( )

protected

Definition at line 787 of file qsql_mysql.cpp.

Referenced by virtual_hook().

{
    if(!d->driver)
        return false;
#if MYSQL_VERSION_ID >= 40100 
    setAt(-1);
    setActive(false);

    if (d->result && isSelect())
        mysql_free_result(d->result);
    d->result = 0;
    setSelect(false);
   
    for (int i = 0; i < d->fields.count(); ++i)
        delete[] d->fields[i].outField;
    d->fields.clear();

    int status = mysql_next_result(d->driver->d->mysql);
    if (status > 0) {
        setLastError(qMakeError(QCoreApplication::translate("QMYSQLResult", "Unable to execute next query"),
                     QSqlError::StatementError, d->driver->d));
        return false;
    } else if (status == -1) {
        return false;   // No more result sets
    }

    d->result = mysql_store_result(d->driver->d->mysql);
    int numFields = mysql_field_count(d->driver->d->mysql);
    if (!d->result && numFields > 0) {
        setLastError(qMakeError(QCoreApplication::translate("QMYSQLResult", "Unable to store next result"),
                     QSqlError::StatementError, d->driver->d));
        return false;
    }

    setSelect(numFields > 0);
    d->fields.resize(numFields);
    d->rowsAffected = mysql_affected_rows(d->driver->d->mysql);

    if (isSelect()) {
        for (int i = 0; i < numFields; i++) {
            MYSQL_FIELD* field = mysql_fetch_field_direct(d->result, i);
            d->fields[i].type = qDecodeMYSQLType(field->type, field->flags);
        }
    }

    setActive(true);
    return true;
#else
    return false;
#endif
}

numRowsAffected()

int QMYSQLResult::numRowsAffected ( )

protectedvirtual

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 738 of file qsql_mysql.cpp.

{
    return d->rowsAffected;
}

record()

QSqlRecord QMYSQLResult::record ( ) const

protectedvirtual

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 762 of file qsql_mysql.cpp.

{
    QSqlRecord info;
    MYSQL_RES *res;
    if (!isActive() || !isSelect() || !d->driver)
        return info;

#if MYSQL_VERSION_ID >= 40108
    res = d->preparedQuery ? d->meta : d->result;
#else
    res = d->result;
#endif

    if (!mysql_errno(d->driver->d->mysql)) {
        mysql_field_seek(res, 0);
        MYSQL_FIELD* field = mysql_fetch_field(res);
        while(field) {
            info.append(qToField(field, d->driver->d->tc));
            field = mysql_fetch_field(res);
        }
    }
    mysql_field_seek(res, 0);
    return info;
}

reset()

bool QMYSQLResult::reset ( const QString &  query )

protectedvirtual

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 686 of file qsql_mysql.cpp.

{
    if (!driver() || !driver()->isOpen() || driver()->isOpenError() || !d->driver)
        return false;

    d->preparedQuery = false;

    cleanup();

    const QByteArray encQuery(fromUnicode(d->driver->d->tc, query));
    if (mysql_real_query(d->driver->d->mysql, encQuery.data(), encQuery.length())) {
        setLastError(qMakeError(QCoreApplication::translate("QMYSQLResult", "Unable to execute query"),
                     QSqlError::StatementError, d->driver->d));
        return false;
    }
    d->result = mysql_store_result(d->driver->d->mysql);
    if (!d->result && mysql_field_count(d->driver->d->mysql) > 0) {
        setLastError(qMakeError(QCoreApplication::translate("QMYSQLResult", "Unable to store result"),
                    QSqlError::StatementError, d->driver->d));
        return false;
    }
    int numFields = mysql_field_count(d->driver->d->mysql);
    setSelect(numFields != 0);
    d->fields.resize(numFields);
    d->rowsAffected = mysql_affected_rows(d->driver->d->mysql);

    if (isSelect()) {
        for(int i = 0; i < numFields; i++) {
            MYSQL_FIELD* field = mysql_fetch_field_direct(d->result, i);
            d->fields[i].type = qDecodeMYSQLType(field->type, field->flags);
        }
        setAt(QSql::BeforeFirstRow);
    }
    setActive(true);
    return isActive();
}

size()

int QMYSQLResult::size ( )

protectedvirtual

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 723 of file qsql_mysql.cpp.

{
    if (d->driver && isSelect())
        if (d->preparedQuery)
#if MYSQL_VERSION_ID >= 40108
            return mysql_stmt_num_rows(d->stmt);
#else
            return -1;
#endif
        else
            return int(mysql_num_rows(d->result));
    else
        return -1;
}

virtual_hook()

void QMYSQLResult::virtual_hook ( int  id, void *  data  )

protectedvirtual

Warning

This function is not part of the public interface.

Reimplemented from QSqlResult.

Definition at line 839 of file qsql_mysql.cpp.

{
    switch (id) {
    case QSqlResult::NextResult:
        Q_ASSERT(data);
        *static_cast<bool*>(data) = nextResult();
        break;
    default:
        QSqlResult::virtual_hook(id, data);
    }
}

Friends and Related Functions

QMYSQLDriver

friend class QMYSQLDriver

friend

Definition at line 71 of file qsql_mysql.h.

QMYSQLResultPrivate

friend class QMYSQLResultPrivate

friend

Definition at line 72 of file qsql_mysql.h.

Referenced by QMYSQLResult().

Properties

d

QMYSQLResultPrivate* QMYSQLResult::d

private

Definition at line 99 of file qsql_mysql.h.

Referenced by cleanup(), data(), fetch(), fetchLast(), fetchNext(), handle(), isNull(), lastInsertId(), nextResult(), numRowsAffected(), QMYSQLResult(), record(), reset(), size(), virtual_hook(), and ~QMYSQLResult().

---

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

• /src/sql/drivers/mysql/qsql_mysql.h
• /src/sql/drivers/mysql/qsql_mysql.cpp