FCL/sf/mw/qt: comparison tests/auto/qsqldatabase/tst

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 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.
 **
 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);
 // 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"));
+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");
+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 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") +
+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") +
+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") + " test", QSqlDriver::TableName)
++ 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));
 }
 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") << qTableName("qtest_view2"));
+tst_Databases::safeDropViews(db, QStringList() << qTableName("qtest_view", __FILE__) << qTableName("qtest_view2", __FILE__));
 QStringList tableNames;
-tableNames << qTableName("qtest")
+tableNames << qTableName("qtest", __FILE__)
-<< qTableName("qtestfields")
+<< qTableName("qtestfields", __FILE__)
-<< qTableName("qtestalter")
+<< qTableName("qtestalter", __FILE__)
-<< qTableName("qtest_temp")
+<< qTableName("qtest_temp", __FILE__)
-<< qTableName("qtest_bigint")
+<< qTableName("qtest_bigint", __FILE__)
-<< qTableName("qtest_xmltype")
+<< qTableName("qtest_xmltype", __FILE__)
-<< qTableName("latin1table")
+<< qTableName("latin1table", __FILE__)
-<< qTableName("qtest_sqlguid")
+<< qTableName("qtest_sqlguid", __FILE__)
-<< qTableName("batable")
+<< qTableName("batable", __FILE__)
-<< qTableName("qtest_prec")
+<< qTableName("qtest_prec", __FILE__)
-<< qTableName("uint")
+<< qTableName("uint", __FILE__)
-<< qTableName("strings")
+<< qTableName("strings", __FILE__)
-<< qTableName("numericfields")
+<< qTableName("numericfields", __FILE__)
-<< qTableName("qtest_ibaseblobs")
+<< qTableName("qtest_ibaseblobs", __FILE__)
-<< qTableName("qtestBindBool")
+<< qTableName("qtestBindBool", __FILE__)
-<< qTableName("testqGetString")
+<< qTableName("testqGetString", __FILE__)
-<< qTableName("qtest_sqlguid")
+<< qTableName("qtest_sqlguid", __FILE__)
-<< qTableName("uint_table")
+<< qTableName("uint_table", __FILE__)
-<< qTableName("uint_test")
+<< qTableName("uint_test", __FILE__)
-<< qTableName("bug_249059");
+<< qTableName("bug_249059", __FILE__);
 QSqlQuery q(0, db);
 if (db.driverName().startsWith("QPSQL")) {
-q.exec("drop schema " + qTableName("qtestschema") + " cascade");
+q.exec("drop schema " + qTableName("qtestschema", __FILE__) + " cascade");
-q.exec("drop schema " + qTableName("qtestScHeMa") + " cascade");
+q.exec("drop schema " + qTableName("qtestScHeMa", __FILE__) + " cascade");
 }
 if (testWhiteSpaceNames(db.driverName()))
