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

**

** All rights reserved.

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

**

** This file is part of the Qt3Support 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 <qplatformdefs.h>

#include "q3sqlcursor.h"

#ifndef QT_NO_SQL

#include "qsqldriver.h"

#include "qsqlresult.h"

#include "qdatetime.h"

#include "qsqldatabase.h"

#include "qsql.h"

#include "q3sqlrecordinfo.h"

#include "q3sqlfieldinfo.h"

QT_BEGIN_NAMESPACE

class Q3SqlCursorPrivate

{

public:

    Q3SqlCursorPrivate(const QString& name, QSqlDatabase sdb)

        : lastAt(QSql::BeforeFirst), nm(name), srt(name), md(0), db(sdb), q(0)

    {}

    ~Q3SqlCursorPrivate()

    {

        delete q;

    }

    QSqlQuery* query()

    {

        if (!q)

            q = new QSqlQuery(QString(), db);

        return q;

    }

    int lastAt;

    QString nm;         //name

    QSqlIndex srt;        //sort

    QString ftr;        //filter

    int md;         //mode

    QSqlIndex priIndx;    //primary index

    QSqlRecord editBuffer;

    // the primary index as it was before the user changed the values in editBuffer

    QString editIndex;

    Q3SqlRecordInfo infoBuffer;

    QSqlDatabase db;

    QSqlQuery *q;

};

QString qOrderByClause(const QSqlIndex & i, const QString& prefix = QString())

{

    QString str;

    int k = i.count();

    if(k == 0)

        return QString();

    str = QLatin1String(" order by ") + i.toString(prefix);

    return str;

}

QString qWhereClause(const QString& prefix, QSqlField* field, const QSqlDriver* driver)

{

    QString f;

    if (field && driver) {

        if (!prefix.isEmpty())

            f += prefix + QLatin1Char('.');

        f += field->name();

        if (field->isNull()) {

            f += QLatin1String(" IS NULL");

        } else {

            f += QLatin1String(" = ") + driver->formatValue(field);

        }

    }

    return f;

}

QString qWhereClause(QSqlRecord* rec, const QString& prefix, const QString& sep,

                      const QSqlDriver* driver)

{

    static QString blank(QLatin1Char(' '));

    QString filter;

    bool separator = false;

    for (int j = 0; j < rec->count(); ++j) {

        QSqlField f = rec->field(j);

        if (rec->isGenerated(j)) {

            if (separator)

                filter += sep + blank;

            filter += qWhereClause(prefix, &f, driver);

            filter += blank;

            separator = true;

        }

    }

    return filter;

}

/*!

    \class Q3SqlCursor

    \brief The Q3SqlCursor class provides browsing and editing of SQL

    tables and views.

    \compat

    A Q3SqlCursor is a database record (see \l QSqlRecord) that

    corresponds to a table or view within an SQL database (see \l

    QSqlDatabase). There are two buffers in a cursor, one used for

    browsing and one used for editing records. Each buffer contains a

    list of fields which correspond to the fields in the table or

    view.

    When positioned on a valid record, the browse buffer contains the

    values of the current record's fields from the database. The edit

    buffer is separate, and is used for editing existing records and

    inserting new records.

    For browsing data, a cursor must first select() data from the

    database. After a successful select() the cursor is active

    (isActive() returns true), but is initially not positioned on a

    valid record (isValid() returns false). To position the cursor on

    a valid record, use one of the navigation functions, next(),

    previous(), first(), last(), or seek(). Once positioned on a valid

    record, data can be retrieved from the browse buffer using

    value(). If a navigation function is not successful, it returns

    false, the cursor will no longer be positioned on a valid record

    and the values returned by value() are undefined.

    For example:

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

    In the above example, a cursor is created specifying a table or

    view name in the database. Then, select() is called, which can be

    optionally parameterised to filter and order the records

    retrieved. Each record in the cursor is retrieved using next().

    When next() returns false, there are no more records to process,

    and the loop terminates.

    For editing records (rows of data), a cursor contains a separate

    edit buffer which is independent of the fields used when browsing.

    The functions insert(), update() and del() operate on the edit

    buffer. This allows the cursor to be repositioned to other

    records while simultaneously maintaining a separate buffer for

    edits. You can get a pointer to the edit buffer using

    editBuffer(). The primeInsert(), primeUpdate() and primeDelete()

    functions also return a pointer to the edit buffer and prepare it

    for insert, update and delete respectively. Edit operations only

    affect a single row at a time. Note that update() and del()

    require that the table or view contain a primaryIndex() to ensure

    that edit operations affect a unique record within the database.

    For example:

    \snippet doc/src/snippets/code/src_qt3support_sql_q3sqlcursor.cpp 1

    To edit an existing database record, first move to the record you

    wish to update. Call primeUpdate() to get the pointer to the

    cursor's edit buffer. Then use this pointer to modify the values

    in the edit buffer. Finally, call update() to save the changes to

    the database. The values in the edit buffer will be used to

    locate the appropriate record when updating the database (see

    primaryIndex()).

    Similarly, when deleting an existing database record, first move

    to the record you wish to delete. Then, call primeDelete() to get

    the pointer to the edit buffer. Finally, call del() to delete the

    record from the database. Again, the values in the edit buffer

    will be used to locate and delete the appropriate record.

    To insert a new record, call primeInsert() to get the pointer to

    the edit buffer. Use this pointer to populate the edit buffer

    with new values and then insert() the record into the database.

    After calling insert(), update() or del(), the cursor is no longer

    positioned on a valid record and can no longer be navigated

    (isValid() return false). The reason for this is that any changes

    made to the database will not be visible until select() is called

    to refresh the cursor. You can change this behavior by passing

    false to insert(), update() or del() which will prevent the cursor

    from becoming invalid. The edits will still not be visible when

    navigating the cursor until select() is called.

    Q3SqlCursor contains virtual methods which allow editing behavior

    to be customized by subclasses. This allows custom cursors to be

    created that encapsulate the editing behavior of a database table

    for an entire application. For example, a cursor can be customized

    to always auto-number primary index fields, or provide fields with

    suitable default values, when inserting new records. Q3SqlCursor

    generates SQL statements which are sent to the database engine;

    you can control which fields are included in these statements

    using setGenerated().

    Note that Q3SqlCursor does not inherit from QObject. This means

    that you are responsible for destroying instances of this class

    yourself. However if you create a Q3SqlCursor and use it in a

    \l Q3DataTable, \l Q3DataBrowser or a \l Q3DataView these classes will

    usually take ownership of the cursor and destroy it when they

    don't need it anymore. The documentation for Q3DataTable,

    Q3DataBrowser and Q3DataView explicitly states which calls take

    ownership of the cursor.

*/

