1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 #include <qsqldatabase.h>

    45 #include <qsqlquery.h>

    46 #include <qsqldriver.h>

    47 #ifdef QT3_SUPPORT

    48 #include <q3sqlcursor.h>

    49 #include <q3sqlrecordinfo.h>

    50 #include <q3cstring.h>

    51 #endif

    52 #include <qsqlrecord.h>

    53 #include <qsqlfield.h>

    54 #include <qsqlindex.h>

    55 #include <qregexp.h>

    56 #include <qvariant.h>

    57 #include <qdatetime.h>

    58 #include <qdebug.h>

    59 

    60 #define NODATABASE_SKIP "No database drivers are available in this Qt configuration"

    61 

    62 #include "tst_databases.h"

    63 

    64 //TESTED_FILES=

    65 

    66 QT_FORWARD_DECLARE_CLASS(QSqlDatabase)

    67 struct FieldDef;

    68 

    69 class tst_QSqlDatabase : public QObject

    70 {

    71     Q_OBJECT

    72 

    73 public:

    74     tst_QSqlDatabase();

    75     virtual ~tst_QSqlDatabase();

    76 

    77 public slots:

    78     void initTestCase();

    79     void cleanupTestCase();

    80     void init();

    81     void cleanup();

    82 private slots:

    83     void record_data() { generic_data(); }

    84     //void record();

    85     void open_data() { generic_data(); }

    86     void open();

    87     void tables_data() { generic_data(); }

    88     void tables();

    89     void oci_tables_data() { generic_data("QOCI"); }

    90     void oci_tables();

    91     void transaction_data() { generic_data(); }

    92     void transaction();

    93     void eventNotification_data() { generic_data(); }

    94     void eventNotification();

    95     void addDatabase();

    96 

    97     //database specific tests

    98     void recordMySQL_data() { generic_data("QMYSQL"); }

    99     void recordMySQL();

   100     void recordPSQL_data() { generic_data("QPSQL"); }

   101     void recordPSQL();

   102     void recordOCI_data() { generic_data("QOCI"); }

   103     void recordOCI();

   104     void recordTDS_data() { generic_data("QTDS"); }

   105     void recordTDS();

   106     void recordDB2_data() { generic_data("QDB2"); }

   107     void recordDB2();

   108     void recordSQLite_data() { generic_data("QSQLITE"); }

   109     void recordSQLite();

   110     void recordAccess_data() { generic_data("QODBC"); }

   111     void recordAccess();

   112     void recordSQLServer_data() { generic_data("QODBC"); }

   113     void recordSQLServer();

   114     void recordIBase_data() {generic_data("QIBASE"); }

   115     void recordIBase();

   116 

   117     void eventNotificationIBase_data() { generic_data("QIBASE"); }

   118     void eventNotificationIBase();

   119     void eventNotificationPSQL_data() { generic_data("QPSQL"); }

   120     void eventNotificationPSQL();

   121 

   122     //database specific 64 bit integer test

   123     void bigIntField_data() { generic_data(); }

   124     void bigIntField();

   125 

   126     // general tests

   127     void getConnectionName_data() { generic_data(); }

   128     void getConnectionName(); // For task 129992

   129 

   130     //problem specific tests

   131     void alterTable_data() { generic_data(); }

   132     void alterTable();

   133     void recordNonSelect_data() { generic_data(); }

   134     void recordNonSelect();

   135     void caseSensivity_data() { generic_data(); }

   136     void caseSensivity();

   137     void noEscapedFieldNamesInRecord_data() { generic_data(); }

   138     void noEscapedFieldNamesInRecord();

   139     void whitespaceInIdentifiers_data() { generic_data(); }

   140     void whitespaceInIdentifiers();

   141     void formatValueTrimStrings_data() { generic_data(); }

   142     void formatValueTrimStrings();

   143     void precisionPolicy_data() { generic_data(); }

   144     void precisionPolicy();

   145 

   146     void db2_valueCacheUpdate_data() { generic_data("QDB2"); }

   147     void db2_valueCacheUpdate();

   148 

   149     void psql_schemas_data() { generic_data("QPSQL"); }

   150     void psql_schemas();

   151     void psql_escapedIdentifiers_data() { generic_data("QPSQL"); }

   152     void psql_escapedIdentifiers();

   153     void psql_escapeBytea_data() { generic_data("QPSQL"); }

   154     void psql_escapeBytea();

   155     void bug_249059_data() { generic_data("QPSQL"); }

   156     void bug_249059();

   157 

   158     void mysqlOdbc_unsignedIntegers_data() { generic_data(); }

   159     void mysqlOdbc_unsignedIntegers();

   160     void mysql_multiselect_data() { generic_data("QMYSQL"); }

   161     void mysql_multiselect();  // For task 144331

   162     void mysql_savepointtest_data() { generic_data("QMYSQL"); }

   163     void mysql_savepointtest();

   164 

   165     void accessOdbc_strings_data() { generic_data(); }

   166     void accessOdbc_strings();

   167 

   168     void ibase_numericFields_data() { generic_data("QIBASE"); }

   169     void ibase_numericFields(); // For task 125053

   170     void ibase_fetchBlobs_data() { generic_data("QIBASE"); }

   171     void ibase_fetchBlobs(); // For task 143471

   172     void ibase_useCustomCharset_data() { generic_data("QIBASE"); }

   173     void ibase_useCustomCharset(); // For task 134608

   174     void ibase_procWithoutReturnValues_data() { generic_data("QIBASE"); } // For task 165423

   175     void ibase_procWithoutReturnValues();

   176     void ibase_procWithReturnValues_data() { generic_data("QIBASE"); } // For task 177530

   177     void ibase_procWithReturnValues();

   178 

   179     void odbc_reopenDatabase_data() { generic_data("QODBC"); }

   180     void odbc_reopenDatabase();

   181     void odbc_uniqueidentifier_data() { generic_data("QODBC"); }

   182     void odbc_uniqueidentifier(); // For task 141822

   183     void odbc_uintfield_data() { generic_data("QODBC"); }

   184     void odbc_uintfield();

   185     void odbc_bindBoolean_data() { generic_data("QODBC"); }

   186     void odbc_bindBoolean();

   187     void odbc_testqGetString_data() { generic_data("QODBC"); }

   188     void odbc_testqGetString();

   189 

   190     void oci_serverDetach_data() { generic_data("QOCI"); }

   191     void oci_serverDetach(); // For task 154518

   192     void oci_xmltypeSupport_data() { generic_data("QOCI"); }

   193     void oci_xmltypeSupport();

   194     void oci_fieldLength_data() { generic_data("QOCI"); }

   195     void oci_fieldLength();

   196     void oci_synonymstest_data() { generic_data("QOCI"); }

   197     void oci_synonymstest();

   198 

   199     void sqlite_bindAndFetchUInt_data() { generic_data("QSQLITE"); }

   200     void sqlite_bindAndFetchUInt();

   201 

   202     void sqlStatementUseIsNull_189093_data() { generic_data(); }

   203     void sqlStatementUseIsNull_189093();

   204 

   205     void sqlite_enable_cache_mode_data() { generic_data("QSQLITE"); }

   206     void sqlite_enable_cache_mode();

   207 

   208 private:

   209     void createTestTables(QSqlDatabase db);

   210     void dropTestTables(QSqlDatabase db);

   211     void populateTestTables(QSqlDatabase db);

   212     void generic_data(const QString &engine=QString());

   213 

   214 #ifdef QT3_SUPPORT

   215     void testRecordInfo(const FieldDef fieldDefs[], const Q3SqlRecordInfo& inf);

   216 #endif

   217     void testRecord(const FieldDef fieldDefs[], const QSqlRecord& inf, QSqlDatabase db);

   218     void commonFieldTest(const FieldDef fieldDefs[], QSqlDatabase, const int);

   219     void checkValues(const FieldDef fieldDefs[], QSqlDatabase db);

   220     void checkNullValues(const FieldDef fieldDefs[], QSqlDatabase db);

   221 

   222     tst_Databases dbs;

   223 };

   224 

   225 // number of records to be inserted per testfunction

   226 static const int ITERATION_COUNT = 2;

   227 static int pkey = 1;

   228 

   229 //helper class for database specific tests

   230 struct FieldDef {

   231     FieldDef(QString tn = QString(),

   232           QVariant::Type t = QVariant::Invalid,

   233           QVariant v = QVariant(),

   234           bool nl = true):

   235         typeName(tn), type(t), val(v), nullable(nl) {}

   236 

   237     QString fieldName() const

   238     {

   239         QString rt = typeName;

   240         rt.replace(QRegExp("\\s"), QString("_"));

   241 #ifdef QT3_SUPPORT

   242         int i = rt.find("(");

   243 #else

   244         int i = rt.indexOf("(");

   245 #endif

   246         if (i == -1)

   247             i = rt.length();

   248         if (i > 20)

   249             i = 20;

   250         return "t_" + rt.left(i);

   251     }

   252     QString typeName;

   253     QVariant::Type type;

   254     QVariant val;

   255     bool nullable;

   256 };

   257 

   258 // creates a table out of the FieldDefs and returns the number of fields

   259 // excluding the primary key field

   260 static int createFieldTable(const FieldDef fieldDefs[], QSqlDatabase db)

   261 {

   262     tst_Databases::safeDropTable(db, qTableName("qtestfields", __FILE__));

   263     QSqlQuery q(db);

   264     // construct a create table statement consisting of all fieldtypes

   265     QString qs = "create table " + qTableName("qtestfields", __FILE__);

   266     QString autoName = tst_Databases::autoFieldName(db);

   267     if (tst_Databases::isMSAccess(db))

   268         qs.append(" (id int not null");

   269     else if (tst_Databases::isPostgreSQL(db))

   270         qs.append(" (id serial not null");

   271     else

   272         qs.append(QString("(id integer not null %1 primary key").arg(autoName));

   273 

   274     int i = 0;

   275     for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {

   276         qs += QString(",\n %1 %2").arg(fieldDefs[ i ].fieldName()).arg(fieldDefs[ i ].typeName);

   277         if ((db.driverName().startsWith("QTDS") || tst_Databases::isSqlServer(db)) && fieldDefs[ i ].nullable) {

   278             qs += " null";

   279         }

   280     }

   281 

   282     if (tst_Databases::isMSAccess(db))

   283         qs.append(",\n primary key (id)");

   284 

   285     qs += ')';

   286     if (!q.exec(qs)) {

   287         qDebug() << "Creation of Table failed:" << tst_Databases::printError(q.lastError(), db);

   288         qDebug() << "Query: " << qs;

   289         return -1;

   290     }

   291     return i;

   292 }

   293 

   294 tst_QSqlDatabase::tst_QSqlDatabase()

   295 {

   296 }

   297 

   298 tst_QSqlDatabase::~tst_QSqlDatabase()

   299 {

   300 }

   301 

   302 void tst_QSqlDatabase::createTestTables(QSqlDatabase db)

   303 {

   304     if (!db.isValid())

   305     return;

   306     QSqlQuery q(db);

   307     if (db.driverName().startsWith("QMYSQL"))

   308         // ### stupid workaround until we find a way to hardcode this

   309         // in the MySQL server startup script

   310         q.exec("set table_type=innodb");

   311     else if (tst_Databases::isSqlServer(db)) {

   312         QVERIFY_SQL(q, exec("SET ANSI_DEFAULTS ON"));

   313         QVERIFY_SQL(q, exec("SET IMPLICIT_TRANSACTIONS OFF"));

   314     } else if(tst_Databases::isPostgreSQL(db))

   315         QVERIFY_SQL( q, exec("set client_min_messages='warning'"));

   316 

   317     // please never ever change this table; otherwise fix all tests ;)

   318     if (tst_Databases::isMSAccess(db)) {

   319         QVERIFY_SQL(q, exec("create table " + qTableName("qtest", __FILE__) +

   320                    " (id int not null, t_varchar varchar(40) not null, t_char char(40), "

   321                    "t_numeric number, primary key (id, t_varchar))"));

   322     } else {

   323         QVERIFY_SQL(q, exec("create table " + qTableName("qtest", __FILE__) +

   324                " (id integer not null, t_varchar varchar(40) not null, "

   325                "t_char char(40), t_numeric numeric(6, 3), primary key (id, t_varchar))"));

   326     }

   327 

   328     if (testWhiteSpaceNames(db.driverName())) {

   329         QString qry = "create table "

   330             + db.driver()->escapeIdentifier(qTableName("qtest", __FILE__) + " test", QSqlDriver::TableName)

   331             + '('

   332             + db.driver()->escapeIdentifier(QLatin1String("test test"), QSqlDriver::FieldName)

   333             + " int not null primary key)";

   334         QVERIFY_SQL(q, exec(qry));

   335     }

   336 }

   337 

   338 void tst_QSqlDatabase::dropTestTables(QSqlDatabase db)

   339 {

   340     if (!db.isValid())

   341         return;

   342 

   343     if(tst_Databases::isPostgreSQL(db)) {

   344         QSqlQuery q(db);

   345         QVERIFY_SQL( q, exec("set client_min_messages='warning'"));

   346     }

   347 

   348     // drop the view first, otherwise we'll get dependency problems

   349     tst_Databases::safeDropViews(db, QStringList() << qTableName("qtest_view", __FILE__) << qTableName("qtest_view2", __FILE__));

   350 

   351     QStringList tableNames;

   352     tableNames << qTableName("qtest", __FILE__)

   353             << qTableName("qtestfields", __FILE__)

   354             << qTableName("qtestalter", __FILE__)

   355             << qTableName("qtest_temp", __FILE__)

   356             << qTableName("qtest_bigint", __FILE__)

   357             << qTableName("qtest_xmltype", __FILE__)

   358             << qTableName("latin1table", __FILE__)

   359             << qTableName("qtest_sqlguid", __FILE__)

   360             << qTableName("batable", __FILE__)

   361             << qTableName("qtest_prec", __FILE__)

   362             << qTableName("uint", __FILE__)

   363             << qTableName("strings", __FILE__)

   364             << qTableName("numericfields", __FILE__)

   365             << qTableName("qtest_ibaseblobs", __FILE__)

   366             << qTableName("qtestBindBool", __FILE__)

   367             << qTableName("testqGetString", __FILE__)

   368             << qTableName("qtest_sqlguid", __FILE__)

   369             << qTableName("uint_table", __FILE__)

   370             << qTableName("uint_test", __FILE__)

   371             << qTableName("bug_249059", __FILE__);

   372 

   373     QSqlQuery q(0, db);

   374     if (db.driverName().startsWith("QPSQL")) {

   375         q.exec("drop schema " + qTableName("qtestschema", __FILE__) + " cascade");

   376         q.exec("drop schema " + qTableName("qtestScHeMa", __FILE__) + " cascade");

   377     }

   378 

   379     if (testWhiteSpaceNames(db.driverName()))

   380         tableNames <<  db.driver()->escapeIdentifier(qTableName("qtest", __FILE__) + " test", QSqlDriver::TableName);

   381 

   382     tst_Databases::safeDropTables(db, tableNames);

   383 

   384     if (db.driverName().startsWith("QOCI")) {

   385         q.exec("drop user "+qTableName("CREATOR", __FILE__)+" cascade");

   386         q.exec("drop user "+qTableName("APPUSER", __FILE__)+" cascade");

   387         q.exec("DROP TABLE system."+qTableName("mypassword", __FILE__));

   388 

   389     }

   390 }

   391 

   392 void tst_QSqlDatabase::populateTestTables(QSqlDatabase db)

   393 {

   394     if (!db.isValid())

   395         return;

   396     QSqlQuery q(db);

   397     const QString qtest(qTableName("qtest", __FILE__));

   398 

   399     q.exec("delete from " + qtest); //non-fatal

   400     QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (0, 'VarChar0', 'Char0', 1.1)"));

   401     QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (1, 'VarChar1', 'Char1', 2.2)"));

   402     QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (2, 'VarChar2', 'Char2', 3.3)"));

   403     QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (3, 'VarChar3', 'Char3', 4.4)"));

   404     QVERIFY_SQL(q, exec("insert into " + qtest + " (id, t_varchar, t_char, t_numeric) values (4, 'VarChar4', NULL, NULL)"));

   405 }

   406 

   407 void tst_QSqlDatabase::initTestCase()

   408 {

   409     dbs.open();

   410 

   411     for (QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it) {

   412         QSqlDatabase db = QSqlDatabase::database((*it));

   413         CHECK_DATABASE(db);

   414         dropTestTables(db); //in case of leftovers

   415         createTestTables(db);

   416         populateTestTables(db);

   417     }

   418 }

   419 

   420 void tst_QSqlDatabase::cleanupTestCase()

   421 {

   422     for (QStringList::ConstIterator it = dbs.dbNames.begin(); it != dbs.dbNames.end(); ++it) {

   423         QSqlDatabase db = QSqlDatabase::database((*it));

   424         CHECK_DATABASE(db);

   425         dropTestTables(db);

   426     }

   427 

   428     dbs.close();

   429 }

   430 

   431 void tst_QSqlDatabase::init()

   432 {

   433 }

   434 

   435 void tst_QSqlDatabase::cleanup()

   436 {

   437 }

   438 

   439 void tst_QSqlDatabase::generic_data(const QString& engine)

   440 {

   441     if ( dbs.fillTestTable(engine) == 0 ) {

   442         if(engine.isEmpty())

   443            QSKIP( "No database drivers are available in this Qt configuration", SkipAll );

   444         else

   445            QSKIP( (QString("No database drivers of type %1 are available in this Qt configuration").arg(engine)).toLocal8Bit(), SkipAll );

   446     }

   447 }

   448 

   449 void tst_QSqlDatabase::addDatabase()

   450 {

   451     QTest::ignoreMessage(QtWarningMsg, "QSqlDatabase: BLAH_FOO_NONEXISTENT_DRIVER driver not loaded");

   452     QTest::ignoreMessage(QtWarningMsg, qPrintable("QSqlDatabase: available drivers: " + QSqlDatabase::drivers().join(QLatin1String(" "))));

   453     {

   454         QSqlDatabase db = QSqlDatabase::addDatabase("BLAH_FOO_NONEXISTENT_DRIVER",

   455                                                     "INVALID_CONNECTION");

   456         QVERIFY(!db.isValid());

   457     }

   458     QVERIFY(QSqlDatabase::contains("INVALID_CONNECTION"));

   459     QSqlDatabase::removeDatabase("INVALID_CONNECTION");

   460     QVERIFY(!QSqlDatabase::contains("INVALID_CONNECTION"));

   461 }

   462 

   463 void tst_QSqlDatabase::open()

   464 {

   465     QFETCH(QString, dbName);

   466     QSqlDatabase db = QSqlDatabase::database(dbName);

   467     CHECK_DATABASE(db);

   468 

   469     int i;

   470     for (i = 0; i < 10; ++i) {

   471         db.close();

   472         QVERIFY(!db.isOpen());

   473         QVERIFY_SQL(db, open());

   474         QVERIFY(db.isOpen());

   475         QVERIFY(!db.isOpenError());

   476     }

   477 

   478     if (db.driverName().startsWith("QSQLITE") && db.databaseName() == ":memory:") {

   479         // tables in in-memory databases don't survive an open/close

   480         createTestTables(db);

   481         populateTestTables(db);

   482     }

   483 }

   484 

   485 void tst_QSqlDatabase::recordNonSelect()

   486 {

   487 #ifdef QT3_SUPPORT

   488     QFETCH(QString, dbName);

   489     QSqlDatabase db = QSqlDatabase::database(dbName);

   490     CHECK_DATABASE(db);

   491 

   492     QSqlQuery q(db);

   493 

   494     // nothing should happen on an empty query

   495     QSqlRecord rec = db.record(q);

   496     QVERIFY(rec.isEmpty());

   497     Q3SqlRecordInfo rInf = db.recordInfo(q);

   498     QVERIFY(rInf.isEmpty());

   499 

   500     QVERIFY_SQL(q, exec("create table " + qTableName("qtest_temp", __FILE__) + " (id int)"));

   501 

   502     // query without result set should return empty record

   503     rec = db.record(q);

   504     QVERIFY(rec.isEmpty());

   505     rInf = db.recordInfo(q);

   506     QVERIFY(rInf.isEmpty());

   507 #endif

   508 }

   509 

   510 void tst_QSqlDatabase::tables()

   511 {

   512     QFETCH(QString, dbName);

   513     QSqlDatabase db = QSqlDatabase::database(dbName);

   514     CHECK_DATABASE(db);

   515 

   516     const QString qtest(qTableName("qtest", __FILE__)), qtest_view(qTableName("qtest_view", __FILE__)), temp_tab(qTableName("test_tab", __FILE__));

   517 

   518     bool views = true;

   519     bool tempTables = false;

   520 

   521     QSqlQuery q(db);

   522     if ( db.driverName().startsWith( "QMYSQL" ) && tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt()<5 )

   523         QSKIP( "Test requires MySQL >= 5.0", SkipSingle );

   524 

   525 

   526     if (!q.exec("CREATE VIEW " + qtest_view + " as select * from " + qtest)) {

   527         qDebug(QString("DBMS '%1' cannot handle VIEWs: %2").arg(

   528                 tst_Databases::dbToString(db)).arg(QString(tst_Databases::printError(q.lastError()))).toLatin1());

   529         views = false;

   530     }

   531 

   532     if (db.driverName().startsWith("QSQLITE3")) {

   533         QVERIFY_SQL(q, exec("CREATE TEMPORARY TABLE " + temp_tab + " (id int)"));

   534         tempTables = true;

   535     }

   536 

   537     QStringList tables = db.tables(QSql::Tables);

   538     QVERIFY(tables.contains(qtest, Qt::CaseInsensitive));

   539     QVERIFY(!tables.contains("sql_features", Qt::CaseInsensitive)); //check for postgres 7.4 internal tables

   540     if (views) {

   541         QVERIFY(!tables.contains(qtest_view, Qt::CaseInsensitive));

   542     }

   543     if (tempTables)

   544         QVERIFY(tables.contains(temp_tab, Qt::CaseInsensitive));

   545 

   546     tables = db.tables(QSql::Views);

   547     if (views) {

   548         if(!tables.contains(qtest_view, Qt::CaseInsensitive))

   549             qDebug() << "failed to find" << qtest_view << "in" << tables;

   550         QVERIFY(tables.contains(qtest_view, Qt::CaseInsensitive));

   551     }

   552     if (tempTables)

   553         QVERIFY(!tables.contains(temp_tab, Qt::CaseInsensitive));

   554     QVERIFY(!tables.contains(qtest, Qt::CaseInsensitive));

   555 

   556     tables = db.tables(QSql::SystemTables);

   557     QVERIFY(!tables.contains(qtest, Qt::CaseInsensitive));

   558     QVERIFY(!tables.contains(qtest_view, Qt::CaseInsensitive));

   559     QVERIFY(!tables.contains(temp_tab, Qt::CaseInsensitive));

   560 

   561     tables = db.tables(QSql::AllTables);

   562     if (views)

   563         QVERIFY(tables.contains(qtest_view, Qt::CaseInsensitive));

   564     if (tempTables)

   565         QVERIFY(tables.contains(temp_tab, Qt::CaseInsensitive));

   566     QVERIFY(tables.contains(qtest, Qt::CaseInsensitive));

   567 

   568     if (db.driverName().startsWith("QPSQL")) {

   569         QVERIFY(tables.contains(qtest + " test"));

   570     }

   571 }

   572 

   573 void tst_QSqlDatabase::whitespaceInIdentifiers()

   574 {

   575     QFETCH(QString, dbName);

   576     QSqlDatabase db = QSqlDatabase::database(dbName);

   577     CHECK_DATABASE(db);

   578 

   579     if (testWhiteSpaceNames(db.driverName())) {

   580         const QString tableName(qTableName("qtest", __FILE__) + " test");

   581         QVERIFY(db.tables().contains(tableName, Qt::CaseInsensitive));

   582 

   583         QSqlRecord rec = db.record(db.driver()->escapeIdentifier(tableName, QSqlDriver::TableName));

   584         QCOMPARE(rec.count(), 1);

   585         QCOMPARE(rec.fieldName(0), QString("test test"));

   586         if(db.driverName().startsWith("QOCI"))

   587             QCOMPARE(rec.field(0).type(), QVariant::Double);

   588         else

   589             QCOMPARE(rec.field(0).type(), QVariant::Int);

   590 

   591         QSqlIndex idx = db.primaryIndex(db.driver()->escapeIdentifier(tableName, QSqlDriver::TableName));

   592         QCOMPARE(idx.count(), 1);

   593         QCOMPARE(idx.fieldName(0), QString("test test"));

   594         if(db.driverName().startsWith("QOCI"))

   595             QCOMPARE(idx.field(0).type(), QVariant::Double);

   596         else

   597             QCOMPARE(idx.field(0).type(), QVariant::Int);

   598     } else {

   599         QSKIP("DBMS does not support whitespaces in identifiers", SkipSingle);

   600     }

   601 }

   602 

   603 void tst_QSqlDatabase::alterTable()

   604 {

   605     QFETCH(QString, dbName);

   606     QSqlDatabase db = QSqlDatabase::database(dbName);

   607     CHECK_DATABASE(db);

   608     const QString qtestalter(qTableName("qtestalter", __FILE__));

   609 

   610     QSqlQuery q(db);

   611 

   612     QVERIFY_SQL(q, exec("create table " + qtestalter + " (F1 char(20), F2 char(20), F3 char(20))"));

   613     QSqlRecord rec = db.record(qtestalter);

   614     QCOMPARE((int)rec.count(), 3);

   615 #ifdef QT3_SUPPORT

   616     Q3SqlRecordInfo rinf = db.recordInfo(qtestalter);

   617     QCOMPARE((int)rinf.count(), 3);

   618 #endif

   619 

   620 

   621     int i;

   622     for (i = 0; i < 3; ++i) {

   623         QCOMPARE(rec.field(i).name().toUpper(), QString("F%1").arg(i + 1));

   624 #ifdef QT3_SUPPORT

   625         QCOMPARE(rinf[ i ].name().upper(), QString("F%1").arg(i + 1));

   626 #endif

   627     }

   628 

   629     if (!q.exec("alter table " + qtestalter + " drop column F2")) {

   630         QSKIP("DBMS doesn't support dropping columns in ALTER TABLE statement", SkipSingle);

   631     }

   632 

   633     rec = db.record(qtestalter);

   634 #ifdef QT3_SUPPORT

   635     rinf = db.recordInfo(qtestalter);

   636 #endif

   637 

   638     QCOMPARE((int)rec.count(), 2);

   639 #ifdef QT3_SUPPORT

   640     QCOMPARE((int)rinf.count(), 2);

   641 #endif

   642 

   643     QCOMPARE(rec.field(0).name().toUpper(), QString("F1"));

   644     QCOMPARE(rec.field(1).name().toUpper(), QString("F3"));

   645 #ifdef QT3_SUPPORT

   646     QCOMPARE(rinf[ 0 ].name().upper(), QString("F1"));

   647     QCOMPARE(rinf[ 1 ].name().upper(), QString("F3"));

   648 #endif

   649 

   650     q.exec("select * from " + qtestalter);

   651 

   652 #ifdef QT3_SUPPORT

   653     rec = db.record(q);

   654     rinf = db.recordInfo(q);

   655 

   656     QCOMPARE((int)rec.count(), 2);

   657     QCOMPARE((int)rinf.count(), 2);

   658 

   659     QCOMPARE(rec.field(0).name().upper(), QString("F1"));

   660     QCOMPARE(rec.field(1).name().upper(), QString("F3"));

   661     QCOMPARE(rinf[ 0 ].name().upper(), QString("F1"));

   662     QCOMPARE(rinf[ 1 ].name().upper(), QString("F3"));

   663 #endif

   664 }

   665 

   666 #if 0

   667 // this is the general test that should work on all databases.

   668 // unfortunately no DBMS supports SQL 92/ 99 so the general

   669 // test is more or less a joke. Please write a test for each

   670 // database plugin (see recordOCI and so on). Use this test

   671 // as a template.

   672 void tst_QSqlDatabase::record()

   673 {

   674     QFETCH(QString, dbName);

   675     QSqlDatabase db = QSqlDatabase::database(dbName);

   676     CHECK_DATABASE(db);

   677 

   678     static const FieldDef fieldDefs[] = {

   679         FieldDef("char(20)", QVariant::String,         QString("blah1"), false),

   680         FieldDef("varchar(20)", QVariant::String,      QString("blah2"), false),

   681         FieldDef()

   682     };

   683 

   684     const int fieldCount = createFieldTable(fieldDefs, db);

   685     QVERIFY(fieldCount > 0);

   686 

   687 // doesn't work with oracle:   checkNullValues(fieldDefs, db);

   688     commonFieldTest(fieldDefs, db, fieldCount);

   689     for (int i = 0; i < ITERATION_COUNT; ++i) {

   690         checkValues(fieldDefs, db);

   691     }

   692 }

   693 #endif

   694 

   695 #ifdef QT3_SUPPORT

   696 void tst_QSqlDatabase::testRecordInfo(const FieldDef fieldDefs[], const Q3SqlRecordInfo& inf)

   697 {

   698     int i = 0;

   699     for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {

   700         QCOMPARE(inf[i+1].name().upper(), fieldDefs[ i ].fieldName().upper());

   701         if (inf[i+1].type() != fieldDefs[ i ].type) {

   702             QFAIL(QString(" Expected: '%1' Received: '%2' for field %3 in testRecordInfo").arg(

   703             QVariant::typeToName(fieldDefs[ i ].type)).arg(

   704               QVariant::typeToName(inf[i+1].type())).arg(

   705             fieldDefs[ i ].fieldName()));

   706         }

   707     }

   708 }

   709 #endif

   710 

   711 void tst_QSqlDatabase::testRecord(const FieldDef fieldDefs[], const QSqlRecord& inf, QSqlDatabase db)

   712 {

   713     int i = 0;

   714     if (!tst_Databases::autoFieldName(db).isEmpty()) // Currently only MySQL is tested

   715         QVERIFY2(inf.field(i).isAutoValue(), qPrintable(inf.field(i).name() + " should be reporting as an autovalue"));

   716     for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {

   717         QCOMPARE(inf.field(i+1).name().toUpper(), fieldDefs[ i ].fieldName().toUpper());

   718         if (inf.field(i+1).type() != fieldDefs[ i ].type) {

   719             QFAIL(qPrintable(QString(" Expected: '%1' Received: '%2' for field %3 in testRecord").arg(

   720               QVariant::typeToName(fieldDefs[ i ].type)).arg(

   721             QVariant::typeToName(inf.field(i+1).type())).arg(

   722               fieldDefs[ i ].fieldName())));

   723         }

   724         QVERIFY(!inf.field(i+1).isAutoValue());

   725 

   726 //	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())));

   727     }

   728 }

   729 

   730 // non-dbms specific tests

   731 void tst_QSqlDatabase::commonFieldTest(const FieldDef fieldDefs[], QSqlDatabase db, const int fieldCount)

   732 {

   733     CHECK_DATABASE(db);

   734 

   735     // check whether recordInfo returns the right types

   736 #ifdef QT3_SUPPORT

   737     Q3SqlRecordInfo inf = db.recordInfo(qTableName("qtestfields", __FILE__));

   738     QCOMPARE((int)inf.count(), fieldCount+1);

   739     testRecordInfo(fieldDefs, inf);

   740 #endif

   741 

   742     QSqlRecord rec = db.record(qTableName("qtestfields", __FILE__));

   743     QCOMPARE((int)rec.count(), fieldCount+1);

   744     testRecord(fieldDefs, rec, db);

   745 

   746     QSqlQuery q(db);

   747     QVERIFY_SQL(q, exec("select * from " + qTableName("qtestfields", __FILE__)));

   748 

   749 #ifdef QT3_SUPPORT

   750     inf = db.recordInfo(q);

   751     QCOMPARE((int)inf.count(), fieldCount+1);

   752     testRecordInfo(fieldDefs, inf);

   753 

   754     rec = db.record(q);

   755     QCOMPARE((int)rec.count(), fieldCount+1);

   756     testRecord(fieldDefs, rec, db);

   757 #endif

   758 }

   759 

   760 // inserts testdata into the testtable, fetches and compares them

   761 void tst_QSqlDatabase::checkValues(const FieldDef fieldDefs[], QSqlDatabase db)

   762 {

   763     Q_UNUSED(fieldDefs);

   764 #ifdef QT3_SUPPORT

   765     CHECK_DATABASE(db);

   766 

   767     Q3SqlCursor cur(qTableName("qtestfields", __FILE__), true, db);

   768     QVERIFY_SQL(cur, select());

   769     QSqlRecord* rec = cur.primeInsert();

   770     Q_ASSERT(rec);

   771     rec->setValue("id", pkey++);

   772     int i = 0;

   773     for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {

   774         rec->setValue(fieldDefs[ i ].fieldName(), fieldDefs[ i ].val);

   775 //     qDebug(QString("inserting %1 into %2").arg(fieldDefs[ i ].val.toString()).arg(fieldDefs[ i ].fieldName()));

   776     }

   777     QVERIFY_SQL(cur, insert());

   778     cur.setForwardOnly(true);

   779     QVERIFY_SQL(cur, select("id = " + QString::number(pkey - 1)));

   780     QVERIFY_SQL(cur, next());

   781 

   782     for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {

   783         bool ok = false;

   784         QVariant val1 = cur.value(fieldDefs[ i ].fieldName());

   785         QVariant val2 = fieldDefs[ i ].val;

   786         if (val1.type() == QVariant::String)

   787             //TDS Workaround

   788             val1 = val1.toString().stripWhiteSpace();

   789         if (fieldDefs[ i ].fieldName() == "t_real") {

   790             // strip precision

   791             val1 = (float)val1.toDouble();

   792             val2 = (float)val2.toDouble();

   793         }

   794         if (val1.canCast(QVariant::Double) && val2.type() == QVariant::Double) {

   795             // we don't care about precision here, we just want to know whether

   796             // we can insert/fetch the right values

   797             ok = (val1.toDouble() - val2.toDouble() < 0.00001);

   798         } else if (val1.type() == val2.type()) {

   799                 ok = (val1 == val2);

   800         } else {

   801             ok = (val1.toString() == val2.toString());

   802         }

   803         if (!ok) {

   804             if (val2.type() == QVariant::DateTime || val2.type() == QVariant::Time)

   805                qDebug("Expected Time: " + val2.toTime().toString("hh:mm:ss.zzz"));

   806             if (val1.type() == QVariant::DateTime || val1.type() == QVariant::Time)

   807                qDebug("Received Time: " + val1.toTime().toString("hh:mm:ss.zzz"));

   808             QFAIL(QString(" Expected: '%1' Received: '%2' for field %3 (etype %4 rtype %5) in checkValues").arg(

   809             val2.type() == QVariant::ByteArray ? val2.toByteArray().toHex() : val2.toString()).arg(

   810             val1.type() == QVariant::ByteArray ? val1.toByteArray().toHex() : val1.toString()).arg(

   811             fieldDefs[ i ].fieldName()).arg(

   812             val2.typeName()).arg(

   813             val1.typeName())

   814             );

   815         }

   816     }

   817 #endif

   818 }

   819 

   820 // inserts a NULL value for each nullable field in testdata, fetches and checks whether

   821 // we get back NULL

   822 void tst_QSqlDatabase::checkNullValues(const FieldDef fieldDefs[], QSqlDatabase db)

   823 {

   824     Q_UNUSED(fieldDefs);

   825 #ifdef QT3_SUPPORT

   826     CHECK_DATABASE(db);

   827 

   828     Q3SqlCursor cur(qTableName("qtestfields", __FILE__), true, db);

   829     QVERIFY_SQL(cur, select());

   830     QSqlRecord* rec = cur.primeInsert();

   831     Q_ASSERT(rec);

   832     rec->setValue("id", pkey++);

   833     int i = 0;

   834     for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {

   835         if (fieldDefs[ i ].fieldName(), fieldDefs[ i ].nullable)

   836             rec->setNull(fieldDefs[ i ].fieldName());

   837         else

   838             rec->setValue(fieldDefs[ i ].fieldName(), fieldDefs[ i ].val);

   839     }

   840     QVERIFY_SQL(cur, insert());

   841     cur.setForwardOnly(true);

   842     QVERIFY_SQL(cur, select("id = " + QString::number(pkey - 1)));

   843     QVERIFY_SQL(cur, next());

   844 

   845     for (i = 0; !fieldDefs[ i ].typeName.isNull(); ++i) {

   846         if (fieldDefs[ i ].nullable == false)

   847             continue;

   848         // multiple inheritance sucks so much

   849         QVERIFY2(((QSqlQuery)cur).isNull(i + 1), "Check whether '" + fieldDefs[ i ].fieldName() + "' is null in QSqlQuery");

   850         QVERIFY2(((QSqlRecord)cur).isNull(fieldDefs[ i ].fieldName()), "Check whether '" + fieldDefs[ i ].fieldName() + "' is null in QSqlRecord");

   851         if (!cur.value(fieldDefs[ i ].fieldName()).isNull())

   852             qDebug(QString("QVariant is not null for NULL-Value in Field '%1'").arg(fieldDefs[ i ].fieldName()));

   853     }

   854 #endif

   855 }

   856 

   857 void tst_QSqlDatabase::recordTDS()

   858 {

   859     QFETCH(QString, dbName);

   860     QSqlDatabase db = QSqlDatabase::database(dbName);

   861     CHECK_DATABASE(db);

   862 

   863     static const FieldDef fieldDefs[] = {

   864     FieldDef("tinyint", QVariant::Int,		255),

   865     FieldDef("smallint", QVariant::Int,		32767),

   866     FieldDef("int", QVariant::Int,			2147483647),

   867     FieldDef("numeric(10,9)", QVariant::Double,	1.23456789),

   868     FieldDef("decimal(10,9)", QVariant::Double,	1.23456789),

   869     FieldDef("float(4)", QVariant::Double,		1.23456789),

   870     FieldDef("double precision", QVariant::Double,	1.23456789),

   871     FieldDef("real", QVariant::Double,		1.23456789),

   872     FieldDef("smallmoney", QVariant::Double,	100.42),

   873     FieldDef("money", QVariant::Double,		200.42),

   874     // accuracy is that of a minute

   875     FieldDef("smalldatetime", QVariant::DateTime,	QDateTime(QDate::currentDate(), QTime(1, 2, 0, 0))),

   876     // accuracy is that of a second

   877     FieldDef("datetime", QVariant::DateTime,	QDateTime(QDate::currentDate(), QTime(1, 2, 3, 0))),

   878     FieldDef("char(20)", QVariant::String,		"blah1"),

   879     FieldDef("varchar(20)", QVariant::String,	"blah2"),

   880     FieldDef("nchar(20)", QVariant::String,	"blah3"),

   881     FieldDef("nvarchar(20)", QVariant::String,	"blah4"),

   882     FieldDef("text", QVariant::String,		"blah5"),

   883 #ifdef QT3_SUPPORT

   884     FieldDef("binary(20)", QVariant::ByteArray,	Q3CString("blah6")),

   885     FieldDef("varbinary(20)", QVariant::ByteArray, Q3CString("blah7")),

   886     FieldDef("image", QVariant::ByteArray,		Q3CString("blah8")),

   887 #endif

   888     FieldDef("bit", QVariant::Int,			1, false),

   889 

   890     FieldDef()

   891     };

   892 

   893     const int fieldCount = createFieldTable(fieldDefs, db);

   894     QVERIFY(fieldCount > 0);

   895 

   896     commonFieldTest(fieldDefs, db, fieldCount);

   897     checkNullValues(fieldDefs, db);

   898     for (int i = 0; i < ITERATION_COUNT; ++i) {

   899     checkValues(fieldDefs, db);

   900     }

   901 }

   902 

   903 void tst_QSqlDatabase::recordOCI()

   904 {

   905     bool hasTimeStamp = false;

   906 

   907     QFETCH(QString, dbName);

   908     QSqlDatabase db = QSqlDatabase::database(dbName);

   909     CHECK_DATABASE(db);

   910 

   911     // runtime check for Oracle version since V8 doesn't support TIMESTAMPs

   912     if (tst_Databases::getOraVersion(db) >= 9)

   913         hasTimeStamp = true;

   914 

   915     FieldDef tsdef;

   916     FieldDef tstzdef;

   917     FieldDef tsltzdef;

   918     FieldDef intytm;

   919     FieldDef intdts;

   920 

   921     static const QDateTime dt(QDate::currentDate(), QTime(1, 2, 3, 0));

   922 

   923     if (hasTimeStamp) {

   924         tsdef = FieldDef("timestamp", QVariant::DateTime,  dt);

   925         tstzdef = FieldDef("timestamp with time zone", QVariant::DateTime, dt);

   926         tsltzdef = FieldDef("timestamp with local time zone", QVariant::DateTime, dt);

   927         intytm = FieldDef("interval year to month", QVariant::String, QString("+01-01"));

   928         intdts = FieldDef("interval day to second", QVariant::String, QString("+01 00:00:01.000000"));

   929     }

   930 

   931     const FieldDef fieldDefs[] = {

   932         FieldDef("char(20)", QVariant::String,          QString("blah1")),

   933         FieldDef("varchar(20)", QVariant::String,       QString("blah2")),

   934         FieldDef("nchar(20)", QVariant::String,         QString("blah3")),

   935         FieldDef("nvarchar2(20)", QVariant::String,     QString("blah4")),

   936         FieldDef("number(10,5)", QVariant::Double,      1.1234567),

   937         FieldDef("date", QVariant::DateTime,            dt),

   938         FieldDef("long raw", QVariant::ByteArray,       QByteArray("blah5")),

   939         FieldDef("raw(2000)", QVariant::ByteArray,      QByteArray("blah6"), false),

   940         FieldDef("blob", QVariant::ByteArray,           QByteArray("blah7")),

   941         FieldDef("clob", QVariant::String,             QString("blah8")),

   942         FieldDef("nclob", QVariant::String,            QString("blah9")),

   943 //        FieldDef("bfile", QVariant::ByteArray,         QByteArray("blah10")),

   944 

   945         intytm,

   946         intdts,

   947         tsdef,

   948         tstzdef,

   949         tsltzdef,

   950         FieldDef()

   951     };

   952 

   953     const int fieldCount = createFieldTable(fieldDefs, db);

   954     QVERIFY(fieldCount > 0);

   955 

   956     commonFieldTest(fieldDefs, db, fieldCount);

   957     checkNullValues(fieldDefs, db);

   958     for (int i = 0; i < ITERATION_COUNT; ++i)

   959         checkValues(fieldDefs, db);

   960 

   961     // some additional tests

   962     QSqlRecord rec = db.record(qTableName("qtestfields", __FILE__));

   963     QCOMPARE(rec.field("T_NUMBER").length(), 10);

   964     QCOMPARE(rec.field("T_NUMBER").precision(), 5);

   965 

   966     QSqlQuery q(db);

   967     QVERIFY_SQL(q, exec("SELECT * FROM " + qTableName("qtestfields", __FILE__)));

   968     rec = q.record();

   969     QCOMPARE(rec.field("T_NUMBER").length(), 10);

   970     QCOMPARE(rec.field("T_NUMBER").precision(), 5);

   971 }

   972 

   973 void tst_QSqlDatabase::recordPSQL()

   974 {

   975     QFETCH(QString, dbName);

   976     QSqlDatabase db = QSqlDatabase::database(dbName);

   977     CHECK_DATABASE(db);

   978 

   979     FieldDef byteadef;

   980     if (db.driver()->hasFeature(QSqlDriver::BLOB))

   981 #ifdef QT3_SUPPORT

   982     byteadef = FieldDef("bytea", QVariant::ByteArray, QByteArray(Q3CString("bl\\ah")));

   983 #else

   984         byteadef = FieldDef("bytea", QVariant::ByteArray, QByteArray("bl\\ah"));

   985 #endif

   986     static FieldDef fieldDefs[] = {

   987     FieldDef("bigint", QVariant::LongLong,	Q_INT64_C(9223372036854775807)),

   988     FieldDef("bigserial", QVariant::LongLong, 100, false),

   989     FieldDef("bit", QVariant::String,	"1"), // a bit in postgres is a bit-string

   990 #ifdef QT3_SUPPORT

   991     FieldDef("boolean", QVariant::Bool,	QVariant(bool(true), 0)),

   992 #endif

   993     FieldDef("box", QVariant::String,	"(5,6),(1,2)"),

   994     FieldDef("char(20)", QVariant::String, "blah5678901234567890"),

   995     FieldDef("varchar(20)", QVariant::String, "blah5678901234567890"),

   996     FieldDef("cidr", QVariant::String,	"12.123.0.0/24"),

   997     FieldDef("circle", QVariant::String,	"<(1,2),3>"),

   998     FieldDef("date", QVariant::Date,	QDate::currentDate()),

   999     FieldDef("float8", QVariant::Double,	1.12345678912),

  1000     FieldDef("inet", QVariant::String,	"12.123.12.23"),

  1001     FieldDef("integer", QVariant::Int,	2147483647),

  1002     FieldDef("interval", QVariant::String, "1 day 12:59:10"),

  1003 //	LOL... you can create a "line" datatype in PostgreSQL <= 7.2.x but

  1004 //	as soon as you want to insert data you get a "not implemented yet" error

  1005 //	FieldDef("line", QVariant::Polygon, QPolygon(QRect(1, 2, 3, 4))),

  1006     FieldDef("lseg", QVariant::String,     "[(1,1),(2,2)]"),

  1007     FieldDef("macaddr", QVariant::String, "08:00:2b:01:02:03"),

  1008     FieldDef("money", QVariant::String,	"$12.23"),

  1009     FieldDef("numeric", QVariant::Double,  1.2345678912),

  1010     FieldDef("path", QVariant::String,	"((1,2),(3,2),(3,5),(1,5))"),

  1011     FieldDef("point", QVariant::String,	"(1,2)"),

  1012     FieldDef("polygon", QVariant::String,	"((1,2),(3,2),(3,5),(1,5))"),

  1013     FieldDef("real", QVariant::Double,	1.1234),

  1014     FieldDef("smallint", QVariant::Int,	32767),

  1015     FieldDef("serial", QVariant::Int,	100, false),

  1016     FieldDef("text", QVariant::String,	"blah"),

  1017     FieldDef("time(6)", QVariant::Time,	QTime(1, 2, 3)),

  1018     FieldDef("timetz", QVariant::Time,	QTime(1, 2, 3)),

  1019     FieldDef("timestamp(6)", QVariant::DateTime, QDateTime::currentDateTime()),

  1020     FieldDef("timestamptz", QVariant::DateTime, QDateTime::currentDateTime()),

  1021     byteadef,

  1022 

  1023     FieldDef()

  1024     };

  1025 

  1026     QSqlQuery q(db);

  1027 

  1028     if(tst_Databases::isPostgreSQL(db))

  1029         QVERIFY_SQL( q, exec("set client_min_messages='warning'"));

  1030 

  1031     q.exec("drop sequence " + qTableName("qtestfields", __FILE__) + "_t_bigserial_seq");

  1032     q.exec("drop sequence " + qTableName("qtestfields", __FILE__) + "_t_serial_seq");

  1033     // older psql cut off the table name

  1034     q.exec("drop sequence " + qTableName("qtestfields", __FILE__).left(15) + "_t_bigserial_seq");

  1035     q.exec("drop sequence " + qTableName("qtestfields", __FILE__).left(18) + "_t_serial_seq");

  1036 

  1037     const int fieldCount = createFieldTable(fieldDefs, db);

  1038     QVERIFY(fieldCount > 0);

  1039 

  1040     commonFieldTest(fieldDefs, db, fieldCount);

  1041     checkNullValues(fieldDefs, db);

  1042     for (int i = 0; i < ITERATION_COUNT; ++i) {

  1043     // increase serial values

  1044     for (int i2 = 0; !fieldDefs[ i2 ].typeName.isNull(); ++i2) {

  1045         if (fieldDefs[ i2 ].typeName == "serial" ||

  1046          fieldDefs[ i2 ].typeName == "bigserial") {

  1047 

  1048         FieldDef def = fieldDefs[ i2 ];

  1049 #ifdef QT3_SUPPORT

  1050         def.val = def.val.asInt() + 1;

  1051 #else

  1052         def.val = def.val.toInt() + 1;

  1053 #endif

  1054         fieldDefs[ i2 ] = def;

  1055         }

  1056     }

  1057     checkValues(fieldDefs, db);

  1058     }

  1059 }

  1060 

  1061 void tst_QSqlDatabase::recordMySQL()

  1062 {

  1063     QFETCH(QString, dbName);

  1064     QSqlDatabase db = QSqlDatabase::database(dbName);

  1065     CHECK_DATABASE(db);

  1066 

  1067     FieldDef bin10, varbin10;

  1068     int major = tst_Databases::getMySqlVersion( db ).section( QChar('.'), 0, 0 ).toInt();

  1069     int minor = tst_Databases::getMySqlVersion( db ).section( QChar('.'), 1, 1 ).toInt();

  1070     int revision = tst_Databases::getMySqlVersion( db ).section( QChar('.'), 2, 2 ).toInt();

  1071     int vernum = (major << 16) + (minor << 8) + revision;

  1072 

  1073     /* The below is broken in mysql below 5.0.15

  1074         see http://dev.mysql.com/doc/refman/5.0/en/binary-varbinary.html

  1075         specifically: Before MySQL 5.0.15, the pad value is space. Values are right-padded

  1076         with space on insert, and trailing spaces are removed on select.

  1077     */

  1078     if( vernum >= ((5 << 16) + 15) ) {

  1079 #ifdef QT3_SUPPORT

  1080         bin10 = FieldDef("binary(10)", QVariant::ByteArray, QByteArray(Q3CString("123abc    ")));

  1081         varbin10 = FieldDef("varbinary(10)", QVariant::ByteArray, QByteArray(Q3CString("123abcv   ")));

  1082 #else

  1083         bin10 = FieldDef("binary(10)", QVariant::ByteArray, QString("123abc    "));

  1084         varbin10 = FieldDef("varbinary(10)", QVariant::ByteArray, QString("123abcv   "));

  1085 #endif

  1086     }

  1087 

  1088     static QDateTime dt(QDate::currentDate(), QTime(1, 2, 3, 0));

  1089     static const FieldDef fieldDefs[] = {

  1090     FieldDef("tinyint", QVariant::Int,	    127),

  1091     FieldDef("tinyint unsigned", QVariant::UInt, 255),

  1092     FieldDef("smallint", QVariant::Int,	    32767),

  1093     FieldDef("smallint unsigned", QVariant::UInt, 65535),

  1094     FieldDef("mediumint", QVariant::Int,	    8388607),

  1095     FieldDef("mediumint unsigned", QVariant::UInt, 16777215),

  1096     FieldDef("integer", QVariant::Int,	    2147483647),

  1097     FieldDef("integer unsigned", QVariant::UInt, 4294967295u),

  1098     FieldDef("bigint", QVariant::LongLong,	    Q_INT64_C(9223372036854775807)),

  1099     FieldDef("bigint unsigned", QVariant::ULongLong, Q_UINT64_C(18446744073709551615)),

  1100     FieldDef("float", QVariant::Double,	    1.12345),

  1101     FieldDef("double", QVariant::Double,	    1.123456789),

  1102     FieldDef("decimal(10, 9)", QVariant::Double,1.123456789),

  1103     FieldDef("numeric(5, 2)", QVariant::Double, 123.67),

  1104     FieldDef("date", QVariant::Date,	    QDate::currentDate()),

  1105     FieldDef("datetime", QVariant::DateTime,   dt),

  1106     FieldDef("timestamp", QVariant::DateTime,  dt, false),

  1107     FieldDef("time", QVariant::Time,	    dt.time()),

  1108     FieldDef("year", QVariant::Int,	    2003),

  1109     FieldDef("char(20)", QVariant::String,	    "Blah"),

  1110     FieldDef("varchar(20)", QVariant::String,  "BlahBlah"),

  1111 #ifdef QT3_SUPPORT

  1112     FieldDef("tinyblob", QVariant::ByteArray,  QByteArray(Q3CString("blah1"))),

  1113     FieldDef("blob", QVariant::ByteArray,	    QByteArray(Q3CString("blah2"))),

  1114     FieldDef("mediumblob", QVariant::ByteArray,QByteArray(Q3CString("blah3"))),

  1115     FieldDef("longblob", QVariant::ByteArray,  QByteArray(Q3CString("blah4"))),

  1116 #endif

  1117     FieldDef("tinytext", QVariant::String,    QString("blah5")),

  1118     FieldDef("text", QVariant::String,	    QString("blah6")),

  1119     FieldDef("mediumtext", QVariant::String,  QString("blah7")),

  1120     FieldDef("longtext", QVariant::String,    QString("blah8")),

  1121 #ifdef QT3_SUPPORT

  1122     bin10,

  1123     varbin10,

  1124 #endif

  1125     // SET OF?

  1126 

  1127     FieldDef()

  1128     };

  1129 

  1130     const int fieldCount = createFieldTable(fieldDefs, db);

  1131     QVERIFY(fieldCount > 0);

  1132 

  1133     commonFieldTest(fieldDefs, db, fieldCount);

  1134     checkNullValues(fieldDefs, db);

  1135     for (int i = 0; i < ITERATION_COUNT; ++i) {