-tableNames <<  db.driver()->escapeIdentifier(qTableName("qtest") + " test", QSqlDriver::TableName);
+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")+" cascade");
+q.exec("drop user "+qTableName("CREATOR", __FILE__)+" cascade");
-q.exec("drop user "+qTableName("APPUSER")+" cascade");
+q.exec("drop user "+qTableName("APPUSER", __FILE__)+" cascade");
-q.exec("DROP TABLE system."+qTableName("mypassword"));
+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 " + qTableName("qtest")); //non-fatal
-QVERIFY_SQL(q, exec("insert into " + qTableName("qtest") + " (id, t_varchar, t_char, t_numeric) values (0, 'VarChar0', 'Char0', 1.1)"));
+q.exec("delete from " + qtest); //non-fatal
-QVERIFY_SQL(q, exec("insert into " + qTableName("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 (0, 'VarChar0', 'Char0', 1.1)"));
-QVERIFY_SQL(q, exec("insert into " + qTableName("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 (1, 'VarChar1', 'Char1', 2.2)"));
-QVERIFY_SQL(q, exec("insert into " + qTableName("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 (2, 'VarChar2', 'Char2', 3.3)"));
-QVERIFY_SQL(q, exec("insert into " + qTableName("qtest") + " (id, t_varchar, t_char, t_numeric) values (4, 'VarChar4', NULL, NULL)"));
+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();
 QSqlRecord rec = db.record(q);
 QVERIFY(rec.isEmpty());
 Q3SqlRecordInfo rInf = db.recordInfo(q);
 QVERIFY(rInf.isEmpty());
-QVERIFY_SQL(q, exec("create table " + qTableName("qtest_temp") + " (id int)"));
+QVERIFY_SQL(q, exec("create table " + qTableName("qtest_temp", __FILE__) + " (id int)"));
 // query without result set should return empty record
 rec = db.record(q);
 QVERIFY(rec.isEmpty());
 rInf = db.recordInfo(q);
 {
 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 " + qTableName("qtest_view") + " as select * from " + qTableName("qtest"))) {
+if (!q.exec("CREATE VIEW " + qtest_view + " as select * from " + qtest)) {
 qDebug(QString("DBMS '%1' cannot handle VIEWs: %2").arg(
 tst_Databases::dbToString(db)).arg(QString(tst_Databases::printError(q.lastError()))).toLatin1());
 views = false;
 }
 if (db.driverName().startsWith("QSQLITE3")) {
-QVERIFY_SQL(q, exec("CREATE TEMPORARY TABLE " + qTableName("temp_tab") + " (id int)"));
+QVERIFY_SQL(q, exec("CREATE TEMPORARY TABLE " + temp_tab + " (id int)"));
 tempTables = true;
 }
 QStringList tables = db.tables(QSql::Tables);
-QVERIFY(tables.contains(qTableName("qtest"), Qt::CaseInsensitive));
+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(qTableName("qtest_view"), Qt::CaseInsensitive));
+QVERIFY(!tables.contains(qtest_view, Qt::CaseInsensitive));
 }
 if (tempTables)
-QVERIFY(tables.contains(qTableName("temp_tab"), Qt::CaseInsensitive));
+QVERIFY(tables.contains(temp_tab, Qt::CaseInsensitive));
 tables = db.tables(QSql::Views);
 if (views) {
-if(!tables.contains(qTableName("qtest_view"), Qt::CaseInsensitive))
+if(!tables.contains(qtest_view, Qt::CaseInsensitive))
-qDebug() << "failed to find" << qTableName("qtest_view") << "in" << tables;
+qDebug() << "failed to find" << qtest_view << "in" << tables;
-QVERIFY(tables.contains(qTableName("qtest_view"), Qt::CaseInsensitive));
+QVERIFY(tables.contains(qtest_view, Qt::CaseInsensitive));
 }
 if (tempTables)
-QVERIFY(!tables.contains(qTableName("temp_tab"), Qt::CaseInsensitive));
+QVERIFY(!tables.contains(temp_tab, Qt::CaseInsensitive));
-QVERIFY(!tables.contains(qTableName("qtest"), Qt::CaseInsensitive));
+QVERIFY(!tables.contains(qtest, Qt::CaseInsensitive));
 tables = db.tables(QSql::SystemTables);
-QVERIFY(!tables.contains(qTableName("qtest"), Qt::CaseInsensitive));
+QVERIFY(!tables.contains(qtest, Qt::CaseInsensitive));
-QVERIFY(!tables.contains(qTableName("qtest_view"), Qt::CaseInsensitive));
+QVERIFY(!tables.contains(qtest_view, Qt::CaseInsensitive));
-QVERIFY(!tables.contains(qTableName("temp_tab"), Qt::CaseInsensitive));
+QVERIFY(!tables.contains(temp_tab, Qt::CaseInsensitive));
 tables = db.tables(QSql::AllTables);
 if (views)
-QVERIFY(tables.contains(qTableName("qtest_view"), Qt::CaseInsensitive));
+QVERIFY(tables.contains(qtest_view, Qt::CaseInsensitive));
 if (tempTables)
-QVERIFY(tables.contains(qTableName("temp_tab"), Qt::CaseInsensitive));
+QVERIFY(tables.contains(temp_tab, Qt::CaseInsensitive));
-QVERIFY(tables.contains(qTableName("qtest"), Qt::CaseInsensitive));
+QVERIFY(tables.contains(qtest, Qt::CaseInsensitive));
 if (db.driverName().startsWith("QPSQL")) {
-QVERIFY(tables.contains(qTableName("qtest") + " test"));
+QVERIFY(tables.contains(qtest + " test"));
 }
 }
 void tst_QSqlDatabase::whitespaceInIdentifiers()
 {
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
 if (testWhiteSpaceNames(db.driverName())) {
-QString tableName = qTableName("qtest") + " test";
+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"));
 void tst_QSqlDatabase::alterTable()
 {
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
+const QString qtestalter(qTableName("qtestalter", __FILE__));
-QSqlQuery q(db);
+QSqlQuery q(db);
-QVERIFY_SQL(q, exec("create table " + qTableName("qtestalter") + " (F1 char(20), F2 char(20), F3 char(20))"));
-QSqlRecord rec = db.record(qTableName("qtestalter"));
+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);
 #ifdef QT3_SUPPORT
-Q3SqlRecordInfo rinf = db.recordInfo(qTableName("qtestalter"));
+Q3SqlRecordInfo rinf = db.recordInfo(qtestalter);
 QCOMPARE((int)rinf.count(), 3);
 #endif
 int i;
 #ifdef QT3_SUPPORT
 QCOMPARE(rinf[ i ].name().upper(), QString("F%1").arg(i + 1));
 #endif
 }
-if (!q.exec("alter table " + qTableName("qtestalter") + " drop column F2")) {
+if (!q.exec("alter table " + qtestalter + " drop column F2")) {
 QSKIP("DBMS doesn't support dropping columns in ALTER TABLE statement", SkipSingle);
 }
-rec = db.record(qTableName("qtestalter"));
+rec = db.record(qtestalter);
 #ifdef QT3_SUPPORT
-rinf = db.recordInfo(qTableName("qtestalter"));
+rinf = db.recordInfo(qtestalter);
 #endif
 QCOMPARE((int)rec.count(), 2);
 #ifdef QT3_SUPPORT
 QCOMPARE((int)rinf.count(), 2);
 #ifdef QT3_SUPPORT
 QCOMPARE(rinf[ 0 ].name().upper(), QString("F1"));
 QCOMPARE(rinf[ 1 ].name().upper(), QString("F3"));
 #endif
-q.exec("select * from " + qTableName("qtestalter"));
+q.exec("select * from " + qtestalter);
 #ifdef QT3_SUPPORT
 rec = db.record(q);
 rinf = db.recordInfo(q);
 {
 CHECK_DATABASE(db);
 // check whether recordInfo returns the right types
 #ifdef QT3_SUPPORT
-Q3SqlRecordInfo inf = db.recordInfo(qTableName("qtestfields"));
+Q3SqlRecordInfo inf = db.recordInfo(qTableName("qtestfields", __FILE__));
 QCOMPARE((int)inf.count(), fieldCount+1);
 testRecordInfo(fieldDefs, inf);
 #endif
-QSqlRecord rec = db.record(qTableName("qtestfields"));
+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")));
+QVERIFY_SQL(q, exec("select * from " + qTableName("qtestfields", __FILE__)));
 #ifdef QT3_SUPPORT
 inf = db.recordInfo(q);
 QCOMPARE((int)inf.count(), fieldCount+1);
 testRecordInfo(fieldDefs, inf);
 {
 Q_UNUSED(fieldDefs);
 #ifdef QT3_SUPPORT
 CHECK_DATABASE(db);
-Q3SqlCursor cur(qTableName("qtestfields"), true, db);
+Q3SqlCursor cur(qTableName("qtestfields", __FILE__), true, db);
 QVERIFY_SQL(cur, select());
 QSqlRecord* rec = cur.primeInsert();
 Q_ASSERT(rec);
 rec->setValue("id", pkey++);
 int i = 0;
 {
 Q_UNUSED(fieldDefs);
 #ifdef QT3_SUPPORT
 CHECK_DATABASE(db);
-Q3SqlCursor cur(qTableName("qtestfields"), true, db);
+Q3SqlCursor cur(qTableName("qtestfields", __FILE__), true, db);
 QVERIFY_SQL(cur, select());
 QSqlRecord* rec = cur.primeInsert();
 Q_ASSERT(rec);
 rec->setValue("id", pkey++);
 int i = 0;
 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) {
+if (tst_Databases::getOraVersion(db) >= 9)
-qDebug("Detected Oracle >= 9, TIMESTAMP test enabled");
+hasTimeStamp = true;
-hasTimeStamp = true;
-} else {
-qDebug("Detected Oracle < 9, TIMESTAMP test disabled");
-}
 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("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")),
+//        FieldDef("bfile", QVariant::ByteArray,         QByteArray("blah10")),
 intytm,
-//    intdts,
+intdts,
-//    tsdef,
+tsdef,
-//    tstzdef,
+tstzdef,
-//    tsltzdef,
+tsltzdef,
 FieldDef()
 };
 const int fieldCount = createFieldTable(fieldDefs, db);
 QVERIFY(fieldCount > 0);
 commonFieldTest(fieldDefs, db, fieldCount);
 checkNullValues(fieldDefs, db);
-for (int i = 0; i < ITERATION_COUNT; ++i) {
+for (int i = 0; i < ITERATION_COUNT; ++i)
 checkValues(fieldDefs, db);
-}
 // some additional tests
-QSqlRecord rec = db.record(qTableName("qtestfields"));
+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")));
+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);
 }
 QSqlQuery q(db);
 if(tst_Databases::isPostgreSQL(db))
 QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
-q.exec("drop sequence " + qTableName("qtestfields") + "_t_bigserial_seq");
+q.exec("drop sequence " + qTableName("qtestfields", __FILE__) + "_t_bigserial_seq");
-q.exec("drop sequence " + qTableName("qtestfields") + "_t_serial_seq");
+q.exec("drop sequence " + qTableName("qtestfields", __FILE__) + "_t_serial_seq");
 // older psql cut off the table name
-q.exec("drop sequence " + qTableName("qtestfields").left(15) + "_t_bigserial_seq");
+q.exec("drop sequence " + qTableName("qtestfields", __FILE__).left(15) + "_t_bigserial_seq");
-q.exec("drop sequence " + qTableName("qtestfields").left(18) + "_t_serial_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);
 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 " + qTableName("qtest") + " values (40, 'VarChar40', 'Char40', 40.40)"));
+QVERIFY_SQL(q, exec("insert into " + qtest + " values (40, 'VarChar40', 'Char40', 40.40)"));
-QVERIFY_SQL(q, exec("select * from " + qTableName("qtest") + " where id = 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 " + qTableName("qtest") + " where id = 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("insert into " + qTableName("qtest") + " values (41, 'VarChar41', 'Char41', 41.41)"));
+QVERIFY_SQL(q, exec("insert into " + qtest + " values (41, 'VarChar41', 'Char41', 41.41)"));
-QVERIFY_SQL(q, exec("select * from " + qTableName("qtest") + " where id = 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")) {
 } else {
 QFAIL("Could not rollback transaction: " + tst_Databases::printError(db.lastError()));
 }
 }
-QVERIFY_SQL(q, exec("select * from " + qTableName("qtest") + " where id = 41"));
+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);
 {
 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 " + qTableName("qtest_bigint") + " (id int, t_s64bit bigint, t_u64bit bigint unsigned)"));
+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 " + qTableName("qtest_bigint") + "(id int, t_s64bit bigint, t_u64bit bigint)"));
+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 " + qTableName("qtest_bigint") + " (id int, t_s64bit int, t_u64bit int)"));
+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 " + qTableName("qtest_bigint") + " (id int, t_s64bit int64, t_u64bit int64)"));
+//    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 " + qTableName("qtest_bigint") + " values (?, ?, ?)"));
+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(0, 1);
 q.bindValue(1, -ll);
 q.bindValue(2,  (qlonglong) ull);
 QVERIFY_SQL(q, exec());
 }
-QVERIFY(q.exec("select * from " + qTableName("qtest_bigint") + " order by id"));
+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);
 || db.driverName().startsWith("QSQLITE")
 || db.driverName().startsWith("QTDS")
 || db.driverName().startsWith("QODBC"))
 cs = true;
