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

     2 **

     3 ** Copyright (C) 2009 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 transaction_data() { generic_data(); }

    90     void transaction();

    91     void eventNotification_data() { generic_data(); }

    92     void eventNotification();

    93     void addDatabase();

    94 

    95     //database specific tests

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

    97     void recordMySQL();

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

    99     void recordPSQL();

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

   101     void recordOCI();

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

   103     void recordTDS();

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

   105     void recordDB2();

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

   107     void recordSQLite();

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

   109     void recordAccess();

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

   111     void recordSQLServer();

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

   113     void recordIBase();

   114 

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

   116     void eventNotificationIBase();

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

   118     void eventNotificationPSQL();

   119 

   120     //database specific 64 bit integer test

   121     void bigIntField_data() { generic_data(); }

   122     void bigIntField();

   123 

   124     // general tests

   125     void getConnectionName_data() { generic_data(); }

   126     void getConnectionName(); // For task 129992

   127 

   128     //problem specific tests

   129     void alterTable_data() { generic_data(); }

   130     void alterTable();

   131     void recordNonSelect_data() { generic_data(); }

   132     void recordNonSelect();

   133     void caseSensivity_data() { generic_data(); }

   134     void caseSensivity();

   135     void noEscapedFieldNamesInRecord_data() { generic_data(); }

   136     void noEscapedFieldNamesInRecord();

   137     void whitespaceInIdentifiers_data() { generic_data(); }

   138     void whitespaceInIdentifiers();

   139     void formatValueTrimStrings_data() { generic_data(); }

   140     void formatValueTrimStrings();

   141     void precisionPolicy_data() { generic_data(); }

   142     void precisionPolicy();

   143 

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

   145     void db2_valueCacheUpdate();

   146 

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

   148     void psql_schemas();

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

   150     void psql_escapedIdentifiers();

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

   152     void psql_escapeBytea();

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

   154     void bug_249059();

   155 

   156     void mysqlOdbc_unsignedIntegers_data() { generic_data(); }

   157     void mysqlOdbc_unsignedIntegers();

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

   159     void mysql_multiselect();  // For task 144331

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

   161     void mysql_savepointtest();

   162 

   163     void accessOdbc_strings_data() { generic_data(); }

   164     void accessOdbc_strings();

   165 

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

   167     void ibase_numericFields(); // For task 125053

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

   169     void ibase_fetchBlobs(); // For task 143471

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

   171     void ibase_useCustomCharset(); // For task 134608

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

   173     void ibase_procWithoutReturnValues();

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

   175     void ibase_procWithReturnValues();

   176 

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

   178     void odbc_reopenDatabase();

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

   180     void odbc_uniqueidentifier(); // For task 141822

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

   182     void odbc_uintfield();

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

   184     void odbc_bindBoolean();

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

   186     void odbc_testqGetString();

   187 

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

   189     void oci_serverDetach(); // For task 154518

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

   191     void oci_xmltypeSupport();

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

   193     void oci_fieldLength();

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

   195     void oci_synonymstest();

   196 

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

   198     void sqlite_bindAndFetchUInt();

   199 

   200     void sqlStatementUseIsNull_189093_data() { generic_data(); }

   201     void sqlStatementUseIsNull_189093();

   202 

   203 

   204 private:

   205     void createTestTables(QSqlDatabase db);

   206     void dropTestTables(QSqlDatabase db);

   207     void populateTestTables(QSqlDatabase db);

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

   209 

   210 #ifdef QT3_SUPPORT

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

   212 #endif

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

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

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

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

   217 

   218     tst_Databases dbs;

   219 };

   220 

   221 // number of records to be inserted per testfunction

   222 static const int ITERATION_COUNT = 2;

   223 static int pkey = 1;

   224 

   225 //helper class for database specific tests

   226 struct FieldDef {

   227     FieldDef(QString tn = QString(),

   228           QVariant::Type t = QVariant::Invalid,

   229           QVariant v = QVariant(),

   230           bool nl = true):

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

   232 

   233     QString fieldName() const

   234     {

   235         QString rt = typeName;

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

   237 #ifdef QT3_SUPPORT

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

   239 #else

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

   241 #endif

   242         if (i == -1)

   243             i = rt.length();

   244         if (i > 20)

   245             i = 20;

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

   247     }

   248     QString typeName;

   249     QVariant::Type type;

   250     QVariant val;

   251     bool nullable;

   252 };

   253 

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

   255 // excluding the primary key field

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

   257 {

   258     tst_Databases::safeDropTable(db, qTableName("qtestfields"));

   259     QSqlQuery q(db);

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

   261     QString qs = "create table " + qTableName("qtestfields");

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

   263     if (tst_Databases::isMSAccess(db))

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

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

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

   267     else

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

   269 

   270     int i = 0;

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

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

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

   274             qs += " null";

   275         }

   276     }

   277 

   278     if (tst_Databases::isMSAccess(db))

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

   280 

   281     qs += ')';

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

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

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

   285         return -1;

   286     }

   287     return i;

   288 }

   289 

   290 tst_QSqlDatabase::tst_QSqlDatabase()

   291 {

   292 }

   293 

   294 tst_QSqlDatabase::~tst_QSqlDatabase()

   295 {

   296 }

   297 

   298 void tst_QSqlDatabase::createTestTables(QSqlDatabase db)

   299 {

   300     if (!db.isValid())

   301     return;

   302     QSqlQuery q(db);

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

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

   305         // in the MySQL server startup script

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

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

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

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

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

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

   312 

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

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

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

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

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

   318     } else {

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

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

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

   322     }

   323 

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

   325         QString qry = "create table "

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

   327             + '('

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

   329             + " int not null primary key)";

   330         QVERIFY_SQL(q, exec(qry));

   331     }

   332 }

   333 

   334 void tst_QSqlDatabase::dropTestTables(QSqlDatabase db)

   335 {

   336     if (!db.isValid())

   337         return;

   338 

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

   340         QSqlQuery q(db);

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

   342     }

   343 

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

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

   346 

   347     QStringList tableNames;

   348     tableNames << qTableName("qtest")

   349             << qTableName("qtestfields")

   350             << qTableName("qtestalter")

   351             << qTableName("qtest_temp")

   352             << qTableName("qtest_bigint")

   353             << qTableName("qtest_xmltype")

   354             << qTableName("latin1table")

   355             << qTableName("qtest_sqlguid")

   356             << qTableName("batable")

   357             << qTableName("qtest_prec")

   358             << qTableName("uint")

   359             << qTableName("strings")

   360             << qTableName("numericfields")

   361             << qTableName("qtest_ibaseblobs")

   362             << qTableName("qtestBindBool")

   363             << qTableName("testqGetString")

   364             << qTableName("qtest_sqlguid")

   365             << qTableName("uint_table")

   366             << qTableName("uint_test")

   367             << qTableName("bug_249059");

   368 

   369     QSqlQuery q(0, db);

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

   371         q.exec("drop schema " + qTableName("qtestschema") + " cascade");

   372         q.exec("drop schema " + qTableName("qtestScHeMa") + " cascade");

   373     }

   374 

   375     if (testWhiteSpaceNames(db.driverName()))

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

   377 

   378     tst_Databases::safeDropTables(db, tableNames);

   379 

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

   381         q.exec("drop user "+qTableName("CREATOR")+" cascade");

   382         q.exec("drop user "+qTableName("APPUSER")+" cascade");

   383 

   384     }

   385 }

   386 

   387 void tst_QSqlDatabase::populateTestTables(QSqlDatabase db)

   388 {

   389     if (!db.isValid())

   390         return;

   391     QSqlQuery q(db);

   392 

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

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

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

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

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

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

   399 }

   400 

   401 void tst_QSqlDatabase::initTestCase()

   402 {

   403     dbs.open();

   404 

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

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

   407         CHECK_DATABASE(db);

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

   409         createTestTables(db);

   410         populateTestTables(db);

   411     }

   412 }

   413 

   414 void tst_QSqlDatabase::cleanupTestCase()

   415 {

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

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

   418         CHECK_DATABASE(db);

   419         dropTestTables(db);

   420     }

   421 

   422     dbs.close();

   423 }

   424 

   425 void tst_QSqlDatabase::init()

   426 {

   427 }

   428 

   429 void tst_QSqlDatabase::cleanup()

   430 {

   431 }

   432 

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

   434 {

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

   436         if(engine.isEmpty())

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

   438         else

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

   440     }

   441 }

   442 

   443 void tst_QSqlDatabase::addDatabase()

   444 {

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

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

   447     {

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

   449                                                     "INVALID_CONNECTION");

   450         QVERIFY(!db.isValid());

   451     }

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

   453     QSqlDatabase::removeDatabase("INVALID_CONNECTION");

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

   455 }

   456 

   457 void tst_QSqlDatabase::open()

   458 {

   459     QFETCH(QString, dbName);

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

   461     CHECK_DATABASE(db);

   462 

   463     int i;

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

   465         db.close();

   466         QVERIFY(!db.isOpen());

   467         QVERIFY_SQL(db, open());

   468         QVERIFY(db.isOpen());

   469         QVERIFY(!db.isOpenError());

   470     }

   471 

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

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

   474         createTestTables(db);

   475         populateTestTables(db);

   476     }

   477 }

   478 

   479 void tst_QSqlDatabase::recordNonSelect()

   480 {

   481 #ifdef QT3_SUPPORT

   482     QFETCH(QString, dbName);

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

   484     CHECK_DATABASE(db);

   485 

   486     QSqlQuery q(db);

   487 

   488     // nothing should happen on an empty query

   489     QSqlRecord rec = db.record(q);

   490     QVERIFY(rec.isEmpty());

   491     Q3SqlRecordInfo rInf = db.recordInfo(q);

   492     QVERIFY(rInf.isEmpty());

   493 

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

   495 

   496     // query without result set should return empty record

   497     rec = db.record(q);

   498     QVERIFY(rec.isEmpty());

   499     rInf = db.recordInfo(q);

   500     QVERIFY(rInf.isEmpty());

   501 #endif

   502 }

   503 

   504 void tst_QSqlDatabase::tables()

   505 {

   506     QFETCH(QString, dbName);

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

   508     CHECK_DATABASE(db);

   509 

   510     bool views = true;

   511     bool tempTables = false;

   512 

   513     QSqlQuery q(db);

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

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

   516 

   517 

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

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

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

   521         views = false;

   522     }

   523 

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

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

   526         tempTables = true;

   527     }

   528 

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

   530     QVERIFY(tables.contains(qTableName("qtest"), Qt::CaseInsensitive));

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

   532     if (views) {

   533         QVERIFY(!tables.contains(qTableName("qtest_view"), Qt::CaseInsensitive));

   534     }

   535     if (tempTables)

   536         QVERIFY(tables.contains(qTableName("temp_tab"), Qt::CaseInsensitive));

   537 

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

   539     if (views) {

   540         if(!tables.contains(qTableName("qtest_view"), Qt::CaseInsensitive))

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

   542         QVERIFY(tables.contains(qTableName("qtest_view"), Qt::CaseInsensitive));

   543     }

   544     if (tempTables)

   545         QVERIFY(!tables.contains(qTableName("temp_tab"), Qt::CaseInsensitive));

   546     QVERIFY(!tables.contains(qTableName("qtest"), Qt::CaseInsensitive));

   547 

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

   549     QVERIFY(!tables.contains(qTableName("qtest"), Qt::CaseInsensitive));

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

   551     QVERIFY(!tables.contains(qTableName("temp_tab"), Qt::CaseInsensitive));

   552 

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

   554     if (views)

   555         QVERIFY(tables.contains(qTableName("qtest_view"), Qt::CaseInsensitive));

   556     if (tempTables)

   557         QVERIFY(tables.contains(qTableName("temp_tab"), Qt::CaseInsensitive));

   558     QVERIFY(tables.contains(qTableName("qtest"), Qt::CaseInsensitive));

   559 

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

   561         QVERIFY(tables.contains(qTableName("qtest") + " test"));

   562     }

   563 }

   564 

   565 void tst_QSqlDatabase::whitespaceInIdentifiers()

   566 {

   567     QFETCH(QString, dbName);

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

   569     CHECK_DATABASE(db);

   570 

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

   572         QString tableName = qTableName("qtest") + " test";

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

   574 

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

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

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

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

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

   580         else

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

   582 

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

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

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

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

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

   588         else

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

   590     } else {

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

   592     }

   593 }

   594 

   595 void tst_QSqlDatabase::alterTable()

   596 {

   597     QFETCH(QString, dbName);

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

   599     CHECK_DATABASE(db);

   600 

   601     QSqlQuery q(db);

   602 

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

   604     QSqlRecord rec = db.record(qTableName("qtestalter"));

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

   606 #ifdef QT3_SUPPORT

   607     Q3SqlRecordInfo rinf = db.recordInfo(qTableName("qtestalter"));

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

   609 #endif

   610 

   611 

   612     int i;

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

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

   615 #ifdef QT3_SUPPORT

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

   617 #endif

   618     }

   619 

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

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

   622     }

   623 

   624     rec = db.record(qTableName("qtestalter"));

   625 #ifdef QT3_SUPPORT

   626     rinf = db.recordInfo(qTableName("qtestalter"));

   627 #endif

   628 

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

   630 #ifdef QT3_SUPPORT

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

   632 #endif

   633 

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

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

   636 #ifdef QT3_SUPPORT

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

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

   639 #endif

   640 

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

   642 

   643 #ifdef QT3_SUPPORT

   644     rec = db.record(q);

   645     rinf = db.recordInfo(q);

   646 

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

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

   649 

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

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

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

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

   654 #endif

   655 }

   656 

   657 #if 0

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

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

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

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

   662 // as a template.

   663 void tst_QSqlDatabase::record()

   664 {

   665     QFETCH(QString, dbName);

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

   667     CHECK_DATABASE(db);

   668 

   669     static const FieldDef fieldDefs[] = {

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

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

   672         FieldDef()

   673     };

   674 

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

   676     QVERIFY(fieldCount > 0);

   677 

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

   679     commonFieldTest(fieldDefs, db, fieldCount);

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

   681         checkValues(fieldDefs, db);

   682     }

   683 }

   684 #endif

   685 

   686 #ifdef QT3_SUPPORT

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

   688 {

   689     int i = 0;

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

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

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

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

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

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

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

   697         }

   698     }

   699 }

   700 #endif

   701 

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

   703 {

   704     int i = 0;

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

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

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

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

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

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

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

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

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

   714         }

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

   716 

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

   718     }

   719 }

   720 

   721 // non-dbms specific tests

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

   723 {

   724     CHECK_DATABASE(db);

   725 

   726     // check whether recordInfo returns the right types

   727 #ifdef QT3_SUPPORT

   728     Q3SqlRecordInfo inf = db.recordInfo(qTableName("qtestfields"));

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

   730     testRecordInfo(fieldDefs, inf);

   731 #endif

   732 

   733     QSqlRecord rec = db.record(qTableName("qtestfields"));

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

   735     testRecord(fieldDefs, rec, db);

   736 

   737     QSqlQuery q(db);

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

   739 

   740 #ifdef QT3_SUPPORT

   741     inf = db.recordInfo(q);

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

   743     testRecordInfo(fieldDefs, inf);

   744 

   745     rec = db.record(q);

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

   747     testRecord(fieldDefs, rec, db);

   748 #endif

   749 }

   750 

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

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

   753 {

   754     Q_UNUSED(fieldDefs);

   755 #ifdef QT3_SUPPORT

   756     CHECK_DATABASE(db);

   757 

   758     Q3SqlCursor cur(qTableName("qtestfields"), true, db);

   759     QVERIFY_SQL(cur, select());

   760     QSqlRecord* rec = cur.primeInsert();

   761     Q_ASSERT(rec);

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

   763     int i = 0;

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

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

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

   767     }

   768     if (!cur.insert()) {

   769         QFAIL(QString("Couldn't insert record: %1 %2").arg(cur.lastError().databaseText()).arg(cur.lastError().driverText()));

   770     }

   771     cur.setForwardOnly(true);

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

   773     QVERIFY_SQL(cur, next());

   774 

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

   776         bool ok = false;

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

   778         QVariant val2 = fieldDefs[ i ].val;

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

   780             //TDS Workaround

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

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

   783             // strip precision

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

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

   786         }

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

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

   789             // we can insert/fetch the right values

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

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

   792                 ok = (val1 == val2);

   793         } else {

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

   795         }

   796         if (!ok) {

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

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

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

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

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

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

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

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

   805             val2.typeName()).arg(

   806             val1.typeName())

   807             );

   808         }

   809     }

   810 #endif

   811 }

   812 

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

   814 // we get back NULL

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

   816 {

   817     Q_UNUSED(fieldDefs);

   818 #ifdef QT3_SUPPORT

   819     CHECK_DATABASE(db);

   820 

   821     Q3SqlCursor cur(qTableName("qtestfields"), true, db);

   822     QVERIFY_SQL(cur, select());

   823     QSqlRecord* rec = cur.primeInsert();

   824     Q_ASSERT(rec);

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

   826     int i = 0;

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

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

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

   830         else

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

   832     }

   833     if (!cur.insert()) {

   834         QFAIL(QString("Couldn't insert record: %1 %2").arg(cur.lastError().databaseText()).arg(cur.lastError().driverText()));

   835     }

   836     cur.setForwardOnly(true);

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

   838     QVERIFY_SQL(cur, next());

   839 

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

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

   842             continue;

   843         // multiple inheritance sucks so much

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

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

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

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

   848     }

   849 #endif

   850 }

   851 

   852 void tst_QSqlDatabase::recordTDS()

   853 {

   854     QFETCH(QString, dbName);

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

   856     CHECK_DATABASE(db);

   857 

   858     static const FieldDef fieldDefs[] = {

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

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

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

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

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

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

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

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

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

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

   869     // accuracy is that of a minute

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

   871     // accuracy is that of a second

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

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

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

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

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

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

   878 #ifdef QT3_SUPPORT

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

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

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

   882 #endif

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

   884 

   885     FieldDef()

   886     };

   887 

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

   889     QVERIFY(fieldCount > 0);

   890 

   891     commonFieldTest(fieldDefs, db, fieldCount);

   892     checkNullValues(fieldDefs, db);

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

   894     checkValues(fieldDefs, db);

   895     }

   896 }

   897 

   898 void tst_QSqlDatabase::recordOCI()

   899 {

   900     bool hasTimeStamp = false;

   901 

   902     QFETCH(QString, dbName);

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

   904     CHECK_DATABASE(db);

   905 

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

   907     if (tst_Databases::getOraVersion(db) >= 9) {

   908     qDebug("Detected Oracle >= 9, TIMESTAMP test enabled");

   909     hasTimeStamp = true;

   910     } else {

   911     qDebug("Detected Oracle < 9, TIMESTAMP test disabled");

   912     }

   913 

   914     FieldDef tsdef;

   915     FieldDef tstzdef;

   916     FieldDef tsltzdef;

   917     FieldDef intytm;

   918     FieldDef intdts;

   919 

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

   921 

   922     if (hasTimeStamp) {

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

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

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

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

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

   928     }

   929 

   930     const FieldDef fieldDefs[] = {

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

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

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

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

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

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

   937 #ifdef QT3_SUPPORT

   938 //X?    FieldDef("long raw", QVariant::ByteArray,       QByteArray(Q3CString("blah5"))),

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

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

   941 #endif

   942 //FIXME FieldDef("clob", QVariant::CString,             Q3CString("blah8")),

   943 //FIXME FieldDef("nclob", QVariant::CString,            Q3CString("blah9")),

   944 //X     FieldDef("bfile", QVariant::ByteArray,          QByteArray(Q3CString("blah10"))),

   945 

   946     intytm,

   947     intdts,

   948     tsdef,

   949     tstzdef,

   950     tsltzdef,

   951     FieldDef()

   952     };

   953 

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

   955     QVERIFY(fieldCount > 0);

   956 

   957     commonFieldTest(fieldDefs, db, fieldCount);

   958     checkNullValues(fieldDefs, db);

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

   960     checkValues(fieldDefs, db);

   961     }

   962 

   963     // some additional tests

   964     QSqlRecord rec = db.record(qTableName("qtestfields"));

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

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

   967 

   968     QSqlQuery q(db);

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

   970     rec = q.record();

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

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

   973 }

   974 

   975 void tst_QSqlDatabase::recordPSQL()

   976 {

   977     QFETCH(QString, dbName);

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

   979     CHECK_DATABASE(db);

   980 

   981     FieldDef byteadef;

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

   983 #ifdef QT3_SUPPORT

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

   985 #else

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

   987 #endif

   988     static FieldDef fieldDefs[] = {

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

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

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

   992 #ifdef QT3_SUPPORT

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

   994 #endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1023     byteadef,

  1024 

  1025     FieldDef()

  1026     };

  1027 

  1028     QSqlQuery q(db);

  1029 

  1030     if(tst_Databases::isPostgreSQL(db))

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

  1032 

  1033     q.exec("drop sequence " + qTableName("qtestfields") + "_t_bigserial_seq");

  1034     q.exec("drop sequence " + qTableName("qtestfields") + "_t_serial_seq");

  1035     // older psql cut off the table name

  1036     q.exec("drop sequence " + qTableName("qtestfields").left(15) + "_t_bigserial_seq");

  1037     q.exec("drop sequence " + qTableName("qtestfields").left(18) + "_t_serial_seq");

  1038 

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

  1040     QVERIFY(fieldCount > 0);

  1041 

  1042     commonFieldTest(fieldDefs, db, fieldCount);

  1043     checkNullValues(fieldDefs, db);

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

  1045     // increase serial values

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

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

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

  1049 

  1050         FieldDef def = fieldDefs[ i2 ];

  1051 #ifdef QT3_SUPPORT

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

  1053 #else

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

  1055 #endif

  1056         fieldDefs[ i2 ] = def;

  1057         }

  1058     }

  1059     checkValues(fieldDefs, db);

  1060     }

  1061 }

  1062 

  1063 void tst_QSqlDatabase::recordMySQL()

  1064 {

  1065     QFETCH(QString, dbName);

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

  1067     CHECK_DATABASE(db);

  1068 

  1069     FieldDef bin10, varbin10;

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

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

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

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

  1074 

  1075     /* The below is broken in mysql below 5.0.15

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

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

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

  1079     */

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

  1081 #ifdef QT3_SUPPORT

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

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

  1084 #else

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

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

  1087 #endif

  1088     }

  1089 

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

  1091     static const FieldDef fieldDefs[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1113 #ifdef QT3_SUPPORT

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

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

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

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

  1118 #endif

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

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

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

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

  1123 #ifdef QT3_SUPPORT

  1124     bin10,

  1125     varbin10,

  1126 #endif

  1127     // SET OF?

  1128 

  1129     FieldDef()

  1130     };

  1131 

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

  1133     QVERIFY(fieldCount > 0);

  1134