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

**

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

#include "qsqldriver.h"

#include "qsqlerror.h"

#include "qsqlfield.h"

#include "qsqlindex.h"

#include "qsqlquery.h"

#include "qsqlrecord.h"

#include "qsqlresult.h"

#include "qsqltablemodel_p.h"

#include <qdebug.h>

QT_BEGIN_NAMESPACE

/*! \internal

    Populates our record with values.

*/

QSqlRecord QSqlTableModelPrivate::record(const QVector<QVariant> &values) const

{

    QSqlRecord r = rec;

    for (int i = 0; i < r.count() && i < values.count(); ++i)

        r.setValue(i, values.at(i));

    return r;

}

/*! \internal

    Set a record for OnFieldChange and OnRowChange.

*/

bool QSqlTableModelPrivate::setRecord(int row, const QSqlRecord &record)

{

    Q_Q(QSqlTableModel);

    bool isOk = true;

    QSqlTableModel::EditStrategy oldStrategy = strategy;

    // FieldChange strategy makes no sense when setting an entire row

    if (strategy == QSqlTableModel::OnFieldChange)

        strategy = QSqlTableModel::OnRowChange;

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

        int idx = nameToIndex(record.fieldName(i));

        if (idx == -1)

            continue;

        QModelIndex cIndex = q->createIndex(row, idx);

        QVariant value = record.value(i);

        QVariant oldValue = q->data(cIndex);

        if (oldValue.isNull() || oldValue != value)

            isOk &= q->setData(cIndex, value, Qt::EditRole);

    }

    if (isOk && oldStrategy == QSqlTableModel::OnFieldChange)

        q->submitAll();

    strategy = oldStrategy;

    return isOk;

}

int QSqlTableModelPrivate::nameToIndex(const QString &name) const

{

    QString fieldname = name;

    if (db.driver()->isIdentifierEscaped(fieldname, QSqlDriver::FieldName))

        fieldname = db.driver()->stripDelimiters(fieldname, QSqlDriver::FieldName);

    return rec.indexOf(fieldname);

}

void QSqlTableModelPrivate::initRecordAndPrimaryIndex()

{

    rec = db.record(tableName);

    primaryIndex = db.primaryIndex(tableName);

}

void QSqlTableModelPrivate::clear()

{

    editIndex = -1;

    sortColumn = -1;

    sortOrder = Qt::AscendingOrder;

    tableName.clear();

    editQuery.clear();

    editBuffer.clear();

    cache.clear();

    primaryIndex.clear();

    rec.clear();

    filter.clear();

}

void QSqlTableModelPrivate::revertInsertedRow()

{

    Q_Q(QSqlTableModel);

    if (insertIndex == -1)

        return;

    q->beginRemoveRows(QModelIndex(), insertIndex, insertIndex);

    insertIndex = -1;

    q->endRemoveRows();

}

void QSqlTableModelPrivate::clearEditBuffer()

{

    editBuffer = rec;

}

void QSqlTableModelPrivate::clearCache()

{

    cache.clear();

}

void QSqlTableModelPrivate::revertCachedRow(int row)

{

    Q_Q(QSqlTableModel);

    ModifiedRow r = cache.value(row);

    switch (r.op) {

    case QSqlTableModelPrivate::None:

        Q_ASSERT_X(false, "QSqlTableModelPrivate::revertCachedRow()", "Invalid entry in cache map");

        return;

    case QSqlTableModelPrivate::Update:

    case QSqlTableModelPrivate::Delete:

        cache.remove(row);

        emit q->dataChanged(q->createIndex(row, 0),

                            q->createIndex(row, q->columnCount() - 1));

        break;

    case QSqlTableModelPrivate::Insert: {

            QMap<int, QSqlTableModelPrivate::ModifiedRow>::Iterator it = cache.find(row);

            if (it == cache.end())

                return;

            q->beginRemoveRows(QModelIndex(), row, row);

            it = cache.erase(it);

            while (it != cache.end()) {

                int oldKey = it.key();

                const QSqlTableModelPrivate::ModifiedRow oldValue = it.value();

                cache.erase(it);

                it = cache.insert(oldKey - 1, oldValue);

                ++it;

            }

            q->endRemoveRows();

        break; }

    }

}

bool QSqlTableModelPrivate::exec(const QString &stmt, bool prepStatement,

                                 const QSqlRecord &rec, const QSqlRecord &whereValues)