-QSqlRecord rec = db.record(qTableName("qtest"));
+QSqlRecord rec = db.record(qTableName("qtest", __FILE__));
 QVERIFY((int)rec.count() > 0);
 if (!cs) {
-rec = db.record(qTableName("QTEST").toUpper());
+rec = db.record(qTableName("QTEST", __FILE__).toUpper());
 QVERIFY((int)rec.count() > 0);
-rec = db.record(qTableName("qTesT"));
+rec = db.record(qTableName("qTesT", __FILE__));
 QVERIFY((int)rec.count() > 0);
 }
 #ifdef QT3_SUPPORT
-Q3SqlRecordInfo rInf = db.recordInfo(qTableName("qtest"));
+Q3SqlRecordInfo rInf = db.recordInfo(qTableName("qtest", __FILE__));
 QVERIFY((int)rInf.count() > 0);
 if (!cs) {
-rInf = db.recordInfo(qTableName("QTEST").upper());
+rInf = db.recordInfo(qTableName("QTEST", __FILE__).upper());
 QVERIFY((int)rInf.count() > 0);
-rInf = db.recordInfo(qTableName("qTesT"));
+rInf = db.recordInfo(qTableName("qTesT", __FILE__));
 QVERIFY((int)rInf.count() > 0);
 }
 #endif
