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

**

** 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 "qsqlquery.h"

//#define QT_DEBUG_SQL

#include "qatomic.h"

#include "qsqlrecord.h"

#include "qsqlresult.h"

#include "qsqldriver.h"

#include "qsqldatabase.h"

#include "private/qsqlnulldriver_p.h"

#include "qvector.h"

#include "qmap.h"

QT_BEGIN_NAMESPACE

class QSqlQueryPrivate

{

public:

    QSqlQueryPrivate(QSqlResult* result);

    ~QSqlQueryPrivate();

    QAtomicInt ref;

    QSqlResult* sqlResult;

    static QSqlQueryPrivate* shared_null();

};

Q_GLOBAL_STATIC_WITH_ARGS(QSqlQueryPrivate, nullQueryPrivate, (0))

Q_GLOBAL_STATIC(QSqlNullDriver, nullDriver)

Q_GLOBAL_STATIC_WITH_ARGS(QSqlNullResult, nullResult, (nullDriver()))

QSqlQueryPrivate* QSqlQueryPrivate::shared_null()

{

    QSqlQueryPrivate *null = nullQueryPrivate();

    null->ref.ref();

    return null;

}

/*!

\internal

*/

QSqlQueryPrivate::QSqlQueryPrivate(QSqlResult* result)

    : ref(1), sqlResult(result)

{

    if (!sqlResult)

        sqlResult = nullResult();

}

QSqlQueryPrivate::~QSqlQueryPrivate()

{

    QSqlResult *nr = nullResult();

    if (!nr || sqlResult == nr)

        return;

    delete sqlResult;

}

/*!

    \class QSqlQuery

    \brief The QSqlQuery class provides a means of executing and

    manipulating SQL statements.

    \ingroup database

    \ingroup shared

    \inmodule QtSql

    QSqlQuery encapsulates the functionality involved in creating,

    navigating and retrieving data from SQL queries which are

    executed on a \l QSqlDatabase. It can be used to execute DML

    (data manipulation language) statements, such as \c SELECT, \c

    INSERT, \c UPDATE and \c DELETE, as well as DDL (data definition

    language) statements, such as \c{CREATE} \c{TABLE}. It can also

    be used to execute database-specific commands which are not

    standard SQL (e.g. \c{SET DATESTYLE=ISO} for PostgreSQL).

    Successfully executed SQL statements set the query's state to

    active so that isActive() returns true. Otherwise the query's

    state is set to inactive. In either case, when executing a new SQL

    statement, the query is positioned on an invalid record. An active

    query must be navigated to a valid record (so that isValid()

    returns true) before values can be retrieved.

    For some databases, if an active query that is a \c{SELECT}

    statement exists when you call \l{QSqlDatabase::}{commit()} or

    \l{QSqlDatabase::}{rollback()}, the commit or rollback will

    fail. See isActive() for details.

    \target QSqlQuery examples

    Navigating records is performed with the following functions:

    \list

    \o next()

    \o previous()

    \o first()

    \o last()

    \o seek()

    \endlist

    These functions allow the programmer to move forward, backward

    or arbitrarily through the records returned by the query. If you

    only need to move forward through the results (e.g., by using

    next()), you can use setForwardOnly(), which will save a

    significant amount of memory overhead and improve performance on

    some databases. Once an active query is positioned on a valid

    record, data can be retrieved using value(). All data is

    transferred from the SQL backend using QVariants.

    For example:

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 7

    To access the data returned by a query, use value(int). Each

    field in the data returned by a \c SELECT statement is accessed

    by passing the field's position in the statement, starting from

    0. This makes using \c{SELECT *} queries inadvisable because the

    order of the fields returned is indeterminate.

    For the sake of efficiency, there are no functions to access a

    field by name (unless you use prepared queries with names, as

    explained below). To convert a field name into an index, use

    record().\l{QSqlRecord::indexOf()}{indexOf()}, for example:

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 8

    QSqlQuery supports prepared query execution and the binding of

    parameter values to placeholders. Some databases don't support

    these features, so for those, Qt emulates the required

    functionality. For example, the Oracle and ODBC drivers have

    proper prepared query support, and Qt makes use of it; but for

    databases that don't have this support, Qt implements the feature

    itself, e.g. by replacing placeholders with actual values when a

    query is executed. Use numRowsAffected() to find out how many rows

    were affected by a non-\c SELECT query, and size() to find how

    many were retrieved by a \c SELECT.

    Oracle databases identify placeholders by using a colon-name

    syntax, e.g \c{:name}. ODBC simply uses \c ? characters. Qt

    supports both syntaxes, with the restriction that you can't mix

    them in the same query.

    You can retrieve the values of all the fields in a single variable

    (a map) using boundValues().

    \section1 Approaches to Binding Values

    Below we present the same example using each of the four

    different binding approaches, as well as one example of binding

    values to a stored procedure.

    \bold{Named binding using named placeholders:}

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 9

    \bold{Positional binding using named placeholders:}

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 10

    \bold{Binding values using positional placeholders (version 1):}

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 11

    \bold{Binding values using positional placeholders (version 2):}

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 12

    \bold{Binding values to a stored procedure:}

    This code calls a stored procedure called \c AsciiToInt(), passing

    it a character through its in parameter, and taking its result in

    the out parameter.

    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 13

    Note that unbound parameters will retain their values.

    Stored procedures that uses the return statement to return values,

    or return multiple result sets, are not fully supported. For specific

    details see \l{SQL Database Drivers}.

    \warning You must load the SQL driver and open the connection before a

    QSqlQuery is created. Also, the connection must remain open while the

    query exists; otherwise, the behavior of QSqlQuery is undefined.

    \sa QSqlDatabase, QSqlQueryModel, QSqlTableModel, QVariant

*/

