/******************************************************************************** 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 "qsqltablemodel.h"#include "qsqldriver.h"#include "qsqlerror.h"#include "qsqlfield.h"#include "qsqlindex.h"#include "qsqlquery.h"#include "qsqlrecord.h"#include "qsqltablemodel_p.h"#include <qdebug.h>/*! \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{    return rec.indexOf(name);}void QSqlTableModelPrivate::initRecordAndPrimaryIndex(){    rec = db.record(tableName);    primaryIndex = db.primaryIndex(tableName);}void QSqlTableModelPrivate::clear(){    editIndex = -1;    sortColumn = -1;    sortOrder = Qt::AscendingOrder;    tableName = QString();    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::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);    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))                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    \module sql    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:    \quotefromfile snippets/sqldatabase/sqldatabase.cpp    \skipto QSqlTableModel_snippets    \skipto QSqlTableModel *model    \printuntil show()    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:    \skipto QSqlTableModel model    \printuntil QString name =    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 before the \a row is deleted.*//*!    \fn void QSqlTableModel::primeInsert(int row, QSqlRecord &record)    This signal is emitted when an insertion is initiated in the given    \a row. 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 before a new row is inserted. 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 before the \a row is updated 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().    \sa select(), setFilter()*/void QSqlTableModel::setTable(const QString &tableName){    Q_D(QSqlTableModel);    clear();    d->tableName = tableName;    d->initRecordAndPrimaryIndex();}/*!    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);