-rec = db.primaryIndex(qTableName("qtest"));
+rec = db.primaryIndex(qTableName("qtest", __FILE__));
 QVERIFY((int)rec.count() > 0);
 if (!cs) {
-rec = db.primaryIndex(qTableName("QTEST").toUpper());
+rec = db.primaryIndex(qTableName("QTEST", __FILE__).toUpper());
 QVERIFY((int)rec.count() > 0);
-rec = db.primaryIndex(qTableName("qTesT"));
+rec = db.primaryIndex(qTableName("qTesT", __FILE__));
 QVERIFY((int)rec.count() > 0);
 }
 }
 void tst_QSqlDatabase::noEscapedFieldNamesInRecord()
 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");
+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()
 if(tst_Databases::isPostgreSQL(db)) {
 QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
 }
-QVERIFY_SQL(q, exec("CREATE SCHEMA " + qTableName("qtestschema")));
+QVERIFY_SQL(q, exec("CREATE SCHEMA " + qTableName("qtestschema", __FILE__)));
-QString table = qTableName("qtestschema") + '.' + qTableName("qtesttable");
+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);
 QSqlQuery q(db);
 if(tst_Databases::isPostgreSQL(db))
 QVERIFY_SQL( q, exec("set client_min_messages='warning'"));
-QString schemaName = qTableName("qtestScHeMa");
+const QString schemaName(qTableName("qtestScHeMa", __FILE__)),
-QString tableName = qTableName("qtest");
+tableName(qTableName("qtest", __FILE__)),
-QString field1Name = QString("fIeLdNaMe");
+field1Name(QLatin1String("fIeLdNaMe")),
-QString field2Name = QString("ZuLu");
+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);
 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);
