/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtSql module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#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"

#include <QDebug>

QT_BEGIN_NAMESPACE

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), precisionPolicy(QSql::LowPrecisionDouble), 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;

    QSql::NumericalPrecisionPolicy precisionPolicy;

    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 names

static 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);

}

static bool qIsAlnum(QChar ch)

{

    uint u = uint(ch.unicode());

    // matches [a-zA-Z0-9_]

    return u - 'a' < 26 || u - 'A' < 26 || u - '0' < 10 || u == '_';

}

QString QSqlResultPrivate::positionalToNamedBinding()

{

    int n = sql.size();

    QString result;

    result.reserve(n * 5 / 4);

    bool inQuote = false;

    int count = 0;

    for (int i = 0; i < n; ++i) {

        QChar ch = sql.at(i);

        if (ch == QLatin1Char('?') && !inQuote) {

            result += qFieldSerial(count++);

        } else {

            if (ch == QLatin1Char('\''))

                inQuote = !inQuote;

            result += ch;

        }

    }

    result.squeeze();

    return result;

}

QString QSqlResultPrivate::namedToPositionalBinding()

{

    int n = sql.size();

    QString result;

    result.reserve(n);

    bool inQuote = false;

    int count = 0;

    int i = 0;

    while (i < n) {

        QChar ch = sql.at(i);

        if (ch == QLatin1Char(':') && !inQuote

                && (i == 0 || sql.at(i - 1) != QLatin1Char(':'))

                && (i < n - 1 && qIsAlnum(sql.at(i + 1)))) {

            int pos = i + 2;

            while (pos < n && qIsAlnum(sql.at(pos)))

                ++pos;

            indexes[sql.mid(i, pos - i)] = count++;

            result += QLatin1Char('?');

            i = pos;

        } else {

            if (ch == QLatin1Char('\''))

                inQuote = !inQuote;

            result += ch;

            ++i;

        }

    }

    result.squeeze();

    return result;

}

/*!

    \class QSqlResult

    \brief The QSqlResult class provides an abstract interface for

    accessing data from specific SQL databases.

    \ingroup database

    \inmodule QtSql

    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;

    if(db) {

        setNumericalPrecisionPolicy(db->numericalPrecisionPolicy());

    }

}

/*!

    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);

}