From 0a2282f97a2d74ac52d6ba8f33b1eaba0df3668d Mon Sep 17 00:00:00 2001 From: Jo Asplin Date: Fri, 2 Sep 2011 12:08:47 +0200 Subject: 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 Reviewed-by: Jason McDonald --- tests/auto/sql/kernel/kernel.pro | 11 + tests/auto/sql/kernel/qsql/.gitignore | 1 + tests/auto/sql/kernel/qsql/qsql.pro | 18 + tests/auto/sql/kernel/qsql/tst_qsql.cpp | 277 ++ tests/auto/sql/kernel/qsqldatabase/.gitignore | 1 + .../auto/sql/kernel/qsqldatabase/qsqldatabase.pro | 32 + .../sql/kernel/qsqldatabase/testdata/qtest.mdb | Bin 0 -> 65536 bytes tests/auto/sql/kernel/qsqldatabase/tst_databases.h | 571 ++++ .../sql/kernel/qsqldatabase/tst_qsqldatabase.cpp | 2218 +++++++++++++ tests/auto/sql/kernel/qsqldriver/qsqldriver.pro | 27 + .../auto/sql/kernel/qsqldriver/tst_qsqldriver.cpp | 230 ++ tests/auto/sql/kernel/qsqlerror/.gitignore | 1 + tests/auto/sql/kernel/qsqlerror/qsqlerror.pro | 18 + tests/auto/sql/kernel/qsqlerror/tst_qsqlerror.cpp | 145 + tests/auto/sql/kernel/qsqlfield/.gitignore | 1 + tests/auto/sql/kernel/qsqlfield/qsqlfield.pro | 15 + tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp | 360 +++ tests/auto/sql/kernel/qsqlquery/.gitignore | 1 + tests/auto/sql/kernel/qsqlquery/qsqlquery.pro | 25 + tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp | 3267 ++++++++++++++++++++ tests/auto/sql/kernel/qsqlrecord/.gitignore | 1 + tests/auto/sql/kernel/qsqlrecord/qsqlrecord.pro | 20 + .../auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp | 522 ++++ tests/auto/sql/kernel/qsqlthread/.gitignore | 1 + tests/auto/sql/kernel/qsqlthread/qsqlthread.pro | 23 + .../auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp | 531 ++++ tests/auto/sql/models/models.pro | 6 + tests/auto/sql/models/qsqlquerymodel/.gitignore | 1 + .../sql/models/qsqlquerymodel/qsqlquerymodel.pro | 20 + .../models/qsqlquerymodel/tst_qsqlquerymodel.cpp | 641 ++++ .../sql/models/qsqlrelationaltablemodel/.gitignore | 1 + .../qsqlrelationaltablemodel.pro | 25 + .../tst_qsqlrelationaltablemodel.cpp | 1494 +++++++++ tests/auto/sql/models/qsqltablemodel/.gitignore | 1 + .../sql/models/qsqltablemodel/qsqltablemodel.pro | 22 + .../models/qsqltablemodel/tst_qsqltablemodel.cpp | 1377 +++++++++ tests/auto/sql/sql.pro | 5 + 37 files changed, 11910 insertions(+) create mode 100644 tests/auto/sql/kernel/kernel.pro create mode 100644 tests/auto/sql/kernel/qsql/.gitignore create mode 100644 tests/auto/sql/kernel/qsql/qsql.pro create mode 100644 tests/auto/sql/kernel/qsql/tst_qsql.cpp create mode 100644 tests/auto/sql/kernel/qsqldatabase/.gitignore create mode 100644 tests/auto/sql/kernel/qsqldatabase/qsqldatabase.pro create mode 100755 tests/auto/sql/kernel/qsqldatabase/testdata/qtest.mdb create mode 100644 tests/auto/sql/kernel/qsqldatabase/tst_databases.h create mode 100644 tests/auto/sql/kernel/qsqldatabase/tst_qsqldatabase.cpp create mode 100644 tests/auto/sql/kernel/qsqldriver/qsqldriver.pro create mode 100644 tests/auto/sql/kernel/qsqldriver/tst_qsqldriver.cpp create mode 100644 tests/auto/sql/kernel/qsqlerror/.gitignore create mode 100644 tests/auto/sql/kernel/qsqlerror/qsqlerror.pro create mode 100644 tests/auto/sql/kernel/qsqlerror/tst_qsqlerror.cpp create mode 100644 tests/auto/sql/kernel/qsqlfield/.gitignore create mode 100644 tests/auto/sql/kernel/qsqlfield/qsqlfield.pro create mode 100644 tests/auto/sql/kernel/qsqlfield/tst_qsqlfield.cpp create mode 100644 tests/auto/sql/kernel/qsqlquery/.gitignore create mode 100644 tests/auto/sql/kernel/qsqlquery/qsqlquery.pro create mode 100644 tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp create mode 100644 tests/auto/sql/kernel/qsqlrecord/.gitignore create mode 100644 tests/auto/sql/kernel/qsqlrecord/qsqlrecord.pro create mode 100644 tests/auto/sql/kernel/qsqlrecord/tst_qsqlrecord.cpp create mode 100644 tests/auto/sql/kernel/qsqlthread/.gitignore create mode 100644 tests/auto/sql/kernel/qsqlthread/qsqlthread.pro create mode 100644 tests/auto/sql/kernel/qsqlthread/tst_qsqlthread.cpp create mode 100644 tests/auto/sql/models/models.pro create mode 100644 tests/auto/sql/models/qsqlquerymodel/.gitignore create mode 100644 tests/auto/sql/models/qsqlquerymodel/qsqlquerymodel.pro create mode 100644 tests/auto/sql/models/qsqlquerymodel/tst_qsqlquerymodel.cpp create mode 100644 tests/auto/sql/models/qsqlrelationaltablemodel/.gitignore create mode 100644 tests/auto/sql/models/qsqlrelationaltablemodel/qsqlrelationaltablemodel.pro create mode 100644 tests/auto/sql/models/qsqlrelationaltablemodel/tst_qsqlrelationaltablemodel.cpp create mode 100644 tests/auto/sql/models/qsqltablemodel/.gitignore create mode 100644 tests/auto/sql/models/qsqltablemodel/qsqltablemodel.pro create mode 100644 tests/auto/sql/models/qsqltablemodel/tst_qsqltablemodel.cpp create mode 100644 tests/auto/sql/sql.pro (limited to 'tests/auto/sql') 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 ); + 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 Binary files /dev/null and b/tests/auto/sql/kernel/qsqldatabase/testdata/qtest.mdb differ 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#if defined (Q_OS_WIN) || defined (Q_OS_WIN32) +# include +# if defined (Q_OS_WINCE) +# include +# endif +#else +#include +#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( "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( "dbName" ); + QTest::addColumn("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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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("MY_TABLE"); + 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 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 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 +#include + +#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 + +#include +#include +#include + + +//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 + +#include +#include +#include + + +//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("val"); + QTest::addColumn("bval"); + QTest::addColumn("strVal"); + QTest::addColumn("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("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("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("ival"); + QTest::addColumn("bval"); + QTest::addColumn("dval"); + QTest::addColumn("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 +#include + +#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 validReturns(QSet() << -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 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(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 + +#include "qsqlrecord.h" +#include "qsqlfield.h" +#include "qstringlist.h" + + + + +#include + +//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("prefix"); + QTest::addColumn("sep"); + QTest::addColumn("ival"); + QTest::addColumn("sval"); + QTest::addColumn("dval"); + QTest::addColumn("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 + + +#include "../qsqldatabase/tst_databases.h" + +#include +#include +#include "qdebug.h" + +#ifdef Q_OS_LINUX +#include +#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 +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +#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"); + 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"); + 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(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 +#include + +#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 +#include "../../kernel/qsqldatabase/tst_databases.h" +#include + +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"); + 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 policies = QList() << 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(spy.at(0).at(0)), model.index(i, 0)); + QCOMPARE(qvariant_cast(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(spy.at(0).at(0)), model.index(i, 1)); + QCOMPARE(qvariant_cast(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"); + QSignalSpy headerDataChangedSpy(&model, SIGNAL(headerDataChanged(Qt::Orientation, int, int))); + + QVERIFY(model.removeRow(1)); + QCOMPARE(headerDataChangedSpy.count(), 1); + QCOMPARE(*static_cast(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"); + 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 args = rowsAboutToBeRemovedSpy.takeFirst(); + QCOMPARE(args.count(), 3); + QCOMPARE(qvariant_cast(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(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(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(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 \ + -- cgit v1.2.3