{

    if (stmt.isEmpty())

        return false;

    // lazy initialization of editQuery

    if (editQuery.driver() != db.driver())

        editQuery = QSqlQuery(db);

    // workaround for In-Process databases - remove all read locks

    // from the table to make sure the editQuery succeeds

    if (db.driver()->hasFeature(QSqlDriver::SimpleLocking))

        const_cast<QSqlResult *>(query.result())->detachFromResultSet();

    if (prepStatement) {

        if (editQuery.lastQuery() != stmt) {

            if (!editQuery.prepare(stmt)) {

                error = editQuery.lastError();

                return false;

            }

        }

        int i;

        for (i = 0; i < rec.count(); ++i) {

            if (rec.isGenerated(i) && rec.value(i).type() != QVariant::Invalid)

                editQuery.addBindValue(rec.value(i));

        }

        for (i = 0; i < whereValues.count(); ++i) {

            if (whereValues.isGenerated(i) && !whereValues.isNull(i))

                editQuery.addBindValue(whereValues.value(i));

        }

        if (!editQuery.exec()) {

            error = editQuery.lastError();

            return false;

        }

    } else {

        if (!editQuery.exec(stmt)) {

            error = editQuery.lastError();

            return false;

        }

    }

    return true;

}

QSqlRecord QSqlTableModelPrivate::primaryValues(int row)

{

    QSqlRecord record;

    if (!query.seek(row)) {

        error = query.lastError();

        return record;

    }

    if (primaryIndex.isEmpty()) {

        record = rec;

        for (int i = 0; i < record.count(); ++i)

            record.setValue(i, query.value(i));

    } else {

        record = primaryIndex;

        for (int i = 0; i < record.count(); ++i)

            record.setValue(i, query.value(rec.indexOf(record.fieldName(i))));

    }

    return record;

}

/*!

    \class QSqlTableModel

    \brief The QSqlTableModel class provides an editable data model

    for a single database table.

    \ingroup database

    \inmodule QtSql

    QSqlTableModel is a high-level interface for reading and writing

    database records from a single table. It is build on top of the

    lower-level QSqlQuery and can be used to provide data to view

    classes such as QTableView. For example:

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

    We set the SQL table's name and the edit strategy, then we set up

    the labels displayed in the view header. The edit strategy

    dictates when the changes done by the user in the view are

    actually applied to the database. The possible values are \l

    OnFieldChange, \l OnRowChange, and \l OnManualSubmit.

    QSqlTableModel can also be used to access a database

    programmatically, without binding it to a view:

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

    The code snippet above extracts the \c salary field from record 4 in

    the result set of the query \c{SELECT * from employee}.

    It is possible to set filters using setFilter(), or modify the

    sort order using setSort(). At the end, you must call select() to

    populate the model with data.

    The \l{sql/tablemodel} example illustrates how to use

    QSqlTableModel as the data source for a QTableView.

    QSqlTableModel provides no direct support for foreign keys. Use

    the QSqlRelationalTableModel and QSqlRelationalDelegate if you

    want to resolve foreign keys.

    \sa QSqlRelationalTableModel, QSqlQuery, {Model/View Programming},

        {Table Model Example}, {Cached Table Example}

*/

/*!

    \fn QSqlTableModel::beforeDelete(int row)

    This signal is emitted by deleteRowFromTable() before the \a row

    is deleted from the currently active database table.

*/

/*!

    \fn void QSqlTableModel::primeInsert(int row, QSqlRecord &record)

    This signal is emitted by insertRows(), when an insertion is

    initiated in the given \a row of the currently active database

    table. The \a record parameter can be written to (since it is a

    reference), for example to populate some fields with default

    values.

*/

/*!

    \fn QSqlTableModel::beforeInsert(QSqlRecord &record)

    This signal is emitted by insertRowIntoTable() before a new row is

    inserted into the currently active database table. The values that

    are about to be inserted are stored in \a record and can be

    modified before they will be inserted.

*/

/*!

    \fn QSqlTableModel::beforeUpdate(int row, QSqlRecord &record)

    This signal is emitted by updateRowInTable() before the \a row is

    updated in the currently active database table with the values

    from \a record.

    Note that only values that are marked as generated will be updated.

    The generated flag can be set with \l QSqlRecord::setGenerated()

    and checked with \l QSqlRecord::isGenerated().

    \sa QSqlRecord::isGenerated()

*/

/*!

    Creates an empty QSqlTableModel and sets the parent to \a parent

    and the database connection to \a db. If \a db is not valid, the

    default database connection will be used.

    The default edit strategy is \l OnRowChange.

*/

QSqlTableModel::QSqlTableModel(QObject *parent, QSqlDatabase db)

    : QSqlQueryModel(*new QSqlTableModelPrivate, parent)

{

    Q_D(QSqlTableModel);

    d->db = db.isValid() ? db : QSqlDatabase::database();

}

/*!  \internal

*/

QSqlTableModel::QSqlTableModel(QSqlTableModelPrivate &dd, QObject *parent, QSqlDatabase db)

    : QSqlQueryModel(dd, parent)

{

    Q_D(QSqlTableModel);

    d->db = db.isValid() ? db : QSqlDatabase::database();

}

/*!

    Destroys the object and frees any allocated resources.

*/

QSqlTableModel::~QSqlTableModel()

{

}