/*!

    \enum Q3SqlCursor::Mode

    This enum type describes how Q3SqlCursor operates on records in the

    database.

    \value ReadOnly  the cursor can only SELECT records from the

    database.

    \value Insert  the cursor can INSERT records into the database.

    \value Update  the cursor can UPDATE records in the database.

    \value Delete  the cursor can DELETE records from the database.

    \value Writable  the cursor can INSERT, UPDATE and DELETE records

    in the database.

*/

/*!

    \fn QVariant Q3SqlCursor::value(const QString &name) const

    \overload

    Returns the value of the field named \a name.

*/

/*!

    \fn void Q3SqlCursor::setValue(const QString &name, const QVariant &val)

    \overload

    Sets the value for the field named \a name to \a val.

*/

/*!

    Constructs a cursor on database \a db using table or view \a name.

    If \a autopopulate is true (the default), the \a name of the

    cursor must correspond to an existing table or view name in the

    database so that field information can be automatically created.

    If the table or view does not exist, the cursor will not be

    functional.

    The cursor is created with an initial mode of Q3SqlCursor::Writable

    (meaning that records can be inserted, updated or deleted using

    the cursor). If the cursor does not have a unique primary index,

    update and deletes cannot be performed.

    Note that \a autopopulate refers to populating the cursor with

    meta-data, e.g. the names of the table's fields, not with

    retrieving data. The select() function is used to populate the

    cursor with data.

    \sa setName() setMode()

*/

Q3SqlCursor::Q3SqlCursor(const QString & name, bool autopopulate, QSqlDatabase db)

    : QSqlRecord(), QSqlQuery(QString(), db)

{

    d = new Q3SqlCursorPrivate(name, db);

    setMode(Writable);

    if (!d->nm.isEmpty())

        setName(d->nm, autopopulate);

}

/*!

    Constructs a copy of \a other.

*/

Q3SqlCursor::Q3SqlCursor(const Q3SqlCursor & other)

    : QSqlRecord(other), QSqlQuery(other)

{

    d = new Q3SqlCursorPrivate(other.d->nm, other.d->db);

    d->lastAt = other.d->lastAt;

    d->nm = other.d->nm;

    d->srt = other.d->srt;

    d->ftr = other.d->ftr;

    d->priIndx = other.d->priIndx;

    d->editBuffer = other.d->editBuffer;

    d->infoBuffer = other.d->infoBuffer;

    d->q = 0; // do not share queries

    setMode(other.mode());

}

/*!

    Destroys the object and frees any allocated resources.

*/

Q3SqlCursor::~Q3SqlCursor()

{

    delete d;

}

/*!

    Sets the cursor equal to \a other.

*/

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

{

    QSqlRecord::operator=(other);

    QSqlQuery::operator=(other);

    delete d;

    d = new Q3SqlCursorPrivate(other.d->nm, other.d->db);

    d->lastAt = other.d->lastAt;

    d->nm = other.d->nm;

    d->srt = other.d->srt;

    d->ftr = other.d->ftr;

    d->priIndx = other.d->priIndx;

    d->editBuffer = other.d->editBuffer;

    d->infoBuffer = other.d->infoBuffer;

    d->q = 0; // do not share queries

    setMode(other.mode());

    return *this;

}