-QString tableName = qTableName("batable");
+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));
 double ver=version.section(QChar::fromLatin1('.'),0,1).toDouble();
 if (ver < 7.3)
 QSKIP("Test requires PostgreSQL >= 7.3", SkipSingle);
 QSqlQuery q(db);
-QString tableName = qTableName("bug_249059");
+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")));
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
 //     DBMS_SPECIFIC(db, "QPSQL");
 QSqlQuery q(db);
-QString tableName = qTableName("qtest_prec");
+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))
 QSKIP("MySQL through ODBC-driver specific test", SkipSingle);
 return;
 }
 QSqlQuery q(db);
-QString tableName = qTableName("uint");
+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)));
 QSKIP("MS Access specific test", SkipSingle);
 return;
 }
 QSqlQuery q(db);
-QString tableName = qTableName("strings");
+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;
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
 QSqlQuery q(db);
-QString tableName = qTableName("numericfields");
+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)));
 {
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
-QString tableName = qTableName("qtest_ibaseblobs");
+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));
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
 QSqlQuery q(db);
-QString procName = qTableName("qtest_proc1");
+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));
 }
 if (!db.driverName().startsWith("QIBASE")) {
 QSKIP("InterBase specific test", SkipSingle);
 return;
 }
-QString procName = qTableName("qtest_proc2");
+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)"
 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"))));
+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"))));
+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"))));
+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"))));
+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'"));
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
 QSqlQuery q(db);
-QVERIFY_SQL(q, exec("SELECT * from " + qTableName("qtest")));
+QVERIFY_SQL(q, exec("SELECT * from " + qTableName("qtest", __FILE__)));
 QVERIFY_SQL(q, next());
 db.open();
-QVERIFY_SQL(q, exec("SELECT * from " + qTableName("qtest")));
+QVERIFY_SQL(q, exec("SELECT * from " + qTableName("qtest", __FILE__)));
 QVERIFY_SQL(q, next());
 db.open();
 }
 void tst_QSqlDatabase::odbc_bindBoolean()
 QSKIP("MySql has inconsistent behaviour of bit field type across versions.", SkipSingle);
 return;
 }
 QSqlQuery q(db);
-QVERIFY_SQL(q, exec("CREATE TABLE " + qTableName("qtestBindBool") + "(id int, boolvalue bit)"));
+QVERIFY_SQL(q, exec("CREATE TABLE " + qTableName("qtestBindBool", __FILE__) + "(id int, boolvalue bit)"));
 // Bind and insert
-QVERIFY_SQL(q, prepare("INSERT INTO " + qTableName("qtestBindBool") + " VALUES(?, ?)"));
+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") + " ORDER BY id"));
+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);
 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 " + qTableName("testqGetString") + "(id int, vcvalue varchar(MAX))"));
