Moved sql autotests into new directory structure

Task-number: QTBUG-21253

Change-Id: Id20605e1247b080e775968b56ea5f56462ca4c71
Reviewed-on: http://codereview.qt.nokia.com/4127
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Jason McDonald <jason.mcdonald@nokia.com>

37 files changed, 11910 insertions, 0 deletions

diff --git a/tests/auto/sql/kernel/kernel.pro b/tests/auto/sql/kernel/kernel.pro
new file mode 100644
index 0000000000..579c31a01f
--- /dev/null
+++ b/tests/auto/sql/kernel/kernel.pro
@@ -0,0 +1,11 @@
+TEMPLATE=subdirs
+SUBDIRS=\
+   qsqlfield \
+   qsqldatabase \
+   qsqlerror \
+   qsqldriver \
+   qsqlquery \
+   qsqlrecord \
+   qsqlthread \
+   qsql \
+
diff --git a/tests/auto/sql/kernel/qsql/.gitignore b/tests/auto/sql/kernel/qsql/.gitignore
new file mode 100644
index 0000000000..b1e335be74
--- /dev/null
+++ b/tests/auto/sql/kernel/qsql/.gitignore
@@ -0,0 +1 @@
+tst_qsql
diff --git a/tests/auto/sql/kernel/qsql/qsql.pro b/tests/auto/sql/kernel/qsql/qsql.pro
new file mode 100644
index 0000000000..3357e762dc
--- /dev/null
+++ b/tests/auto/sql/kernel/qsql/qsql.pro
@@ -0,0 +1,18 @@
+load(qttest_p4)
+SOURCES  += tst_qsql.cpp
+
+QT += sql sql-private gui widgets
+
+wince*: {
+   DEPLOYMENT_PLUGIN += qsqlite
+}
+
+symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+}
diff --git a/tests/auto/sql/kernel/qsql/tst_qsql.cpp b/tests/auto/sql/kernel/qsql/tst_qsql.cpp
new file mode 100644
index 0000000000..453eb44daa
--- /dev/null
+++ b/tests/auto/sql/kernel/qsql/tst_qsql.cpp
@@ -0,0 +1,277 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <qguiapplication.h>
+#include <qsqldatabase.h>
+#include <qsqlerror.h>
+#include <qsqlquery.h>
+#include <qsqlrecord.h>
+#include <qsql.h>
+#include <qsqlresult.h>
+#include <qsqldriver.h>
+#include <qdebug.h>
+#include <private/qsqlnulldriver_p.h>
+
+#include "../qsqldatabase/tst_databases.h"
+
+//TESTED_FILES=
+
+class tst_QSql : public QObject
+{
+Q_OBJECT
+
+public:
+    tst_QSql();
+    virtual ~tst_QSql();
+
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+private slots:
+    void open();
+    void openInvalid();
+    void registerSqlDriver();
+
+    // problem specific tests
+    void openErrorRecovery();
+    void concurrentAccess();
+    void basicDriverTest();
+};
+
+/****************** General Qt SQL Module tests *****************/
+
+tst_QSql::tst_QSql()
+{
+}
+
+tst_QSql::~tst_QSql()
+{
+}
+
+void tst_QSql::initTestCase()
+{
+}
+
+void tst_QSql::cleanupTestCase()
+{
+}
+
+void tst_QSql::init()
+{
+}
+
+void tst_QSql::cleanup()
+{
+}
+
+
+// this is a very basic test for drivers that cannot create/delete tables
+// it can be used while developing new drivers,
+// it's original purpose is to test ODBC Text datasources that are basically
+// to stupid to do anything more advanced than SELECT/INSERT/UPDATE/DELETE
+// the datasource has to have a table called "qtest_basictest" consisting
+// of a field "id"(integer) and "name"(char/varchar).
+void tst_QSql::basicDriverTest()
+{
+    int argc = 0;
+    QGuiApplication app( argc, 0, false );
+    tst_Databases dbs;
+    dbs.open();
+
+    foreach( const QString& dbName, dbs.dbNames )
+    {
+        QSqlDatabase db = QSqlDatabase::database( dbName );
+        QVERIFY_SQL( db, isValid() );
+
+        QStringList tables = db.tables();
+        QString tableName;
+
+        if ( tables.contains( "qtest_basictest.txt" ) )
+            tableName = "qtest_basictest.txt";
+        else if ( tables.contains( "qtest_basictest" ) )
+            tableName = "qtest_basictest";
+        else if ( tables.contains( "QTEST_BASICTEST" ) )
+            tableName = "QTEST_BASICTEST";
+        else {
+            QVERIFY( 1 );
+            continue;
+        }
+
+        qDebug("Testing: %s", qPrintable(tst_Databases::dbToString( db )));
+
+        QSqlRecord rInf = db.record( tableName );
+        QCOMPARE( rInf.count(), 2 );
+        QCOMPARE( rInf.fieldName( 0 ).toLower(), QString( "id" ) );
+        QCOMPARE( rInf.fieldName( 1 ).toLower(), QString( "name" ) );
+    }
+
+    dbs.close();
+    QVERIFY( 1 ); // make sure the test doesn't fail if no database drivers are there
+}
+
+// make sure that the static stuff will be deleted
+// when using multiple QApplication objects
+void tst_QSql::open()
+{
+    int i;
+    int argc = 0;
+    int count = -1;
+    for ( i = 0; i < 10; ++i ) {
+
+	QApplication app( argc, 0, false );
+	tst_Databases dbs;
+
+	dbs.open();
+	if ( count == -1 )
+	    // first iteration: see how many dbs are open
+	    count = (int) dbs.dbNames.count();
+	else
+	    // next iterations: make sure all are opened again
+	    QCOMPARE( count, (int)dbs.dbNames.count() );
+	dbs.close();
+    }
+}
+
+void tst_QSql::openInvalid()
+{
+    QSqlDatabase db;
+    QVERIFY(!db.open());
+
+    QSqlDatabase db2 = QSqlDatabase::addDatabase("doesnt_exist_will_never_exist", "blah");
+    QFAIL_SQL(db2, open());
+}
+
+void tst_QSql::concurrentAccess()
+{
+    int argc = 0;
+    QGuiApplication app( argc, 0, false );
+    tst_Databases dbs;
+
+    dbs.open();
+    foreach ( const QString& dbName, dbs.dbNames ) {
+	QSqlDatabase db = QSqlDatabase::database( dbName );
+	QVERIFY( db.isValid() );
+        if (tst_Databases::isMSAccess(db))
+            continue;
+
+	QSqlDatabase ndb = QSqlDatabase::addDatabase( db.driverName(), "tst_QSql::concurrentAccess" );
+	ndb.setDatabaseName( db.databaseName() );
+	ndb.setHostName( db.hostName() );
+	ndb.setPort( db.port() );
+	ndb.setUserName( db.userName() );
+	ndb.setPassword( db.password() );
+	QVERIFY_SQL( ndb, open() );
+
+	QCOMPARE( db.tables(), ndb.tables() );
+    }
+    // no database servers installed - don't fail
+    QVERIFY(1);
+    dbs.close();
+}
+
+void tst_QSql::openErrorRecovery()
+{
+    int argc = 0;
+    QGuiApplication app( argc, 0, false );
+    tst_Databases dbs;
+
+    dbs.addDbs();
+    if (dbs.dbNames.isEmpty())
+        QSKIP("No database drivers installed", SkipAll);
+    foreach ( const QString& dbName, dbs.dbNames ) {
+	QSqlDatabase db = QSqlDatabase::database( dbName, false );
+	CHECK_DATABASE( db );
+
+	QString userName = db.userName();
+	QString password = db.password();
+
+	// force an open error
+	if ( db.open( "dummy130977", "doesnt_exist" ) ) {
+            qDebug("Promiscuous database server without access control - test skipped for %s",
+                  qPrintable(tst_Databases::dbToString( db )) );
+	    QVERIFY(1);
+	    continue;
+	}
+
+	QFAIL_SQL( db, isOpen() );
+	QVERIFY_SQL( db, isOpenError() );
+
+	// now open it
+	if ( !db.open( userName, password ) ) {
+	    qDebug() << "Could not open Database " << tst_Databases::dbToString( db ) <<
+		    ". Assuming DB is down, skipping... (Error: " << 
+		    tst_Databases::printError( db.lastError() ) << ")";
+	    continue;
+	}
+	QVERIFY_SQL( db, open( userName, password ) );
+	QVERIFY_SQL( db, isOpen() );
+	QFAIL_SQL( db, isOpenError() );
+	db.close();
+	QFAIL_SQL( db, isOpen() );
+
+	// force another open error
+	QFAIL_SQL( db, open( "dummy130977", "doesnt_exist" ) );
+	QFAIL_SQL( db, isOpen() );
+	QVERIFY_SQL( db, isOpenError() );
+    }
+}
+
+void tst_QSql::registerSqlDriver()
+{
+    int argc = 0;
+    QGuiApplication app( argc, 0, false );
+
+    QSqlDatabase::registerSqlDriver( "QSQLTESTDRIVER", new QSqlDriverCreator<QSqlNullDriver> );
+    QVERIFY( QSqlDatabase::drivers().contains( "QSQLTESTDRIVER" ) );
+
+    QSqlDatabase db = QSqlDatabase::addDatabase( "QSQLTESTDRIVER" );
+    QVERIFY( db.isValid() );
+
+    QCOMPARE( db.tables(), QStringList() );
+}
+
+QTEST_APPLESS_MAIN(tst_QSql)
+#include "tst_qsql.moc"
diff --git a/tests/auto/sql/kernel/qsqldatabase/.gitignore b/tests/auto/sql/kernel/qsqldatabase/.gitignore
new file mode 100644
index 0000000000..1dfa12b8d4
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqldatabase/.gitignore
@@ -0,0 +1 @@
+tst_qsqldatabase
diff --git a/tests/auto/sql/kernel/qsqldatabase/qsqldatabase.pro b/tests/auto/sql/kernel/qsqldatabase/qsqldatabase.pro
new file mode 100644
index 0000000000..ee78b79c36
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqldatabase/qsqldatabase.pro
@@ -0,0 +1,32 @@
+load(qttest_p4)
+SOURCES  += tst_qsqldatabase.cpp
+
+QT += sql
+
+win32: {
+   !wince*: LIBS += -lws2_32
+   else: LIBS += -lws2
+}
+
+wince*: {
+   DEPLOYMENT_PLUGIN += qsqlite
+
+   testData.files = testdata
+   testData.path = .
+
+   DEPLOYMENT += testData
+}
+
+symbian {
+	TARGET.EPOCHEAPSIZE=5000 5000000
+	TARGET.EPOCSTACKSIZE=50000
+
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+}
+
diff --git a/tests/auto/sql/kernel/qsqldatabase/testdata/qtest.mdb b/tests/auto/sql/kernel/qsqldatabase/testdata/qtest.mdb
new file mode 100755
index 0000000000..f388f192ac
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqldatabase/testdata/qtest.mdb
diff --git a/tests/auto/sql/kernel/qsqldatabase/tst_databases.h b/tests/auto/sql/kernel/qsqldatabase/tst_databases.h
new file mode 100644
index 0000000000..497f5a49df
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqldatabase/tst_databases.h
@@ -0,0 +1,571 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+/* possible connection parameters */
+
+#ifndef TST_DATABASES_H
+#define TST_DATABASES_H
+
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QSqlError>
+#include <QSqlQuery>
+#include <QRegExp>
+#include <QDir>
+#include <QVariant>
+#include <QDebug>
+#include <QSqlTableModel>
+
+#include <QtTest/QtTest>
+
+#if defined (Q_OS_WIN) || defined (Q_OS_WIN32)
+#  include <qt_windows.h>
+#  if defined (Q_OS_WINCE)
+#    include <winsock2.h>
+#  endif
+#else
+#include <unistd.h>
+#endif
+
+#define CHECK_DATABASE( db ) \
+    if ( !db.isValid() ) { qFatal( "db is Invalid" ); }
+
+#define QVERIFY_SQL(q, stmt) QVERIFY2((q).stmt, tst_Databases::printError((q).lastError(), db))
+#define QFAIL_SQL(q, stmt) QVERIFY2(!(q).stmt, tst_Databases::printError((q).lastError(), db))
+
+#define DBMS_SPECIFIC(db, driver) \
+    if (!db.driverName().startsWith(driver)) { QSKIP(driver " specific test", SkipSingle); return; }
+
+// ### use QSystem::hostName if it is integrated in qtest/main
+static QString qGetHostName()
+{
+    static QString hostname;
+
+    if ( !hostname.isEmpty() )
+        return hostname;
+
+    char hn[257];
+
+    if ( gethostname( hn, 255 ) == 0 ) {
+        hn[256] = '\0';
+        hostname = QString::fromLatin1( hn );
+        hostname.replace( QLatin1Char( '.' ), QLatin1Char( '_' ) );
+        hostname.replace( QLatin1Char( '-' ), QLatin1Char( '_' ) );
+    }
+
+    return hostname;
+}
+
+// to prevent nameclashes on our database server, each machine
+// will use its own set of table names. Call this function to get
+// "tablename_hostname"
+inline static QString qTableName( const QString& prefix, const char *sourceFileName )
+{
+    return QLatin1String("dbtst")+QString::number(qHash(QLatin1String(sourceFileName) + "_" + qGetHostName().replace( "-", "_" )), 16)+"_"+prefix;
+}
+
+inline static QString qTableName( const QString& prefix, QSqlDriver* driver )
+{
+    return driver->escapeIdentifier( prefix + "_" + qGetHostName(), QSqlDriver::TableName );
+}
+
+inline static bool testWhiteSpaceNames( const QString &name )
+{
+/*    return name.startsWith( "QPSQL" )
+           || name.startsWith( "QODBC" )
+           || name.startsWith( "QSQLITE" )
+           || name.startsWith( "QMYSQL" );*/
+    return name != QLatin1String("QSQLITE2");
+}
+
+inline static QString toHex( const QString& binary )
+{
+    QString str;
+    static char const hexchars[] = "0123456789ABCDEF";
+
+    for ( int i = 0; i < binary.size(); i++ ) {
+        ushort code = binary.at(i).unicode();
+        str += (QChar)(hexchars[ (code >> 12) & 0x0F ]);
+        str += (QChar)(hexchars[ (code >> 8) & 0x0F ]);
+        str += (QChar)(hexchars[ (code >> 4) & 0x0F ]);
+        str += (QChar)(hexchars[ code & 0x0F ]);
+    }
+
+    return str;
+}
+
+
+class tst_Databases
+{
+
+public:
+    tst_Databases(): counter( 0 )
+    {
+    }
+
+    ~tst_Databases()
+    {
+        close();
+    }
+
+    // returns a testtable consisting of the names of all database connections if
+    // driverPrefix is empty, otherwise only those that start with driverPrefix.
+    int fillTestTable( const QString& driverPrefix = QString() ) const
+    {
+        QTest::addColumn<QString>( "dbName" );
+        int count = 0;
+
+        for ( int i = 0; i < dbNames.count(); ++i ) {
+            QSqlDatabase db = QSqlDatabase::database( dbNames.at( i ) );
+
+            if ( !db.isValid() )
+                continue;
+
+            if ( driverPrefix.isEmpty() || db.driverName().startsWith( driverPrefix ) ) {
+                QTest::newRow( dbNames.at( i ).toLatin1() ) << dbNames.at( i );
+                ++count;
+            }
+        }
+
+        return count;
+    }
+
+    int fillTestTableWithStrategies( const QString& driverPrefix = QString() ) const
+    {
+        QTest::addColumn<QString>( "dbName" );
+        QTest::addColumn<int>("submitpolicy_i");
+        int count = 0;
+
+        for ( int i = 0; i < dbNames.count(); ++i ) {
+            QSqlDatabase db = QSqlDatabase::database( dbNames.at( i ) );
+
+            if ( !db.isValid() )
+                continue;
+
+            if ( driverPrefix.isEmpty() || db.driverName().startsWith( driverPrefix ) ) {
+                QTest::newRow( QString("%1 [field]").arg(dbNames.at( i )).toLatin1() ) << dbNames.at( i ) << (int)QSqlTableModel::OnFieldChange;
+                QTest::newRow( QString("%1 [row]").arg(dbNames.at( i )).toLatin1() ) << dbNames.at( i ) << (int)QSqlTableModel::OnRowChange;
+                QTest::newRow( QString("%1 [manual]").arg(dbNames.at( i )).toLatin1() ) << dbNames.at( i ) << (int)QSqlTableModel::OnManualSubmit;
+                ++count;
+            }
+        }
+
+        return count;
+    }
+
+    void addDb( const QString& driver, const QString& dbName,
+                const QString& user = QString(), const QString& passwd = QString(),
+                const QString& host = QString(), int port = -1, const QString params = QString() )
+    {
+        QSqlDatabase db;
+
+        if ( !QSqlDatabase::drivers().contains( driver ) ) {
+            qWarning() <<  "Driver" << driver << "is not installed";
+            return;
+        }
+
+        // construct a stupid unique name
+        QString cName = QString::number( counter++ ) + "_" + driver + "@";
+
+        cName += host.isEmpty() ? dbName : host;
+
+        if ( port > 0 )
+            cName += ":" + QString::number( port );
+
+        db = QSqlDatabase::addDatabase( driver, cName );
+
+        if ( !db.isValid() ) {
+            qWarning( "Could not create database object" );
+            return;
+        }
+
+        db.setDatabaseName( dbName );
+
+        db.setUserName( user );
+        db.setPassword( passwd );
+        db.setHostName( host );
+        db.setPort( port );
+        db.setConnectOptions( params );
+        dbNames.append( cName );
+    }
+
+    void addDbs()
+    {
+//         addDb( "QOCI8", "//horsehead.nokia.troll.no:1521/pony.troll.no", "scott", "tiger" ); // Oracle 9i on horsehead
+//         addDb( "QOCI8", "//horsehead.nokia.troll.no:1521/ustest.troll.no", "scott", "tiger", "" ); // Oracle 9i on horsehead
+//         addDb( "QOCI8", "//iceblink.nokia.troll.no:1521/ice.troll.no", "scott", "tiger", "" ); // Oracle 8 on iceblink (not currently working)
+//         addDb( "QOCI", "//silence.nokia.troll.no:1521/testdb", "scott", "tiger" ); // Oracle 10g on silence
+//         addDb( "QOCI", "//bq-oracle10g.apac.nokia.com:1521/XE", "scott", "tiger" ); // Oracle 10gexpress
+
+//      This requires a local ODBC data source to be configured( pointing to a MySql database )
+//         addDb( "QODBC", "mysqlodbc", "troll", "trond" );
+//         addDb( "QODBC", "SqlServer", "troll", "trond" );
+//         addDb( "QTDS7", "testdb", "troll", "trondk", "horsehead" );
+//         addDb( "QODBC", "silencetestdb", "troll", "trond", "silence" );
+//         addDb( "QODBC", "horseheadtestdb", "troll", "trondk", "horsehead" );
+
+//         addDb( "QMYSQL3", "testdb", "troll", "trond", "horsehead.nokia.troll.no" );
+//         addDb( "QMYSQL3", "testdb", "troll", "trond", "horsehead.nokia.troll.no", 3307 );
+//         addDb( "QMYSQL3", "testdb", "troll", "trond", "horsehead.nokia.troll.no", 3308, "CLIENT_COMPRESS=1;CLIENT_SSL=1" ); // MySQL 4.1.1
+//         addDb( "QMYSQL3", "testdb", "troll", "trond", "horsehead.nokia.troll.no", 3309, "CLIENT_COMPRESS=1;CLIENT_SSL=1" ); // MySQL 5.0.18 Linux
+//         addDb( "QMYSQL3", "testdb", "troll", "trond", "silence.nokia.troll.no" ); // MySQL 5.1.36 Windows
+//         addDb( "QMYSQL3", "testdb", "testuser", "Ee4Gabf6_", "mysql4-nokia.trolltech.com.au" ); // MySQL 4.1.22-2.el4  linux
+//         addDb( "QMYSQL3", "testdb", "testuser", "Ee4Gabf6_", "bq-mysql50.apac.nokia.com" ); // MySQL 5.0.45-7.el5 linux
+//         addDb( "QMYSQL3", "testdb", "testuser", "Ee4Gabf6_", "bq-mysql51.apac.nokia.com" ); // MySQL 5.1.36-6.7.2.i586 linux
+
+//         addDb( "QPSQL7", "testdb", "troll", "trond", "horsehead.nokia.troll.no" ); // V7.2 NOT SUPPORTED!
+//         addDb( "QPSQL7", "testdb", "troll", "trond", "horsehead.nokia.troll.no", 5434 ); // V7.2 NOT SUPPORTED! Multi-byte
+//         addDb( "QPSQL7", "testdb", "troll", "trond", "horsehead.nokia.troll.no", 5435 ); // V7.3
+//         addDb( "QPSQL7", "testdb", "troll", "trond", "horsehead.nokia.troll.no", 5436 ); // V7.4
+//         addDb( "QPSQL7", "testdb", "troll", "trond", "horsehead.nokia.troll.no", 5437 ); // V8.0.3
+//         addDb( "QPSQL7", "testdb", "troll", "trond", "silence.nokia.troll.no" );         // V8.2.1, UTF-8
+//         addDb( "QPSQL7", "testdb", "testuser", "Ee4Gabf6_", "postgres74-nokia.trolltech.com.au" );         // Version 7.4.19-1.el4_6.1
+//         addDb( "QPSQL7", "testdb", "testuser", "Ee4Gabf6_", "bq-pgsql81.apac.nokia.com" );         // Version 8.1.11-1.el5_1.1
+//         addDb( "QPSQL7", "testdb", "testuser", "Ee4Gabf6_", "bq-pgsql84.apac.nokia.com" );         // Version 8.4.1-2.1.i586
+//         addDb( "QPSQL7", "testdb", "testuser", "Ee4Gabf6_", "bq-pgsql90.apac.nokia.com" );         // Version 9.0.0
+
+
+//         addDb( "QDB2", "testdb", "troll", "trond", "silence.nokia.troll.no" ); // DB2 v9.1 on silence
+
+//      yes - interbase really wants the physical path on the host machine.
+//         addDb( "QIBASE", "/opt/interbase/qttest.gdb", "SYSDBA", "masterkey", "horsehead.nokia.troll.no" );
+//         addDb( "QIBASE", "silence.troll.no:c:\\ibase\\testdb", "SYSDBA", "masterkey", "" ); // InterBase 7.5 on silence
+//         addDb( "QIBASE", "silence.troll.no:c:\\ibase\\testdb_ascii", "SYSDBA", "masterkey", "" ); // InterBase 7.5 on silence
+//         addDb( "QIBASE", "/opt/firebird/databases/testdb.fdb", "testuser", "Ee4Gabf6_", "firebird1-nokia.trolltech.com.au" ); // Firebird 1.5.5
+//         addDb( "QIBASE", "/opt/firebird/databases/testdb.fdb", "testuser", "Ee4Gabf6_", "firebird2-nokia.trolltech.com.au" ); // Firebird 2.1.1
+
+//      use in-memory database to prevent local files
+//         addDb("QSQLITE", ":memory:");
+         addDb( "QSQLITE", QDir::toNativeSeparators(QDir::tempPath()+"/foo.db") );
+//         addDb( "QSQLITE2", QDir::toNativeSeparators(QDir::tempPath()+"/foo2.db") );
+//         addDb( "QODBC3", "DRIVER={SQL SERVER};SERVER=iceblink.nokia.troll.no\\ICEBLINK", "troll", "trond", "" );
+//         addDb( "QODBC3", "DRIVER={SQL Native Client};SERVER=silence.nokia.troll.no\\SQLEXPRESS", "troll", "trond", "" );
+
+//         addDb( "QODBC", "DRIVER={MySQL ODBC 5.1 Driver};SERVER=bq-mysql50.apac.nokia.com;DATABASE=testdb", "testuser", "Ee4Gabf6_", "" );
+//         addDb( "QODBC", "DRIVER={MySQL ODBC 5.1 Driver};SERVER=bq-mysql51.apac.nokia.com;DATABASE=testdb", "testuser", "Ee4Gabf6_", "" );
+//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=horsehead.nokia.troll.no;DATABASE=testdb;PORT=4101;UID=troll;PWD=trondk", "troll", "trondk", "" );
+//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=silence.nokia.troll.no;DATABASE=testdb;PORT=2392;UID=troll;PWD=trond", "troll", "trond", "" );
+//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=bq-winserv2003-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433;UID=testuser;PWD=Ee4Gabf6_;TDS_Version=8.0", "", "", "" );
+//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=bq-winserv2008-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433;UID=testuser;PWD=Ee4Gabf6_;TDS_Version=8.0", "", "", "" );
+//         addDb( "QTDS7", "testdb", "testuser", "Ee4Gabf6_", "bq-winserv2003" );
+//         addDb( "QTDS7", "testdb", "testuser", "Ee4Gabf6_", "bq-winserv2008" );
+//         addDb( "QODBC3", "DRIVER={SQL SERVER};SERVER=bq-winserv2003-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433", "testuser", "Ee4Gabf6_", "" );
+//         addDb( "QODBC3", "DRIVER={SQL SERVER};SERVER=bq-winserv2008-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433", "testuser", "Ee4Gabf6_", "" );
+//         addDb( "QODBC", "DRIVER={Microsoft Access Driver (*.mdb)};DBQ=c:\\dbs\\access\\testdb.mdb", "", "", "" );
+//         addDb( "QODBC", "DRIVER={Postgresql};SERVER=bq-pgsql84.apac.nokia.com;DATABASE=testdb", "testuser", "Ee4Gabf6_", "" );
+    }
+
+    void open()
+    {
+        addDbs();
+
+        QStringList::Iterator it = dbNames.begin();
+
+        while ( it != dbNames.end() ) {
+            QSqlDatabase db = QSqlDatabase::database(( *it ), false );
+            qDebug() << "Opening:" << (*it);
+
+            if ( db.isValid() && !db.isOpen() ) {
+                if ( !db.open() ) {
+                    qWarning( "tst_Databases: Unable to open %s on %s:\n%s", qPrintable( db.driverName() ), qPrintable( *it ), qPrintable( db.lastError().databaseText() ) );
+                    // well... opening failed, so we just ignore the server, maybe it is not running
+                    it = dbNames.erase( it );
+                } else {
+                    ++it;
+                }
+            }
+        }
+    }
+
+    void close()
+    {
+        for ( QStringList::Iterator it = dbNames.begin(); it != dbNames.end(); ++it ) {
+            {
+                QSqlDatabase db = QSqlDatabase::database(( *it ), false );
+
+                if ( db.isValid() && db.isOpen() )
+                    db.close();
+            }
+
+            QSqlDatabase::removeDatabase(( *it ) );
+        }
+
+        dbNames.clear();
+    }
+
+    // for debugging only: outputs the connection as string
+    static QString dbToString( const QSqlDatabase db )
+    {
+        QString res = db.driverName() + "@";
+
+        if ( db.driverName().startsWith( "QODBC" ) || db.driverName().startsWith( "QOCI" ) ) {
+            res += db.databaseName();
+        } else {
+            res += db.hostName();
+        }
+
+        if ( db.port() > 0 ) {
+            res += ":" + QString::number( db.port() );
+        }
+
+        return res;
+    }
+
+    // drop a table only if it exists to prevent warnings
+    static void safeDropTables( QSqlDatabase db, const QStringList& tableNames )
+    {
+        bool wasDropped;
+        QSqlQuery q( db );
+        QStringList dbtables=db.tables();
+
+        foreach(const QString &tableName, tableNames)
+        {
+            wasDropped = true;
+            QString table=tableName;
+            if ( db.driver()->isIdentifierEscaped(table, QSqlDriver::TableName))
+                table = db.driver()->stripDelimiters(table, QSqlDriver::TableName);
+
+            if ( dbtables.contains( table, Qt::CaseInsensitive ) ) {
+                foreach(const QString &table2, dbtables.filter(table, Qt::CaseInsensitive)) {
+                    if(table2.compare(table.section('.', -1, -1), Qt::CaseInsensitive) == 0) {
+                        table=db.driver()->escapeIdentifier(table2, QSqlDriver::TableName);
+                        if(isPostgreSQL(db))
+                            wasDropped = q.exec( "drop table " + table + " cascade");
+                        else
+                            wasDropped = q.exec( "drop table " + table);
+                        dbtables.removeAll(table2);
+                    }
+                }
+            }
+            if ( !wasDropped ) {
+                qWarning() << dbToString(db) << "unable to drop table" << tableName << ':' << q.lastError();
+//              qWarning() << "last query:" << q.lastQuery();
+//              qWarning() << "dbtables:" << dbtables;
+//              qWarning() << "db.tables():" << db.tables();
+            }
+        }
+    }
+
+    static void safeDropTable( QSqlDatabase db, const QString& tableName )
+    {
+        safeDropTables(db, QStringList() << tableName);
+    }
+
+    static void safeDropViews( QSqlDatabase db, const QStringList &viewNames )
+    {
+        if ( isMSAccess( db ) ) // Access is sooo stupid.
+            safeDropTables( db, viewNames );
+
+        bool wasDropped;
+        QSqlQuery q( db );
+        QStringList dbtables=db.tables(QSql::Views);
+
+        foreach(QString viewName, viewNames)
+        {
+            wasDropped = true;
+            QString view=viewName;
+            if ( db.driver()->isIdentifierEscaped(view, QSqlDriver::TableName))
+                view = db.driver()->stripDelimiters(view, QSqlDriver::TableName);
+
+            if ( dbtables.contains( view, Qt::CaseInsensitive ) ) {
+                foreach(const QString &view2, dbtables.filter(view, Qt::CaseInsensitive)) {
+                    if(view2.compare(view.section('.', -1, -1), Qt::CaseInsensitive) == 0) {
+                        view=db.driver()->escapeIdentifier(view2, QSqlDriver::TableName);
+                        wasDropped = q.exec( "drop view " + view);
+                        dbtables.removeAll(view);
+                    }
+                }
+            }
+
+            if ( !wasDropped )
+                qWarning() << dbToString(db) << "unable to drop view" << viewName << ':' << q.lastError();
+//                  << "\nlast query:" << q.lastQuery()
+//                  << "\ndbtables:" << dbtables
+//                  << "\ndb.tables(QSql::Views):" << db.tables(QSql::Views);
+        }
+    }
+
+    static void safeDropView( QSqlDatabase db, const QString& tableName )
+    {
+        safeDropViews(db, QStringList() << tableName);
+    }
+
+    // returns the type name of the blob datatype for the database db.
+    // blobSize is only used if the db doesn't have a generic blob type
+    static QString blobTypeName( QSqlDatabase db, int blobSize = 10000 )
+    {
+        if ( db.driverName().startsWith( "QMYSQL" ) )
+            return "longblob";
+
+        if ( db.driverName().startsWith( "QPSQL" ) )
+            return "bytea";
+
+        if ( db.driverName().startsWith( "QTDS" )
+                || isSqlServer( db )
+                || isMSAccess( db ) )
+            return "image";
+
+        if ( db.driverName().startsWith( "QDB2" ) )
+            return QString( "blob(%1)" ).arg( blobSize );
+
+        if ( db.driverName().startsWith( "QIBASE" ) )
+            return QString( "blob sub_type 0 segment size 4096" );
+
+        if ( db.driverName().startsWith( "QOCI" )
+                || db.driverName().startsWith( "QSQLITE" ) )
+            return "blob";
+
+        qDebug() <<  "tst_Databases::blobTypeName: Don't know the blob type for" << dbToString( db );
+
+        return "blob";
+    }
+
+    static QString autoFieldName( QSqlDatabase db )
+    {
+        if ( db.driverName().startsWith( "QMYSQL" ) )
+            return "AUTO_INCREMENT";
+        if ( db.driverName().startsWith( "QTDS" ) )
+            return "IDENTITY";
+/*        if ( db.driverName().startsWith( "QPSQL" ) )
+            return "SERIAL";*/
+//        if ( db.driverName().startsWith( "QDB2" ) )
+//            return "GENERATED BY DEFAULT AS IDENTITY";
+
+        return QString();
+    }
+
+    static QByteArray printError( const QSqlError& err )
+    {
+        QString result;
+        if(err.number() > 0)
+            result += '(' + QString::number(err.number()) + ") ";
+        result += '\'';
+        if(!err.driverText().isEmpty())
+            result += err.driverText() + "' || '";
+        result += err.databaseText() + "'";
+        return result.toLocal8Bit();
+    }
+
+    static QByteArray printError( const QSqlError& err, const QSqlDatabase& db )
+    {
+        QString result(dbToString(db) + ": ");
+        if(err.number() > 0)
+            result += '(' + QString::number(err.number()) + ") ";
+        result += '\'';
+        if(!err.driverText().isEmpty())
+            result += err.driverText() + "' || '";
+        result += err.databaseText() + "'";
+        return result.toLocal8Bit();
+    }
+
+    static bool isSqlServer( QSqlDatabase db )
+    {
+        return db.databaseName().contains( "sql server", Qt::CaseInsensitive )
+               || db.databaseName().contains( "sqlserver", Qt::CaseInsensitive )
+               || db.databaseName().contains( "sql native client", Qt::CaseInsensitive )
+               || db.databaseName().contains( "bq-winserv", Qt::CaseInsensitive )
+               || db.hostName().contains( "bq-winserv", Qt::CaseInsensitive );
+    }
+
+    static bool isMSAccess( QSqlDatabase db )
+    {
+        return db.databaseName().contains( "Access Driver", Qt::CaseInsensitive );
+    }
+
+    static bool isPostgreSQL( QSqlDatabase db )
+    {
+        return db.driverName().startsWith("QPSQL") || (db.driverName().startsWith("QODBC") && ( db.databaseName().contains("PostgreSQL", Qt::CaseInsensitive) || db.databaseName().contains("pgsql", Qt::CaseInsensitive) ) );
+    }
+
+    static bool isMySQL( QSqlDatabase db )
+    {
+        return db.driverName().startsWith("QMYSQL") || (db.driverName().startsWith("QODBC") && db.databaseName().contains("MySQL", Qt::CaseInsensitive) );
+    }
+    static bool isDB2( QSqlDatabase db )
+    {
+        return db.driverName().startsWith("QDB2") || (db.driverName().startsWith("QODBC") && db.databaseName().contains("db2", Qt::CaseInsensitive) );
+    }
+
+    // -1 on fail, else Oracle version
+    static int getOraVersion( QSqlDatabase db )
+    {
+        int ver = -1;
+        QSqlQuery q( "SELECT banner FROM v$version", db );
+        q.next();
+
+        QRegExp vers( "([0-9]+)\\.[0-9\\.]+[0-9]" );
+
+        if ( vers.indexIn( q.value( 0 ).toString() ) ) {
+            bool ok;
+            ver = vers.cap( 1 ).toInt( &ok );
+
+            if ( !ok )
+                ver = -1;
+        }
+
+        return ver;
+    }
+
+    static QString getMySqlVersion( const QSqlDatabase &db )
+    {
+        QSqlQuery q(db);
+        q.exec( "select version()" );
+        if(q.next())
+            return q.value( 0 ).toString();
+        else
+            return QString();
+    }
+
+    static QString getPSQLVersion( const QSqlDatabase &db )
+    {
+        QSqlQuery q(db);
+        q.exec( "select version()" );
+        if(q.next())
+            return q.value( 0 ).toString();
+        else
+            return QString();
+    }
+
+    QStringList     dbNames;
+    int      counter;
+};
+
+#endif
+
diff --git a/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp b/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
new file mode 100644
index 0000000000..85ec28a671
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp
@@ -0,0 +1,2218 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <qsqldatabase.h>
+#include <qsqlquery.h>
+#include <qsqldriver.h>
+#include <qsqlrecord.h>
+#include <qsqlfield.h>
+#include <qsqlindex.h>
+#include <qregexp.h>
+#include <qvariant.h>
+#include <qdatetime.h>
+#include <qdebug.h>
+
+#define NODATABASE_SKIP "No database drivers are available in this Qt configuration"
+
+#include "tst_databases.h"
+
+//TESTED_FILES=
+
+QT_FORWARD_DECLARE_CLASS(QSqlDatabase)
+struct FieldDef;
+
+class tst_QSqlDatabase : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QSqlDatabase();
+    virtual ~tst_QSqlDatabase();
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+private slots:
+    void record_data() { generic_data(); }
+    //void record();
+    void open_data() { generic_data(); }
+    void open();
+    void tables_data() { generic_data(); }
+    void tables();
+    void oci_tables_data() { generic_data("QOCI"); }
+    void oci_tables();
+    void transaction_data() { generic_data(); }
+    void transaction();
+    void eventNotification_data() { generic_data(); }
+    void eventNotification();
+    void addDatabase();
+
+    //database specific tests
+    void recordMySQL_data() { generic_data("QMYSQL"); }
+    void recordMySQL();
+    void recordPSQL_data() { generic_data("QPSQL"); }
+    void recordPSQL();
+    void recordOCI_data() { generic_data("QOCI"); }
+    void recordOCI();
+    void recordTDS_data() { generic_data("QTDS"); }
+    void recordTDS();
+    void recordDB2_data() { generic_data("QDB2"); }
+    void recordDB2();
+    void recordSQLite_data() { generic_data("QSQLITE"); }
+    void recordSQLite();
+    void recordAccess_data() { generic_data("QODBC"); }
+    void recordAccess();
+    void recordSQLServer_data() { generic_data("QODBC"); }
+    void recordSQLServer();
+    void recordIBase_data() {generic_data("QIBASE"); }
+    void recordIBase();
+
+    void eventNotificationIBase_data() { generic_data("QIBASE"); }
+    void eventNotificationIBase();
+    void eventNotificationPSQL_data() { generic_data("QPSQL"); }
+    void eventNotificationPSQL();
+
+    //database specific 64 bit integer test
+    void bigIntField_data() { generic_data(); }
+    void bigIntField();
+
+    // general tests
+    void getConnectionName_data() { generic_data(); }
+    void getConnectionName(); // For task 129992
+
+    //problem specific tests
+    void alterTable_data() { generic_data(); }
+    void alterTable();
+    void caseSensivity_data() { generic_data(); }
+    void caseSensivity();
+    void noEscapedFieldNamesInRecord_data() { generic_data(); }
+    void noEscapedFieldNamesInRecord();
+    void whitespaceInIdentifiers_data() { generic_data(); }
+    void whitespaceInIdentifiers();
+    void formatValueTrimStrings_data() { generic_data(); }
+    void formatValueTrimStrings();
+    void precisionPolicy_data() { generic_data(); }
+    void precisionPolicy();
+
+    void db2_valueCacheUpdate_data() { generic_data("QDB2"); }
+    void db2_valueCacheUpdate();
+
+    void psql_schemas_data() { generic_data("QPSQL"); }
+    void psql_schemas();
+    void psql_escapedIdentifiers_data() { generic_data("QPSQL"); }
+    void psql_escapedIdentifiers();
+    void psql_escapeBytea_data() { generic_data("QPSQL"); }
+    void psql_escapeBytea();
+    void bug_249059_data() { generic_data("QPSQL"); }
+    void bug_249059();
+
+    void mysqlOdbc_unsignedIntegers_data() { generic_data(); }
+    void mysqlOdbc_unsignedIntegers();
+    void mysql_multiselect_data() { generic_data("QMYSQL"); }
+    void mysql_multiselect();  // For task 144331
+    void mysql_savepointtest_data() { generic_data("QMYSQL"); }
+    void mysql_savepointtest();
+
+    void accessOdbc_strings_data() { generic_data(); }
+    void accessOdbc_strings();
+
+    void ibase_numericFields_data() { generic_data("QIBASE"); }
+    void ibase_numericFields(); // For task 125053
+    void ibase_fetchBlobs_data() { generic_data("QIBASE"); }
+    void ibase_fetchBlobs(); // For task 143471
+    void ibase_useCustomCharset_data() { generic_data("QIBASE"); }
+    void ibase_useCustomCharset(); // For task 134608
+    void ibase_procWithoutReturnValues_data() { generic_data("QIBASE"); } // For task 165423
+    void ibase_procWithoutReturnValues();
+    void ibase_procWithReturnValues_data() { generic_data("QIBASE"); } // For task 177530
+    void ibase_procWithReturnValues();
+
+    void odbc_reopenDatabase_data() { generic_data("QODBC"); }
+    void odbc_reopenDatabase();
+    void odbc_uniqueidentifier_data() { generic_data("QODBC"); }
+    void odbc_uniqueidentifier(); // For task 141822
+    void odbc_uintfield_data() { generic_data("QODBC"); }
+    void odbc_uintfield();
+    void odbc_bindBoolean_data() { generic_data("QODBC"); }
+    void odbc_bindBoolean();
+    void odbc_testqGetString_data() { generic_data("QODBC"); }
+    void odbc_testqGetString();
+
+    void oci_serverDetach_data() { generic_data("QOCI"); }
+    void oci_serverDetach(); // For task 154518
+    void oci_xmltypeSupport_data() { generic_data("QOCI"); }
+    void oci_xmltypeSupport();
+    void oci_fieldLength_data() { generic_data("QOCI"); }
+    void oci_fieldLength();
+    void oci_synonymstest_data() { generic_data("QOCI"); }
+    void oci_synonymstest();
+
+    void sqlite_bindAndFetchUInt_data() { generic_data("QSQLITE"); }
+    void sqlite_bindAndFetchUInt();
+
+    void sqlStatementUseIsNull_189093_data() { generic_data(); }
+    void sqlStatementUseIsNull_189093();
+
+    void sqlite_enable_cache_mode_data() { generic_data("QSQLITE"); }
+    void sqlite_enable_cache_mode();
+
+private:
+    void createTestTables(QSqlDatabase db);
+    void dropTestTables(QSqlDatabase db);
+    void populateTestTables(QSqlDatabase db);
+    void generic_data(const QString &engine=QString());
+
+    void testRecord(const FieldDef fieldDefs[], const QSqlRecord& inf, QSqlDatabase db);
+    void commonFieldTest(const FieldDef fieldDefs[], QSqlDatabase, const int);
+
+    tst_Databases dbs;
+};
+
+// number of records to be inserted per testfunction
+static const int ITERATION_COUNT = 2;
+
+//helper class for database specific tests
+struct FieldDef {
+    FieldDef(QString tn = QString(),
+          QVariant::Type t = QVariant::Invalid,
+          QVariant v = QVariant(),
+          bool nl = true):
+        typeName(tn), type(t), val(v), nullable(nl) {}
+
+    QString fieldName() const
+    {
+        QString rt = typeName;
+        rt.replace(QRegExp("\\s"), QString("_"));
+        int i = rt.indexOf("(");
+        if (i == -1)
+            i = rt.length();
+        if (i > 20)
+            i = 20;
+        return "t_" + rt.left(i);
+    }
+    QString typeName;
+    QVariant::Type type;
+    QVariant val;
+    bool nullable;
+};
+
+// creates a table out of the FieldDefs and returns the number of fields
+// excluding the primary key field
+static int createFieldTable(const FieldDef fieldDefs[], QSqlDatabase db)
+{
+    tst_Databases::safeDropTable(db, qTableName("qtestfields", __FILE__));
+    QSqlQuery q(db);
+    // construct a create table statement consisting of all fieldtypes
+    QString qs = "create table " + qTableName("qtestfields", __FILE__);
+    QString autoName = tst_Databases::autoFieldName(db);
+    if (tst_Databases::isMSAccess(db))
+        qs.append(" (id int not null");
+    else if (tst_Databases::isPostgreSQL(db))
+        qs.append(" (id serial not null");
+    else
+        qs.append(QString("(id integer not null %1 primary key").arg(autoName));
+
+    int i = 0;
+    for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {
+        qs += QString(",\n %1 %2").arg(fieldDefs[ i ].fieldName()).arg(fieldDefs[ i ].typeName);
+        if ((db.driverName().startsWith("QTDS") || tst_Databases::isSqlServer(db)) && fieldDefs[ i ].nullable) {
+            qs += " null";
+        }
+    }
+
+    if (tst_Databases::isMSAccess(db))
+        qs.append(",\n primary key (id)");
+
+    qs += ')';
+    if (!q.exec(qs)) {
+        qDebug() << "Creation of Table failed:" << tst_Databases::printError(q.lastError(), db);
+        qDebug() << "Query: " << qs;
+        return -1;
+    }
+    return i;
+}
+
+tst_QSqlDatabase::tst_QSqlDatabase()
+{
+}
+
+tst_QSqlDatabase::~tst_QSqlDatabase()
+{
+}
+
+void tst_QSqlDatabase::createTestTables(QSqlDatabase db)
+{
+    if (!db.isValid())
+    return;
+    QSqlQuery q(db);
+    if (db.driverName().startsWith("QMYSQL"))
+        // ### stupid workaround until we find a way to hardcode this
+        // in the MySQL server startup script
+        q.exec("set table_type=innodb");
+    else if (tst_Databases::isSqlServer(db)) {
+        QVERIFY_SQL(q, exec("SET ANSI_DEFAULTS ON"));
+        QVERIFY_SQL(q, exec("SET IMPLICIT_TRANSACTIONS OFF"));
+    } else if(tst_Databases::isPostgreSQL(db))
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+
+    // please never ever change this table; otherwise fix all tests ;)
+    if (tst_Databases::isMSAccess(db)) {
+        QVERIFY_SQL(q, exec("create table " + qTableName("qtest", __FILE__) +
+                   " (id int not null, t_varchar varchar(40) not null, t_char char(40), "
+                   "t_numeric number, primary key (id, t_varchar))"));
+    } else {
+        QVERIFY_SQL(q, exec("create table " + qTableName("qtest", __FILE__) +
+               " (id integer not null, t_varchar varchar(40) not null, "
+               "t_char char(40), t_numeric numeric(6, 3), primary key (id, t_varchar))"));
+    }
+
+    if (testWhiteSpaceNames(db.driverName())) {
+        QString qry = "create table "
+            + db.driver()->escapeIdentifier(qTableName("qtest", __FILE__) + " test", QSqlDriver::TableName)
+            + '('
+            + db.driver()->escapeIdentifier(QLatin1String("test test"), QSqlDriver::FieldName)
+            + " int not null primary key)";
+        QVERIFY_SQL(q, exec(qry));
+    }
+}
+
+void tst_QSqlDatabase::dropTestTables(QSqlDatabase db)
+{
+    if (!db.isValid())
+        return;
+
+    if(tst_Databases::isPostgreSQL(db)) {
+        QSqlQuery q(db);
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+    }
+
+    // drop the view first, otherwise we'll get dependency problems
+    tst_Databases::safeDropViews(db, QStringList() << qTableName("qtest_view", __FILE__) << qTableName("qtest_view2", __FILE__));
+
+    QStringList tableNames;
+    tableNames << qTableName("qtest", __FILE__)
+            << qTableName("qtestfields", __FILE__)
+            << qTableName("qtestalter", __FILE__)
+            << qTableName("qtest_temp", __FILE__)
+            << qTableName("qtest_bigint", __FILE__)
+            << qTableName("qtest_xmltype", __FILE__)
+            << qTableName("latin1table", __FILE__)
+            << qTableName("qtest_sqlguid", __FILE__)
+            << qTableName("batable", __FILE__)
+            << qTableName("qtest_prec", __FILE__)
+            << qTableName("uint", __FILE__)
+            << qTableName("strings", __FILE__)
+            << qTableName("numericfields", __FILE__)
+            << qTableName("qtest_ibaseblobs", __FILE__)
+            << qTableName("qtestBindBool", __FILE__)
+            << qTableName("testqGetString", __FILE__)
+            << qTableName("qtest_sqlguid", __FILE__)
+            << qTableName("uint_table", __FILE__)
+            << qTableName("uint_test", __FILE__)
+            << qTableName("bug_249059", __FILE__);
+
+    QSqlQuery q(0, db);
+    if (db.driverName().startsWith("QPSQL")) {
+        q.exec("drop schema " + qTableName("qtestschema", __FILE__) + " cascade");
+        q.exec("drop schema " + qTableName("qtestScHeMa", __FILE__) + " cascade");
+    }
+
+    if (testWhiteSpaceNames(db.driverName()))
+        tableNames <<  db.driver()->escapeIdentifier(qTableName("qtest", __FILE__) + " test", QSqlDriver::TableName);
+
+    tst_Databases::safeDropTables(db, tableNames);
+
+    if (db.driverName().startsWith("QOCI")) {
+        q.exec("drop user "+qTableName("CREATOR", __FILE__)+" cascade");
+        q.exec("drop user "+qTableName("APPUSER", __FILE__)+" cascade");
+        q.exec("DROP TABLE system."+qTableName("mypassword", __FILE__));
+
+    }
+}
+
+void tst_QSqlDatabase::populateTestTables(QSqlDatabase db)
+{
+    if (!db.isValid())
+        return;
+    QSqlQuery q(db);
+    const QString qtest(qTableName("qtest", __FILE__));
+
+    q.exec("delete from " + qtest); //non-fatal
+    QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (0, 'VarChar0', 'Char0', 1.1)"));
+    QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (1, 'VarChar1', 'Char1', 2.2)"));
+    QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (2, 'VarChar2', 'Char2', 3.3)"));
+    QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (3, 'VarChar3', 'Char3', 4.4)"));
+    QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (4, 'VarChar4', NULL, NULL)"));
+}
+
+void tst_QSqlDatabase::initTestCase()
+{
+    dbs.open();
+
+    for (QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it) {
+        QSqlDatabase db = QSqlDatabase::database((*it));
+        CHECK_DATABASE(db);
+        dropTestTables(db); //in case of leftovers
+        createTestTables(db);
+        populateTestTables(db);
+    }
+}
+
+void tst_QSqlDatabase::cleanupTestCase()
+{
+    for (QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it) {
+        QSqlDatabase db = QSqlDatabase::database((*it));
+        CHECK_DATABASE(db);
+        dropTestTables(db);
+    }
+
+    dbs.close();
+}
+
+void tst_QSqlDatabase::init()
+{
+}
+
+void tst_QSqlDatabase::cleanup()
+{
+}
+
+void tst_QSqlDatabase::generic_data(const QString& engine)
+{
+    if ( dbs.fillTestTable(engine) == 0 ) {
+        if(engine.isEmpty())
+           QSKIP( "No database drivers are available in this Qt configuration", SkipAll );
+        else
+           QSKIP( (QString("No database drivers of type %1 are available in this Qt configuration").arg(engine)).toLocal8Bit(), SkipAll );
+    }
+}
+
+void tst_QSqlDatabase::addDatabase()
+{
+    QTest::ignoreMessage(QtWarningMsg, "QSqlDatabase: BLAH_FOO_NONEXISTENT_DRIVER driver not loaded");
+    QTest::ignoreMessage(QtWarningMsg, qPrintable("QSqlDatabase: available drivers: " + QSqlDatabase::drivers().join(QLatin1String(" "))));
+    {
+        QSqlDatabase db = QSqlDatabase::addDatabase("BLAH_FOO_NONEXISTENT_DRIVER",
+                                                    "INVALID_CONNECTION");
+        QVERIFY(!db.isValid());
+    }
+    QVERIFY(QSqlDatabase::contains("INVALID_CONNECTION"));
+    QSqlDatabase::removeDatabase("INVALID_CONNECTION");
+    QVERIFY(!QSqlDatabase::contains("INVALID_CONNECTION"));
+}
+
+void tst_QSqlDatabase::open()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    int i;
+    for (i = 0; i < 10; ++i) {
+        db.close();
+        QVERIFY(!db.isOpen());
+        QVERIFY_SQL(db, open());
+        QVERIFY(db.isOpen());
+        QVERIFY(!db.isOpenError());
+    }
+
+    if (db.driverName().startsWith("QSQLITE") && db.databaseName() == ":memory:") {
+        // tables in in-memory databases don't survive an open/close
+        createTestTables(db);
+        populateTestTables(db);
+    }
+}
+
+void tst_QSqlDatabase::tables()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    const QString qtest(qTableName("qtest", __FILE__)), qtest_view(qTableName("qtest_view", __FILE__)), temp_tab(qTableName("test_tab", __FILE__));
+
+    bool views = true;
+    bool tempTables = false;
+
+    QSqlQuery q(db);
+    if ( db.driverName().startsWith( "QMYSQL" ) && tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt()<5 )
+        QSKIP( "Test requires MySQL >= 5.0", SkipSingle );
+
+
+    if (!q.exec("CREATE VIEW " + qtest_view + " as select * from " + qtest)) {
+        qDebug("DBMS '%s' cannot handle VIEWs: %s",
+               qPrintable(tst_Databases::dbToString(db)),
+               qPrintable(tst_Databases::printError(q.lastError())));
+        views = false;
+    }
+
+    if (db.driverName().startsWith("QSQLITE3")) {
+        QVERIFY_SQL(q, exec("CREATE TEMPORARY TABLE " + temp_tab + " (id int)"));
+        tempTables = true;
+    }
+
+    QStringList tables = db.tables(QSql::Tables);
+    QVERIFY(tables.contains(qtest, Qt::CaseInsensitive));
+    QVERIFY(!tables.contains("sql_features", Qt::CaseInsensitive)); //check for postgres 7.4 internal tables
+    if (views) {
+        QVERIFY(!tables.contains(qtest_view, Qt::CaseInsensitive));
+    }
+    if (tempTables)
+        QVERIFY(tables.contains(temp_tab, Qt::CaseInsensitive));
+
+    tables = db.tables(QSql::Views);
+    if (views) {
+        if(!tables.contains(qtest_view, Qt::CaseInsensitive))
+            qDebug() << "failed to find" << qtest_view << "in" << tables;
+        QVERIFY(tables.contains(qtest_view, Qt::CaseInsensitive));
+    }
+    if (tempTables)
+        QVERIFY(!tables.contains(temp_tab, Qt::CaseInsensitive));
+    QVERIFY(!tables.contains(qtest, Qt::CaseInsensitive));
+
+    tables = db.tables(QSql::SystemTables);
+    QVERIFY(!tables.contains(qtest, Qt::CaseInsensitive));
+    QVERIFY(!tables.contains(qtest_view, Qt::CaseInsensitive));
+    QVERIFY(!tables.contains(temp_tab, Qt::CaseInsensitive));
+
+    tables = db.tables(QSql::AllTables);
+    if (views)
+        QVERIFY(tables.contains(qtest_view, Qt::CaseInsensitive));
+    if (tempTables)
+        QVERIFY(tables.contains(temp_tab, Qt::CaseInsensitive));
+    QVERIFY(tables.contains(qtest, Qt::CaseInsensitive));
+
+    if (db.driverName().startsWith("QPSQL")) {
+        QVERIFY(tables.contains(qtest + " test"));
+    }
+}
+
+void tst_QSqlDatabase::whitespaceInIdentifiers()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (testWhiteSpaceNames(db.driverName())) {
+        const QString tableName(qTableName("qtest", __FILE__) + " test");
+        QVERIFY(db.tables().contains(tableName, Qt::CaseInsensitive));
+
+        QSqlRecord rec = db.record(db.driver()->escapeIdentifier(tableName, QSqlDriver::TableName));
+        QCOMPARE(rec.count(), 1);
+        QCOMPARE(rec.fieldName(0), QString("test test"));
+        if(db.driverName().startsWith("QOCI"))
+            QCOMPARE(rec.field(0).type(), QVariant::Double);
+        else
+            QCOMPARE(rec.field(0).type(), QVariant::Int);
+
+        QSqlIndex idx = db.primaryIndex(db.driver()->escapeIdentifier(tableName, QSqlDriver::TableName));
+        QCOMPARE(idx.count(), 1);
+        QCOMPARE(idx.fieldName(0), QString("test test"));
+        if(db.driverName().startsWith("QOCI"))
+            QCOMPARE(idx.field(0).type(), QVariant::Double);
+        else
+            QCOMPARE(idx.field(0).type(), QVariant::Int);
+    } else {
+        QSKIP("DBMS does not support whitespaces in identifiers", SkipSingle);
+    }
+}
+
+void tst_QSqlDatabase::alterTable()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    const QString qtestalter(qTableName("qtestalter", __FILE__));
+
+    QSqlQuery q(db);
+
+    QVERIFY_SQL(q, exec("create table " + qtestalter + " (F1 char(20), F2 char(20), F3 char(20))"));
+    QSqlRecord rec = db.record(qtestalter);
+    QCOMPARE((int)rec.count(), 3);
+
+    int i;
+    for (i = 0; i < 3; ++i) {
+        QCOMPARE(rec.field(i).name().toUpper(), QString("F%1").arg(i + 1));
+    }
+
+    if (!q.exec("alter table " + qtestalter + " drop column F2")) {
+        QSKIP("DBMS doesn't support dropping columns in ALTER TABLE statement", SkipSingle);
+    }
+
+    rec = db.record(qtestalter);
+
+    QCOMPARE((int)rec.count(), 2);
+
+    QCOMPARE(rec.field(0).name().toUpper(), QString("F1"));
+    QCOMPARE(rec.field(1).name().toUpper(), QString("F3"));
+
+    q.exec("select * from " + qtestalter);
+}
+
+#if 0
+// this is the general test that should work on all databases.
+// unfortunately no DBMS supports SQL 92/ 99 so the general
+// test is more or less a joke. Please write a test for each
+// database plugin (see recordOCI and so on). Use this test
+// as a template.
+void tst_QSqlDatabase::record()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    static const FieldDef fieldDefs[] = {
+        FieldDef("char(20)", QVariant::String,         QString("blah1"), false),
+        FieldDef("varchar(20)", QVariant::String,      QString("blah2"), false),
+        FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+}
+#endif
+
+void tst_QSqlDatabase::testRecord(const FieldDef fieldDefs[], const QSqlRecord& inf, QSqlDatabase db)
+{
+    int i = 0;
+    if (!tst_Databases::autoFieldName(db).isEmpty()) // Currently only MySQL is tested
+        QVERIFY2(inf.field(i).isAutoValue(), qPrintable(inf.field(i).name() + " should be reporting as an autovalue"));
+    for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {
+        QCOMPARE(inf.field(i+1).name().toUpper(), fieldDefs[ i ].fieldName().toUpper());
+        if (inf.field(i+1).type() != fieldDefs[ i ].type) {
+            QFAIL(qPrintable(QString(" Expected: '%1' Received: '%2' for field %3 in testRecord").arg(
+              QVariant::typeToName(fieldDefs[ i ].type)).arg(
+            QVariant::typeToName(inf.field(i+1).type())).arg(
+              fieldDefs[ i ].fieldName())));
+        }
+        QVERIFY(!inf.field(i+1).isAutoValue());
+
+//	qDebug(QString(" field: %1 type: %2 variant type: %3").arg(fieldDefs[ i ].fieldName()).arg(QVariant::typeToName(inf.field(i+1)->type())).arg(QVariant::typeToName(inf.field(i+1)->value().type())));
+    }
+}
+
+// non-dbms specific tests
+void tst_QSqlDatabase::commonFieldTest(const FieldDef fieldDefs[], QSqlDatabase db, const int fieldCount)
+{
+    CHECK_DATABASE(db);
+
+    QSqlRecord rec = db.record(qTableName("qtestfields", __FILE__));
+    QCOMPARE((int)rec.count(), fieldCount+1);
+    testRecord(fieldDefs, rec, db);
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("select * from " + qTableName("qtestfields", __FILE__)));
+}
+
+void tst_QSqlDatabase::recordTDS()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    static const FieldDef fieldDefs[] = {
+    FieldDef("tinyint", QVariant::Int,		255),
+    FieldDef("smallint", QVariant::Int,		32767),
+    FieldDef("int", QVariant::Int,			2147483647),
+    FieldDef("numeric(10,9)", QVariant::Double,	1.23456789),
+    FieldDef("decimal(10,9)", QVariant::Double,	1.23456789),
+    FieldDef("float(4)", QVariant::Double,		1.23456789),
+    FieldDef("double precision", QVariant::Double,	1.23456789),
+    FieldDef("real", QVariant::Double,		1.23456789),
+    FieldDef("smallmoney", QVariant::Double,	100.42),
+    FieldDef("money", QVariant::Double,		200.42),
+    // accuracy is that of a minute
+    FieldDef("smalldatetime", QVariant::DateTime,	QDateTime(QDate::currentDate(), QTime(1, 2, 0, 0))),
+    // accuracy is that of a second
+    FieldDef("datetime", QVariant::DateTime,	QDateTime(QDate::currentDate(), QTime(1, 2, 3, 0))),
+    FieldDef("char(20)", QVariant::String,		"blah1"),
+    FieldDef("varchar(20)", QVariant::String,	"blah2"),
+    FieldDef("nchar(20)", QVariant::String,	"blah3"),
+    FieldDef("nvarchar(20)", QVariant::String,	"blah4"),
+    FieldDef("text", QVariant::String,		"blah5"),
+    FieldDef("bit", QVariant::Int,			1, false),
+
+    FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+}
+
+void tst_QSqlDatabase::recordOCI()
+{
+    bool hasTimeStamp = false;
+
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    // runtime check for Oracle version since V8 doesn't support TIMESTAMPs
+    if (tst_Databases::getOraVersion(db) >= 9)
+        hasTimeStamp = true;
+
+    FieldDef tsdef;
+    FieldDef tstzdef;
+    FieldDef tsltzdef;
+    FieldDef intytm;
+    FieldDef intdts;
+
+    static const QDateTime dt(QDate::currentDate(), QTime(1, 2, 3, 0));
+
+    if (hasTimeStamp) {
+        tsdef = FieldDef("timestamp", QVariant::DateTime,  dt);
+        tstzdef = FieldDef("timestamp with time zone", QVariant::DateTime, dt);
+        tsltzdef = FieldDef("timestamp with local time zone", QVariant::DateTime, dt);
+        intytm = FieldDef("interval year to month", QVariant::String, QString("+01-01"));
+        intdts = FieldDef("interval day to second", QVariant::String, QString("+01 00:00:01.000000"));
+    }
+
+    const FieldDef fieldDefs[] = {
+        FieldDef("char(20)", QVariant::String,          QString("blah1")),
+        FieldDef("varchar(20)", QVariant::String,       QString("blah2")),
+        FieldDef("nchar(20)", QVariant::String,         QString("blah3")),
+        FieldDef("nvarchar2(20)", QVariant::String,     QString("blah4")),
+        FieldDef("number(10,5)", QVariant::Double,      1.1234567),
+        FieldDef("date", QVariant::DateTime,            dt),
+        FieldDef("long raw", QVariant::ByteArray,       QByteArray("blah5")),
+        FieldDef("raw(2000)", QVariant::ByteArray,      QByteArray("blah6"), false),
+        FieldDef("blob", QVariant::ByteArray,           QByteArray("blah7")),
+        FieldDef("clob", QVariant::String,             QString("blah8")),
+        FieldDef("nclob", QVariant::String,            QString("blah9")),
+//        FieldDef("bfile", QVariant::ByteArray,         QByteArray("blah10")),
+
+        intytm,
+        intdts,
+        tsdef,
+        tstzdef,
+        tsltzdef,
+        FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+
+    // some additional tests
+    QSqlRecord rec = db.record(qTableName("qtestfields", __FILE__));
+    QCOMPARE(rec.field("T_NUMBER").length(), 10);
+    QCOMPARE(rec.field("T_NUMBER").precision(), 5);
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("SELECT * FROM " + qTableName("qtestfields", __FILE__)));
+    rec = q.record();
+    QCOMPARE(rec.field("T_NUMBER").length(), 10);
+    QCOMPARE(rec.field("T_NUMBER").precision(), 5);
+}
+
+void tst_QSqlDatabase::recordPSQL()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    FieldDef byteadef;
+    if (db.driver()->hasFeature(QSqlDriver::BLOB))
+        byteadef = FieldDef("bytea", QVariant::ByteArray, QByteArray("bl\\ah"));
+    static FieldDef fieldDefs[] = {
+    FieldDef("bigint", QVariant::LongLong,	Q_INT64_C(9223372036854775807)),
+    FieldDef("bigserial", QVariant::LongLong, 100, false),
+    FieldDef("bit", QVariant::String,	"1"), // a bit in postgres is a bit-string
+    FieldDef("box", QVariant::String,	"(5,6),(1,2)"),
+    FieldDef("char(20)", QVariant::String, "blah5678901234567890"),
+    FieldDef("varchar(20)", QVariant::String, "blah5678901234567890"),
+    FieldDef("cidr", QVariant::String,	"12.123.0.0/24"),
+    FieldDef("circle", QVariant::String,	"<(1,2),3>"),
+    FieldDef("date", QVariant::Date,	QDate::currentDate()),
+    FieldDef("float8", QVariant::Double,	1.12345678912),
+    FieldDef("inet", QVariant::String,	"12.123.12.23"),
+    FieldDef("integer", QVariant::Int,	2147483647),
+    FieldDef("interval", QVariant::String, "1 day 12:59:10"),
+//	LOL... you can create a "line" datatype in PostgreSQL <= 7.2.x but
+//	as soon as you want to insert data you get a "not implemented yet" error
+//	FieldDef("line", QVariant::Polygon, QPolygon(QRect(1, 2, 3, 4))),
+    FieldDef("lseg", QVariant::String,     "[(1,1),(2,2)]"),
+    FieldDef("macaddr", QVariant::String, "08:00:2b:01:02:03"),
+    FieldDef("money", QVariant::String,	"$12.23"),
+    FieldDef("numeric", QVariant::Double,  1.2345678912),
+    FieldDef("path", QVariant::String,	"((1,2),(3,2),(3,5),(1,5))"),
+    FieldDef("point", QVariant::String,	"(1,2)"),
+    FieldDef("polygon", QVariant::String,	"((1,2),(3,2),(3,5),(1,5))"),
+    FieldDef("real", QVariant::Double,	1.1234),
+    FieldDef("smallint", QVariant::Int,	32767),
+    FieldDef("serial", QVariant::Int,	100, false),
+    FieldDef("text", QVariant::String,	"blah"),
+    FieldDef("time(6)", QVariant::Time,	QTime(1, 2, 3)),
+    FieldDef("timetz", QVariant::Time,	QTime(1, 2, 3)),
+    FieldDef("timestamp(6)", QVariant::DateTime, QDateTime::currentDateTime()),
+    FieldDef("timestamptz", QVariant::DateTime, QDateTime::currentDateTime()),
+    byteadef,
+
+    FieldDef()
+    };
+
+    QSqlQuery q(db);
+
+    if(tst_Databases::isPostgreSQL(db))
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+
+    q.exec("drop sequence " + qTableName("qtestfields", __FILE__) + "_t_bigserial_seq");
+    q.exec("drop sequence " + qTableName("qtestfields", __FILE__) + "_t_serial_seq");
+    // older psql cut off the table name
+    q.exec("drop sequence " + qTableName("qtestfields", __FILE__).left(15) + "_t_bigserial_seq");
+    q.exec("drop sequence " + qTableName("qtestfields", __FILE__).left(18) + "_t_serial_seq");
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+    for (int i = 0; i < ITERATION_COUNT; ++i) {
+    // increase serial values
+    for (int i2 = 0; !fieldDefs[ i2 ].typeName.isNull(); ++i2) {
+        if (fieldDefs[ i2 ].typeName == "serial" ||
+         fieldDefs[ i2 ].typeName == "bigserial") {
+
+        FieldDef def = fieldDefs[ i2 ];
+        def.val = def.val.toInt() + 1;
+        fieldDefs[ i2 ] = def;
+        }
+    }
+    }
+}
+
+void tst_QSqlDatabase::recordMySQL()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    FieldDef bin10, varbin10;
+    int major = tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt();
+    int minor = tst_Databases::getMySqlVersion( db ).section( QChar('.'), 1, 1 ).toInt();
+    int revision = tst_Databases::getMySqlVersion( db ).section( QChar('.'), 2, 2 ).toInt();
+    int vernum = (major << 16) + (minor << 8) + revision;
+
+    /* The below is broken in mysql below 5.0.15
+        see http://dev.mysql.com/doc/refman/5.0/en/binary-varbinary.html
+        specifically: Before MySQL 5.0.15, the pad value is space. Values are right-padded
+        with space on insert, and trailing spaces are removed on select.
+    */
+    if( vernum >= ((5 << 16) + 15) ) {
+        bin10 = FieldDef("binary(10)", QVariant::ByteArray, QString("123abc    "));
+        varbin10 = FieldDef("varbinary(10)", QVariant::ByteArray, QString("123abcv   "));
+    }
+
+    static QDateTime dt(QDate::currentDate(), QTime(1, 2, 3, 0));
+    static const FieldDef fieldDefs[] = {
+    FieldDef("tinyint", QVariant::Int,	    127),
+    FieldDef("tinyint unsigned", QVariant::UInt, 255),
+    FieldDef("smallint", QVariant::Int,	    32767),
+    FieldDef("smallint unsigned", QVariant::UInt, 65535),
+    FieldDef("mediumint", QVariant::Int,	    8388607),
+    FieldDef("mediumint unsigned", QVariant::UInt, 16777215),
+    FieldDef("integer", QVariant::Int,	    2147483647),
+    FieldDef("integer unsigned", QVariant::UInt, 4294967295u),
+    FieldDef("bigint", QVariant::LongLong,	    Q_INT64_C(9223372036854775807)),
+    FieldDef("bigint unsigned", QVariant::ULongLong, Q_UINT64_C(18446744073709551615)),
+    FieldDef("float", QVariant::Double,	    1.12345),
+    FieldDef("double", QVariant::Double,	    1.123456789),
+    FieldDef("decimal(10, 9)", QVariant::Double,1.123456789),
+    FieldDef("numeric(5, 2)", QVariant::Double, 123.67),
+    FieldDef("date", QVariant::Date,	    QDate::currentDate()),
+    FieldDef("datetime", QVariant::DateTime,   dt),
+    FieldDef("timestamp", QVariant::DateTime,  dt, false),
+    FieldDef("time", QVariant::Time,	    dt.time()),
+    FieldDef("year", QVariant::Int,	    2003),
+    FieldDef("char(20)", QVariant::String,	    "Blah"),
+    FieldDef("varchar(20)", QVariant::String,  "BlahBlah"),
+    FieldDef("tinytext", QVariant::String,    QString("blah5")),
+    FieldDef("text", QVariant::String,	    QString("blah6")),
+    FieldDef("mediumtext", QVariant::String,  QString("blah7")),
+    FieldDef("longtext", QVariant::String,    QString("blah8")),
+    // SET OF?
+
+    FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("SELECT DATE_SUB(CURDATE(), INTERVAL 2 DAY)"));
+    QVERIFY(q.next());
+    QCOMPARE(q.value(0).toDateTime().date(), QDate::currentDate().addDays(-2));
+}
+
+void tst_QSqlDatabase::recordDB2()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    static const FieldDef fieldDefs[] = {
+    FieldDef("char(20)", QVariant::String,		QString("Blah1")),
+    FieldDef("varchar(20)", QVariant::String,	QString("Blah2")),
+    FieldDef("long varchar", QVariant::String,	QString("Blah3")),
+    // using BOOLEAN results in "SQL0486N  The BOOLEAN data type is currently only supported internally."
+//X	FieldDef("boolean" , QVariant::Bool,		QVariant(true, 1)),
+    FieldDef("smallint", QVariant::Int,		32767),
+    FieldDef("integer", QVariant::Int,		2147483647),
+    FieldDef("bigint", QVariant::LongLong,		Q_INT64_C(9223372036854775807)),
+    FieldDef("real", QVariant::Double,		1.12345),
+    FieldDef("double", QVariant::Double,		1.23456789),
+    FieldDef("float", QVariant::Double,		1.23456789),
+    FieldDef("decimal(10,9)", QVariant::Double,    1.234567891),
+    FieldDef("numeric(10,9)", QVariant::Double,    1.234567891),
+    FieldDef("date", QVariant::Date,		QDate::currentDate()),
+    FieldDef("time", QVariant::Time,		QTime(1, 2, 3)),
+    FieldDef("timestamp", QVariant::DateTime,	QDateTime::currentDateTime()),
+//     FieldDef("graphic(20)", QVariant::String,	QString("Blah4")),
+//     FieldDef("vargraphic(20)", QVariant::String,	QString("Blah5")),
+//     FieldDef("long vargraphic", QVariant::String,	QString("Blah6")),
+    //X	FieldDef("datalink", QVariant::String,		QString("DLVALUE('Blah10')")),
+    FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+}
+
+void tst_QSqlDatabase::recordIBase()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    static const FieldDef fieldDefs[] = {
+        FieldDef("char(20)", QVariant::String, QString("Blah1"), false),
+        FieldDef("varchar(20)", QVariant::String, QString("Blah2")),
+        FieldDef("smallint", QVariant::Int, 32767),
+        FieldDef("float", QVariant::Double, 1.2345),
+        FieldDef("double precision", QVariant::Double, 1.2345678),
+        FieldDef("timestamp", QVariant::DateTime, QDateTime::currentDateTime()),
+        FieldDef("time", QVariant::Time, QTime::currentTime()),
+        FieldDef("decimal(18)", QVariant::LongLong, Q_INT64_C(9223372036854775807)),
+        FieldDef("numeric(5,2)", QVariant::Double, 123.45),
+
+        FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+}
+
+void tst_QSqlDatabase::recordSQLite()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    static const FieldDef fieldDefs[] = {
+        // The affinity of these fields are TEXT so SQLite should give us strings, not ints or doubles.
+        FieldDef("char(20)", QVariant::String,          QString("123")),
+        FieldDef("varchar(20)", QVariant::String,       QString("123.4")),
+        FieldDef("clob", QVariant::String,              QString("123.45")),
+        FieldDef("text", QVariant::String,              QString("123.456")),
+
+        FieldDef("integer", QVariant::Int,              QVariant(13)),
+        FieldDef("int", QVariant::Int,                  QVariant(12)),
+        FieldDef("real", QVariant::String,              QVariant(1.234567890123456)),
+
+        FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+}
+
+void tst_QSqlDatabase::recordSQLServer()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (!tst_Databases::isSqlServer(db)) {
+    QSKIP("SQL server specific test", SkipSingle);
+    return;
+    }
+
+    // ### TODO: Add the rest of the fields
+    static const FieldDef fieldDefs[] = {
+        FieldDef("varchar(20)", QVariant::String, QString("Blah1")),
+        FieldDef("bigint", QVariant::LongLong, 12345),
+        FieldDef("int", QVariant::Int, 123456),
+        FieldDef("tinyint", QVariant::UInt, 255),
+        FieldDef("float", QVariant::Double, 1.12345),
+        FieldDef("numeric(5,2)", QVariant::Double, 123.45),
+        FieldDef("uniqueidentifier", QVariant::String,
+            QString("AA7DF450-F119-11CD-8465-00AA00425D90")),
+
+        FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+}
+
+void tst_QSqlDatabase::recordAccess()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (!tst_Databases::isMSAccess(db)) {
+    QSKIP("MS Access specific test", SkipSingle);
+    return;
+    }
+
+    QString memo;
+    for (int i = 0; i < 32; i++)
+        memo.append("ABCDEFGH12345678abcdefgh12345678");
+
+    // ### TODO: Add the rest of the fields
+    static const FieldDef fieldDefs[] = {
+    FieldDef("varchar(20)", QVariant::String, QString("Blah1")),
+    FieldDef("single", QVariant::Double, 1.12345),
+    FieldDef("double", QVariant::Double, 1.123456),
+    FieldDef("byte", QVariant::UInt, 255),
+    FieldDef("long", QVariant::Int, 2147483647),
+        FieldDef("memo", QVariant::String, memo),
+    FieldDef()
+    };
+
+    const int fieldCount = createFieldTable(fieldDefs, db);
+    QVERIFY(fieldCount > 0);
+
+    commonFieldTest(fieldDefs, db, fieldCount);
+}
+
+void tst_QSqlDatabase::transaction()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    const QString qtest(qTableName("qtest", __FILE__));
+
+    if (!db.driver()->hasFeature(QSqlDriver::Transactions)) {
+    QSKIP("DBMS not transaction capable", SkipSingle);
+    }
+
+    QVERIFY(db.transaction());
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("insert into " + qtest + " values (40, 'VarChar40', 'Char40', 40.40)"));
+    QVERIFY_SQL(q, exec("select * from " + qtest + " where id = 40"));
+    QVERIFY(q.next());
+    QCOMPARE(q.value(0).toInt(), 40);
+    q.clear();
+
+    QVERIFY(db.commit());
+
+    QVERIFY(db.transaction());
+    QVERIFY_SQL(q, exec("select * from " + qtest + " where id = 40"));
+    QVERIFY(q.next());
+    QCOMPARE(q.value(0).toInt(), 40);
+    q.clear();
+    QVERIFY(db.commit());
+
+    QVERIFY(db.transaction());
+    QVERIFY_SQL(q, exec("insert into " + qtest + " values (41, 'VarChar41', 'Char41', 41.41)"));
+    QVERIFY_SQL(q, exec("select * from " + qtest + " where id = 41"));
+    QVERIFY(q.next());
+    QCOMPARE(q.value(0).toInt(), 41);
+    q.clear(); // for SQLite which does not allow any references on rows that shall be rolled back
+    if (!db.rollback()) {
+    if (db.driverName().startsWith("QMYSQL")) {
+        qDebug("MySQL: %s", qPrintable(tst_Databases::printError(db.lastError())));
+        QSKIP("MySQL transaction failed ", SkipSingle); //non-fatal
+    } else {
+        QFAIL("Could not rollback transaction: " + tst_Databases::printError(db.lastError()));
+        }
+    }
+
+    QVERIFY_SQL(q, exec("select * from " + qtest + " where id = 41"));
+    if(db.driverName().startsWith("QODBC") && dbName.contains("MySQL"))
+        QEXPECT_FAIL("", "Some odbc drivers don't actually roll back despite telling us they do, especially the mysql driver", Continue);
+    QVERIFY(!q.next());
+
+    populateTestTables(db);
+}
+
+void tst_QSqlDatabase::bigIntField()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    QString drvName = db.driverName();
+    const QString qtest_bigint(qTableName("qtest_bigint", __FILE__));
+
+    QSqlQuery q(db);
+    q.setForwardOnly(true);
+    if (drvName.startsWith("QOCI"))
+        q.setNumericalPrecisionPolicy(QSql::LowPrecisionInt64);
+
+    if (drvName.startsWith("QMYSQL")) {
+        QVERIFY_SQL(q, exec("create table " + qtest_bigint + " (id int, t_s64bit bigint, t_u64bit bigint unsigned)"));
+    } else if (drvName.startsWith("QPSQL")
+                || drvName.startsWith("QDB2")
+                || tst_Databases::isSqlServer(db)) {
+        QVERIFY_SQL(q, exec("create table " + qtest_bigint + "(id int, t_s64bit bigint, t_u64bit bigint)"));
+    } else if (drvName.startsWith("QOCI")) {
+        QVERIFY_SQL(q, exec("create table " + qtest_bigint + " (id int, t_s64bit int, t_u64bit int)"));
+    //} else if (drvName.startsWith("QIBASE")) {
+    //    QVERIFY_SQL(q, exec("create table " + qtest_bigint + " (id int, t_s64bit int64, t_u64bit int64)"));
+    } else {
+        QSKIP("no 64 bit integer support", SkipAll);
+    }
+    QVERIFY(q.prepare("insert into " + qtest_bigint + " values (?, ?, ?)"));
+    qlonglong ll = Q_INT64_C(9223372036854775807);
+    qulonglong ull = Q_UINT64_C(18446744073709551615);
+
+    if (drvName.startsWith("QMYSQL") || drvName.startsWith("QOCI")) {
+        q.bindValue(0, 0);
+        q.bindValue(1, ll);
+        q.bindValue(2, ull);
+        QVERIFY_SQL(q, exec());
+        q.bindValue(0, 1);
+        q.bindValue(1, -ll);
+        q.bindValue(2, ull);
+        QVERIFY_SQL(q, exec());
+    } else {
+        // usinged bigint fields not supported - a cast is necessary
+        q.bindValue(0, 0);
+        q.bindValue(1, ll);
+        q.bindValue(2, (qlonglong) ull);
+        QVERIFY_SQL(q, exec());
+        q.bindValue(0, 1);
+        q.bindValue(1, -ll);
+        q.bindValue(2,  (qlonglong) ull);
+        QVERIFY_SQL(q, exec());
+    }
+    QVERIFY(q.exec("select * from " + qtest_bigint + " order by id"));
+    QVERIFY(q.next());
+    QCOMPARE(q.value(1).toDouble(), (double)ll);
+    QCOMPARE(q.value(1).toLongLong(), ll);
+    if(drvName.startsWith("QOCI"))
+        QEXPECT_FAIL("", "Oracle driver lacks support for unsigned int64 types", Continue);
+    QCOMPARE(q.value(2).toULongLong(), ull);
+    QVERIFY(q.next());
+    QCOMPARE(q.value(1).toLongLong(), -ll);
+    if(drvName.startsWith("QOCI"))
+        QEXPECT_FAIL("", "Oracle driver lacks support for unsigned int64 types", Continue);
+    QCOMPARE(q.value(2).toULongLong(), ull);
+}
+
+void tst_QSqlDatabase::caseSensivity()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    bool cs = false;
+    if (db.driverName().startsWith("QMYSQL")
+     || db.driverName().startsWith("QSQLITE")
+     || db.driverName().startsWith("QTDS")
+     || db.driverName().startsWith("QODBC"))
+    cs = true;
+
+    QSqlRecord rec = db.record(qTableName("qtest", __FILE__));
+    QVERIFY((int)rec.count() > 0);
+    if (!cs) {
+    rec = db.record(qTableName("QTEST", __FILE__).toUpper());
+    QVERIFY((int)rec.count() > 0);
+    rec = db.record(qTableName("qTesT", __FILE__));
+    QVERIFY((int)rec.count() > 0);
+    }
+
+    rec = db.primaryIndex(qTableName("qtest", __FILE__));
+    QVERIFY((int)rec.count() > 0);
+    if (!cs) {
+    rec = db.primaryIndex(qTableName("QTEST", __FILE__).toUpper());
+    QVERIFY((int)rec.count() > 0);
+    rec = db.primaryIndex(qTableName("qTesT", __FILE__));
+    QVERIFY((int)rec.count() > 0);
+    }
+}
+
+void tst_QSqlDatabase::noEscapedFieldNamesInRecord()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QString fieldname("t_varchar");
+    if (db.driverName().startsWith("QOCI") || db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QDB2"))
+        fieldname = fieldname.toUpper();
+
+    QSqlQuery q(db);
+    QString query = "SELECT " + db.driver()->escapeIdentifier(fieldname, QSqlDriver::FieldName) + " FROM " + qTableName("qtest", __FILE__);
+    QVERIFY_SQL(q, exec(query));
+    QCOMPARE(q.record().fieldName(0), fieldname);
+}
+
+void tst_QSqlDatabase::psql_schemas()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (!db.tables(QSql::SystemTables).contains("pg_namespace"))
+        QSKIP("server does not support schemas", SkipSingle);
+
+    QSqlQuery q(db);
+
+    if(tst_Databases::isPostgreSQL(db)) {
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+    }
+
+    QVERIFY_SQL(q, exec("CREATE SCHEMA " + qTableName("qtestschema", __FILE__)));
+
+    QString table = qTableName("qtestschema", __FILE__) + '.' + qTableName("qtesttable", __FILE__);
+    QVERIFY_SQL(q, exec("CREATE TABLE " + table + " (id int primary key, name varchar(20))"));
+
+    QVERIFY(db.tables().contains(table));
+
+    QSqlRecord rec = db.record(table);
+    QCOMPARE(rec.count(), 2);
+    QCOMPARE(rec.fieldName(0), QString("id"));
+    QCOMPARE(rec.fieldName(1), QString("name"));
+
+    QSqlIndex idx = db.primaryIndex(table);
+    QCOMPARE(idx.count(), 1);
+    QCOMPARE(idx.fieldName(0), QString("id"));
+}
+
+void tst_QSqlDatabase::psql_escapedIdentifiers()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    QSqlDriver* drv = db.driver();
+    CHECK_DATABASE(db);
+
+    if (!db.tables(QSql::SystemTables).contains("pg_namespace"))
+        QSKIP("server does not support schemas", SkipSingle);
+
+    QSqlQuery q(db);
+
+    if(tst_Databases::isPostgreSQL(db))
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+
+    const QString schemaName(qTableName("qtestScHeMa", __FILE__)),
+                  tableName(qTableName("qtest", __FILE__)),
+                  field1Name(QLatin1String("fIeLdNaMe")),
+                  field2Name(QLatin1String("ZuLu"));
+
+    q.exec(QString("DROP SCHEMA \"%1\" CASCADE").arg(schemaName));
+    QString createSchema = QString("CREATE SCHEMA \"%1\"").arg(schemaName);
+    QVERIFY_SQL(q, exec(createSchema));
+    QString createTable = QString("CREATE TABLE \"%1\".\"%2\" (\"%3\" int PRIMARY KEY, \"%4\" varchar(20))").arg(schemaName).arg(tableName).arg(field1Name).arg(field2Name);
+    QVERIFY_SQL(q, exec(createTable));
+
+    QVERIFY(db.tables().contains(schemaName + '.' + tableName, Qt::CaseSensitive));
+
+    QSqlField fld1(field1Name, QVariant::Int);
+    QSqlField fld2(field2Name, QVariant::String);
+    QSqlRecord rec;
+    rec.append(fld1);
+    rec.append(fld2);
+
+    QVERIFY_SQL(q, exec(drv->sqlStatement(QSqlDriver::SelectStatement, db.driver()->escapeIdentifier(schemaName, QSqlDriver::TableName) + '.' + db.driver()->escapeIdentifier(tableName, QSqlDriver::TableName), rec, false)));
+
+    rec = q.record();
+    QCOMPARE(rec.count(), 2);
+    QCOMPARE(rec.fieldName(0), field1Name);
+    QCOMPARE(rec.fieldName(1), field2Name);
+    QCOMPARE(rec.field(0).type(), QVariant::Int);
+
+    q.exec(QString("DROP SCHEMA \"%1\" CASCADE").arg(schemaName));
+}
+
+void tst_QSqlDatabase::psql_escapeBytea()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    const char dta[4] = {'\x71', '\x14', '\x32', '\x81'};
+    QByteArray ba(dta, 4);
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("batable", __FILE__));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (ba bytea)").arg(tableName)));
+
+    QSqlQuery iq(db);
+    QVERIFY_SQL(iq, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName)));
+    iq.bindValue(0, QVariant(ba));
+    QVERIFY_SQL(iq, exec());
+
+    QVERIFY_SQL(q, exec(QString("SELECT ba FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, next());
+
+    QByteArray res = q.value(0).toByteArray();
+    int i = 0;
+    for (; i < ba.size(); ++i){
+        if (ba[i] != res[i])
+            break;
+    }
+
+    QCOMPARE(i, 4);
+}
+
+void tst_QSqlDatabase::bug_249059()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QString version=tst_Databases::getPSQLVersion( db );
+    double ver=version.section(QChar::fromLatin1('.'),0,1).toDouble();
+    if (ver < 7.3)
+        QSKIP("Test requires PostgreSQL >= 7.3", SkipSingle);
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("bug_249059", __FILE__));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (dt timestamp, t time)").arg(tableName)));
+
+    QSqlQuery iq(db);
+    QVERIFY_SQL(iq, prepare(QString("INSERT INTO %1 VALUES (?, ?)").arg(tableName)));
+    iq.bindValue(0, QVariant(QString("2001-09-09 04:05:06.789 -5:00")));
+    iq.bindValue(1, QVariant(QString("04:05:06.789 -5:00")));
+    QVERIFY_SQL(iq, exec());
+    iq.bindValue(0, QVariant(QString("2001-09-09 04:05:06.789 +5:00")));
+    iq.bindValue(1, QVariant(QString("04:05:06.789 +5:00")));
+    QVERIFY_SQL(iq, exec());
+
+    QVERIFY_SQL(q, exec(QString("SELECT dt, t FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, next());
+    QDateTime dt1=q.value(0).toDateTime();
+    QTime t1=q.value(1).toTime();
+    QVERIFY_SQL(q, next());
+    QDateTime dt2=q.value(0).toDateTime();
+    QTime t2=q.value(1).toTime();
+
+    // These will fail when timezone support is added, when that's the case, set the second record to 14:05:06.789 and it should work correctly
+    QCOMPARE(dt1, dt2);
+    QCOMPARE(t1, t2);
+}
+
+// This test should be rewritten to work with Oracle as well - or the Oracle driver
+// should be fixed to make this test pass (handle overflows)
+void tst_QSqlDatabase::precisionPolicy()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+//     DBMS_SPECIFIC(db, "QPSQL");
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("qtest_prec", __FILE__));
+    if(!db.driver()->hasFeature(QSqlDriver::LowPrecisionNumbers))
+        QSKIP("Driver or database doesn't support setting precision policy", SkipSingle);
+
+    // Create a test table with some data
+    if(tst_Databases::isMSAccess(db))
+        QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id smallint, num number)").arg(tableName)));
+    else
+        QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id smallint, num numeric(18,5))").arg(tableName)));
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?)").arg(tableName)));
+    q.bindValue(0, 1);
+    q.bindValue(1, 123);
+    QVERIFY_SQL(q, exec());
+    q.bindValue(0, 2);
+    q.bindValue(1, 1850000000000.0001);
+    QVERIFY_SQL(q, exec());
+
+    // These are expected to pass
+    q.setNumericalPrecisionPolicy(QSql::HighPrecision);
+    QString query = QString("SELECT num FROM %1 WHERE id = 1").arg(tableName);
+    QVERIFY_SQL(q, exec(query));
+    QVERIFY_SQL(q, next());
+    if(db.driverName().startsWith("QSQLITE"))
+        QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
+    QCOMPARE(q.value(0).type(), QVariant::String);
+
+    q.setNumericalPrecisionPolicy(QSql::LowPrecisionInt64);
+    QVERIFY_SQL(q, exec(query));
+    QVERIFY_SQL(q, next());
+    if(q.value(0).type() != QVariant::LongLong)
+        QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
+    QCOMPARE(q.value(0).type(), QVariant::LongLong);
+    QCOMPARE(q.value(0).toLongLong(), (qlonglong)123);
+
+    q.setNumericalPrecisionPolicy(QSql::LowPrecisionInt32);
+    QVERIFY_SQL(q, exec(query));
+    if(db.driverName().startsWith("QOCI"))
+        QEXPECT_FAIL("", "Oracle fails to move to next when data columns are oversize", Abort);
+    QVERIFY_SQL(q, next());
+    if(db.driverName().startsWith("QSQLITE"))
+        QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
+    QCOMPARE(q.value(0).type(), QVariant::Int);
+    QCOMPARE(q.value(0).toInt(), 123);
+
+    q.setNumericalPrecisionPolicy(QSql::LowPrecisionDouble);
+    QVERIFY_SQL(q, exec(query));
+    QVERIFY_SQL(q, next());
+    if(db.driverName().startsWith("QSQLITE"))
+        QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
+    QCOMPARE(q.value(0).type(), QVariant::Double);
+    QCOMPARE(q.value(0).toDouble(), (double)123);
+
+    query = QString("SELECT num FROM %1 WHERE id = 2").arg(tableName);
+    QVERIFY_SQL(q, exec(query));
+    QVERIFY_SQL(q, next());
+    if(db.driverName().startsWith("QSQLITE"))
+        QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
+    QCOMPARE(q.value(0).type(), QVariant::Double);
+    QCOMPARE(q.value(0).toDouble(), QString("1850000000000.0001").toDouble());
+
+    // Postgres returns invalid QVariants on overflow
+    q.setNumericalPrecisionPolicy(QSql::HighPrecision);
+    QVERIFY_SQL(q, exec(query));
+    QVERIFY_SQL(q, next());
+    if(db.driverName().startsWith("QSQLITE"))
+        QEXPECT_FAIL("", "SQLite returns this value as determined by contents of the field, not the declaration", Continue);
+    QCOMPARE(q.value(0).type(), QVariant::String);
+
+    q.setNumericalPrecisionPolicy(QSql::LowPrecisionInt64);
+    QEXPECT_FAIL("QOCI", "Oracle fails here, to retrieve next", Continue);
+    QVERIFY_SQL(q, exec(query));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).type(), QVariant::LongLong);
+
+    QSql::NumericalPrecisionPolicy oldPrecision= db.numericalPrecisionPolicy();
+    db.setNumericalPrecisionPolicy(QSql::LowPrecisionInt64);
+    QSqlQuery q2(db);
+    q2.exec(QString("SELECT num FROM %1 WHERE id = 2").arg(tableName));
+    QVERIFY_SQL(q2, exec(query));
+    QVERIFY_SQL(q2, next());
+    QCOMPARE(q2.value(0).type(), QVariant::LongLong);
+    db.setNumericalPrecisionPolicy(oldPrecision);
+}
+
+// This test needs a ODBC data source containing MYSQL in it's name
+void tst_QSqlDatabase::mysqlOdbc_unsignedIntegers()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (!db.driverName().startsWith("QODBC") || !dbName.toUpper().contains("MYSQL")) {
+       QSKIP("MySQL through ODBC-driver specific test", SkipSingle);
+       return;
+    }
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("uint", __FILE__));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (foo integer(10) unsigned, bar integer(10))").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 VALUES (-4000000000, -4000000000)").arg(tableName)));
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 VALUES (4000000000, 4000000000)").arg(tableName)));
+
+    QVERIFY_SQL(q, exec(QString("SELECT foo, bar FROM %1").arg(tableName)));
+    QVERIFY(q.next());
+    QCOMPARE(q.value(0).toString(), QString("0"));
+    QCOMPARE(q.value(1).toString(), QString("-2147483648"));
+    QVERIFY(q.next());
+    QCOMPARE(q.value(0).toString(), QString("4000000000"));
+    QCOMPARE(q.value(1).toString(), QString("2147483647"));
+}
+
+void tst_QSqlDatabase::accessOdbc_strings()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (!tst_Databases::isMSAccess(db)) {
+    QSKIP("MS Access specific test", SkipSingle);
+    return;
+    }
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("strings", __FILE__));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (aStr memo, bStr memo, cStr memo, dStr memo"
+            ", eStr memo, fStr memo, gStr memo, hStr memo)").arg(tableName)));
+
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?, ?, ?, ?, ?, ?, ?)").arg(tableName)));
+    QString aStr, bStr, cStr, dStr, eStr, fStr, gStr, hStr;
+
+    q.bindValue(0, aStr.fill('A', 32));
+    q.bindValue(1, bStr.fill('B', 127));
+    q.bindValue(2, cStr.fill('C', 128));
+    q.bindValue(3, dStr.fill('D', 129));
+    q.bindValue(4, eStr.fill('E', 254));
+    q.bindValue(5, fStr.fill('F', 255));
+    q.bindValue(6, gStr.fill('G', 256));
+    q.bindValue(7, hStr.fill('H', 512));
+
+    QVERIFY_SQL(q, exec());
+
+    QVERIFY_SQL(q, exec(QString("SELECT aStr, bStr, cStr, dStr, eStr, fStr, gStr, hStr FROM %1").arg(tableName)));
+    q.next();
+    QCOMPARE(q.value(0).toString(), aStr);
+    QCOMPARE(q.value(1).toString(), bStr);
+    QCOMPARE(q.value(2).toString(), cStr);
+    QCOMPARE(q.value(3).toString(), dStr);
+    QCOMPARE(q.value(4).toString(), eStr);
+    QCOMPARE(q.value(5).toString(), fStr);
+    QCOMPARE(q.value(6).toString(), gStr);
+    QCOMPARE(q.value(7).toString(), hStr);
+}
+
+// For task 125053
+void tst_QSqlDatabase::ibase_numericFields()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("numericfields", __FILE__));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (id int not null, num1 NUMERIC(2,1), "
+        "num2 NUMERIC(5,2), num3 NUMERIC(10,3), "
+        "num4 NUMERIC(18,4))").arg(tableName)));
+
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 VALUES (1, 1.1, 123.45, 1234567.123, 10203040506070.8090)").arg(tableName)));
+
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?, ?, ?, ?, ?)").arg(tableName)));
+
+    double num1 = 1.1;
+    double num2 = 123.45;
+    double num3 = 1234567.123;
+    double num4 = 10203040506070.8090;
+
+    q.bindValue(0, 2);
+    q.bindValue(1, QVariant(num1));
+    q.bindValue(2, QVariant(num2));
+    q.bindValue(3, QVariant(num3));
+    q.bindValue(4, QVariant(num4));
+    QVERIFY_SQL(q, exec());
+
+    QVERIFY_SQL(q, exec(QString("SELECT id, num1, num2, num3, num4 FROM %1").arg(tableName)));
+
+    int id = 0;
+    while (q.next()) {
+        QCOMPARE(q.value(0).toInt(), ++id);
+        QCOMPARE(q.value(1).toString(), QString("%1").arg(num1));
+        QCOMPARE(q.value(2).toString(), QString("%1").arg(num2));
+        QCOMPARE(QString("%1").arg(q.value(3).toDouble()), QString("%1").arg(num3));
+        QCOMPARE(QString("%1").arg(q.value(4).toDouble()), QString("%1").arg(num4));
+        QVERIFY(q.value(0).type() == QVariant::Int);
+        QVERIFY(q.value(1).type() == QVariant::Double);
+        QVERIFY(q.value(2).type() == QVariant::Double);
+        QVERIFY(q.value(3).type() == QVariant::Double);
+        QVERIFY(q.value(4).type() == QVariant::Double);
+
+        QCOMPARE(q.record().field(1).length(), 2);
+        QCOMPARE(q.record().field(1).precision(), 1);
+        QCOMPARE(q.record().field(2).length(), 5);
+        QCOMPARE(q.record().field(2).precision(), 2);
+        QCOMPARE(q.record().field(3).length(), 10);
+        QCOMPARE(q.record().field(3).precision(), 3);
+        QCOMPARE(q.record().field(4).length(), 18);
+        QCOMPARE(q.record().field(4).precision(), 4);
+        QVERIFY(q.record().field(0).requiredStatus() == QSqlField::Required);
+        QVERIFY(q.record().field(1).requiredStatus() == QSqlField::Optional);
+    }
+
+    QSqlRecord r = db.record(tableName);
+    QVERIFY(r.field(0).type() == QVariant::Int);
+    QVERIFY(r.field(1).type() == QVariant::Double);
+    QVERIFY(r.field(2).type() == QVariant::Double);
+    QVERIFY(r.field(3).type() == QVariant::Double);
+    QVERIFY(r.field(4).type() == QVariant::Double);
+    QCOMPARE(r.field(1).length(), 2);
+    QCOMPARE(r.field(1).precision(), 1);
+    QCOMPARE(r.field(2).length(), 5);
+    QCOMPARE(r.field(2).precision(), 2);
+    QCOMPARE(r.field(3).length(), 10);
+    QCOMPARE(r.field(3).precision(), 3);
+    QCOMPARE(r.field(4).length(), 18);
+    QCOMPARE(r.field(4).precision(), 4);
+    QVERIFY(r.field(0).requiredStatus() == QSqlField::Required);
+    QVERIFY(r.field(1).requiredStatus() == QSqlField::Optional);
+}
+
+void tst_QSqlDatabase::ibase_fetchBlobs()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    const QString tableName(qTableName("qtest_ibaseblobs", __FILE__));
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1 (blob1 BLOB segment size 256)").arg(tableName)));
+
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName)));
+    q.bindValue(0, QByteArray().fill('x', 1024));
+    QVERIFY_SQL(q, exec());
+
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName)));
+    q.bindValue(0, QByteArray().fill('x', 16383));
+    QVERIFY_SQL(q, exec());
+
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES (?)").arg(tableName)));
+    q.bindValue(0, QByteArray().fill('x', 17408));
+    QVERIFY_SQL(q, exec());
+
+    QVERIFY_SQL(q, exec(QString("SELECT * FROM %1").arg(tableName)));
+
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toByteArray().size(), 1024);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toByteArray().size(), 16383);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toByteArray().size(), 17408);
+}
+
+void tst_QSqlDatabase::ibase_procWithoutReturnValues()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQuery q(db);
+    const QString procName(qTableName("qtest_proc1", __FILE__));
+    q.exec(QString("drop procedure %1").arg(procName));
+    QVERIFY_SQL(q, exec("CREATE PROCEDURE " + procName + " (str VARCHAR(10))\nAS BEGIN\nstr='test';\nEND;"));
+    QVERIFY_SQL(q, exec(QString("execute procedure %1('qtest')").arg(procName)));
+    q.exec(QString("drop procedure %1").arg(procName));
+}
+
+void tst_QSqlDatabase::ibase_procWithReturnValues()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (!db.driverName().startsWith("QIBASE")) {
+       QSKIP("InterBase specific test", SkipSingle);
+       return;
+    }
+
+    const QString procName(qTableName("qtest_proc2", __FILE__));
+
+    QSqlQuery q(db);
+    q.exec(QString("drop procedure %1").arg(procName));
+    QVERIFY_SQL(q, exec("CREATE PROCEDURE " + procName + " ("
+                        "\nABC INTEGER)"
+                        "\nRETURNS ("
+                        "\nRESULT INTEGER)"
+                        "\nAS"
+                        "\nbegin"
+                        "\nRESULT = 10 * ABC;"
+                        "\nsuspend;"
+                        "\nend"));
+
+    // Interbase procedures can be executed in two ways: EXECUTE PROCEDURE or SELECT
+    QVERIFY_SQL(q, exec(QString("execute procedure %1(123)").arg(procName)));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 1230);
+    QVERIFY_SQL(q, exec(QString("select result from %1(456)").arg(procName)));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 4560);
+    QVERIFY_SQL(q, prepare(QLatin1String("execute procedure ")+procName+QLatin1String("(?)")));
+    q.bindValue(0, 123);
+    QVERIFY_SQL(q, exec());
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 1230);
+    q.bindValue(0, 456);
+    QVERIFY_SQL(q, exec());
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 4560);
+
+    q.exec(QString("drop procedure %1").arg(procName));
+}
+
+void tst_QSqlDatabase::formatValueTrimStrings()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQuery q(db);
+
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 (id, t_varchar, t_char) values (50, 'Trim Test ', 'Trim Test 2   ')").arg(qTableName("qtest", __FILE__))));
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 (id, t_varchar, t_char) values (51, 'TrimTest', 'Trim Test 2')").arg(qTableName("qtest", __FILE__))));
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 (id, t_varchar, t_char) values (52, ' ', '    ')").arg(qTableName("qtest", __FILE__))));
+
+    QVERIFY_SQL(q, exec(QString("SELECT t_varchar, t_char FROM %1 WHERE id >= 50 AND id <= 52 ORDER BY id").arg(qTableName("qtest", __FILE__))));
+
+    QVERIFY_SQL(q, next());
+
+    QCOMPARE(db.driver()->formatValue(q.record().field(0), true), QString("'Trim Test'"));
+    QCOMPARE(db.driver()->formatValue(q.record().field(1), true), QString("'Trim Test 2'"));
+
+    QVERIFY_SQL(q, next());
+    QCOMPARE(db.driver()->formatValue(q.record().field(0), true), QString("'TrimTest'"));
+    QCOMPARE(db.driver()->formatValue(q.record().field(1), true), QString("'Trim Test 2'"));
+
+    QVERIFY_SQL(q, next());
+    QCOMPARE(db.driver()->formatValue(q.record().field(0), true), QString("''"));
+    QCOMPARE(db.driver()->formatValue(q.record().field(1), true), QString("''"));
+
+}
+
+void tst_QSqlDatabase::odbc_reopenDatabase()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("SELECT * from " + qTableName("qtest", __FILE__)));
+    QVERIFY_SQL(q, next());
+    db.open();
+    QVERIFY_SQL(q, exec("SELECT * from " + qTableName("qtest", __FILE__)));
+    QVERIFY_SQL(q, next());
+    db.open();
+}
+
+void tst_QSqlDatabase::odbc_bindBoolean()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (tst_Databases::isMySQL(db)) {
+        QSKIP("MySql has inconsistent behaviour of bit field type across versions.", SkipSingle);
+        return;
+    }
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("CREATE TABLE " + qTableName("qtestBindBool", __FILE__) + "(id int, boolvalue bit)"));
+
+    // Bind and insert
+    QVERIFY_SQL(q, prepare("INSERT INTO " + qTableName("qtestBindBool", __FILE__) + " VALUES(?, ?)"));
+    q.bindValue(0, 1);
+    q.bindValue(1, true);
+    QVERIFY_SQL(q, exec());
+    q.bindValue(0, 2);
+    q.bindValue(1, false);
+    QVERIFY_SQL(q, exec());
+
+    // Retrive
+    QVERIFY_SQL(q, exec("SELECT id, boolvalue FROM " + qTableName("qtestBindBool", __FILE__) + " ORDER BY id"));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 1);
+    QCOMPARE(q.value(1).toBool(), true);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 2);
+    QCOMPARE(q.value(1).toBool(), false);
+}
+
+void tst_QSqlDatabase::odbc_testqGetString()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    const QString testqGetString(qTableName("testqGetString", __FILE__));
+
+    QSqlQuery q(db);
+    if (tst_Databases::isSqlServer(db))
+        QVERIFY_SQL(q, exec("CREATE TABLE " + testqGetString + "(id int, vcvalue varchar(MAX))"));
+    else if(tst_Databases::isMSAccess(db))
+        QVERIFY_SQL(q, exec("CREATE TABLE " + testqGetString + "(id int, vcvalue memo)"));
+    else
+        QVERIFY_SQL(q, exec("CREATE TABLE " + testqGetString + "(id int, vcvalue varchar(65538))"));
+
+    QString largeString;
+    largeString.fill('A', 65536);
+
+    // Bind and insert
+    QVERIFY_SQL(q, prepare("INSERT INTO " + testqGetString + " VALUES(?, ?)"));
+    q.bindValue(0, 1);
+    q.bindValue(1, largeString);
+    QVERIFY_SQL(q, exec());
+    q.bindValue(0, 2);
+    q.bindValue(1, largeString+QLatin1Char('B'));
+    QVERIFY_SQL(q, exec());
+    q.bindValue(0, 3);
+    q.bindValue(1, largeString+QLatin1Char('B')+QLatin1Char('C'));
+    QVERIFY_SQL(q, exec());
+
+    // Retrive
+    QVERIFY_SQL(q, exec("SELECT id, vcvalue FROM " + testqGetString + " ORDER BY id"));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 1);
+    QCOMPARE(q.value(1).toString().length(), 65536);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 2);
+    QCOMPARE(q.value(1).toString().length(), 65537);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 3);
+    QCOMPARE(q.value(1).toString().length(), 65538);
+}
+
+
+void tst_QSqlDatabase::mysql_multiselect()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    const QString qtest(qTableName("qtest", __FILE__));
+
+    QSqlQuery q(db);
+    QString version=tst_Databases::getMySqlVersion( db );
+    double ver=version.section(QChar::fromLatin1('.'),0,1).toDouble();
+    if (ver < 4.1)
+        QSKIP("Test requires MySQL >= 4.1", SkipSingle);
+
+    QVERIFY_SQL(q, exec("SELECT * FROM " + qtest + "; SELECT * FROM " + qtest));
+    QVERIFY_SQL(q, next());
+    QVERIFY_SQL(q, exec("SELECT * FROM " + qtest + "; SELECT * FROM " + qtest));
+    QVERIFY_SQL(q, next());
+    QVERIFY_SQL(q, exec("SELECT * FROM " + qtest));
+}
+
+void tst_QSqlDatabase::ibase_useCustomCharset()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    QString nonlatin1string("��");
+
+    db.close();
+    db.setConnectOptions("ISC_DPB_LC_CTYPE=Latin1");
+    db.open();
+
+    const QString tableName(qTableName("latin1table", __FILE__));
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(text VARCHAR(6) CHARACTER SET Latin1)").arg(tableName)));
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName)));
+    q.addBindValue(nonlatin1string);
+    QVERIFY_SQL(q, exec());
+    QVERIFY_SQL(q, exec(QString("SELECT text FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(toHex(q.value(0).toString()), toHex(nonlatin1string));
+}
+
+void tst_QSqlDatabase::oci_serverDetach()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    for (int i = 0; i < 2; i++) {
+        db.close();
+        if (db.open()) {
+            QSqlQuery query(db);
+            query.exec("SELECT 1 FROM DUAL");
+            db.close();
+        } else {
+            QFAIL(tst_Databases::printError(db.lastError(), db));
+        }
+    }
+    if(!db.open())
+        qFatal("%s", qPrintable(tst_Databases::printError(db.lastError(), db)));
+}
+
+void tst_QSqlDatabase::oci_xmltypeSupport()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    const QString tableName(qTableName("qtest_xmltype", __FILE__));
+    QString xml("<?xml version=\"1.0\"?><TABLE_NAME>MY_TABLE</TABLE_NAME>");
+    QSqlQuery q(db);
+
+    // Embedding the XML in the statement
+    if(!q.exec(QString("CREATE TABLE %1(xmldata xmltype)").arg(tableName)))
+        QSKIP("This test requries xml type support", SkipSingle);
+    QVERIFY_SQL(q, exec(QString("INSERT INTO %1 values('%2')").arg(tableName).arg(xml)));
+    QVERIFY_SQL(q, exec(QString("SELECT a.xmldata.getStringVal() FROM %1 a").arg(tableName)));
+    QVERIFY_SQL(q, last());
+    QCOMPARE(q.value(0).toString(), xml);
+
+    // Binding the XML with a prepared statement
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 values(?)").arg(tableName)));
+    q.addBindValue(xml);
+    QVERIFY_SQL(q, exec());
+    QVERIFY_SQL(q, exec(QString("SELECT a.xmldata.getStringVal() FROM %1 a").arg(tableName)));
+    QVERIFY_SQL(q, last());
+    QCOMPARE(q.value(0).toString(), xml);
+}
+
+
+void tst_QSqlDatabase::oci_fieldLength()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    const QString tableName(qTableName("qtest", __FILE__));
+    QSqlQuery q(db);
+
+    QVERIFY_SQL(q, exec(QString("SELECT t_varchar, t_char FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.record().field(0).length(), 40);
+    QCOMPARE(q.record().field(1).length(), 40);
+}
+
+void tst_QSqlDatabase::oci_synonymstest()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQuery q(db);
+    const QString creator(qTableName("CREATOR", __FILE__)), appuser(qTableName("APPUSER", __FILE__)), table1(qTableName("TABLE1", __FILE__));
+//     QVERIFY_SQL(q, exec("drop public synonym "+table1));
+    QVERIFY_SQL(q, exec(QString("create user %1 identified by %2 default tablespace users temporary tablespace temp").arg(creator).arg(creator)));
+    QVERIFY_SQL(q, exec(QString("grant CONNECT to %1").arg(creator)));
+    QVERIFY_SQL(q, exec(QString("grant RESOURCE to %1").arg(creator)));
+    QSqlDatabase db2=db.cloneDatabase(db, QLatin1String("oci_synonymstest"));
+    db2.close();
+    QVERIFY_SQL(db2, open(creator,creator));
+    QSqlQuery q2(db2);
+    QVERIFY_SQL(q2, exec(QString("create table %1(id int primary key)").arg(table1)));
+    QVERIFY_SQL(q, exec(QString("create user %1 identified by %2 default tablespace users temporary tablespace temp").arg(appuser).arg(appuser)));
+    QVERIFY_SQL(q, exec(QString("grant CREATE ANY SYNONYM to %1").arg(appuser)));
+    QVERIFY_SQL(q, exec(QString("grant CONNECT to %1").arg(appuser)));
+    QVERIFY_SQL(q2, exec(QString("grant select, insert, update, delete on %1 to %2").arg(table1).arg(appuser)));
+    QSqlDatabase db3=db.cloneDatabase(db, QLatin1String("oci_synonymstest2"));
+    db3.close();
+    QVERIFY_SQL(db3, open(appuser,appuser));
+    QSqlQuery q3(db3);
+    QVERIFY_SQL(q3, exec("create synonym "+appuser+'.'+qTableName("synonyms", __FILE__)+" for "+creator+'.'+table1));
+    QVERIFY_SQL(db3, tables().filter(qTableName("synonyms", __FILE__), Qt::CaseInsensitive).count() >= 1);
+}
+
+
+// This test isn't really necessary as SQL_GUID / uniqueidentifier is
+// already tested in recordSQLServer().
+void tst_QSqlDatabase::odbc_uniqueidentifier()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    if (!tst_Databases::isSqlServer(db)) {
+        QSKIP("SQL Server (ODBC) specific test", SkipSingle);
+        return;
+    }
+
+    const QString tableName(qTableName("qtest_sqlguid", __FILE__));
+    QString guid = QString("AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE");
+    QString invalidGuid = QString("GAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE");
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(id uniqueidentifier)").arg(tableName)));
+
+    q.prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName));;
+    q.addBindValue(guid);
+    QVERIFY_SQL(q, exec());
+
+    q.addBindValue(invalidGuid);
+    QEXPECT_FAIL("", "The GUID string is required to be correctly formated!",
+        Continue);
+    QVERIFY_SQL(q, exec());
+
+    QVERIFY_SQL(q, exec(QString("SELECT id FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toString(), guid);
+}
+
+void tst_QSqlDatabase::getConnectionName()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QCOMPARE(db.connectionName(), dbName);
+    QSqlDatabase clone = QSqlDatabase::cloneDatabase(db, "clonedDatabase");
+    QCOMPARE(clone.connectionName(), QString("clonedDatabase"));
+    QTest::ignoreMessage(QtWarningMsg, "QSqlDatabasePrivate::removeDatabase: "
+        "connection 'clonedDatabase' is still in use, all queries will cease to work.");
+    QSqlDatabase::removeDatabase("clonedDatabase");
+    QCOMPARE(clone.connectionName(), QString());
+    QCOMPARE(db.connectionName(), dbName);
+}
+
+void tst_QSqlDatabase::odbc_uintfield()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    const QString tableName(qTableName("uint_table", __FILE__));
+    unsigned int val = 4294967295U;
+
+    QSqlQuery q(db);
+    if ( tst_Databases::isMSAccess( db ) )
+        QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num number)").arg(tableName)));
+    else
+        QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(num numeric(10))").arg(tableName)));
+    q.prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName));
+    q.addBindValue(val);
+    QVERIFY_SQL(q, exec());
+
+    q.exec(QString("SELECT num FROM %1").arg(tableName));
+    if (q.next())
+        QCOMPARE(q.value(0).toUInt(), val);
+}
+
+void tst_QSqlDatabase::eventNotification()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlDriver *driver = db.driver();
+    if (!driver->hasFeature(QSqlDriver::EventNotifications))
+        QSKIP("DBMS doesn't support event notifications", SkipSingle);
+
+    // Not subscribed to any events yet
+    QCOMPARE(driver->subscribedToNotifications().size(), 0);
+
+    // Subscribe to "event_foo"
+    QVERIFY_SQL(*driver, subscribeToNotification(QLatin1String("event_foo")));
+    QCOMPARE(driver->subscribedToNotifications().size(), 1);
+    QVERIFY(driver->subscribedToNotifications().contains("event_foo"));
+
+    // Can't subscribe to the same event multiple times
+    QVERIFY2(!driver->subscribeToNotification(QLatin1String("event_foo")), "Shouldn't be able to subscribe to event_foo twice");
+    QCOMPARE(driver->subscribedToNotifications().size(), 1);
+
+    // Unsubscribe from "event_foo"
+    QVERIFY_SQL(*driver, unsubscribeFromNotification(QLatin1String("event_foo")));
+    QCOMPARE(driver->subscribedToNotifications().size(), 0);
+
+    // Re-subscribing to "event_foo" now is allowed
+    QVERIFY_SQL(*driver, subscribeToNotification(QLatin1String("event_foo")));
+    QCOMPARE(driver->subscribedToNotifications().size(), 1);
+
+    // closing the connection causes automatically unsubscription from all events
+    db.close();
+    QCOMPARE(driver->subscribedToNotifications().size(), 0);
+
+    // Can't subscribe to anything while database is closed
+    QVERIFY2(!driver->subscribeToNotification(QLatin1String("event_foo")), "Shouldn't be able to subscribe to event_foo");
+    QCOMPARE(driver->subscribedToNotifications().size(), 0);
+
+    db.open();
+}
+
+void tst_QSqlDatabase::eventNotificationIBase()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    const QString procedureName(qTableName("posteventProc", __FILE__));
+    QSqlDriver *driver=db.driver();
+    QVERIFY_SQL(*driver, subscribeToNotification(procedureName));
+    QTest::qWait(300);  // Interbase needs some time to call the driver callback.
+
+    db.transaction();   // InterBase events are posted from within transactions.
+    QSqlQuery q(db);
+    q.exec(QString("DROP PROCEDURE %1").arg(procedureName));
+    q.exec(QString("CREATE PROCEDURE %1\nAS BEGIN\nPOST_EVENT '%1';\nEND;").arg(procedureName));
+    q.exec(QString("EXECUTE PROCEDURE %1").arg(procedureName));
+    QSignalSpy spy(driver, SIGNAL(notification(const QString&)));
+    db.commit();        // No notifications are posted until the transaction is committed.
+    QTest::qWait(300);  // Interbase needs some time to post the notification and call the driver callback.
+                        // This happends from another thread, and we have to process events in order for the
+                        // event handler in the driver to be executed and emit the notification signal.
+
+    QCOMPARE(spy.count(), 1);
+    QList<QVariant> arguments = spy.takeFirst();
+    QVERIFY(arguments.at(0).toString() == procedureName);
+    QVERIFY_SQL(*driver, unsubscribeFromNotification(procedureName));
+    q.exec(QString("DROP PROCEDURE %1").arg(procedureName));
+}
+
+void tst_QSqlDatabase::eventNotificationPSQL()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+#if defined(Q_OS_LINUX)
+    QSKIP( "Event support doesn't work on linux", SkipAll );
+#endif
+
+    QSqlQuery query(db);
+    QString procedureName = qTableName("posteventProc", __FILE__);
+
+    QSqlDriver &driver=*(db.driver());
+    QVERIFY_SQL(driver, subscribeToNotification(procedureName));
+    QSignalSpy spy(db.driver(), SIGNAL(notification(const QString&)));
+    query.exec(QString("NOTIFY \"%1\"").arg(procedureName));
+    QCoreApplication::processEvents();
+    QCOMPARE(spy.count(), 1);
+    QList<QVariant> arguments = spy.takeFirst();
+    QVERIFY(arguments.at(0).toString() == procedureName);
+    QVERIFY_SQL(driver, unsubscribeFromNotification(procedureName));
+}
+
+void tst_QSqlDatabase::sqlite_bindAndFetchUInt()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    if (db.driverName().startsWith("QSQLITE2")) { 
+        QSKIP("SQLite3 specific test", SkipSingle); 
+        return; 
+    }
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("uint_test", __FILE__));
+    QVERIFY_SQL(q, exec(QString("CREATE TABLE %1(uint_field UNSIGNED INTEGER)").arg(tableName)));
+    QVERIFY_SQL(q, prepare(QString("INSERT INTO %1 VALUES(?)").arg(tableName)));
+    q.addBindValue(4000000000U);
+    QVERIFY_SQL(q, exec());
+    QVERIFY_SQL(q, exec(QString("SELECT uint_field FROM %1").arg(tableName)));
+    QVERIFY_SQL(q, next());
+
+    // All integers in SQLite are signed, so even though we bound the value
+    // as an UInt it will come back as a LongLong
+    QCOMPARE(q.value(0).type(), QVariant::LongLong);
+    QCOMPARE(q.value(0).toUInt(), 4000000000U);
+}
+
+void tst_QSqlDatabase::db2_valueCacheUpdate()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    const QString tableName(qTableName("qtest", __FILE__));
+    QSqlQuery q(db);
+    q.exec(QString("SELECT id, t_varchar, t_char, t_numeric FROM %1").arg(tableName));
+    q.next();
+    QVariant c4 = q.value(3);
+    QVariant c3 = q.value(2);
+    QVariant c2 = q.value(1);
+    QVariant c1 = q.value(0);
+    QCOMPARE(c4.toString(), q.value(3).toString());
+    QCOMPARE(c3.toString(), q.value(2).toString());
+    QCOMPARE(c2.toString(), q.value(1).toString());
+    QCOMPARE(c1.toString(), q.value(0).toString());
+}
+
+void tst_QSqlDatabase::sqlStatementUseIsNull_189093()
+{
+    // NULL = NULL is unknown, the sqlStatment must use IS NULL
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    // select a record with NULL value
+    QSqlQuery q(QString::null, db);
+    QVERIFY_SQL(q, exec("select * from " + qTableName("qtest", __FILE__) + " where id = 4"));
+    QVERIFY_SQL(q, next());
+
+    QSqlDriver *driver = db.driver();
+    QVERIFY(driver);
+
+    QString preparedStatment = driver->sqlStatement(QSqlDriver::WhereStatement, QString("qtest"), q.record(), true);
+    QCOMPARE(preparedStatment.count("IS NULL", Qt::CaseInsensitive), 2);
+
+    QString statment = driver->sqlStatement(QSqlDriver::WhereStatement, QString("qtest"), q.record(), false);
+    QCOMPARE(statment.count("IS NULL", Qt::CaseInsensitive), 2);
+}
+
+void tst_QSqlDatabase::mysql_savepointtest()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    if ( db.driverName().startsWith( "QMYSQL" ) && tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 1 ).toDouble()<4.1 )
+        QSKIP( "Test requires MySQL >= 4.1", SkipSingle );
+
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("begin"));
+    QVERIFY_SQL(q, exec("insert into "+qTableName("qtest", __FILE__)+" VALUES (54, 'foo', 'foo', 54.54)"));
+    QVERIFY_SQL(q, exec("savepoint foo"));
+}
+
+void tst_QSqlDatabase::oci_tables()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    QSqlQuery q(db);
+    const QString systemTableName("system."+qTableName("mypassword", __FILE__));
+    QVERIFY_SQL(q, exec("CREATE TABLE "+systemTableName+"(name VARCHAR(20))"));
+    QVERIFY(!db.tables().contains(systemTableName.toUpper()));
+    QVERIFY(db.tables(QSql::SystemTables).contains(systemTableName.toUpper()));
+}
+
+void tst_QSqlDatabase::sqlite_enable_cache_mode()
+{
+    QFETCH(QString, dbName);
+    if(dbName.endsWith(":memory:"))
+        QSKIP( "cache mode is meaningless for :memory: databases", SkipSingle );
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    db.close();
+    db.setConnectOptions("QSQLITE_ENABLE_SHARED_CACHE");
+    QVERIFY_SQL(db, open());
+    QSqlDatabase db2 = QSqlDatabase::cloneDatabase(db, dbName+":cachemodeconn2");
+    db2.setConnectOptions("QSQLITE_ENABLE_SHARED_CACHE");
+    QVERIFY_SQL(db2, open());
+    QSqlQuery q(db), q2(db2);
+    QVERIFY_SQL(q, exec("select * from "+qTableName("qtest", __FILE__)));
+    QVERIFY_SQL(q2, exec("select * from "+qTableName("qtest", __FILE__)));
+}
+
+QTEST_MAIN(tst_QSqlDatabase)
+#include "tst_qsqldatabase.moc"
diff --git a/tests/auto/sql/kernel/qsqldriver/qsqldriver.pro b/tests/auto/sql/kernel/qsqldriver/qsqldriver.pro
new file mode 100644
index 0000000000..c02d74a527
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqldriver/qsqldriver.pro
@@ -0,0 +1,27 @@
+load(qttest_p4)
+SOURCES  += tst_qsqldriver.cpp
+
+QT += sql
+
+wince*: {
+   plugFiles.files = ../../../plugins/sqldrivers
+   plugFiles.path    = .
+   DEPLOYMENT += plugFiles
+   LIBS += -lws2
+} else {
+   win32-g++* {
+        LIBS += -lws2_32
+   } else:win32 {
+        LIBS += ws2_32.lib
+   }
+}
+
+symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+}
diff --git a/tests/auto/sql/kernel/qsqldriver/tst_qsqldriver.cpp b/tests/auto/sql/kernel/qsqldriver/tst_qsqldriver.cpp
new file mode 100644
index 0000000000..6e47c24078
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqldriver/tst_qsqldriver.cpp
@@ -0,0 +1,230 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <QtSql/QtSql>
+
+#include "../qsqldatabase/tst_databases.h"
+
+
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QSqlDriver : public QObject
+{
+    Q_OBJECT
+
+public:
+    void recreateTestTables(QSqlDatabase);
+
+    tst_Databases dbs;
+
+public slots:
+    void initTestCase_data();
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void record();
+    void primaryIndex();
+};
+
+
+void tst_QSqlDriver::initTestCase_data()
+{
+    dbs.open();
+    if (dbs.fillTestTable() == 0) {
+        qWarning("NO DATABASES");
+        QSKIP("No database drivers are available in this Qt configuration", SkipAll);
+    }
+}
+
+void tst_QSqlDriver::recreateTestTables(QSqlDatabase db)
+{
+    QSqlQuery q(db);
+    const QString relTEST1(qTableName("relTEST1", __FILE__));
+
+    if(tst_Databases::isPostgreSQL(db))
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+
+    tst_Databases::safeDropTable( db, relTEST1 );
+
+    QVERIFY_SQL( q, exec("create table " + relTEST1 +
+            " (id int not null primary key, name varchar(20), title_key int, another_title_key int)"));
+    QVERIFY_SQL( q, exec("insert into " + relTEST1 + " values(1, 'harry', 1, 2)"));
+    QVERIFY_SQL( q, exec("insert into " + relTEST1 + " values(2, 'trond', 2, 1)"));
+    QVERIFY_SQL( q, exec("insert into " + relTEST1 + " values(3, 'vohi', 1, 2)"));
+    QVERIFY_SQL( q, exec("insert into " + relTEST1 + " values(4, 'boris', 2, 2)"));
+}
+
+void tst_QSqlDriver::initTestCase()
+{
+    foreach (const QString &dbname, dbs.dbNames)
+        recreateTestTables(QSqlDatabase::database(dbname));
+}
+
+void tst_QSqlDriver::cleanupTestCase()
+{
+    foreach (const QString &dbName, dbs.dbNames) {
+        QSqlDatabase db = QSqlDatabase::database(dbName);
+        tst_Databases::safeDropTable( db, qTableName( "relTEST1", __FILE__ ) );
+    }
+    dbs.close();
+}
+
+void tst_QSqlDriver::init()
+{
+}
+
+void tst_QSqlDriver::cleanup()
+{
+}
+
+void tst_QSqlDriver::record()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QString tablename(qTableName("relTEST1", __FILE__));
+    QStringList fields;
+    fields << "id" << "name" << "title_key" << "another_title_key";
+
+    //check we can get records using an unquoted mixed case table name
+    QSqlRecord rec = db.driver()->record(tablename);
+    QCOMPARE(rec.count(), 4);
+
+    if (db.driverName().startsWith("QIBASE")|| db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2"))
+        for(int i = 0; i < fields.count(); ++i)
+            fields[i] = fields[i].toUpper();
+
+    for (int i = 0; i < fields.count(); ++i)
+        QCOMPARE(rec.fieldName(i), fields[i]);
+
+    if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2"))
+        tablename = tablename.toUpper();
+    else if (db.driverName().startsWith("QPSQL"))
+        tablename = tablename.toLower();
+
+    if(!db.driverName().startsWith("QODBC") && !db.databaseName().contains("PostgreSql")) {
+        //check we can get records using a properly quoted table name
+        rec = db.driver()->record(db.driver()->escapeIdentifier(tablename,QSqlDriver::TableName));
+        QCOMPARE(rec.count(), 4);
+    }
+
+    for (int i = 0; i < fields.count(); ++i)
+        QCOMPARE(rec.fieldName(i), fields[i]);
+
+    if( db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2"))
+        tablename = tablename.toLower();
+    else if (db.driverName().startsWith("QPSQL"))
+        tablename = tablename.toUpper();
+
+    //check that we can't get records using incorrect tablename casing that's been quoted
+    rec = db.driver()->record(db.driver()->escapeIdentifier(tablename,QSqlDriver::TableName));
+    if (tst_Databases::isMySQL(db)
+      || db.driverName().startsWith("QSQLITE")
+      || db.driverName().startsWith("QTDS")
+      || tst_Databases::isSqlServer(db)
+      || tst_Databases::isMSAccess(db))
+        QCOMPARE(rec.count(), 4); //mysql, sqlite and tds will match
+    else
+        QCOMPARE(rec.count(), 0);
+
+}
+
+void tst_QSqlDriver::primaryIndex()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QString tablename(qTableName("relTEST1", __FILE__));
+    //check that we can get primary index using unquoted mixed case table name
+    QSqlIndex index = db.driver()->primaryIndex(tablename);
+    QCOMPARE(index.count(), 1);
+
+    if( db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2"))
+        QCOMPARE(index.fieldName(0), QString::fromLatin1("ID"));
+    else
+        QCOMPARE(index.fieldName(0), QString::fromLatin1("id"));
+
+
+    //check that we can get the primary index using a quoted tablename
+    if( db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2"))
+        tablename = tablename.toUpper();
+    else if (db.driverName().startsWith("QPSQL"))
+        tablename = tablename.toLower();
+
+    if(!db.driverName().startsWith("QODBC") && !db.databaseName().contains("PostgreSql")) {
+        index = db.driver()->primaryIndex(db.driver()->escapeIdentifier(tablename, QSqlDriver::TableName));
+        QCOMPARE(index.count(), 1);
+    }
+    if( db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2"))
+        QCOMPARE(index.fieldName(0), QString::fromLatin1("ID"));
+    else
+        QCOMPARE(index.fieldName(0), QString::fromLatin1("id"));
+
+
+
+    //check that we can not get the primary index using a quoted but incorrect table name casing
+    if( db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2"))
+        tablename = tablename.toLower();
+    else if (db.driverName().startsWith("QPSQL"))
+        tablename = tablename.toUpper();
+
+    index = db.driver()->primaryIndex(db.driver()->escapeIdentifier(tablename, QSqlDriver::TableName));
+    if (tst_Databases::isMySQL(db)
+      || db.driverName().startsWith("QSQLITE")
+      || db.driverName().startsWith("QTDS")
+      || tst_Databases::isSqlServer(db)
+      || tst_Databases::isMSAccess(db))
+        QCOMPARE(index.count(), 1); //mysql will always find the table name regardless of casing
+    else
+        QCOMPARE(index.count(), 0);
+}
+
+QTEST_MAIN(tst_QSqlDriver)
+#include "tst_qsqldriver.moc"
diff --git a/tests/auto/sql/kernel/qsqlerror/.gitignore b/tests/auto/sql/kernel/qsqlerror/.gitignore
new file mode 100644
index 0000000000..08997ebd99
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlerror/.gitignore
@@ -0,0 +1 @@
+tst_qsqlerror
diff --git a/tests/auto/sql/kernel/qsqlerror/qsqlerror.pro b/tests/auto/sql/kernel/qsqlerror/qsqlerror.pro
new file mode 100644
index 0000000000..ebf6d24381
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlerror/qsqlerror.pro
@@ -0,0 +1,18 @@
+############################################################
+# Project file for autotest for file qsqlerror.h
+############################################################
+
+load(qttest_p4)
+QT = core sql
+
+SOURCES += tst_qsqlerror.cpp
+
+symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+}
diff --git a/tests/auto/sql/kernel/qsqlerror/tst_qsqlerror.cpp b/tests/auto/sql/kernel/qsqlerror/tst_qsqlerror.cpp
new file mode 100644
index 0000000000..d02b373c73
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlerror/tst_qsqlerror.cpp
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include <qcoreapplication.h>
+#include <qdebug.h>
+#include <qsqlerror.h>
+
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QSqlError : public QObject
+{
+Q_OBJECT
+
+public:
+    tst_QSqlError();
+    virtual ~tst_QSqlError();
+
+private slots:
+    void getSetCheck();
+    void construction();
+    void operators();
+};
+
+tst_QSqlError::tst_QSqlError()
+{
+}
+
+tst_QSqlError::~tst_QSqlError()
+{
+}
+
+// Testing get/set functions
+void tst_QSqlError::getSetCheck()
+{
+    QSqlError obj1;
+    // ErrorType QSqlError::type()
+    // void QSqlError::setType(ErrorType)
+    obj1.setType(QSqlError::ErrorType(QSqlError::NoError));
+    QCOMPARE(QSqlError::ErrorType(QSqlError::NoError), obj1.type());
+    obj1.setType(QSqlError::ErrorType(QSqlError::ConnectionError));
+    QCOMPARE(QSqlError::ErrorType(QSqlError::ConnectionError), obj1.type());
+    obj1.setType(QSqlError::ErrorType(QSqlError::StatementError));
+    QCOMPARE(QSqlError::ErrorType(QSqlError::StatementError), obj1.type());
+    obj1.setType(QSqlError::ErrorType(QSqlError::TransactionError));
+    QCOMPARE(QSqlError::ErrorType(QSqlError::TransactionError), obj1.type());
+    obj1.setType(QSqlError::ErrorType(QSqlError::UnknownError));
+    QCOMPARE(QSqlError::ErrorType(QSqlError::UnknownError), obj1.type());
+
+    // int QSqlError::number()
+    // void QSqlError::setNumber(int)
+    obj1.setNumber(0);
+    QCOMPARE(0, obj1.number());
+    obj1.setNumber(INT_MIN);
+    QCOMPARE(INT_MIN, obj1.number());
+    obj1.setNumber(INT_MAX);
+    QCOMPARE(INT_MAX, obj1.number());
+}
+
+void tst_QSqlError::construction()
+{
+   QSqlError obj1("drivertext", "databasetext", QSqlError::UnknownError, 123);
+   QCOMPARE(obj1.driverText(), QString("drivertext"));
+   QCOMPARE(obj1.databaseText(), QString("databasetext"));
+   QCOMPARE(obj1.type(), QSqlError::UnknownError);
+   QCOMPARE(obj1.number(), 123);
+   obj1.isValid();
+
+   QSqlError obj2(obj1);
+   QCOMPARE(obj2.driverText(), obj1.driverText());
+   QCOMPARE(obj2.databaseText(), obj1.databaseText());
+   QCOMPARE(obj2.type(), obj1.type());
+   QCOMPARE(obj2.number(), obj1.number());
+   QVERIFY(obj2.isValid());
+
+   QSqlError obj3 = obj2;
+   QCOMPARE(obj3.driverText(), obj2.driverText());
+   QCOMPARE(obj3.databaseText(), obj2.databaseText());
+   QCOMPARE(obj3.type(), obj2.type());
+   QCOMPARE(obj3.number(), obj2.number());
+   QVERIFY(obj3.isValid());
+
+   QSqlError obj4;
+   QVERIFY(!obj4.isValid());
+}
+
+void tst_QSqlError::operators()
+{
+   QSqlError error1;
+   QSqlError error2;
+   QSqlError error3;
+
+   error1.setType(QSqlError::NoError);
+   error2.setType(QSqlError::NoError);
+   error3.setType(QSqlError::UnknownError);
+
+   QVERIFY(error1 == error2);
+   QVERIFY(error1 != error3);
+}
+
+
+QTEST_MAIN(tst_QSqlError)
+#include "tst_qsqlerror.moc"
diff --git a/tests/auto/sql/kernel/qsqlfield/.gitignore b/tests/auto/sql/kernel/qsqlfield/.gitignore
new file mode 100644
index 0000000000..441ff77ec0
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlfield/.gitignore
@@ -0,0 +1 @@
+tst_qsqlfield
diff --git a/tests/auto/sql/kernel/qsqlfield/qsqlfield.pro b/tests/auto/sql/kernel/qsqlfield/qsqlfield.pro
new file mode 100644
index 0000000000..2359151f13
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlfield/qsqlfield.pro
@@ -0,0 +1,15 @@
+load(qttest_p4)
+SOURCES  += tst_qsqlfield.cpp
+
+QT += sql
+
+symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+}
+
diff --git a/tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp b/tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp
new file mode 100644
index 0000000000..63f320151f
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp
@@ -0,0 +1,360 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include <qsqlfield.h>
+#include <qvariant.h>
+#include <qsqlfield.h>
+
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QSqlField : public QObject
+{
+Q_OBJECT
+
+public:
+    tst_QSqlField();
+    virtual ~tst_QSqlField();
+
+
+public slots:
+    void init();
+    void cleanup();
+private slots:
+    void getSetCheck();
+    void value();
+    void type();
+    void setValue_data();
+    void setValue();
+    void setReadOnly();
+    void setNull();
+    void setName_data();
+    void setName();
+    void operator_Equal();
+    void operator_Assign();
+    void name_data();
+    void name();
+    void isReadOnly();
+    void isNull();
+    void clear_data();
+    void clear();
+};
+
+// Testing get/set functions
+void tst_QSqlField::getSetCheck()
+{
+    QSqlField obj1;
+    // RequiredStatus QSqlField::requiredStatus()
+    // void QSqlField::setRequiredStatus(RequiredStatus)
+    obj1.setRequiredStatus(QSqlField::RequiredStatus(QSqlField::Unknown));
+    QCOMPARE(QSqlField::RequiredStatus(QSqlField::Unknown), obj1.requiredStatus());
+    obj1.setRequiredStatus(QSqlField::RequiredStatus(QSqlField::Optional));
+    QCOMPARE(QSqlField::RequiredStatus(QSqlField::Optional), obj1.requiredStatus());
+    obj1.setRequiredStatus(QSqlField::RequiredStatus(QSqlField::Required));
+    QCOMPARE(QSqlField::RequiredStatus(QSqlField::Required), obj1.requiredStatus());
+
+    // int QSqlField::length()
+    // void QSqlField::setLength(int)
+    obj1.setLength(0);
+    QCOMPARE(0, obj1.length());
+    obj1.setLength(INT_MIN);
+    QCOMPARE(INT_MIN, obj1.length());
+    obj1.setLength(INT_MAX);
+    QCOMPARE(INT_MAX, obj1.length());
+
+    // int QSqlField::precision()
+    // void QSqlField::setPrecision(int)
+    obj1.setPrecision(0);
+    QCOMPARE(0, obj1.precision());
+    obj1.setPrecision(INT_MIN);
+    QCOMPARE(INT_MIN, obj1.precision());
+    obj1.setPrecision(INT_MAX);
+    QCOMPARE(INT_MAX, obj1.precision());
+}
+
+tst_QSqlField::tst_QSqlField()
+{
+}
+
+tst_QSqlField::~tst_QSqlField()
+{
+
+}
+
+void tst_QSqlField::init()
+{
+// TODO: Add initialization code here.
+// This will be executed immediately before each test is run.
+}
+
+void tst_QSqlField::cleanup()
+{
+// TODO: Add cleanup code here.
+// This will be executed immediately after each test is run.
+}
+
+void tst_QSqlField::clear_data()
+{
+    QTest::addColumn<int>("val");
+    QTest::addColumn<bool>("bval");
+    QTest::addColumn<QString>("strVal");
+    QTest::addColumn<double>("fval");
+
+    //next we fill it with data
+    QTest::newRow( "data0" ) << (int)5 << true << QString("Hallo") << (double)0;
+    QTest::newRow( "data1" )  << -5 << false << QString("NULL") << (double)-4;
+    QTest::newRow( "data2" )  << 0 << false << QString("0") << (double)0;
+}
+
+void tst_QSqlField::clear()
+{
+    QSqlField field( "Testfield", QVariant::Int );
+    QFETCH( int, val );
+    field.setValue( val );
+    field.setReadOnly(true);
+    field.clear();
+    QVERIFY( field.value() == val );
+    QVERIFY( !field.isNull() );
+
+    QSqlField bfield( "Testfield", QVariant::Bool );
+    QFETCH( bool, bval );
+    bfield.setValue( QVariant(bval) );
+    bfield.setReadOnly(true);
+    bfield.clear();
+
+    QVERIFY( bfield.value() == QVariant(bval) );
+    QVERIFY( !bfield.isNull() );
+
+    QSqlField ffield( "Testfield", QVariant::Double );
+    QFETCH( double, fval );
+    ffield.setValue( fval );
+    ffield.setReadOnly(true);
+    ffield.clear();
+    QVERIFY( ffield.value() == fval );
+    QVERIFY( !ffield.isNull() );
+
+    QSqlField sfield( "Testfield", QVariant::String );
+    QFETCH( QString, strVal );
+    sfield.setValue( strVal );
+    sfield.setReadOnly(true);
+    sfield.clear();
+    QVERIFY( sfield.value() == strVal );
+    QVERIFY( !sfield.isNull() );
+}
+
+void tst_QSqlField::isNull()
+{
+    QSqlField field( "test", QVariant::String );
+    QVERIFY( field.isNull() );
+}
+
+void tst_QSqlField::isReadOnly()
+{
+    QSqlField field( "test", QVariant::String );
+    QVERIFY( !field.isReadOnly() );
+    field.setReadOnly( true );
+    QVERIFY( field.isReadOnly() );
+    field.setReadOnly( false );
+    QVERIFY( !field.isReadOnly() );
+}
+
+void tst_QSqlField::name_data()
+{
+    QTest::addColumn<QString>("val");
+
+    //next we fill it with data
+    QTest::newRow( "data0" )  << QString("test");
+    QTest::newRow( "data1" )  << QString("Harry");
+    QTest::newRow( "data2" )  << QString("");
+}
+
+void tst_QSqlField::name()
+{
+    QSqlField field( "test", QVariant::String );
+    QFETCH( QString, val );
+    QVERIFY( field.name() == "test" );
+    field.setName( val );
+    QVERIFY( field.name() == val );
+}
+
+void tst_QSqlField::operator_Assign()
+{
+    QSqlField field1( "test", QVariant::String );
+    field1.setValue( "Harry" );
+    field1.setReadOnly( true );
+    QSqlField field2 = field1;
+    QVERIFY( field1 == field2 );
+    QSqlField field3( "test", QVariant::Double );
+    field3.clear();
+    field1 = field3;
+    QVERIFY( field1 == field3 );
+}
+
+void tst_QSqlField::operator_Equal()
+{
+    QSqlField field1( "test", QVariant::String );
+    QSqlField field2( "test2", QVariant::String );
+    QSqlField field3( "test", QVariant::Int );
+    QVERIFY( !(field1 == field2) );
+    QVERIFY( !(field1 == field3) );
+    field2.setName( "test" );
+    QVERIFY( field1 == field2 );
+    QVERIFY( field1 == field2 );
+    field1.setValue( "Harry" );
+    QVERIFY( !(field1 == field2) );
+    field2.setValue( "Harry" );
+    QVERIFY( field1 == field2 );
+    field1.setReadOnly( true );
+    QVERIFY( !(field1 == field2) );
+    field2.setReadOnly( true );
+    QVERIFY( field1 == field2 );
+}
+
+void tst_QSqlField::setName_data()
+{
+    QTest::addColumn<QString>("val");
+
+    //next we fill it with data
+    QTest::newRow( "data0" )  << QString("test");
+    QTest::newRow( "data1" )  << QString("Harry");
+    QTest::newRow( "data2" )  << QString("");
+}
+
+void tst_QSqlField::setName()
+{
+    QSqlField field( "test", QVariant::String );
+    QFETCH( QString, val );
+    QVERIFY( field.name() == "test" );
+    field.setName( val );
+    QVERIFY( field.name() == val );
+}
+
+void tst_QSqlField::setNull()
+{
+    QSqlField field( "test", QVariant::String );
+    field.setValue( "test" );
+    field.clear();
+    QVERIFY( field.value() == QVariant().toString() );
+    QVERIFY( field.isNull() );
+}
+
+void tst_QSqlField::setReadOnly()
+{
+    QSqlField field( "test", QVariant::String );
+    field.setValue( "test" );
+    field.setReadOnly( true );
+    field.setValue( "Harry" );
+    QVERIFY( field.value() == "test" );
+    field.clear();
+    QVERIFY( field.value() == "test" );
+    QVERIFY( !field.isNull() );
+    field.clear();
+    QVERIFY( field.value() == "test" );
+    QVERIFY( !field.isNull() );
+    field.setReadOnly( false );
+    field.setValue( "Harry" );
+    QVERIFY( field.value() == "Harry" );
+    field.clear();
+    QVERIFY( field.value() == QVariant().toString() );
+    QVERIFY( field.isNull() );
+}
+
+void tst_QSqlField::setValue_data()
+{
+    QTest::addColumn<int>("ival");
+    QTest::addColumn<bool>("bval");
+    QTest::addColumn<double>("dval");
+    QTest::addColumn<QString>("sval");
+
+    //next we fill it with data
+    QTest::newRow( "data0" )  << 0 << false << (double)223.232 << QString("");
+    QTest::newRow( "data1" )  << 123 << true << (double)-232.232 << QString("Harry");
+    QTest::newRow( "data2" )  << -123 << false << (double)232222.323223233338 << QString("Woipertinger");
+}
+
+void tst_QSqlField::setValue()
+{
+    QSqlField field1 ( "test", QVariant::Int );
+    QSqlField field2 ( "test", QVariant::String );
+    QSqlField field3 ( "test", QVariant::Bool );
+    QSqlField field4 ( "test", QVariant::Double );
+    field1.clear();
+    QFETCH( int, ival );
+    QFETCH( QString, sval );
+    QFETCH( double, dval );
+    QFETCH( bool, bval );
+    field1.setValue( ival );
+    QCOMPARE( field1.value().toInt(), ival );
+    // setValue should also reset the NULL flag
+    QVERIFY( !field1.isNull() );
+
+    field2.setValue( sval );
+    QCOMPARE( field2.value().toString(), sval );
+    field3.setValue( QVariant( bval) );
+    QVERIFY( field3.value().toBool() == bval );
+    field4.setValue( dval );
+    QCOMPARE( field4.value().toDouble(), dval );
+    field4.setReadOnly( true );
+    field4.setValue( "Something_that's_not_a_double" );
+    QCOMPARE( field4.value().toDouble(), dval );
+}
+
+void tst_QSqlField::type()
+{
+    QSqlField field1( "string", QVariant::String );
+    QSqlField field2( "string", QVariant::Bool );
+    QSqlField field3( "string", QVariant::Double );
+    QVERIFY( field1.type() == QVariant::String );
+    QVERIFY( field2.type() == QVariant::Bool );
+    QVERIFY( field3.type() == QVariant::Double );
+}
+
+void tst_QSqlField::value()
+{
+    DEPENDS_ON( "setValue" );
+}
+
+QTEST_MAIN(tst_QSqlField)
+#include "tst_qsqlfield.moc"
diff --git a/tests/auto/sql/kernel/qsqlquery/.gitignore b/tests/auto/sql/kernel/qsqlquery/.gitignore
new file mode 100644
index 0000000000..e8aefc3e00
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlquery/.gitignore
@@ -0,0 +1 @@
+tst_qsqlquery
diff --git a/tests/auto/sql/kernel/qsqlquery/qsqlquery.pro b/tests/auto/sql/kernel/qsqlquery/qsqlquery.pro
new file mode 100644
index 0000000000..fbcc998900
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlquery/qsqlquery.pro
@@ -0,0 +1,25 @@
+load(qttest_p4)
+SOURCES  += tst_qsqlquery.cpp
+
+QT = core sql
+
+
+!wince*:win32:LIBS += -lws2_32
+
+
+wince*: {
+   plugFiles.files = ../../../plugins/sqldrivers
+   plugFiles.path    = .
+   DEPLOYMENT += plugFiles
+   LIBS += -lws2
+}
+
+symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+}
diff --git a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
new file mode 100644
index 0000000000..dc0c86d6f4
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
@@ -0,0 +1,3267 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QtSql/QtSql>
+
+#include "../qsqldatabase/tst_databases.h"
+
+const QString qtest(qTableName( "qtest", __FILE__ ));
+
+//TESTED_FILES=
+
+class tst_QSqlQuery : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QSqlQuery();
+    virtual ~tst_QSqlQuery();
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void value_data() { generic_data(); }
+    void value();
+    void isValid_data() { generic_data(); }
+    void isValid();
+    void isActive_data() { generic_data(); }
+    void isActive();
+    void isSelect_data() { generic_data(); }
+    void isSelect();
+    void numRowsAffected_data() { generic_data(); }
+    void numRowsAffected();
+    void size_data() { generic_data(); }
+    void size();
+    void isNull_data() { generic_data(); }
+    void isNull();
+    void query_exec_data() { generic_data(); }
+    void query_exec();
+    void execErrorRecovery_data() { generic_data(); }
+    void execErrorRecovery();
+    void first_data() { generic_data(); }
+    void first();
+    void next_data() { generic_data(); }
+    void next();
+    void prev_data() { generic_data(); }
+    void prev();
+    void last_data() { generic_data(); }
+    void last();
+    void seek_data() { generic_data(); }
+    void seek();
+    void transaction_data() { generic_data(); }
+    void transaction();
+    void record_data() { generic_data(); }
+    void record();
+    void record_sqlite_data() { generic_data("QSQLITE"); }
+    void record_sqlite();
+    void finish_data() { generic_data(); }
+    void finish();
+    void sqlite_finish_data() { generic_data(); }
+    void sqlite_finish();
+    void nextResult_data() { generic_data(); }
+    void nextResult();
+
+    // forwardOnly mode need special treatment
+    void forwardOnly_data() { generic_data(); }
+    void forwardOnly();
+
+    // bug specific tests
+    void bitField_data() {generic_data("QTDS"); }
+    void bitField();
+    void nullBlob_data() { generic_data("QOCI"); }
+    void nullBlob();
+    void blob_data() { generic_data(); }
+    void blob();
+    void rawField_data() { generic_data("QOCI"); }
+    void rawField();
+    void precision_data() { generic_data(); }
+    void precision();
+    void nullResult_data() { generic_data(); }
+    void nullResult();
+    void joins_data() { generic_data(); }
+    void joins();
+    void outValues_data() { generic_data(); }
+    void outValues();
+    void char1Select_data() { generic_data(); }
+    void char1Select();
+    void char1SelectUnicode_data() { generic_data(); }
+    void char1SelectUnicode();
+    void synonyms_data() { generic_data(); }
+    void synonyms();
+    void oraOutValues_data() { generic_data("QOCI"); }
+    void oraOutValues();
+    void mysqlOutValues_data() { generic_data("QMYSQL"); }
+    void mysqlOutValues();
+    void oraClob_data() { generic_data("QOCI"); }
+    void oraClob();
+    void oraLong_data() { generic_data("QOCI"); }
+    void oraLong();
+    void oraOCINumber_data() { generic_data("QOCI"); }
+    void oraOCINumber();
+    void outValuesDB2_data() { generic_data("QDB2"); }
+    void outValuesDB2();
+    void storedProceduresIBase_data() {generic_data("QIBASE"); }
+    void storedProceduresIBase();
+    void oraRowId_data() { generic_data("QOCI"); }
+    void oraRowId();
+    void prepare_bind_exec_data() { generic_data(); }
+    void prepare_bind_exec();
+    void prepared_select_data() { generic_data(); }
+    void prepared_select();
+    void sqlServerLongStrings_data() { generic_data(); }
+    void sqlServerLongStrings();
+    void invalidQuery_data() { generic_data(); }
+    void invalidQuery();
+    void batchExec_data() { generic_data(); }
+    void batchExec();
+    void oraArrayBind_data() { generic_data(); }
+    void oraArrayBind();
+    void lastInsertId_data() { generic_data(); }
+    void lastInsertId();
+    void lastQuery_data() { generic_data(); }
+    void lastQuery();
+    void bindWithDoubleColonCastOperator_data() { generic_data(); }
+    void bindWithDoubleColonCastOperator();
+    void queryOnInvalidDatabase_data() { generic_data(); }
+    void queryOnInvalidDatabase();
+    void createQueryOnClosedDatabase_data() { generic_data(); }
+    void createQueryOnClosedDatabase();
+    void seekForwardOnlyQuery_data() { generic_data(); }
+    void seekForwardOnlyQuery();
+    void reExecutePreparedForwardOnlyQuery_data() { generic_data(); }
+    void reExecutePreparedForwardOnlyQuery();
+    void blobsPreparedQuery_data() { generic_data(); }
+    void blobsPreparedQuery();
+    void emptyTableNavigate_data() { generic_data(); }
+    void emptyTableNavigate();
+
+#ifdef NOT_READY_YET
+    void task_229811();
+    void task_229811_data() { generic_data(); }
+    void task_234422_data() {  generic_data(); }
+    void task_234422();
+#endif
+    void task_217003_data() { generic_data(); }
+    void task_217003();
+
+    void task_250026_data() { generic_data("QODBC"); }
+    void task_250026();
+    void task_205701_data() { generic_data("QMYSQL"); }
+    void task_205701();
+
+    void task_233829_data() { generic_data("QPSQL"); }
+    void task_233829();
+
+    void sqlServerReturn0_data() { generic_data(); }
+    void sqlServerReturn0();
+
+    void QTBUG_551_data() { generic_data("QOCI"); }
+    void QTBUG_551();
+
+    void QTBUG_5251_data() { generic_data("QPSQL"); }
+    void QTBUG_5251();
+    void QTBUG_6421_data() { generic_data("QOCI"); }
+    void QTBUG_6421();
+    void QTBUG_6618_data() { generic_data("QODBC"); }
+    void QTBUG_6618();
+    void QTBUG_6852_data() { generic_data("QMYSQL"); }
+    void QTBUG_6852();
+    void QTBUG_5765_data() { generic_data("QMYSQL"); }
+    void QTBUG_5765();
+    void QTBUG_14132_data() { generic_data("QOCI"); }
+    void QTBUG_14132();
+
+    void sqlite_constraint_data() { generic_data("QSQLITE"); }
+    void sqlite_constraint();
+
+#if 0
+    void benchmark_data() { generic_data(); }
+    void benchmark();
+#endif
+
+private:
+    // returns all database connections
+    void generic_data(const QString &engine=QString());
+    void dropTestTables( QSqlDatabase db );
+    void createTestTables( QSqlDatabase db );
+    void populateTestTables( QSqlDatabase db );
+
+    tst_Databases dbs;
+};
+
+tst_QSqlQuery::tst_QSqlQuery()
+{
+}
+
+tst_QSqlQuery::~tst_QSqlQuery()
+{
+}
+
+void tst_QSqlQuery::initTestCase()
+{
+    dbs.open();
+
+    for ( QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it ) {
+        QSqlDatabase db = QSqlDatabase::database(( *it ) );
+        CHECK_DATABASE( db );
+        dropTestTables( db ); //in case of leftovers
+        createTestTables( db );
+        populateTestTables( db );
+    }
+}
+
+void tst_QSqlQuery::cleanupTestCase()
+{
+    for ( QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it ) {
+        QSqlDatabase db = QSqlDatabase::database(( *it ) );
+        CHECK_DATABASE( db );
+        dropTestTables( db );
+    }
+
+    dbs.close();
+}
+
+void tst_QSqlQuery::init()
+{
+}
+
+void tst_QSqlQuery::cleanup()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( QTest::currentTestFunction() == QLatin1String( "numRowsAffected" )
+            || QTest::currentTestFunction() == QLatin1String( "transactions" )
+            || QTest::currentTestFunction() == QLatin1String( "size" )
+            || QTest::currentTestFunction() == QLatin1String( "isActive" )
+            || QTest::currentTestFunction() == QLatin1String( "lastInsertId" ) ) {
+        populateTestTables( db );
+    }
+
+    if ( QTest::currentTestFailed() && ( db.driverName().startsWith( "QOCI" )
+                                         || db.driverName().startsWith( "QODBC" ) ) ) {
+        //since Oracle ODBC totally craps out on error, we init again
+        db.close();
+        db.open();
+    }
+}
+
+void tst_QSqlQuery::generic_data(const QString& engine)
+{
+    if ( dbs.fillTestTable(engine) == 0 ) {
+        if(engine.isEmpty())
+           QSKIP( "No database drivers are available in this Qt configuration", SkipAll );
+        else
+           QSKIP( (QString("No database drivers of type %1 are available in this Qt configuration").arg(engine)).toLocal8Bit(), SkipAll );
+    }
+}
+
+void tst_QSqlQuery::dropTestTables( QSqlDatabase db )
+{
+    QStringList tablenames;
+    // drop all the table in case a testcase failed
+    tablenames <<  qtest
+               << qTableName( "qtest_null", __FILE__ )
+               << qTableName( "qtest_blob", __FILE__ )
+               << qTableName( "qtest_bittest", __FILE__ )
+               << qTableName( "qtest_nullblob", __FILE__ )
+               << qTableName( "qtest_rawtest", __FILE__ )
+               << qTableName( "qtest_precision", __FILE__ )
+               << qTableName( "qtest_prepare", __FILE__ )
+               << qTableName( "qtestj1", __FILE__ )
+               << qTableName( "qtestj2", __FILE__ )
+               << qTableName( "char1Select", __FILE__ )
+               << qTableName( "char1SU", __FILE__ )
+               << qTableName( "qxmltest", __FILE__ )
+               << qTableName( "qtest_exerr", __FILE__ )
+               << qTableName( "qtest_empty", __FILE__ )
+               << qTableName( "clobby", __FILE__ )
+               << qTableName( "bindtest", __FILE__ )
+               << qTableName( "more_results", __FILE__ )
+               << qTableName( "blobstest", __FILE__ )
+               << qTableName( "oraRowId", __FILE__ )
+               << qTableName( "qtest_batch", __FILE__ )
+               << qTableName("bug6421", __FILE__).toUpper()
+               << qTableName("bug5765", __FILE__)
+               << qTableName("bug6852", __FILE__)
+               << qTableName( "qtest_lockedtable", __FILE__ )
+               << qTableName( "Planet", __FILE__ )
+               << qTableName( "task_250026", __FILE__ )
+               << qTableName( "task_234422", __FILE__ )
+               << qTableName("test141895", __FILE__)
+               << qTableName("qtest_oraOCINumber", __FILE__);
+
+    if ( db.driverName().startsWith("QPSQL") )
+        tablenames << qTableName("task_233829", __FILE__);
+
+    if ( db.driverName().startsWith("QSQLITE") )
+        tablenames << qTableName( "record_sqlite", __FILE__ );
+
+    if ( tst_Databases::isSqlServer( db ) || db.driverName().startsWith( "QOCI" ) )
+        tablenames << qTableName( "qtest_longstr", __FILE__ );
+
+    if (tst_Databases::isSqlServer( db ))
+        db.exec("DROP PROCEDURE " + qTableName("test141895_proc", __FILE__));
+
+    if (tst_Databases::isMySQL( db ))
+        db.exec("DROP PROCEDURE IF EXISTS "+qTableName("bug6852_proc", __FILE__));
+
+    tst_Databases::safeDropTables( db, tablenames );
+
+    if ( db.driverName().startsWith( "QOCI" ) ) {
+        QSqlQuery q( db );
+        q.exec( "DROP PACKAGE " + qTableName("pkg", __FILE__) );
+    }
+}
+
+void tst_QSqlQuery::createTestTables( QSqlDatabase db )
+{
+    QSqlQuery q( db );
+
+    if ( db.driverName().startsWith( "QMYSQL" ) )
+        // ### stupid workaround until we find a way to hardcode this
+        // in the MySQL server startup script
+        q.exec( "set table_type=innodb" );
+    else if(tst_Databases::isPostgreSQL(db))
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+
+    if(tst_Databases::isPostgreSQL(db))
+        QVERIFY_SQL( q, exec( "create table " + qtest + " (id serial NOT NULL, t_varchar varchar(20), t_char char(20), primary key(id)) WITH OIDS" ) );
+    else
+        QVERIFY_SQL( q, exec( "create table " + qtest + " (id int "+tst_Databases::autoFieldName(db) +" NOT NULL, t_varchar varchar(20), t_char char(20), primary key(id))" ) );
+
+    if ( tst_Databases::isSqlServer( db ) || db.driverName().startsWith( "QTDS" ) )
+        QVERIFY_SQL( q, exec( "create table " + qTableName( "qtest_null", __FILE__ ) + " (id int null, t_varchar varchar(20) null)" ) );
+    else
+        QVERIFY_SQL( q, exec( "create table " + qTableName( "qtest_null", __FILE__ ) + " (id int, t_varchar varchar(20))" ) );
+}
+
+void tst_QSqlQuery::populateTestTables( QSqlDatabase db )
+{
+    QSqlQuery q( db );
+    const QString qtest_null(qTableName( "qtest_null", __FILE__ ));
+    q.exec( "delete from " + qtest );
+    QVERIFY_SQL( q, exec( "insert into " + qtest + " values (1, 'VarChar1', 'Char1')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest + " values (2, 'VarChar2', 'Char2')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest + " values (3, 'VarChar3', 'Char3')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest + " values (4, 'VarChar4', 'Char4')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest + " values (5, 'VarChar5', 'Char5')" ) );
+
+    q.exec( "delete from " + qtest_null );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_null + " values (0, NULL)" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_null + " values (1, 'n')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_null + " values (2, 'i')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_null + " values (3, NULL)" ) );
+}
+
+// There were problems with char fields of size 1
+void tst_QSqlQuery::char1Select()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    {
+        QSqlQuery q( db );
+        QVERIFY_SQL( q, exec( "create table " + qTableName( "char1Select", __FILE__ ) + " (id char(1))" ) );
+        QVERIFY_SQL( q, exec( "insert into " + qTableName( "char1Select", __FILE__ ) + " values ('a')" ) );
+        QVERIFY_SQL( q, exec( "select * from " + qTableName( "char1Select", __FILE__ ) ) );
+        QVERIFY( q.next() );
+
+        if ( db.driverName().startsWith( "QIBASE" ) )
+            QCOMPARE( q.value( 0 ).toString().left( 1 ), QString( "a" ) );
+        else
+            QCOMPARE( q.value( 0 ).toString(), QString( "a" ) );
+
+        QVERIFY( !q.next() );
+    }
+}
+
+void tst_QSqlQuery::char1SelectUnicode()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if(db.driverName().startsWith("QDB2"))
+        QSKIP("Needs someone with more Unicode knowledge than I have to fix", SkipSingle);
+
+    if ( db.driver()->hasFeature( QSqlDriver::Unicode ) ) {
+        QString uniStr( QChar(0x0915) ); // DEVANAGARI LETTER KA
+        QSqlQuery q( db );
+
+        if ( db.driverName().startsWith( "QMYSQL" ) && tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt()<5 )
+            QSKIP( "Test requires MySQL >= 5.0", SkipSingle );
+
+        QString createQuery;
+        const QString char1SelectUnicode(qTableName( "char1SU", __FILE__ ));
+
+        if ( tst_Databases::isSqlServer( db ) )
+            createQuery = "create table " + char1SelectUnicode + "(id nchar(1))";
+        else if ( db.driverName().startsWith( "QDB2" )
+                  || db.driverName().startsWith( "QOCI" )
+                  || db.driverName().startsWith( "QPSQL" ) )
+            createQuery = "create table " + char1SelectUnicode + " (id char(3))";
+        else if ( db.driverName().startsWith( "QIBASE" ) )
+            createQuery = "create table " + char1SelectUnicode +
+                          " (id char(1) character set unicode_fss)";
+        else if ( db.driverName().startsWith( "QMYSQL" ) )
+            createQuery = "create table " + char1SelectUnicode + " (id char(1)) "
+                          "default character set 'utf8'";
+        else
+            createQuery = "create table " + char1SelectUnicode + " (id char(1))";
+
+        QVERIFY_SQL( q, exec( createQuery ) );
+
+        QVERIFY_SQL( q, prepare( "insert into " + char1SelectUnicode + " values(?)" ) );
+
+        q.bindValue( 0, uniStr );
+
+        QVERIFY_SQL( q, exec() );
+
+        QVERIFY_SQL( q, exec( "select * from " + char1SelectUnicode ) );
+
+        QVERIFY( q.next() );
+
+        if ( !q.value( 0 ).toString().isEmpty() )
+            QCOMPARE( q.value( 0 ).toString()[ 0 ].unicode(), uniStr[0].unicode() );
+
+        QCOMPARE( q.value( 0 ).toString().trimmed(), uniStr );
+
+        QVERIFY( !q.next() );
+    }
+    else
+        QSKIP( "Database not unicode capable", SkipSingle );
+}
+
+void tst_QSqlQuery::oraRowId()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString oraRowId(qTableName("oraRowId", __FILE__));
+
+    QSqlQuery q( db );
+    QVERIFY_SQL( q, exec( "select rowid from " + qtest ) );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).type(), QVariant::String );
+    QVERIFY( !q.value( 0 ).toString().isEmpty() );
+
+    QVERIFY_SQL( q, exec( "create table " + oraRowId + " (id char(1))" ) );
+
+    QVERIFY_SQL( q, exec( "insert into " + oraRowId + " values('a')" ) );
+    QVariant v1 = q.lastInsertId();
+    QVERIFY( v1.isValid() );
+
+    QVERIFY_SQL( q, exec( "insert into " + oraRowId + " values('b')" ) );
+    QVariant v2 = q.lastInsertId();
+    QVERIFY( v2.isValid() );
+
+    QVERIFY_SQL( q, prepare( "select * from " + oraRowId + " where rowid = ?" ) );
+    q.addBindValue( v1 );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toString(), QString( "a" ) );
+
+    q.addBindValue( v2 );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toString(), QString( "b" ) );
+}
+
+void tst_QSqlQuery::mysqlOutValues()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString hello(qTableName( "hello", __FILE__ )), qtestproc(qTableName( "qtestproc", __FILE__ ));
+
+    QSqlQuery q( db );
+
+    if ( db.driverName().startsWith( "QMYSQL" ) && tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt()<5 )
+        QSKIP( "Test requires MySQL >= 5.0", SkipSingle );
+
+    q.exec( "drop function " + hello );
+
+    QVERIFY_SQL( q, exec( "create function " + hello + " (s char(20)) returns varchar(50) return concat('Hello ', s)" ) );
+
+    QVERIFY_SQL( q, exec( "select " + hello + "('world')" ) );
+    QVERIFY_SQL( q, next() );
+
+    QCOMPARE( q.value( 0 ).toString(), QString( "Hello world" ) );
+
+    QVERIFY_SQL( q, prepare( "select " + hello + "('harald')" ) );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY_SQL( q, next() );
+
+    QCOMPARE( q.value( 0 ).toString(), QString( "Hello harald" ) );
+
+    QVERIFY_SQL( q, exec( "drop function " + hello ) );
+
+    q.exec( "drop procedure " + qtestproc );
+
+    QVERIFY_SQL( q, exec( "create procedure " + qtestproc + " () "
+                            "BEGIN select * from " + qtest + " order by id; END" ) );
+    QVERIFY_SQL( q, exec( "call " + qtestproc + "()" ) );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 1 ).toString(), QString( "VarChar1" ) );
+
+    QVERIFY_SQL( q, exec( "drop procedure " + qtestproc ) );
+
+    QVERIFY_SQL( q, exec( "create procedure " + qtestproc + " (OUT param1 INT) "
+                            "BEGIN set param1 = 42; END" ) );
+
+    QVERIFY_SQL( q, exec( "call " + qtestproc + " (@out)" ) );
+    QVERIFY_SQL( q, exec( "select @out" ) );
+    QCOMPARE( q.record().fieldName( 0 ), QString( "@out" ) );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toInt(), 42 );
+
+    QVERIFY_SQL( q, exec( "drop procedure " + qtestproc ) );
+}
+
+void tst_QSqlQuery::oraOutValues()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString tst_outValues(qTableName("tst_outValues", __FILE__));
+
+    if ( !db.driver()->hasFeature( QSqlDriver::PreparedQueries ) ) {
+        QSKIP( "Test requires prepared query support", SkipSingle );
+        return;
+    }
+
+    QSqlQuery q( db );
+
+    q.setForwardOnly( true );
+
+    /*** outvalue int ***/
+    QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x out int) is\n"
+                            "begin\n"
+                            "    x := 42;\n"
+                            "end;\n" ) );
+    QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );
+    q.addBindValue( 0, QSql::Out );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.boundValue( 0 ).toInt(), 42 );
+
+    // bind a null value, make sure the OCI driver resets the null flag
+    q.addBindValue( QVariant( QVariant::Int ), QSql::Out );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.boundValue( 0 ).toInt(), 42 );
+    QVERIFY( !q.boundValue( 0 ).isNull() );
+
+    /*** outvalue varchar ***/
+    QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x out varchar) is\n"
+                            "begin\n"
+                            "    x := 'blah';\n"
+                            "end;\n" ) );
+    QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );
+    QString s1( "12345" );
+    s1.reserve( 512 );
+    q.addBindValue( s1, QSql::Out );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.boundValue( 0 ).toString(), QString( "blah" ) );
+
+    /*** in/outvalue numeric ***/
+    QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in out numeric) is\n"
+                            "begin\n"
+                            "    x := x + 10;\n"
+                            "end;\n" ) );
+    QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );
+    q.addBindValue( 10, QSql::Out );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.boundValue( 0 ).toInt(), 20 );
+
+    /*** in/outvalue varchar ***/
+    QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in out varchar) is\n"
+                            "begin\n"
+                            "    x := 'homer';\n"
+                            "end;\n" ) );
+    QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );
+    q.addBindValue( QString( "maggy" ), QSql::Out );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.boundValue( 0 ).toString(), QString( "homer" ) );
+
+    /*** in/outvalue varchar ***/
+    QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in out varchar) is\n"
+                            "begin\n"
+                            "    x := NULL;\n"
+                            "end;\n" ) );
+    QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );
+    q.addBindValue( QString( "maggy" ), QSql::Out );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY( q.boundValue( 0 ).isNull() );
+
+    /*** in/outvalue int ***/
+    QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in out int) is\n"
+                            "begin\n"
+                            "    x := NULL;\n"
+                            "end;\n" ) );
+    QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );
+    q.addBindValue( 42, QSql::Out );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY( q.boundValue( 0 ).isNull() );
+
+    /*** in/outvalue varchar ***/
+    QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in varchar, y out varchar) is\n"
+                            "begin\n"
+                            "    y := x||'bubulalakikikokololo';\n"
+                            "end;\n" ) );
+    QVERIFY( q.prepare( "call " + tst_outValues + "(?, ?)" ) );
+    q.addBindValue( QString( "fifi" ), QSql::In );
+    QString out;
+    out.reserve( 50 );
+    q.addBindValue( out, QSql::Out );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.boundValue( 1 ).toString(), QString( "fifibubulalakikikokololo" ) );
+}
+
+void tst_QSqlQuery::oraClob()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString clobby(qTableName("clobby", __FILE__));
+
+    QSqlQuery q( db );
+
+    // simple short string
+    QVERIFY_SQL( q, exec( "create table " + clobby + "(id int primary key, cl clob, bl blob)" ) );
+    QVERIFY_SQL( q, prepare( "insert into " + clobby + " (id, cl, bl) values(?, ?, ?)" ) );
+    q.addBindValue( 1 );
+    q.addBindValue( "bubu" );
+    q.addBindValue( QByteArray("bubu") );
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY_SQL( q, exec( "select bl, cl from " + clobby + " where id = 1" ) );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toString(), QString( "bubu" ) );
+    QCOMPARE( q.value( 1 ).toString(), QString( "bubu" ) );
+
+    // simple short string with binding
+    QVERIFY_SQL( q, prepare( "insert into " + clobby + " (id, cl, bl) values(?, ?, ?)" ) );
+    q.addBindValue( 2 );
+    q.addBindValue( "lala", QSql::Binary );
+    q.addBindValue( QByteArray("lala"), QSql::Binary );
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY_SQL( q, exec( "select bl, cl from " + clobby + " where id = 2" ) );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toString(), QString( "lala" ) );
+    QCOMPARE( q.value( 1 ).toString(), QString( "lala" ) );
+
+    // loooong string
+    QString loong;
+    loong.fill( QLatin1Char( 'A' ), 25000 );
+    QVERIFY_SQL( q, prepare( "insert into " + clobby + " (id, cl, bl) values(?, ?, ?)" ) );
+    q.addBindValue( 3 );
+    q.addBindValue( loong, QSql::Binary );
+    q.addBindValue( loong.toLatin1(), QSql::Binary );
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY_SQL( q, exec( "select bl, cl from " + clobby + " where id = 3" ) );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toString().count(), loong.count() );
+    QVERIFY( q.value( 0 ).toString() == loong );
+    QCOMPARE( q.value( 1 ).toByteArray().count(), loong.toLatin1().count() );
+    QVERIFY( q.value( 1 ).toByteArray() == loong.toLatin1() );
+}
+
+void tst_QSqlQuery::storedProceduresIBase()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    q.exec( "drop procedure " + qTableName( "TESTPROC", __FILE__ ) );
+
+    QVERIFY_SQL( q, exec( "create procedure " + qTableName( "TESTPROC", __FILE__ ) +
+                            " RETURNS (x integer, y varchar(20)) "
+                            "AS BEGIN "
+                            "  x = 42; "
+                            "  y = 'Hello Anders'; "
+                            "END" ) );
+
+    QVERIFY_SQL( q, prepare( "execute procedure " + qTableName( "TestProc", __FILE__ ) ) );
+    QVERIFY_SQL( q, exec() );
+
+    // check for a valid result set
+    QSqlRecord rec = q.record();
+    QCOMPARE( rec.count(), 2 );
+    QCOMPARE( rec.fieldName( 0 ).toUpper(), QString( "X" ) );
+    QCOMPARE( rec.fieldName( 1 ).toUpper(), QString( "Y" ) );
+
+    // the first next shall suceed
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toInt(), 42 );
+    QCOMPARE( q.value( 1 ).toString(), QString( "Hello Anders" ) );
+
+    // the second next shall fail
+    QVERIFY( !q.next() );
+
+    q.exec( "drop procedure " + qTableName( "TestProc", __FILE__ ) );
+}
+
+void tst_QSqlQuery::outValuesDB2()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driver()->hasFeature( QSqlDriver::PreparedQueries ) ) {
+        QSKIP( "Test requires prepared query support", SkipSingle );
+        return;
+    }
+
+    QSqlQuery q( db );
+
+    q.setForwardOnly( true );
+
+    q.exec( "drop procedure " + qTableName( "tst_outValues", __FILE__ ) ); //non-fatal
+    QVERIFY_SQL( q, exec( "CREATE PROCEDURE " + qTableName( "tst_outValues", __FILE__ ) +
+                            " (OUT x int, OUT x2 double, OUT x3 char(20))\n"
+                            "LANGUAGE SQL\n"
+                            "P1: BEGIN\n"
+                            " SET x = 42;\n"
+                            " SET x2 = 4.2;\n"
+                            " SET x3 = 'Homer';\n"
+                            "END P1" ) );
+
+    QVERIFY_SQL( q, prepare( "call " + qTableName( "tst_outValues", __FILE__ ) + "(?, ?, ?)" ) );
+
+    q.addBindValue( 0, QSql::Out );
+    q.addBindValue( 0.0, QSql::Out );
+    q.addBindValue( "Simpson", QSql::Out );
+
+    QVERIFY_SQL( q, exec() );
+
+    QCOMPARE( q.boundValue( 0 ).toInt(), 42 );
+    QCOMPARE( q.boundValue( 1 ).toDouble(), 4.2 );
+    QCOMPARE( q.boundValue( 2 ).toString().trimmed(), QString( "Homer" ) );
+}
+
+void tst_QSqlQuery::outValues()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString tst_outValues(qTableName("tst_outValues", __FILE__));
+
+    if ( !db.driver()->hasFeature( QSqlDriver::PreparedQueries ) ) {
+        QSKIP( "Test requires prepared query support", SkipSingle );
+        return;
+    }
+
+    QSqlQuery q( db );
+
+    q.setForwardOnly( true );
+
+    if ( db.driverName().startsWith( "QOCI" ) ) {
+        QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x out int) is\n"
+                                "begin\n"
+                                "    x := 42;\n"
+                                "end;\n" ) );
+        QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );
+    } else if ( db.driverName().startsWith( "QDB2" ) ) {
+        q.exec( "drop procedure " + tst_outValues ); //non-fatal
+        QVERIFY_SQL( q, exec( "CREATE PROCEDURE " + tst_outValues + " (OUT x int)\n"
+                                "LANGUAGE SQL\n"
+                                "P1: BEGIN\n"
+                                " SET x = 42;\n"
+                                "END P1" ) );
+        QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );
+    } else if ( tst_Databases::isSqlServer( db ) ) {
+        q.exec( "drop procedure " + tst_outValues );  //non-fatal
+        QVERIFY_SQL( q, exec( "create procedure " + tst_outValues + " (@x int out) as\n"
+                                "begin\n"
+                                "    set @x = 42\n"
+                                "end\n" ) );
+        QVERIFY( q.prepare( "{call " + tst_outValues + "(?)}" ) );
+    } else {
+        QSKIP( "Don't know how to create a stored procedure for this database server, please fix this test", SkipSingle );
+        return;
+    }
+
+    q.addBindValue( 0, QSql::Out );
+
+    QVERIFY_SQL( q, exec() );
+
+    QCOMPARE( q.boundValue( 0 ).toInt(), 42 );
+}
+
+void tst_QSqlQuery::blob()
+{
+    static const int BLOBSIZE = 1024 * 10;
+    static const int BLOBCOUNT = 2;
+
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driver()->hasFeature( QSqlDriver::BLOB ) )
+        QSKIP( "DBMS not BLOB capable", SkipSingle );
+
+    //don' make it too big otherwise sybase and mysql will complain
+    QByteArray ba( BLOBSIZE, 0 );
+
+    int i;
+
+    for ( i = 0; i < ( int )ba.size(); ++i )
+        ba[i] = i % 256;
+
+    QSqlQuery q( db );
+
+    q.setForwardOnly( true );
+
+    QString queryString = QString( "create table " + qTableName( "qtest_blob", __FILE__ ) +
+                                   " (id int not null primary key, t_blob %1)" ).arg( tst_Databases::blobTypeName( db, BLOBSIZE ) );
+    QVERIFY_SQL( q, exec( queryString ) );
+
+    QVERIFY_SQL( q, prepare( "insert into " + qTableName( "qtest_blob", __FILE__ ) + " (id, t_blob) values (?, ?)" ) );
+
+    for ( i = 0; i < BLOBCOUNT; ++i ) {
+        q.addBindValue( i );
+        q.addBindValue( ba );
+        QVERIFY_SQL( q, exec() );
+    }
+
+    QVERIFY_SQL( q, exec( "select * from " + qTableName( "qtest_blob", __FILE__ ) ) );
+
+    for ( i = 0; i < BLOBCOUNT; ++i ) {
+        QVERIFY( q.next() );
+        QByteArray res = q.value( 1 ).toByteArray();
+        QVERIFY2( res.size() >= ba.size(),
+                  QString( "array sizes differ, expected %1, got %2" ).arg( ba.size() ).arg( res.size() ).toLatin1() );
+
+        for ( int i2 = 0; i2 < ( int )ba.size(); ++i2 ) {
+            if ( res[i2] != ba[i2] )
+                QFAIL( QString( "ByteArrays differ at position %1, expected %2, got %3" ).arg(
+                           i2 ).arg(( int )( unsigned char )ba[i2] ).arg(( int )( unsigned char )res[i2] ).toLatin1() );
+        }
+    }
+}
+
+void tst_QSqlQuery::value()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY_SQL( q, exec( "select id, t_varchar, t_char from " + qtest + " order by id" ) );
+    int i = 1;
+
+    while ( q.next() ) {
+        QCOMPARE( q.value( 0 ).toInt(), i );
+
+        if ( db.driverName().startsWith( "QIBASE" ) )
+            QVERIFY( q.value( 1 ).toString().startsWith( "VarChar" + QString::number( i ) ) );
+        else if ( q.value( 1 ).toString().right( 1 ) == " " )
+            QCOMPARE( q.value( 1 ).toString(), ( "VarChar" + QString::number( i ) + "            " ) );
+        else
+            QCOMPARE( q.value( 1 ).toString(), ( "VarChar" + QString::number( i ) ) );
+
+        if ( db.driverName().startsWith( "QIBASE" ) )
+            QVERIFY( q.value( 2 ).toString().startsWith( "Char" + QString::number( i ) ) );
+        else if ( q.value( 2 ).toString().right( 1 ) != " " )
+            QCOMPARE( q.value( 2 ).toString(), ( "Char" + QString::number( i ) ) );
+        else
+            QCOMPARE( q.value( 2 ).toString(), ( "Char" + QString::number( i ) + "               " ) );
+
+        i++;
+    }
+}
+
+void tst_QSqlQuery::record()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY( q.record().isEmpty() );
+    QVERIFY_SQL( q, exec( "select id, t_varchar, t_char from " + qtest + " order by id" ) );
+    QCOMPARE( q.record().fieldName( 0 ).toLower(), QString( "id" ) );
+    QCOMPARE( q.record().fieldName( 1 ).toLower(), QString( "t_varchar" ) );
+    QCOMPARE( q.record().fieldName( 2 ).toLower(), QString( "t_char" ) );
+    QCOMPARE(q.record().value(0), QVariant(q.record().field(0).type()));
+    QCOMPARE(q.record().value(1), QVariant(q.record().field(1).type()));
+    QCOMPARE(q.record().value(2), QVariant(q.record().field(2).type()));
+
+    QVERIFY( q.next() );
+    QVERIFY( q.next() );
+
+    QCOMPARE( q.record().fieldName( 0 ).toLower(), QString( "id" ) );
+    QCOMPARE( q.value( 0 ).toInt(), 2 );
+}
+
+void tst_QSqlQuery::isValid()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY( !q.isValid() );
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    QVERIFY( q.first() );
+    QVERIFY( q.isValid() );
+}
+
+void tst_QSqlQuery::isActive()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY( !q.isActive() );
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    QVERIFY( q.isActive() );
+    QVERIFY( q.last() );
+
+    if ( !tst_Databases::isMSAccess( db ) )
+        // Access is stupid enough to let you scroll over boundaries
+        QVERIFY( !q.next() );
+
+    QVERIFY( q.isActive() );
+
+    QVERIFY_SQL( q, exec( "insert into " + qtest + " values (41, 'VarChar41', 'Char41')" ) );
+
+    QVERIFY( q.isActive() );
+
+    QVERIFY_SQL( q, exec( "update " + qtest + " set id = 42 where id = 41" ) );
+
+    QVERIFY( q.isActive() );
+
+    QVERIFY_SQL( q, exec( "delete from " + qtest + " where id = 42" ) );
+
+    QVERIFY( q.isActive() );
+}
+
+void tst_QSqlQuery::numRowsAffected()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QCOMPARE( q.numRowsAffected(), -1 );
+
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    int i = 0;
+
+    while ( q.next() )
+        ++i;
+
+    if ( q.numRowsAffected() == -1 || q.numRowsAffected() == 0 )
+        QSKIP("Database doesn't support numRowsAffected", SkipSingle);
+
+    if ( q.numRowsAffected() != -1 && q.numRowsAffected() != 0 && q.numRowsAffected() != i ) {
+        // the value is undefined for SELECT, this check is just here for curiosity
+        qDebug( "Expected numRowsAffected to be -1, 0 or %d, got %d", i, q.numRowsAffected() );
+    }
+
+    QVERIFY_SQL( q, exec( "update " + qtest + " set id = 100 where id = 1" ) );
+
+    QCOMPARE( q.numRowsAffected(), 1 );
+    QCOMPARE( q.numRowsAffected(), 1 ); // yes, we check twice
+
+    QVERIFY_SQL( q, exec( "update " + qtest + " set id = id + 100" ) );
+    QCOMPARE( q.numRowsAffected(), i );
+    QCOMPARE( q.numRowsAffected(), i ); // yes, we check twice
+
+    QVERIFY_SQL( q, exec( "insert into " + qtest + " values (42000, 'homer', 'marge')" ) );
+    QCOMPARE( q.numRowsAffected(), 1 );
+    QCOMPARE( q.numRowsAffected(), 1 ); // yes, we check twice
+
+    QSqlQuery q2( db );
+    QVERIFY_SQL( q2, exec( "insert into " + qtest + " values (42001, 'homer', 'marge')" ) );
+
+    if ( !db.driverName().startsWith( "QSQLITE2" ) ) {
+        // SQLite 2.x accumulates changed rows in nested queries. See task 33794
+        QCOMPARE( q2.numRowsAffected(), 1 );
+        QCOMPARE( q2.numRowsAffected(), 1 ); // yes, we check twice
+    }
+}
+
+void tst_QSqlQuery::size()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QCOMPARE( q.size(), -1 );
+
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    int i = 0;
+
+    while ( q.next() )
+        ++i;
+
+    if ( db.driver()->hasFeature( QSqlDriver::QuerySize ) ) {
+        QCOMPARE( q.size(), i );
+        QCOMPARE( q.size(), i ); // yes, twice
+    } else {
+        QCOMPARE( q.size(), -1 );
+        QCOMPARE( q.size(), -1 ); // yes, twice
+    }
+
+    QSqlQuery q2( "select * from " + qtest, db );
+
+    if ( db.driver()->hasFeature( QSqlDriver::QuerySize ) )
+        QCOMPARE( q.size(), i );
+    else
+        QCOMPARE( q.size(), -1 );
+
+    q2.clear();
+
+    QVERIFY_SQL( q, exec( "update " + qtest + " set id = 100 where id = 1" ) );
+    QCOMPARE( q.size(), -1 );
+    QCOMPARE( q.size(), -1 ); // yes, twice
+}
+
+void tst_QSqlQuery::isSelect()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    QVERIFY( q.isSelect() );
+
+    QVERIFY_SQL( q, exec( "update " + qtest + " set id = 1 where id = 1" ) );
+    QVERIFY( q.isSelect() == false );
+}
+
+void tst_QSqlQuery::first()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY( q.at() == QSql::BeforeFirstRow );
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    QVERIFY( q.last() );
+    QVERIFY_SQL( q, first() );
+    QVERIFY( q.at() == 0 );
+}
+
+void tst_QSqlQuery::next()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY( q.at() == QSql::BeforeFirstRow );
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    QVERIFY( q.first() );
+    QVERIFY( q.next() );
+    QVERIFY( q.at() == 1 );
+}
+
+void tst_QSqlQuery::prev()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY( q.at() == QSql::BeforeFirstRow );
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    QVERIFY( q.first() );
+    QVERIFY( q.next() );
+    QVERIFY( q.previous() );
+    QVERIFY( q.at() == 0 );
+}
+
+void tst_QSqlQuery::last()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QCOMPARE( q.at(), int( QSql::BeforeFirstRow ) );
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    int i = 0;
+
+    while ( q.next() )
+        i++;
+
+    QCOMPARE( q.at(), int( QSql::AfterLastRow ) );
+
+    QVERIFY( q.last() );
+
+    QSet<int> validReturns(QSet<int>() << -1 << i-1);
+    QVERIFY( validReturns.contains(q.at()) );
+
+    QSqlQuery q2( "select * from " + qtest, db );
+
+    QVERIFY( q2.last() );
+
+    QVERIFY( validReturns.contains(q.at()) );
+}
+
+void tst_QSqlQuery::seek()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    QSqlQuery q( db );
+    QVERIFY( q.at() == QSql::BeforeFirstRow );
+    QVERIFY_SQL( q, exec( QString( "select id from %1 order by id" ).arg( qtest ) ) );
+
+    // NB! The order of the calls below are important!
+    QVERIFY( q.last() );
+    QVERIFY( !q.seek( QSql::BeforeFirstRow ) );
+    QCOMPARE( q.at(), int( QSql::BeforeFirstRow ) );
+    QVERIFY( q.seek( 0 ) );
+    QCOMPARE( q.at(), 0 );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+
+    QVERIFY( q.seek( 1 ) );
+    QCOMPARE( q.at(), 1 );
+    QCOMPARE( q.value( 0 ).toInt(), 2 );
+
+    QVERIFY( q.seek( 3 ) );
+    QCOMPARE( q.at(), 3 );
+    QCOMPARE( q.value( 0 ).toInt(), 4 );
+
+    QVERIFY( q.seek( -2, true ) );
+    QCOMPARE( q.at(), 1 );
+    QVERIFY( q.seek( 0 ) );
+    QCOMPARE( q.at(), 0 );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+}
+
+void tst_QSqlQuery::seekForwardOnlyQuery()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    q.setForwardOnly( false );
+    QVERIFY( !q.isForwardOnly() );
+
+    QVERIFY( q.at() == QSql::BeforeFirstRow );
+    QVERIFY_SQL( q, exec( QString( "select id from %1 order by id" ).arg( qtest ) ) );
+
+    QSqlRecord rec;
+
+    // NB! The order of the calls below are important!
+    QVERIFY( q.seek( 0 ) );
+    QCOMPARE( q.at(), 0 );
+    rec = q.record();
+    QCOMPARE( rec.value( 0 ).toInt(), 1 );
+
+    QVERIFY( q.seek( 1 ) );
+    QCOMPARE( q.at(), 1 );
+    rec = q.record();
+    QCOMPARE( rec.value( 0 ).toInt(), 2 );
+
+    // Make a jump!
+    QVERIFY( q.seek( 3 ) );
+    QCOMPARE( q.at(), 3 );
+    rec = q.record();
+    QCOMPARE( rec.value( 0 ).toInt(), 4 );
+
+    // Last record in result set
+    QVERIFY( q.seek( 4 ) );
+    QCOMPARE( q.at(), 4 );
+    rec = q.record();
+    QCOMPARE( rec.value( 0 ).toInt(), 5 );
+}
+
+// tests the forward only mode;
+void tst_QSqlQuery::forwardOnly()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    q.setForwardOnly( true );
+    QVERIFY( q.isForwardOnly() );
+    QVERIFY( q.at() == QSql::BeforeFirstRow );
+    QVERIFY_SQL( q, exec( "select * from " + qtest + " order by id" ) );
+    QVERIFY( q.at() == QSql::BeforeFirstRow );
+    QVERIFY( q.first() );
+    QCOMPARE( q.at(), 0 );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QVERIFY( q.next() );
+    QCOMPARE( q.at(), 1 );
+    QCOMPARE( q.value( 0 ).toInt(), 2 );
+    QVERIFY( q.next() );
+    QCOMPARE( q.at(), 2 );
+    QCOMPARE( q.value( 0 ).toInt(), 3 );
+
+    // lets make some mistakes to see how robust it is
+    QTest::ignoreMessage( QtWarningMsg, "QSqlQuery::seek: cannot seek backwards in a forward only query" );
+    QVERIFY( q.first() == false );
+    QCOMPARE( q.at(), 2 );
+    QCOMPARE( q.value( 0 ).toInt(), 3 );
+    QTest::ignoreMessage( QtWarningMsg, "QSqlQuery::seek: cannot seek backwards in a forward only query" );
+    QVERIFY( q.previous() == false );
+    QCOMPARE( q.at(), 2 );
+    QCOMPARE( q.value( 0 ).toInt(), 3 );
+    QVERIFY( q.next() );
+    QCOMPARE( q.at(), 3 );
+    QCOMPARE( q.value( 0 ).toInt(), 4 );
+
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    int i = 0;
+
+    while ( q.next() )
+        i++;
+
+    QVERIFY( q.at() == QSql::AfterLastRow );
+
+    QSqlQuery q2 = q;
+
+    QVERIFY( q2.isForwardOnly() );
+
+    QVERIFY_SQL( q, exec( "select * from " + qtest + " order by id" ) );
+
+    QVERIFY( q.isForwardOnly() );
+
+    QVERIFY( q2.isForwardOnly() );
+
+    QCOMPARE( q.at(), int( QSql::BeforeFirstRow ) );
+
+    QVERIFY_SQL( q, seek( 3 ) );
+
+    QCOMPARE( q.at(), 3 );
+
+    QCOMPARE( q.value( 0 ).toInt(), 4 );
+
+    QTest::ignoreMessage( QtWarningMsg, "QSqlQuery::seek: cannot seek backwards in a forward only query" );
+
+    QVERIFY( q.seek( 0 ) == false );
+
+    QCOMPARE( q.value( 0 ).toInt(), 4 );
+
+    QCOMPARE( q.at(), 3 );
+
+    QVERIFY( q.last() );
+
+    QCOMPARE( q.at(), i-1 );
+
+    QTest::ignoreMessage( QtWarningMsg, "QSqlQuery::seek: cannot seek backwards in a forward only query" );
+
+    QVERIFY( q.first() == false );
+
+    QCOMPARE( q.at(), i-1 );
+
+    QVERIFY( q.next() == false );
+
+    QCOMPARE( q.at(), int( QSql::AfterLastRow ) );
+}
+
+void tst_QSqlQuery::query_exec()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY( !q.isValid() );
+    QVERIFY( !q.isActive() );
+    QVERIFY_SQL( q, exec( "select * from " + qtest ) );
+    QVERIFY( q.isActive() );
+    QVERIFY( q.next() );
+    QVERIFY( q.isValid() );
+}
+
+void tst_QSqlQuery::isNull()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY_SQL( q, exec( "select id, t_varchar from " + qTableName( "qtest_null", __FILE__ ) + " order by id" ) );
+    QVERIFY( q.next() );
+    QVERIFY( !q.isNull( 0 ) );
+    QVERIFY( q.isNull( 1 ) );
+    QCOMPARE( q.value( 0 ).toInt(), 0 );
+    QCOMPARE( q.value( 1 ).toString(), QString() );
+    QVERIFY( !q.value( 0 ).isNull() );
+    QVERIFY( q.value( 1 ).isNull() );
+
+    QVERIFY( q.next() );
+    QVERIFY( !q.isNull( 0 ) );
+    QVERIFY( !q.isNull( 1 ) );
+}
+
+/*! TDS specific BIT field test */
+void tst_QSqlQuery::bitField()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driverName().startsWith( "QTDS" ) )
+        QSKIP( "TDS specific test", SkipSingle );
+
+    QSqlQuery q( db );
+
+    QVERIFY_SQL( q, exec( "create table " + qTableName( "qtest_bittest", __FILE__ ) + " (bitty bit)" ) );
+
+    QVERIFY_SQL( q, exec( "insert into " + qTableName( "qtest_bittest", __FILE__ ) + " values (0)" ) );
+
+    QVERIFY_SQL( q, exec( "insert into " + qTableName( "qtest_bittest", __FILE__ ) + " values (1)" ) );
+
+    QVERIFY_SQL( q, exec( "select bitty from " + qTableName( "qtest_bittest", __FILE__ ) ) );
+
+    QVERIFY( q.next() );
+
+    QVERIFY( q.value( 0 ).toInt() == 0 );
+
+    QVERIFY( q.next() );
+
+    QVERIFY( q.value( 0 ).toInt() == 1 );
+}
+
+
+/*! Oracle specific NULL BLOB test */
+void tst_QSqlQuery::nullBlob()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString qtest_nullblob(qTableName("qtest_nullblob", __FILE__));
+
+    QSqlQuery q( db );
+    QVERIFY_SQL( q, exec( "create table " + qtest_nullblob + " (id int primary key, bb blob)" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_nullblob + " values (0, EMPTY_BLOB())" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_nullblob + " values (1, NULL)" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_nullblob + " values (2, 'aabbcc00112233445566')" ) );
+    // necessary otherwise oracle will bombard you with internal errors
+    q.setForwardOnly( true );
+    QVERIFY_SQL( q, exec( "select * from " + qtest_nullblob + " order by id" ) );
+
+    QVERIFY( q.next() );
+    QCOMPARE(( int )q.value( 1 ).toByteArray().size(), 0 );
+    QVERIFY( !q.isNull( 1 ) );
+
+    QVERIFY( q.next() );
+    QCOMPARE(( int )q.value( 1 ).toByteArray().size(), 0 );
+    QVERIFY( q.isNull( 1 ) );
+
+    QVERIFY( q.next() );
+    QCOMPARE(( int )q.value( 1 ).toByteArray().size(), 10 );
+    QVERIFY( !q.isNull( 1 ) );
+}
+
+/* Oracle specific RAW field test */
+void tst_QSqlQuery::rawField()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString qtest_rawtest(qTableName("qtest_rawtest", __FILE__));
+
+    QSqlQuery q( db );
+    q.setForwardOnly( true );
+    QVERIFY_SQL( q, exec( "create table " + qtest_rawtest +
+                            " (id int, col raw(20))" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_rawtest + " values (0, NULL)" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtest_rawtest + " values (1, '00aa1100ddeeff')" ) );
+    QVERIFY_SQL( q, exec( "select col from " + qtest_rawtest + " order by id" ) );
+    QVERIFY( q.next() );
+    QVERIFY( q.isNull( 0 ) );
+    QCOMPARE(( int )q.value( 0 ).toByteArray().size(), 0 );
+    QVERIFY( q.next() );
+    QVERIFY( !q.isNull( 0 ) );
+    QCOMPARE(( int )q.value( 0 ).toByteArray().size(), 7 );
+}
+
+// test whether we can fetch values with more than DOUBLE precision
+// note that MySQL's 3.x highest precision is that of a double, although
+// you can define field with higher precision
+void tst_QSqlQuery::precision()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString qtest_precision(qTableName( "qtest_precision", __FILE__ ));
+
+    static const char* precStr = "1.2345678901234567891";
+
+    if ( db.driverName().startsWith( "QIBASE" ) )
+        QSKIP( "DB unable to store high precision", SkipSingle );
+
+    {
+        // need a new scope for SQLITE
+        QSqlQuery q( db );
+
+        if ( tst_Databases::isMSAccess( db ) )
+            QVERIFY_SQL( q, exec( "create table " + qtest_precision + " (col1 number)" ) );
+        else
+            QVERIFY_SQL( q, exec( "create table " + qtest_precision + " (col1 numeric(21, 20))" ) );
+
+        QVERIFY_SQL( q, exec( "insert into " + qtest_precision + " (col1) values (1.2345678901234567891)" ) );
+
+        QVERIFY_SQL( q, exec( "select * from " + qtest_precision ) );
+        QVERIFY( q.next() );
+
+        QString val = q.value( 0 ).toString();
+
+        if ( !val.startsWith( "1.2345678901234567891" ) ) {
+            int i = 0;
+
+            while ( precStr[i] != 0 && *( precStr + i ) == val[i].toLatin1() )
+                i++;
+
+            // MySQL and TDS have crappy precisions by default
+            if ( db.driverName().startsWith( "QMYSQL" ) ) {
+                if ( i < 17 )
+                    QWARN( "MySQL didn't return the right precision" );
+            } else if ( db.driverName().startsWith( "QTDS" ) ) {
+                if ( i < 18 )
+                    QWARN( "TDS didn't return the right precision" );
+            } else {
+                QWARN( QString( tst_Databases::dbToString( db ) + " didn't return the right precision (" +
+                                QString::number( i ) + " out of 21), " + val ).toLatin1() );
+            }
+        }
+    } // SQLITE scope
+}
+
+void tst_QSqlQuery::nullResult()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY_SQL( q, exec( "select * from " + qtest + " where id > 50000" ) );
+
+    if ( q.driver()->hasFeature( QSqlDriver::QuerySize ) )
+        QCOMPARE( q.size(), 0 );
+
+    QVERIFY( q.next() == false );
+
+    QVERIFY( q.first() == false );
+    QVERIFY( q.last() == false );
+    QVERIFY( q.previous() == false );
+    QVERIFY( q.seek( 10 ) == false );
+    QVERIFY( q.seek( 0 ) == false );
+}
+
+// this test is just an experiment to see whether we can do query-based transactions
+// the real transaction test is in tst_QSqlDatabase
+void tst_QSqlQuery::transaction()
+{
+    // query based transaction is not really possible with Qt
+    QSKIP( "only tested manually by trained staff", SkipAll );
+
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driver()->hasFeature( QSqlDriver::Transactions ) )
+        QSKIP( "DBMS not transaction capable", SkipSingle );
+
+    // this is the standard SQL
+    QString startTransactionStr( "start transaction" );
+
+    if ( db.driverName().startsWith( "QMYSQL" ) )
+        startTransactionStr = "begin work";
+
+    QSqlQuery q( db );
+
+    QSqlQuery q2( db );
+
+    // test a working transaction
+    q.exec( startTransactionStr );
+
+    QVERIFY_SQL( q, exec( "insert into" + qtest + " values (40, 'VarChar40', 'Char40')" ) );
+
+    QVERIFY_SQL( q, exec( "select * from" + qtest + " where id = 40" ) );
+
+    QVERIFY( q.next() );
+
+    QCOMPARE( q.value( 0 ).toInt(), 40 );
+
+    QVERIFY_SQL( q, exec( "commit" ) );
+
+    QVERIFY_SQL( q, exec( "select * from" + qtest + " where id = 40" ) );
+
+    QVERIFY( q.next() );
+
+    QCOMPARE( q.value( 0 ).toInt(), 40 );
+
+    // test a rollback
+    q.exec( startTransactionStr );
+
+    QVERIFY_SQL( q, exec( "insert into" + qtest + " values (41, 'VarChar41', 'Char41')" ) );
+
+    QVERIFY_SQL( q, exec( "select * from" + qtest + " where id = 41" ) );
+
+    QVERIFY( q.next() );
+
+    QCOMPARE( q.value( 0 ).toInt(), 41 );
+
+    if ( !q.exec( "rollback" ) ) {
+        if ( db.driverName().startsWith( "QMYSQL" ) ) {
+            qDebug( "MySQL: %s", qPrintable(tst_Databases::printError( q.lastError() ) ));
+            QSKIP( "MySQL transaction failed ", SkipSingle ); //non-fatal
+        } else
+            QFAIL( "Could not rollback transaction: " + tst_Databases::printError( q.lastError() ) );
+    }
+
+    QVERIFY_SQL( q, exec( "select * from" + qtest + " where id = 41" ) );
+
+    QVERIFY( q.next() == false );
+
+    // test concurrent access
+    q.exec( startTransactionStr );
+    QVERIFY_SQL( q, exec( "insert into" + qtest + " values (42, 'VarChar42', 'Char42')" ) );
+    QVERIFY_SQL( q, exec( "select * from" + qtest + " where id = 42" ) );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 42 );
+
+    QVERIFY_SQL( q2, exec( "select * from" + qtest + " where id = 42" ) );
+
+    if ( q2.next() )
+        qDebug("DBMS '%s' doesn't support query based transactions with concurrent access",
+               qPrintable(tst_Databases::dbToString( db )));
+
+    QVERIFY_SQL( q, exec( "commit" ) );
+
+    QVERIFY_SQL( q2, exec( "select * from" + qtest + " where id = 42" ) );
+
+    QVERIFY( q2.next() );
+
+    QCOMPARE( q2.value( 0 ).toInt(), 42 );
+}
+
+void tst_QSqlQuery::joins()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString qtestj1(qTableName("qtestj1", __FILE__)), qtestj2(qTableName("qtestj2", __FILE__));
+
+    if ( db.driverName().startsWith( "QOCI" )
+            || db.driverName().startsWith( "QTDS" )
+            || db.driverName().startsWith( "QODBC" )
+            || db.driverName().startsWith( "QIBASE" ) ) {
+        // Oracle broken beyond recognition - cannot outer join on more than
+        // one table.
+        QSKIP( "DBMS cannot understand standard SQL", SkipSingle );
+        return;
+    }
+
+    QSqlQuery q( db );
+
+    QVERIFY_SQL( q, exec( "create table " + qtestj1 + " (id1 int, id2 int)" ) );
+    QVERIFY_SQL( q, exec( "create table " + qtestj2 + " (id int, name varchar(20))" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtestj1 + " values (1, 1)" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtestj1 + " values (1, 2)" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtestj2 + " values(1, 'trenton')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + qtestj2 + " values(2, 'marius')" ) );
+
+    QVERIFY_SQL( q, exec( "select qtestj1.id1, qtestj1.id2, qtestj2.id, qtestj2.name, qtestj3.id, qtestj3.name "
+                            "from " + qtestj1 + " qtestj1 left outer join " + qtestj2 +
+                            " qtestj2 on (qtestj1.id1 = qtestj2.id) "
+                            "left outer join " + qtestj2 + " as qtestj3 on (qtestj1.id2 = qtestj3.id)" ) );
+
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QCOMPARE( q.value( 1 ).toInt(), 1 );
+    QCOMPARE( q.value( 2 ).toInt(), 1 );
+    QCOMPARE( q.value( 3 ).toString(), QString( "trenton" ) );
+    QCOMPARE( q.value( 4 ).toInt(), 1 );
+    QCOMPARE( q.value( 5 ).toString(), QString( "trenton" ) );
+
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QCOMPARE( q.value( 1 ).toInt(), 2 );
+    QCOMPARE( q.value( 2 ).toInt(), 1 );
+    QCOMPARE( q.value( 3 ).toString(), QString( "trenton" ) );
+    QCOMPARE( q.value( 4 ).toInt(), 2 );
+    QCOMPARE( q.value( 5 ).toString(), QString( "marius" ) );
+}
+
+void tst_QSqlQuery::synonyms()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q(db);
+    QVERIFY_SQL( q, exec("select a.id, a.t_char, a.t_varchar from " + qtest + " a where a.id = 1") );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QCOMPARE( q.value( 1 ).toString().trimmed(), QString( "Char1" ) );
+    QCOMPARE( q.value( 2 ).toString().trimmed(), QString( "VarChar1" ) );
+
+    QSqlRecord rec = q.record();
+    QCOMPARE(( int )rec.count(), 3 );
+    QCOMPARE( rec.field( 0 ).name().toLower(), QString( "id" ) );
+    QCOMPARE( rec.field( 1 ).name().toLower(), QString( "t_char" ) );
+    QCOMPARE( rec.field( 2 ).name().toLower(), QString( "t_varchar" ) );
+}
+
+// It doesn't make sense to split this into several tests
+void tst_QSqlQuery::prepare_bind_exec()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString qtest_prepare(qTableName("qtest_prepare", __FILE__));
+
+    if(db.driverName().startsWith("QIBASE") && (db.databaseName() == "silence.nokia.troll.no:c:\\ibase\\testdb_ascii" || db.databaseName() == "/opt/interbase/qttest.gdb"))
+        QSKIP("Can't transliterate extended unicode to ascii", SkipSingle);
+    if(db.driverName().startsWith("QDB2"))
+        QSKIP("Needs someone with more Unicode knowledge than I have to fix", SkipSingle);
+
+    {
+        // new scope for SQLITE
+        static const QString utf8str = QString::fromUtf8( "काचं शक्नोम्यत्तुम् । नोपहिनस्ति माम् ॥" );
+
+        static const QString values[6] = { "Harry", "Trond", "Mark", "Ma?rk", "?", ":id" };
+
+        bool useUnicode = db.driver()->hasFeature( QSqlDriver::Unicode );
+
+        QSqlQuery q( db );
+
+        if ( db.driverName().startsWith( "QMYSQL" ) && tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt()<5 )
+            useUnicode = false;
+
+        QString createQuery;
+
+        if(tst_Databases::isPostgreSQL(db))
+            QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+
+        if ( tst_Databases::isSqlServer( db ) || db.driverName().startsWith( "QTDS" ) )
+            createQuery = "create table " + qtest_prepare + " (id int primary key, name nvarchar(200) null)";
+        else if ( tst_Databases::isMySQL(db) && useUnicode )
+            createQuery = "create table " + qtest_prepare + " (id int not null primary key, name varchar(200) character set utf8)";
+        else
+            createQuery = "create table " + qtest_prepare + " (id int not null primary key, name varchar(200))";
+
+        QVERIFY_SQL( q, exec( createQuery ) );
+
+        QVERIFY( q.prepare( "insert into " + qtest_prepare + " (id, name) values (:id, :name)" ) );
+        int i;
+
+        for ( i = 0; i < 6; ++i ) {
+            q.bindValue( ":name", values[i] );
+            q.bindValue( ":id", i );
+            QVERIFY_SQL( q, exec() );
+            QMap<QString, QVariant> m = q.boundValues();
+            QCOMPARE(( int ) m.count(), 2 );
+            QCOMPARE( m[":name"].toString(), values[i] );
+            QCOMPARE( m[":id"].toInt(), i );
+        }
+
+        q.bindValue( ":id", 8 );
+
+        QVERIFY_SQL( q, exec() );
+
+        if ( useUnicode ) {
+            q.bindValue( ":id", 7 );
+            q.bindValue( ":name", utf8str );
+            QVERIFY_SQL( q, exec() );
+        }
+
+        QVERIFY_SQL( q, exec( "SELECT * FROM " + qtest_prepare + " order by id" ) );
+
+        for ( i = 0; i < 6; ++i ) {
+            QVERIFY( q.next() );
+            QCOMPARE( q.value( 0 ).toInt(), i );
+            QCOMPARE( q.value( 1 ).toString().trimmed(), values[ i ] );
+        }
+
+        if ( useUnicode ) {
+            QVERIFY_SQL( q, next() );
+            QCOMPARE( q.value( 0 ).toInt(), 7 );
+            QCOMPARE( q.value( 1 ).toString(), utf8str );
+        }
+
+        QVERIFY_SQL( q, next() );
+
+        QCOMPARE( q.value( 0 ).toInt(), 8 );
+        QCOMPARE( q.value( 1 ).toString(), values[5] );
+
+        QVERIFY( q.prepare( "insert into " + qtest_prepare + " (id, name) values (:id, 'Bart')" ) );
+        q.bindValue( ":id", 99 );
+        QVERIFY_SQL( q, exec() );
+        q.bindValue( ":id", 100 );
+        QVERIFY_SQL( q, exec() );
+        QVERIFY( q.exec( "select * from " + qtest_prepare + " where id > 98 order by id" ) );
+
+        for ( i = 99; i <= 100; ++i ) {
+            QVERIFY( q.next() );
+            QCOMPARE( q.value( 0 ).toInt(), i );
+            QCOMPARE( q.value( 1 ).toString().trimmed(), QString( "Bart" ) );
+        }
+
+        /*** SELECT stuff ***/
+        QVERIFY( q.prepare( "select * from " + qtest_prepare + " where id = :id" ) );
+
+        for ( i = 0; i < 6; ++i ) {
+            q.bindValue( ":id", i );
+            QVERIFY_SQL( q, exec() );
+            QVERIFY_SQL( q, next() );
+            QCOMPARE( q.value( 0 ).toInt(), i );
+            QCOMPARE( q.value( 1 ).toString().trimmed(), values[ i ] );
+            QSqlRecord rInf = q.record();
+            QCOMPARE(( int )rInf.count(), 2 );
+            QCOMPARE( rInf.field( 0 ).name().toUpper(), QString( "ID" ) );
+            QCOMPARE( rInf.field( 1 ).name().toUpper(), QString( "NAME" ) );
+            QVERIFY( !q.next() );
+        }
+
+        QVERIFY_SQL( q, exec( "DELETE FROM " + qtest_prepare ) );
+
+        QVERIFY( q.prepare( "insert into " + qtest_prepare + " (id, name) values (?, ?)" ) );
+        q.bindValue( 0, 0 );
+        q.bindValue( 1, values[ 0 ] );
+        QVERIFY_SQL( q, exec() );
+        q.addBindValue( 1 );
+        q.addBindValue( values[ 1 ] );
+        QVERIFY_SQL( q, exec() );
+        q.addBindValue( 2 );
+        q.addBindValue( values[ 2 ] );
+        QVERIFY_SQL( q, exec() );
+        q.addBindValue( 3 );
+        q.addBindValue( values[ 3 ] );
+        QVERIFY_SQL( q, exec() );
+        q.addBindValue( 4 );
+        q.addBindValue( values[ 4 ] );
+        QVERIFY_SQL( q, exec() );
+        q.bindValue( 1, values[ 5 ] );
+        q.bindValue( 0, 5 );
+        QVERIFY_SQL( q, exec() );
+        q.bindValue( 0, 6 );
+        q.bindValue( 1, QString() );
+        QVERIFY_SQL( q, exec() );
+
+        if ( db.driver()->hasFeature( QSqlDriver::Unicode ) ) {
+            q.bindValue( 0, 7 );
+            q.bindValue( 1, utf8str );
+            QVERIFY_SQL( q, exec() );
+        }
+
+        QVERIFY_SQL( q, exec( "SELECT * FROM " + qtest_prepare + " order by id" ) );
+
+        for ( i = 0; i < 6; ++i ) {
+            QVERIFY( q.next() );
+            QCOMPARE( q.value( 0 ).toInt(), i );
+            QCOMPARE( q.value( 1 ).toString().trimmed(), values[ i ] );
+        }
+
+        QVERIFY( q.next() );
+
+        QCOMPARE( q.value( 0 ).toInt(), 6 );
+        QVERIFY( q.isNull( 1 ) );
+
+        if ( useUnicode ) {
+            QVERIFY( q.next() );
+            QCOMPARE( q.value( 0 ).toInt(), 7 );
+            QCOMPARE( q.value( 1 ).toString(), utf8str );
+        }
+
+        QVERIFY( q.prepare( "insert into " + qtest_prepare + " (id, name) values (?, 'Bart')" ) );
+
+        q.bindValue( 0, 99 );
+        QVERIFY_SQL( q, exec() );
+        q.addBindValue( 100 );
+        QVERIFY_SQL( q, exec() );
+        QVERIFY( q.exec( "select * from " + qtest_prepare + " where id > 98 order by id" ) );
+
+        for ( i = 99; i <= 100; ++i ) {
+            QVERIFY( q.next() );
+            QCOMPARE( q.value( 0 ).toInt(), i );
+            QCOMPARE( q.value( 1 ).toString().trimmed(), QString( "Bart" ) );
+        }
+
+        /* insert a duplicate id and make sure the db bails out */
+        QVERIFY( q.prepare( "insert into " + qtest_prepare + " (id, name) values (?, ?)" ) );
+
+        q.addBindValue( 99 );
+
+        q.addBindValue( "something silly" );
+
+        QVERIFY( !q.exec() );
+
+        QVERIFY( q.lastError().isValid() );
+
+        QVERIFY( !q.isActive() );
+
+    } // end of SQLite scope
+}
+
+void tst_QSqlQuery::prepared_select()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY_SQL( q, prepare( "select a.id, a.t_char, a.t_varchar from " + qtest + " a where a.id = ?" ) );
+
+    q.bindValue( 0, 1 );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.at(), ( int )QSql::BeforeFirstRow );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+
+    q.bindValue( 0, 2 );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.at(), ( int )QSql::BeforeFirstRow );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 2 );
+
+    q.bindValue( 0, 3 );
+    QVERIFY_SQL( q, exec() );
+    QCOMPARE( q.at(), ( int )QSql::BeforeFirstRow );
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 3 );
+
+    QVERIFY_SQL( q, prepare( "select a.id, a.t_char, a.t_varchar from " + qtest + " a where a.id = ?" ) );
+    QCOMPARE( q.at(), ( int )QSql::BeforeFirstRow );
+    QVERIFY( !q.first() );
+}
+
+void tst_QSqlQuery::sqlServerLongStrings()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !tst_Databases::isSqlServer( db ) )
+        QSKIP( "SQL Server specific test", SkipSingle );
+
+    QSqlQuery q( db );
+
+    QVERIFY_SQL( q, exec( "CREATE TABLE " + qTableName( "qtest_longstr", __FILE__ ) + " (id int primary key, longstring ntext)" ) );
+
+    QVERIFY_SQL( q, prepare( "INSERT INTO " + qTableName( "qtest_longstr", __FILE__ ) + " VALUES (?, ?)" ) );
+
+    q.addBindValue( 0 );
+
+    q.addBindValue( QString::fromLatin1( "bubu" ) );
+
+    QVERIFY_SQL( q, exec() );
+
+    QString testStr;
+
+    testStr.fill( QLatin1Char( 'a' ), 85000 );
+
+    q.addBindValue( 1 );
+
+    q.addBindValue( testStr );
+
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY_SQL( q, exec( "select * from " + qTableName( "qtest_longstr", __FILE__ ) ) );
+
+    QVERIFY_SQL( q, next() );
+
+    QCOMPARE( q.value( 0 ).toInt(), 0 );
+
+    QCOMPARE( q.value( 1 ).toString(), QString::fromLatin1( "bubu" ) );
+
+    QVERIFY_SQL( q, next() );
+
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+
+    QCOMPARE( q.value( 1 ).toString(), testStr );
+}
+
+void tst_QSqlQuery::invalidQuery()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+
+    QVERIFY( !q.exec() );
+
+    QVERIFY( !q.exec( "blahfasel" ) );
+    QVERIFY( q.lastError().type() != QSqlError::NoError );
+    QVERIFY( !q.next() );
+    QVERIFY( !q.isActive() );
+
+    if ( !db.driverName().startsWith( "QOCI" ) && !db.driverName().startsWith( "QDB2" ) && !db.driverName().startsWith( "QODBC" ) ) {
+        // oracle and db2 just prepares everything without complaining
+        if ( db.driver()->hasFeature( QSqlDriver::PreparedQueries ) )
+            QVERIFY( !q.prepare( "blahfasel" ) );
+    }
+
+    QVERIFY( !q.exec() );
+
+    QVERIFY( !q.isActive() );
+    QVERIFY( !q.next() );
+}
+
+class ResultHelper: public QSqlResult
+{
+
+public:
+    ResultHelper(): QSqlResult( 0 ) {} // don't call, it's only for stupid compilers
+
+    bool execBatch( bool bindArray = false )
+    {
+        return QSqlResult::execBatch( bindArray );
+    }
+};
+
+void tst_QSqlQuery::batchExec()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driver()->hasFeature( QSqlDriver::BatchOperations ) )
+        QSKIP( "Database can't do BatchOperations", SkipSingle );
+
+    QSqlQuery q( db );
+    const QString tableName = qTableName( "qtest_batch", __FILE__ );
+
+    QVERIFY_SQL( q, exec( "create table " + tableName + " (id int, name varchar(20), dt date, num numeric(8, 4))" ) );
+    QVERIFY_SQL( q, prepare( "insert into " + tableName + " (id, name, dt, num) values (?, ?, ?, ?)" ) );
+
+    QVariantList intCol;
+    intCol << 1 << 2 << QVariant( QVariant::Int );
+
+    QVariantList charCol;
+    charCol << QLatin1String( "harald" ) << QLatin1String( "boris" ) << QVariant( QVariant::String );
+
+    QVariantList dateCol;
+    QDateTime dt = QDateTime( QDate::currentDate(), QTime( 1, 2, 3 ) );
+    dateCol << dt << dt.addDays( -1 ) << QVariant( QVariant::DateTime );
+
+    QVariantList numCol;
+    numCol << 2.3 << 3.4 << QVariant( QVariant::Double );
+
+    q.addBindValue( intCol );
+    q.addBindValue( charCol );
+    q.addBindValue( dateCol );
+    q.addBindValue( numCol );
+
+    QVERIFY_SQL( q, execBatch() );
+    QVERIFY_SQL( q, exec( "select id, name, dt, num from " + tableName + " order by id" ) );
+
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QCOMPARE( q.value( 1 ).toString(), QString( "harald" ) );
+    QCOMPARE( q.value( 2 ).toDateTime(), dt );
+    QCOMPARE( q.value( 3 ).toDouble(), 2.3 );
+
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 2 );
+    QCOMPARE( q.value( 1 ).toString(), QString( "boris" ) );
+    QCOMPARE( q.value( 2 ).toDateTime(), dt.addDays( -1 ) );
+    QCOMPARE( q.value( 3 ).toDouble(), 3.4 );
+
+    QVERIFY( q.next() );
+    QVERIFY( q.value( 0 ).isNull() );
+    QVERIFY( q.value( 1 ).isNull() );
+    QVERIFY( q.value( 2 ).isNull() );
+    QVERIFY( q.value( 3 ).isNull() );
+}
+
+void tst_QSqlQuery::oraArrayBind()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driver()->hasFeature( QSqlDriver::BatchOperations ) )
+        QSKIP( "Database can't do BatchOperations", SkipSingle );
+
+    QSqlQuery q( db );
+
+    QVERIFY_SQL( q, exec( "CREATE OR REPLACE PACKAGE ora_array_test "
+                            "IS "
+                            "TYPE names_type IS TABLE OF VARCHAR(64) NOT NULL INDEX BY BINARY_INTEGER; "
+                            "names_tab names_type; "
+                            "PROCEDURE set_name(name_in IN VARCHAR2, row_in in INTEGER); "
+                            "PROCEDURE get_name(row_in IN INTEGER, str_out OUT VARCHAR2); "
+                            "PROCEDURE get_table(tbl OUT names_type); "
+                            "PROCEDURE set_table(tbl IN names_type); "
+                            "END ora_array_test; " ) );
+
+    QVERIFY_SQL( q, exec( "CREATE OR REPLACE PACKAGE BODY ora_array_test "
+                            "IS "
+                            "PROCEDURE set_name(name_in IN VARCHAR2, row_in in INTEGER) "
+                            "IS "
+                            "BEGIN "
+                            "names_tab(row_in) := name_in; "
+                            "END set_name; "
+
+                            "PROCEDURE get_name(row_in IN INTEGER, str_out OUT VARCHAR2) "
+                            "IS "
+                            "BEGIN "
+                            "str_out := names_tab(row_in); "
+                            "END get_name; "
+
+                            "PROCEDURE get_table(tbl OUT names_type) "
+                            "IS "
+                            "BEGIN "
+                            "tbl:=names_tab; "
+                            "END get_table; "
+
+                            "PROCEDURE set_table(tbl IN names_type) "
+                            "IS "
+                            "BEGIN "
+                            "names_tab := tbl; "
+                            "END set_table; "
+                            "END ora_array_test; " ) );
+
+    QVariantList list;
+
+    list << QString( "lorem" ) << QString( "ipsum" ) << QString( "dolor" ) << QString( "sit" ) << QString( "amet" );
+
+    QVERIFY_SQL( q, prepare( "BEGIN "
+                               "ora_array_test.set_table(?); "
+                               "END;" ) );
+
+    q.bindValue( 0, list, QSql::In );
+
+    QVERIFY_SQL( q, execBatch( QSqlQuery::ValuesAsColumns ) );
+
+    QVERIFY_SQL( q, prepare( "BEGIN "
+                               "ora_array_test.get_table(?); "
+                               "END;" ) );
+
+    list.clear();
+
+    list << QString( 64,' ' ) << QString( 64,' ' ) << QString( 64,' ' ) << QString( 64,' ' ) << QString( 64,' ' );
+
+    q.bindValue( 0, list, QSql::Out );
+
+    QVERIFY_SQL( q, execBatch( QSqlQuery::ValuesAsColumns ) );
+
+    QVariantList out_list = q.boundValue( 0 ).toList();
+
+    QCOMPARE( out_list.at( 0 ).toString(), QString( "lorem" ) );
+
+    QCOMPARE( out_list.at( 1 ).toString(), QString( "ipsum" ) );
+
+    QCOMPARE( out_list.at( 2 ).toString(), QString( "dolor" ) );
+
+    QCOMPARE( out_list.at( 3 ).toString(), QString( "sit" ) );
+
+    QCOMPARE( out_list.at( 4 ).toString(), QString( "amet" ) );
+
+    QVERIFY_SQL( q, exec( "DROP PACKAGE ora_array_test" ) );
+}
+
+/*
+    Tests that QSqlDatabase::record and QSqlQuery::record returns the same thing
+    otherwise our models get confused.
+ */
+void tst_QSqlQuery::record_sqlite()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+
+    QVERIFY_SQL( q, exec( "create table "+qTableName( "record_sqlite", __FILE__ )+"(id integer primary key, name varchar, title int)" ) );
+
+    QSqlRecord rec = db.record( qTableName( "record_sqlite", __FILE__ ) );
+
+    QCOMPARE( rec.count(), 3 );
+    QCOMPARE( rec.field( 0 ).type(), QVariant::Int );
+    QCOMPARE( rec.field( 1 ).type(), QVariant::String );
+    QCOMPARE( rec.field( 2 ).type(), QVariant::Int );
+
+    /* important - select from an empty table */
+    QVERIFY_SQL( q, exec( "select id, name, title from "+qTableName( "record_sqlite", __FILE__ ) ) );
+
+    rec = q.record();
+    QCOMPARE( rec.count(), 3 );
+    QCOMPARE( rec.field( 0 ).type(), QVariant::Int );
+    QCOMPARE( rec.field( 1 ).type(), QVariant::String );
+    QCOMPARE( rec.field( 2 ).type(), QVariant::Int );
+}
+
+void tst_QSqlQuery::oraLong()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+
+    QString aLotOfText( 127000, QLatin1Char( 'H' ) );
+
+    QVERIFY_SQL( q, exec( "create table " + qTableName( "qtest_longstr", __FILE__ ) + " (id int primary key, astr long)" ) );
+    QVERIFY_SQL( q, prepare( "insert into " + qTableName( "qtest_longstr", __FILE__ ) + " (id, astr) values (?, ?)" ) );
+    q.addBindValue( 1 );
+    q.addBindValue( aLotOfText );
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY_SQL( q, exec( "select id,astr from " + qTableName( "qtest_longstr", __FILE__ ) ) );
+
+    QVERIFY( q.next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QCOMPARE( q.value( 1 ).toString(), aLotOfText );
+}
+
+void tst_QSqlQuery::execErrorRecovery()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+
+    QVERIFY_SQL( q, exec( "create table " + qTableName( "qtest_exerr", __FILE__ ) + " (id int not null primary key)" ) );
+    QVERIFY_SQL( q, prepare( "insert into " + qTableName( "qtest_exerr", __FILE__ ) + " values (?)" ) );
+
+    q.addBindValue( 1 );
+    QVERIFY_SQL( q, exec() );
+
+    q.addBindValue( 1 ); // binding the same pkey - should fail
+    QVERIFY( !q.exec() );
+
+    q.addBindValue( 2 ); // this should work again
+    QVERIFY_SQL( q, exec() );
+}
+
+void tst_QSqlQuery::lastInsertId()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driver()->hasFeature( QSqlDriver::LastInsertId ) )
+        QSKIP( "Database doesn't support lastInsertId", SkipSingle );
+
+    QSqlQuery q( db );
+
+    QVERIFY_SQL( q, exec( "insert into " + qtest + " values (41, 'VarChar41', 'Char41')" ) );
+
+    QVariant v = q.lastInsertId();
+
+    QVERIFY( v.isValid() );
+}
+
+void tst_QSqlQuery::lastQuery()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QString sql = "select * from " + qtest;
+    QVERIFY_SQL( q, exec( sql ) );
+    QCOMPARE( q.lastQuery(), sql );
+    QCOMPARE( q.executedQuery(), sql );
+}
+
+void tst_QSqlQuery::bindWithDoubleColonCastOperator()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    // Only PostgreSQL support the double-colon cast operator
+
+    if ( !db.driverName().startsWith( "QPSQL" ) ) {
+        QSKIP( "Test requires PostgreSQL", SkipSingle );
+        return;
+    }
+
+    const QString tablename(qTableName( "bindtest", __FILE__ ));
+
+    QSqlQuery q( db );
+
+    QVERIFY_SQL( q, exec( "create table " + tablename + " (id1 int, id2 int, id3 int, fld1 int, fld2 int)" ) );
+    QVERIFY_SQL( q, exec( "insert into " + tablename + " values (1, 2, 3, 10, 5)" ) );
+
+    QVERIFY_SQL( q, prepare( "select sum((fld1 - fld2)::int) from " + tablename + " where id1 = :myid1 and id2 =:myid2 and id3=:myid3" ) );
+    q.bindValue( ":myid1", 1 );
+    q.bindValue( ":myid2", 2 );
+    q.bindValue( ":myid3", 3 );
+
+    QVERIFY_SQL( q, exec() );
+    QVERIFY_SQL( q, next() );
+
+    if ( db.driver()->hasFeature( QSqlDriver::PreparedQueries ) )
+        QCOMPARE( q.executedQuery(), QString( "select sum((fld1 - fld2)::int) from " + tablename + " where id1 = ? and id2 =? and id3=?" ) );
+    else
+        QCOMPARE( q.executedQuery(), QString( "select sum((fld1 - fld2)::int) from " + tablename + " where id1 = 1 and id2 =2 and id3=3" ) );
+}
+
+/* For task 157397: Using QSqlQuery with an invalid QSqlDatabase
+   does not set the last error of the query.
+   This test function will output some warnings, that's ok.
+*/
+void tst_QSqlQuery::queryOnInvalidDatabase()
+{
+    {
+        QTest::ignoreMessage( QtWarningMsg, "QSqlDatabase: INVALID driver not loaded" );
+        QSqlDatabase db = QSqlDatabase::addDatabase( "INVALID", "invalidConnection" );
+        QVERIFY2( db.lastError().isValid(),
+                  qPrintable( QString( "db.lastError().isValid() should be true!" ) ) );
+
+        QTest::ignoreMessage( QtWarningMsg, "QSqlQuery::exec: database not open" );
+        QSqlQuery query( "SELECT 1 AS ID", db );
+        QVERIFY2( query.lastError().isValid(),
+                  qPrintable( QString( "query.lastError().isValid() should be true!" ) ) );
+    }
+
+    QSqlDatabase::removeDatabase( "invalidConnection" );
+
+    {
+        QSqlDatabase db = QSqlDatabase::database( "this connection does not exist" );
+        QTest::ignoreMessage( QtWarningMsg, "QSqlQuery::exec: database not open" );
+        QSqlQuery query( "SELECT 1 AS ID", db );
+        QVERIFY2( query.lastError().isValid(),
+                  qPrintable( QString( "query.lastError().isValid() should be true!" ) ) );
+    }
+}
+
+/* For task 159138: Error on instantiating a sql-query before explicitly
+   opening the database. This is something we don't support, so this isn't
+   really a bug. However some of the drivers are nice enough to support it.
+*/
+void tst_QSqlQuery::createQueryOnClosedDatabase()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    // Only supported by these drivers
+
+    if ( !db.driverName().startsWith( "QPSQL" )
+            && !db.driverName().startsWith( "QOCI" )
+            && !db.driverName().startsWith( "QMYSQL" )
+            && !db.driverName().startsWith( "QDB2" ) ) {
+        QSKIP( "Test is specific for PostgreSQL, Oracle, MySql and DB2", SkipSingle );
+        return;
+    }
+
+    db.close();
+
+    QSqlQuery q( db );
+    db.open();
+    QVERIFY_SQL( q, exec( QString( "select * from %1 where id = 1" ).arg( qtest ) ) );
+
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QCOMPARE( q.value( 1 ).toString().trimmed(), QLatin1String( "VarChar1" ) );
+    QCOMPARE( q.value( 2 ).toString().trimmed(), QLatin1String( "Char1" ) );
+
+    db.close();
+    QVERIFY2( !q.exec( QString( "select * from %1 where id = 1" ).arg( qtest ) ),
+              qPrintable( QString( "This can't happen! The query should not have been executed!" ) ) );
+}
+
+void tst_QSqlQuery::reExecutePreparedForwardOnlyQuery()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    q.setForwardOnly( true );
+
+    QVERIFY_SQL( q, prepare( QString( "SELECT id, t_varchar, t_char FROM %1 WHERE id = :id" ).arg( qtest ) ) );
+    q.bindValue( ":id", 1 );
+    QVERIFY_SQL( q, exec() );
+
+    // Do something, like iterate over the result, or skip to the end
+    QVERIFY_SQL( q, last() );
+
+    QVERIFY_SQL( q, exec() );
+    /* This was broken with SQLite because the cache size was set to 0 in the 2nd execute.
+       When forwardOnly is set we don't cahce the entire result, but we do cache the current row
+       but this requires the cache size to be equal to the column count.
+    */
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QCOMPARE( q.value( 1 ).toString().trimmed(), QString( "VarChar1" ) );
+    QCOMPARE( q.value( 2 ).toString().trimmed(), QString( "Char1" ) );
+}
+
+void tst_QSqlQuery::finish()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    QVERIFY_SQL( q, prepare( "SELECT id FROM " + qtest + " WHERE id = ?" ) );
+
+    int id = 4;
+    q.bindValue( 0, id );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY( q.isActive() );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toInt(), id );
+
+    q.finish();
+    QVERIFY( !q.isActive() ); // query is now inactive
+    QCOMPARE( q.boundValue( 0 ).toInt(), id ); // bound values are retained
+
+    QVERIFY_SQL( q, exec() ); // no prepare necessary
+    QVERIFY( q.isActive() );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toInt(), id );
+
+    q.finish();
+    QVERIFY( !q.isActive() );
+
+    QVERIFY_SQL( q, exec( "SELECT id FROM " + qtest + " WHERE id = 1" ) );
+    QVERIFY( q.isActive() );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toInt(), 1 );
+    QCOMPARE( q.record().count(), 1 );
+}
+
+void tst_QSqlQuery::sqlite_finish()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    if (db.driverName() != QLatin1String("QSQLITE")) {
+        QSKIP("Sqlite3 specific test", SkipSingle);
+        return;
+    }
+
+    if ( db.databaseName().startsWith( ':' ) )
+        QSKIP( "This test requires a database on the filesystem, not in-memory", SkipAll );
+
+    {
+        QSqlDatabase db2 = QSqlDatabase::addDatabase( "QSQLITE", "sqlite_finish_sqlite" );
+        db2.setDatabaseName( db.databaseName() );
+        QVERIFY_SQL( db2, open() );
+
+        const QString tableName(qTableName( "qtest_lockedtable", __FILE__ ));
+        QSqlQuery q( db );
+
+        tst_Databases::safeDropTable( db, tableName );
+        q.exec( "CREATE TABLE " + tableName + " (pk_id INTEGER PRIMARY KEY, whatever TEXT)" );
+        q.exec( "INSERT INTO " + tableName + " values(1, 'whatever')" );
+        q.exec( "INSERT INTO " + tableName + " values(2, 'whatever more')" );
+
+        // This creates a read-lock in the database
+        QVERIFY_SQL( q, exec( "SELECT * FROM " + tableName + " WHERE pk_id = 1 or pk_id = 2" ) );
+        QVERIFY_SQL( q, next() );
+
+        // The DELETE will fail because of the read-lock
+        QSqlQuery q2( db2 );
+        QVERIFY( !q2.exec( "DELETE FROM " + tableName + " WHERE pk_id=2" ) );
+        QCOMPARE( q2.numRowsAffected(), -1 );
+
+        // The DELETE will succeed now because finish() removes the lock
+        q.finish();
+        QVERIFY_SQL( q2, exec( "DELETE FROM " + tableName + " WHERE pk_id=2" ) );
+        QCOMPARE( q2.numRowsAffected(), 1 );
+
+        tst_Databases::safeDropTable( db, tableName );
+    }
+
+    QSqlDatabase::removeDatabase( "sqlite_finish_sqlite" );
+}
+
+void tst_QSqlQuery::nextResult()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driver()->hasFeature( QSqlDriver::MultipleResultSets ) || !db.driver()->hasFeature( QSqlDriver::BatchOperations ) )
+        QSKIP( "DBMS does not support multiple result sets or batch operations", SkipSingle );
+
+    QSqlQuery q( db );
+
+    if ( db.driverName().startsWith( "QMYSQL" ) && tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt()<5 )
+        QSKIP( "Test requires MySQL >= 5.0", SkipSingle );
+
+    enum DriverType { ODBC, MYSQL, DB2 };
+    DriverType driverType = ODBC;
+
+    if ( db.driverName().startsWith( "QMYSQL" ) )
+        driverType = MYSQL;
+    else if ( db.driverName().startsWith( "QDB2" ) )
+        driverType = DB2;
+
+    const QString tableName(qTableName( "more_results", __FILE__ ));
+
+    QVERIFY_SQL( q, exec( "CREATE TABLE " + tableName + " (id integer, text varchar(20), num numeric(6, 3), empty varchar(10));" ) );
+
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " VALUES(1, 'one', 1.1, '');" ) );
+
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " VALUES(2, 'two', 2.2, '');" ) );
+
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " VALUES(3, 'three', 3.3, '');" ) );
+
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " VALUES(4, 'four', 4.4, '');" ) );
+
+    QStringList tstStrings;
+
+    tstStrings << "one" << "two" << "three" << "four";
+
+    // Query that returns only one result set, nothing special about this
+    QVERIFY_SQL( q, exec( QString( "SELECT * FROM %1;" ).arg( tableName ) ) );
+
+    QVERIFY( q.next() );                // Move to first row of the result set
+
+    QVERIFY( !q.nextResult() );         // No more result sets are available
+
+    QVERIFY( !q.isActive() );           // So the query is no longer active
+
+    QVERIFY( !q.next() );               // ... and no data is available as the call
+
+    // to nextResult() discarded the result set
+
+    // Query that returns two result sets (batch sql)
+    // When working with multiple result sets SQL Server insists on non-scrollable cursors
+    if ( driverType == ODBC )
+        q.setForwardOnly( true );
+
+    QVERIFY_SQL( q, exec( "SELECT id FROM " + tableName + "; SELECT text, num FROM " + tableName + ';' ) );
+
+    QCOMPARE( q.record().count(), 1 );  // Check that the meta data is as expected
+
+    QCOMPARE( q.record().field( 0 ).name().toUpper(), QString( "ID" ) );
+
+    QCOMPARE( q.record().field( 0 ).type(), QVariant::Int );
+
+    QVERIFY( q.nextResult() );          // Discards first result set and move to the next
+
+    QCOMPARE( q.record().count(), 2 );  // New meta data should be available
+
+    QCOMPARE( q.record().field( 0 ).name().toUpper(), QString( "TEXT" ) );
+
+    QCOMPARE( q.record().field( 0 ).type(), QVariant::String );
+
+    QCOMPARE( q.record().field( 1 ).name().toUpper(), QString( "NUM" ) );
+
+    if ( driverType == MYSQL )
+        QCOMPARE( q.record().field( 1 ).type(), QVariant::String );
+    else
+        QCOMPARE( q.record().field( 1 ).type(), QVariant::Double );
+
+    QVERIFY( q.next() );                    // Move to first row of the second result set
+
+    QFAIL_SQL(q, nextResult()); // No more result sets after this
+
+    QVERIFY( !q.isActive() );               // So the query is no longer active
+
+    QVERIFY( !q.next() );                   // ... and no data is available as the call to
+
+    // nextResult() discarded the result set
+
+    // Query that returns one result set, a count of affected rows and then another result set
+    QString query1 = QString( "SELECT id, text, num, empty FROM %1 WHERE id <= 3" ).arg( tableName );
+
+    QString query2 = QString( "UPDATE %1 SET empty = 'Yatta!'" ).arg( tableName );
+
+    QString query3 = QString( "SELECT id, empty FROM %1 WHERE id <=2" ).arg( tableName );
+
+    QVERIFY_SQL( q, exec( QString( "%1; %2; %3;" ).arg( query1 ).arg( query2 ).arg( query3 ) ) );
+
+    // Check result set returned by first statement
+    QVERIFY( q.isSelect() );            // The first statement is a select
+
+    for ( int i = 0; i < 3; i++ ) {
+        QVERIFY_SQL( q, next() );
+        QCOMPARE( q.value( 0 ).toInt(), 1+i );
+        QCOMPARE( q.value( 1 ).toString(), tstStrings.at( i ) );
+        QCOMPARE( q.value( 2 ).toDouble(), 1.1*( i+1 ) );
+        QVERIFY( q.value( 3 ).toString().isEmpty() );
+    }
+
+    QVERIFY_SQL( q, nextResult() );
+
+    QVERIFY( !q.isSelect() );           // The second statement isn't a SELECT
+    QVERIFY( !q.next() );               // ... so no result set is available
+    QCOMPARE( q.numRowsAffected(), 4 ); // 4 rows was affected by the UPDATE
+
+    // Check result set returned by third statement
+    QVERIFY_SQL( q, nextResult() );
+    QVERIFY( q.isSelect() );            // The third statement is a SELECT
+
+    for ( int i = 0; i < 2; i++ ) {
+        QVERIFY_SQL( q, next() );
+        QCOMPARE( q.value( 0 ).toInt(), 1+i );
+        QCOMPARE( q.value( 1 ).toString(), QString( "Yatta!" ) );
+    }
+
+    // Stored procedure with multiple result sets
+    const QString procName(qTableName( "proc_more_res", __FILE__ ));
+
+    q.exec( QString( "DROP PROCEDURE %1;" ).arg( procName ) );
+
+    if ( driverType == MYSQL )
+        QVERIFY_SQL( q, exec( QString( "CREATE PROCEDURE %1()"
+                                         "\nBEGIN"
+                                         "\nSELECT id, text FROM %2;"
+                                         "\nSELECT empty, num, text, id FROM %3;"
+                                         "\nEND" ).arg( procName ).arg( tableName ).arg( tableName ) ) );
+    else if ( driverType == DB2 )
+        QVERIFY_SQL( q, exec( QString( "CREATE PROCEDURE %1()"
+                                         "\nRESULT SETS 2"
+                                         "\nLANGUAGE SQL"
+                                         "\np1:BEGIN"
+                                         "\nDECLARE cursor1 CURSOR WITH RETURN FOR SELECT id, text FROM %2;"
+                                         "\nDECLARE cursor2 CURSOR WITH RETURN FOR SELECT empty, num, text, id FROM %3;"
+                                         "\nOPEN cursor1;"
+                                         "\nOPEN cursor2;"
+                                         "\nEND p1" ).arg( procName ).arg( tableName ).arg( tableName ) ) );
+    else
+        QVERIFY_SQL( q, exec( QString( "CREATE PROCEDURE %1"
+                                         "\nAS"
+                                         "\nSELECT id, text FROM %2"
+                                         "\nSELECT empty, num, text, id FROM %3" ).arg( procName ).arg( tableName ).arg( tableName ) ) );
+
+    if ( driverType == MYSQL || driverType == DB2 ) {
+        q.setForwardOnly( true );
+        QVERIFY_SQL( q, exec( QString( "CALL %1()" ).arg( procName ) ) );
+    } else {
+        QVERIFY_SQL( q, exec( QString( "EXEC %1" ).arg( procName ) ) );
+    }
+
+    for ( int i = 0; i < 4; i++ ) {
+        QVERIFY_SQL( q, next() );
+        QCOMPARE( q.value( 0 ).toInt(), i+1 );
+        QCOMPARE( q.value( 1 ).toString(), tstStrings.at( i ) );
+    }
+
+    QVERIFY_SQL( q, nextResult() );
+
+    QVERIFY_SQL( q, isActive() );
+
+    for ( int i = 0; i < 4; i++ ) {
+        QVERIFY_SQL( q, next() );
+        QCOMPARE( q.value( 0 ).toString(), QString( "Yatta!" ) );
+        QCOMPARE( q.value( 1 ).toDouble(), 1.1*( 1+i ) );
+        QCOMPARE( q.value( 2 ).toString(), tstStrings.at( i ) );
+        QCOMPARE( q.value( 3 ).toInt(), 1+i );
+    }
+
+    // MySQL also counts the CALL itself as a result
+    if ( driverType == MYSQL ) {
+        QVERIFY( q.nextResult() );
+        QVERIFY( !q.isSelect() );           // ... but it's not a select
+        QCOMPARE( q.numRowsAffected(), 0 ); // ... and no rows are affected (at least not with this procedure)
+    }
+
+    QVERIFY( !q.nextResult() );
+
+    QVERIFY( !q.isActive() );
+
+    q.exec( QString( "DROP PROCEDURE %1;" ).arg( procName ) );
+}
+
+
+// For task 190311. Problem: Truncation happens on the 2nd execution if that BLOB is larger
+// than the BLOB on the 1st execution. This was only for MySQL, but the test is general
+// enough to be run with all backends.
+void tst_QSqlQuery::blobsPreparedQuery()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if ( !db.driver()->hasFeature( QSqlDriver::BLOB ) || !db.driver()->hasFeature( QSqlDriver::PreparedQueries ) )
+        QSKIP( "DBMS does not support BLOBs or prepared queries", SkipSingle );
+
+    const QString tableName(qTableName( "blobstest", __FILE__ ));
+
+    QSqlQuery q( db );
+    q.setForwardOnly( true ); // This is needed to make the test work with DB2.
+    QString shortBLOB( "abc" );
+    QString longerBLOB( "abcdefghijklmnopqrstuvxyz¿äëïöü¡  " );
+
+    // In PostgreSQL a BLOB is not called a BLOB, but a BYTEA! :-)
+    // ... and in SQL Server it can be called a lot, but IMAGE will do.
+    QString typeName( "BLOB" );
+    if ( db.driverName().startsWith( "QPSQL" ) )
+        typeName = "BYTEA";
+    else if ( db.driverName().startsWith( "QODBC" ) && tst_Databases::isSqlServer( db ))
+        typeName = "IMAGE";
+
+    QVERIFY_SQL( q, exec( QString( "CREATE TABLE %1(id INTEGER, data %2)" ).arg( tableName ).arg( typeName ) ) );
+    q.prepare( QString( "INSERT INTO %1(id, data) VALUES(:id, :data)" ).arg( tableName ) );
+    q.bindValue( ":id", 1 );
+    q.bindValue( ":data", shortBLOB.toAscii() );
+    QVERIFY_SQL( q, exec() );
+
+    q.bindValue( ":id", 2 );
+    q.bindValue( ":data", longerBLOB.toAscii() );
+    QVERIFY_SQL( q, exec() );
+
+    // Two executions and result sets
+    q.prepare( QString( "SELECT data FROM %1 WHERE id = ?" ).arg( tableName ) );
+    q.bindValue( 0, QVariant( 1 ) );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toString(), shortBLOB );
+
+    q.bindValue( 0, QVariant( 2 ) );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toString(), longerBLOB );
+
+    // Only one execution and result set
+    q.prepare( QString( "SELECT id, data FROM %1 ORDER BY id" ).arg( tableName ) );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 1 ).toString(), shortBLOB );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 1 ).toString(), longerBLOB );
+}
+
+// There were problems with navigating past the end of a table returning an error on mysql
+void tst_QSqlQuery::emptyTableNavigate()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    {
+        QSqlQuery q( db );
+        QVERIFY_SQL( q, exec( "create table " + qTableName( "qtest_empty", __FILE__ ) + " (id char(10))" ) );
+        QVERIFY_SQL( q, prepare( "select * from " + qTableName( "qtest_empty", __FILE__ ) ) );
+        QVERIFY_SQL( q, exec() );
+        QVERIFY( !q.next() );
+        QCOMPARE( q.lastError().isValid(), false );
+    }
+}
+
+void tst_QSqlQuery::task_217003()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    QSqlQuery q( db );
+    const QString Planet(qTableName( "Planet", __FILE__));
+
+    QVERIFY_SQL( q, exec( "create table " + Planet + " (Name varchar(20))" ) );
+    QVERIFY_SQL( q, exec( "insert into " + Planet + " VALUES ('Mercury')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + Planet + " VALUES ('Venus')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + Planet + " VALUES ('Earth')" ) );
+    QVERIFY_SQL( q, exec( "insert into " + Planet + " VALUES ('Mars')" ) );
+
+    QVERIFY_SQL( q, exec( "SELECT Name FROM " + Planet ) );
+    QVERIFY_SQL( q, seek( 3 ) );
+    QCOMPARE( q.value( 0 ).toString(), QString( "Mars" ) );
+    QVERIFY_SQL( q, seek( 1 ) );
+    QCOMPARE( q.value( 0 ).toString(), QString( "Venus" ) );
+    QVERIFY_SQL( q, exec( "SELECT Name FROM " + Planet ) );
+    QVERIFY_SQL( q, seek( 3 ) );
+    QCOMPARE( q.value( 0 ).toString(), QString( "Mars" ) );
+    QVERIFY_SQL( q, seek( 0 ) );
+    QCOMPARE( q.value( 0 ).toString(), QString( "Mercury" ) );
+    QVERIFY_SQL( q, seek( 1 ) );
+    QCOMPARE( q.value( 0 ).toString(), QString( "Venus" ) );
+}
+
+void tst_QSqlQuery::task_250026()
+{
+    QString data258, data1026;
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    QSqlQuery q( db );
+
+    const QString tableName(qTableName( "task_250026", __FILE__ ));
+
+    if ( !q.exec( "create table " + tableName + " (longfield varchar(1100))" ) ) {
+        qDebug() << "Error" << q.lastError();
+        QSKIP( "Db doesn't support \"1100\" as a size for fields", SkipSingle );
+    }
+
+    data258.fill( 'A', 258 );
+    data1026.fill( 'A', 1026 );
+    QVERIFY_SQL( q, prepare( "insert into " + tableName + "(longfield) VALUES (:longfield)" ) );
+    q.bindValue( "longfield", data258 );
+    QVERIFY_SQL( q, exec() );
+    q.bindValue( "longfield", data1026 );
+    QVERIFY_SQL( q, exec() );
+    QVERIFY_SQL( q, exec( "select * from " + tableName ) );
+    QVERIFY_SQL( q, next() );
+    QCOMPARE( q.value( 0 ).toString().length(), data258.length() );
+    QVERIFY_SQL( q, next() );
+	QCOMPARE( q.value( 0 ).toString().length(), data1026.length() );
+}
+
+void tst_QSqlQuery::task_205701()
+{
+    QSqlDatabase qsdb = QSqlDatabase::addDatabase("QMYSQL", "atest");
+    qsdb.setHostName("test");
+    qsdb.setDatabaseName("test");
+    qsdb.setUserName("test");
+    qsdb.setPassword("test");
+    qsdb.open();
+
+//     {
+        QSqlQuery query(qsdb);
+//     }
+    QSqlDatabase::removeDatabase("atest");
+}
+
+#ifdef NOT_READY_YET
+// For task: 229811
+void tst_QSqlQuery::task_229811()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if (!db.driverName().startsWith( "QODBC" )) return;
+
+    QSqlQuery q( db );
+
+    const QString tableName(qTableName( "task_229811", __FILE__ ));
+
+    if ( !q.exec( "CREATE TABLE " + tableName + " (Word varchar(20))" ) ) {
+        qDebug() << "Warning" << q.lastError();
+    }
+
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " values ('Albert')" ) );
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " values ('Beehive')" ) );
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " values ('Alimony')" ) );
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " values ('Bohemian')" ) );
+    QVERIFY_SQL( q, exec( "INSERT INTO " + tableName + " values ('AllStars')" ) );
+
+
+    QString stmt = "SELECT * FROM " + tableName  +  " WHERE Word LIKE :name";
+    QVERIFY_SQL(q,prepare(stmt));
+    q.bindValue(":name", "A%");
+    QVERIFY_SQL(q,exec());
+
+    QVERIFY(q.isActive());
+    QVERIFY(q.isSelect());
+    QVERIFY(q.first());
+
+    QSqlRecord rec = q.record();
+    QCOMPARE(rec.field(0).value().toString(), QString("Albert"));
+    QVERIFY(q.next());
+    rec = q.record();
+    QCOMPARE(rec.field(0).value().toString(), QString("Alimony"));
+    QVERIFY(q.next());
+    rec = q.record();
+    QCOMPARE(rec.field(0).value().toString(),QString("AllStars"));
+
+    q.exec("DROP TABLE " + tableName );
+}
+
+void tst_QSqlQuery::task_234422()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery query(db);
+    QStringList m_airlines;
+    QStringList m_countries;
+
+    m_airlines << "Lufthansa" << "SAS" << "United" << "KLM" << "Aeroflot";
+    m_countries << "DE" << "SE" << "US" << "NL" << "RU";
+
+    const QString tableName(qTableName( "task_234422", __FILE__ ));
+
+    QVERIFY_SQL(query,exec("CREATE TABLE " + tableName + " (id int primary key, "
+                "name varchar(20), homecountry varchar(2))"));
+    for (int i = 0; i < m_airlines.count(); ++i) {
+        QVERIFY(query.exec(QString("INSERT INTO " + tableName + " values(%1, '%2', '%3')")
+                    .arg(i).arg(m_airlines[i], m_countries[i])));
+    }
+
+    QVERIFY_SQL(query, exec("SELECT name FROM " + tableName));
+    QVERIFY(query.isSelect());
+    QVERIFY(query.first());
+    QVERIFY(query.next());
+    QCOMPARE(query.at(), 1);
+
+    QSqlQuery query2(query);
+
+    QVERIFY_SQL(query2,exec());
+    QVERIFY(query2.first());
+    QCOMPARE(query2.at(), 0);
+    QCOMPARE(query.at(), 1);
+}
+
+#endif
+
+void tst_QSqlQuery::task_233829()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q( db );
+    const QString tableName(qTableName("task_233829", __FILE__));
+    QVERIFY_SQL(q,exec("CREATE TABLE " + tableName  + "(dbl1 double precision,dbl2 double precision) without oids;"));
+
+    QString queryString("INSERT INTO " + tableName +"(dbl1, dbl2) VALUES(?,?)");
+
+    double k = 0.0;
+    QVERIFY_SQL(q,prepare(queryString));
+    q.bindValue(0,0.0 / k); // nan
+    q.bindValue(1,0.0 / k); // nan
+    QVERIFY_SQL(q,exec());
+}
+
+void tst_QSqlQuery::sqlServerReturn0()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    if (!tst_Databases::isSqlServer( db ))
+        QSKIP("SQL Server specific test", SkipSingle);
+
+    const QString tableName(qTableName("test141895", __FILE__)), procName(qTableName("test141895_proc", __FILE__));
+    QSqlQuery q( db );
+    q.exec("DROP TABLE " + tableName);
+    q.exec("DROP PROCEDURE " + procName);
+    QVERIFY_SQL(q, exec("CREATE TABLE "+tableName+" (id integer)"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" (id) VALUES (1)"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" (id) VALUES (2)"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" (id) VALUES (2)"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" (id) VALUES (3)"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" (id) VALUES (1)"));
+    QVERIFY_SQL(q, exec("CREATE PROCEDURE "+procName+
+        " AS "
+        "SELECT * FROM "+tableName+" WHERE ID = 2 "
+        "RETURN 0"));
+
+    QVERIFY_SQL(q, exec("{CALL "+procName+"}"));
+
+    QVERIFY_SQL(q, next());
+}
+
+void tst_QSqlQuery::QTBUG_551()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    QSqlQuery q(db);
+    const QString pkgname(qTableName("pkg", __FILE__));
+    QVERIFY_SQL(q, exec("CREATE OR REPLACE PACKAGE "+pkgname+" IS \n\
+            \n\
+            TYPE IntType IS TABLE OF INTEGER      INDEX BY BINARY_INTEGER;\n\
+            TYPE VCType  IS TABLE OF VARCHAR2(60) INDEX BY BINARY_INTEGER;\n\
+            PROCEDURE P (Inp IN IntType,  Outp OUT VCType);\n\
+            END "+pkgname+";"));
+
+     QVERIFY_SQL(q, exec("CREATE OR REPLACE PACKAGE BODY "+pkgname+" IS\n\
+            PROCEDURE P (Inp IN IntType,  Outp OUT VCType)\n\
+            IS\n\
+            BEGIN\n\
+             Outp(1) := '1. Value is ' ||TO_CHAR(Inp(1));\n\
+             Outp(2) := '2. Value is ' ||TO_CHAR(Inp(2));\n\
+             Outp(3) := '3. Value is ' ||TO_CHAR(Inp(3));\n\
+            END p;\n\
+            END "+pkgname+";"));
+
+    QVariantList inLst, outLst, res_outLst;
+
+    q.prepare("begin "+pkgname+".p(:inp, :outp); end;");
+
+    QString StVal;
+    StVal.reserve(60);
+
+    // loading arrays
+    for (int Cnt=0; Cnt < 3; Cnt++) {
+        inLst << Cnt;
+        outLst << StVal;
+    }
+
+    q.bindValue(":inp", inLst);
+    q.bindValue(":outp", outLst, QSql::Out);
+
+    QVERIFY_SQL(q, execBatch(QSqlQuery::ValuesAsColumns) );
+    res_outLst = qVariantValue<QVariantList>(q.boundValues()[":outp"]);
+    QCOMPARE(res_outLst[0].toString(), QLatin1String("1. Value is 0"));
+    QCOMPARE(res_outLst[1].toString(), QLatin1String("2. Value is 1"));
+    QCOMPARE(res_outLst[2].toString(), QLatin1String("3. Value is 2"));
+}
+
+void tst_QSqlQuery::QTBUG_14132()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    QSqlQuery q(db);
+    const QString procedureName(qTableName("procedure", __FILE__));
+    QVERIFY_SQL(q, exec("CREATE OR REPLACE PROCEDURE "+ procedureName + " (outStr OUT varchar2)  \n\
+                        is \n\
+                        begin \n\
+                        outStr := 'OUTSTRING'; \n\
+                        end;"));
+    QString placeholder = "XXXXXXXXX";
+    QVERIFY(q.prepare("CALL "+procedureName+"(?)"));
+    q.addBindValue(placeholder, QSql::Out);
+    QVERIFY_SQL(q, exec());
+    QCOMPARE(q.boundValue(0).toString(), QLatin1String("OUTSTRING"));
+}
+
+void tst_QSqlQuery::QTBUG_5251()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString timetest(qTableName("timetest", __FILE__));
+
+    if (!db.driverName().startsWith( "QPSQL" )) return;
+
+    QSqlQuery q(db);
+    q.exec("DROP TABLE " + timetest);
+    QVERIFY_SQL(q, exec("CREATE TABLE  " + timetest + " (t  TIME)"));
+    QVERIFY_SQL(q, exec("INSERT INTO " + timetest +  " VALUES ('1:2:3.666')"));
+
+    QSqlTableModel timetestModel(0,db);
+    timetestModel.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    timetestModel.setTable(timetest);
+    QVERIFY_SQL(timetestModel, select());
+
+    QCOMPARE(timetestModel.record(0).field(0).value().toTime().toString("HH:mm:ss.zzz"), QString("01:02:03.666"));
+    QVERIFY_SQL(timetestModel,setData(timetestModel.index(0, 0), QTime(0,12,34,500)));
+    QCOMPARE(timetestModel.record(0).field(0).value().toTime().toString("HH:mm:ss.zzz"), QString("00:12:34.500"));
+    QVERIFY_SQL(timetestModel, submitAll());
+    QCOMPARE(timetestModel.record(0).field(0).value().toTime().toString("HH:mm:ss.zzz"), QString("00:12:34.500"));
+
+    QVERIFY_SQL(q, exec("UPDATE " + timetest + " SET t = '0:11:22.33'"));
+    QVERIFY_SQL(timetestModel, select());
+    QCOMPARE(timetestModel.record(0).field(0).value().toTime().toString("HH:mm:ss.zzz"), QString("00:11:22.330"));
+
+}
+
+void tst_QSqlQuery::QTBUG_6421()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("bug6421", __FILE__).toUpper());
+
+    QVERIFY_SQL(q, exec("create table "+tableName+"(COL1 char(10), COL2 char(10), COL3 char(10))"));
+    QVERIFY_SQL(q, exec("create index INDEX1 on "+tableName+" (COL1 desc)"));
+    QVERIFY_SQL(q, exec("create index INDEX2 on "+tableName+" (COL2 desc)"));
+    QVERIFY_SQL(q, exec("create index INDEX3 on "+tableName+" (COL3 desc)"));
+    q.setForwardOnly(true);
+    QVERIFY_SQL(q, exec("select COLUMN_EXPRESSION from ALL_IND_EXPRESSIONS where TABLE_NAME='"+tableName+"'"));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toString(), QLatin1String("\"COL1\""));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toString(), QLatin1String("\"COL2\""));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toString(), QLatin1String("\"COL3\""));
+}
+
+void tst_QSqlQuery::QTBUG_6618()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    if (!tst_Databases::isSqlServer( db ))
+        QSKIP("SQL Server specific test", SkipSingle);
+
+    QSqlQuery q(db);
+    q.exec( "drop procedure " + qTableName( "tst_raiseError", __FILE__ ) );  //non-fatal
+    QString errorString;
+    for (int i=0;i<110;i++)
+        errorString+="reallylong";
+    errorString+=" error";
+    QVERIFY_SQL( q, exec("create procedure " + qTableName( "tst_raiseError", __FILE__ ) + " as\n"
+                         "begin\n"
+                         "    raiserror('" + errorString + "', 16, 1)\n"
+                         "end\n" ));
+    q.exec( "{call " + qTableName( "tst_raiseError", __FILE__ ) + "}" );
+    QVERIFY(q.lastError().text().contains(errorString));
+}
+
+void tst_QSqlQuery::QTBUG_6852()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    if ( tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt()<5 )
+        QSKIP( "Test requires MySQL >= 5.0", SkipSingle );
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("bug6852", __FILE__)), procName(qTableName("bug6852_proc", __FILE__));
+
+    QVERIFY_SQL(q, exec("DROP PROCEDURE IF EXISTS "+procName));
+    QVERIFY_SQL(q, exec("CREATE TABLE "+tableName+"(\n"
+                        "MainKey INT NOT NULL,\n"
+                        "OtherTextCol VARCHAR(45) NOT NULL,\n"
+                        "PRIMARY KEY(`MainKey`))"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" VALUES(0, \"Disabled\")"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" VALUES(5, \"Error Only\")"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" VALUES(10, \"Enabled\")"));
+    QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" VALUES(15, \"Always\")"));
+    QVERIFY_SQL(q, exec("CREATE PROCEDURE "+procName+"()\n"
+                        "READS SQL DATA\n"
+                        "BEGIN\n"
+                        "  SET @st = 'SELECT MainKey, OtherTextCol from "+tableName+"';\n"
+                        "  PREPARE stmt from @st;\n"
+                        "  EXECUTE stmt;\n"
+                        "END;"));
+
+    QVERIFY_SQL(q, exec("CALL "+procName+"()"));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 0);
+    QCOMPARE(q.value(1).toString(), QLatin1String("Disabled"));
+}
+
+void tst_QSqlQuery::QTBUG_5765()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    if ( tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 1 ).toFloat()<4.1 )
+        QSKIP( "Test requires MySQL >= 4.1", SkipSingle );
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("bug5765", __FILE__));
+
+    QVERIFY_SQL(q, exec("CREATE TABLE "+tableName+"(testval TINYINT(1) DEFAULT 0)"));
+    q.prepare("INSERT INTO "+tableName+" SET testval = :VALUE");
+    q.bindValue(":VALUE", 1);
+    QVERIFY_SQL(q, exec());
+    q.bindValue(":VALUE", 12);
+    QVERIFY_SQL(q, exec());
+    q.bindValue(":VALUE", 123);
+    QVERIFY_SQL(q, exec());
+    QString sql="select testval from "+tableName;
+    QVERIFY_SQL(q, exec(sql));
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 1);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 12);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 123);
+    QVERIFY_SQL(q, prepare(sql));
+    QVERIFY_SQL(q, exec());
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 1);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 12);
+    QVERIFY_SQL(q, next());
+    QCOMPARE(q.value(0).toInt(), 123);
+}
+
+void tst_QSqlQuery::oraOCINumber()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    const QString qtest_oraOCINumber(qTableName("qtest_oraOCINumber", __FILE__));
+
+    QSqlQuery q( db );
+    q.setForwardOnly( true );
+    QVERIFY_SQL( q, exec( "create table " + qtest_oraOCINumber +
+                            " (col1 number(20), col2 number(20))" ) );
+    QVERIFY(q.prepare("insert into " + qtest_oraOCINumber + " values (?, ?)"));
+    QVariantList col1Values;
+    QVariantList col2Values;
+    col1Values << (qulonglong)(1)
+               << (qulonglong)(0)
+               << (qulonglong)(INT_MAX)
+               << (qulonglong)(UINT_MAX)
+               << (qulonglong)(LONG_MAX)
+               << (qulonglong)(ULONG_MAX)
+               << (qulonglong)(LLONG_MAX)
+               << (qulonglong)(ULLONG_MAX);
+
+    col2Values << (qlonglong)(1)
+               << (qlonglong)(0)
+               << (qlonglong)(-1)
+               << (qlonglong)(LONG_MAX)
+               << (qlonglong)(LONG_MIN)
+               << (qlonglong)(ULONG_MAX)
+               << (qlonglong)(LLONG_MAX)
+               << (qlonglong)(LLONG_MIN);
+
+    q.addBindValue(col1Values);
+    q.addBindValue(col2Values);
+    QVERIFY(q.execBatch());
+    QString sqlStr = "select * from " + qtest_oraOCINumber +  " where col1 = :bindValue0 AND col2 = :bindValue1";
+    QVERIFY(q.prepare(sqlStr));
+
+    q.bindValue(":bindValue0", (qulonglong)(1), QSql::InOut);
+    q.bindValue(":bindValue1", (qlonglong)(1), QSql::InOut);
+
+    QVERIFY_SQL( q, exec() );
+    QVERIFY( q.next() );
+    QCOMPARE(q.boundValue( 0 ).toULongLong(),  qulonglong(1));
+    QCOMPARE(q.boundValue( 1 ).toLongLong(),  (qlonglong)(1));
+
+    q.bindValue(":bindValue0", (qulonglong)(0), QSql::InOut);
+    q.bindValue(":bindValue1", (qlonglong)(0), QSql::InOut);
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY( q.next() );
+    QCOMPARE(q.boundValue( 0 ).toULongLong(),  (qulonglong)(0));
+    QCOMPARE(q.boundValue( 1 ).toLongLong(),  (qlonglong)(0));
+
+    q.bindValue(":bindValue0", (qulonglong)(INT_MAX), QSql::InOut);
+    q.bindValue(":bindValue1", (qlonglong)(-1), QSql::InOut);
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY( q.next() );
+    QCOMPARE(q.boundValue( 0 ).toULongLong(),  (qulonglong)(INT_MAX));
+    QCOMPARE(q.boundValue( 1 ).toLongLong(),  (qlonglong)(-1));
+
+    q.bindValue(":bindValue0", (qulonglong)(UINT_MAX), QSql::InOut);
+    q.bindValue(":bindValue1", (qlonglong)(LONG_MAX), QSql::InOut);
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY( q.next() );
+    QCOMPARE(q.boundValue( 0 ).toULongLong(),  (qulonglong)(UINT_MAX));
+    QCOMPARE(q.boundValue( 1 ).toLongLong(),  (qlonglong)(LONG_MAX));
+
+    q.bindValue(":bindValue0", (qulonglong)(LONG_MAX), QSql::InOut);
+    q.bindValue(":bindValue1", (qlonglong)(LONG_MIN), QSql::InOut);
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY( q.next() );
+    QCOMPARE(q.boundValue( 0 ).toULongLong(),  (qulonglong)(LONG_MAX));
+    QCOMPARE(q.boundValue( 1 ).toLongLong(),  (qlonglong)(LONG_MIN));
+
+    q.bindValue(":bindValue0", (qulonglong)(ULONG_MAX), QSql::InOut);
+    q.bindValue(":bindValue1", (qlonglong)(ULONG_MAX), QSql::InOut);
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY( q.next() );
+    QCOMPARE(q.boundValue( 0 ).toULongLong(),  (qulonglong)(ULONG_MAX));
+    QCOMPARE(q.boundValue( 1 ).toLongLong(),  (qlonglong)(ULONG_MAX));
+
+    q.bindValue(":bindValue0", (qulonglong)(LLONG_MAX), QSql::InOut);
+    q.bindValue(":bindValue1", (qlonglong)(LLONG_MAX), QSql::InOut);
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY( q.next() );
+    QCOMPARE(q.boundValue( 0 ).toULongLong(),  (qulonglong)(LLONG_MAX));
+    QCOMPARE(q.boundValue( 1 ).toLongLong(),  (qlonglong)(LLONG_MAX));
+
+    q.bindValue(":bindValue0", (qulonglong)(ULLONG_MAX), QSql::InOut);
+    q.bindValue(":bindValue1", (qlonglong)(LLONG_MIN), QSql::InOut);
+    QVERIFY_SQL( q, exec() );
+
+    QVERIFY( q.next() );
+    QCOMPARE(q.boundValue( 0 ).toULongLong(),  (qulonglong)(ULLONG_MAX));
+    QCOMPARE(q.boundValue( 1 ).toLongLong(),  (qlonglong)(LLONG_MIN));
+
+}
+
+void tst_QSqlQuery::sqlite_constraint()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+
+    if (db.driverName() != QLatin1String("QSQLITE")) {
+        QSKIP("Sqlite3 specific test", SkipSingle);
+        return;
+    }
+
+    QSqlQuery q(db);
+    const QString trigger(qTableName("test_constraint", __FILE__));
+
+    QVERIFY_SQL(q, exec("CREATE TEMP TRIGGER "+trigger+" BEFORE DELETE ON "+qtest+
+                        "\nFOR EACH ROW "
+                        "\nBEGIN"
+                        "\n  SELECT RAISE(ABORT, 'Raised Abort successfully');"
+                        "\nEND;"
+                        ));
+
+    QVERIFY(!q.exec("DELETE FROM "+qtest));
+    QCOMPARE(q.lastError().databaseText(), QLatin1String("Raised Abort successfully"));
+}
+
+#if 0
+void tst_QSqlQuery::benchmark()
+{
+    QFETCH( QString, dbName );
+    QSqlDatabase db = QSqlDatabase::database( dbName );
+    CHECK_DATABASE( db );
+    if ( tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt()<5 )
+        QSKIP( "Test requires MySQL >= 5.0", SkipSingle );
+
+    QSqlQuery q(db);
+    const QString tableName(qTableName("benchmark", __FILE__));
+
+    tst_Databases::safeDropTable( db, tableName );
+
+    QVERIFY_SQL(q, exec("CREATE TABLE "+tableName+"(\n"
+                        "MainKey INT NOT NULL,\n"
+                        "OtherTextCol VARCHAR(45) NOT NULL,\n"
+                        "PRIMARY KEY(`MainKey`))"));
+
+    int i=1;
+
+    QBENCHMARK {
+        QVERIFY_SQL(q, exec("INSERT INTO "+tableName+" VALUES("+QString::number(i)+", \"Value"+QString::number(i)+"\")"));
+        i++;
+    }
+
+    tst_Databases::safeDropTable( db, tableName );
+}
+#endif
+
+QTEST_MAIN( tst_QSqlQuery )
+#include "tst_qsqlquery.moc"
diff --git a/tests/auto/sql/kernel/qsqlrecord/.gitignore b/tests/auto/sql/kernel/qsqlrecord/.gitignore
new file mode 100644
index 0000000000..0235188129
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlrecord/.gitignore
@@ -0,0 +1 @@
+tst_qsqlrecord
diff --git a/tests/auto/sql/kernel/qsqlrecord/qsqlrecord.pro b/tests/auto/sql/kernel/qsqlrecord/qsqlrecord.pro
new file mode 100644
index 0000000000..16e3ae4f80
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlrecord/qsqlrecord.pro
@@ -0,0 +1,20 @@
+load(qttest_p4)
+SOURCES  += tst_qsqlrecord.cpp
+
+symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+
+    TARGET.EPOCSTACKSIZE=50000
+    TARGET.EPOCHEAPSIZE=50000 5000000
+}
+
+QT += sql
+
+
+
diff --git a/tests/auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp b/tests/auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp
new file mode 100644
index 0000000000..c84e39fb2a
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp
@@ -0,0 +1,522 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include "qsqlrecord.h"
+#include "qsqlfield.h"
+#include "qstringlist.h"
+
+
+
+
+#include <qsqlrecord.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+#define NUM_FIELDS 4
+
+class tst_QSqlRecord : public QObject
+{
+Q_OBJECT
+
+public:
+    tst_QSqlRecord();
+    virtual ~tst_QSqlRecord();
+
+
+public slots:
+    void init();
+    void cleanup();
+private slots:
+    void value();
+    void setValue_data();
+    void setValue();
+    void setNull();
+    void setGenerated();
+    void remove();
+    void position();
+    void operator_Assign();
+    void isNull();
+    void isGenerated();
+    void isEmpty();
+    void insert();
+    void fieldName();
+    void field();
+    void count();
+    void contains();
+    void clearValues_data();
+    void clearValues();
+    void clear();
+    void append();
+
+private:
+    QSqlRecord* rec;
+    QSqlField* fields[ NUM_FIELDS ];
+    void createTestRecord();
+};
+
+tst_QSqlRecord::tst_QSqlRecord()
+{
+    rec = 0;
+    for ( int i = 0; i < NUM_FIELDS; ++i )
+        fields[ i ] = 0;
+}
+
+tst_QSqlRecord::~tst_QSqlRecord()
+{
+    delete rec;
+    for ( int i = 0; i < NUM_FIELDS; ++i )
+        delete fields[ i ];
+    rec = 0;
+}
+
+void tst_QSqlRecord::init()
+{
+    cleanup();
+}
+
+void tst_QSqlRecord::cleanup()
+{
+    delete rec;
+    for ( int i = 0; i < NUM_FIELDS; ++i ) {
+	delete fields[ i ];
+	fields[ i ] = 0;
+    }
+    rec = 0;
+}
+
+void tst_QSqlRecord::createTestRecord()
+{
+    delete rec;
+    rec = new QSqlRecord();
+    fields[ 0 ] = new QSqlField( "string", QVariant::String );
+    fields[ 1 ] = new QSqlField( "int", QVariant::Int );
+    fields[ 2 ] = new QSqlField( "double", QVariant::Double );
+    fields[ 3 ] = new QSqlField( "bool", QVariant::Bool );
+    for ( int i = 0; i < NUM_FIELDS; ++i )
+	rec->append( *(fields[ i ] ) );
+}
+
+
+void tst_QSqlRecord::append()
+{
+    delete rec;
+    rec = new QSqlRecord();
+    rec->append( QSqlField( "string", QVariant::String ) );
+    QCOMPARE( rec->field( 0 ).name(), (QString) "string" );
+    QVERIFY( !rec->isEmpty() );
+    QCOMPARE( (int)rec->count(), 1 );
+    rec->append( QSqlField( "int", QVariant::Int ) );
+    QCOMPARE( rec->field( 1 ).name(), (QString) "int" );
+    QCOMPARE( (int)rec->count(), 2 );
+    rec->append( QSqlField( "double", QVariant::Double ) );
+    QCOMPARE( rec->field( 2 ).name(), (QString) "double" );
+    QCOMPARE( (int)rec->count(), 3 );
+    rec->append( QSqlField( "bool", QVariant::Bool ) );
+    QCOMPARE( rec->field( 3 ).name(), (QString) "bool" );
+    QCOMPARE( (int)rec->count(), 4 );
+    QCOMPARE( rec->indexOf( "string" ), 0 );
+    QCOMPARE( rec->indexOf( "int" ), 1 );
+    QCOMPARE( rec->indexOf( "double" ), 2 );
+    QCOMPARE( rec->indexOf( "bool" ), 3 );
+}
+
+void tst_QSqlRecord::clear()
+{
+    createTestRecord();
+
+    rec->clear();
+    QCOMPARE( (int)rec->count(), 0 );
+    QVERIFY( rec->isEmpty() );
+    QVERIFY( !rec->contains( fields[0]->name() ) );
+}
+
+void tst_QSqlRecord::clearValues_data()
+{
+    QTest::addColumn<QString>("prefix");
+    QTest::addColumn<QString>("sep");
+    QTest::addColumn<int>("ival");
+    QTest::addColumn<QString>("sval");
+    QTest::addColumn<double>("dval");
+    QTest::addColumn<int>("bval");
+
+    QTest::newRow( "data0" ) << QString::fromLatin1("tablename") << QString::fromLatin1(",") << 10
+                          << QString::fromLatin1("Trond K.") << 2222.231234441 << 0;
+    QTest::newRow( "data1" ) << QString::fromLatin1("mytable") << QString::fromLatin1(".") << 12
+                          << QString::fromLatin1("Josten") << 544444444444423232.32334441 << 1;
+    QTest::newRow( "data2" ) << QString::fromLatin1("tabby") << QString::fromLatin1("-") << 12
+                          << QString::fromLatin1("Odvin") << 899129389283.32334441 << 1;
+    QTest::newRow( "data3" ) << QString::fromLatin1("per") << QString::fromLatin1("00") << 12
+                          << QString::fromLatin1("Brge") << 29382939182.99999919 << 0;
+}
+
+void tst_QSqlRecord::clearValues()
+{
+    int i;
+    QFETCH( int, ival );
+    QFETCH( QString, sval );
+    QFETCH( double, dval );
+    QFETCH( int, bval );
+
+    if(rec)
+        delete rec;
+
+    rec = new QSqlRecord();
+    rec->append( QSqlField( "string", QVariant::String ) );
+    QCOMPARE( rec->field(0).name(), (QString) "string" );
+    QVERIFY( !rec->isEmpty() );
+    QCOMPARE( (int)rec->count(), 1 );
+    rec->append( QSqlField( "int", QVariant::Int ) );
+    QCOMPARE( rec->field(1).name(), (QString) "int" );
+    QCOMPARE( (int)rec->count(), 2 );
+    rec->append( QSqlField( "double", QVariant::Double ) );
+    QCOMPARE( rec->field(2).name(), (QString) "double" );
+    QCOMPARE( (int)rec->count(), 3 );
+    rec->append( QSqlField( "bool", QVariant::Bool ) );
+    QCOMPARE( rec->field(3).name(), (QString) "bool" );
+    QCOMPARE( (int)rec->count(), 4 );
+    QCOMPARE( rec->indexOf( "string" ), 0 );
+    QCOMPARE( rec->indexOf( "int" ), 1 );
+    QCOMPARE( rec->indexOf( "double" ), 2 );
+    QCOMPARE( rec->indexOf( "bool" ), 3 );
+    for ( i = 0; i < 4; ++i )
+        rec->setNull( i );
+
+    rec->setValue( 0, sval );
+    rec->setValue( 1, ival );
+    rec->setValue( 2, dval );
+    rec->setValue( 3, QVariant(bval) );
+    QVERIFY( rec->value( 0 ) == sval );
+    QVERIFY( rec->value( 1 ) == ival );
+    QVERIFY( rec->value( 2 ) == dval );
+    QVERIFY( rec->value( 3 ) == QVariant(bval) );
+
+    rec->clearValues();
+
+    for ( i = 0; i < 4; ++i )
+        QVERIFY( rec->isNull( i ) );
+
+}
+
+void tst_QSqlRecord::contains()
+{
+    createTestRecord();
+    for ( int i = 0; i < NUM_FIELDS; ++i )
+	QVERIFY( rec->contains( fields[ i ]->name() ) );
+    QVERIFY( !rec->contains( "__Harry__" ) );
+}
+
+void tst_QSqlRecord::count()
+{
+    createTestRecord();
+    QCOMPARE( (int)rec->count(), NUM_FIELDS );
+    rec->remove( 3 );
+    QCOMPARE( (int)rec->count(), NUM_FIELDS - 1 );
+    rec->clear();
+    QCOMPARE( (int)rec->count(), 0 );
+    QCOMPARE( (int)QSqlRecord().count(), 0 );
+}
+
+void tst_QSqlRecord::field()
+{
+    createTestRecord();
+
+    int i;
+    for ( i = 0; i < NUM_FIELDS; ++i )
+	QVERIFY( rec->field( i ) == *fields[ i ] );
+
+    for ( i = 0; i < NUM_FIELDS; ++i )
+	QVERIFY( rec->field( (fields[ i ] )->name() ) == *( fields[ i ] ) );
+    QVERIFY( rec->indexOf( "_This should give a warning!_" ) == -1 );
+}
+
+void tst_QSqlRecord::fieldName()
+{
+    createTestRecord();
+
+    for ( int i = 0; i < NUM_FIELDS; ++i )
+	QVERIFY( rec->field( (fields[ i ] )->name() ) == *( fields[ i ] ) );
+    QVERIFY( rec->fieldName( NUM_FIELDS ).isNull() );
+}
+
+void tst_QSqlRecord::insert()
+{
+    QSqlRecord iRec;
+    int i;
+    for ( i = 0; i <= 100; ++i ) {
+	iRec.insert( i, QSqlField( QString::number( i ), QVariant::Int ) );
+    }
+    for ( i = 0; i <= 100; ++i ) {
+	QCOMPARE( iRec.fieldName( i ), QString::number( i ) );
+    }
+//    iRec.insert( 505, QSqlField( "Harry", QVariant::Double ) );
+//    QCOMPARE( iRec.fieldName( 505 ), (QString)"Harry" );
+//    QVERIFY( iRec.field( 505 ).type() == QVariant::Double );
+
+    iRec.insert( 42, QSqlField( "Everything", QVariant::String ) );
+    QCOMPARE( iRec.fieldName( 42 ), (QString)"Everything" );
+    QVERIFY( iRec.field( 42 ).type() == QVariant::String );
+}
+
+void tst_QSqlRecord::isEmpty()
+{
+    QSqlRecord eRec;
+    QVERIFY( eRec.isEmpty() );
+    eRec.append( QSqlField( "Harry", QVariant::String ) );
+    QVERIFY( !eRec.isEmpty() );
+    eRec.remove( 0 );
+    QVERIFY( eRec.isEmpty() );
+    eRec.insert( 0, QSqlField( "Harry", QVariant::String ) );
+    QVERIFY( !eRec.isEmpty() );
+    eRec.clear();
+    QVERIFY( eRec.isEmpty() );
+}
+
+void tst_QSqlRecord::isGenerated()
+{
+    createTestRecord();
+
+    int i;
+    for ( i = 0; i < NUM_FIELDS; ++i )
+	QVERIFY( rec->isGenerated( i ) );
+
+    for ( i = 0; i < NUM_FIELDS; ++i )
+	QVERIFY( rec->isGenerated( fields[ i ]->name() ) );
+
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	if ( i % 2 )
+	    rec->setGenerated( i, false );
+    }
+    rec->setGenerated( NUM_FIELDS * 2, false ); // nothing should happen here
+
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	if ( i % 2 ) {
+	    QVERIFY( !rec->isGenerated( i ) );
+	} else {
+	    QVERIFY( rec->isGenerated( i ) );
+        }
+    }
+
+    for ( i = 0; i < NUM_FIELDS; ++i )
+	if ( i % 2 ) {
+	    QVERIFY( !rec->isGenerated( fields[ i ]->name() ) );
+	} else {
+	    QVERIFY( rec->isGenerated( fields[ i ]->name() ) );
+        }
+
+    rec->setGenerated( "_This should give a warning!_",  false ); // nothing should happen here
+}
+
+void tst_QSqlRecord::isNull()
+{
+    createTestRecord();
+
+    int i;
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	QVERIFY( rec->isNull( i ) );
+	QVERIFY( rec->isNull( fields[ i ]->name() ) );
+    }
+
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	if ( i % 2 )
+	    rec->setNull( i );
+    }
+    rec->setNull( NUM_FIELDS ); // nothing should happen here
+
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	if ( i % 2 ) {
+	    QVERIFY( rec->isNull( i ) );
+	    QVERIFY( rec->isNull( fields[ i ]->name() ) );
+        }
+    }
+
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	rec->setNull( fields[ i ]->name() );
+    }
+    rec->setNull( "_This should give a warning!_" ); // nothing should happen here
+
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	QVERIFY( rec->isNull( i ) );
+	QVERIFY( rec->isNull( fields[ i ]->name() ) );
+    }
+}
+
+void tst_QSqlRecord::operator_Assign()
+{
+    createTestRecord();
+    int i;
+    QSqlRecord buf2, buf3, buf4; // since buffers are implicitely shared, we exaggerate a bit here
+    buf2 = *rec;
+    buf3 = *rec;
+    buf4 = *rec;
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	QVERIFY( buf2.field( i ) == *fields[ i ] );
+	QVERIFY( buf3.field( i ) == *( fields[ i ] ) );
+	QVERIFY( buf4.field( i ) == *( fields[ i ] ) );
+    }
+    for ( i = 0; i < NUM_FIELDS; ++i )
+	buf3.setNull( i );
+    buf3.remove( NUM_FIELDS - 1 );
+    QSqlRecord buf5 = buf3;
+    for ( i = 0; i < NUM_FIELDS - 1; ++i ) {
+	QSqlField fi ( fields[ i ]->name(), fields[ i ]->type() );
+	fi.clear();
+	QVERIFY( buf5.field( i ) == fi );
+	QVERIFY( buf5.isGenerated( i ) );
+    }
+}
+
+void tst_QSqlRecord::position()
+{
+    createTestRecord();
+    int i;
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	QCOMPARE( rec->indexOf( fields[ i ]->name() ), i );
+    }
+}
+
+void tst_QSqlRecord::remove()
+{
+    createTestRecord();
+    int i;
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	rec->setGenerated( i, false );
+	QCOMPARE( (int)rec->count(), NUM_FIELDS - i );
+	rec->remove( 0 );
+	QCOMPARE( (int)rec->count(), NUM_FIELDS - i - 1 );
+    }
+    rec->remove( NUM_FIELDS * 2 ); // nothing should happen
+    for ( i = 0; i < NUM_FIELDS; ++i ) {
+	rec->insert( i, QSqlField( fields[ i ]->name(), fields[ i ]->type() ) );
+	QVERIFY( rec->isGenerated( i ) );
+    }
+}
+
+void tst_QSqlRecord::setGenerated()
+{
+    isGenerated();
+}
+
+void tst_QSqlRecord::setNull()
+{
+    isNull();
+}
+
+void tst_QSqlRecord::setValue_data()
+{
+    clearValues_data();
+}
+
+void tst_QSqlRecord::setValue()
+{
+    int i;
+
+    delete rec;
+    rec = new QSqlRecord();
+    rec->append( QSqlField( "string", QVariant::String ) );
+    QCOMPARE( rec->field( 0 ).name(), (QString) "string" );
+    QVERIFY( !rec->isEmpty() );
+    QCOMPARE( (int)rec->count(), 1 );
+    rec->append( QSqlField( "int", QVariant::Int ) );
+    QCOMPARE( rec->field( 1 ).name(), (QString) "int" );
+    QCOMPARE( (int)rec->count(), 2 );
+    rec->append( QSqlField( "double", QVariant::Double ) );
+    QCOMPARE( rec->field( 2 ).name(), (QString) "double" );
+    QCOMPARE( (int)rec->count(), 3 );
+    rec->append( QSqlField( "bool", QVariant::Bool ) );
+    QCOMPARE( rec->field( 3 ).name(), (QString) "bool" );
+    QCOMPARE( (int)rec->count(), 4 );
+    QCOMPARE( rec->indexOf( "string" ), 0 );
+    QCOMPARE( rec->indexOf( "int" ), 1 );
+    QCOMPARE( rec->indexOf( "double" ), 2 );
+    QCOMPARE( rec->indexOf( "bool" ), 3 );
+
+    QFETCH( int, ival );
+    QFETCH( QString, sval );
+    QFETCH( double, dval );
+    QFETCH( int, bval );
+
+    for ( i = 0; i < 4; ++i )
+	rec->setNull( i );
+
+    rec->setValue( 0, sval );
+    rec->setValue( 1, ival );
+    rec->setValue( 2, dval );
+    rec->setValue( 3, QVariant(bval) );
+    QVERIFY( rec->value( 0 ) == sval );
+    QVERIFY( rec->value( 1 ) == ival );
+    QVERIFY( rec->value( 2 ) == dval );
+    QVERIFY( rec->value( 3 ) == QVariant(bval) );
+    for ( i = 0; i < 4; ++i )
+	QVERIFY( !rec->isNull( i ) );
+
+    QSqlRecord rec2 = *rec;
+    QVERIFY( rec2.value( 0 ) == sval );
+    QVERIFY( rec2.value( 1 ) == ival );
+    QVERIFY( rec2.value( 2 ) == dval );
+    QVERIFY( rec2.value( 3 ) == QVariant(bval) );
+
+    rec2.setValue( "string", "__Harry__" );
+    QVERIFY( rec2.value( 0 ) == "__Harry__" );
+
+    for ( i = 0; i < 4; ++i )
+	QVERIFY( !rec2.isNull( i ) );
+
+    QCOMPARE( rec->value( 0 ).toString(), sval );
+    QCOMPARE( rec->value( 1 ).toInt(), ival );
+    QCOMPARE( rec->value( 2 ).toDouble(), dval );
+    QCOMPARE( rec->value( 3 ), QVariant(bval) );
+}
+
+void tst_QSqlRecord::value()
+{
+    // this test is already covered in setValue()
+    QSqlRecord rec2;
+    rec2.append( QSqlField( "string", QVariant::String ) );
+    rec2.setValue( "string", "Harry" );
+    QVERIFY( rec2.value( "string" ) == "Harry" );
+}
+
+QTEST_MAIN(tst_QSqlRecord)
+#include "tst_qsqlrecord.moc"
diff --git a/tests/auto/sql/kernel/qsqlthread/.gitignore b/tests/auto/sql/kernel/qsqlthread/.gitignore
new file mode 100644
index 0000000000..4108739f86
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlthread/.gitignore
@@ -0,0 +1 @@
+tst_qsqlthread
diff --git a/tests/auto/sql/kernel/qsqlthread/qsqlthread.pro b/tests/auto/sql/kernel/qsqlthread/qsqlthread.pro
new file mode 100644
index 0000000000..2e4c72ac92
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlthread/qsqlthread.pro
@@ -0,0 +1,23 @@
+load(qttest_p4)
+SOURCES  += tst_qsqlthread.cpp
+
+QT = core sql
+
+
+wince*: {
+   plugFiles.files = ../../../plugins/sqldrivers
+   plugFiles.path    = .
+   DEPLOYMENT += plugFiles
+   LIBS += -lws2
+}else:symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+}else {
+   win32:LIBS += -lws2_32
+}
+
diff --git a/tests/auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp b/tests/auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp
new file mode 100644
index 0000000000..d39b69151c
--- /dev/null
+++ b/tests/auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp
@@ -0,0 +1,531 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+
+#include "../qsqldatabase/tst_databases.h"
+
+#include <QtCore>
+#include <QtSql>
+#include "qdebug.h"
+
+#ifdef Q_OS_LINUX
+#include <pthread.h>
+#endif
+
+const QString qtest(qTableName("qtest", __FILE__));
+// set this define if Oracle is built with threading support
+//#define QOCI_THREADED
+
+class tst_QSqlThread : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QSqlThread();
+    virtual ~tst_QSqlThread();
+
+
+    void dropTestTables();
+    void createTestTables();
+    void recreateTestTables();
+    void repopulateTestTables();
+
+    void generic_data(const QString &engine=QString());
+    tst_Databases dbs;
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+protected slots:
+    void threadFinished() { ++threadFinishedCount; }
+
+private slots:
+    void simpleThreading_data() { generic_data(); }
+    void simpleThreading();
+    void readWriteThreading_data() { generic_data(); }
+    void readWriteThreading();
+    void readFromSingleConnection_data() { generic_data(); }
+    void readFromSingleConnection();
+    void readWriteFromSingleConnection_data() { generic_data(); }
+    void readWriteFromSingleConnection();
+    void preparedReadWriteFromSingleConnection_data() { generic_data(); }
+    void preparedReadWriteFromSingleConnection();
+    void transactionsFromSingleConnection_data() { generic_data(); }
+    void transactionsFromSingleConnection();
+
+private:
+    int threadFinishedCount;
+};
+
+static QBasicAtomicInt counter;
+
+class QtTestSqlThread : public QThread
+{
+    Q_OBJECT
+public:
+    QtTestSqlThread(const QSqlDatabase &aDb, QObject *parent = 0)
+        : QThread(parent), sourceDb(aDb) {}
+
+    void runHelper(const QString &dbName)
+    {
+        QSqlDatabase db = QSqlDatabase::cloneDatabase(sourceDb, dbName);
+        QVERIFY_SQL(db, open());
+
+        int sum = 0;
+        QSqlQuery q("select id from " + qtest, db);
+        QVERIFY_SQL(q, isActive());
+        while (q.next())
+            sum += q.value(0).toInt();
+        QCOMPARE(sum, 6);
+        q.clear();
+    }
+
+    void run()
+    {
+        QString dbName = QString("QThreadDb%1").arg((size_t)currentThreadId());
+        runHelper(dbName);
+
+        QSqlDatabase::database(dbName).close();
+        QSqlDatabase::removeDatabase(dbName);
+    }
+
+private:
+    QSqlDatabase sourceDb;
+};
+
+enum { ProdConIterations = 10 };
+
+class SqlProducer: public QThread
+{
+    Q_OBJECT
+public:
+    SqlProducer(const QSqlDatabase &aDb, QObject *parent = 0)
+        : QThread(parent), sourceDb(aDb) {}
+
+    void runHelper(const QString &dbName)
+    {
+        QSqlDatabase db = QSqlDatabase::cloneDatabase(sourceDb, dbName);
+        QVERIFY_SQL(db, open());
+        QSqlQuery q(db);
+        QVERIFY_SQL(q, prepare("insert into " + qtest + " values (?, ?, ?)"));
+        int id = 10;
+        for (int i = 0; i < ProdConIterations; ++i) {
+            q.bindValue(0, ++id);
+            q.bindValue(1, "threaddy");
+            q.bindValue(2, 10);
+            QVERIFY_SQL(q, exec());
+#ifdef Q_OS_LINUX
+            pthread_yield();
+#endif
+        }
+    }
+
+    void run()
+    {
+        QString dbName = QString("Producer%1").arg((size_t)currentThreadId());
+        runHelper(dbName);
+        QSqlDatabase::database(dbName).close();
+        QSqlDatabase::removeDatabase(dbName);
+    }
+private:
+    QSqlDatabase sourceDb;
+};
+
+class SqlConsumer: public QThread
+{
+    Q_OBJECT
+
+public:
+    SqlConsumer(const QSqlDatabase &aDb, QObject *parent = 0)
+        : QThread(parent), sourceDb(aDb) {}
+
+    void runHelper(const QString &dbName)
+    {
+        QSqlDatabase db = QSqlDatabase::cloneDatabase(sourceDb, dbName);
+        QVERIFY_SQL(db, open());
+        QSqlQuery q1(db), q2(db);
+        QVERIFY_SQL(q2, prepare("delete from " + qtest + " where id = :id"));
+
+        for (int i = 0; i < ProdConIterations; ++i) {
+            QVERIFY_SQL(q1, exec("select max(id) from " + qtest));
+            q1.first();
+            q2.bindValue("id", q1.value(0));
+            q1.clear();
+            QVERIFY_SQL(q2, exec());
+#ifdef Q_OS_LINUX
+            pthread_yield();
+#endif
+        }
+    }
+
+    void run()
+    {
+        QString dbName = QString("Consumer%1").arg((size_t)currentThreadId());
+        runHelper(dbName);
+        QSqlDatabase::database(dbName).close();
+        QSqlDatabase::removeDatabase(dbName);
+    }
+
+private:
+    QSqlDatabase sourceDb;
+};
+
+class SqlThread: public QThread
+{
+    Q_OBJECT
+
+public:
+    enum Mode { SimpleReading, PreparedReading, SimpleWriting, PreparedWriting };
+
+    SqlThread(Mode m, const QSqlDatabase &db, QObject *parent = 0)
+        : QThread(parent), sourceDb(db), mode(m) {}
+
+    void run()
+    {
+        QSqlDatabase &db = sourceDb;
+        switch (mode) {
+        case SimpleReading: {
+            // Executes a Query for reading, iterates over the first 4 results
+            QSqlQuery q(sourceDb);
+            for (int j = 0; j < ProdConIterations; ++j) {
+                QVERIFY_SQL(q, exec("select id,name from " + qtest + " order by id"));
+                for (int i = 1; i < 4; ++i) {
+                    QVERIFY_SQL(q, next());
+                    QCOMPARE(q.value(0).toInt(), i);
+                }
+            }
+            break; }
+        case SimpleWriting: {
+            // Executes a query for writing (appends a new row)
+            QSqlQuery q(sourceDb);
+            for (int j = 0; j < ProdConIterations; ++j) {
+                QVERIFY_SQL(q, exec(QString("insert into " + qtest
+                                + " (id, name) values(%1, '%2')")
+                                      .arg(counter.fetchAndAddRelaxed(1)).arg("Robert")));
+            }
+            break; }
+        case PreparedReading: {
+            // Prepares a query for reading and iterates over the results
+            QSqlQuery q(sourceDb);
+            QVERIFY_SQL(q, prepare("select id, name from " + qtest + " where id = ?"));
+            for (int j = 0; j < ProdConIterations; ++j) {
+                q.addBindValue(j % 3 + 1);
+                QVERIFY_SQL(q, exec());
+                QVERIFY_SQL(q, next());
+                QCOMPARE(q.value(0).toInt(), j % 3 + 1);
+            }
+            break; }
+        case PreparedWriting: {
+            QSqlQuery q(sourceDb);
+            QVERIFY_SQL(q, prepare("insert into " + qtest + " (id, name) "
+                                     "values(?, ?)"));
+            for (int i = 0; i < ProdConIterations; ++i) {
+                q.addBindValue(counter.fetchAndAddRelaxed(1));
+                q.addBindValue("Robert");
+                QVERIFY_SQL(q, exec());
+            }
+            break; }
+        }
+    }
+
+private:
+    QSqlDatabase sourceDb;
+    Mode mode;
+};
+
+
+tst_QSqlThread::tst_QSqlThread()
+    : threadFinishedCount(0)
+{
+}
+
+tst_QSqlThread::~tst_QSqlThread()
+{
+}
+
+void tst_QSqlThread::generic_data(const QString& engine)
+{
+    if ( dbs.fillTestTable(engine) == 0 ) {
+        if(engine.isEmpty())
+           QSKIP( "No database drivers are available in this Qt configuration", SkipAll );
+        else
+           QSKIP( (QString("No database drivers of type %1 are available in this Qt configuration").arg(engine)).toLocal8Bit(), SkipAll );
+    }
+}
+
+void tst_QSqlThread::dropTestTables()
+{
+    for (int i = 0; i < dbs.dbNames.count(); ++i) {
+        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
+        QSqlQuery q(db);
+
+        tst_Databases::safeDropTables(db, QStringList() << qtest << qTableName("qtest2", __FILE__) << qTableName("emptytable", __FILE__));
+    }
+}
+
+void tst_QSqlThread::createTestTables()
+{
+    for (int i = 0; i < dbs.dbNames.count(); ++i) {
+        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
+        QSqlQuery q(db);
+
+        QVERIFY_SQL(q, exec("create table " + qtest
+                       + "(id int NOT NULL primary key, name varchar(20), title int)"));
+
+        QVERIFY_SQL(q, exec("create table " + qTableName("qtest2", __FILE__)
+                       + "(id int NOT NULL primary key, title varchar(20))"));
+
+        QVERIFY_SQL(q, exec("create table " + qTableName("emptytable", __FILE__)
+                       + "(id int NOT NULL primary key)"));
+    }
+}
+
+void tst_QSqlThread::repopulateTestTables()
+{
+    for (int i = 0; i < dbs.dbNames.count(); ++i) {
+        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
+        QSqlQuery q(db);
+
+        QVERIFY_SQL(q, exec("delete from " + qtest));
+        QVERIFY_SQL(q, exec("insert into " + qtest + " values(1, 'harry', 1)"));
+        QVERIFY_SQL(q, exec("insert into " + qtest + " values(2, 'trond', 2)"));
+        QVERIFY_SQL(q, exec("insert into " + qtest + " values(3, 'vohi', 3)"));
+
+        QVERIFY_SQL(q, exec("delete from " + qTableName("qtest2", __FILE__)));
+        QVERIFY_SQL(q, exec("insert into " + qTableName("qtest2", __FILE__) + " values(1, 'herr')"));
+        QVERIFY_SQL(q, exec("insert into " + qTableName("qtest2", __FILE__) + " values(2, 'mister')"));
+    }
+}
+
+void tst_QSqlThread::recreateTestTables()
+{
+    dropTestTables();
+    createTestTables();
+    repopulateTestTables();
+}
+
+void tst_QSqlThread::initTestCase()
+{
+    dbs.open();
+    recreateTestTables();
+}
+
+void tst_QSqlThread::cleanupTestCase()
+{
+    dropTestTables();
+    dbs.close();
+}
+
+void tst_QSqlThread::init()
+{
+    threadFinishedCount = 0;
+    counter = 4;
+}
+
+void tst_QSqlThread::cleanup()
+{
+//     repopulateTestTables();
+}
+
+// This test creates two threads that clone their db connection and read
+// from it
+void tst_QSqlThread::simpleThreading()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (db.databaseName() == ":memory:")
+        QSKIP("does not work with in-memory databases", SkipSingle);
+
+    QtTestSqlThread t1(db);
+    QtTestSqlThread t2(db);
+
+    connect(&t1, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+    connect(&t2, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+
+    t1.start();
+    t2.start();
+
+    while (threadFinishedCount < 2)
+        QTest::qWait(100);
+}
+
+// This test creates two threads that clone their db connection and read
+// or write
+void tst_QSqlThread::readWriteThreading()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (db.databaseName() == ":memory:")
+        QSKIP("does not work with in-memory databases", SkipSingle);
+    else if (tst_Databases::isMSAccess(db))
+        QSKIP("does not work with MS Access databases", SkipSingle);
+
+    SqlProducer producer(db);
+    SqlConsumer consumer(db);
+
+    connect(&producer, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+    connect(&consumer, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+
+    producer.start();
+    consumer.start();
+
+    while (threadFinishedCount < 2)
+        QTest::qWait(100);
+}
+
+// run with n threads in parallel. Change this constant to hammer the poor DB server even more
+static const int maxThreadCount = 4;
+
+void tst_QSqlThread::readFromSingleConnection()
+{
+#ifdef QOCI_THREADED
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (db.databaseName() == ":memory:")
+        QSKIP("does not work with in-memory databases", SkipSingle);
+
+    QObject cleanupHelper; // make sure the threads die when we exit the scope
+    for (int i = 0; i < maxThreadCount; ++i) {
+        SqlThread *reader = new SqlThread(SqlThread::SimpleReading, db, &cleanupHelper);
+        connect(reader, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+        reader->start();
+    }
+
+    while (threadFinishedCount < maxThreadCount)
+        QTest::qWait(100);
+#endif
+}
+
+void tst_QSqlThread::readWriteFromSingleConnection()
+{
+#ifdef QOCI_THREADED
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (db.databaseName() == ":memory:")
+        QSKIP("does not work with in-memory databases", SkipSingle);
+
+    QObject cleanupHelper;
+    for (int i = 0; i < maxThreadCount; ++i) {
+        SqlThread *reader = new SqlThread(SqlThread::SimpleReading, db, &cleanupHelper);
+        connect(reader, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+        reader->start();
+
+        SqlThread *writer = new SqlThread(SqlThread::SimpleWriting, db, &cleanupHelper);
+        connect(writer, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+        writer->start();
+    }
+
+    while (threadFinishedCount < maxThreadCount * 2)
+        QTest::qWait(100);
+#endif
+}
+
+void tst_QSqlThread::preparedReadWriteFromSingleConnection()
+{
+#ifdef QOCI_THREADED
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (db.databaseName() == ":memory:")
+        QSKIP("does not work with in-memory databases", SkipSingle);
+
+    QObject cleanupHelper;
+    for (int i = 0; i < maxThreadCount; ++i) {
+        SqlThread *reader = new SqlThread(SqlThread::PreparedReading, db, &cleanupHelper);
+        connect(reader, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+        reader->start();
+
+        SqlThread *writer = new SqlThread(SqlThread::PreparedWriting, db, &cleanupHelper);
+        connect(writer, SIGNAL(finished()), this, SLOT(threadFinished()), Qt::QueuedConnection);
+        writer->start();
+    }
+
+    while (threadFinishedCount < maxThreadCount * 2)
+        QTest::qWait(100);
+#endif
+}
+
+void tst_QSqlThread::transactionsFromSingleConnection()
+{
+#ifdef QOCI_THREADED
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (db.databaseName() == ":memory:")
+        QSKIP("does not work with in-memory databases", SkipSingle);
+
+    // start and commit a transaction
+    QVERIFY_SQL(db, db.transaction());
+    preparedReadWriteFromSingleConnection(); // read and write from multiple threads
+    if (QTest::currentTestFailed())
+        return;
+    QVERIFY_SQL(db, db.commit());
+
+    // reset test environment
+    threadFinishedCount = 0;
+
+    // start and roll back a transaction
+    QVERIFY_SQL(db, db.transaction());
+    preparedReadWriteFromSingleConnection(); // read and write from multiple threads
+    if (QTest::currentTestFailed())
+        return;
+    QVERIFY_SQL(db, db.rollback());
+#endif
+}
+
+QTEST_MAIN(tst_QSqlThread)
+#include "tst_qsqlthread.moc"
diff --git a/tests/auto/sql/models/models.pro b/tests/auto/sql/models/models.pro
new file mode 100644
index 0000000000..d04ba01710
--- /dev/null
+++ b/tests/auto/sql/models/models.pro
@@ -0,0 +1,6 @@
+TEMPLATE=subdirs
+SUBDIRS=\
+   qsqlquerymodel \
+   qsqlrelationaltablemodel \
+   qsqltablemodel \
+
diff --git a/tests/auto/sql/models/qsqlquerymodel/.gitignore b/tests/auto/sql/models/qsqlquerymodel/.gitignore
new file mode 100644
index 0000000000..e5ff8accf6
--- /dev/null
+++ b/tests/auto/sql/models/qsqlquerymodel/.gitignore
@@ -0,0 +1 @@
+tst_qsqlquerymodel
diff --git a/tests/auto/sql/models/qsqlquerymodel/qsqlquerymodel.pro b/tests/auto/sql/models/qsqlquerymodel/qsqlquerymodel.pro
new file mode 100644
index 0000000000..0664bae6e9
--- /dev/null
+++ b/tests/auto/sql/models/qsqlquerymodel/qsqlquerymodel.pro
@@ -0,0 +1,20 @@
+load(qttest_p4)
+SOURCES  += tst_qsqlquerymodel.cpp
+
+QT += widgets sql
+
+wince*: {
+   DEPLOYMENT_PLUGIN += qsqlite
+	LIBS += -lws2
+}else:symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+} else {
+   win32:LIBS += -lws2_32
+}
+
diff --git a/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp b/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp
new file mode 100644
index 0000000000..fabba48d7c
--- /dev/null
+++ b/tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp
@@ -0,0 +1,641 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <QtGui>
+
+#include <qsqldriver.h>
+#include <qsqldatabase.h>
+#include <qsqlerror.h>
+#include <qsqlfield.h>
+#include <qsqlquery.h>
+#include <qsqlrecord.h>
+
+#include <qsqlquerymodel.h>
+#include <qsortfilterproxymodel.h>
+
+#include "../../kernel/qsqldatabase/tst_databases.h"
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+Q_DECLARE_METATYPE(Qt::Orientation)
+
+class tst_QSqlQueryModel : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QSqlQueryModel();
+    virtual ~tst_QSqlQueryModel();
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void insertColumn_data() { generic_data(); }
+    void insertColumn();
+    void removeColumn_data() { generic_data(); }
+    void removeColumn();
+    void record_data() { generic_data(); }
+    void record();
+    void setHeaderData_data() { generic_data(); }
+    void setHeaderData();
+    void fetchMore_data() { generic_data(); }
+    void fetchMore();
+
+    //problem specific tests
+    void withSortFilterProxyModel_data() { generic_data(); }
+    void withSortFilterProxyModel();
+    void setQuerySignalEmission_data() { generic_data(); }
+    void setQuerySignalEmission();
+    void setQueryWithNoRowsInResultSet_data() { generic_data(); }
+    void setQueryWithNoRowsInResultSet();
+
+    void task_180617();
+    void task_180617_data() { generic_data(); }
+    void task_QTBUG_4963_setHeaderDataWithProxyModel();
+
+private:
+    void generic_data(const QString &engine=QString());
+    void dropTestTables(QSqlDatabase db);
+    void createTestTables(QSqlDatabase db);
+    void populateTestTables(QSqlDatabase db);
+    tst_Databases dbs;
+};
+
+/* Stupid class that makes protected members public for testing */
+class DBTestModel: public QSqlQueryModel
+{
+public:
+    DBTestModel(QObject *parent = 0): QSqlQueryModel(parent) {}
+    QModelIndex indexInQuery(const QModelIndex &item) const { return QSqlQueryModel::indexInQuery(item); }
+};
+
+tst_QSqlQueryModel::tst_QSqlQueryModel()
+{
+}
+
+tst_QSqlQueryModel::~tst_QSqlQueryModel()
+{
+}
+
+void tst_QSqlQueryModel::initTestCase()
+{
+    qRegisterMetaType<QModelIndex>("QModelIndex");
+    dbs.open();
+    for (QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it) {
+	QSqlDatabase db = QSqlDatabase::database((*it));
+	CHECK_DATABASE(db);
+	dropTestTables(db); //in case of leftovers
+	createTestTables(db);
+	populateTestTables(db);
+    }
+}
+
+void tst_QSqlQueryModel::cleanupTestCase()
+{
+    for (QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it) {
+	QSqlDatabase db = QSqlDatabase::database((*it));
+	CHECK_DATABASE(db);
+	dropTestTables(db);
+    }
+    dbs.close();
+}
+
+void tst_QSqlQueryModel::dropTestTables(QSqlDatabase db)
+{
+    QStringList tableNames;
+    tableNames << qTableName("test", __FILE__)
+            << qTableName("test2", __FILE__)
+            << qTableName("test3", __FILE__)
+            << qTableName("many", __FILE__);
+    tst_Databases::safeDropTables(db, tableNames);
+}
+
+void tst_QSqlQueryModel::createTestTables(QSqlDatabase db)
+{
+    dropTestTables(db);
+    QSqlQuery q(db);
+    if(tst_Databases::isPostgreSQL(db))
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+    QVERIFY_SQL( q, exec("create table " + qTableName("test", __FILE__) + "(id integer not null, name varchar(20), title integer, primary key (id))"));
+    QVERIFY_SQL( q, exec("create table " + qTableName("test2", __FILE__) + "(id integer not null, title varchar(20), primary key (id))"));
+    QVERIFY_SQL( q, exec("create table " + qTableName("test3", __FILE__) + "(id integer not null, primary key (id))"));
+    QVERIFY_SQL( q, exec("create table " + qTableName("many", __FILE__) + "(id integer not null, name varchar(20), primary key (id))"));
+}
+
+void tst_QSqlQueryModel::populateTestTables(QSqlDatabase db)
+{
+    qWarning() << "Populating test tables, this can take quite a while... ZZZzzz...";
+    bool hasTransactions = db.driver()->hasFeature(QSqlDriver::Transactions);
+
+    QSqlQuery q(db), q2(db);
+
+    tst_Databases::safeDropTables(db, QStringList() << qTableName("manytmp", __FILE__) << qTableName("test3tmp", __FILE__));
+    QVERIFY_SQL(q, exec("create table " + qTableName("manytmp", __FILE__) + "(id integer not null, name varchar(20), primary key (id))"));
+    QVERIFY_SQL(q, exec("create table " + qTableName("test3tmp", __FILE__) + "(id integer not null, primary key (id))"));
+
+    if (hasTransactions) QVERIFY_SQL(db, transaction());
+
+    QVERIFY_SQL(q, exec("insert into " + qTableName("test", __FILE__) + " values(1, 'harry', 1)"));
+    QVERIFY_SQL(q, exec("insert into " + qTableName("test", __FILE__) + " values(2, 'trond', 2)"));
+    QVERIFY_SQL(q, exec("insert into " + qTableName("test2", __FILE__) + " values(1, 'herr')"));
+    QVERIFY_SQL(q, exec("insert into " + qTableName("test2", __FILE__) + " values(2, 'mister')"));
+
+    QVERIFY_SQL(q, exec(QString("insert into " + qTableName("test3", __FILE__) + " values(0)")));
+    QVERIFY_SQL(q, prepare("insert into "+qTableName("test3", __FILE__)+"(id) select id + ? from "+qTableName("test3tmp", __FILE__)));
+    for (int i=1; i<260; i*=2) {
+        q2.exec("delete from "+qTableName("test3tmp", __FILE__));
+        QVERIFY_SQL(q2, exec("insert into "+qTableName("test3tmp", __FILE__)+"(id) select id from "+qTableName("test3", __FILE__)));
+        q.bindValue(0, i);
+        QVERIFY_SQL(q, exec());
+    }
+
+    QVERIFY_SQL(q, exec(QString("insert into " + qTableName("many", __FILE__) + "(id, name) values (0, \'harry\')")));
+    QVERIFY_SQL(q, prepare("insert into "+qTableName("many", __FILE__)+"(id, name) select id + ?, name from "+qTableName("manytmp", __FILE__)));
+    for (int i=1; i < 2048; i*=2) {
+        q2.exec("delete from "+qTableName("manytmp", __FILE__));
+        QVERIFY_SQL(q2, exec("insert into "+qTableName("manytmp", __FILE__)+"(id, name) select id, name from "+qTableName("many", __FILE__)));
+        q.bindValue(0, i);
+        QVERIFY_SQL(q, exec());
+    }
+
+    if (hasTransactions) QVERIFY_SQL(db, commit());
+
+    tst_Databases::safeDropTables(db, QStringList() << qTableName("manytmp", __FILE__) << qTableName("test3tmp", __FILE__));
+}
+
+void tst_QSqlQueryModel::generic_data(const QString& engine)
+{
+    if ( dbs.fillTestTable(engine) == 0 ) {
+        if(engine.isEmpty())
+           QSKIP( "No database drivers are available in this Qt configuration", SkipAll );
+        else
+           QSKIP( (QString("No database drivers of type %1 are available in this Qt configuration").arg(engine)).toLocal8Bit(), SkipAll );
+    }
+}
+
+void tst_QSqlQueryModel::init()
+{
+}
+
+void tst_QSqlQueryModel::cleanup()
+{
+}
+
+void tst_QSqlQueryModel::removeColumn()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    DBTestModel model;
+    model.setQuery(QSqlQuery("select * from " + qTableName("test", __FILE__), db));
+    model.fetchMore();
+    QSignalSpy spy(&model, SIGNAL(columnsAboutToBeRemoved(QModelIndex, int, int)));
+
+    QCOMPARE(model.columnCount(), 3);
+    QVERIFY(model.removeColumn(0));
+    QCOMPARE(spy.count(), 1);
+    QVERIFY(*(QModelIndex *)spy.at(0).at(0).constData() == QModelIndex());
+    QCOMPARE(spy.at(0).at(1).toInt(), 0);
+    QCOMPARE(spy.at(0).at(2).toInt(), 0);
+
+    QCOMPARE(model.columnCount(), 2);
+    QCOMPARE(model.indexInQuery(model.index(0, 0)).column(), 1);
+    QCOMPARE(model.indexInQuery(model.index(0, 1)).column(), 2);
+    QCOMPARE(model.indexInQuery(model.index(0, 2)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 3)).column(), -1);
+
+    QVERIFY(model.insertColumn(1));
+    QCOMPARE(model.columnCount(), 3);
+    QCOMPARE(model.indexInQuery(model.index(0, 0)).column(), 1);
+    QCOMPARE(model.indexInQuery(model.index(0, 1)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 2)).column(), 2);
+    QCOMPARE(model.indexInQuery(model.index(0, 3)).column(), -1);
+
+    QCOMPARE(model.data(model.index(0, 0)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 1)), QVariant());
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 3)), QVariant());
+
+    QVERIFY(!model.removeColumn(42));
+    QVERIFY(!model.removeColumn(3));
+    QVERIFY(!model.removeColumn(1, model.index(1, 2)));
+    QCOMPARE(model.columnCount(), 3);
+
+    QVERIFY(model.removeColumn(2));
+
+    QCOMPARE(spy.count(), 2);
+    QVERIFY(*(QModelIndex *)spy.at(1).at(0).constData() == QModelIndex());
+    QCOMPARE(spy.at(1).at(1).toInt(), 2);
+    QCOMPARE(spy.at(1).at(2).toInt(), 2);
+
+    QCOMPARE(model.columnCount(), 2);
+    QCOMPARE(model.indexInQuery(model.index(0, 0)).column(), 1);
+    QCOMPARE(model.indexInQuery(model.index(0, 1)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 2)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 3)).column(), -1);
+
+    QVERIFY(model.removeColumn(1));
+
+    QCOMPARE(spy.count(), 3);
+    QVERIFY(*(QModelIndex *)spy.at(2).at(0).constData() == QModelIndex());
+    QCOMPARE(spy.at(2).at(1).toInt(), 1);
+    QCOMPARE(spy.at(2).at(2).toInt(), 1);
+
+    QCOMPARE(model.columnCount(), 1);
+    QCOMPARE(model.indexInQuery(model.index(0, 0)).column(), 1);
+    QCOMPARE(model.indexInQuery(model.index(0, 1)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 2)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 3)).column(), -1);
+    QCOMPARE(model.data(model.index(0, 0)).toString(), QString("harry"));
+
+    QVERIFY(model.removeColumn(0));
+
+    QCOMPARE(spy.count(), 4);
+    QVERIFY(*(QModelIndex *)spy.at(3).at(0).constData() == QModelIndex());
+    QCOMPARE(spy.at(3).at(1).toInt(), 0);
+    QCOMPARE(spy.at(3).at(2).toInt(), 0);
+
+    QCOMPARE(model.columnCount(), 0);
+    QCOMPARE(model.indexInQuery(model.index(0, 0)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 1)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 2)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 3)).column(), -1);
+}
+
+void tst_QSqlQueryModel::insertColumn()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    DBTestModel model;
+    model.setQuery(QSqlQuery("select * from " + qTableName("test", __FILE__), db));
+    model.fetchMore(); // necessary???
+
+    bool isToUpper = db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2");
+    const QString idColumn(isToUpper ? "ID" : "id");
+    const QString nameColumn(isToUpper ? "NAME" : "name");
+    const QString titleColumn(isToUpper ? "TITLE" : "title");
+
+    QSignalSpy spy(&model, SIGNAL(columnsInserted(QModelIndex, int, int)));
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 3)), QVariant());
+
+    QCOMPARE(model.headerData(0, Qt::Horizontal).toString(), idColumn);
+    QCOMPARE(model.headerData(1, Qt::Horizontal).toString(), nameColumn);
+    QCOMPARE(model.headerData(2, Qt::Horizontal).toString(), titleColumn);
+    QCOMPARE(model.headerData(3, Qt::Horizontal).toString(), QString("4"));
+
+    QVERIFY(model.insertColumn(1));
+
+    QCOMPARE(spy.count(), 1);
+    QVERIFY(*(QModelIndex *)spy.at(0).at(0).constData() == QModelIndex());
+    QCOMPARE(spy.at(0).at(1).toInt(), 1);
+    QCOMPARE(spy.at(0).at(2).toInt(), 1);
+
+    QCOMPARE(model.indexInQuery(model.index(0, 0)).column(), 0);
+    QCOMPARE(model.indexInQuery(model.index(0, 1)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 2)).column(), 1);
+    QCOMPARE(model.indexInQuery(model.index(0, 3)).column(), 2);
+    QCOMPARE(model.indexInQuery(model.index(0, 4)).column(), -1);
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)), QVariant());
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 3)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 4)), QVariant());
+
+    QCOMPARE(model.headerData(0, Qt::Horizontal).toString(), idColumn);
+    QCOMPARE(model.headerData(1, Qt::Horizontal).toString(), QString("2"));
+    QCOMPARE(model.headerData(2, Qt::Horizontal).toString(), nameColumn);
+    QCOMPARE(model.headerData(3, Qt::Horizontal).toString(), titleColumn);
+    QCOMPARE(model.headerData(4, Qt::Horizontal).toString(), QString("5"));
+
+    QVERIFY(!model.insertColumn(-1));
+    QVERIFY(!model.insertColumn(100));
+    QVERIFY(!model.insertColumn(1, model.index(1, 1)));
+
+    QVERIFY(model.insertColumn(0));
+
+    QCOMPARE(spy.count(), 2);
+    QVERIFY(*(QModelIndex *)spy.at(1).at(0).constData() == QModelIndex());
+    QCOMPARE(spy.at(1).at(1).toInt(), 0);
+    QCOMPARE(spy.at(1).at(2).toInt(), 0);
+
+    QCOMPARE(model.indexInQuery(model.index(0, 0)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 1)).column(), 0);
+    QCOMPARE(model.indexInQuery(model.index(0, 2)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 3)).column(), 1);
+    QCOMPARE(model.indexInQuery(model.index(0, 4)).column(), 2);
+    QCOMPARE(model.indexInQuery(model.index(0, 5)).column(), -1);
+
+    QVERIFY(!model.insertColumn(6));
+    QVERIFY(model.insertColumn(5));
+
+    QCOMPARE(spy.count(), 3);
+    QVERIFY(*(QModelIndex *)spy.at(2).at(0).constData() == QModelIndex());
+    QCOMPARE(spy.at(2).at(1).toInt(), 5);
+    QCOMPARE(spy.at(2).at(2).toInt(), 5);
+
+    QCOMPARE(model.indexInQuery(model.index(0, 0)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 1)).column(), 0);
+    QCOMPARE(model.indexInQuery(model.index(0, 2)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 3)).column(), 1);
+    QCOMPARE(model.indexInQuery(model.index(0, 4)).column(), 2);
+    QCOMPARE(model.indexInQuery(model.index(0, 5)).column(), -1);
+    QCOMPARE(model.indexInQuery(model.index(0, 6)).column(), -1);
+
+    QCOMPARE(model.record().field(0).name(), QString());
+    QCOMPARE(model.record().field(1).name(), idColumn);
+    QCOMPARE(model.record().field(2).name(), QString());
+    QCOMPARE(model.record().field(3).name(), nameColumn);
+    QCOMPARE(model.record().field(4).name(), titleColumn);
+    QCOMPARE(model.record().field(5).name(), QString());
+    QCOMPARE(model.record().field(6).name(), QString());
+
+    QCOMPARE(model.headerData(0, Qt::Horizontal).toString(), QString("1"));
+    QCOMPARE(model.headerData(1, Qt::Horizontal).toString(), idColumn);
+    QCOMPARE(model.headerData(2, Qt::Horizontal).toString(), QString("3"));
+    QCOMPARE(model.headerData(3, Qt::Horizontal).toString(), nameColumn);
+    QCOMPARE(model.headerData(4, Qt::Horizontal).toString(), titleColumn);
+    QCOMPARE(model.headerData(5, Qt::Horizontal).toString(), QString("6"));
+    QCOMPARE(model.headerData(6, Qt::Horizontal).toString(), QString("7"));
+}
+
+void tst_QSqlQueryModel::record()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQueryModel model;
+    model.setQuery(QSqlQuery("select * from " + qTableName("test", __FILE__), db));
+
+    QSqlRecord rec = model.record();
+
+    bool isToUpper = db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2");
+
+    QCOMPARE(rec.count(), 3);
+    QCOMPARE(rec.fieldName(0), isToUpper ? QString("ID") : QString("id"));
+    QCOMPARE(rec.fieldName(1), isToUpper ? QString("NAME") : QString("name"));
+    QCOMPARE(rec.fieldName(2), isToUpper ? QString("TITLE") : QString("title"));
+    QCOMPARE(rec.value(0), QVariant(rec.field(0).type()));
+    QCOMPARE(rec.value(1), QVariant(rec.field(1).type()));
+    QCOMPARE(rec.value(2), QVariant(rec.field(2).type()));
+
+    rec = model.record(0);
+    QCOMPARE(rec.fieldName(0), isToUpper ? QString("ID") : QString("id"));
+    QCOMPARE(rec.fieldName(1), isToUpper ? QString("NAME") : QString("name"));
+    QCOMPARE(rec.fieldName(2), isToUpper ? QString("TITLE") : QString("title"));
+    QCOMPARE(rec.value(0).toString(), QString("1"));
+    QCOMPARE(rec.value(1), QVariant("harry"));
+    QCOMPARE(rec.value(2), QVariant(1));
+}
+
+void tst_QSqlQueryModel::setHeaderData()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQueryModel model;
+
+    QVERIFY(!model.setHeaderData(5, Qt::Vertical, "foo"));
+    QVERIFY(model.headerData(5, Qt::Vertical).isValid());
+
+    model.setQuery(QSqlQuery("select * from " + qTableName("test", __FILE__), db));
+
+    qRegisterMetaType<Qt::Orientation>("Qt::Orientation");
+    QSignalSpy spy(&model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)));
+    QVERIFY(model.setHeaderData(2, Qt::Horizontal, "bar"));
+    QCOMPARE(model.headerData(2, Qt::Horizontal).toString(), QString("bar"));
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(qvariant_cast<Qt::Orientation>(spy.value(0).value(0)), Qt::Horizontal);
+    QCOMPARE(spy.value(0).value(1).toInt(), 2);
+    QCOMPARE(spy.value(0).value(2).toInt(), 2);
+
+    QVERIFY(!model.setHeaderData(7, Qt::Horizontal, "foo", Qt::ToolTipRole));
+    QVERIFY(!model.headerData(7, Qt::Horizontal, Qt::ToolTipRole).isValid());
+
+    bool isToUpper = db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2");
+    QCOMPARE(model.headerData(0, Qt::Horizontal).toString(), isToUpper ? QString("ID") : QString("id"));
+    QCOMPARE(model.headerData(1, Qt::Horizontal).toString(), isToUpper ? QString("NAME") : QString("name"));
+    QCOMPARE(model.headerData(2, Qt::Horizontal).toString(), QString("bar"));
+    QVERIFY(model.headerData(3, Qt::Horizontal).isValid());
+}
+
+void tst_QSqlQueryModel::fetchMore()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQueryModel model;
+    QSignalSpy spy(&model, SIGNAL(rowsInserted(QModelIndex, int, int)));
+
+    model.setQuery(QSqlQuery("select * from " + qTableName("many", __FILE__), db));
+    int rowCount = model.rowCount();
+
+    QCOMPARE(spy.value(0).value(1).toInt(), 0);
+    QCOMPARE(spy.value(0).value(2).toInt(), rowCount - 1);
+
+    // If the driver doesn't return the query size fetchMore() causes the
+    // model to grow and new signals are emitted
+    if (!db.driver()->hasFeature(QSqlDriver::QuerySize)) {
+        spy.clear();
+        model.fetchMore();
+        int newRowCount = model.rowCount();
+        QCOMPARE(spy.value(0).value(1).toInt(), rowCount);
+        QCOMPARE(spy.value(0).value(2).toInt(), newRowCount - 1);
+    }
+}
+
+// For task 149491: When used with QSortFilterProxyModel, a view and a
+// database that doesn't support the QuerySize feature, blank rows was
+// appended if the query returned more than 256 rows and setQuery()
+// was called more than once. This because an insertion of rows was
+// triggered at the same time as the model was being cleared.
+void tst_QSqlQueryModel::withSortFilterProxyModel()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (db.driver()->hasFeature(QSqlDriver::QuerySize))
+        QSKIP("Test applies only for drivers not reporting the query size.", SkipSingle);
+
+    QSqlQueryModel model;
+    model.setQuery(QSqlQuery("SELECT * FROM " + qTableName("test3", __FILE__), db));
+    QSortFilterProxyModel proxy;
+    proxy.setSourceModel(&model);
+
+    QTableView view;
+    view.setModel(&proxy);
+
+    QSignalSpy modelRowsRemovedSpy(&model, SIGNAL(rowsRemoved(const QModelIndex &, int, int)));
+    QSignalSpy modelRowsInsertedSpy(&model, SIGNAL(rowsInserted(const QModelIndex &, int, int)));
+    model.setQuery(QSqlQuery("SELECT * FROM " + qTableName("test3", __FILE__), db));
+    view.scrollToBottom();
+
+    QTestEventLoop::instance().enterLoop(1);
+
+    QCOMPARE(proxy.rowCount(), 511);
+
+    // The second call to setQuery() clears the model by removing it's rows.
+    // Only 256 rows because that is what was cached.
+    QCOMPARE(modelRowsRemovedSpy.count(), 1);
+    QCOMPARE(modelRowsRemovedSpy.value(0).value(1).toInt(), 0);
+    QCOMPARE(modelRowsRemovedSpy.value(0).value(2).toInt(), 255);
+
+    // The call to scrollToBottom() forces the model to fetch all rows,
+    // which will be done in two steps.
+    QCOMPARE(modelRowsInsertedSpy.count(), 2);
+    QCOMPARE(modelRowsInsertedSpy.value(0).value(1).toInt(), 0);
+    QCOMPARE(modelRowsInsertedSpy.value(0).value(2).toInt(), 255);
+    QCOMPARE(modelRowsInsertedSpy.value(1).value(1).toInt(), 256);
+    QCOMPARE(modelRowsInsertedSpy.value(1).value(2).toInt(), 510);
+}
+
+// For task 155402: When the model is already empty when setQuery() is called
+// no rows have to be removed and rowsAboutToBeRemoved and rowsRemoved should
+// not be emitted.
+void tst_QSqlQueryModel::setQuerySignalEmission()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQueryModel model;
+    QSignalSpy modelRowsAboutToBeRemovedSpy(&model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)));
+    QSignalSpy modelRowsRemovedSpy(&model, SIGNAL(rowsRemoved(const QModelIndex &, int, int)));
+
+    // First select, the model was empty and no rows had to be removed!
+    model.setQuery(QSqlQuery("SELECT * FROM " + qTableName("test", __FILE__), db));
+    QCOMPARE(modelRowsAboutToBeRemovedSpy.count(), 0);
+    QCOMPARE(modelRowsRemovedSpy.count(), 0);
+
+    // Second select, the model wasn't empty and two rows had to be removed!
+    model.setQuery(QSqlQuery("SELECT * FROM " + qTableName("test", __FILE__), db));
+    QCOMPARE(modelRowsAboutToBeRemovedSpy.count(), 1);
+    QCOMPARE(modelRowsAboutToBeRemovedSpy.value(0).value(1).toInt(), 0);
+    QCOMPARE(modelRowsAboutToBeRemovedSpy.value(0).value(2).toInt(), 1);
+    QCOMPARE(modelRowsRemovedSpy.count(), 1);
+    QCOMPARE(modelRowsRemovedSpy.value(0).value(1).toInt(), 0);
+    QCOMPARE(modelRowsRemovedSpy.value(0).value(2).toInt(), 1);
+}
+
+// For task 170783: When the query's result set is empty no rows should be inserted,
+// i.e. no rowsAboutToBeInserted or rowsInserted signals should be emitted.
+void tst_QSqlQueryModel::setQueryWithNoRowsInResultSet()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQueryModel model;
+    QSignalSpy modelRowsAboutToBeInsertedSpy(&model, SIGNAL(rowsAboutToBeInserted(const QModelIndex &, int, int)));
+    QSignalSpy modelRowsInsertedSpy(&model, SIGNAL(rowsInserted(const QModelIndex &, int, int)));
+
+    // The query's result set will be empty so no signals should be emitted!
+    QSqlQuery query(db);
+    QVERIFY_SQL(query, exec("SELECT * FROM " + qTableName("test", __FILE__) + " where 0 = 1"));
+    model.setQuery(query);
+    QCOMPARE(modelRowsAboutToBeInsertedSpy.count(), 0);
+    QCOMPARE(modelRowsInsertedSpy.count(), 0);
+}
+
+// For task 180617
+// According to the task, several specific duplicate SQL queries would cause
+// multiple empty grid lines to be visible in the view
+void tst_QSqlQueryModel::task_180617()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    const QString test3(qTableName("test3", __FILE__));
+
+    QTableView view;
+    QCOMPARE(view.columnAt(0), -1);
+    QCOMPARE(view.rowAt(0), -1);
+
+    QSqlQueryModel model;
+    model.setQuery( "SELECT TOP 0 * FROM " + test3, db );
+    view.setModel(&model);
+
+    bool error = false;
+    // Usually a syntax error
+    if (model.lastError().isValid())    // usually a syntax error
+        error = true;
+
+    QCOMPARE(view.columnAt(0), (error)?-1:0 );
+    QCOMPARE(view.rowAt(0), -1);
+
+    model.setQuery( "SELECT TOP 0 * FROM " + test3, db );
+    model.setQuery( "SELECT TOP 0 * FROM " + test3, db );
+    model.setQuery( "SELECT TOP 0 * FROM " + test3, db );
+    model.setQuery( "SELECT TOP 0 * FROM " + test3, db );
+
+    QCOMPARE(view.columnAt(0),  (error)?-1:0 );
+    QCOMPARE(view.rowAt(0), -1);
+}
+
+void tst_QSqlQueryModel::task_QTBUG_4963_setHeaderDataWithProxyModel()
+{
+    QSqlQueryModel plainModel;
+    QSortFilterProxyModel proxyModel;
+    proxyModel.setSourceModel(&plainModel);
+    QVERIFY(!plainModel.setHeaderData(0, Qt::Horizontal, QObject::tr("ID")));
+    // And it should not crash.
+}
+
+QTEST_MAIN(tst_QSqlQueryModel)
+#include "tst_qsqlquerymodel.moc"
diff --git a/tests/auto/sql/models/qsqlrelationaltablemodel/.gitignore b/tests/auto/sql/models/qsqlrelationaltablemodel/.gitignore
new file mode 100644
index 0000000000..b6f469c4dc
--- /dev/null
+++ b/tests/auto/sql/models/qsqlrelationaltablemodel/.gitignore
@@ -0,0 +1 @@
+tst_qsqlrelationaltablemodel
diff --git a/tests/auto/sql/models/qsqlrelationaltablemodel/qsqlrelationaltablemodel.pro b/tests/auto/sql/models/qsqlrelationaltablemodel/qsqlrelationaltablemodel.pro
new file mode 100644
index 0000000000..dad42d512c
--- /dev/null
+++ b/tests/auto/sql/models/qsqlrelationaltablemodel/qsqlrelationaltablemodel.pro
@@ -0,0 +1,25 @@
+load(qttest_p4)
+SOURCES  += tst_qsqlrelationaltablemodel.cpp
+
+QT += sql
+
+wince*: {
+   plugFiles.files = ../../../plugins/sqldrivers
+   plugFiles.path    = .
+   DEPLOYMENT += plugFiles
+   LIBS += -lws2
+}else:symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+} else {
+   win32-g++* {
+        LIBS += -lws2_32
+   } else:win32 {
+        LIBS += ws2_32.lib
+   }
+}
diff --git a/tests/auto/sql/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp b/tests/auto/sql/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
new file mode 100644
index 0000000000..2c5af13c0c
--- /dev/null
+++ b/tests/auto/sql/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp
@@ -0,0 +1,1494 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <QtSql/QtSql>
+
+#include "../../kernel/qsqldatabase/tst_databases.h"
+
+const QString reltest1(qTableName("reltest1", __FILE__)),
+        reltest2(qTableName("reltest2", __FILE__)),
+        reltest3(qTableName("reltest3", __FILE__)),
+        reltest4(qTableName("reltest4", __FILE__)),
+        reltest5(qTableName("reltest5", __FILE__));
+
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QSqlRelationalTableModel : public QObject
+{
+    Q_OBJECT
+
+public:
+    void recreateTestTables(QSqlDatabase);
+
+    tst_Databases dbs;
+
+public slots:
+    void initTestCase_data();
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void data();
+    void setData();
+    void multipleRelation();
+    void insertRecord();
+    void setRecord();
+    void insertWithStrategies();
+    void removeColumn();
+    void filter();
+    void sort();
+    void revert();
+
+    void clearDisplayValuesCache();
+    void insertRecordDuplicateFieldNames();
+    void invalidData();
+    void relationModel();
+    void casing();
+    void escapedRelations();
+    void escapedTableName();
+    void whiteSpaceInIdentifiers();
+    void psqlSchemaTest();
+    void selectAfterUpdate();
+
+private:
+    void dropTestTables( QSqlDatabase db );
+};
+
+
+void tst_QSqlRelationalTableModel::initTestCase_data()
+{
+    dbs.open();
+    if (dbs.fillTestTable() == 0) {
+        qWarning("NO DATABASES");
+        QSKIP("No database drivers are available in this Qt configuration", SkipAll);
+    }
+}
+
+void tst_QSqlRelationalTableModel::recreateTestTables(QSqlDatabase db)
+{
+    dropTestTables(db);
+
+    QSqlQuery q(db);
+    QVERIFY_SQL( q, exec("create table " + reltest1 +
+            " (id int not null primary key, name varchar(20), title_key int, another_title_key int)"));
+    QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(1, 'harry', 1, 2)"));
+    QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(2, 'trond', 2, 1)"));
+    QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(3, 'vohi', 1, 2)"));
+    QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(4, 'boris', 2, 2)"));
+    QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(5, 'nat', NULL, NULL)"));
+    QVERIFY_SQL( q, exec("insert into " + reltest1 + " values(6, 'ale', NULL, 2)"));
+
+    QVERIFY_SQL( q, exec("create table " + reltest2 + " (tid int not null primary key, title varchar(20))"));
+    QVERIFY_SQL( q, exec("insert into " + reltest2 + " values(1, 'herr')"));
+    QVERIFY_SQL( q, exec("insert into " + reltest2 + " values(2, 'mister')"));
+
+    QVERIFY_SQL( q, exec("create table " + reltest3 + " (id int not null primary key, name varchar(20), city_key int)"));
+    QVERIFY_SQL( q, exec("insert into " + reltest3 + " values(1, 'Gustav', 1)"));
+    QVERIFY_SQL( q, exec("insert into " + reltest3 + " values(2, 'Heidi', 2)"));
+
+    QVERIFY_SQL( q, exec("create table " + reltest4 + " (id int not null primary key, name varchar(20))"));
+    QVERIFY_SQL( q, exec("insert into " + reltest4 + " values(1, 'Oslo')"));
+    QVERIFY_SQL( q, exec("insert into " + reltest4 + " values(2, 'Trondheim')"));
+
+    QVERIFY_SQL( q, exec("create table " + reltest5 + " (title varchar(20) not null primary key, abbrev varchar(20))"));
+    QVERIFY_SQL( q, exec("insert into " + reltest5 + " values('herr', 'Hr')"));
+    QVERIFY_SQL( q, exec("insert into " + reltest5 + " values('mister', 'Mr')"));
+
+    if (testWhiteSpaceNames(db.driverName())) {
+        QString reltest6 = db.driver()->escapeIdentifier(qTableName("rel", __FILE__)+" test6", QSqlDriver::TableName);
+        QVERIFY_SQL( q, exec("create table " + reltest6 + " (id int not null primary key, " + db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName) +
+                    " int, " + db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName) + " int)"));
+        QVERIFY_SQL( q, exec("insert into " + reltest6 + " values(1, 1,9)"));
+        QVERIFY_SQL( q, exec("insert into " + reltest6 + " values(2, 2,8)"));
+
+        QString reltest7 = db.driver()->escapeIdentifier(qTableName("rel", __FILE__)+" test7", QSqlDriver::TableName);
+        QVERIFY_SQL( q, exec("create table " + reltest7 + " (" + db.driver()->escapeIdentifier("city id", QSqlDriver::TableName) + " int not null primary key, " + db.driver()->escapeIdentifier("city name", QSqlDriver::FieldName) + " varchar(20))"));
+        QVERIFY_SQL( q, exec("insert into " + reltest7 + " values(1, 'New York')"));
+        QVERIFY_SQL( q, exec("insert into " + reltest7 + " values(2, 'Washington')"));
+    }
+}
+
+void tst_QSqlRelationalTableModel::initTestCase()
+{
+    foreach (const QString &dbname, dbs.dbNames) {
+        QSqlDatabase db=QSqlDatabase::database(dbname);
+        if (db.driverName().startsWith("QIBASE"))
+            db.exec("SET DIALECT 3");
+        else if (tst_Databases::isSqlServer(db)) {
+            db.exec("SET ANSI_DEFAULTS ON");
+            db.exec("SET IMPLICIT_TRANSACTIONS OFF");
+        }
+        else if(tst_Databases::isPostgreSQL(db))
+            db.exec("set client_min_messages='warning'");
+        recreateTestTables(db);
+    }
+}
+
+void tst_QSqlRelationalTableModel::cleanupTestCase()
+{
+    foreach (const QString &dbName, dbs.dbNames) {
+        QSqlDatabase db = QSqlDatabase::database(dbName);
+        CHECK_DATABASE( db );
+        dropTestTables( QSqlDatabase::database(dbName) );
+    }
+    dbs.close();
+}
+
+void tst_QSqlRelationalTableModel::dropTestTables( QSqlDatabase db )
+{
+    QStringList tableNames;
+    tableNames << reltest1
+            << reltest2
+            << reltest3
+            << reltest4
+            << reltest5
+            << (qTableName( "rel", __FILE__)+" test6")
+            << (qTableName( "rel", __FILE__)+" test7")
+            << qTableName("CASETEST1", db.driver() )
+            << qTableName("casetest1", db.driver() );
+    tst_Databases::safeDropTables( db, tableNames );
+
+    db.exec("DROP SCHEMA "+qTableName("QTBUG_5373", __FILE__)+" CASCADE");
+    db.exec("DROP SCHEMA "+qTableName("QTBUG_5373_s2", __FILE__)+" CASCADE");
+}
+
+void tst_QSqlRelationalTableModel::init()
+{
+}
+
+void tst_QSqlRelationalTableModel::cleanup()
+{
+}
+
+void tst_QSqlRelationalTableModel::data()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.columnCount(), 4);
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    //try a non-existent index
+    QVERIFY2(model.data(model.index(0,4)).isValid() == false,"Invalid index returned valid QVariant");
+
+    // check row with null relation: they are reported only in LeftJoin mode
+    QCOMPARE(model.rowCount(), 4);
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(4, 0)).toInt(), 5);
+    QCOMPARE(model.data(model.index(4, 1)).toString(), QString("nat"));
+    QVERIFY2(model.data(model.index(4, 2)).isValid() == true, "NULL relation reported with invalid QVariant");
+
+    //check data retrieval when relational key is a non-integer type
+    //in this case a string
+    QSqlRelationalTableModel model2(0,db);
+    model2.setTable(reltest2);
+    model2.setRelation(1, QSqlRelation(reltest5,"title","abbrev"));
+    QVERIFY_SQL(model2, select());
+
+    QCOMPARE(model2.data(model2.index(0, 1)).toString(), QString("Hr"));
+    QCOMPARE(model2.data(model2.index(1, 1)).toString(), QString("Mr"));
+}
+
+void tst_QSqlRelationalTableModel::setData()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    // set the values using OnRowChange Strategy
+    {
+        QSqlRelationalTableModel model(0, db);
+
+        model.setTable(reltest1);
+        model.setSort(0, Qt::AscendingOrder);
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        QVERIFY_SQL(model, select());
+
+        QVERIFY(model.setData(model.index(0, 1), QString("harry2")));
+        QVERIFY(model.setData(model.index(0, 2), 2));
+
+        QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));
+        QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+
+        model.submit();
+
+        QVERIFY(model.setData(model.index(3,1), QString("boris2")));
+        QVERIFY(model.setData(model.index(3, 2), 1));
+
+        QCOMPARE(model.data(model.index(3,1)).toString(), QString("boris2"));
+        QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+
+        model.submit();
+    }
+    { //verify values
+        QSqlRelationalTableModel model(0, db);
+        model.setTable(reltest1);
+        model.setSort(0, Qt::AscendingOrder);
+        QVERIFY_SQL(model, select());
+
+        QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));
+        QCOMPARE(model.data(model.index(0, 2)).toInt(), 2);
+        QCOMPARE(model.data(model.index(3, 1)).toString(), QString("boris2"));
+        QCOMPARE(model.data(model.index(3, 2)).toInt(), 1);
+
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        QVERIFY_SQL(model, select());
+        QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+        QCOMPARE(model.data(model.index(3,2)).toString(), QString("herr"));
+
+    }
+
+    //set the values using OnFieldChange strategy
+    {
+        QSqlRelationalTableModel model(0, db);
+        model.setTable(reltest1);
+        model.setEditStrategy(QSqlTableModel::OnFieldChange);
+        model.setSort(0, Qt::AscendingOrder);
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        QVERIFY_SQL(model, select());
+
+        QVERIFY(model.setData(model.index(1,1), QString("trond2")));
+        QVERIFY(model.setData(model.index(2,2), 2));
+
+        QCOMPARE(model.data(model.index(1,1)).toString(), QString("trond2"));
+        QCOMPARE(model.data(model.index(2,2)).toString(), QString("mister"));
+    }
+    { //verify values
+        QSqlRelationalTableModel model(0, db);
+        model.setTable(reltest1);
+        model.setSort(0, Qt::AscendingOrder);
+        QVERIFY_SQL(model, select());
+
+        QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond2"));
+        QCOMPARE(model.data(model.index(2, 2)).toInt(), 2);
+
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        QVERIFY_SQL(model, select());
+        QCOMPARE(model.data(model.index(2, 2)).toString(), QString("mister"));
+    }
+
+    //set values using OnManualSubmit strategy
+    {
+        QSqlRelationalTableModel model(0, db);
+
+        model.setTable(reltest1);
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+
+        //sybase doesn't allow tables with the same alias used twice as col names
+        //so don't set up an identical relation when using the tds driver
+        if (!db.driverName().startsWith("QTDS"))
+            model.setRelation(3, QSqlRelation(reltest2, "tid", "title"));
+
+        model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+        model.setSort(0, Qt::AscendingOrder);
+        QVERIFY_SQL(model, select());
+
+        QVERIFY(model.setData(model.index(2, 1), QString("vohi2")));
+        QVERIFY(model.setData(model.index(3, 2), 1));
+        QVERIFY(model.setData(model.index(0, 3), 1));
+
+        QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi2"));
+        QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+        if (!db.driverName().startsWith("QTDS"))
+            QCOMPARE(model.data(model.index(0, 3)).toString(), QString("herr"));
+        else
+            QCOMPARE(model.data(model.index(0, 3)).toInt(), 1);
+
+        QVERIFY_SQL(model, submitAll());
+    }
+    { //verify values
+        QSqlRelationalTableModel model(0, db);
+        model.setTable(reltest1);
+        model.setSort(0, Qt::AscendingOrder);
+        QVERIFY_SQL(model, select());
+
+        QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi2"));
+        QCOMPARE(model.data(model.index(3, 2)).toInt(), 1);
+        QCOMPARE(model.data(model.index(0, 3)).toInt(), 1);
+
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        if (!db.driverName().startsWith("QTDS"))
+            model.setRelation(3, QSqlRelation(reltest2, "tid", "title"));
+        QVERIFY_SQL(model, select());
+        QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+
+        if (!db.driverName().startsWith("QTDS"))
+            QCOMPARE(model.data(model.index(0, 3)).toString(), QString("herr"));
+        else
+            QCOMPARE(model.data(model.index(0, 3)).toInt(), 1);
+    }
+
+    //check setting of data when the relational key is a non-integer type
+    //in this case a string.
+    {
+        QSqlRelationalTableModel model(0, db);
+
+        model.setTable(reltest2);
+        model.setRelation(1, QSqlRelation(reltest5, "title", "abbrev"));
+        model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+        QVERIFY_SQL(model, select());
+
+        QCOMPARE(model.data(model.index(0,1)).toString(), QString("Hr"));
+        QVERIFY(model.setData(model.index(0,1), QString("mister")));
+        QCOMPARE(model.data(model.index(0,1)).toString(), QString("Mr"));
+        QVERIFY_SQL(model, submitAll());
+
+        QCOMPARE(model.data(model.index(0,1)).toString(), QString("Mr"));
+    }
+
+    // Redo same tests, with a LeftJoin
+    {
+        QSqlRelationalTableModel model(0, db);
+
+        model.setTable(reltest2);
+        model.setRelation(1, QSqlRelation(reltest5, "title", "abbrev"));
+        model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+        model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+        QVERIFY_SQL(model, select());
+
+        QCOMPARE(model.data(model.index(0,1)).toString(), QString("Mr"));
+        QVERIFY(model.setData(model.index(0,1), QString("herr")));
+        QCOMPARE(model.data(model.index(0,1)).toString(), QString("Hr"));
+        QVERIFY_SQL(model, submitAll());
+
+        QCOMPARE(model.data(model.index(0,1)).toString(), QString("Hr"));
+    }
+
+}
+
+void tst_QSqlRelationalTableModel::multipleRelation()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    recreateTestTables(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    model.setRelation(3, QSqlRelation(reltest4, "id", "name"));
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+    QCOMPARE(model.data(model.index(0, 3)).toString(), QString("Trondheim"));
+
+    // Redo same test in the LeftJoin mode
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    model.setRelation(3, QSqlRelation(reltest4, "id", "name"));
+    model.setSort(0, Qt::AscendingOrder);
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+    QCOMPARE(model.data(model.index(0, 3)).toString(), QString("Trondheim"));
+}
+
+void tst_QSqlRelationalTableModel::insertRecord()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QSqlRecord rec;
+    QSqlField f1("id", QVariant::Int);
+    QSqlField f2("name", QVariant::String);
+    QSqlField f3("title_key", QVariant::Int);
+    QSqlField f4("another_title_key", QVariant::Int);
+
+    f1.setValue(7);
+    f2.setValue("test");
+    f3.setValue(1);
+    f4.setValue(2);
+
+    f1.setGenerated(true);
+    f2.setGenerated(true);
+    f3.setGenerated(true);
+    f4.setGenerated(true);
+
+    rec.append(f1);
+    rec.append(f2);
+    rec.append(f3);
+    rec.append(f4);
+
+    QVERIFY_SQL(model, insertRecord(-1, rec));
+
+    QCOMPARE(model.data(model.index(4, 0)).toInt(), 7);
+    QCOMPARE(model.data(model.index(4, 1)).toString(), QString("test"));
+    QCOMPARE(model.data(model.index(4, 2)).toString(), QString("herr"));
+
+    // In LeftJoin mode, two additional rows are fetched
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(6, 0)).toInt(), 7);
+    QCOMPARE(model.data(model.index(6, 1)).toString(), QString("test"));
+    QCOMPARE(model.data(model.index(6, 2)).toString(), QString("herr"));
+}
+
+void tst_QSqlRelationalTableModel::setRecord()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    recreateTestTables(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QSqlRecord rec;
+    QSqlField f1("id", QVariant::Int);
+    QSqlField f2("name", QVariant::String);
+    QSqlField f3("title_key", QVariant::Int);
+    QSqlField f4("another_title_key", QVariant::Int);
+
+    f1.setValue(7);
+    f2.setValue("tester");
+    f3.setValue(1);
+    f4.setValue(2);
+
+    f1.setGenerated(true);
+    f2.setGenerated(true);
+    f3.setGenerated(true);
+    f4.setGenerated(true);
+
+    rec.append(f1);
+    rec.append(f2);
+    rec.append(f3);
+    rec.append(f4);
+
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 2)).toString(), QString("mister"));
+
+    QVERIFY_SQL(model, setRecord(1, rec));
+
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 7);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("tester"));
+    QCOMPARE(model.data(model.index(1, 2)).toString(), QString("herr"));
+
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, submit());
+
+    QCOMPARE(model.data(model.index(3, 0)).toInt(), 7);
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("tester"));
+    QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+
+}
+
+void tst_QSqlRelationalTableModel::insertWithStrategies()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    model.setSort(0, Qt::AscendingOrder);
+
+    if (!db.driverName().startsWith("QTDS"))
+        model.setRelation(3, QSqlRelation(reltest2, "tid", "title"));
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0,0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0,1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0,2)).toString(), QString("herr"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(0,3)).toString(), QString("mister"));
+    else
+        QCOMPARE(model.data(model.index(0,3)).toInt(), 2);
+
+    model.insertRows(0, 1);
+    model.setData(model.index(0, 0), 1011);
+    model.setData(model.index(0, 1), "test");
+    model.setData(model.index(0, 2), 2);
+    model.setData(model.index(0, 3), 1);
+
+    QCOMPARE(model.data(model.index(0,0)).toInt(), 1011);
+    QCOMPARE(model.data(model.index(0,1)).toString(), QString("test"));
+    QCOMPARE(model.data(model.index(0,2)).toString(), QString("mister"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(0,3)).toString(), QString("herr"));
+    else
+        QCOMPARE(model.data(model.index(0,3)).toInt(), 1);
+
+    QCOMPARE(model.data(model.index(1,0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(1,1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1,2)).toString(), QString("herr"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(1,3)).toString(), QString("mister"));
+    else
+        QCOMPARE(model.data(model.index(1,3)).toInt(), 2);
+
+
+
+    QVERIFY_SQL(model, submitAll());
+
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+
+    QCOMPARE(model.data(model.index(0,0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0,1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0,2)).toString(), QString("herr"));
+
+    if (!db.driverName().startsWith("QTDS")) {
+        QCOMPARE(model.data(model.index(0,3)).toString(), QString("mister"));
+        model.setData(model.index(0,3),1);
+        QCOMPARE(model.data(model.index(0,3)).toString(), QString("herr"));
+    } else {
+        QCOMPARE(model.data(model.index(0,3)).toInt(), 2);
+        model.setData(model.index(0,3),1);
+        QCOMPARE(model.data(model.index(0,3)).toInt(), 1);
+    }
+
+    model.insertRows(0, 2);
+    model.setData(model.index(0, 0), 1012);
+    model.setData(model.index(0, 1), "george");
+    model.setData(model.index(0, 2), 2);
+    model.setData(model.index(0, 3), 2);
+
+    model.setData(model.index(1, 0), 1013);
+    model.setData(model.index(1, 1), "kramer");
+    model.setData(model.index(1, 2), 2);
+    model.setData(model.index(1, 3), 1);
+
+    QCOMPARE(model.data(model.index(0,0)).toInt(),1012);
+    QCOMPARE(model.data(model.index(0,1)).toString(), QString("george"));
+    QCOMPARE(model.data(model.index(0,2)).toString(), QString("mister"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(0,3)).toString(), QString("mister"));
+    else
+        QCOMPARE(model.data(model.index(0,3)).toInt(), 2);
+
+
+    QCOMPARE(model.data(model.index(1,0)).toInt(),1013);
+    QCOMPARE(model.data(model.index(1,1)).toString(), QString("kramer"));
+    QCOMPARE(model.data(model.index(1,2)).toString(), QString("mister"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(1,3)).toString(), QString("herr"));
+    else
+        QCOMPARE(model.data(model.index(1,3)).toInt(), 1);
+
+    QCOMPARE(model.data(model.index(2,0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(2,1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(2,2)).toString(), QString("herr"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(2,3)).toString(), QString("herr"));
+    else
+        QCOMPARE(model.data(model.index(2,3)).toInt(), 1);
+
+    QVERIFY_SQL(model, submitAll());
+}
+
+void tst_QSqlRelationalTableModel::removeColumn()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    recreateTestTables(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    QVERIFY_SQL(model, select());
+
+    QVERIFY_SQL(model, removeColumn(3));
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.columnCount(), 3);
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+    QCOMPARE(model.data(model.index(0, 3)), QVariant());
+
+    // try removing more than one column
+    QVERIFY_SQL(model, removeColumns(1, 2));
+    QCOMPARE(model.columnCount(), 1);
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)), QVariant());
+
+    // try in LeftJoin mode the same tests
+    CHECK_DATABASE(db);
+    recreateTestTables(db);
+
+    QSqlRelationalTableModel lmodel(0, db);
+
+    lmodel.setTable(reltest1);
+    lmodel.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    lmodel.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(lmodel, select());
+
+    QVERIFY_SQL(lmodel, removeColumn(3));
+    QVERIFY_SQL(lmodel, select());
+
+    QCOMPARE(lmodel.columnCount(), 3);
+
+    QCOMPARE(lmodel.data(lmodel.index(0, 0)).toInt(), 1);
+    QCOMPARE(lmodel.data(lmodel.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(lmodel.data(lmodel.index(0, 2)).toString(), QString("herr"));
+    QCOMPARE(lmodel.data(lmodel.index(0, 3)), QVariant());
+
+    // try removing more than one column
+    QVERIFY_SQL(lmodel, removeColumns(1, 2));
+    QCOMPARE(lmodel.columnCount(), 1);
+    QCOMPARE(lmodel.data(lmodel.index(0, 0)).toInt(), 1);
+    QCOMPARE(lmodel.data(lmodel.index(0, 1)), QVariant());
+}
+
+void tst_QSqlRelationalTableModel::filter()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    recreateTestTables(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    model.setFilter("title = 'herr'");
+
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 2);
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+    QCOMPARE(model.data(model.index(1, 2)).toString(), QString("herr"));
+
+    // Redo same filter test in LeftJoin mode
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model,select());
+
+    QCOMPARE(model.rowCount(), 2);
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+    QCOMPARE(model.data(model.index(1, 2)).toString(), QString("herr"));
+}
+
+void tst_QSqlRelationalTableModel::sort()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    if (!db.driverName().startsWith("QTDS"))
+        model.setRelation(3, QSqlRelation(reltest2, "tid", "title"));
+
+    model.setSort(2, Qt::DescendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.rowCount(), 4);
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+    QCOMPARE(model.data(model.index(1, 2)).toString(), QString("mister"));
+    QCOMPARE(model.data(model.index(2, 2)).toString(), QString("herr"));
+    QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+
+
+    model.setSort(3, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    if (!db.driverName().startsWith("QTDS")) {
+        QCOMPARE(model.rowCount(), 4);
+        QCOMPARE(model.data(model.index(0, 3)).toString(), QString("herr"));
+        QCOMPARE(model.data(model.index(1, 3)).toString(), QString("mister"));
+        QCOMPARE(model.data(model.index(2, 3)).toString(), QString("mister"));
+        QCOMPARE(model.data(model.index(3, 3)).toString(), QString("mister"));
+    } else {
+        QCOMPARE(model.data(model.index(0, 3)).toInt(), 1);
+        QCOMPARE(model.data(model.index(1, 3)).toInt(), 2);
+        QCOMPARE(model.data(model.index(2, 3)).toInt(), 2);
+        QCOMPARE(model.data(model.index(3, 3)).toInt(), 2);
+    }
+
+    // redo same test in LeftJoin mode
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    model.setSort(2, Qt::DescendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.rowCount(), 6);
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+    QCOMPARE(model.data(model.index(1, 2)).toString(), QString("mister"));
+    QCOMPARE(model.data(model.index(2, 2)).toString(), QString("herr"));
+    QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+    QCOMPARE(model.data(model.index(4, 2)).toString(), QString(""));
+    QCOMPARE(model.data(model.index(5, 2)).toString(), QString(""));
+
+    model.setSort(3, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    if (!db.driverName().startsWith("QTDS")) {
+        QCOMPARE(model.rowCount(), 6);
+        QCOMPARE(model.data(model.index(0, 3)).toString(), QString(""));
+        QCOMPARE(model.data(model.index(1, 3)).toString(), QString("herr"));
+        QCOMPARE(model.data(model.index(2, 3)).toString(), QString("mister"));
+        QCOMPARE(model.data(model.index(3, 3)).toString(), QString("mister"));
+        QCOMPARE(model.data(model.index(4, 3)).toString(), QString("mister"));
+        QCOMPARE(model.data(model.index(5, 3)).toString(), QString("mister"));
+    } else {
+        QCOMPARE(model.data(model.index(0, 3)).toInt(), 1);
+        QCOMPARE(model.data(model.index(1, 3)).toInt(), 2);
+        QCOMPARE(model.data(model.index(2, 3)).toInt(), 2);
+        QCOMPARE(model.data(model.index(3, 3)).toInt(), 2);
+    }
+}
+
+static void testRevert(QSqlRelationalTableModel &model)
+{
+    /* revert single row */
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+    QVERIFY(model.setData(model.index(0, 2), 2, Qt::EditRole));
+
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+    model.revertRow(0);
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    /* revert all */
+    QVERIFY(model.setData(model.index(0, 2), 2, Qt::EditRole));
+
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+    model.revertAll();
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    // the following only works for OnManualSubmit
+    if (model.editStrategy() != QSqlTableModel::OnManualSubmit)
+        return;
+
+    /* revert inserted rows */
+    int initialRowCount = model.rowCount();
+    QVERIFY(model.insertRows(4, 4));
+    QVERIFY(model.rowCount() == (initialRowCount + 4));
+
+    /* make sure the new rows are initialized to nothing */
+    QVERIFY(model.data(model.index(4, 2)).toString().isEmpty());
+    QVERIFY(model.data(model.index(5, 2)).toString().isEmpty());
+    QVERIFY(model.data(model.index(6, 2)).toString().isEmpty());
+    QVERIFY(model.data(model.index(7, 2)).toString().isEmpty());
+
+    /* Set some values */
+    QVERIFY(model.setData(model.index(4, 0), 42, Qt::EditRole));
+    QVERIFY(model.setData(model.index(5, 0), 43, Qt::EditRole));
+    QVERIFY(model.setData(model.index(6, 0), 44, Qt::EditRole));
+    QVERIFY(model.setData(model.index(7, 0), 45, Qt::EditRole));
+
+    QVERIFY(model.setData(model.index(4, 2), 2, Qt::EditRole));
+    QVERIFY(model.setData(model.index(5, 2), 2, Qt::EditRole));
+    QVERIFY(model.setData(model.index(6, 2), 1, Qt::EditRole));
+    QVERIFY(model.setData(model.index(7, 2), 2, Qt::EditRole));
+
+    /* Now revert the newly inserted rows */
+    model.revertAll();
+    QVERIFY(model.rowCount() == initialRowCount);
+
+    /* Insert rows again */
+    QVERIFY(model.insertRows(4, 4));
+
+    /* make sure the new rows are initialized to nothing */
+    QVERIFY(model.data(model.index(4, 2)).toString().isEmpty());
+    QVERIFY(model.data(model.index(5, 2)).toString().isEmpty());
+    QVERIFY(model.data(model.index(6, 2)).toString().isEmpty());
+    QVERIFY(model.data(model.index(7, 2)).toString().isEmpty());
+}
+
+void tst_QSqlRelationalTableModel::revert()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    model.setRelation(3, QSqlRelation(reltest4, "id", "name"));
+
+    model.setSort(0, Qt::AscendingOrder);
+
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.data(model.index(0, 0)).toString(), QString("1"));
+
+    testRevert(model);
+    if (QTest::currentTestFailed())
+        return;
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+    testRevert(model);
+
+    /* and again with OnManualSubmit */
+    model.setJoinMode(QSqlRelationalTableModel::InnerJoin);
+    QVERIFY_SQL(model, select());
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    testRevert(model);
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    testRevert(model);
+}
+
+void tst_QSqlRelationalTableModel::clearDisplayValuesCache()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+
+    if (!db.driverName().startsWith("QTDS"))
+        model.setRelation(3, QSqlRelation(reltest2, "tid", "title"));
+    model.setSort(1, Qt::AscendingOrder);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(3, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(3, 3)).toString(), QString("mister"));
+    else
+        QCOMPARE(model.data(model.index(3, 3)).toInt(), 2 );
+
+    model.insertRow(model.rowCount());
+    QVERIFY(model.setData(model.index(4, 0), 7, Qt::EditRole));
+    QVERIFY(model.setData(model.index(4, 1), "anders", Qt::EditRole));
+    QVERIFY(model.setData(model.index(4, 2), 1, Qt::EditRole));
+    QVERIFY(model.setData(model.index(4, 3), 1, Qt::EditRole));
+    model.submitAll();
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 7);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("anders"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(0, 3)).toString(), QString("herr"));
+    else
+        QCOMPARE(model.data(model.index(0, 3)).toInt(), 1);
+
+    QCOMPARE(model.data(model.index(4, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(4, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(4, 2)).toString(), QString("herr"));
+    if (!db.driverName().startsWith("QTDS"))
+        QCOMPARE(model.data(model.index(4, 3)).toString(), QString("mister"));
+    else
+        QCOMPARE(model.data(model.index(4, 3)).toInt(), 2);
+}
+
+// For task 140782 and 176374: If the main table and the the related tables uses the same
+// name for a column or display column then insertRecord() would return true though it
+// actually failed.
+void tst_QSqlRelationalTableModel::insertRecordDuplicateFieldNames()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+    model.setTable(reltest3);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    model.setSort(0, Qt::AscendingOrder);
+
+    // Duplication of "name", used in both reltest3 and reltest4.
+    model.setRelation(2, QSqlRelation(reltest4, "id", "name"));
+    QVERIFY_SQL(model, select());
+
+    if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2")) {
+        QCOMPARE(model.record(1).value((reltest4+QLatin1String("_name_2")).toUpper()).toString(),
+            QString("Trondheim"));
+    } else {
+        QCOMPARE(model.record(1).value((reltest4+QLatin1String("_name_2"))).toString(),
+            QString("Trondheim"));
+    }
+
+    QSqlRecord rec = model.record();
+    rec.setValue(0, 3);
+    rec.setValue(1, "Berge");
+    rec.setValue(2, 1); // Must insert the key value
+
+    if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2")) {
+        QCOMPARE(rec.fieldName(0), QLatin1String("ID"));
+        QCOMPARE(rec.fieldName(1), QLatin1String("NAME")); // This comes from main table
+    } else {
+        QCOMPARE(rec.fieldName(0), QLatin1String("id"));
+        QCOMPARE(rec.fieldName(1), QLatin1String("name"));
+    }
+
+    // The duplicate field names is aliased because it's comes from the relation's display column.
+    if(db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2"))
+        QCOMPARE(rec.fieldName(2), (reltest4+QLatin1String("_name_2")).toUpper());
+    else
+        QCOMPARE(rec.fieldName(2), reltest4+QLatin1String("_name_2"));
+
+    QVERIFY(model.insertRecord(-1, rec));
+    QCOMPARE(model.data(model.index(2, 2)).toString(), QString("Oslo"));
+    QVERIFY(model.submitAll());
+    QCOMPARE(model.data(model.index(2, 2)).toString(), QString("Oslo"));
+}
+
+void tst_QSqlRelationalTableModel::invalidData()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    QVERIFY_SQL(model, select());
+
+    //try set a non-existent relational key
+    QVERIFY(model.setData(model.index(0, 2), 3) == false);
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    //try to set data in non valid index
+    QVERIFY(model.setData(model.index(0,10),5) == false);
+
+    //same test with LeftJoin mode
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    //try set a non-existent relational key
+    QVERIFY(model.setData(model.index(0, 2), 3) == false);
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    //try to set data in non valid index
+    QVERIFY(model.setData(model.index(0,10),5) == false);
+}
+
+void tst_QSqlRelationalTableModel::relationModel()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    QVERIFY_SQL(model, select());
+
+    QVERIFY(model.relationModel(0) == NULL);
+    QVERIFY(model.relationModel(1) == NULL);
+    QVERIFY(model.relationModel(2) != NULL);
+    QVERIFY(model.relationModel(3) == NULL);
+    QVERIFY(model.relationModel(4) == NULL);
+
+    model.setRelation(3, QSqlRelation(reltest4, "id", "name"));
+    QVERIFY_SQL(model, select());
+
+    QVERIFY(model.relationModel(0) == NULL);
+    QVERIFY(model.relationModel(1) == NULL);
+    QVERIFY(model.relationModel(2) != NULL);
+    QVERIFY(model.relationModel(3) != NULL);
+    QVERIFY(model.relationModel(4) == NULL);
+
+    QSqlTableModel *rel_model = model.relationModel(2);
+    QCOMPARE(rel_model->data(rel_model->index(0,1)).toString(), QString("herr"));
+
+    //same test in JoinMode
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QVERIFY(model.relationModel(0) == NULL);
+    QVERIFY(model.relationModel(1) == NULL);
+    QVERIFY(model.relationModel(2) != NULL);
+    QVERIFY(model.relationModel(3) != NULL);
+    QVERIFY(model.relationModel(4) == NULL);
+
+    QSqlTableModel *rel_model2 = model.relationModel(2);
+    QCOMPARE(rel_model2->data(rel_model->index(0,1)).toString(), QString("herr"));
+}
+
+void tst_QSqlRelationalTableModel::casing()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (db.driverName().startsWith("QSQLITE") || db.driverName().startsWith("QIBASE") || tst_Databases::isSqlServer(db))
+        QSKIP("The casing test for this database is irrelevant since this database does not treat different cases as separate entities", SkipAll);
+
+    QSqlQuery q(db);
+    QVERIFY_SQL( q, exec("create table " + qTableName("CASETEST1", db.driver()).toUpper()  +
+                " (id int not null primary key, name varchar(20), title_key int, another_title_key int)"));
+
+    if( !q.exec("create table " + qTableName("casetest1", db.driver())  +
+                " (ident int not null primary key, name varchar(20), title_key int)"))
+        QSKIP("The casing test for this database is irrelevant since this database does not treat different cases as separate entities", SkipAll);
+
+    QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db.driver()).toUpper() + " values(1, 'harry', 1, 2)"));
+    QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db.driver()).toUpper() + " values(2, 'trond', 2, 1)"));
+    QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db.driver()).toUpper() + " values(3, 'vohi', 1, 2)"));
+    QVERIFY_SQL( q, exec("insert into " + qTableName("CASETEST1", db.driver()).toUpper() + " values(4, 'boris', 2, 2)"));
+    QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db.driver()) + " values(1, 'jerry', 1)"));
+    QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db.driver()) + " values(2, 'george', 2)"));
+    QVERIFY_SQL( q, exec("insert into " + qTableName("casetest1", db.driver()) + " values(4, 'kramer', 2)"));
+
+    if (db.driverName().startsWith("QOCI")) {
+        //try an owner that doesn't exist
+        QSqlRecord rec = db.driver()->record("doug." + qTableName("CASETEST1", db.driver()).toUpper());
+        QCOMPARE( rec.count(), 0);
+
+        //try an owner that does exist
+        rec = db.driver()->record(db.userName() + "." +  qTableName("CASETEST1", db.driver()).toUpper());
+        QCOMPARE( rec.count(), 4);
+    }
+    QSqlRecord rec = db.driver()->record(qTableName("CASETEST1", db.driver()).toUpper());
+    QCOMPARE( rec.count(), 4);
+
+    rec = db.driver()->record(qTableName("casetest1", db.driver()));
+    QCOMPARE( rec.count(), 3);
+
+    QSqlTableModel upperCaseModel(0, db);
+    upperCaseModel.setTable(qTableName("CASETEST1", db.driver()).toUpper());
+
+    QCOMPARE(upperCaseModel.tableName(),qTableName("CASETEST1",db.driver()).toUpper());
+
+    QVERIFY_SQL(upperCaseModel, select());
+
+    QCOMPARE(upperCaseModel.rowCount(), 4);
+
+    QSqlTableModel lowerCaseModel(0, db);
+    lowerCaseModel.setTable(qTableName("casetest1", db.driver()));
+    QCOMPARE(lowerCaseModel.tableName(), qTableName("casetest1",db.driver()));
+    QVERIFY_SQL(lowerCaseModel, select());
+
+    QCOMPARE(lowerCaseModel.rowCount(), 3);
+
+    QSqlRelationalTableModel model(0, db);
+    model.setTable(qTableName("CASETEST1", db.driver()).toUpper());
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+}
+
+void tst_QSqlRelationalTableModel::escapedRelations()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    recreateTestTables(db);
+
+    QSqlRelationalTableModel model(0, db);
+    model.setTable(reltest1);
+
+    //try with relation table name quoted
+    if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2")) {
+        model.setRelation(2, QSqlRelation(db.driver()->escapeIdentifier(reltest2.toUpper(),QSqlDriver::TableName),
+                            "tid",
+                            "title"));
+    } else {
+        model.setRelation(2, QSqlRelation(db.driver()->escapeIdentifier(reltest2,QSqlDriver::TableName),
+                            "tid",
+                            "title"));
+
+    }
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    //try with index column quoted
+    model.setJoinMode(QSqlRelationalTableModel::InnerJoin);
+    if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2")) {
+        model.setRelation(2, QSqlRelation(reltest2,
+                            db.driver()->escapeIdentifier("tid", QSqlDriver::FieldName).toUpper(),
+                            "title"));
+    } else {
+        model.setRelation(2, QSqlRelation(reltest2,
+                            db.driver()->escapeIdentifier("tid", QSqlDriver::FieldName),
+                            "title"));
+    }
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    //try with display column quoted
+    model.setJoinMode(QSqlRelationalTableModel::InnerJoin);
+    if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2")) {
+
+        model.setRelation(2, QSqlRelation(reltest2,
+                            "tid",
+                            db.driver()->escapeIdentifier("title", QSqlDriver::FieldName).toUpper()));
+    } else {
+        model.setRelation(2, QSqlRelation(reltest2,
+                            "tid",
+                            db.driver()->escapeIdentifier("title", QSqlDriver::FieldName)));
+    }
+
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    //try with tablename and index and display columns quoted in the relation
+    model.setJoinMode(QSqlRelationalTableModel::InnerJoin);
+    if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2")) {
+        model.setRelation(2, QSqlRelation(reltest2,
+                            "tid",
+                            db.driver()->escapeIdentifier("title", QSqlDriver::FieldName).toUpper()));
+    } else {
+        model.setRelation(2, QSqlRelation(reltest2,
+                            "tid",
+                            db.driver()->escapeIdentifier("title", QSqlDriver::FieldName)));
+    }
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toString(), QString("herr"));
+}
+
+void tst_QSqlRelationalTableModel::escapedTableName()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    // set the values using OnRowChange Strategy with an escaped tablename
+    {
+        QSqlRelationalTableModel model(0, db);
+
+        if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2")) {
+            model.setTable(db.driver()->escapeIdentifier(reltest1.toUpper(), QSqlDriver::TableName));
+        } else {
+            model.setTable(db.driver()->escapeIdentifier(reltest1, QSqlDriver::TableName));
+        }
+        model.setSort(0, Qt::AscendingOrder);
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        QVERIFY_SQL(model, select());
+
+        QVERIFY(model.setData(model.index(0, 1), QString("harry2")));
+        QVERIFY(model.setData(model.index(0, 2), 2));
+
+        QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));
+        QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+
+        model.submit();
+
+        QVERIFY(model.setData(model.index(3,1), QString("boris2")));
+        QVERIFY(model.setData(model.index(3, 2), 1));
+
+        QCOMPARE(model.data(model.index(3,1)).toString(), QString("boris2"));
+        QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+
+        model.submit();
+    }
+    { //verify values
+        QSqlRelationalTableModel model(0, db);
+        model.setTable(reltest1);
+        model.setSort(0, Qt::AscendingOrder);
+        QVERIFY_SQL(model, select());
+
+        QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));
+        QCOMPARE(model.data(model.index(0, 2)).toInt(), 2);
+        QCOMPARE(model.data(model.index(3, 1)).toString(), QString("boris2"));
+        QCOMPARE(model.data(model.index(3, 2)).toInt(), 1);
+
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        QVERIFY_SQL(model, select());
+        QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+        QCOMPARE(model.data(model.index(3,2)).toString(), QString("herr"));
+
+    }
+
+    //ok, now do same test with LeftJoin
+    {
+        QSqlRelationalTableModel model(0, db);
+
+        if (db.driverName().startsWith("QIBASE") || db.driverName().startsWith("QOCI") || db.driverName().startsWith("QDB2")) {
+            model.setTable(db.driver()->escapeIdentifier(reltest1.toUpper(), QSqlDriver::TableName));
+        } else {
+            model.setTable(db.driver()->escapeIdentifier(reltest1, QSqlDriver::TableName));
+        }
+        model.setSort(0, Qt::AscendingOrder);
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+        QVERIFY_SQL(model, select());
+
+        QVERIFY(model.setData(model.index(0, 1), QString("harry2")));
+        QVERIFY(model.setData(model.index(0, 2), 2));
+
+        QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));
+        QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+
+        model.submit();
+
+        QVERIFY(model.setData(model.index(3,1), QString("boris2")));
+        QVERIFY(model.setData(model.index(3, 2), 1));
+
+        QCOMPARE(model.data(model.index(3,1)).toString(), QString("boris2"));
+        QCOMPARE(model.data(model.index(3, 2)).toString(), QString("herr"));
+
+        model.submit();
+    }
+    { //verify values
+        QSqlRelationalTableModel model(0, db);
+        model.setTable(reltest1);
+        model.setSort(0, Qt::AscendingOrder);
+        model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+        QVERIFY_SQL(model, select());
+
+        QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));
+        QCOMPARE(model.data(model.index(0, 2)).toInt(), 2);
+        QCOMPARE(model.data(model.index(3, 1)).toString(), QString("boris2"));
+        QCOMPARE(model.data(model.index(3, 2)).toInt(), 1);
+
+        model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+        QVERIFY_SQL(model, select());
+        QCOMPARE(model.data(model.index(0, 2)).toString(), QString("mister"));
+        QCOMPARE(model.data(model.index(3,2)).toString(), QString("herr"));
+
+    }
+}
+
+void tst_QSqlRelationalTableModel::whiteSpaceInIdentifiers()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (!testWhiteSpaceNames(db.driverName()))
+        QSKIP("White space test irrelevant for driver", SkipAll);
+    QSqlRelationalTableModel model(0, db);
+    model.setTable(db.driver()->escapeIdentifier(qTableName("rel", __FILE__)+" test6", QSqlDriver::TableName));
+    model.setSort(0, Qt::DescendingOrder);
+    model.setRelation(1, QSqlRelation(db.driver()->escapeIdentifier(qTableName("rel", __FILE__)+" test7", QSqlDriver::TableName),
+                        db.driver()->escapeIdentifier("city id", QSqlDriver::FieldName),
+                        db.driver()->escapeIdentifier("city name", QSqlDriver::FieldName)));
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0,1)).toString(), QString("Washington"));
+    QCOMPARE(model.data(model.index(1,1)).toString(), QString("New York"));
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0,1)).toString(), QString("Washington"));
+    QCOMPARE(model.data(model.index(1,1)).toString(), QString("New York"));
+
+    model.setJoinMode(QSqlRelationalTableModel::InnerJoin);
+    QVERIFY_SQL(model, select());
+
+    QSqlRecord rec;
+    QSqlField f1("id", QVariant::Int);
+    QSqlField f2(db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName), QVariant::Int);
+    QSqlField f3(db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName), QVariant::Int);
+
+    f1.setValue(3);
+    f2.setValue(2);
+    f3.setValue(7);
+
+    f1.setGenerated(true);
+    f2.setGenerated(true);
+    f3.setGenerated(true);
+
+    rec.append(f1);
+    rec.append(f2);
+    rec.append(f3);
+
+    QVERIFY_SQL(model, insertRecord(-1, rec));
+    model.submitAll();
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("Washington"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 7);
+
+    //TODO: For some reson setting a record using manual submit fails
+    //model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+
+    QSqlRecord recNew;
+    QSqlField f1New("id", QVariant::Int);
+    QSqlField f2New(db.driver()->escapeIdentifier("city key", QSqlDriver::FieldName), QVariant::Int);
+    QSqlField f3New(db.driver()->escapeIdentifier("extra field", QSqlDriver::FieldName), QVariant::Int);
+
+    f1New.setValue(4);
+    f2New.setValue(1);
+    f3New.setValue(6);
+
+    f1New.setGenerated(true);
+    f2New.setGenerated(true);
+    f3New.setGenerated(true);
+
+    recNew.append(f1New);
+    recNew.append(f2New);
+    recNew.append(f3New);
+
+    QVERIFY_SQL(model, setRecord(0, recNew));
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 4);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("New York"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 6);
+
+    QVERIFY_SQL(model, submitAll());
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 4);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("New York"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 6);
+}
+
+void tst_QSqlRelationalTableModel::psqlSchemaTest()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if(!tst_Databases::isPostgreSQL(db)) {
+        QSKIP("Postgresql specific test", SkipSingle);
+        return;
+    }
+    QSqlRelationalTableModel model(0, db);
+    QSqlQuery q(db);
+    QVERIFY_SQL(q, exec("create schema "+qTableName("QTBUG_5373", __FILE__)));
+    QVERIFY_SQL(q, exec("create schema "+qTableName("QTBUG_5373_s2", __FILE__)));
+    QVERIFY_SQL(q, exec("create table "+qTableName("QTBUG_5373", __FILE__)+"."+qTableName("document", __FILE__)+"(document_id int primary key, relatingid int, userid int)"));
+    QVERIFY_SQL(q, exec("create table "+qTableName("QTBUG_5373_s2", __FILE__)+"."+qTableName("user", __FILE__)+"(userid int primary key, username char(40))"));
+    model.setTable(qTableName("QTBUG_5373", __FILE__)+"."+qTableName("document", __FILE__));
+    model.setRelation(1, QSqlRelation(qTableName("QTBUG_5373_s2", __FILE__)+"."+qTableName("user", __FILE__), "userid", "username"));
+    model.setRelation(2, QSqlRelation(qTableName("QTBUG_5373_s2", __FILE__)+"."+qTableName("user", __FILE__), "userid", "username"));
+    QVERIFY_SQL(model, select());
+
+    model.setJoinMode(QSqlRelationalTableModel::LeftJoin);
+    QVERIFY_SQL(model, select());
+}
+
+void tst_QSqlRelationalTableModel::selectAfterUpdate()
+{
+    QFETCH_GLOBAL(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlRelationalTableModel model(0, db);
+    model.setTable(reltest1);
+    model.setRelation(2, QSqlRelation(reltest2, "tid", "title"));
+    QVERIFY_SQL(model, select());
+    QVERIFY(model.relationModel(2)->rowCount() == 2);
+    {
+        QSqlQuery q(db);
+        QVERIFY_SQL(q, exec("insert into " + reltest2 + " values(3, 'mrs')"));
+        model.relationModel(2)->select();
+    }
+    QVERIFY(model.relationModel(2)->rowCount() == 3);
+    QVERIFY(model.setData(model.index(0,2), 3));
+    QVERIFY(model.submitAll());
+    QCOMPARE(model.data(model.index(0,2)), QVariant("mrs"));
+}
+
+QTEST_MAIN(tst_QSqlRelationalTableModel)
+#include "tst_qsqlrelationaltablemodel.moc"
diff --git a/tests/auto/sql/models/qsqltablemodel/.gitignore b/tests/auto/sql/models/qsqltablemodel/.gitignore
new file mode 100644
index 0000000000..460982f59c
--- /dev/null
+++ b/tests/auto/sql/models/qsqltablemodel/.gitignore
@@ -0,0 +1 @@
+tst_qsqltablemodel
diff --git a/tests/auto/sql/models/qsqltablemodel/qsqltablemodel.pro b/tests/auto/sql/models/qsqltablemodel/qsqltablemodel.pro
new file mode 100644
index 0000000000..e49020f0a6
--- /dev/null
+++ b/tests/auto/sql/models/qsqltablemodel/qsqltablemodel.pro
@@ -0,0 +1,22 @@
+load(qttest_p4)
+SOURCES  += tst_qsqltablemodel.cpp
+
+QT += sql
+
+wince*: {
+   plugFiles.files = ../../../plugins/sqldrivers
+   plugFiles.path    = .
+   DEPLOYMENT += plugFiles
+   LIBS += -lws2
+}else:symbian {
+    qt_not_deployed {
+        contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2)|contains(S60_VERSION, 5.0) {
+            sqlite.path = /sys/bin
+            sqlite.files = sqlite3.dll
+            DEPLOYMENT += sqlite
+        }
+    }
+}else {
+   win32:LIBS += -lws2_32
+}
+
diff --git a/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp b/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp
new file mode 100644
index 0000000000..07efd4a3a1
--- /dev/null
+++ b/tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp
@@ -0,0 +1,1377 @@
+/****************************************************************************
+**
+** 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 test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include "../../kernel/qsqldatabase/tst_databases.h"
+#include <QtSql>
+
+const QString test(qTableName("test", __FILE__)),
+                   test2(qTableName("test2", __FILE__)),
+                   test3(qTableName("test3", __FILE__));
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+Q_DECLARE_METATYPE(QModelIndex)
+
+class tst_QSqlTableModel : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QSqlTableModel();
+    virtual ~tst_QSqlTableModel();
+
+
+    void dropTestTables();
+    void createTestTables();
+    void recreateTestTables();
+    void repopulateTestTables();
+
+    tst_Databases dbs;
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+private slots:
+
+    void select_data() { generic_data(); }
+    void select();
+    void insertColumns_data() { generic_data_with_strategies(); }
+    void insertColumns();
+    void submitAll_data() { generic_data(); }
+    void submitAll();
+    void setRecord_data()  { generic_data(); }
+    void setRecord();
+    void insertRow_data() { generic_data_with_strategies(); }
+    void insertRow();
+    void insertRecord_data() { generic_data(); }
+    void insertRecord();
+    void insertMultiRecords_data() { generic_data(); }
+    void insertMultiRecords();
+    void removeRow_data() { generic_data(); }
+    void removeRow();
+    void removeRows_data() { generic_data(); }
+    void removeRows();
+    void removeInsertedRow_data() { generic_data_with_strategies(); }
+    void removeInsertedRow();
+    void removeInsertedRows_data() { generic_data(); }
+    void removeInsertedRows();
+    void setFilter_data() { generic_data(); }
+    void setFilter();
+    void setInvalidFilter_data() { generic_data(); }
+    void setInvalidFilter();
+
+    void emptyTable_data() { generic_data(); }
+    void emptyTable();
+    void tablesAndSchemas_data() { generic_data("QPSQL"); }
+    void tablesAndSchemas();
+    void whitespaceInIdentifiers_data() { generic_data(); }
+    void whitespaceInIdentifiers();
+    void primaryKeyOrder_data() { generic_data("QSQLITE"); }
+    void primaryKeyOrder();
+
+    void sqlite_bigTable_data() { generic_data("QSQLITE"); }
+    void sqlite_bigTable();
+
+    // bug specific tests
+    void insertRecordBeforeSelect_data() { generic_data(); }
+    void insertRecordBeforeSelect();
+    void submitAllOnInvalidTable_data() { generic_data(); }
+    void submitAllOnInvalidTable();
+    void insertRecordsInLoop_data() { generic_data(); }
+    void insertRecordsInLoop();
+    void sqlite_attachedDatabase_data() { generic_data("QSQLITE"); }
+    void sqlite_attachedDatabase(); // For task 130799
+    void tableModifyWithBlank_data() { generic_data(); }
+    void tableModifyWithBlank(); // For mail task
+
+    void removeColumnAndRow_data() { generic_data(); }
+    void removeColumnAndRow(); // task 256032
+
+    void insertBeforeDelete_data() { generic_data(); }
+    void insertBeforeDelete();
+private:
+    void generic_data(const QString& engine=QString());
+    void generic_data_with_strategies(const QString& engine=QString());
+};
+
+tst_QSqlTableModel::tst_QSqlTableModel()
+{
+    qRegisterMetaType<QModelIndex>("QModelIndex");
+    dbs.open();
+}
+
+tst_QSqlTableModel::~tst_QSqlTableModel()
+{
+}
+
+void tst_QSqlTableModel::dropTestTables()
+{
+    for (int i = 0; i < dbs.dbNames.count(); ++i) {
+        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
+        QSqlQuery q(db);
+        if(tst_Databases::isPostgreSQL(db))
+            QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+
+        QStringList tableNames;
+        tableNames << test
+                   << test2
+                   << test3
+                   << qTableName("test4", __FILE__)
+                   << qTableName("emptytable", __FILE__)
+                   << qTableName("bigtable", __FILE__)
+                   << qTableName("foo", __FILE__);
+        if (testWhiteSpaceNames(db.driverName()))
+            tableNames << qTableName("qtestw hitespace", db.driver());
+
+        tst_Databases::safeDropTables(db, tableNames);
+
+        if (db.driverName().startsWith("QPSQL")) {
+            q.exec("DROP SCHEMA " + qTableName("testschema", __FILE__) + " CASCADE");
+        }
+    }
+}
+
+void tst_QSqlTableModel::createTestTables()
+{
+    for (int i = 0; i < dbs.dbNames.count(); ++i) {
+        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
+        QSqlQuery q(db);
+
+        QVERIFY_SQL( q, exec("create table " + test + "(id int, name varchar(20), title int)"));
+
+        QVERIFY_SQL( q, exec("create table " + test2 + "(id int, title varchar(20))"));
+
+        QVERIFY_SQL( q, exec("create table " + test3 + "(id int, random varchar(20), randomtwo varchar(20))"));
+
+        if(!tst_Databases::isSqlServer(db))
+            QVERIFY_SQL( q, exec("create table " + qTableName("test4", __FILE__) + "(column1 varchar(50), column2 varchar(50), column3 varchar(50))"));
+        else
+            QVERIFY_SQL( q, exec("create table " + qTableName("test4", __FILE__) + "(column1 varchar(50), column2 varchar(50) NULL, column3 varchar(50))"));
+
+
+        QVERIFY_SQL( q, exec("create table " + qTableName("emptytable", __FILE__) + "(id int)"));
+
+        if (testWhiteSpaceNames(db.driverName())) {
+            QString qry = "create table " + qTableName("qtestw hitespace", db.driver()) + " ("+ db.driver()->escapeIdentifier("a field", QSqlDriver::FieldName) + " int)";
+            QVERIFY_SQL( q, exec(qry));
+        }
+    }
+}
+
+void tst_QSqlTableModel::repopulateTestTables()
+{
+    for (int i = 0; i < dbs.dbNames.count(); ++i) {
+        QSqlDatabase db = QSqlDatabase::database(dbs.dbNames.at(i));
+        QSqlQuery q(db);
+
+        q.exec("delete from " + test);
+        QVERIFY_SQL( q, exec("insert into " + test + " values(1, 'harry', 1)"));
+        QVERIFY_SQL( q, exec("insert into " + test + " values(2, 'trond', 2)"));
+        QVERIFY_SQL( q, exec("insert into " + test + " values(3, 'vohi', 3)"));
+
+        q.exec("delete from " + test2);
+        QVERIFY_SQL( q, exec("insert into " + test2 + " values(1, 'herr')"));
+        QVERIFY_SQL( q, exec("insert into " + test2 + " values(2, 'mister')"));
+
+        q.exec("delete from " + test3);
+        QVERIFY_SQL( q, exec("insert into " + test3 + " values(1, 'foo', 'bar')"));
+        QVERIFY_SQL( q, exec("insert into " + test3 + " values(2, 'baz', 'joe')"));
+    }
+}
+
+void tst_QSqlTableModel::recreateTestTables()
+{
+    dropTestTables();
+    createTestTables();
+    repopulateTestTables();
+}
+
+void tst_QSqlTableModel::generic_data(const QString &engine)
+{
+    if ( dbs.fillTestTable(engine) == 0 ) {
+        if (engine.isEmpty())
+           QSKIP( "No database drivers are available in this Qt configuration", SkipAll );
+        else
+           QSKIP( (QString("No database drivers of type %1 are available in this Qt configuration").arg(engine)).toLocal8Bit(), SkipAll );
+    }
+}
+
+void tst_QSqlTableModel::generic_data_with_strategies(const QString &engine)
+{
+    if ( dbs.fillTestTableWithStrategies(engine) == 0 ) {
+        if (engine.isEmpty())
+           QSKIP( "No database drivers are available in this Qt configuration", SkipAll );
+        else
+           QSKIP( (QString("No database drivers of type %1 are available in this Qt configuration").arg(engine)).toLocal8Bit(), SkipAll );
+    }
+}
+
+void tst_QSqlTableModel::initTestCase()
+{
+    recreateTestTables();
+}
+
+void tst_QSqlTableModel::cleanupTestCase()
+{
+    dropTestTables();
+    dbs.close();
+}
+
+void tst_QSqlTableModel::init()
+{
+}
+
+void tst_QSqlTableModel::cleanup()
+{
+    repopulateTestTables();
+}
+
+void tst_QSqlTableModel::select()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.rowCount(), 3);
+    QCOMPARE(model.columnCount(), 3);
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 3)), QVariant());
+
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 2)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 3)), QVariant());
+
+    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(2, 2)).toInt(), 3);
+    QCOMPARE(model.data(model.index(2, 3)), QVariant());
+
+    QCOMPARE(model.data(model.index(3, 0)), QVariant());
+    QCOMPARE(model.data(model.index(3, 1)), QVariant());
+    QCOMPARE(model.data(model.index(3, 2)), QVariant());
+    QCOMPARE(model.data(model.index(3, 3)), QVariant());
+}
+
+void tst_QSqlTableModel::insertColumns()
+{
+    // Just like the select test, with extra stuff
+    QFETCH(QString, dbName);
+    QFETCH(int, submitpolicy_i);
+    QSqlTableModel::EditStrategy submitpolicy = (QSqlTableModel::EditStrategy) submitpolicy_i;
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    model.setEditStrategy(submitpolicy);
+
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.rowCount(), 3);
+    QCOMPARE(model.columnCount(), 3);
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 3)), QVariant());
+
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 2)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 3)), QVariant());
+
+    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(2, 2)).toInt(), 3);
+    QCOMPARE(model.data(model.index(2, 3)), QVariant());
+
+    QCOMPARE(model.data(model.index(3, 0)), QVariant());
+    QCOMPARE(model.data(model.index(3, 1)), QVariant());
+    QCOMPARE(model.data(model.index(3, 2)), QVariant());
+    QCOMPARE(model.data(model.index(3, 3)), QVariant());
+
+    // Now add a column at 0 and 2
+    model.insertColumn(0);
+    model.insertColumn(2);
+
+    QCOMPARE(model.rowCount(), 3);
+    QCOMPARE(model.columnCount(), 5);
+
+    QCOMPARE(model.data(model.index(0, 0)), QVariant());
+    QCOMPARE(model.data(model.index(0, 1)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 2)), QVariant());
+    QCOMPARE(model.data(model.index(0, 3)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 4)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 5)), QVariant());
+
+    QCOMPARE(model.data(model.index(1, 0)), QVariant());
+    QCOMPARE(model.data(model.index(1, 1)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 2)), QVariant());
+    QCOMPARE(model.data(model.index(1, 3)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 4)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 5)), QVariant());
+
+    QCOMPARE(model.data(model.index(2, 0)), QVariant());
+    QCOMPARE(model.data(model.index(2, 1)).toInt(), 3);
+    QCOMPARE(model.data(model.index(2, 2)), QVariant());
+    QCOMPARE(model.data(model.index(2, 3)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(2, 4)).toInt(), 3);
+    QCOMPARE(model.data(model.index(2, 5)), QVariant());
+
+    QCOMPARE(model.data(model.index(3, 0)), QVariant());
+    QCOMPARE(model.data(model.index(3, 1)), QVariant());
+    QCOMPARE(model.data(model.index(3, 2)), QVariant());
+    QCOMPARE(model.data(model.index(3, 3)), QVariant());
+    QCOMPARE(model.data(model.index(3, 4)), QVariant());
+    QCOMPARE(model.data(model.index(3, 5)), QVariant());
+}
+
+void tst_QSqlTableModel::setRecord()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QList<QSqlTableModel::EditStrategy> policies = QList<QSqlTableModel::EditStrategy>() << QSqlTableModel::OnFieldChange << QSqlTableModel::OnRowChange << QSqlTableModel::OnManualSubmit;
+
+    QString Xsuffix;
+    foreach( QSqlTableModel::EditStrategy submitpolicy, policies) {
+
+        QSqlTableModel model(0, db);
+        model.setEditStrategy((QSqlTableModel::EditStrategy)submitpolicy);
+        model.setTable(test3);
+        model.setSort(0, Qt::AscendingOrder);
+        QVERIFY_SQL(model, select());
+
+        for (int i = 0; i < model.rowCount(); ++i) {
+            QSignalSpy spy(&model, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
+
+            QSqlRecord rec = model.record(i);
+            rec.setValue(1, rec.value(1).toString() + 'X');
+            rec.setValue(2, rec.value(2).toString() + 'X');
+            QVERIFY(model.setRecord(i, rec));
+
+            if ((QSqlTableModel::EditStrategy)submitpolicy == QSqlTableModel::OnManualSubmit) {
+                // setRecord should emit dataChanged() itself for manualSubmit
+                QCOMPARE(spy.count(), 1);
+                QCOMPARE(spy.at(0).count(), 2);
+                QCOMPARE(qvariant_cast<QModelIndex>(spy.at(0).at(0)), model.index(i, 0));
+                QCOMPARE(qvariant_cast<QModelIndex>(spy.at(0).at(1)), model.index(i, rec.count() - 1));
+                QVERIFY(model.submitAll());
+            } else if ((QSqlTableModel::EditStrategy)submitpolicy == QSqlTableModel::OnRowChange && i == model.rowCount() -1)
+                model.submit();
+            else {
+                // dataChanged() is not emitted when submitAll() is called
+                QCOMPARE(spy.count(), 2);
+                QCOMPARE(spy.at(0).count(), 2);
+                QCOMPARE(qvariant_cast<QModelIndex>(spy.at(0).at(0)), model.index(i, 1));
+                QCOMPARE(qvariant_cast<QModelIndex>(spy.at(0).at(1)), model.index(i, 1));
+            }
+        }
+
+        Xsuffix.append('X');
+
+        QCOMPARE(model.data(model.index(0, 1)).toString(), QString("foo").append(Xsuffix));
+        QCOMPARE(model.data(model.index(0, 2)).toString(), QString("bar").append(Xsuffix));
+        QCOMPARE(model.data(model.index(1, 1)).toString(), QString("baz").append(Xsuffix));
+        QCOMPARE(model.data(model.index(1, 2)).toString(), QString("joe").append(Xsuffix));
+    }
+}
+
+void tst_QSqlTableModel::insertRow()
+{
+    QFETCH(QString, dbName);
+    QFETCH(int, submitpolicy_i);
+    QSqlTableModel::EditStrategy submitpolicy = (QSqlTableModel::EditStrategy) submitpolicy_i;
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setEditStrategy(submitpolicy);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 2)).toInt(), 2);
+    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(2, 2)).toInt(), 3);
+
+    QVERIFY(model.insertRow(2));
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 2)).toInt(), 2);
+    QCOMPARE(model.data(model.index(2, 0)).toInt(), 0);
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(2, 2)).toInt(), 0);
+    QCOMPARE(model.data(model.index(3, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(3, 2)).toInt(), 3);
+
+    QSqlRecord rec = model.record(1);
+    rec.setValue(0, 42);
+    rec.setValue(1, QString("francis"));
+
+    // FieldChange updates immediately and resorts
+    // Row/Manual submit does not resort
+    QVERIFY(model.setRecord(2, rec));
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 2)).toInt(), 2);
+
+    // See comment above setRecord
+    if (submitpolicy == QSqlTableModel::OnFieldChange) {
+        QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);
+        QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+        QCOMPARE(model.data(model.index(2, 2)).toInt(), 3);
+        QCOMPARE(model.data(model.index(3, 0)).toInt(), 42);
+        QCOMPARE(model.data(model.index(3, 1)).toString(), QString("francis"));
+        QCOMPARE(model.data(model.index(3, 2)).toInt(), 2);
+    } else {
+        QCOMPARE(model.data(model.index(2, 0)).toInt(), 42);
+        QCOMPARE(model.data(model.index(2, 1)).toString(), QString("francis"));
+        QCOMPARE(model.data(model.index(2, 2)).toInt(), 2);
+        QCOMPARE(model.data(model.index(3, 0)).toInt(), 3);
+        QCOMPARE(model.data(model.index(3, 1)).toString(), QString("vohi"));
+        QCOMPARE(model.data(model.index(3, 2)).toInt(), 3);
+    }
+
+    QVERIFY(model.submitAll());
+
+    // After the submit we should have the resorted view
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(0, 2)).toInt(), 1);
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 2)).toInt(), 2);
+    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(2, 2)).toInt(), 3);
+    QCOMPARE(model.data(model.index(3, 0)).toInt(), 42);
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("francis"));
+    QCOMPARE(model.data(model.index(3, 2)).toInt(), 2);
+
+}
+
+void tst_QSqlTableModel::insertRecord()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QSqlRecord rec = model.record();
+    rec.setValue(0, 42);
+    rec.setValue(1, QString("vohi"));
+    rec.setValue(2, 1);
+    QVERIFY(model.insertRecord(1, rec));
+    QCOMPARE(model.rowCount(), 4);
+
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 42);
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(1, 2)).toInt(), 1);
+
+    model.revertAll();
+    model.setEditStrategy(QSqlTableModel::OnRowChange);
+
+    QVERIFY(model.insertRecord(-1, rec));
+
+    QCOMPARE(model.data(model.index(3, 0)).toInt(), 42);
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(3, 2)).toInt(), 1);
+}
+
+void tst_QSqlTableModel::insertMultiRecords()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.rowCount(), 3);
+
+    QVERIFY(model.insertRow(2));
+
+    QCOMPARE(model.data(model.index(2, 0)), QVariant(model.record().field(0).type()));
+    QCOMPARE(model.data(model.index(2, 1)), QVariant(model.record().field(1).type()));
+    QCOMPARE(model.data(model.index(2, 2)), QVariant(model.record().field(2).type()));
+
+    QVERIFY(model.insertRow(3));
+    QVERIFY(model.insertRow(0));
+
+    QCOMPARE(model.data(model.index(5, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(5, 1)).toString(), QString("vohi"));
+    QCOMPARE(model.data(model.index(5, 2)).toInt(), 3);
+
+    QVERIFY(model.setData(model.index(0, 0), QVariant(42)));
+    QVERIFY(model.setData(model.index(3, 0), QVariant(43)));
+    QVERIFY(model.setData(model.index(4, 0), QVariant(44)));
+    QVERIFY(model.setData(model.index(4, 1), QVariant(QLatin1String("gunnar"))));
+    QVERIFY(model.setData(model.index(4, 2), QVariant(1)));
+
+    QVERIFY(model.submitAll());
+    model.clear();
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 2);
+    QCOMPARE(model.data(model.index(2, 0)).toInt(), 3);
+    QCOMPARE(model.data(model.index(3, 0)).toInt(), 42);
+    QCOMPARE(model.data(model.index(4, 0)).toInt(), 43);
+    QCOMPARE(model.data(model.index(5, 0)).toInt(), 44);
+    QCOMPARE(model.data(model.index(5, 1)).toString(), QString("gunnar"));
+    QCOMPARE(model.data(model.index(5, 2)).toInt(), 1);
+}
+
+void tst_QSqlTableModel::submitAll()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    QVERIFY_SQL(model, select());
+
+    QVERIFY(model.setData(model.index(0, 1), "harry2", Qt::EditRole));
+    QVERIFY(model.setData(model.index(1, 1), "trond2", Qt::EditRole));
+
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond2"));
+
+    QVERIFY_SQL(model, submitAll());
+
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry2"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond2"));
+
+    QVERIFY(model.setData(model.index(0, 1), "harry", Qt::EditRole));
+    QVERIFY(model.setData(model.index(1, 1), "trond", Qt::EditRole));
+
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+
+    QVERIFY_SQL(model, submitAll());
+
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+}
+
+void tst_QSqlTableModel::removeRow()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+
+    // headerDataChanged must be emitted by the model when the edit strategy is OnManualSubmit,
+    // when OnFieldChange or OnRowChange it's not needed because the model will re-select.
+    qRegisterMetaType<Qt::Orientation>("Qt::Orientation");
+    QSignalSpy headerDataChangedSpy(&model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)));
+
+    QVERIFY(model.removeRow(1));
+    QCOMPARE(headerDataChangedSpy.count(), 1);
+    QCOMPARE(*static_cast<const Qt::Orientation *>(headerDataChangedSpy.at(0).value(0).constData()), Qt::Vertical);
+    QCOMPARE(headerDataChangedSpy.at(0).at(1).toInt(), 1);
+    QCOMPARE(headerDataChangedSpy.at(0).at(2).toInt(), 1);
+    QVERIFY(model.submitAll());
+    QCOMPARE(model.rowCount(), 2);
+
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+    QCOMPARE(model.data(model.index(1, 0)).toInt(), 3);
+    model.clear();
+
+    recreateTestTables();
+
+    model.setTable(test);
+    model.setEditStrategy(QSqlTableModel::OnRowChange);
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+
+    headerDataChangedSpy.clear();
+    QVERIFY(model.removeRow(1));
+    QCOMPARE(headerDataChangedSpy.count(), 0);
+    QCOMPARE(model.rowCount(), 2);
+
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("vohi"));
+}
+
+void tst_QSqlTableModel::removeRows()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    model.setEditStrategy(QSqlTableModel::OnFieldChange);
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+
+    QSignalSpy beforeDeleteSpy(&model, SIGNAL(beforeDelete(int)));
+
+    // Make sure wrong stuff is ok
+    QVERIFY(!model.removeRows(-1,1)); // negative start
+    QVERIFY(!model.removeRows(-1, 0)); // negative start, and zero count
+    QVERIFY(!model.removeRows(1, 0)); // zero count
+    QVERIFY(!model.removeRows(5, 1)); // past end (causes a beforeDelete to be emitted)
+    QVERIFY(!model.removeRows(1, 0, model.index(2, 0))); // can't pass a valid modelindex
+
+    QVERIFY_SQL(model, removeRows(0, 2));
+    QCOMPARE(beforeDeleteSpy.count(), 3);
+    QVERIFY(beforeDeleteSpy.at(0).at(0).toInt() == 5);
+    QVERIFY(beforeDeleteSpy.at(1).at(0).toInt() == 0);
+    QVERIFY(beforeDeleteSpy.at(2).at(0).toInt() == 1);
+    QCOMPARE(model.rowCount(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("vohi"));
+    model.clear();
+
+    recreateTestTables();
+    model.setTable(test);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+    beforeDeleteSpy.clear();
+
+    // When the edit strategy is OnManualSubmit the beforeDelete() signal
+    // isn't emitted until submitAll() is called.
+
+    QVERIFY(!model.removeRows(-1,1)); // negative start
+    QVERIFY(!model.removeRows(-1, 0)); // negative start, and zero count
+    QVERIFY(!model.removeRows(1, 0)); // zero count
+    QVERIFY(!model.removeRows(5, 1)); // past end (DOESN'T cause a beforeDelete to be emitted)
+    QVERIFY(!model.removeRows(1, 0, model.index(2, 0))); // can't pass a valid modelindex
+
+    qRegisterMetaType<Qt::Orientation>("Qt::Orientation");
+    QSignalSpy headerDataChangedSpy(&model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)));
+    QVERIFY(model.removeRows(0, 2, QModelIndex()));
+    QCOMPARE(headerDataChangedSpy.count(), 2);
+    QCOMPARE(headerDataChangedSpy.at(0).at(1).toInt(), 0);
+    QCOMPARE(headerDataChangedSpy.at(0).at(2).toInt(), 0);
+    QCOMPARE(headerDataChangedSpy.at(1).at(1).toInt(), 1);
+    QCOMPARE(headerDataChangedSpy.at(1).at(2).toInt(), 1);
+    QCOMPARE(model.rowCount(), 3);
+    QVERIFY(beforeDeleteSpy.count() == 0);
+    QVERIFY(model.submitAll());
+    QVERIFY(beforeDeleteSpy.count() == 2);
+    QVERIFY(beforeDeleteSpy.at(0).at(0).toInt() == 0);
+    QVERIFY(beforeDeleteSpy.at(1).at(0).toInt() == 1);
+    QCOMPARE(model.rowCount(), 1);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("vohi"));
+}
+
+void tst_QSqlTableModel::removeInsertedRow()
+{
+    QFETCH(QString, dbName);
+    QFETCH(int, submitpolicy_i);
+    QSqlTableModel::EditStrategy submitpolicy = (QSqlTableModel::EditStrategy) submitpolicy_i;
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+
+    model.setEditStrategy(submitpolicy);
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+
+    QVERIFY(model.insertRow(1));
+    QCOMPARE(model.rowCount(), 4);
+
+    QVERIFY(model.removeRow(1));
+    QCOMPARE(model.rowCount(), 3);
+
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+
+    // Now insert a row with a null, and check that removing it also works (QTBUG-15979 etc)
+    model.insertRow(1);
+    model.setData(model.index(1,0), 55);
+    model.setData(model.index(1,1), QString("null columns"));
+    model.setData(model.index(1,2), QVariant());
+
+    model.submitAll();
+
+    QCOMPARE(model.rowCount(), 4);
+    QCOMPARE(model.data(model.index(3, 0)).toInt(), 55);
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("null columns"));
+    QCOMPARE(model.data(model.index(3, 2)).isNull(), true);
+
+    QVERIFY(model.removeRow(3));
+    model.submitAll();
+    QCOMPARE(model.rowCount(), 3);
+
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+}
+
+void tst_QSqlTableModel::removeInsertedRows()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit); // you can't insert more than one row otherwise
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+
+    // First put two empty rows, and remove them one by one
+    QVERIFY(model.insertRows(1, 2));
+    QCOMPARE(model.rowCount(), 5);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(4, 1)).toString(), QString("vohi"));
+
+    QVERIFY(model.removeRow(1));
+    QCOMPARE(model.rowCount(), 4);
+
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("vohi"));
+
+    QVERIFY(model.removeRow(1));
+    QCOMPARE(model.rowCount(), 3);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+
+    // Now put two empty rows, and remove them all at once
+    QVERIFY(model.insertRows(1, 2));
+    QCOMPARE(model.rowCount(), 5);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(4, 1)).toString(), QString("vohi"));
+
+    QVERIFY(model.removeRows(1, 2));
+    QCOMPARE(model.rowCount(), 3);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("vohi"));
+
+
+    // Now put two empty rows, and remove one good and two empty
+    QVERIFY(model.insertRows(1, 2));
+    QCOMPARE(model.rowCount(), 5);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(4, 1)).toString(), QString("vohi"));
+
+    QVERIFY(model.removeRows(0, 3));
+    QVERIFY(model.submitAll()); // otherwise the remove of the real row doesn't work
+
+    QCOMPARE(model.rowCount(), 2);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("vohi"));
+
+    // Reset back again
+    model.clear();
+    recreateTestTables();
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit); // you can't insert more than one row otherwise
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+
+    // Now two empty and one good
+    QVERIFY(model.insertRows(1, 2));
+    QCOMPARE(model.rowCount(), 5);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(4, 1)).toString(), QString("vohi"));
+
+    QVERIFY(model.removeRows(1, 3));
+    QVERIFY(model.submitAll());
+    QCOMPARE(model.rowCount(), 2);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("vohi"));
+
+    // Reset back again
+    model.clear();
+    recreateTestTables();
+    model.setTable(test);
+    model.setSort(0, Qt::AscendingOrder);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit); // you can't insert more than one row otherwise
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+
+    // one empty, one good, one empty
+    QVERIFY(model.insertRows(1, 1));
+    QVERIFY(model.insertRows(3, 1));
+    QCOMPARE(model.rowCount(), 5);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(2, 1)).toString(), QString("trond"));
+    QCOMPARE(model.data(model.index(3, 1)).toString(), QString());
+    QCOMPARE(model.data(model.index(4, 1)).toString(), QString("vohi"));
+
+    QVERIFY(model.removeRows(1, 3));
+    QVERIFY(model.submitAll());
+    QCOMPARE(model.rowCount(), 2);
+    QCOMPARE(model.data(model.index(0, 1)).toString(), QString("harry"));
+    QCOMPARE(model.data(model.index(1, 1)).toString(), QString("vohi"));
+}
+
+void tst_QSqlTableModel::emptyTable()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    QCOMPARE(model.rowCount(), 0);
+    QCOMPARE(model.columnCount(), 0);
+
+    model.setTable(qTableName("emptytable", __FILE__));
+    QCOMPARE(model.rowCount(), 0);
+    QCOMPARE(model.columnCount(), 1);
+
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 0);
+    QCOMPARE(model.columnCount(), 1);
+}
+
+void tst_QSqlTableModel::tablesAndSchemas()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQuery q(db);
+    q.exec("DROP SCHEMA " + qTableName("testschema", __FILE__) + " CASCADE");
+    QVERIFY_SQL( q, exec("create schema " + qTableName("testschema", __FILE__)));
+    QString tableName = qTableName("testschema", __FILE__) + '.' + qTableName("testtable", __FILE__);
+    QVERIFY_SQL( q, exec("create table " + tableName + "(id int)"));
+    QVERIFY_SQL( q, exec("insert into " + tableName + " values(1)"));
+    QVERIFY_SQL( q, exec("insert into " + tableName + " values(2)"));
+
+    QSqlTableModel model(0, db);
+    model.setTable(tableName);
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 2);
+    QCOMPARE(model.columnCount(), 1);
+}
+
+void tst_QSqlTableModel::whitespaceInIdentifiers()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    if (!testWhiteSpaceNames(db.driverName()))
+        QSKIP("DBMS doesn't support whitespaces in identifiers", SkipSingle);
+
+    QString tableName = qTableName("qtestw hitespace", db.driver());
+
+    QSqlTableModel model(0, db);
+    model.setTable(tableName);
+    QVERIFY_SQL(model, select());
+}
+
+void tst_QSqlTableModel::primaryKeyOrder()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQuery q(db);
+
+    if(tst_Databases::isPostgreSQL(db))
+        QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
+
+    QVERIFY_SQL( q, exec("create table "+qTableName("foo", __FILE__)+"(a varchar(20), id int not null primary key, b varchar(20))"));
+
+    QSqlTableModel model(0, db);
+    model.setTable(qTableName("foo", __FILE__));
+
+    QSqlIndex pk = model.primaryKey();
+    QCOMPARE(pk.count(), 1);
+    QCOMPARE(pk.fieldName(0), QLatin1String("id"));
+
+    QVERIFY(model.insertRow(0));
+    QVERIFY(model.setData(model.index(0, 0), "hello"));
+    QVERIFY(model.setData(model.index(0, 1), 42));
+    QVERIFY(model.setData(model.index(0, 2), "blah"));
+    QVERIFY_SQL(model, submitAll());
+
+    QVERIFY(model.setData(model.index(0, 1), 43));
+    QVERIFY_SQL(model, submitAll());
+
+    QCOMPARE(model.data(model.index(0, 1)).toInt(), 43);
+}
+
+void tst_QSqlTableModel::setInvalidFilter()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    // set an invalid filter, make sure it fails
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setFilter("blahfahsel");
+
+    QCOMPARE(model.filter(), QString("blahfahsel"));
+    QVERIFY(!model.select());
+
+    // set a valid filter later, make sure if passes
+    model.setFilter("id = 1");
+    QVERIFY_SQL(model, select());
+}
+
+void tst_QSqlTableModel::setFilter()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setFilter("id = 1");
+    QCOMPARE(model.filter(), QString("id = 1"));
+    QVERIFY_SQL(model, select());
+
+    QCOMPARE(model.rowCount(), 1);
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 1);
+
+    QSignalSpy rowsRemovedSpy(&model, SIGNAL(rowsRemoved(QModelIndex,int,int)));
+    QSignalSpy rowsAboutToBeRemovedSpy(&model,
+            SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)));
+    QSignalSpy rowsInsertedSpy(&model, SIGNAL(rowsInserted(QModelIndex,int,int)));
+    QSignalSpy rowsAboutToBeInsertedSpy(&model,
+            SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)));
+    model.setFilter("id = 2");
+
+    // check the signals
+    QCOMPARE(rowsAboutToBeRemovedSpy.count(), 1);
+    QCOMPARE(rowsRemovedSpy.count(), 1);
+    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 1);
+    QCOMPARE(rowsInsertedSpy.count(), 1);
+    QList<QVariant> args = rowsAboutToBeRemovedSpy.takeFirst();
+    QCOMPARE(args.count(), 3);
+    QCOMPARE(qvariant_cast<QModelIndex>(args.at(0)), QModelIndex());
+    QCOMPARE(args.at(1).toInt(), 0);
+    QCOMPARE(args.at(2).toInt(), 0);
+    args = rowsRemovedSpy.takeFirst();
+    QCOMPARE(args.count(), 3);
+    QCOMPARE(qvariant_cast<QModelIndex>(args.at(0)), QModelIndex());
+    QCOMPARE(args.at(1).toInt(), 0);
+    QCOMPARE(args.at(2).toInt(), 0);
+    args = rowsInsertedSpy.takeFirst();
+    QCOMPARE(args.count(), 3);
+    QCOMPARE(qvariant_cast<QModelIndex>(args.at(0)), QModelIndex());
+    QCOMPARE(args.at(1).toInt(), 0);
+    QCOMPARE(args.at(2).toInt(), 0);
+    args = rowsAboutToBeInsertedSpy.takeFirst();
+    QCOMPARE(args.count(), 3);
+    QCOMPARE(qvariant_cast<QModelIndex>(args.at(0)), QModelIndex());
+    QCOMPARE(args.at(1).toInt(), 0);
+    QCOMPARE(args.at(2).toInt(), 0);
+
+    QCOMPARE(model.rowCount(), 1);
+    QCOMPARE(model.data(model.index(0, 0)).toInt(), 2);
+}
+
+void tst_QSqlTableModel::sqlite_bigTable()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    const QString bigtable(qTableName("bigtable", __FILE__));
+
+    bool hasTransactions = db.driver()->hasFeature(QSqlDriver::Transactions);
+    if (hasTransactions) QVERIFY(db.transaction());
+    QSqlQuery q(db);
+    QVERIFY_SQL( q, exec("create table "+bigtable+"(id int primary key, name varchar)"));
+    QVERIFY_SQL( q, prepare("insert into "+bigtable+"(id, name) values (?, ?)"));
+    QTime startTime;
+    startTime.start();
+    for (int i = 0; i < 10000; ++i) {
+        q.addBindValue(i);
+        q.addBindValue(QString::number(i));
+        if(i%1000 == 0 && startTime.elapsed() > 5000)
+            qDebug() << i << "records written";
+        QVERIFY_SQL( q, exec());
+    }
+    q.clear();
+    if (hasTransactions) QVERIFY(db.commit());
+
+    QSqlTableModel model(0, db);
+    model.setTable(bigtable);
+    QVERIFY_SQL(model, select());
+
+    QSqlRecord rec = model.record();
+    rec.setValue("id", 424242);
+    rec.setValue("name", "Guillaume");
+    QVERIFY_SQL(model, insertRecord(-1, rec));
+
+    model.clear();
+}
+
+// For task 118547: couldn't insert records unless select()
+// had first been called.
+void tst_QSqlTableModel::insertRecordBeforeSelect()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    QCOMPARE(model.lastError().type(), QSqlError::NoError);
+
+    QSqlRecord buffer = model.record();
+    buffer.setValue("id", 13);
+    buffer.setValue("name", QString("The Lion King"));
+    buffer.setValue("title", 0);
+    QVERIFY_SQL(model, insertRecord(-1, buffer));
+
+    buffer.setValue("id", 26);
+    buffer.setValue("name", QString("T. Leary"));
+    buffer.setValue("title", 0);
+    QVERIFY_SQL(model, insertRecord(1, buffer));
+
+    int rowCount = model.rowCount();
+    model.clear();
+    QCOMPARE(model.rowCount(), 0);
+
+    QSqlTableModel model2(0, db);
+    model2.setTable(test);
+    QVERIFY_SQL(model2, select());
+    QCOMPARE(model2.rowCount(), rowCount);
+}
+
+// For task 118547: set errors if table doesn't exist and if records
+// are inserted and submitted on a non-existing table.
+void tst_QSqlTableModel::submitAllOnInvalidTable()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+
+    // setTable returns a void, so the error can only be caught by
+    // manually checking lastError(). ### Qt5: This should be changed!
+    model.setTable(qTableName("invalidTable", __FILE__));
+    QCOMPARE(model.lastError().type(), QSqlError::StatementError);
+
+    // This will give us an empty record which is expected behavior
+    QSqlRecord buffer = model.record();
+    buffer.setValue("bogus", 1000);
+    buffer.setValue("bogus2", QString("I will go nowhere!"));
+
+    // Inserting the record into the *model* will work (OnManualSubmit)
+    QVERIFY_SQL(model, insertRecord(-1, buffer));
+
+    // The submit and select shall fail because the table doesn't exist
+    QEXPECT_FAIL("", "The table doesn't exist: submitAll() shall fail",
+        Continue);
+    QVERIFY_SQL(model, submitAll());
+    QEXPECT_FAIL("", "The table doesn't exist: select() shall fail",
+        Continue);
+    QVERIFY_SQL(model, select());
+}
+
+// For task 147575: the rowsRemoved signal emitted from the model was lying
+void tst_QSqlTableModel::insertRecordsInLoop()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    model.select();
+
+    QSqlRecord record = model.record();
+    record.setValue(0, 10);
+    record.setValue(1, "Testman");
+    record.setValue(2, 1);
+
+    QSignalSpy spyRowsRemoved(&model, SIGNAL(rowsRemoved(const QModelIndex &, int, int)));
+    QSignalSpy spyRowsInserted(&model, SIGNAL(rowsInserted(const QModelIndex &, int, int)));
+    for (int i = 0; i < 10; i++) {
+        QVERIFY(model.insertRecord(model.rowCount(), record));
+        QCOMPARE(spyRowsInserted.at(i).at(1).toInt(), i+3); // The table already contains three rows
+        QCOMPARE(spyRowsInserted.at(i).at(2).toInt(), i+3);
+    }
+    model.submitAll(); // submitAll() calls select() which clears and repopulates the table
+
+    int firstRowIndex = 0, lastRowIndex = 12;
+    QCOMPARE(spyRowsRemoved.count(), 1);
+    QCOMPARE(spyRowsRemoved.at(0).at(1).toInt(), firstRowIndex);
+    QCOMPARE(spyRowsRemoved.at(0).at(2).toInt(), lastRowIndex);
+
+    QCOMPARE(spyRowsInserted.at(10).at(1).toInt(), firstRowIndex);
+    QCOMPARE(spyRowsInserted.at(10).at(2).toInt(), lastRowIndex);
+    QCOMPARE(spyRowsInserted.count(), 11);
+
+    QCOMPARE(model.rowCount(), 13);
+    QCOMPARE(model.columnCount(), 3);
+}
+
+void tst_QSqlTableModel::sqlite_attachedDatabase()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+    if(db.databaseName() == ":memory:")
+        QSKIP(":memory: database, skipping test", SkipSingle);
+
+    QSqlDatabase attachedDb = QSqlDatabase::cloneDatabase(db, db.driverName() + QLatin1String("attached"));
+    attachedDb.setDatabaseName(db.databaseName()+QLatin1String("attached.dat"));
+    QVERIFY_SQL(attachedDb, open());
+    QSqlQuery q(attachedDb);
+    tst_Databases::safeDropTables(attachedDb, QStringList() << "atest" << "atest2");
+    QVERIFY_SQL( q, exec("CREATE TABLE atest(id int, text varchar(20))"));
+    QVERIFY_SQL( q, exec("CREATE TABLE atest2(id int, text varchar(20))"));
+    QVERIFY_SQL( q, exec("INSERT INTO atest VALUES(1, 'attached-atest')"));
+    QVERIFY_SQL( q, exec("INSERT INTO atest2 VALUES(2, 'attached-atest2')"));
+
+    QSqlQuery q2(db);
+    tst_Databases::safeDropTable(db, "atest");
+    QVERIFY_SQL(q2, exec("CREATE TABLE atest(id int, text varchar(20))"));
+    QVERIFY_SQL(q2, exec("INSERT INTO atest VALUES(3, 'main')"));
+    QVERIFY_SQL(q2, exec("ATTACH DATABASE \""+attachedDb.databaseName()+"\" as adb"));
+
+    // This should query the table in the attached database (schema supplied)
+    QSqlTableModel model(0, db);
+    model.setTable("adb.atest");
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 1);
+    QCOMPARE(model.data(model.index(0, 0), Qt::DisplayRole).toInt(), 1);
+    QCOMPARE(model.data(model.index(0, 1), Qt::DisplayRole).toString(), QLatin1String("attached-atest"));
+
+    // This should query the table in the attached database (unique tablename)
+    model.setTable("atest2");
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 1);
+    QCOMPARE(model.data(model.index(0, 0), Qt::DisplayRole).toInt(), 2);
+    QCOMPARE(model.data(model.index(0, 1), Qt::DisplayRole).toString(), QLatin1String("attached-atest2"));
+
+    // This should query the table in the main database (tables in main db has 1st priority)
+    model.setTable("atest");
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 1);
+    QCOMPARE(model.data(model.index(0, 0), Qt::DisplayRole).toInt(), 3);
+    QCOMPARE(model.data(model.index(0, 1), Qt::DisplayRole).toString(), QLatin1String("main"));
+}
+
+
+void tst_QSqlTableModel::tableModifyWithBlank()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(qTableName("test4", __FILE__));
+    model.select();
+
+    //generate a time stamp for the test. Add one second to the current time to make sure
+    //it is different than the QSqlQuery test.
+    QString timeString=QDateTime::currentDateTime().addSecs(1).toString(Qt::ISODate);
+
+    //insert a new row, with column0 being the timestamp.
+    //Should be equivalent to QSqlQuery INSERT INTO... command)
+    QVERIFY_SQL(model, insertRow(0));
+    QVERIFY_SQL(model, setData(model.index(0,0),timeString));
+    QVERIFY_SQL(model, submitAll());
+
+    //set a filter on the table so the only record we get is the one we just made
+    //I could just do another setData command, but I want to make sure the TableModel
+    //matches exactly what is stored in the database
+    model.setFilter("column1='"+timeString+"'"); //filter to get just the newly entered row
+    QVERIFY_SQL(model, select());
+
+    //Make sure we only get one record, and that it is the one we just made
+    QCOMPARE(model.rowCount(), 1); //verify only one entry
+    QCOMPARE(model.record(0).value(0).toString(), timeString); //verify correct record
+
+    //At this point we know that the initial value (timestamp) was succsefully stored in the database
+    //Attempt to modify the data in the new record
+    //equivalent to query.exec("update test set column3="... command in direct test
+    //set the data in the first column to "col1ModelData"
+    QVERIFY_SQL(model, setData(model.index(0,1), "col1ModelData"));
+
+    //do a quick check to make sure that the setData command properly set the value in the model
+    QCOMPARE(model.record(0).value(1).toString(), QLatin1String("col1ModelData"));
+
+    //submit the changed data to the database
+    //This is where I have been getting errors.
+    QVERIFY_SQL(model, submitAll());
+
+    //make sure the model has the most current data for our record
+    QVERIFY_SQL(model, select());
+
+    //verify that our new record was the only record returned
+    QCOMPARE(model.rowCount(), 1);
+
+    //And that the record returned is, in fact, our test record.
+    QCOMPARE(model.record(0).value(0).toString(), timeString);
+
+    //Make sure the value of the first column matches what we set it to previously.
+    QCOMPARE(model.record(0).value(1).toString(), QLatin1String("col1ModelData"));
+}
+
+void tst_QSqlTableModel::removeColumnAndRow()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    QVERIFY_SQL(model, select());
+    QCOMPARE(model.rowCount(), 3);
+    QCOMPARE(model.columnCount(), 3);
+
+    QVERIFY(model.removeColumn(0));
+    QVERIFY(model.removeRow(0));
+    QVERIFY(model.submitAll());
+    QCOMPARE(model.rowCount(), 2);
+    QCOMPARE(model.columnCount(), 2);
+
+    // check with another table because the model has been modified
+    // but not the sql table
+    QSqlTableModel model2(0, db);
+    model2.setTable(test);
+    QVERIFY_SQL(model2, select());
+    QCOMPARE(model2.rowCount(), 2);
+    QCOMPARE(model2.columnCount(), 3);
+}
+
+void tst_QSqlTableModel::insertBeforeDelete()
+{
+    QFETCH(QString, dbName);
+    QSqlDatabase db = QSqlDatabase::database(dbName);
+    CHECK_DATABASE(db);
+
+    QSqlQuery q(db);
+    QVERIFY_SQL( q, exec("insert into " + test + " values(9, 'andrew', 9)"));
+    QVERIFY_SQL( q, exec("insert into " + test + " values(10, 'justin', 10)"));
+
+    QSqlTableModel model(0, db);
+    model.setTable(test);
+    model.setEditStrategy(QSqlTableModel::OnManualSubmit);
+    QVERIFY_SQL(model, select());
+
+    QSqlRecord rec = model.record();
+    rec.setValue(0, 4);
+    rec.setValue(1, QString("bill"));
+    rec.setValue(2, 4);
+    QVERIFY_SQL(model, insertRecord(4, rec));
+
+    QVERIFY_SQL(model, removeRow(5));
+    QVERIFY_SQL(model, submitAll());
+    QCOMPARE(model.rowCount(), 5);
+}
+
+QTEST_MAIN(tst_QSqlTableModel)
+#include "tst_qsqltablemodel.moc"
diff --git a/tests/auto/sql/sql.pro b/tests/auto/sql/sql.pro
new file mode 100644
index 0000000000..99f6e38cf8
--- /dev/null
+++ b/tests/auto/sql/sql.pro
@@ -0,0 +1,5 @@
+TEMPLATE=subdirs
+SUBDIRS=\
+   kernel \
+   models \
+