/*!

    Sets the current sort to \a sort. Note that no new records are

    selected. To select new records, use select(). The \a sort will

    apply to any subsequent select() calls that do not explicitly

    specify a sort.

*/

void Q3SqlCursor::setSort(const QSqlIndex& sort)

{

    d->srt = sort;

}

/*!

    Returns the current sort, or an empty index if there is no current

    sort.

*/

QSqlIndex Q3SqlCursor::sort() const

{

    return d->srt;

}

/*!

    Sets the current filter to \a filter. Note that no new records are

    selected. To select new records, use select(). The \a filter will

    apply to any subsequent select() calls that do not explicitly

    specify a filter.

    The filter is a SQL \c WHERE clause without the keyword 'WHERE',

    e.g. \c{name='Dave'} which will be processed by the DBMS.

*/

void Q3SqlCursor::setFilter(const QString& filter)

{

    d->ftr = filter;

}

/*!

    Returns the current filter, or an empty string if there is no

    current filter.

*/

QString Q3SqlCursor::filter() const

{

    return d->ftr;

}

/*!

    Sets the name of the cursor to \a name. If \a autopopulate is true

    (the default), the \a name must correspond to a valid table or

    view name in the database. Also, note that all references to the

    cursor edit buffer become invalidated when fields are

    auto-populated. See the Q3SqlCursor constructor documentation for

    more information.

*/

void Q3SqlCursor::setName(const QString& name, bool autopopulate)

{

    d->nm = name;

    if (autopopulate) {

        if (driver()) {

            d->infoBuffer = driver()->record(name);

            *this = d->infoBuffer.toRecord();

            d->editBuffer = *this;

            d->priIndx = driver()->primaryIndex(name);

        }

        if (isEmpty())

            qWarning("Q3SqlCursor::setName: unable to build record, does '%s' exist?", name.latin1());

    }

}

/*!

    Returns the name of the cursor.

*/

QString Q3SqlCursor::name() const

{

    return d->nm;

}

/*! \internal

*/

QString Q3SqlCursor::toString(const QString& prefix, const QString& sep) const

{

    QString pflist;

    QString pfix =  prefix.isEmpty() ? prefix : prefix + QLatin1Char('.');

    bool comma = false;

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

        const QString fname = fieldName(i);

        if (isGenerated(i)) {

            if(comma)

                pflist += sep + QLatin1Char(' ');

            pflist += pfix + driver()->escapeIdentifier(fname, QSqlDriver::FieldName);

            comma = true;

        }

    }

    return pflist;

}

/*!

  \internal

  Assigns the record \a list.

*/

QSqlRecord & Q3SqlCursor::operator=(const QSqlRecord & list)

{

    return QSqlRecord::operator=(list);

}

/*!

    Append a copy of field \a fieldInfo to the end of the cursor. Note

    that all references to the cursor edit buffer become invalidated.

*/

void Q3SqlCursor::append(const Q3SqlFieldInfo& fieldInfo)

{

    d->editBuffer.append(fieldInfo.toField());

    d->infoBuffer.append(fieldInfo);

    QSqlRecord::append(fieldInfo.toField());

}

/*!

    Removes all fields from the cursor. Note that all references to

    the cursor edit buffer become invalidated.

*/

void Q3SqlCursor::clear()

{

    d->editBuffer.clear();

    d->infoBuffer.clear();

    QSqlRecord::clear();

}

/*!

    Insert a copy of \a fieldInfo at position \a pos. If a field

    already exists at \a pos, it is removed. Note that all references

    to the cursor edit buffer become invalidated.

*/

void  Q3SqlCursor::insert(int pos, const Q3SqlFieldInfo& fieldInfo)

{

    d->editBuffer.replace(pos, fieldInfo.toField());

    d->infoBuffer[pos] = fieldInfo;

    QSqlRecord::replace(pos, fieldInfo.toField());

}

/*!

    Removes the field at \a pos. If \a pos does not exist, nothing

    happens. Note that all references to the cursor edit buffer become

    invalidated.

*/

void Q3SqlCursor::remove(int pos)

{

    d->editBuffer.remove(pos);

    d->infoBuffer[pos] = Q3SqlFieldInfo();

    QSqlRecord::remove(pos);

}

/*!

    Sets the generated flag for the field \a name to \a generated. If

    the field does not exist, nothing happens. Only fields that have

    \a generated set to true are included in the SQL that is

    generated by insert(), update() or del().

*/

void Q3SqlCursor::setGenerated(const QString& name, bool generated)

{

    int pos = indexOf(name);

    if (pos == -1)

        return;

    QSqlRecord::setGenerated(name, generated);

    d->editBuffer.setGenerated(name, generated);

    d->infoBuffer[pos].setGenerated(generated);