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

    43 #include <QtSql/QtSql>

    44 

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

    46 

    47 //TESTED_FILES=

    48 

    49 class tst_QSqlQuery : public QObject

    50 {

    51     Q_OBJECT

    52 

    53 public:

    54     tst_QSqlQuery();

    55     virtual ~tst_QSqlQuery();

    56 

    57 public slots:

    58     void initTestCase();

    59     void cleanupTestCase();

    60     void init();

    61     void cleanup();

    62 

    63 private slots:

    64     void value_data() { generic_data(); }

    65     void value();

    66     void isValid_data() { generic_data(); }

    67     void isValid();

    68     void isActive_data() { generic_data(); }

    69     void isActive();

    70     void isSelect_data() { generic_data(); }

    71     void isSelect();

    72     void numRowsAffected_data() { generic_data(); }

    73     void numRowsAffected();

    74     void size_data() { generic_data(); }

    75     void size();

    76     void isNull_data() { generic_data(); }

    77     void isNull();

    78     void query_exec_data() { generic_data(); }

    79     void query_exec();

    80     void execErrorRecovery_data() { generic_data(); }

    81     void execErrorRecovery();

    82     void first_data() { generic_data(); }

    83     void first();

    84     void next_data() { generic_data(); }

    85     void next();

    86     void prev_data() { generic_data(); }

    87     void prev();

    88     void last_data() { generic_data(); }

    89     void last();

    90     void seek_data() { generic_data(); }

    91     void seek();

    92     void transaction_data() { generic_data(); }

    93     void transaction();

    94     void record_data() { generic_data(); }

    95     void record();

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

    97     void record_sqlite();

    98     void finish_data() { generic_data(); }

    99     void finish();

   100     void sqlite_finish_data() { generic_data(); }

   101     void sqlite_finish();

   102     void nextResult_data() { generic_data(); }

   103     void nextResult();

   104 

   105     // forwardOnly mode need special treatment

   106     void forwardOnly_data() { generic_data(); }

   107     void forwardOnly();

   108 

   109     // bug specific tests

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

   111     void bitField();

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

   113     void nullBlob();

   114     void blob_data() { generic_data(); }

   115     void blob();

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

   117     void rawField();

   118     void precision_data() { generic_data(); }

   119     void precision();

   120     void nullResult_data() { generic_data(); }

   121     void nullResult();

   122     void joins_data() { generic_data(); }

   123     void joins();

   124     void outValues_data() { generic_data(); }

   125     void outValues();

   126     void char1Select_data() { generic_data(); }

   127     void char1Select();

   128     void char1SelectUnicode_data() { generic_data(); }

   129     void char1SelectUnicode();

   130     void synonyms_data() { generic_data(); }

   131     void synonyms();

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

   133     void oraOutValues();

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

   135     void mysqlOutValues();

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

   137     void oraClob();

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

   139     void oraLong();

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

   141     void outValuesDB2();

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

   143     void storedProceduresIBase();

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

   145     void oraRowId();

   146     void prepare_bind_exec_data() { generic_data(); }

   147     void prepare_bind_exec();

   148     void prepared_select_data() { generic_data(); }

   149     void prepared_select();

   150     void sqlServerLongStrings_data() { generic_data(); }

   151     void sqlServerLongStrings();

   152     void invalidQuery_data() { generic_data(); }

   153     void invalidQuery();

   154     void batchExec_data() { generic_data(); }

   155     void batchExec();

   156     void oraArrayBind_data() { generic_data(); }

   157     void oraArrayBind();

   158     void lastInsertId_data() { generic_data(); }

   159     void lastInsertId();

   160     void lastQuery_data() { generic_data(); }

   161     void lastQuery();

   162     void bindWithDoubleColonCastOperator_data() { generic_data(); }

   163     void bindWithDoubleColonCastOperator();

   164     void queryOnInvalidDatabase_data() { generic_data(); }

   165     void queryOnInvalidDatabase();

   166     void createQueryOnClosedDatabase_data() { generic_data(); }

   167     void createQueryOnClosedDatabase();

   168     void seekForwardOnlyQuery_data() { generic_data(); }

   169     void seekForwardOnlyQuery();

   170     void reExecutePreparedForwardOnlyQuery_data() { generic_data(); }

   171     void reExecutePreparedForwardOnlyQuery();

   172     void blobsPreparedQuery_data() { generic_data(); }

   173     void blobsPreparedQuery();

   174     void emptyTableNavigate_data() { generic_data(); }

   175     void emptyTableNavigate();

   176 

   177 #ifdef NOT_READY_YET

   178     void task_229811();

   179     void task_229811_data() { generic_data(); }

   180     void task_234422_data() {  generic_data(); }

   181     void task_234422();

   182 #endif

   183     void task_217003_data() { generic_data(); }

   184     void task_217003();

   185 

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

   187     void task_250026();

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

   189     void task_205701();

   190 

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

   192     void task_233829();

   193 

   194     void sqlServerReturn0_data() { generic_data(); }

   195     void sqlServerReturn0();

   196 

   197 private:

   198     // returns all database connections

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

   200     void dropTestTables( QSqlDatabase db );

   201     void createTestTables( QSqlDatabase db );

   202     void populateTestTables( QSqlDatabase db );

   203 

   204     tst_Databases dbs;

   205 };

   206 

   207 tst_QSqlQuery::tst_QSqlQuery()

   208 {

   209 }

   210 

   211 tst_QSqlQuery::~tst_QSqlQuery()

   212 {

   213 }

   214 

   215 void tst_QSqlQuery::initTestCase()

   216 {

   217     dbs.open();

   218 

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

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

   221         CHECK_DATABASE( db );

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

   223         createTestTables( db );

   224         populateTestTables( db );

   225     }

   226 }

   227 

   228 void tst_QSqlQuery::cleanupTestCase()

   229 {

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

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

   232         CHECK_DATABASE( db );

   233         dropTestTables( db );

   234     }

   235 

   236     dbs.close();

   237 }

   238 

   239 void tst_QSqlQuery::init()

   240 {

   241 }

   242 

   243 void tst_QSqlQuery::cleanup()

   244 {

   245     QFETCH( QString, dbName );

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

   247     CHECK_DATABASE( db );

   248 

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

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

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

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

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

   254         populateTestTables( db );

   255     }

   256 

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

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

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

   260         db.close();

   261         db.open();

   262     }

   263 }

   264 

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

   266 {

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

   268         if(engine.isEmpty())

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

   270         else

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

   272     }

   273 }

   274 

   275 void tst_QSqlQuery::dropTestTables( QSqlDatabase db )

   276 {

   277     QStringList tablenames;

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

   279     tablenames <<  qTableName( "qtest" )

   280                << qTableName( "qtest_null" )

   281                << qTableName( "qtest_blob" )

   282                << qTableName( "qtest_bittest" )

   283                << qTableName( "qtest_nullblob" )

   284                << qTableName( "qtest_rawtest" )

   285                << qTableName( "qtest_precision" )

   286                << qTableName( "qtest_prepare" )

   287                << qTableName( "qtestj1" )

   288                << qTableName( "qtestj2" )

   289                << qTableName( "char1Select" )

   290                << qTableName( "char1SelectUnicode" )

   291                << qTableName( "qxmltest" )

   292                << qTableName( "qtest_exerr" )

   293                << qTableName( "qtest_empty" )

   294                << qTableName( "clobby" )

   295                << qTableName( "bindtest" )

   296                << qTableName( "more_results" )

   297                << qTableName( "blobstest" )

   298                << qTableName( "oraRowId" )

   299                << qTableName( "qtest_batch" );

   300 

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

   302         tablenames << qTableName("task_233829");

   303 

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

   305         tablenames << qTableName( "record_sqlite" );

   306 

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

   308         tablenames << qTableName( "qtest_longstr" );

   309 

   310     tablenames <<  qTableName( "qtest_lockedtable" );

   311 

   312     tablenames <<  qTableName( "Planet" );

   313 

   314     tablenames << qTableName( "task_250026" );

   315     tablenames << qTableName( "task_234422" );

   316 

   317     if (tst_Databases::isSqlServer( db )) {

   318         QSqlQuery q( db );

   319         q.exec("DROP PROCEDURE " + qTableName("test141895_proc"));

   320     }

   321 

   322     tablenames << qTableName("test141895");

   323 

   324     tst_Databases::safeDropTables( db, tablenames );

   325 }

   326 

   327 void tst_QSqlQuery::createTestTables( QSqlDatabase db )

   328 {

   329     QSqlQuery q( db );

   330 

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

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

   333         // in the MySQL server startup script

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

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

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

   337 

   338     if(tst_Databases::isPostgreSQL(db))

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

   340     else

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

   342 

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

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

   345     else

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

   347 }

   348 

   349 void tst_QSqlQuery::populateTestTables( QSqlDatabase db )

   350 {

   351     QSqlQuery q( db );

   352     q.exec( "delete from " + qTableName( "qtest" ) );

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

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

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

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

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

   358 

   359     q.exec( "delete from " + qTableName( "qtest_null" ) );

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

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

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

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

   364 }

   365 

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

   367 void tst_QSqlQuery::char1Select()

   368 {

   369     QFETCH( QString, dbName );

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

   371     CHECK_DATABASE( db );

   372 

   373     {

   374         QSqlQuery q( db );

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

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

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

   378         QVERIFY( q.next() );

   379 

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

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

   382         else

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

   384 

   385         QVERIFY( !q.next() );

   386     }

   387 }

   388 

   389 void tst_QSqlQuery::char1SelectUnicode()

   390 {

   391     QFETCH( QString, dbName );

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

   393     CHECK_DATABASE( db );

   394 

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

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

   397 

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

   399         QString uniStr( QChar( 'का' ) );

   400         QSqlQuery q( db );

   401 

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

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

   404 

   405         QString createQuery;

   406 

   407         if ( tst_Databases::isSqlServer( db ) )

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

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

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

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

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

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

   414             createQuery = "create table " + qTableName( "char1SelectUnicode" ) +

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

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

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

   418                           "default character set 'utf8'";

   419         else

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

   421 

   422         QVERIFY_SQL( q, exec( createQuery ) );

   423 

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

   425 

   426         q.bindValue( 0, uniStr );

   427 

   428         QVERIFY_SQL( q, exec() );

   429 

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

   431 

   432         QVERIFY( q.next() );

   433 

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

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

   436 

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

   438 

   439         QVERIFY( !q.next() );

   440     }

   441     else

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

   443 }

   444 

   445 void tst_QSqlQuery::oraRowId()

   446 {

   447     QFETCH( QString, dbName );

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

   449     CHECK_DATABASE( db );

   450 

   451     QSqlQuery q( db );

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

   453     QVERIFY( q.next() );

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

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

   456 

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

   458 

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

   460     QVariant v1 = q.lastInsertId();

   461     QVERIFY( v1.isValid() );

   462 

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

   464     QVariant v2 = q.lastInsertId();

   465     QVERIFY( v2.isValid() );

   466 

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

   468     q.addBindValue( v1 );

   469     QVERIFY_SQL( q, exec() );

   470     QVERIFY( q.next() );

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

   472 

   473     q.addBindValue( v2 );

   474     QVERIFY_SQL( q, exec() );

   475     QVERIFY( q.next() );

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

   477 }

   478 

   479 void tst_QSqlQuery::mysqlOutValues()

   480 {

   481     QFETCH( QString, dbName );

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

   483     CHECK_DATABASE( db );

   484 

   485     QSqlQuery q( db );

   486 

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

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

   489 

   490     q.exec( "drop function " + qTableName( "hello" ) );

   491 

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

   493 

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

   495     QVERIFY_SQL( q, next() );

   496 

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

   498 

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

   500     QVERIFY_SQL( q, exec() );

   501     QVERIFY_SQL( q, next() );

   502 

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

   504 

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

   506 

   507     q.exec( "drop procedure " + qTableName( "qtestproc" ) );

   508 

   509     QVERIFY_SQL( q, exec( "create procedure " + qTableName( "qtestproc" ) + " () "

   510                             "BEGIN select * from " + qTableName( "qtest" ) + " order by id; END" ) );

   511     QVERIFY_SQL( q, exec( "call " + qTableName( "qtestproc" ) + "()" ) );

   512     QVERIFY_SQL( q, next() );

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

   514 

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

   516 

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

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

   519 

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

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

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

   523     QVERIFY_SQL( q, next() );

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

   525 

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

   527 }

   528 

   529 void tst_QSqlQuery::oraOutValues()

   530 {

   531     QFETCH( QString, dbName );

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

   533     CHECK_DATABASE( db );

   534 

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

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

   537         return;

   538     }

   539 

   540     QSqlQuery q( db );

   541 

   542     q.setForwardOnly( true );

   543 

   544     /*** outvalue int ***/

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

   546                             "begin\n"

   547                             "    x := 42;\n"

   548                             "end;\n" ) );

   549     QVERIFY( q.prepare( "call " + qTableName( "tst_outvalues" ) + "(?)" ) );

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

   551     QVERIFY_SQL( q, exec() );

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

   553 

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

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

   556     QVERIFY_SQL( q, exec() );

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

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

   559 

   560     /*** outvalue varchar ***/

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

   562                             "begin\n"

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

   564                             "end;\n" ) );

   565     QVERIFY( q.prepare( "call " + qTableName( "tst_outvalues" ) + "(?)" ) );

   566     QString s1( "12345" );

   567     s1.reserve( 512 );

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

   569     QVERIFY_SQL( q, exec() );

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

   571 

   572     /*** in/outvalue numeric ***/

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

   574                             "begin\n"

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

   576                             "end;\n" ) );

   577     QVERIFY( q.prepare( "call " + qTableName( "tst_outvalues" ) + "(?)" ) );

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

   579     QVERIFY_SQL( q, exec() );

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

   581 

   582     /*** in/outvalue varchar ***/

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

   584                             "begin\n"

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

   586                             "end;\n" ) );

   587     QVERIFY( q.prepare( "call " + qTableName( "tst_outvalues" ) + "(?)" ) );

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

   589     QVERIFY_SQL( q, exec() );

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

   591 

   592     /*** in/outvalue varchar ***/

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

   594                             "begin\n"

   595                             "    x := NULL;\n"

   596                             "end;\n" ) );

   597     QVERIFY( q.prepare( "call " + qTableName( "tst_outvalues" ) + "(?)" ) );

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

   599     QVERIFY_SQL( q, exec() );

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

   601 

   602     /*** in/outvalue int ***/

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

   604                             "begin\n"

   605                             "    x := NULL;\n"

   606                             "end;\n" ) );

   607     QVERIFY( q.prepare( "call " + qTableName( "tst_outvalues" ) + "(?)" ) );

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

   609     QVERIFY_SQL( q, exec() );

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

   611 

   612     /*** in/outvalue varchar ***/

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

   614                             "begin\n"

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

   616                             "end;\n" ) );

   617     QVERIFY( q.prepare( "call " + qTableName( "tst_outvalues" ) + "(?, ?)" ) );

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

   619     QString out;

   620     out.reserve( 50 );

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

   622     QVERIFY_SQL( q, exec() );

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

   624 }

   625 

   626 void tst_QSqlQuery::oraClob()

   627 {

   628     QFETCH( QString, dbName );

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

   630     CHECK_DATABASE( db );

   631 

   632     QSqlQuery q( db );

   633 

   634     // simple short string

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

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

   637     q.addBindValue( 1 );

   638     q.addBindValue( "bubu" );

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

   640     QVERIFY_SQL( q, exec() );

   641 

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

   643     QVERIFY( q.next() );

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

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

   646 

   647     // simple short string with binding

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

   649     q.addBindValue( 2 );

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

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

   652     QVERIFY_SQL( q, exec() );

   653 

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

   655     QVERIFY( q.next() );

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

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

   658 

   659     // loooong string

   660     QString loong;

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

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

   663     q.addBindValue( 3 );

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

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

   666     QVERIFY_SQL( q, exec() );

   667 

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

   669     QVERIFY( q.next() );

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

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

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

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

   674 }

   675 

   676 void tst_QSqlQuery::storedProceduresIBase()

   677 {

   678     QFETCH( QString, dbName );

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

   680     CHECK_DATABASE( db );

   681 

   682     QSqlQuery q( db );

   683     q.exec( "drop procedure " + qTableName( "TESTPROC" ) );

   684 

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

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

   687                             "AS BEGIN "

   688                             "  x = 42; "

   689                             "  y = 'Hello Anders'; "

   690                             "END" ) );

   691 

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

   693     QVERIFY_SQL( q, exec() );

   694 

   695     // check for a valid result set

   696     QSqlRecord rec = q.record();

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

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

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

   700 

   701     // the first next shall suceed

   702     QVERIFY_SQL( q, next() );

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

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

   705 

   706     // the second next shall fail

   707     QVERIFY( !q.next() );

   708 

   709     q.exec( "drop procedure " + qTableName( "TestProc" ) );

   710 }

   711 

   712 void tst_QSqlQuery::outValuesDB2()

   713 {

   714     QFETCH( QString, dbName );

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

   716     CHECK_DATABASE( db );

   717 

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

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

   720         return;

   721     }

   722 

   723     QSqlQuery q( db );

   724 

   725     q.setForwardOnly( true );

   726 

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

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

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

   730                             "LANGUAGE SQL\n"

   731                             "P1: BEGIN\n"

   732                             " SET x = 42;\n"

   733                             " SET x2 = 4.2;\n"

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

   735                             "END P1" ) );

   736 

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

   738 

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

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

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

   742 

   743     QVERIFY_SQL( q, exec() );

   744 

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

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

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

   748 }

   749 

   750 void tst_QSqlQuery::outValues()

   751 {

   752     QFETCH( QString, dbName );

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

   754     CHECK_DATABASE( db );

   755 

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

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

   758         return;

   759     }

   760 

   761     QSqlQuery q( db );

   762 

   763     q.setForwardOnly( true );

   764 

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

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

   767                                 "begin\n"

   768                                 "    x := 42;\n"

   769                                 "end;\n" ) );

   770         QVERIFY( q.prepare( "call " + qTableName( "tst_outvalues" ) + "(?)" ) );

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

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

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

   774                                 "LANGUAGE SQL\n"

   775                                 "P1: BEGIN\n"

   776                                 " SET x = 42;\n"

   777                                 "END P1" ) );

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

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

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

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

   782                                 "begin\n"

   783                                 "    set @x = 42\n"

   784                                 "end\n" ) );

   785         QVERIFY( q.prepare( "{call " + qTableName( "tst_outvalues" ) + "(?)}" ) );

   786     } else {

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

   788         return;

   789     }

   790 

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

   792 

   793     QVERIFY_SQL( q, exec() );

   794 

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

   796 }

   797 

   798 void tst_QSqlQuery::blob()

   799 {

   800     static const int BLOBSIZE = 1024 * 10;

   801     static const int BLOBCOUNT = 2;

   802 

   803     QFETCH( QString, dbName );

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

   805     CHECK_DATABASE( db );

   806 

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

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

   809 

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

   811     QByteArray ba( BLOBSIZE, 0 );

   812 

   813     int i;

   814 

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

   816         ba[i] = i % 256;

   817 

   818     QSqlQuery q( db );

   819 

   820     q.setForwardOnly( true );

   821 

   822     QString queryString = QString( "create table " + qTableName( "qtest_blob" ) +

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

   824     QVERIFY_SQL( q, exec( queryString ) );

   825 

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

   827 

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

   829         q.addBindValue( i );

   830         q.addBindValue( ba );

   831         QVERIFY_SQL( q, exec() );

   832     }

   833 

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

   835 

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

   837         QVERIFY( q.next() );

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

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

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

   841 

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

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

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

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

   846         }

   847     }

   848 }

   849 

   850 void tst_QSqlQuery::value()

   851 {

   852     QFETCH( QString, dbName );

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

   854     CHECK_DATABASE( db );

   855 

   856     QSqlQuery q( db );

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

   858     int i = 1;

   859 

   860     while ( q.next() ) {

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

   862 

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

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

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

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

   867         else

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

   869 

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

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

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

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

   874         else

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

   876 

   877         i++;

   878     }

   879 }

   880 

   881 void tst_QSqlQuery::record()

   882 {

   883     QFETCH( QString, dbName );

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

   885     CHECK_DATABASE( db );

   886 

   887     QSqlQuery q( db );

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

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

   890     QSqlRecord rec = q.record();

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

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

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

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

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

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

   897 

   898     QVERIFY( q.next() );

   899     QVERIFY( q.next() );

   900 

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

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

   903 }

   904 

   905 void tst_QSqlQuery::isValid()

   906 {

   907     QFETCH( QString, dbName );

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

   909     CHECK_DATABASE( db );

   910 

   911     QSqlQuery q( db );

   912     QVERIFY( !q.isValid() );

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

   914     QVERIFY( q.first() );

   915     QVERIFY( q.isValid() );

   916 }

   917 

   918 void tst_QSqlQuery::isActive()

   919 {

   920     QFETCH( QString, dbName );

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

   922     CHECK_DATABASE( db );

   923 

   924     QSqlQuery q( db );

   925     QVERIFY( !q.isActive() );

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

   927     QVERIFY( q.isActive() );

   928     QVERIFY( q.last() );

   929 

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

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

   932         QVERIFY( !q.next() );

   933 

   934     QVERIFY( q.isActive() );

   935 

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

   937 

   938     QVERIFY( q.isActive() );

   939 

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

   941 

   942     QVERIFY( q.isActive() );

   943 

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

   945 

   946     QVERIFY( q.isActive() );

   947 }

   948 

   949 void tst_QSqlQuery::numRowsAffected()

   950 {

   951     QFETCH( QString, dbName );

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

   953     CHECK_DATABASE( db );

   954 

   955     QSqlQuery q( db );

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

   957 

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

   959     int i = 0;

   960 

   961     while ( q.next() )

   962         ++i;

   963 

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

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

   966 

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

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

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

   970     }

   971 

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

   973 

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

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

   976 

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

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

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

   980 

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

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

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

   984 

   985     QSqlQuery q2( db );

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

   987 

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

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

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

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

   992     }

   993 }

   994 

   995 void tst_QSqlQuery::size()

   996 {

   997     QFETCH( QString, dbName );

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

   999     CHECK_DATABASE( db );

  1000 

  1001     QSqlQuery q( db );

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

  1003 

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

  1005     int i = 0;

  1006 

  1007     while ( q.next() )

  1008         ++i;

  1009 

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

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

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

  1013     } else {

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

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

  1016     }

  1017 

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

  1019 

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

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

  1022     else

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

  1024 

  1025     q2.clear();

  1026 

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

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

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

  1030 }

  1031 

  1032 void tst_QSqlQuery::isSelect()

  1033 {

  1034     QFETCH( QString, dbName );

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

  1036     CHECK_DATABASE( db );

  1037 

  1038     QSqlQuery q( db );

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

  1040     QVERIFY( q.isSelect() );

  1041 

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

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

  1044 }

  1045 

  1046 void tst_QSqlQuery::first()

  1047 {

  1048     QFETCH( QString, dbName );

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

  1050     CHECK_DATABASE( db );

  1051 

  1052     QSqlQuery q( db );

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

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

  1055     QVERIFY( q.last() );

  1056     QVERIFY_SQL( q, first() );

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

  1058 }

  1059 

  1060 void tst_QSqlQuery::next()

  1061 {

  1062     QFETCH( QString, dbName );

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

  1064     CHECK_DATABASE( db );

  1065 

  1066     QSqlQuery q( db );

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

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

  1069     QVERIFY( q.first() );

  1070     QVERIFY( q.next() );

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

  1072 }

  1073 

  1074 void tst_QSqlQuery::prev()

  1075 {

  1076     QFETCH( QString, dbName );

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

  1078     CHECK_DATABASE( db );

  1079 

  1080     QSqlQuery q( db );

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

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

  1083     QVERIFY( q.first() );

  1084     QVERIFY( q.next() );

  1085     QVERIFY( q.previous() );

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

  1087 }

  1088 

  1089 void tst_QSqlQuery::last()

  1090 {

  1091     QFETCH( QString, dbName );

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

  1093     CHECK_DATABASE( db );

  1094 

  1095     QSqlQuery q( db );

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

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

  1098     int i = 0;

  1099 

  1100     while ( q.next() )

  1101         i++;

  1102 

  1103     QCOMPARE( q.at(), int( QSql::AfterLastRow ) );

  1104 

  1105     QVERIFY( q.last() );

  1106 

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

  1108         // Access doesn't return the correct position

  1109         QCOMPARE( q.at(), ( i-1 ) );

  1110 

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

  1112 

  1113     QVERIFY( q2.last() );

  1114 

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

  1116         // Access doesn't return the correct position

  1117         QCOMPARE( q.at(), ( i-1 ) );

  1118 }

  1119 

  1120 void tst_QSqlQuery::seek()

  1121 {

  1122     QFETCH( QString, dbName );

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

  1124     CHECK_DATABASE( db );

  1125     QSqlQuery q( db );

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

  1127     QVERIFY_SQL( q, exec( QString( "select id from %1 order by id" ).arg( qTableName( "qtest" ) ) ) );

  1128 

  1129     // NB! The order of the calls below are important!

  1130     QVERIFY( q.last() );

  1131     QVERIFY( !q.seek( QSql::BeforeFirstRow ) );

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

  1133     QVERIFY( q.seek( 0 ) );

  1134     QCOMPARE( q.at(), 0 );