Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

11 files changed, 3526 insertions, 0 deletions

diff --git a/src/sql/models/models.pri b/src/sql/models/models.pri
new file mode 100644
index 0000000000..972cf2f3f2
--- /dev/null
+++ b/src/sql/models/models.pri
@@ -0,0 +1,12 @@
+HEADERS +=      models/qsqlquerymodel.h \
+                models/qsqlquerymodel_p.h \
+                models/qsqltablemodel.h \
+                models/qsqltablemodel_p.h \
+                models/qsqlrelationaldelegate.h \
+                models/qsqlrelationaltablemodel.h
+
+SOURCES +=      models/qsqlquerymodel.cpp \
+                models/qsqltablemodel.cpp \
+                models/qsqlrelationaldelegate.cpp \
+                models/qsqlrelationaltablemodel.cpp
+
diff --git a/src/sql/models/qsqlquerymodel.cpp b/src/sql/models/qsqlquerymodel.cpp
new file mode 100644
index 0000000000..d1051dedab
--- /dev/null
+++ b/src/sql/models/qsqlquerymodel.cpp
@@ -0,0 +1,600 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 "qsqlquerymodel.h"
+
+#include <qdebug.h>
+#include <qsqldriver.h>
+#include <qsqlfield.h>
+
+#include "qsqlquerymodel_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#define QSQL_PREFETCH 255
+
+void QSqlQueryModelPrivate::prefetch(int limit)
+{
+    Q_Q(QSqlQueryModel);
+
+    if (atEnd || limit <= bottom.row() || bottom.column() == -1)
+        return;
+
+    QModelIndex newBottom;
+    const int oldBottomRow = qMax(bottom.row(), 0);
+
+    // try to seek directly
+    if (query.seek(limit)) {
+        newBottom = q->createIndex(limit, bottom.column());
+    } else {
+        // have to seek back to our old position for MS Access
+        int i = oldBottomRow;
+        if (query.seek(i)) {
+            while (query.next())
+                ++i;
+            newBottom = q->createIndex(i, bottom.column());
+        } else {
+            // empty or invalid query
+            newBottom = q->createIndex(-1, bottom.column());
+        }
+        atEnd = true; // this is the end.
+    }
+    if (newBottom.row() >= 0 && newBottom.row() > bottom.row()) {
+        q->beginInsertRows(QModelIndex(), bottom.row() + 1, newBottom.row());
+        bottom = newBottom;
+        q->endInsertRows();
+    } else {
+        bottom = newBottom;
+    }
+}
+
+QSqlQueryModelPrivate::~QSqlQueryModelPrivate()
+{
+}
+
+void QSqlQueryModelPrivate::initColOffsets(int size)
+{
+    colOffsets.resize(size);
+    memset(colOffsets.data(), 0, colOffsets.size() * sizeof(int));
+}
+
+/*!
+    \class QSqlQueryModel
+    \brief The QSqlQueryModel class provides a read-only data model for SQL
+    result sets.
+
+    \ingroup database
+    \inmodule QtSql
+
+    QSqlQueryModel is a high-level interface for executing SQL
+    statements and traversing the result set. It is built 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 16
+
+    We set the model's query, then we set up the labels displayed in
+    the view header.
+
+    QSqlQueryModel can also be used to access a database
+    programmatically, without binding it to a view:
+
+    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 21
+
+    The code snippet above extracts the \c salary field from record 4 in
+    the result set of the query \c{SELECT * from employee}. Assuming
+    that \c salary is column 2, we can rewrite the last line as follows:
+
+    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 22
+
+    The model is read-only by default. To make it read-write, you
+    must subclass it and reimplement setData() and flags(). Another
+    option is to use QSqlTableModel, which provides a read-write
+    model based on a single database table.
+
+    The \l{sql/querymodel} example illustrates how to use
+    QSqlQueryModel to display the result of a query. It also shows
+    how to subclass QSqlQueryModel to customize the contents of the
+    data before showing it to the user, and how to create a
+    read-write model based on QSqlQueryModel.
+
+    If the database doesn't return the amount of selected rows in
+    a query, the model will fetch rows incrementally.
+    See fetchMore() for more information.
+
+    \sa QSqlTableModel, QSqlRelationalTableModel, QSqlQuery,
+        {Model/View Programming}, {Query Model Example}
+*/
+
+/*!
+    Creates an empty QSqlQueryModel with the given \a parent.
+ */
+QSqlQueryModel::QSqlQueryModel(QObject *parent)
+    : QAbstractTableModel(*new QSqlQueryModelPrivate, parent)
+{
+}
+
+/*! \internal
+ */
+QSqlQueryModel::QSqlQueryModel(QSqlQueryModelPrivate &dd, QObject *parent)
+    : QAbstractTableModel(dd, parent)
+{
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+
+    \sa clear()
+*/
+QSqlQueryModel::~QSqlQueryModel()
+{
+}
+
+/*!
+    \since 4.1
+
+    Fetches more rows from a database.
+    This only affects databases that don't report back the size of a query
+    (see QSqlDriver::hasFeature()).
+
+    To force fetching of the entire database, you can use the following:
+
+    \snippet doc/src/snippets/code/src_sql_models_qsqlquerymodel.cpp 0
+
+    \a parent should always be an invalid QModelIndex.
+
+    \sa canFetchMore()
+*/
+void QSqlQueryModel::fetchMore(const QModelIndex &parent)
+{
+    Q_D(QSqlQueryModel);
+    if (parent.isValid())
+        return;
+    d->prefetch(qMax(d->bottom.row(), 0) + QSQL_PREFETCH);
+}
+
+/*!
+    \since 4.1
+
+    Returns true if it is possible to read more rows from the database.
+    This only affects databases that don't report back the size of a query
+    (see QSqlDriver::hasFeature()).
+
+    \a parent should always be an invalid QModelIndex.
+
+    \sa fetchMore()
+ */
+bool QSqlQueryModel::canFetchMore(const QModelIndex &parent) const
+{
+    Q_D(const QSqlQueryModel);
+    return (!parent.isValid() && !d->atEnd);
+}
+
+/*! \fn int QSqlQueryModel::rowCount(const QModelIndex &parent) const
+    \since 4.1
+
+    If the database supports returning the size of a query
+    (see QSqlDriver::hasFeature()), the amount of rows of the current
+    query is returned. Otherwise, returns the amount of rows
+    currently cached on the client.
+
+    \a parent should always be an invalid QModelIndex.
+
+    \sa canFetchMore(), QSqlDriver::hasFeature()
+ */
+int QSqlQueryModel::rowCount(const QModelIndex &index) const
+{
+    Q_D(const QSqlQueryModel);
+    return index.isValid() ? 0 : d->bottom.row() + 1;
+}
+
+/*! \reimp
+ */
+int QSqlQueryModel::columnCount(const QModelIndex &index) const
+{
+    Q_D(const QSqlQueryModel);
+    return index.isValid() ? 0 : d->rec.count();
+}
+
+/*!
+    Returns the value for the specified \a item and \a role.
+
+    If \a item is out of bounds or if an error occurred, an invalid
+    QVariant is returned.
+
+    \sa lastError()
+*/
+QVariant QSqlQueryModel::data(const QModelIndex &item, int role) const
+{
+    Q_D(const QSqlQueryModel);
+    if (!item.isValid())
+        return QVariant();
+
+    QVariant v;
+    if (role & ~(Qt::DisplayRole | Qt::EditRole))
+        return v;
+
+    if (!d->rec.isGenerated(item.column()))
+        return v;
+    QModelIndex dItem = indexInQuery(item);
+    if (dItem.row() > d->bottom.row())
+        const_cast<QSqlQueryModelPrivate *>(d)->prefetch(dItem.row());
+
+    if (!d->query.seek(dItem.row())) {
+        d->error = d->query.lastError();
+        return v;
+    }
+
+    return d->query.value(dItem.column());
+}
+
+/*!
+    Returns the header data for the given \a role in the \a section
+    of the header with the specified \a orientation.
+*/
+QVariant QSqlQueryModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    Q_D(const QSqlQueryModel);
+    if (orientation == Qt::Horizontal) {
+        QVariant val = d->headers.value(section).value(role);
+        if (role == Qt::DisplayRole && !val.isValid())
+            val = d->headers.value(section).value(Qt::EditRole);
+        if (val.isValid())
+            return val;
+
+        // See if it's an inserted column (iiq.column() != -1)
+        QModelIndex dItem = indexInQuery(createIndex(0, section));
+
+        if (role == Qt::DisplayRole && d->rec.count() > section && dItem.column() != -1)
+            return d->rec.fieldName(section);
+    }
+    return QAbstractItemModel::headerData(section, orientation, role);
+}
+
+/*!
+    This virtual function is called whenever the query changes. The
+    default implementation does nothing.
+
+    query() returns the new query.
+
+    \sa query(), setQuery()
+ */
+void QSqlQueryModel::queryChange()
+{
+    // do nothing
+}
+
+/*!
+    Resets the model and sets the data provider to be the given \a
+    query. Note that the query must be active and must not be
+    isForwardOnly().
+
+    lastError() can be used to retrieve verbose information if there
+    was an error setting the query.
+
+    \note Calling setQuery() will remove any inserted columns.
+
+    \sa query(), QSqlQuery::isActive(), QSqlQuery::setForwardOnly(), lastError()
+*/
+void QSqlQueryModel::setQuery(const QSqlQuery &query)
+{
+    Q_D(QSqlQueryModel);
+    QSqlRecord newRec = query.record();
+    bool columnsChanged = (newRec != d->rec);
+    bool hasQuerySize = query.driver()->hasFeature(QSqlDriver::QuerySize);
+    bool hasNewData = (newRec != QSqlRecord()) || !query.lastError().isValid();
+
+    if (d->colOffsets.size() != newRec.count() || columnsChanged)
+        d->initColOffsets(newRec.count());
+
+    bool mustClearModel = d->bottom.isValid();
+    if (mustClearModel) {
+        d->atEnd = true;
+        beginRemoveRows(QModelIndex(), 0, qMax(d->bottom.row(), 0));
+        d->bottom = QModelIndex();
+    }
+
+    d->error = QSqlError();
+    d->query = query;
+    d->rec = newRec;
+
+    if (mustClearModel)
+        endRemoveRows();
+
+    d->atEnd = false;
+
+    if (columnsChanged && hasNewData)
+        reset();
+
+    if (!query.isActive() || query.isForwardOnly()) {
+        d->atEnd = true;
+        d->bottom = QModelIndex();
+        if (query.isForwardOnly())
+            d->error = QSqlError(QLatin1String("Forward-only queries "
+                                               "cannot be used in a data model"),
+                                 QString(), QSqlError::ConnectionError);
+        else
+            d->error = query.lastError();
+        return;
+    }
+    QModelIndex newBottom;
+    if (hasQuerySize && d->query.size() > 0) {
+        newBottom = createIndex(d->query.size() - 1, d->rec.count() - 1);
+        beginInsertRows(QModelIndex(), 0, qMax(0, newBottom.row()));
+        d->bottom = createIndex(d->query.size() - 1, columnsChanged ? 0 : d->rec.count() - 1);
+        d->atEnd = true;
+        endInsertRows();
+    } else {
+        newBottom = createIndex(-1, d->rec.count() - 1);
+    }
+    d->bottom = newBottom;
+
+    queryChange();
+
+    // fetchMore does the rowsInserted stuff for incremental models
+    fetchMore();
+}
+
+/*! \overload
+
+    Executes the query \a query for the given database connection \a
+    db. If no database (or an invalid database) is specified, the
+    default connection is used.
+
+    lastError() can be used to retrieve verbose information if there
+    was an error setting the query.
+
+    Example:
+    \snippet doc/src/snippets/code/src_sql_models_qsqlquerymodel.cpp 1
+
+    \sa query(), queryChange(), lastError()
+*/
+void QSqlQueryModel::setQuery(const QString &query, const QSqlDatabase &db)
+{
+    setQuery(QSqlQuery(query, db));
+}
+
+/*!
+    Clears the model and releases any acquired resource.
+*/
+void QSqlQueryModel::clear()
+{
+    Q_D(QSqlQueryModel);
+    d->error = QSqlError();
+    d->atEnd = true;
+    d->query.clear();
+    d->rec.clear();
+    d->colOffsets.clear();
+    d->bottom = QModelIndex();
+    d->headers.clear();
+}
+
+/*!
+    Sets the caption for a horizontal header for the specified \a role to
+    \a value. This is useful if the model is used to
+    display data in a view (e.g., QTableView).
+
+    Returns true if \a orientation is Qt::Horizontal and
+    the \a section refers to a valid section; otherwise returns
+    false.
+
+    Note that this function cannot be used to modify values in the
+    database since the model is read-only.
+
+    \sa data()
+ */
+bool QSqlQueryModel::setHeaderData(int section, Qt::Orientation orientation,
+                                   const QVariant &value, int role)
+{
+    Q_D(QSqlQueryModel);
+    if (orientation != Qt::Horizontal || section < 0 || columnCount() <= section)
+        return false;
+
+    if (d->headers.size() <= section)
+        d->headers.resize(qMax(section + 1, 16));
+    d->headers[section][role] = value;
+    emit headerDataChanged(orientation, section, section);
+    return true;
+}
+
+/*!
+    Returns the QSqlQuery associated with this model.
+
+    \sa setQuery()
+*/
+QSqlQuery QSqlQueryModel::query() const
+{
+    Q_D(const QSqlQueryModel);
+    return d->query;
+}
+
+/*!
+    Returns information about the last error that occurred on the
+    database.
+
+    \sa query()
+*/
+QSqlError QSqlQueryModel::lastError() const
+{
+    Q_D(const QSqlQueryModel);
+    return d->error;
+}
+
+/*!
+   Protected function which allows derived classes to set the value of
+   the last error that occurred on the database to \a error.
+
+   \sa lastError()
+*/
+void QSqlQueryModel::setLastError(const QSqlError &error)
+{
+    Q_D(QSqlQueryModel);
+    d->error = error;
+}
+
+/*!
+    Returns the record containing information about the fields of the
+    current query. If \a row is the index of a valid row, the record
+    will be populated with values from that row.
+
+    If the model is not initialized, an empty record will be
+    returned.
+
+    \sa QSqlRecord::isEmpty()
+*/
+QSqlRecord QSqlQueryModel::record(int row) const
+{
+    Q_D(const QSqlQueryModel);
+    if (row < 0)
+        return d->rec;
+
+    QSqlRecord rec = d->rec;
+    for (int i = 0; i < rec.count(); ++i)
+        rec.setValue(i, data(createIndex(row, i), Qt::EditRole));
+    return rec;
+}
+
+/*! \overload
+
+    Returns an empty record containing information about the fields
+    of the current query.
+
+    If the model is not initialized, an empty record will be
+    returned.
+
+    \sa QSqlRecord::isEmpty()
+ */
+QSqlRecord QSqlQueryModel::record() const
+{
+    Q_D(const QSqlQueryModel);
+    return d->rec;
+}
+
+/*!
+    Inserts \a count columns into the model at position \a column. The
+    \a parent parameter must always be an invalid QModelIndex, since
+    the model does not support parent-child relationships.
+
+    Returns true if \a column is within bounds; otherwise returns false.
+
+    By default, inserted columns are empty. To fill them with data,
+    reimplement data() and handle any inserted column separately:
+
+    \snippet doc/src/snippets/sqldatabase/sqldatabase.cpp 23
+
+    \sa removeColumns()
+*/
+bool QSqlQueryModel::insertColumns(int column, int count, const QModelIndex &parent)
+{
+    Q_D(QSqlQueryModel);
+    if (count <= 0 || parent.isValid() || column < 0 || column > d->rec.count())
+        return false;
+
+    beginInsertColumns(parent, column, column + count - 1);
+    for (int c = 0; c < count; ++c) {
+        QSqlField field;
+        field.setReadOnly(true);
+        field.setGenerated(false);
+        d->rec.insert(column, field);
+        if (d->colOffsets.size() < d->rec.count()) {
+            int nVal = d->colOffsets.isEmpty() ? 0 : d->colOffsets[d->colOffsets.size() - 1];
+            d->colOffsets.append(nVal);
+            Q_ASSERT(d->colOffsets.size() >= d->rec.count());
+        }
+        for (int i = column + 1; i < d->colOffsets.count(); ++i)
+            ++d->colOffsets[i];
+    }
+    endInsertColumns();
+    return true;
+}
+
+/*!
+    Removes \a count columns from the model starting from position \a
+    column. The \a parent parameter must always be an invalid
+    QModelIndex, since the model does not support parent-child
+    relationships.
+
+    Removing columns effectively hides them. It does not affect the
+    underlying QSqlQuery.
+
+    Returns true if the columns were removed; otherwise returns false.
+ */
+bool QSqlQueryModel::removeColumns(int column, int count, const QModelIndex &parent)
+{
+    Q_D(QSqlQueryModel);
+    if (count <= 0 || parent.isValid() || column < 0 || column >= d->rec.count())
+        return false;
+
+    beginRemoveColumns(parent, column, column + count - 1);
+
+    int i;
+    for (i = 0; i < count; ++i)
+        d->rec.remove(column);
+    for (i = column; i < d->colOffsets.count(); ++i)
+        d->colOffsets[i] -= count;
+
+    endRemoveColumns();
+    return true;
+}
+
+/*!
+    Returns the index of the value in the database result set for the
+    given \a item in the model.
+
+    The return value is identical to \a item if no columns or rows
+    have been inserted, removed, or moved around.
+
+    Returns an invalid model index if \a item is out of bounds or if
+    \a item does not point to a value in the result set.
+
+    \sa QSqlTableModel::indexInQuery(), insertColumns(), removeColumns()
+*/
+QModelIndex QSqlQueryModel::indexInQuery(const QModelIndex &item) const
+{
+    Q_D(const QSqlQueryModel);
+    if (item.column() < 0 || item.column() >= d->rec.count()
+        || !d->rec.isGenerated(item.column()))
+        return QModelIndex();
+    return createIndex(item.row(), item.column() - d->colOffsets[item.column()],
+                       item.internalPointer());
+}
+
+QT_END_NAMESPACE
diff --git a/src/sql/models/qsqlquerymodel.h b/src/sql/models/qsqlquerymodel.h
new file mode 100644
index 0000000000..b4acfa114f
--- /dev/null
+++ b/src/sql/models/qsqlquerymodel.h
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#ifndef QSQLQUERYMODEL_H
+#define QSQLQUERYMODEL_H
+
+#include <QtCore/qabstractitemmodel.h>
+#include <QtSql/qsqldatabase.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Sql)
+
+class QSqlQueryModelPrivate;
+class QSqlError;
+class QSqlRecord;
+class QSqlQuery;
+
+class Q_SQL_EXPORT QSqlQueryModel: public QAbstractTableModel
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QSqlQueryModel)
+
+public:
+    explicit QSqlQueryModel(QObject *parent = 0);
+    virtual ~QSqlQueryModel();
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    QSqlRecord record(int row) const;
+    QSqlRecord record() const;
+
+    QVariant data(const QModelIndex &item, int role = Qt::DisplayRole) const;
+    QVariant headerData(int section, Qt::Orientation orientation,
+                        int role = Qt::DisplayRole) const;
+    bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value,
+                       int role = Qt::EditRole);
+
+    bool insertColumns(int column, int count, const QModelIndex &parent = QModelIndex());
+    bool removeColumns(int column, int count, const QModelIndex &parent = QModelIndex());
+
+    void setQuery(const QSqlQuery &query);
+    void setQuery(const QString &query, const QSqlDatabase &db = QSqlDatabase());
+    QSqlQuery query() const;
+
+    virtual void clear();
+
+    QSqlError lastError() const;
+
+    void fetchMore(const QModelIndex &parent = QModelIndex());
+    bool canFetchMore(const QModelIndex &parent = QModelIndex()) const;
+
+protected:
+    virtual void queryChange();
+
+    QModelIndex indexInQuery(const QModelIndex &item) const;
+    void setLastError(const QSqlError &error);
+    QSqlQueryModel(QSqlQueryModelPrivate &dd, QObject *parent = 0);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSQLQUERYMODEL_H
diff --git a/src/sql/models/qsqlquerymodel_p.h b/src/sql/models/qsqlquerymodel_p.h
new file mode 100644
index 0000000000..f77a0c94a5
--- /dev/null
+++ b/src/sql/models/qsqlquerymodel_p.h
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#ifndef QSQLQUERYMODEL_P_H
+#define QSQLQUERYMODEL_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of qsql*model.h .  This header file may change from version to version
+// without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qabstractitemmodel_p.h"
+#include "QtSql/qsqlerror.h"
+#include "QtSql/qsqlquery.h"
+#include "QtSql/qsqlrecord.h"
+#include "QtCore/qhash.h"
+#include "QtCore/qvarlengtharray.h"
+#include "QtCore/qvector.h"
+
+QT_BEGIN_NAMESPACE
+
+class QSqlQueryModelPrivate: public QAbstractItemModelPrivate
+{
+    Q_DECLARE_PUBLIC(QSqlQueryModel)
+public:
+    QSqlQueryModelPrivate() : atEnd(false) {}
+    ~QSqlQueryModelPrivate();
+    
+    void prefetch(int);
+    void initColOffsets(int size);
+
+    mutable QSqlQuery query;
+    mutable QSqlError error;
+    QModelIndex bottom;
+    QSqlRecord rec;
+    uint atEnd : 1;
+    QVector<QHash<int, QVariant> > headers;
+    QVarLengthArray<int, 56> colOffsets; // used to calculate indexInQuery of columns
+};
+
+QT_END_NAMESPACE
+
+#endif // QSQLQUERYMODEL_P_H
diff --git a/src/sql/models/qsqlrelationaldelegate.cpp b/src/sql/models/qsqlrelationaldelegate.cpp
new file mode 100644
index 0000000000..4663ddbc65
--- /dev/null
+++ b/src/sql/models/qsqlrelationaldelegate.cpp
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 "qglobal.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QSqlRelationalDelegate
+    \brief The QSqlRelationalDelegate class provides a delegate that is used to
+    display and edit data from a QSqlRelationalTableModel.
+
+    Unlike the default delegate, QSqlRelationalDelegate provides a
+    combobox for fields that are foreign keys into other tables. To
+    use the class, simply call QAbstractItemView::setItemDelegate()
+    on the view with an instance of QSqlRelationalDelegate:
+
+    \snippet examples/sql/relationaltablemodel/relationaltablemodel.cpp 4
+
+    The \l{sql/relationaltablemodel}{Relational Table Model} example
+    (shown below) illustrates how to use QSqlRelationalDelegate in
+    conjunction with QSqlRelationalTableModel to provide tables with
+    foreign key support.
+
+    \image relationaltable.png
+
+    \sa QSqlRelationalTableModel, {Model/View Programming}
+*/
+
+
+/*!
+    \fn QSqlRelationalDelegate::QSqlRelationalDelegate(QObject *parent)
+
+    Constructs a QSqlRelationalDelegate object with the given \a
+    parent.
+*/
+
+/*!
+    \fn QSqlRelationalDelegate::~QSqlRelationalDelegate()
+
+    Destroys the QSqlRelationalDelegate object and frees any
+    allocated resources.
+*/
+
+/*!
+    \fn QWidget *QSqlRelationalDelegate::createEditor(QWidget *parent,
+                                                      const QStyleOptionViewItem &option,
+                                                      const QModelIndex &index) const
+    \reimp
+*/
+
+/*!
+    \fn void QSqlRelationalDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
+    \reimp
+*/
+
+/*!
+    \fn void QSqlRelationalDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
+                                                  const QModelIndex &index) const
+    \reimp
+*/
+
+QT_END_NAMESPACE
diff --git a/src/sql/models/qsqlrelationaldelegate.h b/src/sql/models/qsqlrelationaldelegate.h
new file mode 100644
index 0000000000..f4f4bc5136
--- /dev/null
+++ b/src/sql/models/qsqlrelationaldelegate.h
@@ -0,0 +1,129 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#ifndef QSQLRELATIONALDELEGATE_H
+#define QSQLRELATIONALDELEGATE_H
+
+#ifdef QT_GUI_LIB
+
+#include <QtGui/qitemdelegate.h>
+#include <QtGui/qlistview.h>
+#include <QtGui/qcombobox.h>
+#include <QtSql/qsqlrelationaltablemodel.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Sql)
+
+class QSqlRelationalDelegate: public QItemDelegate
+{
+public:
+
+explicit QSqlRelationalDelegate(QObject *aParent = 0)
+    : QItemDelegate(aParent)
+{}
+
+~QSqlRelationalDelegate()
+{}
+
+QWidget *createEditor(QWidget *aParent,
+                      const QStyleOptionViewItem &option,
+                      const QModelIndex &index) const
+{
+    const QSqlRelationalTableModel *sqlModel = qobject_cast<const QSqlRelationalTableModel *>(index.model());
+    QSqlTableModel *childModel = sqlModel ? sqlModel->relationModel(index.column()) : 0;
+    if (!childModel)
+        return QItemDelegate::createEditor(aParent, option, index);
+
+    QComboBox *combo = new QComboBox(aParent);
+    combo->setModel(childModel);
+    combo->setModelColumn(childModel->fieldIndex(sqlModel->relation(index.column()).displayColumn()));
+    combo->installEventFilter(const_cast<QSqlRelationalDelegate *>(this));
+
+    return combo;
+}
+
+void setEditorData(QWidget *editor, const QModelIndex &index) const
+{
+    const QSqlRelationalTableModel *sqlModel = qobject_cast<const QSqlRelationalTableModel *>(index.model());
+    QComboBox *combo = qobject_cast<QComboBox *>(editor);
+    if (!sqlModel || !combo) {
+        QItemDelegate::setEditorData(editor, index);
+        return;
+    }
+    combo->setCurrentIndex(combo->findText(sqlModel->data(index).toString()));
+}
+
+void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
+{
+    if (!index.isValid())
+        return;
+
+    QSqlRelationalTableModel *sqlModel = qobject_cast<QSqlRelationalTableModel *>(model);
+    QSqlTableModel *childModel = sqlModel ? sqlModel->relationModel(index.column()) : 0;
+    QComboBox *combo = qobject_cast<QComboBox *>(editor);
+    if (!sqlModel || !childModel || !combo) {
+        QItemDelegate::setModelData(editor, model, index);
+        return;
+    }
+
+    int currentItem = combo->currentIndex();
+    int childColIndex = childModel->fieldIndex(sqlModel->relation(index.column()).displayColumn());
+    int childEditIndex = childModel->fieldIndex(sqlModel->relation(index.column()).indexColumn());
+    sqlModel->setData(index,
+            childModel->data(childModel->index(currentItem, childColIndex), Qt::DisplayRole),
+            Qt::DisplayRole);
+    sqlModel->setData(index,
+            childModel->data(childModel->index(currentItem, childEditIndex), Qt::EditRole),
+            Qt::EditRole);
+}
+
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_GUI_LIB
+
+#endif // QSQLRELATIONALDELEGATE_H
diff --git a/src/sql/models/qsqlrelationaltablemodel.cpp b/src/sql/models/qsqlrelationaltablemodel.cpp
new file mode 100644
index 0000000000..63633e6ed9
--- /dev/null
+++ b/src/sql/models/qsqlrelationaltablemodel.cpp
@@ -0,0 +1,753 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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 "qsqlrelationaltablemodel.h"
+
+#include "qhash.h"
+#include "qstringlist.h"
+#include "qsqldatabase.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"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QSqlRelation
+    \brief The QSqlRelation class stores information about an SQL foreign key.
+
+    QSqlRelation is a helper class for QSqlRelationalTableModel. See
+    QSqlRelationalTableModel::setRelation() and
+    QSqlRelationalTableModel::relation() for details.
+
+    \sa QSqlRelationalTableModel, QSqlRelationalDelegate,
+        {Relational Table Model Example}
+*/
+
+/*!
+    \fn QSqlRelation::QSqlRelation()
+
+    Constructs an invalid QSqlRelation object.
+
+    For such an object, the tableName(), indexColumn(), and
+    displayColumn() functions return an empty string.
+
+    \sa isValid()
+*/
+
+/*!
+    \fn QSqlRelation::QSqlRelation(const QString &tableName, const QString &indexColumn,
+                                   const QString &displayColumn)
+
+    Constructs a QSqlRelation object, where \a tableName is the SQL
+    table name to which a foreign key refers, \a indexColumn is the
+    foreign key, and \a displayColumn is the field that should be
+    presented to the user.
+
+    \sa tableName(), indexColumn(), displayColumn()
+*/
+
+/*!
+    \fn QString QSqlRelation::tableName() const
+
+    Returns the name of the table to which a foreign key refers.
+*/
+
+/*!
+    \fn QString QSqlRelation::indexColumn() const
+
+    Returns the index column from table tableName() to which a
+    foreign key refers.
+*/
+
+/*!
+    \fn QString QSqlRelation::displayColumn() const
+
+    Returns the column from table tableName() that should be
+    presented to the user instead of a foreign key.
+*/
+
+/*!
+    \fn bool QSqlRelation::isValid() const
+
+    Returns true if the QSqlRelation object is valid; otherwise
+    returns false.
+*/
+
+struct QRelation
+{
+    public:
+        QRelation(): model(0),m_parent(0),m_dictInitialized(false){}
+        void init(QSqlRelationalTableModel *parent, const QSqlRelation &relation);
+
+        void populateModel();
+
+        bool isDictionaryInitialized();
+        void populateDictionary();
+        void clearDictionary();
+
+        void clear();
+        bool isValid();
+
+        QSqlRelation rel;
+        QSqlTableModel *model;
+        QHash<QString, QVariant> dictionary;//maps keys to display values
+
+    private:
+        QSqlRelationalTableModel *m_parent;
+        bool m_dictInitialized;
+};
+
+/*
+    A QRelation must be initialized before it is considered valid.
+    Note: population of the model and dictionary are kept separate
+          from initialization, and are populated on an as needed basis.
+*/
+void QRelation::init(QSqlRelationalTableModel *parent, const QSqlRelation &relation)
+{
+    Q_ASSERT(parent != NULL);
+    m_parent = parent;
+    rel = relation;
+}
+
+void QRelation::populateModel()
+{
+    if (!isValid())
+        return;
+    Q_ASSERT(m_parent != NULL);
+
+    if (!model) {
+        model = new QSqlTableModel(m_parent, m_parent->database());
+        model->setTable(rel.tableName());
+        model->select();
+    }
+}
+
+bool QRelation::isDictionaryInitialized()
+{
+    return m_dictInitialized;
+}
+
+void QRelation::populateDictionary()
+{
+    if (!isValid())
+        return;
+
+    if (model ==  NULL)
+        populateModel();
+
+    QSqlRecord record;
+    QString indexColumn;
+    QString displayColumn;
+    for (int i=0; i < model->rowCount(); ++i) {
+        record = model->record(i);
+
+        indexColumn = rel.indexColumn();
+        if (m_parent->database().driver()->isIdentifierEscaped(indexColumn, QSqlDriver::FieldName))
+            indexColumn = m_parent->database().driver()->stripDelimiters(indexColumn, QSqlDriver::FieldName);
+
+        displayColumn = rel.displayColumn();
+        if (m_parent->database().driver()->isIdentifierEscaped(displayColumn, QSqlDriver::FieldName))
+            displayColumn = m_parent->database().driver()->stripDelimiters(displayColumn, QSqlDriver::FieldName);
+
+        dictionary[record.field(indexColumn).value().toString()] =
+            record.field(displayColumn).value();
+    }
+    m_dictInitialized = true;
+}
+
+void QRelation::clearDictionary()
+{
+    dictionary.clear();
+    m_dictInitialized = false;
+}
+
+void QRelation::clear()
+{
+    delete model;
+    model = 0;
+    clearDictionary();
+}
+
+bool QRelation::isValid()
+{
+    return (rel.isValid() && m_parent != NULL);
+}
+
+class QSqlRelationalTableModelPrivate: public QSqlTableModelPrivate
+{
+    Q_DECLARE_PUBLIC(QSqlRelationalTableModel)
+public:
+    QSqlRelationalTableModelPrivate()
+        : QSqlTableModelPrivate()
+    {}
+    QString relationField(const QString &tableName, const QString &fieldName) const;
+
+    int nameToIndex(const QString &name) const;
+    mutable QVector<QRelation> relations;
+    QSqlRecord baseRec; // the record without relations
+    void clearChanges();
+    void clearEditBuffer();
+    void clearCache();
+    void revertCachedRow(int row);
+
+    void translateFieldNames(int row, QSqlRecord &values) const;
+};
+
+static void qAppendWhereClause(QString &query, const QString &clause1, const QString &clause2)
+{
+    if (clause1.isEmpty() && clause2.isEmpty())
+        return;
+    if (clause1.isEmpty() || clause2.isEmpty())
+        query.append(QLatin1String(" WHERE (")).append(clause1).append(clause2);
+    else
+        query.append(QLatin1String(" WHERE (")).append(clause1).append(
+                        QLatin1String(") AND (")).append(clause2);
+    query.append(QLatin1String(") "));
+}
+
+void QSqlRelationalTableModelPrivate::clearChanges()
+{
+    for (int i = 0; i < relations.count(); ++i) {
+        QRelation &rel = relations[i];
+        rel.clear();
+    }
+}
+
+void QSqlRelationalTableModelPrivate::revertCachedRow(int row)
+{
+    QSqlTableModelPrivate::revertCachedRow(row);
+}
+
+int QSqlRelationalTableModelPrivate::nameToIndex(const QString &name) const
+{
+    QString fieldname = name;
+    if (db.driver()->isIdentifierEscaped(fieldname, QSqlDriver::FieldName))
+        fieldname = db.driver()->stripDelimiters(fieldname, QSqlDriver::FieldName);
+    return baseRec.indexOf(fieldname);
+}
+
+void QSqlRelationalTableModelPrivate::clearEditBuffer()
+{
+    editBuffer = baseRec;
+    clearGenerated(editBuffer);
+}
+
+/*!
+    \reimp
+*/
+void QSqlRelationalTableModelPrivate::clearCache()
+{
+    for (int i = 0; i < relations.count(); ++i)
+        relations[i].clearDictionary();
+
+    QSqlTableModelPrivate::clearCache();
+}
+
+/*!
+    \class QSqlRelationalTableModel
+    \brief The QSqlRelationalTableModel class provides an editable
+    data model for a single database table, with foreign key support.
+
+    \ingroup database
+    \inmodule QtSql
+
+    QSqlRelationalTableModel acts like QSqlTableModel, but allows
+    columns to be set as foreign keys into other database tables.
+
+    \table
+    \row \o \inlineimage noforeignkeys.png
+         \o \inlineimage foreignkeys.png
+    \endtable
+
+    The screenshot on the left shows a plain QSqlTableModel in a
+    QTableView. Foreign keys (\c city and \c country) aren't resolved
+    to human-readable values. The screenshot on the right shows a
+    QSqlRelationalTableModel, with foreign keys resolved into
+    human-readable text strings.
+
+    The following code snippet shows how the QSqlRelationalTableModel
+    was set up:
+
+    \snippet examples/sql/relationaltablemodel/relationaltablemodel.cpp 0
+    \codeline
+    \snippet examples/sql/relationaltablemodel/relationaltablemodel.cpp 1
+    \snippet examples/sql/relationaltablemodel/relationaltablemodel.cpp 2
+
+    The setRelation() function calls establish a relationship between
+    two tables. The first call specifies that column 2 in table \c
+    employee is a foreign key that maps with field \c id of table \c
+    city, and that the view should present the \c{city}'s \c name
+    field to the user. The second call does something similar with
+    column 3.
+
+    If you use a read-write QSqlRelationalTableModel, you probably
+    want to use QSqlRelationalDelegate on the view. Unlike the default
+    delegate, QSqlRelationalDelegate provides a combobox for fields
+    that are foreign keys into other tables. To use the class, simply
+    call QAbstractItemView::setItemDelegate() on the view with an
+    instance of QSqlRelationalDelegate:
+
+    \snippet examples/sql/relationaltablemodel/relationaltablemodel.cpp 4
+
+    The \l{sql/relationaltablemodel} example illustrates how to use
+    QSqlRelationalTableModel in conjunction with
+    QSqlRelationalDelegate to provide tables with foreigh key
+    support.
+
+    \image relationaltable.png
+
+    Notes:
+
+    \list
+    \o The table must have a primary key declared.
+    \o The table's primary key may not contain a relation to
+       another table.
+    \o If a relational table contains keys that refer to non-existent
+       rows in the referenced table, the rows containing the invalid
+       keys will not be exposed through the model. The user or the
+       database is responsible for keeping referential integrity.
+    \o If a relation's display column name is also used as a column
+       name in the main table, or if it is used as display column
+       name in more than one relation it will be aliased. The alias is
+       is the relation's table name and display column name joined
+       by an underscore (e.g. tablename_columnname). All occurrences
+       of the duplicate display column name are aliased when
+       duplication is detected, but no aliasing is done to the column
+       names in the main table. The aliasing doesn't affect
+       QSqlRelation, so QSqlRelation::displayColumn() will return the
+       original display column name, but QSqlRecord::fieldName() will
+       return aliases.
+    \o When using setData() the role should always be Qt::EditRole,
+       and when using data() the role should always be Qt::DisplayRole.
+    \endlist
+
+    \sa QSqlRelation, QSqlRelationalDelegate,
+        {Relational Table Model Example}
+*/
+
+
+/*!
+    Creates an empty QSqlRelationalTableModel 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.
+*/
+QSqlRelationalTableModel::QSqlRelationalTableModel(QObject *parent, QSqlDatabase db)
+    : QSqlTableModel(*new QSqlRelationalTableModelPrivate, parent, db)
+{
+}
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+QSqlRelationalTableModel::~QSqlRelationalTableModel()
+{
+}
+
+/*!
+    \reimp
+*/
+QVariant QSqlRelationalTableModel::data(const QModelIndex &index, int role) const
+{
+    Q_D(const QSqlRelationalTableModel);
+
+    if (role == Qt::DisplayRole && index.column() > 0 && index.column() < d->relations.count() &&
+            d->relations.value(index.column()).isValid()) {
+        QRelation &relation = d->relations[index.column()];
+        if (!relation.isDictionaryInitialized())
+            relation.populateDictionary();
+
+        //only perform a dictionary lookup for the display value
+        //when the value at index has been changed or added.
+        //At an unmodified index, the underlying model will
+        //already have the correct display value.
+        QVariant v;
+        switch (d->strategy) {
+            case OnFieldChange:
+                break;
+            case OnRowChange:
+                if ((index.row() == d->editIndex || index.row() == d->insertIndex)
+                    && d->editBuffer.isGenerated(index.column()))
+                    v = d->editBuffer.value(index.column());
+                break;
+            case OnManualSubmit:
+                const QSqlTableModelPrivate::ModifiedRow row = d->cache.value(index.row());
+                if (row.op != QSqlTableModelPrivate::None && row.rec.isGenerated(index.column()))
+                    v = row.rec.value(index.column());
+                break;
+        }
+        if (v.isValid())
+            return relation.dictionary[v.toString()];
+    }
+    return QSqlTableModel::data(index, role);
+}
+
+/*!
+    Sets the data for the \a role in the item with the specified \a
+    index to the \a value given. Depending on the edit strategy, the
+    value might be applied to the database at once, or it may be
+    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).
+
+    For relational columns, \a value must be the index, not the
+    display value. The index must also exist in the referenced
+    table, otherwise the function returns false.
+
+    \sa editStrategy(), data(), submit(), revertRow()
+*/
+bool QSqlRelationalTableModel::setData(const QModelIndex &index, const QVariant &value,
+                                       int role)
+{
+    Q_D(QSqlRelationalTableModel);
+    if ( role == Qt::EditRole && index.column() > 0 && index.column() < d->relations.count()
+            && d->relations.value(index.column()).isValid()) {
+        QRelation &relation = d->relations[index.column()];
+        if (!relation.isDictionaryInitialized())
+            relation.populateDictionary();
+        if (!relation.dictionary.contains(value.toString()))
+            return false;
+    }
+    return QSqlTableModel::setData(index, value, role);
+}
+
+/*!
+    Lets the specified \a column be a foreign index specified by \a relation.
+
+    Example:
+
+    \snippet examples/sql/relationaltablemodel/relationaltablemodel.cpp 0
+    \codeline
+    \snippet examples/sql/relationaltablemodel/relationaltablemodel.cpp 1
+
+    The setRelation() call specifies that column 2 in table \c
+    employee is a foreign key that maps with field \c id of table \c
+    city, and that the view should present the \c{city}'s \c name
+    field to the user.
+
+    Note: The table's primary key may not contain a relation to another table.
+
+    \sa relation()
+*/
+void QSqlRelationalTableModel::setRelation(int column, const QSqlRelation &relation)
+{
+    Q_D(QSqlRelationalTableModel);
+    if (column < 0)
+        return;
+    if (d->relations.size() <= column)
+        d->relations.resize(column + 1);
+    d->relations[column].init(this, relation);
+}
+
+/*!
+    Returns the relation for the column \a column, or an invalid
+    relation if no relation is set.
+
+    \sa setRelation(), QSqlRelation::isValid()
+*/
+QSqlRelation QSqlRelationalTableModel::relation(int column) const
+{
+    Q_D(const QSqlRelationalTableModel);
+    return d->relations.value(column).rel;
+}
+
+QString QSqlRelationalTableModelPrivate::relationField(const QString &tableName,
+                        const QString &fieldName) const
+{
+    QString ret;
+    ret.reserve(tableName.size() + fieldName.size() + 1);
+    ret.append(tableName).append(QLatin1Char('.')).append(fieldName);
+
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+QString QSqlRelationalTableModel::selectStatement() const
+{
+    Q_D(const QSqlRelationalTableModel);
+    QString query;
+
+    if (tableName().isEmpty())
+        return query;
+    if (d->relations.isEmpty())
+        return QSqlTableModel::selectStatement();
+
+    QString tList;
+    QString fList;
+    QString where;
+
+    QSqlRecord rec = d->baseRec;
+    QStringList tables;
+    const QRelation nullRelation;
+
+    // Count how many times each field name occurs in the record
+    QHash<QString, int> fieldNames;
+    QStringList fieldList;
+    for (int i = 0; i < rec.count(); ++i) {
+        QSqlRelation relation = d->relations.value(i, nullRelation).rel;
+        QString name;
+        if (relation.isValid())
+        {
+            // Count the display column name, not the original foreign key
+            name = relation.displayColumn();
+            if (d->db.driver()->isIdentifierEscaped(name, QSqlDriver::FieldName))
+                name = d->db.driver()->stripDelimiters(name, QSqlDriver::FieldName);
+
+            QSqlRecord rec = database().record(relation.tableName());
+            for (int i = 0; i < rec.count(); ++i) {
+                if (name.compare(rec.fieldName(i), Qt::CaseInsensitive) == 0) {
+                    name = rec.fieldName(i);
+                    break;
+                }
+            }
+        }
+        else
+            name = rec.fieldName(i);
+        fieldNames.insert(name, fieldNames.value(name, 0) + 1);
+        fieldList.append(name);
+    }
+
+    for (int i = 0; i < rec.count(); ++i) {
+        QSqlRelation relation = d->relations.value(i, nullRelation).rel;
+        if (relation.isValid()) {
+            QString relTableAlias = QString::fromLatin1("relTblAl_%1").arg(i);
+            if (!fList.isEmpty())
+                fList.append(QLatin1String(", "));
+            fList.append(d->relationField(relTableAlias,relation.displayColumn()));
+
+            // If there are duplicate field names they must be aliased
+            if (fieldNames.value(fieldList[i]) > 1) {
+                QString relTableName = relation.tableName().section(QChar::fromLatin1('.'), -1, -1);
+                if (d->db.driver()->isIdentifierEscaped(relTableName, QSqlDriver::TableName))
+                    relTableName = d->db.driver()->stripDelimiters(relTableName, QSqlDriver::TableName);
+                QString displayColumn = relation.displayColumn();
+                if (d->db.driver()->isIdentifierEscaped(displayColumn, QSqlDriver::FieldName))
+                    displayColumn = d->db.driver()->stripDelimiters(displayColumn, QSqlDriver::FieldName);
+                fList.append(QString::fromLatin1(" AS %1_%2_%3").arg(relTableName).arg(displayColumn).arg(fieldNames.value(fieldList[i])));
+                fieldNames.insert(fieldList[i], fieldNames.value(fieldList[i])-1);
+            }
+
+            // this needs fixing!! the below if is borken.
+            tables.append(relation.tableName().append(QLatin1Char(' ')).append(relTableAlias));
+            if(!where.isEmpty())
+                where.append(QLatin1String(" AND "));
+            where.append(d->relationField(tableName(), d->db.driver()->escapeIdentifier(rec.fieldName(i), QSqlDriver::FieldName)));
+            where.append(QLatin1String(" = "));
+            where.append(d->relationField(relTableAlias, relation.indexColumn()));
+        } else {
+            if (!fList.isEmpty())
+                fList.append(QLatin1String(", "));
+            fList.append(d->relationField(tableName(), d->db.driver()->escapeIdentifier(rec.fieldName(i), QSqlDriver::FieldName)));
+        }
+    }
+    if (!tables.isEmpty())
+        tList.append(tables.join(QLatin1String(", ")));
+    if (fList.isEmpty())
+        return query;
+    if(!tList.isEmpty())
+        tList.prepend(QLatin1String(", "));
+    tList.prepend(tableName());
+    query.append(QLatin1String("SELECT "));
+    query.append(fList).append(QLatin1String(" FROM ")).append(tList);
+    qAppendWhereClause(query, where, filter());
+
+    QString orderBy = orderByClause();
+    if (!orderBy.isEmpty())
+        query.append(QLatin1Char(' ')).append(orderBy);
+
+    return query;
+}
+
+/*!
+    Returns a QSqlTableModel object for accessing the table for which
+    \a column is a foreign key, or 0 if there is no relation for the
+    given \a column.
+
+    The returned object is owned by the QSqlRelationalTableModel.
+
+    \sa setRelation(), relation()
+*/
+QSqlTableModel *QSqlRelationalTableModel::relationModel(int column) const
+{
+    Q_D(const QSqlRelationalTableModel);
+    if ( column < 0 || column >= d->relations.count())
+        return 0;
+
+    QRelation &relation = const_cast<QSqlRelationalTableModelPrivate *>(d)->relations[column];
+    if (!relation.isValid())
+        return 0;
+
+    if (!relation.model)
+        relation.populateModel();
+    return relation.model;
+}
+
+/*!
+    \reimp
+*/
+void QSqlRelationalTableModel::revertRow(int row)
+{
+    QSqlTableModel::revertRow(row);
+}
+
+/*!
+    \reimp
+*/
+void QSqlRelationalTableModel::clear()
+{
+    Q_D(QSqlRelationalTableModel);
+    d->clearChanges();
+    d->relations.clear();
+    QSqlTableModel::clear();
+}
+
+/*!
+    \reimp
+*/
+bool QSqlRelationalTableModel::select()
+{
+    return QSqlTableModel::select();
+}
+
+/*!
+    \reimp
+*/
+void QSqlRelationalTableModel::setTable(const QString &table)
+{
+    Q_D(QSqlRelationalTableModel);
+
+    // memorize the table before applying the relations
+    d->baseRec = d->db.record(table);
+
+    QSqlTableModel::setTable(table);
+}
+
+/*! \internal
+ */
+void QSqlRelationalTableModelPrivate::translateFieldNames(int row, QSqlRecord &values) const
+{
+    Q_Q(const QSqlRelationalTableModel);
+
+    for (int i = 0; i < values.count(); ++i) {
+        int realCol = q->indexInQuery(q->createIndex(row, i)).column();
+        if (realCol != -1 && relations.value(realCol).isValid()) {
+            QVariant v = values.value(i);
+            bool gen = values.isGenerated(i);
+            values.replace(i, baseRec.field(realCol));
+            values.setValue(i, v);
+            values.setGenerated(i, gen);
+        }
+    }
+}
+
+/*!
+    \reimp
+*/
+bool QSqlRelationalTableModel::updateRowInTable(int row, const QSqlRecord &values)
+{
+    Q_D(QSqlRelationalTableModel);
+
+    QSqlRecord rec = values;
+    d->translateFieldNames(row, rec);
+
+    return QSqlTableModel::updateRowInTable(row, rec);
+}
+
+/*!
+    \reimp
+*/
+bool QSqlRelationalTableModel::insertRowIntoTable(const QSqlRecord &values)
+{
+    Q_D(QSqlRelationalTableModel);
+
+    QSqlRecord rec = values;
+    d->translateFieldNames(0, rec);
+
+    return QSqlTableModel::insertRowIntoTable(rec);
+}
+
+/*!
+    \reimp
+*/
+QString QSqlRelationalTableModel::orderByClause() const
+{
+    Q_D(const QSqlRelationalTableModel);
+
+    const QSqlRelation rel = d->relations.value(d->sortColumn).rel;
+    if (!rel.isValid())
+        return QSqlTableModel::orderByClause();
+
+    QString s = QLatin1String("ORDER BY ");
+    s.append(d->relationField(QLatin1String("relTblAl_") + QString::number(d->sortColumn),
+                    rel.displayColumn()));
+    s += d->sortOrder == Qt::AscendingOrder ? QLatin1String(" ASC") : QLatin1String(" DESC");
+    return s;
+}
+
+/*!
+    \reimp
+*/
+bool QSqlRelationalTableModel::removeColumns(int column, int count, const QModelIndex &parent)
+{
+    Q_D(QSqlRelationalTableModel);
+
+    if (parent.isValid() || column < 0 || column + count > d->rec.count())
+        return false;
+
+    for (int i = 0; i < count; ++i) {
+        d->baseRec.remove(column);
+        if (d->relations.count() > column)
+            d->relations.remove(column);
+    }
+    return QSqlTableModel::removeColumns(column, count, parent);
+}
+
+QT_END_NAMESPACE
diff --git a/src/sql/models/qsqlrelationaltablemodel.h b/src/sql/models/qsqlrelationaltablemodel.h
new file mode 100644
index 0000000000..58384821a1
--- /dev/null
+++ b/src/sql/models/qsqlrelationaltablemodel.h
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#ifndef QSQLRELATIONALTABLEMODEL_H
+#define QSQLRELATIONALTABLEMODEL_H
+
+#include <QtSql/qsqltablemodel.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Sql)
+
+class Q_SQL_EXPORT QSqlRelation
+{
+public:
+    QSqlRelation() {}
+    QSqlRelation(const QString &aTableName, const QString &indexCol,
+               const QString &displayCol)
+        : tName(aTableName), iColumn(indexCol), dColumn(displayCol) {}
+    inline QString tableName() const
+    { return tName; }
+    inline QString indexColumn() const
+    { return iColumn; }
+    inline QString displayColumn() const
+    { return dColumn; }
+    inline bool isValid() const
+    { return !(tName.isEmpty() || iColumn.isEmpty() || dColumn.isEmpty()); }
+private:
+    QString tName, iColumn, dColumn;
+};
+
+class QSqlRelationalTableModelPrivate;
+
+class Q_SQL_EXPORT QSqlRelationalTableModel: public QSqlTableModel
+{
+    Q_OBJECT
+
+public:
+    explicit QSqlRelationalTableModel(QObject *parent = 0,
+                                      QSqlDatabase db = QSqlDatabase());
+    virtual ~QSqlRelationalTableModel();
+
+    QVariant data(const QModelIndex &item, int role = Qt::DisplayRole) const;
+    bool setData(const QModelIndex &item, const QVariant &value, int role = Qt::EditRole);
+    bool removeColumns(int column, int count, const QModelIndex &parent = QModelIndex());
+
+    void clear();
+    bool select();
+
+    void setTable(const QString &tableName);
+    virtual void setRelation(int column, const QSqlRelation &relation);
+    QSqlRelation relation(int column) const;
+    virtual QSqlTableModel *relationModel(int column) const;
+
+public Q_SLOTS:
+    void revertRow(int row);
+
+protected:
+    QString selectStatement() const;
+    bool updateRowInTable(int row, const QSqlRecord &values);
+    bool insertRowIntoTable(const QSqlRecord &values);
+    QString orderByClause() const;
+
+private:
+    Q_DECLARE_PRIVATE(QSqlRelationalTableModel)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSQLRELATIONALTABLEMODEL_H
diff --git a/src/sql/models/qsqltablemodel.cpp b/src/sql/models/qsqltablemodel.cpp
new file mode 100644
index 0000000000..99b516a05c
--- /dev/null
+++ b/src/sql/models/qsqltablemodel.cpp
@@ -0,0 +1,1366 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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;
+    clearGenerated(editBuffer);
+}
+
+void QSqlTableModelPrivate::clearCache()
+{
+    cache.clear();
+}
+
+void QSqlTableModelPrivate::clearGenerated(QSqlRecord &rec)
+{
+    for (int i = rec.count() - 1; i >= 0; i--)
+        rec.setGenerated(i, false);
+}
+
+void QSqlTableModelPrivate::setGeneratedValue(QSqlRecord &rec, int c, QVariant v)
+{
+    rec.setValue(c, v);
+    rec.setGenerated(c, true);
+}
+
+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))
+                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 21
+
+    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.
+
+    \note Calling select() will revert any unsubmitted changes and remove any inserted columns.
+
+    \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() || lastError().isValid()) {
+        // 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();
+
+    // Problem.. we need to use QSQM::indexInQuery to handle inserted columns
+    // but inserted rows we need to handle
+    // and indexInQuery is not virtual (grrr) so any values we pass to QSQM need
+    // to handle the insertedRows
+    QModelIndex item = indexInQuery(index);
+
+    switch (d->strategy) {
+    case OnFieldChange:
+    case OnRowChange:
+        if (index.row() == d->insertIndex) {
+            if (item.column() < 0 || item.column() >= d->rec.count())
+                return QVariant();
+            return d->editBuffer.value(index.column());
+        }
+        if (d->editIndex == item.row()) {
+            if (d->editBuffer.isGenerated(item.column()))
+                return d->editBuffer.value(item.column());
+        }
+        break;
+    case OnManualSubmit:
+        if (d->cache.contains(index.row())) {
+            const QSqlTableModelPrivate::ModifiedRow row = d->cache.value(index.row());
+            if (row.rec.isGenerated(item.column()) || row.op == QSqlTableModelPrivate::Insert)
+                return row.rec.value(item.column());
+        }
+        break;
+    }
+
+    // We need to handle row mapping here, but not column mapping
+    return QSqlQueryModel::data(index.sibling(item.row(), index.column()), 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.isGenerated(index.column());
+        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.isGenerated(index.column()));
+        }
+    }
+    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;
+
+    bool isOk = true;
+    switch (d->strategy) {
+    case OnFieldChange: {
+        if (index.row() == d->insertIndex) {
+            QSqlTableModelPrivate::setGeneratedValue(d->editBuffer, index.column(), value);
+            return true;
+        }
+        d->clearEditBuffer();
+        QSqlTableModelPrivate::setGeneratedValue(d->editBuffer, index.column(), value);
+        isOk = updateRowInTable(index.row(), d->editBuffer);
+        if (isOk)
+            select();
+        emit dataChanged(index, index);
+        break; }
+    case OnRowChange:
+        if (index.row() == d->insertIndex) {
+            QSqlTableModelPrivate::setGeneratedValue(d->editBuffer, index.column(), value);
+            return true;
+        }
+        if (d->editIndex != index.row()) {
+            if (d->editIndex != -1)
+                submit();
+            d->clearEditBuffer();
+        }
+        QSqlTableModelPrivate::setGeneratedValue(d->editBuffer, index.column(), value);
+        d->editIndex = index.row();
+        emit dataChanged(index, index);
+        break;
+    case OnManualSubmit: {
+        QSqlTableModelPrivate::ModifiedRow &row = d->cache[index.row()];
+        if (row.op == QSqlTableModelPrivate::None) {
+            row.op = QSqlTableModelPrivate::Update;
+            row.rec = d->rec;
+            QSqlTableModelPrivate::clearGenerated(row.rec);
+            row.primaryValues = d->primaryValues(indexInQuery(index).row());
+        }
+        QSqlTableModelPrivate::setGeneratedValue(row.rec, index.column(), value);
+        emit dataChanged(index, index);
+        break; }
+    }
+    return isOk;
+}
+
+/*!
+    This function simply calls QSqlQueryModel::setQuery(\a query).
+    You should normally not call it on a QSqlTableModel. Instead, use
+    setTable(), setSort(), setFilter(), etc., to set up the query.
+
+    \sa selectStatement()
+*/
+void QSqlTableModel::setQuery(const QSqlQuery &query)
+{
+    QSqlQueryModel::setQuery(query);
+}
+
+/*!
+    Updates the given \a row in the currently active database table
+    with the specified \a values. Returns true if successful; otherwise
+    returns false.
+
+    This is a low-level method that operates directly on the database
+    and should not be called directly. Use setData() to update values.
+    The model will decide depending on its edit strategy when to modify
+    the database.
+
+    Note that only values that have the generated-flag set are updated.
+    The generated-flag can be set with QSqlRecord::setGenerated() and
+    tested with QSqlRecord::isGenerated().
+
+    \sa QSqlRecord::isGenerated(), setData()
+*/
+bool QSqlTableModel::updateRowInTable(int row, const QSqlRecord &values)
+{
+    Q_D(QSqlTableModel);
+    QSqlRecord rec(values);
+    emit beforeUpdate(row, rec);
+
+    const QSqlRecord whereValues = d->strategy == OnManualSubmit ? d->cache[row].primaryValues : d->primaryValues(row);
+    bool prepStatement = d->db.driver()->hasFeature(QSqlDriver::PreparedQueries);
+    QString stmt = d->db.driver()->sqlStatement(QSqlDriver::UpdateStatement, d->tableName,
+                                                rec, prepStatement);
+    QString where = d->db.driver()->sqlStatement(QSqlDriver::WhereStatement, d->tableName,
+                                                 whereValues, prepStatement);
+
+    if (stmt.isEmpty() || where.isEmpty() || row < 0 || row >= rowCount()) {
+        d->error = QSqlError(QLatin1String("No Fields to update"), QString(),
+                                 QSqlError::StatementError);
+        return false;
+    }
+    stmt.append(QLatin1Char(' ')).append(where);
+
+    return d->exec(stmt, prepStatement, rec, whereValues);
+}
+
+
+/*!
+    Inserts the values \a values into the currently active database table.
+
+    This is a low-level method that operates directly on the database
+    and should not be called directly. Use insertRow() and setData()
+    to insert values. The model will decide depending on its edit strategy
+    when to modify the database.
+
+    Returns true if the values could be inserted, otherwise false.
+    Error information can be retrieved with \l lastError().
+
+    \sa lastError(), insertRow(), insertRows()
+*/
+bool QSqlTableModel::insertRowIntoTable(const QSqlRecord &values)
+{
+    Q_D(QSqlTableModel);
+    QSqlRecord rec = values;
+    emit beforeInsert(rec);
+
+    bool prepStatement = d->db.driver()->hasFeature(QSqlDriver::PreparedQueries);
+    QString stmt = d->db.driver()->sqlStatement(QSqlDriver::InsertStatement, d->tableName,
+                                                rec, prepStatement);
+
+    if (stmt.isEmpty()) {
+        d->error = QSqlError(QLatin1String("No Fields to update"), QString(),
+                                 QSqlError::StatementError);
+        return false;
+    }
+
+    return d->exec(stmt, prepStatement, rec, QSqlRecord() /* no where values */);
+}
+
+/*!
+    Deletes the given \a row from the currently active database table.
+
+    This is a low-level method that operates directly on the database
+    and should not be called directly. Use removeRow() or removeRows()
+    to delete values. The model will decide depending on its edit strategy
+    when to modify the database.
+
+    Returns true if the row was deleted; otherwise returns false.
+
+    \sa removeRow(), removeRows()
+*/
+bool QSqlTableModel::deleteRowFromTable(int row)
+{
+    Q_D(QSqlTableModel);
+    emit beforeDelete(row);
+
+    const QSqlRecord whereValues = d->strategy == OnManualSubmit ? d->cache[row].primaryValues : d->primaryValues(row);
+    bool prepStatement = d->db.driver()->hasFeature(QSqlDriver::PreparedQueries);
+    QString stmt = d->db.driver()->sqlStatement(QSqlDriver::DeleteStatement,
+                                                d->tableName,
+                                                QSqlRecord(),
+                                                prepStatement);
+    QString where = d->db.driver()->sqlStatement(QSqlDriver::WhereStatement,
+                                                 d->tableName,
+                                                 whereValues,
+                                                 prepStatement);
+
+    if (stmt.isEmpty() || where.isEmpty()) {
+        d->error = QSqlError(QLatin1String("Unable to delete row"), QString(),
+                             QSqlError::StatementError);
+        return false;
+    }
+    stmt.append(QLatin1Char(' ')).append(where);
+
+    return d->exec(stmt, prepStatement, QSqlRecord() /* no new values */, whereValues);
+}
+
+/*!
+    Submits all pending changes and returns true on success.
+    Returns false on error, detailed error information can be
+    obtained with lastError().
+
+    On success the model will be repopulated. Any views 
+    presenting it will lose their selections.
+
+    Note: In OnManualSubmit mode, already submitted changes won't
+    be cleared from the cache when submitAll() fails. This allows
+    transactions to be rolled back and resubmitted again without
+    losing data.
+
+    \sa revertAll(), lastError()
+*/
+bool QSqlTableModel::submitAll()
+{
+    Q_D(QSqlTableModel);
+
+    switch (d->strategy) {
+    case OnFieldChange:
+        if (d->insertIndex == -1)
+            return true;
+        // else fall through
+    case OnRowChange:
+        if (d->editBuffer.isEmpty())
+            return true;
+        if (d->insertIndex != -1) {
+            if (!insertRowIntoTable(d->editBuffer))
+                return false;
+            d->bottom = d->bottom.sibling(d->bottom.row() + 1, d->bottom.column());
+        } else {
+            if (!updateRowInTable(d->editIndex, d->editBuffer))
+                return false;
+        }
+        d->clearEditBuffer();
+        d->editIndex = -1;
+        d->insertIndex = -1;
+        return select();
+    case OnManualSubmit:
+        for (QSqlTableModelPrivate::CacheMap::ConstIterator it = d->cache.constBegin();
+             it != d->cache.constEnd(); ++it) {
+            switch (it.value().op) {
+            case QSqlTableModelPrivate::Insert:
+                if (!insertRowIntoTable(it.value().rec))
+                    return false;
+                d->bottom = d->bottom.sibling(d->bottom.row() + 1, d->bottom.column());
+                break;
+            case QSqlTableModelPrivate::Update:
+                if (!updateRowInTable(it.key(), it.value().rec))
+                    return false;
+                break;
+            case QSqlTableModelPrivate::Delete:
+                if (!deleteRowFromTable(it.key()))
+                    return false;
+                break;
+            case QSqlTableModelPrivate::None:
+                Q_ASSERT_X(false, "QSqlTableModel::submitAll()", "Invalid cache operation");
+                break;
+            }
+        }
+        d->clearCache();
+        return select();
+    }
+    return false;
+}
+
+/*!
+    This reimplemented slot is called by the item delegates when the
+    user stopped editing the current row.
+
+    Submits the currently edited row if the model's strategy is set
+    to OnRowChange or OnFieldChange. Does nothing for the OnManualSubmit
+    strategy.
+
+    Use submitAll() to submit all pending changes for the
+    OnManualSubmit strategy.
+
+    Returns true on success; otherwise returns false. Use lastError()
+    to query detailed error information.
+
+    On success the model will be repopulated. Any views 
+    presenting it will lose their selections.
+
+    \sa revert(), revertRow(), submitAll(), revertAll(), lastError()
+*/
+bool QSqlTableModel::submit()
+{
+    Q_D(QSqlTableModel);
+    if (d->strategy == OnRowChange || d->strategy == OnFieldChange)
+        return submitAll();
+    return true;
+}
+
+/*!
+    This reimplemented slot is called by the item delegates when the
+    user canceled editing the current row.
+
+    Reverts the changes if the model's strategy is set to
+    OnRowChange. Does nothing for the other edit strategies.
+
+    Use revertAll() to revert all pending changes for the
+    OnManualSubmit strategy or revertRow() to revert a specific row.
+
+    \sa submit(), submitAll(), revertRow(), revertAll()
+*/
+void QSqlTableModel::revert()
+{
+    Q_D(QSqlTableModel);
+    if (d->strategy == OnRowChange)
+        revertAll();
+}
+
+/*!
+    \enum QSqlTableModel::EditStrategy
+
+    This enum type describes which strategy to choose when editing values in the database.
+
+    \value OnFieldChange  All changes to the model will be applied immediately to the database.
+    \value OnRowChange  Changes to a row will be applied when the user selects a different row.
+    \value OnManualSubmit  All changes will be cached in the model until either submitAll()
+                           or revertAll() is called.
+
+    Note: To prevent inserting only partly initialized rows into the database,
+    \c OnFieldChange will behave like \c OnRowChange for newly inserted rows.
+
+    \sa setEditStrategy()
+*/
+
+
+/*!
+    Sets the strategy for editing values in the database to \a
+    strategy.
+
+    This will revert any pending changes.
+
+    \sa editStrategy(), revertAll()
+*/
+void QSqlTableModel::setEditStrategy(EditStrategy strategy)
+{
+    Q_D(QSqlTableModel);
+    revertAll();
+    d->strategy = strategy;
+}
+
+/*!
+    Returns the current edit strategy.
+
+    \sa setEditStrategy()
+*/
+QSqlTableModel::EditStrategy QSqlTableModel::editStrategy() const
+{
+    Q_D(const QSqlTableModel);
+    return d->strategy;
+}
+
+/*!
+    Reverts all pending changes.
+
+    \sa revert(), revertRow(), submitAll()
+*/
+void QSqlTableModel::revertAll()
+{
+    Q_D(QSqlTableModel);
+    switch (d->strategy) {
+    case OnFieldChange:
+        break;
+    case OnRowChange:
+        if (d->editIndex != -1)
+            revertRow(d->editIndex);
+        else if (d->insertIndex != -1)
+            revertRow(d->insertIndex);
+        break;
+    case OnManualSubmit:
+        while (!d->cache.isEmpty())
+            revertRow(d->cache.constBegin().key());
+        break;
+    }
+}
+
+/*!
+    Reverts all changes for the specified \a row.
+
+    \sa revert(), revertAll(), submit(), submitAll()
+*/
+void QSqlTableModel::revertRow(int row)
+{
+    if (row < 0)
+        return;
+
+    Q_D(QSqlTableModel);
+    switch (d->strategy) {
+    case OnFieldChange:
+        break;
+    case OnRowChange: {
+        if (d->editIndex == row) {
+            d->editBuffer.clear();
+            int oldIndex = d->editIndex;
+            d->editIndex = -1;
+            emit dataChanged(createIndex(oldIndex, 0), createIndex(oldIndex, columnCount()));
+        } else if (d->insertIndex == row) {
+            d->revertInsertedRow();
+        }
+        break; }
+    case OnManualSubmit:
+        d->revertCachedRow(row);
+        break;
+    }
+}
+
+/*!
+    Returns the primary key for the current table, or an empty
+    QSqlIndex if the table is not set or has no primary key.
+
+    \sa setTable(), setPrimaryKey(), QSqlDatabase::primaryIndex()
+*/
+QSqlIndex QSqlTableModel::primaryKey() const
+{
+    Q_D(const QSqlTableModel);
+    return d->primaryIndex;
+}
+
+/*!
+    Protected method that allows subclasses to set the primary key to
+    \a key.
+
+    Normally, the primary index is set automatically whenever you
+    call setTable().
+
+    \sa primaryKey(), QSqlDatabase::primaryIndex()
+*/
+void QSqlTableModel::setPrimaryKey(const QSqlIndex &key)
+{
+    Q_D(QSqlTableModel);
+    d->primaryIndex = key;
+}
+
+/*!
+    Returns a pointer to the used QSqlDatabase or 0 if no database was set.
+*/
+QSqlDatabase QSqlTableModel::database() const
+{
+    Q_D(const QSqlTableModel);
+     return d->db;
+}
+
+/*!
+    Sorts the data by \a column with the sort order \a order.
+    This will immediately select data, use setSort()
+    to set a sort order without populating the model with data.
+
+    \sa setSort(), select(), orderByClause()
+*/
+void QSqlTableModel::sort(int column, Qt::SortOrder order)
+{
+    setSort(column, order);
+    select();
+}
+
+/*!
+    Sets the sort order for \a column to \a order. This does not
+    affect the current data, to refresh the data using the new
+    sort order, call select().
+
+    \sa select(), orderByClause()
+*/
+void QSqlTableModel::setSort(int column, Qt::SortOrder order)
+{
+    Q_D(QSqlTableModel);
+    d->sortColumn = column;
+    d->sortOrder = order;
+}
+
+/*!
+    Returns an SQL \c{ORDER BY} clause based on the currently set
+    sort order.
+
+    \sa setSort(), selectStatement()
+*/
+QString QSqlTableModel::orderByClause() const
+{
+    Q_D(const QSqlTableModel);
+    QString s;
+    QSqlField f = d->rec.field(d->sortColumn);
+    if (!f.isValid())
+        return s;
+        
+    QString table = d->tableName;
+    //we can safely escape the field because it would have been obtained from the database
+    //and have the correct case
+    QString field = d->db.driver()->escapeIdentifier(f.name(), QSqlDriver::FieldName);
+    s.append(QLatin1String("ORDER BY ")).append(table).append(QLatin1Char('.')).append(field);
+    s += d->sortOrder == Qt::AscendingOrder ? QLatin1String(" ASC") : QLatin1String(" DESC");
+
+    return s;
+}
+
+/*!
+    Returns the index of the field \a fieldName.
+*/
+int QSqlTableModel::fieldIndex(const QString &fieldName) const
+{
+    Q_D(const QSqlTableModel);
+    return d->rec.indexOf(fieldName);
+}
+
+/*!
+    Returns the SQL \c SELECT statement used internally to populate
+    the model. The statement includes the filter and the \c{ORDER BY}
+    clause.
+
+    \sa filter(), orderByClause()
+*/
+QString QSqlTableModel::selectStatement() const
+{
+    Q_D(const QSqlTableModel);
+    QString query;
+    if (d->tableName.isEmpty()) {
+        d->error = QSqlError(QLatin1String("No table name given"), QString(),
+                             QSqlError::StatementError);
+        return query;
+    }
+    if (d->rec.isEmpty()) {
+        d->error = QSqlError(QLatin1String("Unable to find table ") + d->tableName, QString(),
+                             QSqlError::StatementError);
+        return query;
+    }
+
+    query = d->db.driver()->sqlStatement(QSqlDriver::SelectStatement,
+                                         d->tableName,
+                                         d->rec,
+                                         false);
+    if (query.isEmpty()) {
+        d->error = QSqlError(QLatin1String("Unable to select fields from table ") + d->tableName,
+                             QString(), QSqlError::StatementError);
+        return query;
+    }
+    if (!d->filter.isEmpty())
+        query.append(QLatin1String(" WHERE ")).append(d->filter);
+    QString orderBy(orderByClause());
+    if (!orderBy.isEmpty())
+        query.append(QLatin1Char(' ')).append(orderBy);
+
+    return query;
+}
+
+/*!
+    Removes \a count columns from the \a parent model, starting at
+    index \a column.
+
+    Returns if the columns were successfully removed; otherwise
+    returns false.
+
+    \sa removeRows()
+*/
+bool QSqlTableModel::removeColumns(int column, int count, const QModelIndex &parent)
+{
+    Q_D(QSqlTableModel);
+    if (parent.isValid() || column < 0 || column + count > d->rec.count())
+        return false;
+    for (int i = 0; i < count; ++i)
+        d->rec.remove(column);
+    if (d->query.isActive())
+        return select();
+    return true;
+}
+
+/*!
+    Removes \a count rows starting at \a row. Since this model
+    does not support hierarchical structures, \a parent must be
+    an invalid model index.
+
+    Emits the beforeDelete() signal before a row is deleted. When
+    the edit strategy is OnManualSubmit signal emission is delayed
+    until submitAll() is called.
+
+    Returns true if all rows could be removed; otherwise returns
+    false. Detailed error information can be retrieved using
+    lastError().
+
+    \sa removeColumns(), insertRows()
+*/
+bool QSqlTableModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    Q_D(QSqlTableModel);
+    if (parent.isValid() || row < 0 || count <= 0)
+        return false;
+
+    int i;
+    switch (d->strategy) {
+    case OnFieldChange:
+    case OnRowChange:
+        for (i = 0; i < count; ++i) {
+            if (row + i == d->insertIndex)
+                d->revertInsertedRow();
+            else if (!deleteRowFromTable(row + i))
+                return false;
+        }
+        select();
+        break;
+    case OnManualSubmit:
+        for (i = 0; i < count; ++i) {
+            int idx = row + i;
+            if (idx >= rowCount())
+                return false;
+            if (d->cache.value(idx).op == QSqlTableModelPrivate::Insert) {
+                revertRow(idx);
+                // Reverting a row means all the other cache entries have been adjusted downwards
+                // so fake this by adjusting row
+                --row;
+            } else {
+                d->cache[idx].op = QSqlTableModelPrivate::Delete;
+                d->cache[idx].primaryValues = d->primaryValues(indexInQuery(createIndex(idx, 0)).row());
+                emit headerDataChanged(Qt::Vertical, idx, idx);
+            }
+        }
+        break;
+    }
+    return true;
+}
+
+/*!
+    Inserts \a count empty rows at position \a row. Note that \a
+    parent must be invalid, since this model does not support
+    parent-child relations.
+
+    Only one row at a time can be inserted when using the
+    OnFieldChange or OnRowChange update strategies.
+
+    The primeInsert() signal will be emitted for each new row.
+    Connect to it if you want to initialize the new row with default
+    values.
+
+    Returns false if the parameters are out of bounds; otherwise
+    returns true.
+
+    \sa primeInsert(), insertRecord()
+*/
+bool QSqlTableModel::insertRows(int row, int count, const QModelIndex &parent)
+{
+    Q_D(QSqlTableModel);
+    if (row < 0 || count <= 0 || row > rowCount() || parent.isValid())
+        return false;
+
+    switch (d->strategy) {
+    case OnFieldChange:
+    case OnRowChange:
+        if (count != 1)
+            return false;
+        beginInsertRows(parent, row, row);
+        d->insertIndex = row;
+        // ### apply dangling changes...
+        d->clearEditBuffer();
+        emit primeInsert(row, d->editBuffer);
+        break;
+    case OnManualSubmit:
+        beginInsertRows(parent, row, row + count - 1);
+        if (!d->cache.isEmpty()) {
+            QMap<int, QSqlTableModelPrivate::ModifiedRow>::Iterator it = d->cache.end();
+            while (it != d->cache.begin() && (--it).key() >= row) {
+                int oldKey = it.key();
+                const QSqlTableModelPrivate::ModifiedRow oldValue = it.value();
+                d->cache.erase(it);
+                it = d->cache.insert(oldKey + count, oldValue);
+            }
+        }
+
+        for (int i = 0; i < count; ++i) {
+            d->cache[row + i] = QSqlTableModelPrivate::ModifiedRow(QSqlTableModelPrivate::Insert,
+                                                                   d->rec);
+            emit primeInsert(row + i, d->cache[row + i].rec);
+        }
+        break;
+    }
+    endInsertRows();
+    return true;
+}
+
+/*!
+    Inserts the \a record after \a row. If \a row is negative, the
+    record will be appended to the end. Calls insertRows() and
+    setRecord() internally.
+
+    Returns true if the row could be inserted, otherwise false.
+
+    \sa insertRows(), removeRows()
+*/
+bool QSqlTableModel::insertRecord(int row, const QSqlRecord &record)
+{
+    Q_D(QSqlTableModel);
+    if (row < 0)
+        row = rowCount();
+    if (!insertRow(row, QModelIndex()))
+        return false;
+    if (!setRecord(row, record))
+        return false;
+    if (d->strategy == OnFieldChange || d->strategy == OnRowChange)
+        return submit();
+    return true;
+}
+
+/*! \reimp
+*/
+int QSqlTableModel::rowCount(const QModelIndex &parent) const
+{
+    Q_D(const QSqlTableModel);
+
+    if (parent.isValid())
+        return 0;
+
+    int rc = QSqlQueryModel::rowCount();
+    if (d->strategy == OnManualSubmit) {
+        for (QSqlTableModelPrivate::CacheMap::ConstIterator it = d->cache.constBegin();
+             it != d->cache.constEnd(); ++it) {
+             if (it.value().op == QSqlTableModelPrivate::Insert)
+                 ++rc;
+        }
+    } else if (d->insertIndex >= 0) {
+        ++rc;
+    }
+    return rc;
+}
+
+/*!
+    Returns the index of the value in the database result set for the
+    given \a item in the model.
+
+    The return value is identical to \a item if no columns or rows
+    have been inserted, removed, or moved around.
+
+    Returns an invalid model index if \a item is out of bounds or if
+    \a item does not point to a value in the result set.
+
+    \sa QSqlQueryModel::indexInQuery()
+*/
+QModelIndex QSqlTableModel::indexInQuery(const QModelIndex &item) const
+{
+    Q_D(const QSqlTableModel);
+    const QModelIndex it = QSqlQueryModel::indexInQuery(item); // this adjusts columns only
+    if (d->strategy == OnManualSubmit) {
+        int rowOffset = 0;
+        QSqlTableModelPrivate::CacheMap::ConstIterator i = d->cache.constBegin();
+        while (i != d->cache.constEnd() && i.key() <= it.row()) {
+            if (i.value().op == QSqlTableModelPrivate::Insert)
+                ++rowOffset;
+            ++i;
+        }
+        return createIndex(it.row() - rowOffset, it.column(), it.internalPointer());
+    } else {
+        if (d->insertIndex >= 0 && it.row() >= d->insertIndex)
+            return createIndex(it.row() - 1, it.column(), it.internalPointer());
+    }
+    return it;
+}
+
+/*!
+    Returns the currently set filter.
+
+    \sa setFilter(), select()
+*/
+QString QSqlTableModel::filter() const
+{
+    Q_D(const QSqlTableModel);
+    return d->filter;
+}
+
+/*!
+    Sets the current filter to \a filter.
+
+    The filter is a SQL \c WHERE clause without the keyword \c WHERE
+    (for example, \c{name='Josephine')}.
+
+    If the model is already populated with data from a database,
+    the model re-selects it with the new filter. Otherwise, the filter
+    will be applied the next time select() is called.
+
+    \sa filter(), select(), selectStatement(), orderByClause()
+*/
+void QSqlTableModel::setFilter(const QString &filter)
+{
+    Q_D(QSqlTableModel);
+    d->filter = filter;
+    if (d->query.isActive())
+        select();
+}
+
+/*! \reimp
+*/
+void QSqlTableModel::clear()
+{
+    Q_D(QSqlTableModel);
+    d->clear();
+    QSqlQueryModel::clear();
+}
+
+/*! \reimp
+*/
+Qt::ItemFlags QSqlTableModel::flags(const QModelIndex &index) const
+{
+    Q_D(const QSqlTableModel);
+    if (index.internalPointer() || index.column() < 0 || index.column() >= d->rec.count()
+        || index.row() < 0)
+        return 0;
+    if (d->rec.field(index.column()).isReadOnly())
+        return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
+    return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
+}
+
+/*!
+    Sets the values at the specified \a row to the values of \a
+    record. Returns true if all the values could be set; otherwise
+    returns false.
+
+    \sa record()
+*/
+bool QSqlTableModel::setRecord(int row, const QSqlRecord &record)
+{
+    Q_D(QSqlTableModel);
+    Q_ASSERT_X(row >= 0, "QSqlTableModel::setRecord()", "Cannot set a record to a row less than 0");
+    if (row >= rowCount())
+        return false;
+
+    bool isOk = true;
+    switch (d->strategy) {
+    case OnFieldChange:
+    case OnRowChange:
+        return d->setRecord(row, record);
+    case OnManualSubmit: {
+        QSqlTableModelPrivate::ModifiedRow &mrow = d->cache[row];
+        if (mrow.op == QSqlTableModelPrivate::None) {
+            mrow.op = QSqlTableModelPrivate::Update;
+            mrow.rec = d->rec;
+            QSqlTableModelPrivate::clearGenerated(mrow.rec);
+            mrow.primaryValues = d->primaryValues(indexInQuery(createIndex(row, 0)).row());
+        }
+        QString fieldName;
+        for (int i = 0; i < record.count(); ++i) {
+            fieldName = record.fieldName(i);
+            if (d->db.driver()->isIdentifierEscaped(fieldName, QSqlDriver::FieldName))
+                fieldName = d->db.driver()->stripDelimiters(fieldName, QSqlDriver::FieldName);
+            int idx = mrow.rec.indexOf(fieldName);
+            if (idx == -1) {
+                isOk = false;
+            } else {
+                QSqlTableModelPrivate::setGeneratedValue(mrow.rec, idx, record.value(i));
+            }
+        }
+
+        if (isOk)
+            emit dataChanged(createIndex(row, 0), createIndex(row, columnCount() - 1));
+        return isOk; }
+    }
+    return false;
+}
+
+QT_END_NAMESPACE
diff --git a/src/sql/models/qsqltablemodel.h b/src/sql/models/qsqltablemodel.h
new file mode 100644
index 0000000000..6c3e35a137
--- /dev/null
+++ b/src/sql/models/qsqltablemodel.h
@@ -0,0 +1,141 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#ifndef QSQLTABLEMODEL_H
+#define QSQLTABLEMODEL_H
+
+#include <QtSql/qsqldatabase.h>
+#include <QtSql/qsqlquerymodel.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Sql)
+
+class QSqlTableModelPrivate;
+class QSqlRecord;
+class QSqlField;
+class QSqlIndex;
+
+class Q_SQL_EXPORT QSqlTableModel: public QSqlQueryModel
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QSqlTableModel)
+
+public:
+    enum EditStrategy {OnFieldChange, OnRowChange, OnManualSubmit};
+
+    explicit QSqlTableModel(QObject *parent = 0, QSqlDatabase db = QSqlDatabase());
+    virtual ~QSqlTableModel();
+
+    virtual bool select();
+
+    virtual void setTable(const QString &tableName);
+    QString tableName() const;
+
+    Qt::ItemFlags flags(const QModelIndex &index) const;
+
+    QVariant data(const QModelIndex &idx, int role = Qt::DisplayRole) const;
+    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
+
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+
+    bool isDirty(const QModelIndex &index) const;
+    void clear();
+
+    virtual void setEditStrategy(EditStrategy strategy);
+    EditStrategy editStrategy() const;
+
+    QSqlIndex primaryKey() const;
+    QSqlDatabase database() const;
+    int fieldIndex(const QString &fieldName) const;
+
+    void sort(int column, Qt::SortOrder order);
+    virtual void setSort(int column, Qt::SortOrder order);
+
+    QString filter() const;
+    virtual void setFilter(const QString &filter);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+
+    bool removeColumns(int column, int count, const QModelIndex &parent = QModelIndex());
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+    bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex());
+
+    bool insertRecord(int row, const QSqlRecord &record);
+    bool setRecord(int row, const QSqlRecord &record);
+
+    virtual void revertRow(int row);
+
+public Q_SLOTS:
+    bool submit();
+    void revert();
+
+    bool submitAll();
+    void revertAll();
+
+Q_SIGNALS:
+    void primeInsert(int row, QSqlRecord &record);
+
+    void beforeInsert(QSqlRecord &record);
+    void beforeUpdate(int row, QSqlRecord &record);
+    void beforeDelete(int row);
+
+protected:
+    QSqlTableModel(QSqlTableModelPrivate &dd, QObject *parent = 0, QSqlDatabase db = QSqlDatabase());
+
+    virtual bool updateRowInTable(int row, const QSqlRecord &values);
+    virtual bool insertRowIntoTable(const QSqlRecord &values);
+    virtual bool deleteRowFromTable(int row);
+    virtual QString orderByClause() const;
+    virtual QString selectStatement() const;
+
+    void setPrimaryKey(const QSqlIndex &key);
+    void setQuery(const QSqlQuery &query);
+    QModelIndex indexInQuery(const QModelIndex &item) const;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSQLTABLEMODEL_H
diff --git a/src/sql/models/qsqltablemodel_p.h b/src/sql/models/qsqltablemodel_p.h
new file mode 100644
index 0000000000..322c23b67d
--- /dev/null
+++ b/src/sql/models/qsqltablemodel_p.h
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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$
+**
+****************************************************************************/
+
+#ifndef QSQLTABLEMODEL_P_H
+#define QSQLTABLEMODEL_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of qsql*model.h .  This header file may change from version to version
+// without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qmap.h"
+#include "private/qsqlquerymodel_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QSqlTableModelPrivate: public QSqlQueryModelPrivate
+{
+    Q_DECLARE_PUBLIC(QSqlTableModel)
+
+public:
+    QSqlTableModelPrivate()
+        : editIndex(-1), insertIndex(-1), sortColumn(-1),
+          sortOrder(Qt::AscendingOrder),
+          strategy(QSqlTableModel::OnRowChange)
+    {}
+    void clear();
+    QSqlRecord primaryValues(int index);
+    virtual void clearEditBuffer();
+    virtual void clearCache();
+    static void clearGenerated(QSqlRecord &rec);
+    static void setGeneratedValue(QSqlRecord &rec, int c, QVariant v);
+    QSqlRecord record(const QVector<QVariant> &values) const;
+
+    bool exec(const QString &stmt, bool prepStatement,
+              const QSqlRecord &rec, const QSqlRecord &whereValues);
+    virtual void revertCachedRow(int row);
+    void revertInsertedRow();
+    bool setRecord(int row, const QSqlRecord &record);
+    virtual int nameToIndex(const QString &name) const;
+    void initRecordAndPrimaryIndex();
+
+    QSqlDatabase db;
+    int editIndex;
+    int insertIndex;
+
+    int sortColumn;
+    Qt::SortOrder sortOrder;
+
+    QSqlTableModel::EditStrategy strategy;
+
+    QSqlQuery editQuery;
+    QSqlIndex primaryIndex;
+    QString tableName;
+    QString filter;
+
+    enum Op { None, Insert, Update, Delete };
+
+    struct ModifiedRow
+    {
+        ModifiedRow(Op o = None, const QSqlRecord &r = QSqlRecord()): op(o), rec(r) { clearGenerated(rec);}
+        ModifiedRow(const ModifiedRow &other): op(other.op), rec(other.rec), primaryValues(other.primaryValues) {}
+        Op op;
+        QSqlRecord rec;
+		QSqlRecord primaryValues;
+    };
+
+    QSqlRecord editBuffer;
+
+    typedef QMap<int, ModifiedRow> CacheMap;
+    CacheMap cache;
+};
+
+QT_END_NAMESPACE
+
+#endif // QSQLTABLEMODEL_P_H