/******************************************************************************** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.**** This file is part of the QtSql module of the Qt Toolkit.**** This file may be used under the terms of the GNU General Public** License version 2.0 as published by the Free Software Foundation** and appearing in the file LICENSE.GPL included in the packaging of** this file.  Please review the following information to ensure GNU** General Public Licensing requirements will be met:** http://www.trolltech.com/products/qt/opensource.html**** If you are unsure which license is appropriate for your use, please** review the following information:** http://www.trolltech.com/products/qt/licensing.html or contact the** sales department at sales@trolltech.com.**** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.******************************************************************************/#include "qvariant.h"#include "qhash.h"#include "qregexp.h"#include "qsqlerror.h"#include "qsqlfield.h"#include "qsqlrecord.h"#include "qsqlresult.h"#include "qvector.h"#include "qsqldriver.h"struct QHolder {    QHolder(const QString& hldr = QString(), int index = -1): holderName(hldr), holderPos(index) {}    bool operator==(const QHolder& h) const { return h.holderPos == holderPos && h.holderName == holderName; }    bool operator!=(const QHolder& h) const { return h.holderPos != holderPos || h.holderName != holderName; }    QString holderName;    int holderPos;};class QSqlResultPrivate{public:    QSqlResultPrivate(QSqlResult* d)    : q(d), sqldriver(0), idx(QSql::BeforeFirstRow), active(false),      isSel(false), forwardOnly(false), bindCount(0), binds(QSqlResult::PositionalBinding)    {}    void clearValues()    {        values.clear();        bindCount = 0;    }    void resetBindCount()    {        bindCount = 0;    }    void clearIndex()    {        indexes.clear();        holders.clear();        types.clear();    }    void clear()    {        clearValues();        clearIndex();;    }    QString positionalToNamedBinding();    QString namedToPositionalBinding();    QString holderAt(int index) const;public:    QSqlResult* q;    const QSqlDriver* sqldriver;    int idx;    QString sql;    bool active;    bool isSel;    QSqlError error;    bool forwardOnly;    int bindCount;    QSqlResult::BindingSyntax binds;    QString executedQuery;    QHash<int, QSql::ParamType> types;    QVector<QVariant> values;    typedef QHash<QString, int> IndexMap;    IndexMap indexes;    typedef QVector<QHolder> QHolderVector;    QHolderVector holders;};QString QSqlResultPrivate::holderAt(int index) const{    return indexes.key(index);}// return a unique id for bound namesstatic QString qFieldSerial(int i){    ushort arr[] = { ':', 'f', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };    ushort *ptr = &arr[1];    while (i > 0) {        *(++ptr) = 'a' + i % 16;        i >>= 4;    }    return QString::fromUtf16(arr, int(ptr - arr) + 1);}QString QSqlResultPrivate::positionalToNamedBinding(){    QRegExp rx(QLatin1String("'[^']*'|\\?"));    QString q = sql;    int i = 0, cnt = -1;    while ((i = rx.indexIn(q, i)) != -1) {        if (rx.cap(0) == QLatin1String("?"))            q = q.replace(i, 1, qFieldSerial(++cnt));        i += rx.matchedLength();    }    return q;}QString QSqlResultPrivate::namedToPositionalBinding(){    QRegExp rx(QLatin1String("'[^']*'|:([a-zA-Z0-9_]+)"));    QString q = sql;    int i = 0, cnt = -1;    while ((i = rx.indexIn(q, i)) != -1) {        if (rx.cap(1).isEmpty()) {            i += rx.matchedLength();        } else {            // record the index of the placeholder - needed            // for emulating named bindings with ODBC            indexes[rx.cap(0)]= ++cnt;            q.replace(i, rx.matchedLength(), QLatin1String("?"));            ++i;        }    }    return q;}/*!    \class QSqlResult    \brief The QSqlResult class provides an abstract interface for    accessing data from specific SQL databases.    \ingroup database    \module sql    Normally, you would use QSqlQuery instead of QSqlResult, since    QSqlQuery provides a generic wrapper for database-specific    implementations of QSqlResult.    If you are implementing your own SQL driver (by subclassing    QSqlDriver), you will need to provide your own QSqlResult    subclass that implements all the pure virtual functions and other    virtual functions that you need.    \sa QSqlDriver*//*!    \enum QSqlResult::BindingSyntax    This enum type specifies the different syntaxes for specifying    placeholders in prepared queries.    \value PositionalBinding Use the ODBC-style positional syntax, with "?" as placeholders.    \value NamedBinding Use the Oracle-style syntax with named placeholders (e.g., ":id")    \omitvalue BindByPosition    \omitvalue BindByName    \sa bindingSyntax()*//*!    \enum QSqlResult::VirtualHookOperation    \internal*//*!    Creates a QSqlResult using database driver \a db. The object is    initialized to an inactive state.    \sa isActive(), driver()*/QSqlResult::QSqlResult(const QSqlDriver *db){    d = new QSqlResultPrivate(this);    d->sqldriver = db;}/*!    Destroys the object and frees any allocated resources.*/QSqlResult::~QSqlResult(){    delete d;}/*!    Sets the current query for the result to \a query. You must call    reset() to execute the query on the database.    \sa reset(), lastQuery()*/void QSqlResult::setQuery(const QString& query){    d->sql = query;}/*!    Returns the current SQL query text, or an empty string if there    isn't one.    \sa setQuery()*/QString QSqlResult::lastQuery() const{    return d->sql;}/*!    Returns the current (zero-based) row position of the result. May    return the special values QSql::BeforeFirstRow or    QSql::AfterLastRow.    \sa setAt(), isValid()*/int QSqlResult::at() const{    return d->idx;}/*!    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.    \sa at()*/bool QSqlResult::isValid() const{    return d->idx != QSql::BeforeFirstRow && d->idx != QSql::AfterLastRow;}/*!    \fn bool QSqlResult::isNull(int index)    Returns true if the field at position \a index in the current row    is null; otherwise returns false.*//*!    Returns true if the result has records to be retrieved; otherwise    returns false.*/bool QSqlResult::isActive() const{    return d->active;}/*!    This function is provided for derived classes to set the    internal (zero-based) row position to \a index.    \sa at()*/void QSqlResult::setAt(int index){    d->idx = index;}/*!    This function is provided for derived classes to indicate whether    or not the current statement is a SQL \c SELECT statement. The \a    select parameter should be true if the statement is a \c SELECT    statement; otherwise it should be false.    \sa isSelect()*/void QSqlResult::setSelect(bool select){    d->isSel = select;}/*!    Returns true if the current result is from a \c SELECT statement;    otherwise returns false.    \sa setSelect()*/bool QSqlResult::isSelect() const{    return d->isSel;}/*!    Returns the driver associated with the result. This is the object    that was passed to the constructor.*/const QSqlDriver *QSqlResult::driver() const{    return d->sqldriver;}/*!    This function is provided for derived classes to set the internal    active state to \a active.    \sa isActive()*/void QSqlResult::setActive(bool active){    if (active && d->executedQuery.isEmpty())        d->executedQuery = d->sql;    d->active = active;}/*!    This function is provided for derived classes to set the last    error to \a error.    \sa lastError()*/void QSqlResult::setLastError(const QSqlError &error){    d->error = error;}/*!    Returns the last error associated with the result.*/QSqlError QSqlResult::lastError() const{    return d->error;}/*!    \fn int QSqlResult::size()    Returns the size of the \c SELECT result, or -1 if it cannot be    determined or if the query is not a \c SELECT statement.    \sa numRowsAffected()*//*!    \fn int QSqlResult::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 \c SELECT    statement.    \sa size()*//*!    \fn QVariant QSqlResult::data(int index)    Returns the data for field \a 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 \a index is    non-negative. Derived classes must reimplement this function and    return the value of field \a index, or QVariant() if it cannot be    determined.*//*!    \fn  bool QSqlResult::reset(const QString &query)    Sets the result to use the SQL statement \a query for subsequent    data retrieval.    Derived classes must reimplement this function and apply the \a    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.    \sa setQuery()*//*!    \fn bool QSqlResult::fetch(int index)    Positions the result to an arbitrary (zero-based) row \a 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 \a index, and call setAt() with an appropriate    value. Return true to indicate success, or false to signify    failure.    \sa isActive(), fetchFirst(), fetchLast(), fetchNext(), fetchPrevious()*//*!    \fn bool QSqlResult::fetchFirst()    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.    \sa fetch(), fetchLast()*//*!    \fn bool QSqlResult::fetchLast()    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.    \sa fetch(), fetchFirst()*//*!    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.    \sa fetch(), fetchPrevious()*/bool QSqlResult::fetchNext(){    return fetch(at() + 1);}/*!    Positions the result to the previous record (row) in the result.    This function is only called if the result is in an active state.