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 #include <QtTest/QtTest>

    43 #include <QtSql/QtSql>

    44 

    45 #include "../qsqldatabase/tst_databases.h"

    46 

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

    48 

    49 //TESTED_FILES=

    50 

    51 class tst_QSqlQuery : public QObject

    52 {

    53     Q_OBJECT

    54 

    55 public:

    56     tst_QSqlQuery();

    57     virtual ~tst_QSqlQuery();

    58 

    59 public slots:

    60     void initTestCase();

    61     void cleanupTestCase();

    62     void init();

    63     void cleanup();

    64 

    65 private slots:

    66     void value_data() { generic_data(); }

    67     void value();

    68     void isValid_data() { generic_data(); }

    69     void isValid();

    70     void isActive_data() { generic_data(); }

    71     void isActive();

    72     void isSelect_data() { generic_data(); }

    73     void isSelect();

    74     void numRowsAffected_data() { generic_data(); }

    75     void numRowsAffected();

    76     void size_data() { generic_data(); }

    77     void size();

    78     void isNull_data() { generic_data(); }

    79     void isNull();

    80     void query_exec_data() { generic_data(); }

    81     void query_exec();

    82     void execErrorRecovery_data() { generic_data(); }

    83     void execErrorRecovery();

    84     void first_data() { generic_data(); }

    85     void first();

    86     void next_data() { generic_data(); }

    87     void next();

    88     void prev_data() { generic_data(); }

    89     void prev();

    90     void last_data() { generic_data(); }

    91     void last();

    92     void seek_data() { generic_data(); }

    93     void seek();

    94     void transaction_data() { generic_data(); }

    95     void transaction();

    96     void record_data() { generic_data(); }

    97     void record();

    98     void record_sqlite_data() { generic_data("QSQLITE"); }

    99     void record_sqlite();

   100     void finish_data() { generic_data(); }

   101     void finish();

   102     void sqlite_finish_data() { generic_data(); }

   103     void sqlite_finish();

   104     void nextResult_data() { generic_data(); }

   105     void nextResult();

   106 

   107     // forwardOnly mode need special treatment

   108     void forwardOnly_data() { generic_data(); }

   109     void forwardOnly();

   110 

   111     // bug specific tests

   112     void bitField_data() {generic_data("QTDS"); }

   113     void bitField();

   114     void nullBlob_data() { generic_data("QOCI"); }

   115     void nullBlob();

   116     void blob_data() { generic_data(); }

   117     void blob();

   118     void rawField_data() { generic_data("QOCI"); }

   119     void rawField();

   120     void precision_data() { generic_data(); }

   121     void precision();

   122     void nullResult_data() { generic_data(); }

   123     void nullResult();

   124     void joins_data() { generic_data(); }

   125     void joins();

   126     void outValues_data() { generic_data(); }

   127     void outValues();

   128     void char1Select_data() { generic_data(); }

   129     void char1Select();

   130     void char1SelectUnicode_data() { generic_data(); }

   131     void char1SelectUnicode();

   132     void synonyms_data() { generic_data(); }

   133     void synonyms();

   134     void oraOutValues_data() { generic_data("QOCI"); }

   135     void oraOutValues();

   136     void mysqlOutValues_data() { generic_data("QMYSQL"); }

   137     void mysqlOutValues();

   138     void oraClob_data() { generic_data("QOCI"); }

   139     void oraClob();

   140     void oraLong_data() { generic_data("QOCI"); }

   141     void oraLong();

   142     void outValuesDB2_data() { generic_data("QDB2"); }

   143     void outValuesDB2();

   144     void storedProceduresIBase_data() {generic_data("QIBASE"); }

   145     void storedProceduresIBase();

   146     void oraRowId_data() { generic_data("QOCI"); }

   147     void oraRowId();

   148     void prepare_bind_exec_data() { generic_data(); }

   149     void prepare_bind_exec();

   150     void prepared_select_data() { generic_data(); }

   151     void prepared_select();

   152     void sqlServerLongStrings_data() { generic_data(); }

   153     void sqlServerLongStrings();

   154     void invalidQuery_data() { generic_data(); }

   155     void invalidQuery();

   156     void batchExec_data() { generic_data(); }

   157     void batchExec();

   158     void oraArrayBind_data() { generic_data(); }

   159     void oraArrayBind();

   160     void lastInsertId_data() { generic_data(); }

   161     void lastInsertId();

   162     void lastQuery_data() { generic_data(); }

   163     void lastQuery();

   164     void bindWithDoubleColonCastOperator_data() { generic_data(); }

   165     void bindWithDoubleColonCastOperator();

   166     void queryOnInvalidDatabase_data() { generic_data(); }

   167     void queryOnInvalidDatabase();

   168     void createQueryOnClosedDatabase_data() { generic_data(); }

   169     void createQueryOnClosedDatabase();

   170     void seekForwardOnlyQuery_data() { generic_data(); }

   171     void seekForwardOnlyQuery();

   172     void reExecutePreparedForwardOnlyQuery_data() { generic_data(); }

   173     void reExecutePreparedForwardOnlyQuery();

   174     void blobsPreparedQuery_data() { generic_data(); }

   175     void blobsPreparedQuery();

   176     void emptyTableNavigate_data() { generic_data(); }

   177     void emptyTableNavigate();

   178 

   179 #ifdef NOT_READY_YET

   180     void task_229811();

   181     void task_229811_data() { generic_data(); }

   182     void task_234422_data() {  generic_data(); }

   183     void task_234422();

   184 #endif

   185     void task_217003_data() { generic_data(); }

   186     void task_217003();

   187 

   188     void task_250026_data() { generic_data("QODBC"); }

   189     void task_250026();

   190     void task_205701_data() { generic_data("QMYSQL"); }

   191     void task_205701();

   192 

   193     void task_233829_data() { generic_data("QPSQL"); }

   194     void task_233829();

   195 

   196     void sqlServerReturn0_data() { generic_data(); }

   197     void sqlServerReturn0();

   198 

   199     void QTBUG_551_data() { generic_data("QOCI"); }

   200     void QTBUG_551();

   201 

   202     void QTBUG_5251_data() { generic_data("QPSQL"); }

   203     void QTBUG_5251();

   204     void QTBUG_6421_data() { generic_data("QOCI"); }

   205     void QTBUG_6421();

   206     void QTBUG_6618_data() { generic_data("QODBC"); }

   207     void QTBUG_6618();

   208     void QTBUG_6852_data() { generic_data("QMYSQL"); }

   209     void QTBUG_6852();

   210     void QTBUG_5765_data() { generic_data("QMYSQL"); }

   211     void QTBUG_5765();

   212 

   213 #if 0

   214     void benchmark_data() { generic_data(); }

   215     void benchmark();

   216 #endif

   217 

   218 private:

   219     // returns all database connections

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

   221     void dropTestTables( QSqlDatabase db );

   222     void createTestTables( QSqlDatabase db );

   223     void populateTestTables( QSqlDatabase db );

   224 

   225     tst_Databases dbs;

   226 };

   227 

   228 tst_QSqlQuery::tst_QSqlQuery()

   229 {

   230 }

   231 

   232 tst_QSqlQuery::~tst_QSqlQuery()

   233 {

   234 }

   235 

   236 void tst_QSqlQuery::initTestCase()

   237 {

   238     dbs.open();

   239 

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

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

   242         CHECK_DATABASE( db );

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

   244         createTestTables( db );

   245         populateTestTables( db );

   246     }

   247 }

   248 

   249 void tst_QSqlQuery::cleanupTestCase()

   250 {

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

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

   253         CHECK_DATABASE( db );

   254         dropTestTables( db );

   255     }

   256 

   257     dbs.close();

   258 }

   259 

   260 void tst_QSqlQuery::init()

   261 {

   262 }

   263 

   264 void tst_QSqlQuery::cleanup()

   265 {

   266     QFETCH( QString, dbName );

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

   268     CHECK_DATABASE( db );

   269 

   270     if ( QTest::currentTestFunction() == QLatin1String( "numRowsAffected" )

   271             || QTest::currentTestFunction() == QLatin1String( "transactions" )

   272             || QTest::currentTestFunction() == QLatin1String( "size" )

   273             || QTest::currentTestFunction() == QLatin1String( "isActive" )

   274             || QTest::currentTestFunction() == QLatin1String( "lastInsertId" ) ) {

   275         populateTestTables( db );

   276     }

   277 

   278     if ( QTest::currentTestFailed() && ( db.driverName().startsWith( "QOCI" )

   279                                          || db.driverName().startsWith( "QODBC" ) ) ) {

   280         //since Oracle ODBC totally craps out on error, we init again

   281         db.close();

   282         db.open();

   283     }

   284 }

   285 

   286 void tst_QSqlQuery::generic_data(const QString& engine)

   287 {

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

   289         if(engine.isEmpty())

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

   291         else

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

   293     }

   294 }

   295 

   296 void tst_QSqlQuery::dropTestTables( QSqlDatabase db )

   297 {

   298     QStringList tablenames;

   299     // drop all the table in case a testcase failed

   300     tablenames <<  qtest

   301                << qTableName( "qtest_null", __FILE__ )

   302                << qTableName( "qtest_blob", __FILE__ )

   303                << qTableName( "qtest_bittest", __FILE__ )

   304                << qTableName( "qtest_nullblob", __FILE__ )

   305                << qTableName( "qtest_rawtest", __FILE__ )

   306                << qTableName( "qtest_precision", __FILE__ )

   307                << qTableName( "qtest_prepare", __FILE__ )

   308                << qTableName( "qtestj1", __FILE__ )

   309                << qTableName( "qtestj2", __FILE__ )

   310                << qTableName( "char1Select", __FILE__ )

   311                << qTableName( "char1SU", __FILE__ )

   312                << qTableName( "qxmltest", __FILE__ )

   313                << qTableName( "qtest_exerr", __FILE__ )

   314                << qTableName( "qtest_empty", __FILE__ )

   315                << qTableName( "clobby", __FILE__ )

   316                << qTableName( "bindtest", __FILE__ )

   317                << qTableName( "more_results", __FILE__ )

   318                << qTableName( "blobstest", __FILE__ )

   319                << qTableName( "oraRowId", __FILE__ )

   320                << qTableName( "qtest_batch", __FILE__ )

   321                << qTableName("bug6421", __FILE__).toUpper()

   322                << qTableName("bug5765", __FILE__)

   323                << qTableName("bug6852", __FILE__)

   324                << qTableName( "qtest_lockedtable", __FILE__ )

   325                << qTableName( "Planet", __FILE__ )

   326                << qTableName( "task_250026", __FILE__ )

   327                << qTableName( "task_234422", __FILE__ )

   328                << qTableName("test141895", __FILE__);

   329 

   330     if ( db.driverName().startsWith("QPSQL") )

   331         tablenames << qTableName("task_233829", __FILE__);

   332 

   333     if ( db.driverName().startsWith("QSQLITE") )

   334         tablenames << qTableName( "record_sqlite", __FILE__ );

   335 

   336     if ( tst_Databases::isSqlServer( db ) || db.driverName().startsWith( "QOCI" ) )

   337         tablenames << qTableName( "qtest_longstr", __FILE__ );

   338 

   339     if (tst_Databases::isSqlServer( db ))

   340         db.exec("DROP PROCEDURE " + qTableName("test141895_proc", __FILE__));

   341 

   342     if (tst_Databases::isMySQL( db ))

   343         db.exec("DROP PROCEDURE IF EXISTS "+qTableName("bug6852_proc", __FILE__));

   344 

   345     tst_Databases::safeDropTables( db, tablenames );

   346 

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

   348         QSqlQuery q( db );

   349         q.exec( "DROP PACKAGE " + qTableName("pkg", __FILE__) );

   350     }

   351 }

   352 

   353 void tst_QSqlQuery::createTestTables( QSqlDatabase db )

   354 {

   355     QSqlQuery q( db );

   356 

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

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

   359         // in the MySQL server startup script

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

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

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

   363 

   364     if(tst_Databases::isPostgreSQL(db))

   365         QVERIFY_SQL( q, exec( "create table " + qtest + " (id serial NOT NULL, t_varchar varchar(20), t_char char(20), primary key(id)) WITH OIDS" ) );

   366     else

   367         QVERIFY_SQL( q, exec( "create table " + qtest + " (id int "+tst_Databases::autoFieldName(db) +" NOT NULL, t_varchar varchar(20), t_char char(20), primary key(id))" ) );

   368 

   369     if ( tst_Databases::isSqlServer( db ) || db.driverName().startsWith( "QTDS" ) )

   370         QVERIFY_SQL( q, exec( "create table " + qTableName( "qtest_null", __FILE__ ) + " (id int null, t_varchar varchar(20) null)" ) );

   371     else

   372         QVERIFY_SQL( q, exec( "create table " + qTableName( "qtest_null", __FILE__ ) + " (id int, t_varchar varchar(20))" ) );

   373 }

   374 

   375 void tst_QSqlQuery::populateTestTables( QSqlDatabase db )

   376 {

   377     QSqlQuery q( db );

   378     const QString qtest_null(qTableName( "qtest_null", __FILE__ ));

   379     q.exec( "delete from " + qtest );

   380     QVERIFY_SQL( q, exec( "insert into " + qtest + " values (1, 'VarChar1', 'Char1')" ) );

   381     QVERIFY_SQL( q, exec( "insert into " + qtest + " values (2, 'VarChar2', 'Char2')" ) );

   382     QVERIFY_SQL( q, exec( "insert into " + qtest + " values (3, 'VarChar3', 'Char3')" ) );

   383     QVERIFY_SQL( q, exec( "insert into " + qtest + " values (4, 'VarChar4', 'Char4')" ) );

   384     QVERIFY_SQL( q, exec( "insert into " + qtest + " values (5, 'VarChar5', 'Char5')" ) );

   385 

   386     q.exec( "delete from " + qtest_null );

   387     QVERIFY_SQL( q, exec( "insert into " + qtest_null + " values (0, NULL)" ) );

   388     QVERIFY_SQL( q, exec( "insert into " + qtest_null + " values (1, 'n')" ) );

   389     QVERIFY_SQL( q, exec( "insert into " + qtest_null + " values (2, 'i')" ) );

   390     QVERIFY_SQL( q, exec( "insert into " + qtest_null + " values (3, NULL)" ) );

   391 }

   392 

   393 // There were problems with char fields of size 1

   394 void tst_QSqlQuery::char1Select()

   395 {

   396     QFETCH( QString, dbName );

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

   398     CHECK_DATABASE( db );

   399 

   400     {

   401         QSqlQuery q( db );

   402         QVERIFY_SQL( q, exec( "create table " + qTableName( "char1Select", __FILE__ ) + " (id char(1))" ) );

   403         QVERIFY_SQL( q, exec( "insert into " + qTableName( "char1Select", __FILE__ ) + " values ('a')" ) );

   404         QVERIFY_SQL( q, exec( "select * from " + qTableName( "char1Select", __FILE__ ) ) );

   405         QVERIFY( q.next() );

   406 

   407         if ( db.driverName().startsWith( "QIBASE" ) )

   408             QCOMPARE( q.value( 0 ).toString().left( 1 ), QString( "a" ) );

   409         else

   410             QCOMPARE( q.value( 0 ).toString(), QString( "a" ) );

   411 

   412         QVERIFY( !q.next() );

   413     }

   414 }

   415 

   416 void tst_QSqlQuery::char1SelectUnicode()

   417 {

   418     QFETCH( QString, dbName );

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

   420     CHECK_DATABASE( db );

   421 

   422     if(db.driverName().startsWith("QDB2"))

   423         QSKIP("Needs someone with more Unicode knowledge than I have to fix", SkipSingle);

   424 

   425     if ( db.driver()->hasFeature( QSqlDriver::Unicode ) ) {

   426         QString uniStr( QChar(0x0915) ); // DEVANAGARI LETTER KA

   427         QSqlQuery q( db );

   428 

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

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

   431 

   432         QString createQuery;

   433         const QString char1SelectUnicode(qTableName( "char1SU", __FILE__ ));

   434 

   435         if ( tst_Databases::isSqlServer( db ) )

   436             createQuery = "create table " + char1SelectUnicode + "(id nchar(1))";

   437         else if ( db.driverName().startsWith( "QDB2" )

   438                   || db.driverName().startsWith( "QOCI" )

   439                   || db.driverName().startsWith( "QPSQL" ) )

   440             createQuery = "create table " + char1SelectUnicode + " (id char(3))";

   441         else if ( db.driverName().startsWith( "QIBASE" ) )

   442             createQuery = "create table " + char1SelectUnicode +

   443                           " (id char(1) character set unicode_fss)";

   444         else if ( db.driverName().startsWith( "QMYSQL" ) )

   445             createQuery = "create table " + char1SelectUnicode + " (id char(1)) "

   446                           "default character set 'utf8'";

   447         else

   448             createQuery = "create table " + char1SelectUnicode + " (id char(1))";

   449 

   450         QVERIFY_SQL( q, exec( createQuery ) );

   451 

   452         QVERIFY_SQL( q, prepare( "insert into " + char1SelectUnicode + " values(?)" ) );

   453 

   454         q.bindValue( 0, uniStr );

   455 

   456         QVERIFY_SQL( q, exec() );

   457 

   458         QVERIFY_SQL( q, exec( "select * from " + char1SelectUnicode ) );

   459 

   460         QVERIFY( q.next() );

   461 

   462         if ( !q.value( 0 ).toString().isEmpty() )

   463             QCOMPARE( q.value( 0 ).toString()[ 0 ].unicode(), uniStr[0].unicode() );

   464 

   465         QCOMPARE( q.value( 0 ).toString().trimmed(), uniStr );

   466 

   467         QVERIFY( !q.next() );

   468     }

   469     else

   470         QSKIP( "Database not unicode capable", SkipSingle );

   471 }

   472 

   473 void tst_QSqlQuery::oraRowId()

   474 {

   475     QFETCH( QString, dbName );

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

   477     CHECK_DATABASE( db );

   478     const QString oraRowId(qTableName("oraRowId", __FILE__));

   479 

   480     QSqlQuery q( db );

   481     QVERIFY_SQL( q, exec( "select rowid from " + qtest ) );

   482     QVERIFY( q.next() );

   483     QCOMPARE( q.value( 0 ).type(), QVariant::String );

   484     QVERIFY( !q.value( 0 ).toString().isEmpty() );

   485 

   486     QVERIFY_SQL( q, exec( "create table " + oraRowId + " (id char(1))" ) );

   487 

   488     QVERIFY_SQL( q, exec( "insert into " + oraRowId + " values('a')" ) );

   489     QVariant v1 = q.lastInsertId();

   490     QVERIFY( v1.isValid() );

   491 

   492     QVERIFY_SQL( q, exec( "insert into " + oraRowId + " values('b')" ) );

   493     QVariant v2 = q.lastInsertId();

   494     QVERIFY( v2.isValid() );

   495 

   496     QVERIFY_SQL( q, prepare( "select * from " + oraRowId + " where rowid = ?" ) );

   497     q.addBindValue( v1 );

   498     QVERIFY_SQL( q, exec() );

   499     QVERIFY( q.next() );

   500     QCOMPARE( q.value( 0 ).toString(), QString( "a" ) );

   501 

   502     q.addBindValue( v2 );

   503     QVERIFY_SQL( q, exec() );

   504     QVERIFY( q.next() );

   505     QCOMPARE( q.value( 0 ).toString(), QString( "b" ) );

   506 }

   507 

   508 void tst_QSqlQuery::mysqlOutValues()

   509 {

   510     QFETCH( QString, dbName );

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

   512     CHECK_DATABASE( db );

   513     const QString hello(qTableName( "hello", __FILE__ )), qtestproc(qTableName( "qtestproc", __FILE__ ));

   514 

   515     QSqlQuery q( db );

   516 

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

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

   519 

   520     q.exec( "drop function " + hello );

   521 

   522     QVERIFY_SQL( q, exec( "create function " + hello + " (s char(20)) returns varchar(50) return concat('Hello ', s)" ) );

   523 

   524     QVERIFY_SQL( q, exec( "select " + hello + "('world')" ) );

   525     QVERIFY_SQL( q, next() );

   526 

   527     QCOMPARE( q.value( 0 ).toString(), QString( "Hello world" ) );

   528 

   529     QVERIFY_SQL( q, prepare( "select " + hello + "('harald')" ) );

   530     QVERIFY_SQL( q, exec() );

   531     QVERIFY_SQL( q, next() );

   532 

   533     QCOMPARE( q.value( 0 ).toString(), QString( "Hello harald" ) );

   534 

   535     QVERIFY_SQL( q, exec( "drop function " + hello ) );

   536 

   537     q.exec( "drop procedure " + qtestproc );

   538 

   539     QVERIFY_SQL( q, exec( "create procedure " + qtestproc + " () "

   540                             "BEGIN select * from " + qtest + " order by id; END" ) );

   541     QVERIFY_SQL( q, exec( "call " + qtestproc + "()" ) );

   542     QVERIFY_SQL( q, next() );

   543     QCOMPARE( q.value( 1 ).toString(), QString( "VarChar1" ) );

   544 

   545     QVERIFY_SQL( q, exec( "drop procedure " + qtestproc ) );

   546 

   547     QVERIFY_SQL( q, exec( "create procedure " + qtestproc + " (OUT param1 INT) "

   548                             "BEGIN set param1 = 42; END" ) );

   549 

   550     QVERIFY_SQL( q, exec( "call " + qtestproc + " (@out)" ) );

   551     QVERIFY_SQL( q, exec( "select @out" ) );

   552     QCOMPARE( q.record().fieldName( 0 ), QString( "@out" ) );

   553     QVERIFY_SQL( q, next() );

   554     QCOMPARE( q.value( 0 ).toInt(), 42 );

   555 

   556     QVERIFY_SQL( q, exec( "drop procedure " + qtestproc ) );

   557 }

   558 

   559 void tst_QSqlQuery::oraOutValues()

   560 {

   561     QFETCH( QString, dbName );

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

   563     CHECK_DATABASE( db );

   564     const QString tst_outValues(qTableName("tst_outValues", __FILE__));

   565 

   566     if ( !db.driver()->hasFeature( QSqlDriver::PreparedQueries ) ) {

   567         QSKIP( "Test requires prepared query support", SkipSingle );

   568         return;

   569     }

   570 

   571     QSqlQuery q( db );

   572 

   573     q.setForwardOnly( true );

   574 

   575     /*** outvalue int ***/

   576     QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x out int) is\n"

   577                             "begin\n"

   578                             "    x := 42;\n"

   579                             "end;\n" ) );

   580     QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );

   581     q.addBindValue( 0, QSql::Out );

   582     QVERIFY_SQL( q, exec() );

   583     QCOMPARE( q.boundValue( 0 ).toInt(), 42 );

   584 

   585     // bind a null value, make sure the OCI driver resets the null flag

   586     q.addBindValue( QVariant( QVariant::Int ), QSql::Out );

   587     QVERIFY_SQL( q, exec() );

   588     QCOMPARE( q.boundValue( 0 ).toInt(), 42 );

   589     QVERIFY( !q.boundValue( 0 ).isNull() );

   590 

   591     /*** outvalue varchar ***/

   592     QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x out varchar) is\n"

   593                             "begin\n"

   594                             "    x := 'blah';\n"

   595                             "end;\n" ) );

   596     QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );

   597     QString s1( "12345" );

   598     s1.reserve( 512 );

   599     q.addBindValue( s1, QSql::Out );

   600     QVERIFY_SQL( q, exec() );

   601     QCOMPARE( q.boundValue( 0 ).toString(), QString( "blah" ) );

   602 

   603     /*** in/outvalue numeric ***/

   604     QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in out numeric) is\n"

   605                             "begin\n"

   606                             "    x := x + 10;\n"

   607                             "end;\n" ) );

   608     QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );

   609     q.addBindValue( 10, QSql::Out );

   610     QVERIFY_SQL( q, exec() );

   611     QCOMPARE( q.boundValue( 0 ).toInt(), 20 );

   612 

   613     /*** in/outvalue varchar ***/

   614     QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in out varchar) is\n"

   615                             "begin\n"

   616                             "    x := 'homer';\n"

   617                             "end;\n" ) );

   618     QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );

   619     q.addBindValue( QString( "maggy" ), QSql::Out );

   620     QVERIFY_SQL( q, exec() );

   621     QCOMPARE( q.boundValue( 0 ).toString(), QString( "homer" ) );

   622 

   623     /*** in/outvalue varchar ***/

   624     QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in out varchar) is\n"

   625                             "begin\n"

   626                             "    x := NULL;\n"

   627                             "end;\n" ) );

   628     QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );

   629     q.addBindValue( QString( "maggy" ), QSql::Out );

   630     QVERIFY_SQL( q, exec() );

   631     QVERIFY( q.boundValue( 0 ).isNull() );

   632 

   633     /*** in/outvalue int ***/

   634     QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in out int) is\n"

   635                             "begin\n"

   636                             "    x := NULL;\n"

   637                             "end;\n" ) );

   638     QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );

   639     q.addBindValue( 42, QSql::Out );

   640     QVERIFY_SQL( q, exec() );

   641     QVERIFY( q.boundValue( 0 ).isNull() );

   642 

   643     /*** in/outvalue varchar ***/

   644     QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x in varchar, y out varchar) is\n"

   645                             "begin\n"

   646                             "    y := x||'bubulalakikikokololo';\n"

   647                             "end;\n" ) );

   648     QVERIFY( q.prepare( "call " + tst_outValues + "(?, ?)" ) );

   649     q.addBindValue( QString( "fifi" ), QSql::In );

   650     QString out;

   651     out.reserve( 50 );

   652     q.addBindValue( out, QSql::Out );

   653     QVERIFY_SQL( q, exec() );

   654     QCOMPARE( q.boundValue( 1 ).toString(), QString( "fifibubulalakikikokololo" ) );

   655 }

   656 

   657 void tst_QSqlQuery::oraClob()

   658 {

   659     QFETCH( QString, dbName );

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

   661     CHECK_DATABASE( db );

   662     const QString clobby(qTableName("clobby", __FILE__));

   663 

   664     QSqlQuery q( db );

   665 

   666     // simple short string

   667     QVERIFY_SQL( q, exec( "create table " + clobby + "(id int primary key, cl clob, bl blob)" ) );

   668     QVERIFY_SQL( q, prepare( "insert into " + clobby + " (id, cl, bl) values(?, ?, ?)" ) );

   669     q.addBindValue( 1 );

   670     q.addBindValue( "bubu" );

   671     q.addBindValue( QByteArray("bubu") );

   672     QVERIFY_SQL( q, exec() );

   673 

   674     QVERIFY_SQL( q, exec( "select bl, cl from " + clobby + " where id = 1" ) );

   675     QVERIFY( q.next() );

   676     QCOMPARE( q.value( 0 ).toString(), QString( "bubu" ) );

   677     QCOMPARE( q.value( 1 ).toString(), QString( "bubu" ) );

   678 

   679     // simple short string with binding

   680     QVERIFY_SQL( q, prepare( "insert into " + clobby + " (id, cl, bl) values(?, ?, ?)" ) );

   681     q.addBindValue( 2 );

   682     q.addBindValue( "lala", QSql::Binary );

   683     q.addBindValue( QByteArray("lala"), QSql::Binary );

   684     QVERIFY_SQL( q, exec() );

   685 

   686     QVERIFY_SQL( q, exec( "select bl, cl from " + clobby + " where id = 2" ) );

   687     QVERIFY( q.next() );

   688     QCOMPARE( q.value( 0 ).toString(), QString( "lala" ) );

   689     QCOMPARE( q.value( 1 ).toString(), QString( "lala" ) );

   690 

   691     // loooong string

   692     QString loong;

   693     loong.fill( QLatin1Char( 'A' ), 25000 );

   694     QVERIFY_SQL( q, prepare( "insert into " + clobby + " (id, cl, bl) values(?, ?, ?)" ) );

   695     q.addBindValue( 3 );

   696     q.addBindValue( loong, QSql::Binary );

   697     q.addBindValue( loong.toLatin1(), QSql::Binary );

   698     QVERIFY_SQL( q, exec() );

   699 

   700     QVERIFY_SQL( q, exec( "select bl, cl from " + clobby + " where id = 3" ) );

   701     QVERIFY( q.next() );

   702     QCOMPARE( q.value( 0 ).toString().count(), loong.count() );

   703     QVERIFY( q.value( 0 ).toString() == loong );

   704     QCOMPARE( q.value( 1 ).toByteArray().count(), loong.toLatin1().count() );

   705     QVERIFY( q.value( 1 ).toByteArray() == loong.toLatin1() );

   706 }

   707 

   708 void tst_QSqlQuery::storedProceduresIBase()

   709 {

   710     QFETCH( QString, dbName );

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

   712     CHECK_DATABASE( db );

   713 

   714     QSqlQuery q( db );

   715     q.exec( "drop procedure " + qTableName( "TESTPROC", __FILE__ ) );

   716 

   717     QVERIFY_SQL( q, exec( "create procedure " + qTableName( "TESTPROC", __FILE__ ) +

   718                             " RETURNS (x integer, y varchar(20)) "

   719                             "AS BEGIN "

   720                             "  x = 42; "

   721                             "  y = 'Hello Anders'; "

   722                             "END" ) );

   723 

   724     QVERIFY_SQL( q, prepare( "execute procedure " + qTableName( "TestProc", __FILE__ ) ) );

   725     QVERIFY_SQL( q, exec() );

   726 

   727     // check for a valid result set

   728     QSqlRecord rec = q.record();

   729     QCOMPARE( rec.count(), 2 );

   730     QCOMPARE( rec.fieldName( 0 ).toUpper(), QString( "X" ) );

   731     QCOMPARE( rec.fieldName( 1 ).toUpper(), QString( "Y" ) );

   732 

   733     // the first next shall suceed

   734     QVERIFY_SQL( q, next() );

   735     QCOMPARE( q.value( 0 ).toInt(), 42 );

   736     QCOMPARE( q.value( 1 ).toString(), QString( "Hello Anders" ) );

   737 

   738     // the second next shall fail

   739     QVERIFY( !q.next() );

   740 

   741     q.exec( "drop procedure " + qTableName( "TestProc", __FILE__ ) );

   742 }

   743 

   744 void tst_QSqlQuery::outValuesDB2()

   745 {

   746     QFETCH( QString, dbName );

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

   748     CHECK_DATABASE( db );

   749 

   750     if ( !db.driver()->hasFeature( QSqlDriver::PreparedQueries ) ) {

   751         QSKIP( "Test requires prepared query support", SkipSingle );

   752         return;

   753     }

   754 

   755     QSqlQuery q( db );

   756 

   757     q.setForwardOnly( true );

   758 

   759     q.exec( "drop procedure " + qTableName( "tst_outValues", __FILE__ ) ); //non-fatal

   760     QVERIFY_SQL( q, exec( "CREATE PROCEDURE " + qTableName( "tst_outValues", __FILE__ ) +

   761                             " (OUT x int, OUT x2 double, OUT x3 char(20))\n"

   762                             "LANGUAGE SQL\n"

   763                             "P1: BEGIN\n"

   764                             " SET x = 42;\n"

   765                             " SET x2 = 4.2;\n"

   766                             " SET x3 = 'Homer';\n"

   767                             "END P1" ) );

   768 

   769     QVERIFY_SQL( q, prepare( "call " + qTableName( "tst_outValues", __FILE__ ) + "(?, ?, ?)" ) );

   770 

   771     q.addBindValue( 0, QSql::Out );

   772     q.addBindValue( 0.0, QSql::Out );

   773     q.addBindValue( "Simpson", QSql::Out );

   774 

   775     QVERIFY_SQL( q, exec() );

   776 

   777     QCOMPARE( q.boundValue( 0 ).toInt(), 42 );

   778     QCOMPARE( q.boundValue( 1 ).toDouble(), 4.2 );

   779     QCOMPARE( q.boundValue( 2 ).toString().trimmed(), QString( "Homer" ) );

   780 }

   781 

   782 void tst_QSqlQuery::outValues()

   783 {

   784     QFETCH( QString, dbName );

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

   786     CHECK_DATABASE( db );

   787     const QString tst_outValues(qTableName("tst_outValues", __FILE__));

   788 

   789     if ( !db.driver()->hasFeature( QSqlDriver::PreparedQueries ) ) {

   790         QSKIP( "Test requires prepared query support", SkipSingle );

   791         return;

   792     }

   793 

   794     QSqlQuery q( db );

   795 

   796     q.setForwardOnly( true );

   797 

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

   799         QVERIFY_SQL( q, exec( "create or replace procedure " + tst_outValues + "(x out int) is\n"

   800                                 "begin\n"

   801                                 "    x := 42;\n"

   802                                 "end;\n" ) );

   803         QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );

   804     } else if ( db.driverName().startsWith( "QDB2" ) ) {

   805         q.exec( "drop procedure " + tst_outValues ); //non-fatal

   806         QVERIFY_SQL( q, exec( "CREATE PROCEDURE " + tst_outValues + " (OUT x int)\n"

   807                                 "LANGUAGE SQL\n"

   808                                 "P1: BEGIN\n"

   809                                 " SET x = 42;\n"

   810                                 "END P1" ) );

   811         QVERIFY( q.prepare( "call " + tst_outValues + "(?)" ) );

   812     } else if ( tst_Databases::isSqlServer( db ) ) {

   813         q.exec( "drop procedure " + tst_outValues );  //non-fatal

   814         QVERIFY_SQL( q, exec( "create procedure " + tst_outValues + " (@x int out) as\n"

   815                                 "begin\n"

   816                                 "    set @x = 42\n"

   817                                 "end\n" ) );

   818         QVERIFY( q.prepare( "{call " + tst_outValues + "(?)}" ) );

   819     } else {

   820         QSKIP( "Don't know how to create a stored procedure for this database server, please fix this test", SkipSingle );

   821         return;

   822     }

   823 

   824     q.addBindValue( 0, QSql::Out );

   825 

   826     QVERIFY_SQL( q, exec() );

   827 

   828     QCOMPARE( q.boundValue( 0 ).toInt(), 42 );

   829 }

   830 

   831 void tst_QSqlQuery::blob()

   832 {

   833     static const int BLOBSIZE = 1024 * 10;

   834     static const int BLOBCOUNT = 2;

   835 

   836     QFETCH( QString, dbName );

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

   838     CHECK_DATABASE( db );

   839 

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

   841         QSKIP( "DBMS not BLOB capable", SkipSingle );

   842 

   843     //don' make it too big otherwise sybase and mysql will complain

   844     QByteArray ba( BLOBSIZE, 0 );

   845 

   846     int i;

   847 

   848     for ( i = 0; i < ( int )ba.size(); ++i )

   849         ba[i] = i % 256;

   850 

   851     QSqlQuery q( db );

   852 

   853     q.setForwardOnly( true );

   854 

   855     QString queryString = QString( "create table " + qTableName( "qtest_blob", __FILE__ ) +

   856                                    " (id int not null primary key, t_blob %1)" ).arg( tst_Databases::blobTypeName( db, BLOBSIZE ) );

   857     QVERIFY_SQL( q, exec( queryString ) );

   858 

   859     QVERIFY_SQL( q, prepare( "insert into " + qTableName( "qtest_blob", __FILE__ ) + " (id, t_blob) values (?, ?)" ) );

   860 

   861     for ( i = 0; i < BLOBCOUNT; ++i ) {

   862         q.addBindValue( i );

   863         q.addBindValue( ba );

   864         QVERIFY_SQL( q, exec() );

   865     }

   866 

   867     QVERIFY_SQL( q, exec( "select * from " + qTableName( "qtest_blob", __FILE__ ) ) );

   868 

   869     for ( i = 0; i < BLOBCOUNT; ++i ) {

   870         QVERIFY( q.next() );

   871         QByteArray res = q.value( 1 ).toByteArray();

   872         QVERIFY2( res.size() >= ba.size(),

   873                   QString( "array sizes differ, expected %1, got %2" ).arg( ba.size() ).arg( res.size() ).toLatin1() );

   874 

   875         for ( int i2 = 0; i2 < ( int )ba.size(); ++i2 ) {

   876             if ( res[i2] != ba[i2] )

   877                 QFAIL( QString( "ByteArrays differ at position %1, expected %2, got %3" ).arg(

   878                            i2 ).arg(( int )( unsigned char )ba[i2] ).arg(( int )( unsigned char )res[i2] ).toLatin1() );

   879         }

   880     }

   881 }

   882 

   883 void tst_QSqlQuery::value()

   884 {

   885     QFETCH( QString, dbName );

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

   887     CHECK_DATABASE( db );

   888 

   889     QSqlQuery q( db );

   890     QVERIFY_SQL( q, exec( "select id, t_varchar, t_char from " + qtest + " order by id" ) );

   891     int i = 1;

   892 

   893     while ( q.next() ) {

   894         QCOMPARE( q.value( 0 ).toInt(), i );

   895 

   896         if ( db.driverName().startsWith( "QIBASE" ) )

   897             QVERIFY( q.value( 1 ).toString().startsWith( "VarChar" + QString::number( i ) ) );

   898         else if ( q.value( 1 ).toString().right( 1 ) == " " )

   899             QCOMPARE( q.value( 1 ).toString(), ( "VarChar" + QString::number( i ) + "            " ) );

   900         else

   901             QCOMPARE( q.value( 1 ).toString(), ( "VarChar" + QString::number( i ) ) );

   902 

   903         if ( db.driverName().startsWith( "QIBASE" ) )

   904             QVERIFY( q.value( 2 ).toString().startsWith( "Char" + QString::number( i ) ) );

   905         else if ( q.value( 2 ).toString().right( 1 ) != " " )

   906             QCOMPARE( q.value( 2 ).toString(), ( "Char" + QString::number( i ) ) );

   907         else

   908             QCOMPARE( q.value( 2 ).toString(), ( "Char" + QString::number( i ) + "               " ) );

   909 

   910         i++;

   911     }

   912 }

   913 

   914 void tst_QSqlQuery::record()

   915 {

   916     QFETCH( QString, dbName );

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

   918     CHECK_DATABASE( db );

   919 

   920     QSqlQuery q( db );

   921     QVERIFY( q.record().isEmpty() );

   922     QVERIFY_SQL( q, exec( "select id, t_varchar, t_char from " + qtest + " order by id" ) );

   923     QSqlRecord rec = q.record();

   924     QCOMPARE( q.record().fieldName( 0 ).toLower(), QString( "id" ) );

   925     QCOMPARE( q.record().fieldName( 1 ).toLower(), QString( "t_varchar" ) );

   926     QCOMPARE( q.record().fieldName( 2 ).toLower(), QString( "t_char" ) );

   927     QVERIFY( !q.record().value( 0 ).isValid() );

   928     QVERIFY( !q.record().value( 1 ).isValid() );

   929     QVERIFY( !q.record().value( 2 ).isValid() );

   930 

   931     QVERIFY( q.next() );

   932     QVERIFY( q.next() );

   933 

   934     QCOMPARE( q.record().fieldName( 0 ).toLower(), QString( "id" ) );

   935     QCOMPARE( q.value( 0 ).toInt(), 2 );

   936 }

   937 

   938 void tst_QSqlQuery::isValid()

   939 {

   940     QFETCH( QString, dbName );

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

   942     CHECK_DATABASE( db );

   943 

   944     QSqlQuery q( db );

   945     QVERIFY( !q.isValid() );

   946     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

   947     QVERIFY( q.first() );

   948     QVERIFY( q.isValid() );

   949 }

   950 

   951 void tst_QSqlQuery::isActive()

   952 {

   953     QFETCH( QString, dbName );

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

   955     CHECK_DATABASE( db );

   956 

   957     QSqlQuery q( db );

   958     QVERIFY( !q.isActive() );

   959     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

   960     QVERIFY( q.isActive() );

   961     QVERIFY( q.last() );

   962 

   963     if ( !tst_Databases::isMSAccess( db ) )

   964         // Access is stupid enough to let you scroll over boundaries

   965         QVERIFY( !q.next() );

   966 

   967     QVERIFY( q.isActive() );

   968 

   969     QVERIFY_SQL( q, exec( "insert into " + qtest + " values (41, 'VarChar41', 'Char41')" ) );

   970 

   971     QVERIFY( q.isActive() );

   972 

   973     QVERIFY_SQL( q, exec( "update " + qtest + " set id = 42 where id = 41" ) );

   974 

   975     QVERIFY( q.isActive() );

   976 

   977     QVERIFY_SQL( q, exec( "delete from " + qtest + " where id = 42" ) );

   978 

   979     QVERIFY( q.isActive() );

   980 }

   981 

   982 void tst_QSqlQuery::numRowsAffected()

   983 {

   984     QFETCH( QString, dbName );

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

   986     CHECK_DATABASE( db );

   987 

   988     QSqlQuery q( db );

   989     QCOMPARE( q.numRowsAffected(), -1 );

   990 

   991     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

   992     int i = 0;

   993 

   994     while ( q.next() )

   995         ++i;

   996 

   997     if ( q.numRowsAffected() == -1 || q.numRowsAffected() == 0 )

   998         QSKIP("Database doesn't support numRowsAffected", SkipSingle);

   999 

  1000     if ( q.numRowsAffected() != -1 && q.numRowsAffected() != 0 && q.numRowsAffected() != i ) {

  1001         // the value is undefined for SELECT, this check is just here for curiosity

  1002         qDebug( "Expected numRowsAffected to be -1, 0 or %d, got %d", i, q.numRowsAffected() );

  1003     }

  1004 

  1005     QVERIFY_SQL( q, exec( "update " + qtest + " set id = 100 where id = 1" ) );

  1006 

  1007     QCOMPARE( q.numRowsAffected(), 1 );

  1008     QCOMPARE( q.numRowsAffected(), 1 ); // yes, we check twice

  1009 

  1010     QVERIFY_SQL( q, exec( "update " + qtest + " set id = id + 100" ) );

  1011     QCOMPARE( q.numRowsAffected(), i );

  1012     QCOMPARE( q.numRowsAffected(), i ); // yes, we check twice

  1013 

  1014     QVERIFY_SQL( q, exec( "insert into " + qtest + " values (42000, 'homer', 'marge')" ) );

  1015     QCOMPARE( q.numRowsAffected(), 1 );

  1016     QCOMPARE( q.numRowsAffected(), 1 ); // yes, we check twice

  1017 

  1018     QSqlQuery q2( db );

  1019     QVERIFY_SQL( q2, exec( "insert into " + qtest + " values (42001, 'homer', 'marge')" ) );

  1020 

  1021     if ( !db.driverName().startsWith( "QSQLITE2" ) ) {

  1022         // SQLite 2.x accumulates changed rows in nested queries. See task 33794

  1023         QCOMPARE( q2.numRowsAffected(), 1 );

  1024         QCOMPARE( q2.numRowsAffected(), 1 ); // yes, we check twice

  1025     }

  1026 }

  1027 

  1028 void tst_QSqlQuery::size()

  1029 {

  1030     QFETCH( QString, dbName );

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

  1032     CHECK_DATABASE( db );

  1033 

  1034     QSqlQuery q( db );

  1035     QCOMPARE( q.size(), -1 );

  1036 

  1037     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

  1038     int i = 0;

  1039 

  1040     while ( q.next() )

  1041         ++i;

  1042 

  1043     if ( db.driver()->hasFeature( QSqlDriver::QuerySize ) ) {

  1044         QCOMPARE( q.size(), i );

  1045         QCOMPARE( q.size(), i ); // yes, twice

  1046     } else {

  1047         QCOMPARE( q.size(), -1 );

  1048         QCOMPARE( q.size(), -1 ); // yes, twice

  1049     }

  1050 

  1051     QSqlQuery q2( "select * from " + qtest, db );

  1052 

  1053     if ( db.driver()->hasFeature( QSqlDriver::QuerySize ) )

  1054         QCOMPARE( q.size(), i );

  1055     else

  1056         QCOMPARE( q.size(), -1 );

  1057 

  1058     q2.clear();

  1059 

  1060     QVERIFY_SQL( q, exec( "update " + qtest + " set id = 100 where id = 1" ) );

  1061     QCOMPARE( q.size(), -1 );

  1062     QCOMPARE( q.size(), -1 ); // yes, twice

  1063 }

  1064 

  1065 void tst_QSqlQuery::isSelect()

  1066 {

  1067     QFETCH( QString, dbName );

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

  1069     CHECK_DATABASE( db );

  1070 

  1071     QSqlQuery q( db );

  1072     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

  1073     QVERIFY( q.isSelect() );

  1074 

  1075     QVERIFY_SQL( q, exec( "update " + qtest + " set id = 1 where id = 1" ) );

  1076     QVERIFY( q.isSelect() == false );

  1077 }

  1078 

  1079 void tst_QSqlQuery::first()

  1080 {

  1081     QFETCH( QString, dbName );

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

  1083     CHECK_DATABASE( db );

  1084 

  1085     QSqlQuery q( db );

  1086     QVERIFY( q.at() == QSql::BeforeFirstRow );

  1087     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

  1088     QVERIFY( q.last() );

  1089     QVERIFY_SQL( q, first() );

  1090     QVERIFY( q.at() == 0 );

  1091 }

  1092 

  1093 void tst_QSqlQuery::next()

  1094 {

  1095     QFETCH( QString, dbName );

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

  1097     CHECK_DATABASE( db );

  1098 

  1099     QSqlQuery q( db );

  1100     QVERIFY( q.at() == QSql::BeforeFirstRow );

  1101     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

  1102     QVERIFY( q.first() );

  1103     QVERIFY( q.next() );

  1104     QVERIFY( q.at() == 1 );

  1105 }

  1106 

  1107 void tst_QSqlQuery::prev()

  1108 {

  1109     QFETCH( QString, dbName );

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

  1111     CHECK_DATABASE( db );

  1112 

  1113     QSqlQuery q( db );

  1114     QVERIFY( q.at() == QSql::BeforeFirstRow );

  1115     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

  1116     QVERIFY( q.first() );

  1117     QVERIFY( q.next() );

  1118     QVERIFY( q.previous() );

  1119     QVERIFY( q.at() == 0 );

  1120 }

  1121 

  1122 void tst_QSqlQuery::last()

  1123 {

  1124     QFETCH( QString, dbName );

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

  1126     CHECK_DATABASE( db );

  1127 

  1128     QSqlQuery q( db );

  1129     QCOMPARE( q.at(), int( QSql::BeforeFirstRow ) );

  1130     QVERIFY_SQL( q, exec( "select * from " + qtest ) );

  1131     int i = 0;

  1132 

  1133     while ( q.next() )

  1134         i++;

  1135