+QVERIFY_SQL(q, exec("CREATE TABLE " + testqGetString + "(id int, vcvalue varchar(MAX))"));
 else if(tst_Databases::isMSAccess(db))
-QVERIFY_SQL(q, exec("CREATE TABLE " + qTableName("testqGetString") + "(id int, vcvalue memo)"));
+QVERIFY_SQL(q, exec("CREATE TABLE " + testqGetString + "(id int, vcvalue memo)"));
 else
-QVERIFY_SQL(q, exec("CREATE TABLE " + qTableName("testqGetString") + "(id int, vcvalue varchar(65538))"));
+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 " + qTableName("testqGetString") + " VALUES(?, ?)"));
+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'));
 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 " + qTableName("testqGetString") + " ORDER BY id"));
+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);
 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 " + qTableName("qtest") + "; SELECT * FROM " + qTableName("qtest")));
+QVERIFY_SQL(q, exec("SELECT * FROM " + qtest + "; SELECT * FROM " + qtest));
 QVERIFY_SQL(q, next());
-QVERIFY_SQL(q, exec("SELECT * FROM " + qTableName("qtest") + "; SELECT * FROM " + qTableName("qtest")));
+QVERIFY_SQL(q, exec("SELECT * FROM " + qtest + "; SELECT * FROM " + qtest));
 QVERIFY_SQL(q, next());
-QVERIFY_SQL(q, exec("SELECT * FROM " + qTableName("qtest")));
+QVERIFY_SQL(q, exec("SELECT * FROM " + qtest));
 }
 void tst_QSqlDatabase::ibase_useCustomCharset()
 {
 QFETCH(QString, dbName);
 db.close();
 db.setConnectOptions("ISC_DPB_LC_CTYPE=Latin1");
 db.open();
-QString tableName = qTableName("latin1table");
+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);
 {
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
-QString tableName = qTableName("qtest_xmltype");
+const QString tableName(qTableName("qtest_xmltype", __FILE__));
 QString xml("<?xml version=\"1.0\"?><TABLE_NAME>MY_TABLE</TABLE_NAME>");
 QSqlQuery q(db);
 // Embedding the XML in the statement
 if(!q.exec(QString("CREATE TABLE %1(xmldata xmltype)").arg(tableName)))
 {
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
-QString tableName = qTableName("qtest");
+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);
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
 QSqlQuery q(db);
-QString creator(qTableName("CREATOR")), appuser(qTableName("APPUSER")), table1(qTableName("TABLE1"));
+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"));
 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")+" for "+creator+'.'+table1));
+QVERIFY_SQL(q3, exec("create synonym "+appuser+'.'+qTableName("synonyms", __FILE__)+" for "+creator+'.'+table1));
-QVERIFY_SQL(db3, tables().filter(qTableName("synonyms"), Qt::CaseInsensitive).count() >= 1);
+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().
 if (!tst_Databases::isSqlServer(db)) {
 QSKIP("SQL Server (ODBC) specific test", SkipSingle);
 return;
 }
-QString tableName = qTableName("qtest_sqlguid");
+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)));
 {
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
-QString tableName = qTableName("uint_table");
+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)));
 {
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
-QString procedureName = qTableName("posteventProc");
+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.
 #if defined(Q_OS_LINUX)
 QSKIP( "Event support doesn't work on linux", SkipAll );
 #endif
 QSqlQuery query(db);
-QString procedureName = qTableName("posteventProc");
+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));
 QSKIP("SQLite3 specific test", SkipSingle);
 return;
 }
 QSqlQuery q(db);
-QString tableName = qTableName("uint_test");
+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)));
 {
 QFETCH(QString, dbName);
 QSqlDatabase db = QSqlDatabase::database(dbName);
 CHECK_DATABASE(db);
-QString tableName = qTableName("qtest");
+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);
 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") + " where id = 4"));
+QVERIFY_SQL(q, exec("select * from " + qTableName("qtest", __FILE__) + " where id = 4"));
 QVERIFY_SQL(q, next());
 QSqlDriver *driver = db.driver();
 QVERIFY(driver);
 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")+" VALUES (54, 'foo', 'foo', 54.54)"));
+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);
-QString systemTableName("system."+qTableName("mypassword"));
+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"

changeset 7	f7bc934e204c
parent 3	41300fa6a67c