/*!

    Constructs a QSqlQuery object which uses the QSqlResult \a result

    to communicate with a database.

*/

QSqlQuery::QSqlQuery(QSqlResult *result)

{

    d = new QSqlQueryPrivate(result);

}

/*!

    Destroys the object and frees any allocated resources.

*/

QSqlQuery::~QSqlQuery()

{

    if (!d->ref.deref())

        delete d;

}

/*!

    Constructs a copy of \a other.

*/

QSqlQuery::QSqlQuery(const QSqlQuery& other)

{

    d = other.d;

    d->ref.ref();

}

/*!

    \internal

*/

static void qInit(QSqlQuery *q, const QString& query, QSqlDatabase db)

{

    QSqlDatabase database = db;

    if (!database.isValid())

        database = QSqlDatabase::database(QLatin1String(QSqlDatabase::defaultConnection), false);

    if (database.isValid()) {

        *q = QSqlQuery(database.driver()->createResult());

    }

    if (!query.isEmpty())

        q->exec(query);

}

/*!

    Constructs a QSqlQuery object using the SQL \a query and the

    database \a db. If \a db is not specified, the application's

    default database is used. If \a query is not an empty string, it

    will be executed.

    \sa QSqlDatabase

*/

QSqlQuery::QSqlQuery(const QString& query, QSqlDatabase db)

{

    d = QSqlQueryPrivate::shared_null();

    qInit(this, query, db);

}

/*!

    Constructs a QSqlQuery object using the database \a db.

    \sa QSqlDatabase

*/

QSqlQuery::QSqlQuery(QSqlDatabase db)

{

    d = QSqlQueryPrivate::shared_null();

    qInit(this, QString(), db);

}

/*!

    Assigns \a other to this object.

*/

QSqlQuery& QSqlQuery::operator=(const QSqlQuery& other)

{

    qAtomicAssign(d, other.d);

    return *this;

}

/*!

  Returns true if the query is \l{isActive()}{active} and positioned

  on a valid record and the \a field is NULL; otherwise returns

  false. Note that for some drivers, isNull() will not return accurate

  information until after an attempt is made to retrieve data.

  \sa isActive(), isValid(), value()

*/

bool QSqlQuery::isNull(int field) const

{

    if (d->sqlResult->isActive() && d->sqlResult->isValid())

        return d->sqlResult->isNull(field);

    return true;

}

/*!

  Executes the SQL in \a query. Returns true and sets the query state

  to \l{isActive()}{active} if the query was successful; otherwise

  returns false. The \a query string must use syntax appropriate for

  the SQL database being queried (for example, standard SQL).

  After the query is executed, the query is positioned on an \e

  invalid record and must be navigated to a valid record before data

  values can be retrieved (for example, using next()).

  Note that the last error for this query is reset when exec() is

  called.

  Example:

  \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 34

  \sa isActive(), isValid(), next(), previous(), first(), last(),

  seek()

*/

bool QSqlQuery::exec(const QString& query)