/*!

    Sets the database table on which the model operates to \a

    tableName. Does not select data from the table, but fetches its

    field information.

    To populate the model with the table's data, call select().

    Error information can be retrieved with \l lastError().

    \sa select(), setFilter(), lastError()

*/

void QSqlTableModel::setTable(const QString &tableName)

{

    Q_D(QSqlTableModel);

    clear();

    d->tableName = tableName;

    d->initRecordAndPrimaryIndex();

    d->initColOffsets(d->rec.count());

    if (d->rec.count() == 0)

        d->error = QSqlError(QLatin1String("Unable to find table ") + d->tableName, QString(),

                             QSqlError::StatementError);

}

/*!

    Returns the name of the currently selected table.

*/

QString QSqlTableModel::tableName() const

{

    Q_D(const QSqlTableModel);

    return d->tableName;

}

/*!

    Populates the model with data from the table that was set via setTable(), using the

    specified filter and sort condition, and returns true if successful; otherwise

    returns false.

    \sa setTable(), setFilter(), selectStatement()

*/

bool QSqlTableModel::select()

{

    Q_D(QSqlTableModel);

    QString query = selectStatement();

    if (query.isEmpty())

        return false;

    revertAll();

    QSqlQuery qu(query, d->db);

    setQuery(qu);

    if (!qu.isActive()) {

        // something went wrong - revert to non-select state

        d->initRecordAndPrimaryIndex();

        return false;

    }

    return true;

}

/*!

    \reimp

*/

QVariant QSqlTableModel::data(const QModelIndex &index, int role) const

{

    Q_D(const QSqlTableModel);

    if (!index.isValid() || (role != Qt::DisplayRole && role != Qt::EditRole))

        return QVariant();

    QModelIndex item = indexInQuery(index);

    switch (d->strategy) {

    case OnFieldChange:

    case OnRowChange:

        if (index.row() == d->insertIndex) {

            QVariant val;

            if (item.column() < 0 || item.column() >= d->rec.count())

                return val;

            val = d->editBuffer.value(index.column());

            if (val.type() == QVariant::Invalid)

                val = QVariant(d->rec.field(item.column()).type());

            return val;

        }

        if (d->editIndex == item.row()) {

            QVariant var = d->editBuffer.value(item.column());

            if (var.isValid())

                return var;

        }

        break;

    case OnManualSubmit: {

        const QSqlTableModelPrivate::ModifiedRow row = d->cache.value(index.row());

        const QVariant var = row.rec.value(item.column());

        if (var.isValid() || row.op == QSqlTableModelPrivate::Insert)

            return var;

        break; }

    }

    return QSqlQueryModel::data(item, role);

}

/*!

    \reimp

*/

QVariant QSqlTableModel::headerData(int section, Qt::Orientation orientation, int role) const

{

    Q_D(const QSqlTableModel);

    if (orientation == Qt::Vertical && role == Qt::DisplayRole) {

        switch (d->strategy) {

        case OnFieldChange:

        case OnRowChange:

            if (d->insertIndex == section)

                return QLatin1String("*");

            break;

        case OnManualSubmit:

            QSqlTableModelPrivate::Op op = d->cache.value(section).op;

            if (op == QSqlTableModelPrivate::Insert)

                return QLatin1String("*");

            else if (op == QSqlTableModelPrivate::Delete)

                return QLatin1String("!");

            break;

        }

    }

    return QSqlQueryModel::headerData(section, orientation, role);

}

/*!

    Returns true if the value at the index \a index is dirty, otherwise false.

    Dirty values are values that were modified in the model

    but not yet written into the database.

    If \a index is invalid or points to a non-existing row, false is returned.

*/

bool QSqlTableModel::isDirty(const QModelIndex &index) const

{

    Q_D(const QSqlTableModel);

    if (!index.isValid())

        return false;

    switch (d->strategy) {

        case OnFieldChange:

            return false;

        case OnRowChange:

            return index.row() == d->editIndex && d->editBuffer.value(index.column()).isValid();

        case OnManualSubmit: {

            const QSqlTableModelPrivate::ModifiedRow row = d->cache.value(index.row());

            return row.op == QSqlTableModelPrivate::Insert

                   || row.op == QSqlTableModelPrivate::Delete

                   || (row.op == QSqlTableModelPrivate::Update

                       && row.rec.value(index.column()).isValid());

        }

    }

    return false;

}

/*!

    Sets the data for the item \a index for the role \a role to \a

    value. Depending on the edit strategy, the value might be applied

    to the database at once or cached in the model.

    Returns true if the value could be set or false on error, for

    example if \a index is out of bounds.

    \sa editStrategy(), data(), submit(), submitAll(), revertRow()

*/

bool QSqlTableModel::setData(const QModelIndex &index, const QVariant &value, int role)

{

    Q_D(QSqlTableModel);

    if (role != Qt::EditRole)

        return QSqlQueryModel::setData(index, value, role);

    if (!index.isValid() || index.column() >= d->rec.count() || index.row() >= rowCount())

        return false;