{

    if (d->ref != 1) {

        bool fo = isForwardOnly();

        *this = QSqlQuery(driver()->createResult());

        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());

        setForwardOnly(fo);

    } else {

        d->sqlResult->clear();

        d->sqlResult->setActive(false);

        d->sqlResult->setLastError(QSqlError());

        d->sqlResult->setAt(QSql::BeforeFirstRow);

        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());

    }

    d->sqlResult->setQuery(query.trimmed());

    if (!driver()->isOpen() || driver()->isOpenError()) {

        qWarning("QSqlQuery::exec: database not open");

        return false;

    }

    if (query.isEmpty()) {

        qWarning("QSqlQuery::exec: empty query");

        return false;

    }

#ifdef QT_DEBUG_SQL

    qDebug("\n QSqlQuery: %s", query.toLocal8Bit().constData());

#endif

    return d->sqlResult->reset(query);

}

/*!

    Returns the value of field \a index in the current record.

    The fields are numbered from left to right using the text of the

    \c SELECT statement, e.g. in

    \snippet doc/src/snippets/code/src_sql_kernel_qsqlquery.cpp 0

    field 0 is \c forename and field 1 is \c

    surname. Using \c{SELECT *} is not recommended because the order

    of the fields in the query is undefined.

    An invalid QVariant is returned if field \a index does not

    exist, if the query is inactive, or if the query is positioned on

    an invalid record.

    \sa previous() next() first() last() seek() isActive() isValid()

*/

QVariant QSqlQuery::value(int index) const

{

    if (isActive() && isValid() && (index > QSql::BeforeFirstRow))

        return d->sqlResult->data(index);

    qWarning("QSqlQuery::value: not positioned on a valid record");

    return QVariant();

}

/*!

    Returns the current internal position of the query. The first

    record is at position zero. If the position is invalid, the

    function returns QSql::BeforeFirstRow or

    QSql::AfterLastRow, which are special negative values.

    \sa previous() next() first() last() seek() isActive() isValid()

*/

int QSqlQuery::at() const

{

    return d->sqlResult->at();

}

/*!

    Returns the text of the current query being used, or an empty

    string if there is no current query text.

    \sa executedQuery()

*/

QString QSqlQuery::lastQuery() const

{

    return d->sqlResult->lastQuery();

}

/*!

    Returns the database driver associated with the query.

*/

const QSqlDriver *QSqlQuery::driver() const

{

    return d->sqlResult->driver();

}

/*!

    Returns the result associated with the query.

*/

const QSqlResult* QSqlQuery::result() const

{

    return d->sqlResult;

}

/*!

  Retrieves the record at position \a index, if available, and

  positions the query on the retrieved record. The first record is at

  position 0. Note that the query must be in an \l{isActive()}

  {active} state and isSelect() must return true before calling this

  function.

  If \a relative is false (the default), the following rules apply:

  \list

  \o If \a index is negative, the result is positioned before the

  first record and false is returned.

  \o Otherwise, an attempt is made to move to the record at position

  \a index. If the record at position \a index could not be retrieved,

  the result is positioned after the last record and false is

  returned. If the record is successfully retrieved, true is returned.

  \endlist

  If \a relative is true, the following rules apply:

  \list

  \o If the result is currently positioned before the first record or

  on the first record, and \a index is negative, there is no change,

  and false is returned.

  \o If the result is currently located after the last record, and \a

  index is positive, there is no change, and false is returned.

  \o If the result is currently located somewhere in the middle, and

  the relative offset \a index moves the result below zero, the result

  is positioned before the first record and false is returned.

  \o Otherwise, an attempt is made to move to the record \a index

  records ahead of the current record (or \a index records behind the

  current record if \a index is negative). If the record at offset \a

  index could not be retrieved, the result is positioned after the

  last record if \a index >= 0, (or before the first record if \a

  index is negative), and false is returned. If the record is

  successfully retrieved, true is returned.

  \endlist

  \sa next() previous() first() last() at() isActive() isValid()

*/

bool QSqlQuery::seek(int index, bool relative)

{

    if (!isSelect() || !isActive())

        return false;

    int actualIdx;

    if (!relative) { // arbitrary seek

        if (index < 0) {

            d->sqlResult->setAt(QSql::BeforeFirstRow);

            return false;

        }

        actualIdx = index;

    } else {

        switch (at()) { // relative seek

        case QSql::BeforeFirstRow:

            if (index > 0)

                actualIdx = index;

            else {

                return false;

            }

            break;

        case QSql::AfterLastRow:

            if (index < 0) {

                d->sqlResult->fetchLast();

                actualIdx = at() + index;

            } else {

                return false;

            }

            break;

        default:

            if ((at() + index) < 0) {

                d->sqlResult->setAt(QSql::BeforeFirstRow);

                return false;

            }