diff --git a/autotests/ConnectionTest.cpp b/autotests/ConnectionTest.cpp index 865d324a..9d34f9fa 100644 --- a/autotests/ConnectionTest.cpp +++ b/autotests/ConnectionTest.cpp @@ -1,133 +1,133 @@ /* This file is part of the KDE project Copyright (C) 2012-2016 Jarosław Staniek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "ConnectionTest.h" #include #include #include #include #include #include QTEST_GUILESS_MAIN(ConnectionTest) void ConnectionTest::initTestCase() { } void ConnectionTest::testConnectionData() { KDbConnectionData cdata; QVERIFY(cdata.databaseName().isEmpty()); QVERIFY(cdata.driverId().isEmpty()); QVERIFY(cdata.caption().isEmpty()); QVERIFY(cdata.description().isEmpty()); QVERIFY(cdata.userName().isEmpty()); QVERIFY(cdata.hostName().isEmpty()); QCOMPARE(cdata.port(), 0); QVERIFY(cdata.useLocalSocketFile()); QVERIFY(cdata.localSocketFileName().isEmpty()); QVERIFY(cdata.password().isEmpty()); QVERIFY(!cdata.savePassword()); QCOMPARE(cdata, cdata); QVERIFY2(!cdata.isPasswordNeeded(), "Password-needed is not false for empty data"); QVERIFY(cdata.toUserVisibleString().isEmpty()); QCOMPARE(cdata, KDbConnectionData()); QString db = "mydb"; cdata.setDatabaseName(db); QCOMPARE(cdata.databaseName(), db); QCOMPARE(db, cdata.toUserVisibleString()); QCOMPARE(db, cdata.toUserVisibleString(KDbConnectionData::UserVisibleStringOption::None)); cdata.setDriverId("INVALID.ID"); QCOMPARE(db, cdata.toUserVisibleString()); // driver ID invalid: still just returns the db name QCOMPARE(db, cdata.toUserVisibleString(KDbConnectionData::UserVisibleStringOption::None)); // like above KDbDriverManager manager; //! @todo more drivers if (manager.driver("org.kde.kdb.sqlite")) { // only if sqlite is present qDebug() << "org.kde.kdb.sqlite driver found, testing..."; cdata = KDbConnectionData(); cdata.setDriverId("org.kde.kdb.sqlite"); QCOMPARE(cdata.toUserVisibleString(), KDbConnection::tr("")); cdata.setDatabaseName("my.db"); QCOMPARE(cdata.toUserVisibleString(), KDbConnection::tr("file: %1").arg("my.db")); KDbConnectionData copy(cdata); QCOMPARE(cdata, copy); } if (manager.driver("org.kde.kdb.mysql")) { // only if mysql is present qDebug() << "org.kde.kdb.mysql driver found, testing..."; cdata = KDbConnectionData(); cdata.setDriverId("org.kde.kdb.mysql"); QCOMPARE(cdata.toUserVisibleString(), QLatin1String("localhost")); QCOMPARE(cdata.toUserVisibleString(KDbConnectionData::UserVisibleStringOption::None), QLatin1String("localhost")); // like above cdata.setUserName("joe"); QCOMPARE(cdata.toUserVisibleString(), QLatin1String("joe@localhost")); cdata.setUserName(QString()); cdata.setHostName("example.com"); QCOMPARE(cdata.toUserVisibleString(), QLatin1String("example.com")); cdata.setUserName("joe"); QCOMPARE(cdata.toUserVisibleString(), QLatin1String("joe@example.com")); QCOMPARE(cdata.toUserVisibleString(KDbConnectionData::UserVisibleStringOption::None), QLatin1String("example.com")); cdata.setPort(12345); QCOMPARE(cdata.toUserVisibleString(), QLatin1String("joe@example.com:12345")); QCOMPARE(cdata.toUserVisibleString(KDbConnectionData::UserVisibleStringOption::None), QLatin1String("example.com:12345")); KDbConnectionData copy(cdata); QCOMPARE(cdata, copy); } } void ConnectionTest::testCreateDb() { QVERIFY(utils.testCreateDb("ConnectionTest")); QVERIFY(utils.testUse()); QVERIFY(utils.testProperties()); QVERIFY(utils.testCreateTables()); QVERIFY(utils.testDisconnectAndDropDb()); } void ConnectionTest::testConnectToNonexistingDb() { QVERIFY(utils.driver); //open connection KDbConnectionData cdata; cdata.setDatabaseName(QLatin1String("/really-non-existing/path/fiuwehf2349f8h23c2jcoeqw")); QVERIFY(utils.testConnect(cdata)); - QVERIFY(utils.connection); - KDB_VERIFY(utils.connection, !utils.connection->databaseExists(utils.connection->data().databaseName()), + QVERIFY(utils.connection()); + KDB_VERIFY(utils.connection(), !utils.connection()->databaseExists(utils.connection()->data().databaseName()), "Database should not exist"); - KDB_EXPECT_FAIL(utils.connection, utils.connection->useDatabase(), + KDB_EXPECT_FAIL(utils.connection(), utils.connection()->useDatabase(), ERR_OBJECT_NOT_FOUND, "Should fail to use database"); - KDB_EXPECT_FAIL(utils.connection, utils.connection->isDatabaseUsed(), + KDB_EXPECT_FAIL(utils.connection(), utils.connection()->isDatabaseUsed(), ERR_OBJECT_NOT_FOUND, "Database can't be used after call to useDatabase()"); - QVERIFY2(utils.connection->closeDatabase(), "Closing after failed USE should work"); - KDB_VERIFY(utils.connection, utils.connection->disconnect(), "Failed to disconnect database"); - QVERIFY2(!utils.connection->isConnected(), "Should not be connected"); + QVERIFY2(utils.connection()->closeDatabase(), "Closing after failed USE should work"); + KDB_VERIFY(utils.connection(), utils.connection()->disconnect(), "Failed to disconnect database"); + QVERIFY2(!utils.connection()->isConnected(), "Should not be connected"); } void ConnectionTest::cleanupTestCase() { } diff --git a/autotests/KDbTest.cpp b/autotests/KDbTest.cpp index 57c5b6b5..fe95c134 100644 --- a/autotests/KDbTest.cpp +++ b/autotests/KDbTest.cpp @@ -1,1209 +1,1209 @@ /* This file is part of the KDE project Copyright (C) 2015-2016 Jarosław Staniek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "KDbTest.h" #include #include #include #include #include QTEST_GUILESS_MAIN(KDbTest) void KDbTest::initTestCase() { } void KDbTest::testVersionInfo() { KDbVersionInfo info = KDb::version(); KDbVersionInfo info2(KDb::version()); QCOMPARE(info, info2); KDbVersionInfo info3(info.major(), info.minor(), info.release()); QCOMPARE(info, info3); QVERIFY(KDbVersionInfo(0, 0, 0).isNull()); QVERIFY(!info.isNull()); QVERIFY(!info2.isNull()); QVERIFY(!info3.isNull()); } //! @todo add tests requiring connection #if 0 //! @overload bool deleteRecord(KDbConnection*, const KDbTableSchema&, const QString &, KDbField::Type, const QVariant &) KDB_EXPORT bool deleteRecords(KDbConnection* conn, const QString &tableName, const QString &keyname, KDbField::Type keytype, const QVariant &keyval); //! Deletes records using one generic criteria. inline bool deleteRecords(KDbConnection* conn, const KDbTableSchema &table, const QString &keyname, KDbField::Type keytype, const QVariant &keyval) //! @overload bool deleteRecords(KDbConnection*, const QString&, const QString&, KDbField::Type, const QVariant&); inline bool deleteRecords(KDbConnection* conn, const QString &tableName, const QString &keyname, const QString &keyval) //! @overload bool deleteRecords(KDbConnection*, const QString&, const QString&, const QString&); inline bool deleteRecords(KDbConnection* conn, const KDbTableSchema &table, const QString &keyname, const QString &keyval) //! @overload bool deleteRecords(KDbConnection*, const KDbTableSchema&, const QString&, const QString&); inline bool deleteRecords(KDbConnection* conn, const KDbTableSchema &table, const QString& keyname, int keyval) //! @overload bool deleteRecords(KDbConnection*, const KDbTableSchema&, const QString&, int); inline bool deleteRecords(KDbConnection* conn, const QString &tableName, const QString& keyname, int keyval) //! Deletes records with two generic criterias. KDB_EXPORT bool deleteRecords(KDbConnection* conn, const QString &tableName, const QString &keyname1, KDbField::Type keytype1, const QVariant& keyval1, const QString &keyname2, KDbField::Type keytype2, const QVariant& keyval2); //! Deletes records with three generic criterias. KDB_EXPORT bool deleteRecords(KDbConnection* conn, const QString &tableName, const QString &keyname1, KDbField::Type keytype1, const QVariant& keyval1, const QString &keyname2, KDbField::Type keytype2, const QVariant& keyval2, const QString &keyname3, KDbField::Type keytype3, const QVariant& keyval3); //! Deletes all records from table @a tableName. KDB_EXPORT bool deleteAllRecords(KDbConnection* conn, const QString &tableName); //! @overload bool deleteAllRecords(KDbConnection*, const QString&); inline bool deleteAllRecords(KDbConnection* conn, const KDbTableSchema &table) #endif void KDbTest::testFieldTypes() { QCOMPARE(KDbField::FirstType, KDbField::Byte); QCOMPARE(KDbField::LastType, KDbField::BLOB); QVERIFY(KDbField::FirstType < KDbField::LastType); } void KDbTest::testFieldTypesForGroup_data() { QTest::addColumn("typeGroup"); QTest::addColumn>("types"); int c = 0; ++c; QTest::newRow("invalid") << KDbField::InvalidGroup << (QList() << KDbField::InvalidType); ++c; QTest::newRow("text") << KDbField::TextGroup << (QList() << KDbField::Text << KDbField::LongText); ++c; QTest::newRow("integer") << KDbField::IntegerGroup << (QList() << KDbField::Byte << KDbField::ShortInteger << KDbField::Integer << KDbField::BigInteger); ++c; QTest::newRow("float") << KDbField::FloatGroup << (QList() << KDbField::Float << KDbField::Double); ++c; QTest::newRow("boolean") << KDbField::BooleanGroup << (QList() << KDbField::Boolean); ++c; QTest::newRow("datetime") << KDbField::DateTimeGroup << (QList() << KDbField::Date << KDbField::DateTime << KDbField::Time); ++c; QTest::newRow("blob") << KDbField::BLOBGroup << (QList() << KDbField::BLOB); QCOMPARE(c, KDbField::typeGroupsCount()); // make sure we're checking everything } void KDbTest::testFieldTypesForGroup() { QFETCH(KDbField::TypeGroup, typeGroup); QFETCH(QList, types); QCOMPARE(KDb::fieldTypesForGroup(typeGroup), types); } void KDbTest::testFieldTypeNamesAndStringsForGroup_data() { QTest::addColumn("typeGroup"); QTest::addColumn>("typeNames"); QTest::addColumn("typeStrings"); int c = 0; ++c; QTest::newRow("invalid") << KDbField::InvalidGroup << (QList() << "Invalid Type") << (QStringList() << "InvalidType"); ++c; QTest::newRow("text") << KDbField::TextGroup << (QList() << "Text" << "Long Text") << (QStringList() << "Text" << "LongText"); ++c; QTest::newRow("integer") << KDbField::IntegerGroup << (QList() << "Byte" << "Short Integer Number" << "Integer Number" << "Big Integer Number") << (QStringList() << "Byte" << "ShortInteger" << "Integer" << "BigInteger"); ++c; QTest::newRow("float") << KDbField::FloatGroup << (QList() << "Single Precision Number" << "Double Precision Number") << (QStringList() << "Float" << "Double"); ++c; QTest::newRow("boolean") << KDbField::BooleanGroup << (QList() << "Yes/No Value") << (QStringList() << "Boolean"); ++c; QTest::newRow("datetime") << KDbField::DateTimeGroup << (QList() << "Date" << "Date and Time" << "Time") << (QStringList() << "Date" << "DateTime" << "Time"); ++c; QTest::newRow("blob") << KDbField::BLOBGroup << (QList() << "Object") << (QStringList() << "BLOB"); QCOMPARE(c, KDbField::typeGroupsCount()); // make sure we're checking everything } void KDbTest::testFieldTypeNamesAndStringsForGroup() { QFETCH(KDbField::TypeGroup, typeGroup); QFETCH(QList, typeNames); QFETCH(QStringList, typeStrings); QStringList translatedNames; foreach(const QByteArray &name, typeNames) { translatedNames.append(KDbField::tr(name.constData())); } QCOMPARE(KDb::fieldTypeNamesForGroup(typeGroup), translatedNames); QCOMPARE(KDb::fieldTypeStringsForGroup(typeGroup), typeStrings); } void KDbTest::testDefaultFieldTypeForGroup() { int c = 0; ++c; QCOMPARE(KDb::defaultFieldTypeForGroup(KDbField::InvalidGroup), KDbField::InvalidType); ++c; QCOMPARE(KDb::defaultFieldTypeForGroup(KDbField::TextGroup), KDbField::Text); ++c; QCOMPARE(KDb::defaultFieldTypeForGroup(KDbField::IntegerGroup), KDbField::Integer); ++c; QCOMPARE(KDb::defaultFieldTypeForGroup(KDbField::FloatGroup), KDbField::Double); ++c; QCOMPARE(KDb::defaultFieldTypeForGroup(KDbField::BooleanGroup), KDbField::Boolean); ++c; QCOMPARE(KDb::defaultFieldTypeForGroup(KDbField::DateTimeGroup), KDbField::Date); ++c; QCOMPARE(KDb::defaultFieldTypeForGroup(KDbField::BLOBGroup), KDbField::BLOB); QCOMPARE(c, KDbField::typeGroupsCount()); // make sure we're checking everything } void KDbTest::testSimplifiedFieldTypeName() { int c = 0; ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::InvalidType), KDbField::tr("Invalid Group")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Byte), KDbField::tr("Number")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::ShortInteger), KDbField::tr("Number")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Integer), KDbField::tr("Number")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::BigInteger), KDbField::tr("Number")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Boolean), KDbField::tr("Yes/No")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Date), KDbField::tr("Date/Time")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::DateTime), KDbField::tr("Date/Time")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Time), KDbField::tr("Date/Time")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Float), KDbField::tr("Number")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Double), KDbField::tr("Number")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Text), KDbField::tr("Text")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::LongText), KDbField::tr("Text")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::BLOB), KDbField::tr("Image")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Null), KDbField::tr("Invalid Group")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Asterisk), KDbField::tr("Invalid Group")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Enum), KDbField::tr("Invalid Group")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Map), KDbField::tr("Invalid Group")); ++c; QCOMPARE(KDb::simplifiedFieldTypeName(KDbField::Tuple), KDbField::tr("Invalid Group")); QCOMPARE(c, KDbField::typesCount() + KDbField::specialTypesCount()); // make sure we're checking everything } void KDbTest::testIsEmptyValue_data() { QTest::addColumn("type"); QTest::addColumn("value"); QTest::addColumn("result"); QTest::addColumn("resultForNullValue"); QTest::addColumn("resultForEmptyString"); int c = 0; ++c; QTest::newRow("Invalid") << KDbField::InvalidType << QVariant("abc") << false << true << false; ++c; QTest::newRow("Byte") << KDbField::Byte << QVariant(17) << false << true << false; ++c; QTest::newRow("ShortInteger") << KDbField::ShortInteger << QVariant(1733) << false << true << false; ++c; QTest::newRow("Integer") << KDbField::Integer << QVariant(11733) << false << true << false; ++c; QTest::newRow("BigInteger") << KDbField::BigInteger << QVariant(0xffffff12) << false << true << false; ++c; QTest::newRow("Boolean") << KDbField::Boolean << QVariant(false) << false << true << false; ++c; QTest::newRow("Date") << KDbField::Date << QVariant(QDate(2015, 11, 07)) << false << true << false; ++c; QTest::newRow("DateTime") << KDbField::DateTime << QVariant(QDateTime(QDate(2015, 11, 07), QTime(12, 58, 17))) << false << true << false; ++c; QTest::newRow("Time") << KDbField::Time << QVariant(QTime(12, 58, 17)) << false << true << false; ++c; QTest::newRow("Float") << KDbField::Float << QVariant(3.14) << false << true << false; ++c; QTest::newRow("Double") << KDbField::Double << QVariant(3.1415) << false << true << false; ++c; QTest::newRow("Text") << KDbField::Text << QVariant(QLatin1String("abc")) << false << false << true; ++c; QTest::newRow("LongText") << KDbField::LongText << QVariant(QLatin1String("abc")) << false << false << true; ++c; QTest::newRow("BLOB") << KDbField::LongText << QVariant(QByteArray(5, 'X')) << false << false << true; ++c; QTest::newRow("Null") << KDbField::Null << QVariant(123) << false << true << false; ++c; QTest::newRow("Asterisk") << KDbField::Asterisk << QVariant(123) << false << true << false; ++c; QTest::newRow("Enum") << KDbField::Enum << QVariant(123) << false << true << false; ++c; QTest::newRow("Map") << KDbField::Map << QVariant(123) << false << true << false; ++c; QTest::newRow("Tuple") << KDbField::Tuple << QVariant(123) << false << true << false; QCOMPARE(c, KDbField::typesCount() + KDbField::specialTypesCount()); } void KDbTest::testIsEmptyValue() { QFETCH(KDbField::Type, type); QFETCH(QVariant, value); QFETCH(bool, result); QFETCH(bool, resultForNullValue); QFETCH(bool, resultForEmptyString); QCOMPARE(KDb::isEmptyValue(type, QVariant()), resultForNullValue); QCOMPARE(KDb::isEmptyValue(type, QVariant(QString(""))), resultForEmptyString); QCOMPARE(KDb::isEmptyValue(type, value), result); } //! @todo add tests #if 0 /*! Sets string pointed by @a msg to an error message retrieved from @a resultable, and string pointed by @a details to details of this error (server message and result number). Does nothing if @a result is empty. In this case @a msg and @a details strings are not overwritten. If the string pointed by @a msg is not empty, @a result message is appended to the string pointed by @a details. */ KDB_EXPORT void getHTMLErrorMesage(const KDbResultable& resultable, QString *msg, QString *details); /*! This methods works like above, but appends both a message and a description to string pointed by @a msg. */ KDB_EXPORT void getHTMLErrorMesage(const KDbResultable& resultable, QString *msg); /*! This methods works like above, but works on @a result's members instead. */ KDB_EXPORT void getHTMLErrorMesage(const KDbResultable& resultable, KDbResultInfo *info); /*! Function useful for building WHERE parts of SQL statements. Constructs an SQL string like "fielname = value" for specific @a drv driver, field type @a t, @a fieldName and @a value. If @a value is null, "fieldname is NULL" string is returned. */ KDB_EXPORT KDbEscapedString sqlWhere(KDbDriver *drv, KDbField::Type t, const QString& fieldName, const QVariant& value); /*! Find an identifier for object @a objName of type @a objType. On success true is returned and *id is set to the value of the identifier. On failure false is returned. If there is no such object, @c cancelled value is returned. */ KDB_EXPORT tristate idForObjectName(KDbConnection* conn, int *id, const QString& objName, int objType); /*! @return a number of columns that can be retrieved from table or query schema. In case of query, expanded fields are counted. Can return -1 if @a tableOrQuery has neither table or query assigned. */ KDB_EXPORT int fieldCount(KDbTableOrQuerySchema* tableOrQuery); /*! shows connection test dialog with a progress bar indicating connection testing (within a second thread). @a data is used to perform a (temporary) test connection. @a msgHandler is used to display errors. On successful connecting, a message is displayed. After testing, temporary connection is closed. */ KDB_EXPORT void connectionTestDialog(QWidget* parent, const KDbConnectionData& data, KDbMessageHandler* msgHandler); //! Used in splitToTableAndFieldParts(). enum SplitToTableAndFieldPartsOptions { FailIfNoTableOrFieldName = 0, //!< default value for splitToTableAndFieldParts() SetFieldNameIfNoTableName = 1 //!< see splitToTableAndFieldParts() }; /*! Splits @a string like "table.field" into "table" and "field" parts. On success, a table name is passed to @a tableName and a field name is passed to @a fieldName. The function fails if either: - @a string is empty, or - @a string does not contain '.' character and @a option is FailIfNoTableOrFieldName (the default), or - '.' character is the first of last character of @a string (in this case table name or field name could become empty what is not allowed). If @a option is SetFieldNameIfNoTableName and @a string does not contain '.', @a string is passed to @a fieldName and @a tableName is set to QString() without failure. If function fails, @a tableName and @a fieldName remain unchanged. @return true on success. */ KDB_EXPORT bool splitToTableAndFieldParts(const QString& string, QString *tableName, QString *fieldName, SplitToTableAndFieldPartsOptions option = FailIfNoTableOrFieldName); /*! @return true if @a type supports "visibleDecimalPlaces" property. */ KDB_EXPORT bool supportsVisibleDecimalPlacesProperty(KDbField::Type type); //*! @return string constructed by converting @a value. * If @a decimalPlaces is < 0, all meaningful fractional digits are returned (up to 10). * If @a automatically is 0, just integer part is returned. * If @a automatically is > 0, fractional part should take exactly N digits: if the fractional part is shorter than N, additional zeros are appended. Examples: * numberToString(12.345, 6) == "12.345000" * numberToString(12.345, 0) == "12" * numberToString(12.345, -1) == "12.345" * numberToString(12.0, -1) == "12" * numberToString(0.0, -1) == "0" @note No rounding is performed @note No thousands group separator is used. Decimal symbol is '.'. @see KDb::numberToLocaleString() KDbField::visibleDecimalPlaces() */ KDB_EXPORT QString numberToString(double value, int decimalPlaces); /*! Like KDb::numberToString() but formats the string using locale.toString(). If @a locale if @c nullptr, desault QLocale is used. @see KDb::numberToString() KDbField::visibleDecimalPlaces() */ KDB_EXPORT QString numberToLocaleString(double value, int decimalPlaces, const QLocale *locale = nullptr); //! @return true if @a propertyName is a builtin field property. KDB_EXPORT bool isBuiltinTableFieldProperty(const QByteArray& propertyName); //! @return true if @a propertyName is an extended field property. KDB_EXPORT bool isExtendedTableFieldProperty(const QByteArray& propertyName); //! @return true if @a propertyName is belongs to lookup field's schema. KDB_EXPORT bool isLookupFieldSchemaProperty(const QByteArray& propertyName); /*! @return type of field for integer value @a type. If @a type cannot be casted to KDbField::Type, KDbField::InvalidType is returned. This can be used when type information is deserialized from a string or QVariant. */ KDB_EXPORT KDbField::Type intToFieldType(int type); /*! @return type group of field for integer value @a typeGroup. If @a typeGroup cannot be casted to KDbField::TypeGroup, KDbField::InvalidGroup is returned. This can be used when type information is deserialized from a string or QVariant. */ KDB_EXPORT KDbField::TypeGroup intToFieldTypeGroup(int typeGroup); /*! Gets property values for the lookup schema @a lookup. @a values is cleared before filling. This function is used e.g. for altering table design. */ KDB_EXPORT void getProperties(const KDbLookupFieldSchema *lookup, QMap *values); /*! Gets property values for @a field. Properties from extended schema are included. @a values is cleared before filling. The same number of properties in the same order is returned. This function is used e.g. for altering table design. */ KDB_EXPORT void getFieldProperties(const KDbField &field, QMap *values); /*! Sets property values for @a field. @return true if all the values are valid and allowed. On failure contents of @a field is undefined. Properties from extended schema are also supported. This function is used e.g. by KDbAlterTableHandler when property information comes in form of text. */ KDB_EXPORT bool setFieldProperties(KDbField *field, const QMap& values); /*! Sets property value for @a field. @return true if the property has been found and the value is valid for this property. On failure contents of @a field is undefined. Properties from extended schema are also supported as well as QVariant customProperty(const QString& propertyName) const; This function is used e.g. by KDbAlterTableHandler when property information comes in form of text. */ KDB_EXPORT bool setFieldProperty(KDbField *field, const QByteArray& propertyName, const QVariant& value); /*! @return property value loaded from a DOM @a node, written in a QtDesigner-like notation: <number>int</number> or <bool>bool</bool>, etc. Supported types are "string", "cstring", "bool", "number". For invalid values null QVariant is returned. You can check the validity of the returned value using QVariant::type(). */ KDB_EXPORT QVariant loadPropertyValueFromDom(const QDomNode& node, bool *ok); /*! Convenience version of loadPropertyValueFromDom(). @return int value. */ KDB_EXPORT int loadIntPropertyValueFromDom(const QDomNode& node, bool* ok); /*! Convenience version of loadPropertyValueFromDom(). @return QString value. */ KDB_EXPORT QString loadStringPropertyValueFromDom(const QDomNode& node, bool* ok); /*! Saves integer element for value @a value to @a doc document within parent element @a parentEl. The value will be enclosed in "number" element and "elementName" element. Example: saveNumberElementToDom(doc, parentEl, "height", 15) will create @code 15 @endcode @return the reference to element created with tag elementName. */ KDB_EXPORT QDomElement saveNumberElementToDom(QDomDocument *doc, QDomElement *parentEl, const QString& elementName, int value); /*! Saves boolean element for value @a value to @a doc document within parent element @a parentEl. Like saveNumberElementToDom() but creates "bool" tags. True/false values will be saved as "true"/"false" strings. @return the reference to element created with tag elementName. */ KDB_EXPORT QDomElement saveBooleanElementToDom(QDomDocument *doc, QDomElement *parentEl, const QString& elementName, bool value); //! @return equivalent of empty (default) value that can be set for a database field of type @a type /*! In particular returns: - empty string for text types, - 0 for integer and floating-point types, - false for boolean types, - a null byte array for BLOB type, - current date, time, date+time is returned (measured at client side) for date, time and date/time types respectively, - a null QVariant for unsupported values such as KDbField::InvalidType. */ KDB_EXPORT QVariant emptyValueForFieldType(KDbField::Type type); //! @return a value that can be set for a database field of type @a type having "notEmpty" property set. /*! It works in a similar way as @ref QVariant KDb::emptyValueForFieldType(KDbField::Type type) with the following differences: - " " string (a single space) is returned for Text and LongText types - a byte array with saved "filenew" PNG image (icon) for BLOB type Returns null QVariant for unsupported values like KDbField::InvalidType. */ KDB_EXPORT QVariant notEmptyValueForFieldType(KDbField::Type type); /*! @return true if the @a word is an reserved KDbSQL keyword See src/generated/sqlkeywords.cpp in the KDb source code. @todo add function returning list of keywords. */ KDB_EXPORT bool isKDbSqlKeyword(const QByteArray& word); //! @return @a string string with applied KDbSQL identifier escaping /*! This escaping can be used for field, table, database names, etc. Use it for user-visible backend-independent statements. @see KDb::escapeIdentifierAndAddQuotes() */ KDB_EXPORT QString escapeIdentifier(const QString& string); //! @overload QString escapeIdentifier(const QString&) KDB_EXPORT QByteArray escapeIdentifier(const QByteArray& string); //! @return @a string string with applied KDbSQL identifier escaping and enclosed in " quotes /*! This escaping can be used for field, table, database names, etc. Use it for user-visible backend-independent statements. @see KDb::escapeIdentifier */ KDB_EXPORT QString escapeIdentifierAndAddQuotes(const QString& string); //! @overload QString escapeIdentifierAndAddQuotes(const QString&) KDB_EXPORT QByteArray escapeIdentifierAndAddQuotes(const QByteArray& string); /*! @return escaped string @a string w using KDbSQL dialect, i.e. doubles single quotes ("'") and inserts the string into single quotes. Quotes "'" are prepended and appended. Also escapes \\n, \\r, \\t, \\\\, \\0. Use it for user-visible backend-independent statements. */ KDB_EXPORT QString escapeString(const QString& string); /** * @brief Returns escaped string @a string * * If @a drv driver is present, it is used to perform escaping, otherwise escapeString() is used * so the KDbSQL dialect-escaping is performed. */ KDB_EXPORT KDbEscapedString escapeString(KDbDriver *drv, const QString& string); /** * @brief Returns escaped string @a string * * If @a conn is present, its driver is used to perform escaping, otherwise escapeString() is used * so the KDbSQL dialect-escaping is performed. */ KDB_EXPORT KDbEscapedString escapeString(KDbConnection *conn, const QString& string); #endif void KDbTest::testUnescapeString_data() { QTest::addColumn("sequence"); QTest::addColumn("result"); QTest::addColumn("quote"); // can be ' or ", if 0 then both variants are checked QTest::addColumn("errorPosition"); QTest::addColumn("errorPositionWhenAppended"); // quote-independent cases, success #define T2(tag, sequence, result, quote) QTest::newRow(tag) << QString::fromUtf8(sequence) \ << QString::fromUtf8(result) << quote << -1 << -1 #define T(tag, sequence, result) T2(tag, sequence, result, '\0') QTest::newRow("null") << QString() << QString() << '\0' << -1 << -1; QTest::newRow("\\0") << QString("\\0") << QString(QLatin1Char('\0')) << '\0' << -1 << -1; const char *s = " String without escaping %_? 𝌆 ©"; T("without escaping", s, s); T("empty", "", ""); T("\\'", "\\'", "'"); T("\\\"", "\\\"", "\""); T("\\\\", "\\\\", "\\"); T("\\b", "\\b", "\b"); T("\\f", "\\f", "\f"); T("\\n", "\\n", "\n"); T("\\r", "\\r", "\r"); T("\\t", "\\t", "\t"); T("\\v", "\\v", "\v"); T("_\\_", "_\\_", "__"); T("?\\?", "?\\?", "??"); T("%\\%", "%\\%", "%%"); T("ignored \\ in \\a", "\\a", "a"); T("ignored \\ in \\♥", "\\♥ ", "♥ "); T("ignored \\ in 𝌆\\\\\\a", "𝌆\\\\\\a", "𝌆\\a"); T("unfinished \\", "\\", ""); T("unfinished \\ 2", "one two\\", "one two"); T("\\xA9", "\\xA9", "©"); T("\\xa9\\xa9", "\\xa9\\xa9", "©©"); QTest::newRow("\\x00") << QString("\\x00") << QString(QLatin1Char('\0')) << '\0' << -1 << -1; QTest::newRow("\\u0000") << QString("\\u0000") << QString(QChar(static_cast(0))) << '\0' << -1 << -1; T("\\u2665", "\\u2665", "♥"); #ifndef _MSC_VER // does not work with MSVC: "warning C4566: character represented // by universal-character-name cannot be represented in the current code page" T("\\xff", "\\xff", "\u00ff"); T("\\uffff", "\\uffff", "\uffff"); #endif QTest::newRow("\\u{0}") << QString("\\u{0}") << QString(QLatin1Char('\0')) << '\0' << -1 << -1; QTest::newRow("\\u{0000000000}") << QString("\\u{0000000000}") << QString(QLatin1Char('\0')) << '\0' << -1 << -1; T("\\u{A9}", "\\u{A9}", "©"); T("\\u{a9}", "\\u{a9}", "©"); T("\\u{0a9}", "\\u{0a9}", "©"); T("\\u{00a9}", "\\u{00a9}", "©"); T("\\u{2665}", "\\u{2665}", "♥"); T("\\u{02665}", "\\u{02665}", "♥"); QTest::newRow("\\u{1D306}") << QString("\\u{1D306}") << QString(QChar(0x1D306)) << '\0' << -1 << -1; QTest::newRow("\\u{1d306}") << QString("\\u{1d306}") << QString(QChar(0x1d306)) << '\0' << -1 << -1; QTest::newRow("\\u{01D306}") << QString("\\u{01D306}") << QString(QChar(0x1D306)) << '\0' << -1 << -1; QTest::newRow("\\u{01d306}") << QString("\\u{01d306}") << QString(QChar(0x1d306)) << '\0' << -1 << -1; QTest::newRow("\\u{00001D306}") << QString("\\u{00001D306}") << QString(QChar(0x1D306)) << '\0' << -1 << -1; QTest::newRow("\\u{10FFFF}") << QString("\\u{10FFFF}") << QString(QChar(0x10FFFF)) << '\0' << -1 << -1; // quote-dependent cases, success T2("2x ' for ' quote", "''", "'", '\''); T2("4x ' for ' quote", "''''", "''", '\''); T2("2x \" for ' quote", "\"\"", "\"\"", '\''); T2("3x \" for ' quote", "\"\"\"", "\"\"\"", '\''); T2("2x ' for \" quote", "''", "''", '"'); T2("3x ' for \" quote", "'''", "'''", '"'); T2("2x \" for \" quote", "\"\"", "\"", '"'); T2("4x \" for \" quote", "\"\"\"\"", "\"\"", '"'); #undef T #undef T2 // failures QTest::newRow("invalid quote") << QString::fromUtf8("abc") << QString() << 'x' << 0 << 0; #define T(tag, sequence, quote, errorPosition, errorPositionWhenAppended) \ QTest::newRow(tag) << QString::fromUtf8(sequence) << QString() << quote \ << errorPosition << errorPositionWhenAppended T("missing ' quote", "'", '\'', 0, 0); T("missing \" quote", "\"", '"', 0, 0); T("invalid \\x", "\\x", '\0', 1, 2); T("invalid \\xQ", "\\xQ", '\0', 2, 2); T("invalid \\xQt", "\\xQt", '\0', 2, 2); T("invalid \\xAQ", "\\xAQ", '\0', 3, 3); T("invalid \\u", "\\u", '\0', 1, 2); T("invalid \\ua", "\\ua", '\0', 2, 3); T("invalid \\u40", "\\u40", '\0', 3, 4); T("invalid \\u405", "\\u405", '\0', 4, 5); T("invalid \\uQ", "\\uQ", '\0', 2, 2); T("invalid \\uQt", "\\uQt", '\0', 2, 2); T("invalid \\uQt5", "\\uQt5", '\0', 2, 2); T("invalid \\uQt57", "\\uQt57", '\0', 2, 2); T("invalid \\uaQ", "\\uaQ", '\0', 3, 3); T("invalid \\uabQ", "\\uabQ", '\0', 4, 4); T("invalid \\uabcQ", "\\uabcQ", '\0', 5, 5); T("invalid \\u{", "\\u{", '\0', 2, 3); T("invalid \\u{26", "\\u{26", '\0', 4, 5); T("invalid \\u{266", "\\u{266", '\0', 5, 6); T("invalid \\u{2665", "\\u{2665", '\0', 6, 7); T("invalid \\u{2665a", "\\u{2665a", '\0', 7, 8); T("invalid \\u{}", "\\u{}", '\0', 3, 3); T("invalid \\u{Q}", "\\u{Q}", '\0', 3, 3); T("invalid \\u{Qt}", "\\u{Qt}", '\0', 3, 3); T("invalid \\u{Qt5}", "\\u{Qt5}", '\0', 3, 3); T("invalid \\u{Qt57}", "\\u{Qt57}", '\0', 3, 3); T("invalid \\u{Qt57", "\\u{Qt57", '\0', 3, 3); T("invalid \\u{aQ}", "\\u{aQ}", '\0', 4, 4); T("invalid \\u{abQ}", "\\u{abQ}", '\0', 5, 5); T("invalid \\u{abcQ}", "\\u{abcQ}", '\0', 6, 6); T("invalid \\u{abcdQ}", "\\u{abcdQ}", '\0', 7, 7); T("invalid \\u{abcdQ}", "\\u{abcdQ}", '\0', 7, 7); T("invalid \\u{abcdfQ}", "\\u{abcdfQ}", '\0', 8, 8); T("invalid too large \\u{110000}", "\\u{110000}", '\0', 8, 8); T("invalid too large \\u{1100000}", "\\u{1100000}", '\0', 8, 8); T("invalid too large \\u{00110000}", "\\u{00110000}", '\0', 10, 10); } void KDbTest::testUnescapeStringHelper(const QString &sequenceString, const QString &resultString_, char quote, int errorPosition, int offset) { int actualErrorPosition = -2; QString resultString(resultString_); if (errorPosition >= 0) { errorPosition += offset; resultString.clear(); } //qDebug() << KDb::unescapeString("\\0bar", '\'', &errorPosition); #define COMPARE(x, y) \ if (x != y) { \ qDebug() << "sequenceString:" << sequenceString << "resultString:" << resultString; \ } \ QCOMPARE(x, y) if (quote == 0) { // both cases COMPARE(KDb::unescapeString(sequenceString, '\'', &actualErrorPosition), resultString); COMPARE(actualErrorPosition, errorPosition); COMPARE(KDb::unescapeString(sequenceString, '\'', nullptr), resultString); COMPARE(KDb::unescapeString(sequenceString, '"', &actualErrorPosition), resultString); COMPARE(actualErrorPosition, errorPosition); COMPARE(KDb::unescapeString(sequenceString, '"', nullptr), resultString); } else { if (quote != '\'' && quote != '"') { resultString.clear(); errorPosition = 0; } COMPARE(KDb::unescapeString(sequenceString, quote, &actualErrorPosition), resultString); COMPARE(actualErrorPosition, errorPosition); COMPARE(KDb::unescapeString(sequenceString, quote, nullptr), resultString); } #undef CHECK_POS } void KDbTest::testUnescapeString() { QFETCH(QString, sequence); QFETCH(QString, result); QFETCH(char, quote); QFETCH(int, errorPosition); QFETCH(int, errorPositionWhenAppended); testUnescapeStringHelper(sequence, result, quote, errorPosition, 0); testUnescapeStringHelper("foo" + sequence, "foo" + result, quote, errorPosition, 3); testUnescapeStringHelper(sequence + " bar", result + " bar", quote, errorPositionWhenAppended, 0); testUnescapeStringHelper("foo" + sequence + " bar", "foo" + result + " bar", quote, errorPositionWhenAppended, 3); } void KDbTest::testEscapeBLOB_data() { QTest::addColumn("blob"); QTest::addColumn("escapedX"); QTest::addColumn("escaped0x"); QTest::addColumn("escapedHex"); QTest::addColumn("escapedOctal"); QTest::addColumn("escapedBytea"); QTest::newRow("") << QByteArray() << QString("X''") << QString() << QString("") << QString("''") << QString("E'\\\\x'::bytea"); QTest::newRow("0,1,k") << QByteArray("\0\1k", 3) << QString("X'00016B'") << QString("0x00016B") << QString("00016B") << QString("'\\\\000\\\\001k'") << QString("E'\\\\x00016B'::bytea"); QTest::newRow("ABC\\\\0") << QByteArray("ABC\0", 4) << QString("X'41424300'") << QString("0x41424300") << QString("41424300") << QString("'ABC\\\\000'") << QString("E'\\\\x41424300'::bytea"); QTest::newRow("'") << QByteArray("'") << QString("X'27'") << QString("0x27") << QString("27") << QString("'\\\\047'") << QString("E'\\\\x27'::bytea"); QTest::newRow("\\") << QByteArray("\\") << QString("X'5C'") << QString("0x5C") << QString("5C") << QString("'\\\\134'") << QString("E'\\\\x5C'::bytea"); } void KDbTest::testEscapeBLOB() { QFETCH(QByteArray, blob); QFETCH(QString, escapedX); QFETCH(QString, escaped0x); QFETCH(QString, escapedHex); QFETCH(QString, escapedOctal); QFETCH(QString, escapedBytea); QCOMPARE(KDb::escapeBLOB(blob, KDb::BLOBEscapingType::XHex), escapedX); QCOMPARE(KDb::escapeBLOB(blob, KDb::BLOBEscapingType::ZeroXHex), escaped0x); QCOMPARE(KDb::escapeBLOB(blob, KDb::BLOBEscapingType::Hex), escapedHex); QCOMPARE(KDb::escapeBLOB(blob, KDb::BLOBEscapingType::Octal), escapedOctal); QCOMPARE(KDb::escapeBLOB(blob, KDb::BLOBEscapingType::ByteaHex), escapedBytea); } void KDbTest::testPgsqlByteaToByteArray() { QCOMPARE(KDb::pgsqlByteaToByteArray(nullptr, 0), QByteArray()); QCOMPARE(KDb::pgsqlByteaToByteArray("", 0), QByteArray()); QCOMPARE(KDb::pgsqlByteaToByteArray(" ", 0), QByteArray()); QCOMPARE(KDb::pgsqlByteaToByteArray("\\101"), QByteArray("A")); QCOMPARE(KDb::pgsqlByteaToByteArray("\\101", 4), QByteArray("A")); QCOMPARE(KDb::pgsqlByteaToByteArray("\\101B", 4), QByteArray("A")); // cut-off at #4 QCOMPARE(KDb::pgsqlByteaToByteArray("\\'\\\\\\'"), QByteArray("\'\\\'")); QCOMPARE(KDb::pgsqlByteaToByteArray("\\\\a\\377bc\\'d\"\n"), QByteArray("\\a\377bc\'d\"\n")); } void KDbTest::testXHexToByteArray_data() { QTest::addColumn("data"); QTest::addColumn("length"); // -2 means "compute length", other values: pass it as is QTest::addColumn("ok"); QTest::addColumn("result"); QTest::newRow("") << QByteArray() << 0 << false << QByteArray(); QTest::newRow("bad prefix") << QByteArray("bad") << -2 << false << QByteArray(); QTest::newRow("X") << QByteArray("X") << -2 << false << QByteArray(); QTest::newRow("X'") << QByteArray("X'") << -2 << false << QByteArray(); QTest::newRow("X''") << QByteArray("X''") << -2 << true << QByteArray(); QTest::newRow("X'1") << QByteArray("X'1") << -2 << false << QByteArray(); QTest::newRow("X'1' cut") << QByteArray("X'1'") << 3 << false << QByteArray(); QTest::newRow("X'1'") << QByteArray("X'1'") << -2 << true << QByteArray("\1"); QTest::newRow("X'0'") << QByteArray("X'0'") << -2 << true << QByteArray("\0", 1); QTest::newRow("X'000'") << QByteArray("X'000'") << -2 << true << QByteArray("\0\0", 2); QTest::newRow("X'01'") << QByteArray("X'01'") << -2 << true << QByteArray("\1"); QTest::newRow("X'FeAb2C'") << QByteArray("X'FeAb2C'") << -2 << true << QByteArray("\376\253\54"); } void KDbTest::testXHexToByteArray() { QFETCH(QByteArray, data); QFETCH(int, length); QFETCH(bool, ok); QFETCH(QByteArray, result); bool actualOk; QCOMPARE(KDb::xHexToByteArray(data.constData(), length == -1 ? data.length() : length, &actualOk), result); QCOMPARE(actualOk, ok); QCOMPARE(KDb::xHexToByteArray(data.constData(), length, nullptr), result); } void KDbTest::testZeroXHexToByteArray_data() { QTest::addColumn("data"); QTest::addColumn("length"); // -2 means "compute length", other values: pass it as is QTest::addColumn("ok"); QTest::addColumn("result"); QTest::newRow("") << QByteArray() << 0 << false << QByteArray(); QTest::newRow("0") << QByteArray("0") << -2 << false << QByteArray(); QTest::newRow("0x") << QByteArray("0x") << -2 << false << QByteArray(); QTest::newRow("0X22") << QByteArray("0X22") << -2 << false << QByteArray(); QTest::newRow("bad prefix") << QByteArray("bad") << -2 << false << QByteArray(); QTest::newRow("0x0") << QByteArray("0x0") << -2 << true << QByteArray("\0", 1); QTest::newRow("0x0 cut") << QByteArray("0x0") << 2 << false << QByteArray(); QTest::newRow("0X0") << QByteArray("0X0") << -2 << false << QByteArray(); QTest::newRow("0x0123") << QByteArray("0x0123") << -2 << true << QByteArray("\1\43"); QTest::newRow("0x0123 cut") << QByteArray("0x0123") << 4 << true << QByteArray("\1"); QTest::newRow("0x00000'") << QByteArray("0x00000") << -2 << true << QByteArray("\0\0\0", 3); QTest::newRow("0xFeAb2C") << QByteArray("0xFeAb2C") << -2 << true << QByteArray("\376\253\54"); } void KDbTest::testZeroXHexToByteArray() { QFETCH(QByteArray, data); QFETCH(int, length); QFETCH(bool, ok); QFETCH(QByteArray, result); bool actualOk; QCOMPARE(KDb::zeroXHexToByteArray(data.constData(), length == -1 ? data.length() : length, &actualOk), result); QCOMPARE(actualOk, ok); QCOMPARE(KDb::zeroXHexToByteArray(data.constData(), length, nullptr), result); } //! @todo add tests #if 0 /*! @return int list converted from string list. If @a ok is not 0, *ok is set to result of the conversion. */ KDB_EXPORT QList stringListToIntList(const QStringList &list, bool *ok); /*! @return string converted from list @a list. Separators are ',' characters, "," and "\\" are escaped. @see KDb::deserializeList() */ KDB_EXPORT QString serializeList(const QStringList &list); /*! @return string list converted from @a data which was built using serializeList(). Separators are ',' characters, escaping is assumed as "\\,". */ KDB_EXPORT QStringList deserializeList(const QString &data); /*! @return int list converted from @a data which was built using serializeList(). Separators are ',' characters, escaping is assumed as "\\,". If @a ok is not 0, *ok is set to result of the conversion. @see KDb::stringListToIntList() */ KDB_EXPORT QList deserializeIntList(const QString &data, bool *ok); /*! @return string value serialized from a variant value @a v. This functions works like QVariant::toString() except the case when @a v is of type: - QByteArray - in this case KDb::escapeBLOB(v.toByteArray(), KDb::BLOBEscapeHex) is used. - QStringList - in this case KDb::serializeList(v.toStringList()) is used. This function is needed for handling values of random type, for example "defaultValue" property of table fields can contain value of any type. Note: the returned string is an unescaped string. */ KDB_EXPORT QString variantToString(const QVariant& v); /*! @return variant value of type @a type for a string @a s that was previously serialized using @ref variantToString( const QVariant& v ) function. @a ok is set to the result of the operation. With exception for types mentioned in documentation of variantToString(), QVariant::convert() is used for conversion. */ KDB_EXPORT QVariant stringToVariant(const QString& s, QVariant::Type type, bool* ok); /*! @return true if setting default value for @a field field is allowed. Fields with unique (and thus primary key) flags set do not accept default values. */ KDB_EXPORT bool isDefaultValueAllowed(const KDbField &field); //! Provides limits for values of type @a type /*! The result is put into integers pointed by @a minValue and @a maxValue. The limits are machine-independent,. what is useful for format and protocol compatibility. Supported types are Byte, ShortInteger, Integer and BigInteger. The value of @a signedness controls the values; they can be limited to unsigned or not. Results for BigInteger or non-integer types are the same as for Integer due to limitation of int type. Signed integers are assumed. @a minValue and @a maxValue must not be 0. */ KDB_EXPORT void getLimitsForFieldType(KDbField::Type type, qlonglong *minValue, qlonglong *maxValue, KDb::Signedness signedness = KDb::Signed); /*! @return type that's maximum of two integer types @a t1 and @a t2, e.g. Integer for (Byte, Integer). If one of the types is not of the integer group, KDbField::InvalidType is returned. Returned type may not fit to the result of evaluated expression that involves the arguments. For example, 100 is within Byte type, maximumForIntegerFieldTypes(Byte, Byte) is Byte but result of 100 * 100 exceeds the range of Byte. */ KDB_EXPORT KDbField::Type maximumForIntegerFieldTypes(KDbField::Type t1, KDbField::Type t2); #endif void KDbTest::testCstringToVariant_data() { QTest::addColumn("data"); // QString() -> 0, QString("") -> empty string "" QTest::addColumn("type"); QTest::addColumn("length"); QTest::addColumn("variant"); QTest::addColumn("signedness"); QTest::addColumn("okResult"); int c = 0; ++c; QTest::newRow("invalid1") << QString() << KDbField::InvalidType << -1 << QVariant() << KDb::Signed << false; QTest::newRow("invalid2") << "" << KDbField::InvalidType << -1 << QVariant() << KDb::Signed << false; QTest::newRow("invalid3") << "abc" << KDbField::InvalidType << 3 << QVariant() << KDb::Signed << false; ++c; QTest::newRow("byte1") << "0" << KDbField::Byte << 1 << QVariant(0) << KDb::Signed << true; QTest::newRow("ubyte1") << "0" << KDbField::Byte << 1 << QVariant(0) << KDb::Unsigned << true; QTest::newRow("byte2") << "42" << KDbField::Byte << -1 << QVariant(42) << KDb::Signed << true; QTest::newRow("ubyte2") << "42" << KDbField::Byte << -1 << QVariant(42) << KDb::Unsigned << true; QTest::newRow("byte3") << "129" << KDbField::Byte << -1 << QVariant() << KDb::Signed << false; QTest::newRow("ubyte3") << "129" << KDbField::Byte << -1 << QVariant(129) << KDb::Unsigned << true; QTest::newRow("byte4") << "-128" << KDbField::Byte << -1 << QVariant(-128) << KDb::Signed << true; QTest::newRow("ubyte4") << "-128" << KDbField::Byte << -1 << QVariant() << KDb::Unsigned << false; ++c; QTest::newRow("short1") << "-123" << KDbField::ShortInteger << -1 << QVariant(-123) << KDb::Signed << true; QTest::newRow("short2") << "942" << KDbField::ShortInteger << -1 << QVariant(942) << KDb::Signed << true; QTest::newRow("short3") << "32767" << KDbField::ShortInteger << -1 << QVariant(32767) << KDb::Signed << true; QTest::newRow("short4") << "32768" << KDbField::ShortInteger << -1 << QVariant() << KDb::Signed << false; QTest::newRow("ushort4") << "32768" << KDbField::ShortInteger << -1 << QVariant(32768) << KDb::Unsigned << true; QTest::newRow("short5") << "-32768" << KDbField::ShortInteger << -1 << QVariant(-32768) << KDb::Signed << true; QTest::newRow("ushort5") << "-32768" << KDbField::ShortInteger << -1 << QVariant() << KDb::Unsigned << false; ++c; QTest::newRow("int1") << QString::number(0x07FFFFFFF) << KDbField::Integer << -1 << QVariant(0x07FFFFFFF) << KDb::Signed << true; QTest::newRow("uint1") << QString::number(0x07FFFFFFF) << KDbField::Integer << -1 << QVariant(0x07FFFFFFF) << KDb::Unsigned << true; QTest::newRow("int2") << QString::number(-0x07FFFFFFF) << KDbField::Integer << -1 << QVariant(-0x07FFFFFFF) << KDb::Signed << true; QTest::newRow("uint2") << QString::number(-0x07FFFFFFF) << KDbField::Integer << -1 << QVariant() << KDb::Unsigned << false; QTest::newRow("int3") << QString::number(std::numeric_limits::min()) << KDbField::Integer << -1 << QVariant() << KDb::Signed << false; QTest::newRow("uint4") << "-1" << KDbField::Integer << -1 << QVariant() << KDb::Unsigned << false; QTest::newRow("int4") << "-1" << KDbField::Integer << -1 << QVariant(-1) << KDb::Signed << true; //!< @todo cannot be larger? ++c; QTest::newRow("bigint1") << QString::number(0x07FFFFFFF) << KDbField::BigInteger << -1 << QVariant(0x07FFFFFFF) << KDb::Signed << true; QTest::newRow("ubigint1") << QString::number(0x07FFFFFFF) << KDbField::BigInteger << -1 << QVariant(0x07FFFFFFF) << KDb::Unsigned << true; QTest::newRow("bigint2") << QString::number(-0x07FFFFFFF) << KDbField::BigInteger << -1 << QVariant(-0x07FFFFFFF) << KDb::Signed << true; QTest::newRow("ubigint2") << QString::number(-0x07FFFFFFF) << KDbField::BigInteger << -1 << QVariant() << KDb::Unsigned << false; QTest::newRow("bigint3") << QString::number(std::numeric_limits::min()) << KDbField::BigInteger << -1 << QVariant() << KDb::Signed << false; QTest::newRow("ubigint4") << "-1" << KDbField::BigInteger << -1 << QVariant() << KDb::Unsigned << false; QTest::newRow("bigint4") << "-1" << KDbField::BigInteger << -1 << QVariant(-1) << KDb::Signed << true; ++c; QTest::newRow("bool0") << "0" << KDbField::Boolean << -1 << QVariant(false) << KDb::Signed << true; QTest::newRow("bool1") << "1" << KDbField::Boolean << -1 << QVariant(true) << KDb::Signed << true; QTest::newRow("bool-") << "-" << KDbField::Boolean << -1 << QVariant(true) << KDb::Signed << true; QTest::newRow("bool5") << "5" << KDbField::Boolean << -1 << QVariant(true) << KDb::Signed << true; QTest::newRow("bool false") << "false" << KDbField::Boolean << -1 << QVariant(false) << KDb::Signed << true; QTest::newRow("bool False") << "False" << KDbField::Boolean << -1 << QVariant(false) << KDb::Signed << true; QTest::newRow("bool TRUE") << "TRUE" << KDbField::Boolean << -1 << QVariant(true) << KDb::Signed << true; QTest::newRow("bool true") << "true" << KDbField::Boolean << -1 << QVariant(true) << KDb::Signed << true; QTest::newRow("bool no") << "no" << KDbField::Boolean << -1 << QVariant(true) << KDb::Signed << true; // surprised? See docs for QVariant::toBool(). ++c; //! @todo support Date ++c; //! @todo support DateTime ++c; //! @todo support Time ++c; //! @todo support Float ++c; //! @todo support Double ++c; //! @todo support Text ++c; //! @todo support LongText ++c; //! @todo support BLOB ++c; QTest::newRow("Null") << " " << KDbField::Null << -1 << QVariant() << KDb::Signed << false; ++c; QTest::newRow("Asterisk") << " " << KDbField::Asterisk << -1 << QVariant() << KDb::Signed << false; ++c; QTest::newRow("Enum") << " " << KDbField::Enum << -1 << QVariant() << KDb::Signed << false; ++c; QTest::newRow("Map") << " " << KDbField::Map << -1 << QVariant() << KDb::Signed << false; ++c; QTest::newRow("Tuple") << " " << KDbField::Tuple << -1 << QVariant() << KDb::Signed << false; QCOMPARE(c, KDbField::typesCount() + KDbField::specialTypesCount()); } void KDbTest::testCstringToVariant() { QFETCH(QString, data); QFETCH(KDbField::Type, type); QFETCH(int, length); QFETCH(QVariant, variant); QFETCH(KDb::Signedness, signedness); QFETCH(bool, okResult); bool ok; const QByteArray ba(data.toUtf8()); // to avoid pointer to temp. const char *realData = ba.isNull() ? nullptr : ba.constData(); QCOMPARE(KDb::cstringToVariant(realData, type, &ok, length, signedness), variant); QCOMPARE(ok, okResult); QCOMPARE(KDb::cstringToVariant(realData, type, nullptr, length, signedness), variant); // a case where ok == 0 if (realData) { QCOMPARE(KDb::cstringToVariant(realData, type, &ok, data.length(), signedness), variant); // a case where length is set QCOMPARE(ok, okResult); } QCOMPARE(KDb::cstringToVariant(nullptr, type, &ok, length, signedness), QVariant()); // a case where data == 0 (NULL) QVERIFY(ok || type < KDbField::Byte || type > KDbField::LastType); // fails for NULL if this type isn't allowed if (type != KDbField::Boolean) { QCOMPARE(KDb::cstringToVariant(realData, type, &ok, 0, signedness), QVariant()); // a case where length == 0 QVERIFY(!ok); } if (KDbField::isTextType(type)) { // a case where data == "" QCOMPARE(KDb::cstringToVariant("", type, &ok, length, signedness), QVariant("")); QVERIFY(ok); } else if (type != KDbField::Boolean) { QCOMPARE(KDb::cstringToVariant("", type, &ok, length, signedness), QVariant()); QVERIFY(!ok); } } //! @todo add tests #if 0 /*! @return default file-based driver MIME type (typically something like "application/x-kexiproject-sqlite") */ KDB_EXPORT QString defaultFileBasedDriverMimeType(); /*! @return default file-based driver ID (currently, "org.kde.kdb.sqlite"). */ KDB_EXPORT QString defaultFileBasedDriverId(); /*! Escapes and converts value @a v (for type @a ftype) to string representation required by KDbSQL commands. For Date/Time type KDb::dateTimeToSql() is used. For BLOB type KDb::escapeBlob() with BLOBEscapingType::ZeroXHex conversion type is used. */ KDB_EXPORT KDbEscapedString valueToSql(KDbField::Type ftype, const QVariant& v); /*! Converts value @a v to string representation required by KDbSQL commands: ISO 8601 DateTime format - with "T" delimiter/ For specification see https://www.w3.org/TR/NOTE-datetime. Example: "1994-11-05T13:15:30" not "1994-11-05 13:15:30". @todo Add support for time zones */ KDB_EXPORT KDbEscapedString dateTimeToSql(const QDateTime& v); #ifdef KDB_DEBUG_GUI //! A prototype of handler for GUI debugger typedef void(*DebugGUIHandler)(const QString&); //! Sets handler for GUI debugger KDB_EXPORT void setDebugGUIHandler(DebugGUIHandler handler); //! Outputs string @a text to the GUI debugger KDB_EXPORT void debugGUI(const QString& text); //! A prototype of handler for GUI debugger (specialized for the Alter Table feature) typedef void(*AlterTableActionDebugGUIHandler)(const QString&, int); //! Sets handler for GUI debugger (specialized for the Alter Table feature) KDB_EXPORT void setAlterTableActionDebugHandler(AlterTableActionDebugGUIHandler handler); //! Outputs string @a text to the GUI debugger (specialized for the Alter Table feature); //! @a nestingLevel can be provided for nested outputs. KDB_EXPORT void alterTableActionDebugGUI(const QString& text, int nestingLevel = 0); #endif //! @return @a string if it is not empty, else returns @a stringIfEmpty. /*! This function is an optimization in cases when @a string is a result of expensive functioncall because any evaluation will be performed once, not twice. Another advantage is simpified code through the functional approach. The function expects bool isEmpty() method to be present in type T, so T can typically be QString or QByteArray. */ template T iifNotEmpty(const T &string, const T &stringIfEmpty) { return string.isEmpty() ? stringIfEmpty : string; } //! @overload iifNotEmpty(const T &string, const T &stringIfEmpty) template T iifNotEmpty(const QByteArray &string, const T &stringIfEmpty) { return iifNotEmpty(QLatin1String(string), stringIfEmpty); } //! @overload iifNotEmpty(const T &string, const T &stringIfEmpty) template T iifNotEmpty(const T &string, const QByteArray &stringIfEmpty) { return iifNotEmpty(string, QLatin1String(stringIfEmpty)); } //! @return @a value if @a ok is true, else returns default value T(). template T iif(bool ok, const T &value) { if (ok) { return value; } return T(); } /*! @return a list of paths that KDb will search when dynamically loading libraries (plugins) This is basicaly list of directories returned QCoreApplication::libraryPaths() that have readable subdirectory "kdb". @see QCoreApplication::libraryPaths() */ KDB_EXPORT QStringList libraryPaths(); #endif void KDbTest::testTemporaryTableName() { QVERIFY(utils.testCreateDbWithTables("KDbTest")); QString baseName = QLatin1String("foobar"); - QString tempName1 = KDb::temporaryTableName(utils.connection.data(), baseName); + QString tempName1 = KDb::temporaryTableName(utils.connection(), baseName); QVERIFY(!tempName1.isEmpty()); QVERIFY(tempName1.contains(baseName)); - QString tempName2 = KDb::temporaryTableName(utils.connection.data(), baseName); + QString tempName2 = KDb::temporaryTableName(utils.connection(), baseName); QVERIFY(!tempName2.isEmpty()); QVERIFY(tempName2.contains(baseName)); QVERIFY(tempName1 != tempName2); - utils.connection->closeDatabase(); + utils.connection()->closeDatabase(); QTest::ignoreMessage(QtWarningMsg, "Missing database handle"); QTest::ignoreMessage(QtWarningMsg, QRegularExpression("!executeQuery().*")); - QString tempName = KDb::temporaryTableName(utils.connection.data(), baseName); + QString tempName = KDb::temporaryTableName(utils.connection(), baseName); QVERIFY2(tempName.isEmpty(), "Temporary name should not be created when database is closed "); - utils.connection->disconnect(); + utils.connection()->disconnect(); QTest::ignoreMessage(QtWarningMsg, "Missing database handle"); QTest::ignoreMessage(QtWarningMsg, QRegularExpression("!executeQuery().*")); - tempName = KDb::temporaryTableName(utils.connection.data(), baseName); + tempName = KDb::temporaryTableName(utils.connection(), baseName); QVERIFY2(tempName.isEmpty(), "Temporary name should not be created connection is missing"); - utils.connection->dropDatabase(utils.connection->data().databaseName()); + utils.connection()->dropDatabase(utils.connection()->data().databaseName()); } //! @todo add tests #if 0 /*! @return absolute path to "sqlite3" program. Empty string is returned if the program was not found. */ KDB_EXPORT QString sqlite3ProgramPath(); /*! Imports file in SQL format from @a inputFileName into @a outputFileName. Works for any SQLite 3 dump file. Requires access to executing the "sqlite3" command. File named @a outputFileName will be silently overwritten with a new SQLite 3 database file. @return true on success. */ KDB_EXPORT bool importSqliteFile(const QString &inputFileName, const QString &outputFileName); /*! @return @c true if @a s is a valid identifier, i.e. starts with a letter or '_' character and contains only letters, numbers and '_' character. */ KDB_EXPORT bool isIdentifier(const QString& s); /*! @return valid identifier based on @a s. Non-alphanumeric characters (or spaces) are replaced with '_'. If a number is at the beginning, '_' is added at start. Empty strings are not changed. Case remains unchanged. */ KDB_EXPORT QString stringToIdentifier(const QString &s); /*! @return useful message "Value of "valueName" column must be an identifier. "v" is not a valid identifier.". It is also used by KDbIdentifierValidator. */ KDB_EXPORT QString identifierExpectedMessage(const QString &valueName, const QVariant& v); #endif void KDbTest::deleteRecordWithOneConstraintsTest() { QVERIFY(utils.testCreateDbWithTables("KDbTest")); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "id", 2)); - QVERIFY2(KDb::deleteRecords(utils.connection.data(), "persons", "id", "3"), + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "id", 2)); + QVERIFY2(KDb::deleteRecords(utils.connection(), "persons", "id", "3"), "Passing a valid Integer in String Format"); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "id", "Foo")); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "name", "Jaroslaw")); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "surname", "FooBar")); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "age", 45)); + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "id", "Foo")); + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "name", "Jaroslaw")); + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "surname", "FooBar")); + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "age", 45)); // and empty data. - KDbTableSchema *kdb_t = utils.connection.data()->tableSchema("persons"); + KDbTableSchema *kdb_t = utils.connection()->tableSchema("persons"); QVERIFY(kdb_t); - QVERIFY2(utils.connection.data()->insertRecord(kdb_t, 10, 20, QVariant(), "Bar"), + QVERIFY2(utils.connection()->insertRecord(kdb_t, 10, 20, QVariant(), "Bar"), "Inserting NULL data"); - QVERIFY2(utils.connection.data()->insertRecord(kdb_t,15, 20, "", "Bar"), + QVERIFY2(utils.connection()->insertRecord(kdb_t,15, 20, "", "Bar"), "Inserting empty data"); - QVERIFY2(KDb::deleteRecords(utils.connection.data(), "persons", "name", QString()), + QVERIFY2(KDb::deleteRecords(utils.connection(), "persons", "name", QString()), "Passing a null value instead of string"); // - QVERIFY2(KDb::deleteRecords(utils.connection.data(), "persons", "name", ""), + QVERIFY2(KDb::deleteRecords(utils.connection(), "persons", "name", ""), "Passing an empty string"); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "age", "Nitish")); + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "age", "Nitish")); QVERIFY(utils.testDisconnectAndDropDb()); } static QRegularExpression resultRegExp(const QString &code, const QString &message, const QString &sql, const QString &serverErrorCode, const QString &serverMessage) { return QRegularExpression( QString::fromLatin1("KDbResult: CODE=%1 MESSAGE=\\\"%2\\\" ERR_SQL=KDbEscapedString:" "\\\"%3\\\" SERVER_ERROR_CODE=%4 SERVER_MESSAGE=\\\"%5") .arg(code.isEmpty() ? "[0-9]*" : code, message, sql, serverErrorCode.isEmpty() ? "[0-9]*" : serverErrorCode, serverMessage)); } void KDbTest::deleteNonExistingRecordTest() { QVERIFY(utils.testCreateDbWithTables("KDbTest")); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "id", 400)); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "name", "FooBar")); + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "id", 400)); + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "name", "FooBar")); QTest::ignoreMessage(QtWarningMsg, resultRegExp("260", "Error while executing SQL statement.", "DELETE FROM \\[persons\\] WHERE \\[Foo\\]='FooBar'", "0", "no such column: Foo")); - QVERIFY2(!KDb::deleteRecords(utils.connection.data(), "persons", "Foo", "FooBar"), + QVERIFY2(!KDb::deleteRecords(utils.connection(), "persons", "Foo", "FooBar"), "Passing a NonExisting Column - should fail because 'Foo' column does not exist, " "See also https://bugs.kde.org/376052"); QVERIFY(utils.testDisconnectAndDropDb()); } void KDbTest::deleteRecordWithTwoConstraintsTest() { QVERIFY(utils.testCreateDbWithTables("KDbTest")); - QVERIFY2(KDb::deleteRecords(utils.connection.data(), "persons", "id", KDbField::Integer, + QVERIFY2(KDb::deleteRecords(utils.connection(), "persons", "id", KDbField::Integer, 2, "age", KDbField::Integer, 60), "Both fields are INTEGER"); - KDbTableSchema *kdb_t = utils.connection.data()->tableSchema("persons"); + KDbTableSchema *kdb_t = utils.connection()->tableSchema("persons"); QVERIFY(kdb_t); - utils.connection.data()->insertRecord(kdb_t, 10, QVariant(), "Foo", "Bar") ; - QVERIFY2(KDb::deleteRecords(utils.connection.data(), "persons", "id", KDbField::Integer, + utils.connection()->insertRecord(kdb_t, 10, QVariant(), "Foo", "Bar") ; + QVERIFY2(KDb::deleteRecords(utils.connection(), "persons", "id", KDbField::Integer, 10, "age", KDbField::Integer, QVariant()), "Passing NULL value for integer field"); - QVERIFY(utils.connection.data()->insertRecord(kdb_t, 20, QVariant(), QVariant(), "Bar")); - QVERIFY2(KDb::deleteRecords(utils.connection.data(), "persons", "age", KDbField::Integer, + QVERIFY(utils.connection()->insertRecord(kdb_t, 20, QVariant(), QVariant(), "Bar")); + QVERIFY2(KDb::deleteRecords(utils.connection(), "persons", "age", KDbField::Integer, QVariant(), "name", KDbField::Text, QVariant()), "Passing 2 NULL values"); - QVERIFY2(KDb::deleteRecords(utils.connection.data(), "persons", "age", KDbField::Integer, + QVERIFY2(KDb::deleteRecords(utils.connection(), "persons", "age", KDbField::Integer, 20, "name", KDbField::Text, "Jaroslaw"), "One argument is Integer and another is Text"); - QVERIFY2(KDb::deleteRecords(utils.connection.data(), "persons", "age", KDbField::Integer, + QVERIFY2(KDb::deleteRecords(utils.connection(), "persons", "age", KDbField::Integer, 20, "name", KDbField::Text, 56), "Two arguments, passing second integer instead of text but it is converted to text"); QTest::ignoreMessage(QtWarningMsg, resultRegExp("260", "Error while executing SQL statement.", "DELETE FROM \\[persons\\] WHERE \\[age\\]=TRAP AND \\[name\\]='56'", "0", "no such column: TRAP")); - QVERIFY2(!KDb::deleteRecords(utils.connection.data(), "persons", "age", KDbField::Integer, + QVERIFY2(!KDb::deleteRecords(utils.connection(), "persons", "age", KDbField::Integer, "TRAP", "name", KDbField::Text, 56), "Passing text instead of integer, conversion error expected"); QVERIFY(utils.testDisconnectAndDropDb()); } void KDbTest::deleteRecordWithThreeConstraintsTest() { QVERIFY(utils.testCreateDbWithTables("KDbTest")); - KDbTableSchema *kdb_t = utils.connection.data()->tableSchema("persons"); + KDbTableSchema *kdb_t = utils.connection()->tableSchema("persons"); QVERIFY(kdb_t); //One null value. - QVERIFY(utils.connection.data()->insertRecord(kdb_t, 10, QVariant(), "Foo", "Bar")); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "age", KDbField::Integer, QVariant(), + QVERIFY(utils.connection()->insertRecord(kdb_t, 10, QVariant(), "Foo", "Bar")); + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "age", KDbField::Integer, QVariant(), "name", KDbField::Text, "Foo", "surname", KDbField::Text, "Bar")); //Mix of null and empty values - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "age", KDbField::Integer, QVariant(), + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "age", KDbField::Integer, QVariant(), "name", KDbField::Text, "", "surname", KDbField::Text, "")); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "age", KDbField::Integer,27, + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "age", KDbField::Integer,27, "name", KDbField::Text, "Jaraslaw", "id", KDbField::Integer, 1)); - QVERIFY(KDb::deleteRecords(utils.connection.data(), "persons", "age", KDbField::Integer, 60, + QVERIFY(KDb::deleteRecords(utils.connection(), "persons", "age", KDbField::Integer, 60, "name", KDbField::Text, "Lech", "id", KDbField::Integer, 2)); QVERIFY(utils.testDisconnectAndDropDb()); } void KDbTest::deleteAllRecordsTest() { QVERIFY(utils.testCreateDbWithTables("KDbTest")); - QVERIFY(KDb::deleteAllRecords(utils.connection.data(), "persons")); + QVERIFY(KDb::deleteAllRecords(utils.connection(), "persons")); QRegularExpression deleteAllErrorRegExp = resultRegExp( "", "Error while executing SQL statement.", "DELETE FROM \\[.*\\]", 0, "no such table: .*"); QTest::ignoreMessage(QtWarningMsg, deleteAllErrorRegExp); - QVERIFY2(!KDb::deleteAllRecords(utils.connection.data(), QString()), + QVERIFY2(!KDb::deleteAllRecords(utils.connection(), QString()), "Passing a null table name"); QTest::ignoreMessage(QtWarningMsg, deleteAllErrorRegExp); - QVERIFY2(!KDb::deleteAllRecords(utils.connection.data(), ""), + QVERIFY2(!KDb::deleteAllRecords(utils.connection(), ""), "Passing an empty table name"); - QVERIFY(KDb::deleteAllRecords(utils.connection.data(), "cars")); + QVERIFY(KDb::deleteAllRecords(utils.connection(), "cars")); QTest::ignoreMessage(QtWarningMsg, deleteAllErrorRegExp); - QVERIFY2(!KDb::deleteAllRecords(utils.connection.data(), "NonExistingTable"), + QVERIFY2(!KDb::deleteAllRecords(utils.connection(), "NonExistingTable"), "Passing a nonexisting table name"); QVERIFY(utils.testDisconnectAndDropDb()); } void KDbTest::cleanupTestCase() { } diff --git a/autotests/KDbTestUtils.cpp b/autotests/KDbTestUtils.cpp index abb9ffc7..51fcc5a8 100644 --- a/autotests/KDbTestUtils.cpp +++ b/autotests/KDbTestUtils.cpp @@ -1,361 +1,388 @@ /* This file is part of the KDE project - Copyright (C) 2015 Jarosław Staniek + Copyright (C) 2015-2018 Jarosław Staniek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "KDbTestUtils.h" #include "KDbUtils_p.h" #include #include #include #include #include #include #include #include #include #include #include #include "../tests/features/tables_test_p.h" namespace QTest { KDBTESTUTILS_EXPORT bool qCompare(const KDbEscapedString &val1, const KDbEscapedString &val2, const char *actual, const char *expected, const char *file, int line) { return val1 == val2 ? compare_helper(true, "COMPARE()", toString(qPrintable(val1.toString())), toString(qPrintable(val2.toString())), actual, expected, file, line) : compare_helper(false, "Compared values are not the same", toString(qPrintable(val1.toString())), toString(qPrintable(val2.toString())), actual, expected, file, line); } KDBTESTUTILS_EXPORT bool qCompare(const KDbEscapedString &val1, const char *val2, const char *actual, const char *expected, const char *file, int line) { return val1 == val2 ? compare_helper(true, "COMPARE()", toString(qPrintable(val1.toString())), toString(val2), actual, expected, file, line) : compare_helper(false, "Compared values are not the same", toString(qPrintable(val1.toString())), toString(val2), actual, expected, file, line); } KDBTESTUTILS_EXPORT bool qCompare(const char *val1, const KDbEscapedString &val2, const char *actual, const char *expected, const char *file, int line) { return val1 == val2 ? compare_helper(true, "COMPARE()", toString(val1), toString(qPrintable(val2.toString())), actual, expected, file, line) : compare_helper(false, "Compared values are not the same", toString(val1), toString(qPrintable(val2.toString())), actual, expected, file, line); } KDBTESTUTILS_EXPORT bool qCompare(const KDbEscapedString &val1, const QString &val2, const char *actual, const char *expected, const char *file, int line) { return val1 == KDbEscapedString(val2) ? compare_helper(true, "COMPARE()", toString(qPrintable(val1.toString())), toString(val2), actual, expected, file, line) : compare_helper(false, "Compared values are not the same", toString(qPrintable(val1.toString())), toString(val2), actual, expected, file, line); } KDBTESTUTILS_EXPORT bool qCompare(const QString &val1, const KDbEscapedString &val2, const char *actual, const char *expected, const char *file, int line) { return KDbEscapedString(val1) == val2 ? compare_helper(true, "COMPARE()", toString(val1), toString(qPrintable(val2.toString())), actual, expected, file, line) : compare_helper(false, "Compared values are not the same", toString(val1), toString(qPrintable(val2.toString())), actual, expected, file, line); } } class KDbTestUtils::Private { public: Private() {} QScopedPointer kdbBuilder; QScopedPointer driverBuilder; + + KDbConnection *connection() + { + return m_connection.data(); + } + + void setConnection(KDbConnection *conn) + { + kdbBuilder.reset(); // dependency will be removed + m_connection.reset(conn); + } + + KDbConnection* takeConnection() + { + if (!m_connection) { + return nullptr; + } + kdbBuilder.reset(); // dependency may be removed + return m_connection.take(); + } + +private: + QScopedPointer m_connection; }; KDbTestUtils::KDbTestUtils() - : connection(nullptr) - , d(new Private) + : d(new Private) { QCoreApplication::addLibraryPath(KDB_LOCAL_PLUGINS_DIR); // make plugins work without installing them } KDbTestUtils::~KDbTestUtils() { delete d; } +KDbConnection* KDbTestUtils::connection() +{ + return d->connection(); +} + KDbNativeStatementBuilder* KDbTestUtils::kdbBuilder() { - Q_ASSERT(connection); - if (connection && !d->kdbBuilder) { - d->kdbBuilder.reset(new KDbNativeStatementBuilder(connection.data(), KDb::KDbEscaping)); + Q_ASSERT(connection()); + if (connection() && !d->kdbBuilder) { + d->kdbBuilder.reset(new KDbNativeStatementBuilder(connection(), KDb::KDbEscaping)); } return d->kdbBuilder.data(); } KDbNativeStatementBuilder* KDbTestUtils::driverBuilder() { - Q_ASSERT(connection); - if (connection && !d->driverBuilder) { - d->driverBuilder.reset(new KDbNativeStatementBuilder(connection.data(), KDb::DriverEscaping)); + Q_ASSERT(connection()); + if (connection() && !d->driverBuilder) { + d->driverBuilder.reset(new KDbNativeStatementBuilder(connection(), KDb::DriverEscaping)); } return d->driverBuilder.data(); } void KDbTestUtils::testDriverManagerInternal(bool forceEmpty) { DriverManagerInternal::self()->forceEmpty = forceEmpty; QStringList ids = manager.driverIds(); //qDebug() << "DRIVERS:" << ids; QVERIFY2(forceEmpty == manager.result().isError(), "Error in driver manager"); //qDebug() << manager.result().message(); QVERIFY2(forceEmpty == ids.isEmpty(), "No db drivers found"); if (forceEmpty) { // no drivers, so try to find one and expect failure ids << "org.kde.kdb.sqlite"; } for (const QString &id : qAsConst(ids)) { const KDbDriverMetaData* driverMetaData; if (forceEmpty) { KDB_EXPECT_FAIL(manager.resultable(), driverMetaData = manager.driverMetaData(id), ERR_DRIVERMANAGER, "Driver metadata not found"); // find driver for the metadata KDB_EXPECT_FAIL(manager.resultable(), driver = manager.driver(id), ERR_DRIVERMANAGER, "Driver not found"); } else { KDB_VERIFY(manager.resultable(), driverMetaData = manager.driverMetaData(id), "Driver metadata not found"); QCOMPARE(driverMetaData->id(), id); // find driver for the metadata KDB_VERIFY(manager.resultable(), driver = manager.driver(id), "Driver not found"); } } DriverManagerInternal::self()->forceEmpty = false; // default state } void KDbTestUtils::testDriverManagerInternal() { testDriverManagerInternal(true); testDriverManagerInternal(false); } void KDbTestUtils::testDriver(const QString &driverId, bool fileBased, const QStringList &mimeTypes) { // find the metadata const KDbDriverMetaData* driverMetaData; KDB_VERIFY(manager.resultable(), driverMetaData = manager.driverMetaData(driverId), "Driver metadata not found"); QCOMPARE(driverMetaData->id(), driverId); QCOMPARE(driverMetaData->isFileBased(), fileBased); // test the mimetypes QStringList foundMimeTypes(driverMetaData->mimeTypes()); foundMimeTypes.sort(); QStringList expectedMimeTypes(mimeTypes); expectedMimeTypes.sort(); //qDebug() << "mimeTypes:" << mimeTypes; QCOMPARE(foundMimeTypes, expectedMimeTypes); QVERIFY(!KDb::defaultFileBasedDriverMimeType().isEmpty()); QMimeDatabase mimeDb; foreach(const QString &mimeName, expectedMimeTypes) { QVERIFY2(mimeDb.mimeTypeForName(mimeName).isValid(), qPrintable(QString("%1 MIME type not found in the MIME database").arg(mimeName))); } // find driver for the metadata KDB_VERIFY(manager.resultable(), driver = manager.driver(driverId), "Driver not found"); } void KDbTestUtils::testSqliteDriverInternal() { QStringList mimeTypes; mimeTypes << "application/x-kexiproject-sqlite3" << "application/x-sqlite3"; testDriver("org.kde.kdb.sqlite", true, // file-based mimeTypes); QVERIFY2(mimeTypes.contains(KDb::defaultFileBasedDriverMimeType()), "SQLite's MIME types should include the default file based one"); } void KDbTestUtils::testConnectInternal(const KDbConnectionData &cdata, const KDbConnectionOptions &options) { //qDebug() << cdata; if (!driver) { //! @todo don't hardcode SQLite here KDB_VERIFY(manager.resultable(), driver = manager.driver("org.kde.kdb.sqlite"), "Driver not found"); } KDbConnectionOptions connOptionsOverride(options); QStringList extraSqliteExtensionPaths; extraSqliteExtensionPaths << SQLITE_LOCAL_ICU_EXTENSION_PATH; connOptionsOverride.insert("extraSqliteExtensionPaths", extraSqliteExtensionPaths); - connection.reset(); // remove previous connection if present + d->setConnection(nullptr); // remove previous connection if present const int connCount = driver->connections().count(); - connection.reset(driver->createConnection(cdata, connOptionsOverride)); - KDB_VERIFY(driver, !connection.isNull(), "Failed to create connection"); + d->setConnection(driver->createConnection(cdata, connOptionsOverride)); + KDB_VERIFY(driver, connection(), "Failed to create connection"); QVERIFY2(cdata.driverId().isEmpty(), "Connection data has filled driver ID"); - QCOMPARE(connection->data().driverId(), driver->metaData()->id()); - QVERIFY2(driver->connections().contains(connection.data()), "Driver does not list created connection"); + QCOMPARE(connection()->data().driverId(), driver->metaData()->id()); + QVERIFY2(driver->connections().contains(connection()), "Driver does not list created connection"); QCOMPARE(driver->connections().count(), connCount + 1); // one more - const KDbUtils::Property extraSqliteExtensionPathsProperty = connection->options()->property("extraSqliteExtensionPaths"); + const KDbUtils::Property extraSqliteExtensionPathsProperty = connection()->options()->property("extraSqliteExtensionPaths"); QVERIFY2(!extraSqliteExtensionPathsProperty.isNull(), "extraSqliteExtensionPaths property not found"); QCOMPARE(extraSqliteExtensionPathsProperty.value().type(), QVariant::StringList); QCOMPARE(extraSqliteExtensionPathsProperty.value().toStringList(), extraSqliteExtensionPaths); - const KDbUtils::Property readOnlyProperty = connection->options()->property("readOnly"); + const KDbUtils::Property readOnlyProperty = connection()->options()->property("readOnly"); QVERIFY2(!readOnlyProperty.isNull(), "readOnly property not found"); - QCOMPARE(readOnlyProperty.value().toBool(), connection->options()->isReadOnly()); + QCOMPARE(readOnlyProperty.value().toBool(), connection()->options()->isReadOnly()); //! @todo Add extensive test for a read-only connection - KDB_VERIFY(connection, connection->connect(), "Failed to connect"); - KDB_VERIFY(connection, connection->isConnected(), "Database not connected after call to connect()"); + KDB_VERIFY(connection(), connection()->connect(), "Failed to connect"); + KDB_VERIFY(connection(), connection()->isConnected(), "Database not connected after call to connect()"); } void KDbTestUtils::testUseInternal() { - KDB_VERIFY(connection, connection->databaseExists(connection->data().databaseName()), "Database does not exists"); - KDB_VERIFY(connection, connection->useDatabase(), "Failed to use database"); - KDB_VERIFY(connection, connection->isDatabaseUsed(), "Database not used after call to useDatabase()"); + KDB_VERIFY(connection(), connection()->databaseExists(connection()->data().databaseName()), "Database does not exist"); + KDB_VERIFY(connection(), connection()->useDatabase(), "Failed to use database"); + KDB_VERIFY(connection(), connection()->isDatabaseUsed(), "Database not used after call to useDatabase()"); } void KDbTestUtils::testConnectAndUseInternal(const KDbConnectionData &cdata, const KDbConnectionOptions &options) { - if (!testConnect(cdata, options) || !connection) { + if (!testConnect(cdata, options) || !connection()) { qWarning() << driver->result(); QFAIL("testConnect"); } - if (!testUse() || !connection->isDatabaseUsed()) { - qWarning() << connection->result(); + if (!testUse() || !connection()->isDatabaseUsed()) { + qWarning() << connection()->result(); bool result = testDisconnect(); Q_UNUSED(result); QFAIL("testUse"); } } void KDbTestUtils::testConnectAndUseInternal(const QString &path, const KDbConnectionOptions &options) { KDbConnectionData cdata; cdata.setDatabaseName(path); testConnectAndUseInternal(cdata, options); } void KDbTestUtils::testCreateDbInternal(const QString &dbName) { //open connection KDbConnectionData cdata; //! @todo don't hardcode SQLite (.kexi) extension here QString fullDbName(QDir::fromNativeSeparators(QFile::decodeName(FILES_OUTPUT_DIR "/") + dbName + ".kexi")); cdata.setDatabaseName(fullDbName); QVERIFY(testConnect(cdata)); - QVERIFY(connection); + QVERIFY(connection()); //! @todo KDbDriver::metaData { - QScopedPointer connGuard(connection.take()); + QScopedPointer connGuard(d->takeConnection()); if (connGuard->databaseExists(dbName)) { KDB_VERIFY(connGuard, connGuard->dropDatabase(fullDbName), "Failed to drop database"); } KDB_VERIFY(connGuard, !connGuard->databaseExists(fullDbName), "Database exists"); KDB_VERIFY(connGuard, connGuard->createDatabase(fullDbName), "Failed to create db"); - KDB_VERIFY(connGuard, connGuard->databaseExists(fullDbName), "Database does not exists after creation"); - connection.reset(connGuard.take()); + KDB_VERIFY(connGuard, connGuard->databaseExists(fullDbName), "Database does not exist after creation"); + d->setConnection(connGuard.take()); } } void KDbTestUtils::testCreateDbWithTablesInternal(const QString &dbName) { QVERIFY(testCreateDb(dbName)); - KDB_VERIFY(connection, connection->useDatabase(), "Failed to use database"); + KDB_VERIFY(connection(), connection()->useDatabase(), "Failed to use database"); testCreateTablesInternal(); } void KDbTestUtils::testPropertiesInternal() { QStringList properties; - properties << connection->databaseProperties().names(); + properties << connection()->databaseProperties().names(); QVERIFY(properties.contains("kexidb_major_ver")); bool ok; - QVERIFY(connection->databaseProperties().value("kexidb_major_ver").toInt(&ok) >= 0); + QVERIFY(connection()->databaseProperties().value("kexidb_major_ver").toInt(&ok) >= 0); QVERIFY(ok); QVERIFY(properties.contains("kexidb_minor_ver")); - QVERIFY(connection->databaseProperties().value("kexidb_minor_ver").toInt(&ok) >= 0); + QVERIFY(connection()->databaseProperties().value("kexidb_minor_ver").toInt(&ok) >= 0); QVERIFY(ok); } void KDbTestUtils::testCreateTablesInternal() { - QVERIFY2(tablesTest_createTables(connection.data()) == 0, "Failed to create test data"); + QVERIFY2(tablesTest_createTables(connection()) == 0, "Failed to create test data"); } void KDbTestUtils::testDisconnectPrivate() { - if (!connection) { + if (!connection()) { return; } - KDB_VERIFY(connection, connection->closeDatabase(), "Failed to close database"); - KDB_VERIFY(connection, !connection->isDatabaseUsed(), "Database still used after closing"); - KDB_VERIFY(connection, connection->closeDatabase(), "Second closeDatabase() call should not fail"); - KDB_VERIFY(connection, connection->disconnect(), "Failed to disconnect database"); - KDB_VERIFY(connection, !connection->isConnected(), "Database still connected after disconnecting"); - KDB_VERIFY(connection, connection->disconnect(), "Second disconnect() call should not fail"); + KDB_VERIFY(connection(), connection()->closeDatabase(), "Failed to close database"); + KDB_VERIFY(connection(), !connection()->isDatabaseUsed(), "Database still used after closing"); + KDB_VERIFY(connection(), connection()->closeDatabase(), "Second closeDatabase() call should not fail"); + KDB_VERIFY(connection(), connection()->disconnect(), "Failed to disconnect database"); + KDB_VERIFY(connection(), !connection()->isConnected(), "Database still connected after disconnecting"); + KDB_VERIFY(connection(), connection()->disconnect(), "Second disconnect() call should not fail"); } void KDbTestUtils::testDisconnectInternal() { const int connCount = driver ? driver->connections().count() : 0; testDisconnectPrivate(); QVERIFY(!QTest::currentTestFailed()); - connection.reset(); + d->setConnection(nullptr); QCOMPARE(driver ? driver->connections().count() : -1, connCount - 1); // one less } void KDbTestUtils::testDropDbInternal() { - QVERIFY(connection->dropDatabase(connection->data().databaseName())); + QVERIFY(connection()->dropDatabase(connection()->data().databaseName())); } void KDbTestUtils::testDisconnectAndDropDbInternal() { - QString dbName(connection.data()->data().databaseName()); + QString dbName(connection()->data().databaseName()); testDisconnectPrivate(); QVERIFY(!QTest::currentTestFailed()); - KDB_VERIFY(connection, connection->dropDatabase(dbName), "Failed to drop database"); - connection.reset(); + KDB_VERIFY(connection(), connection()->dropDatabase(dbName), "Failed to drop database"); + d->setConnection(nullptr); } diff --git a/autotests/KDbTestUtils.h b/autotests/KDbTestUtils.h index e8fdc64c..0ac0b7cb 100644 --- a/autotests/KDbTestUtils.h +++ b/autotests/KDbTestUtils.h @@ -1,199 +1,203 @@ /* This file is part of the KDE project - Copyright (C) 2015 Jarosław Staniek + Copyright (C) 2015-2018 Jarosław Staniek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifndef KDB_TESTUTILS_H #define KDB_TESTUTILS_H #include "kdbtestutils_export.h" #include #include #include #include #include #include class KDbNativeStatementBuilder; Q_DECLARE_METATYPE(KDbField::TypeGroup) Q_DECLARE_METATYPE(KDbField::Type) Q_DECLARE_METATYPE(KDb::Signedness) Q_DECLARE_METATYPE(QList) Q_DECLARE_METATYPE(KDb::BLOBEscapingType) //! @internal for KDB_VERIFY template const T* KDB_POINTER_WRAPPER(const T &t) { return &t; } //! @internal for KDB_VERIFY template const T* KDB_POINTER_WRAPPER(const T *t) { return t; } //! @internal for KDB_VERIFY template T* KDB_POINTER_WRAPPER(T *t) { return t; } //! @internal for KDB_VERIFY template T* KDB_POINTER_WRAPPER(const QPointer &t) { return t.data(); } //! @internal for KDB_VERIFY template T* KDB_POINTER_WRAPPER(const QScopedPointer &t) { return t.data(); } namespace QTest { KDBTESTUTILS_EXPORT bool qCompare(const KDbEscapedString &val1, const KDbEscapedString &val2, const char *actual, const char *expected, const char *file, int line); KDBTESTUTILS_EXPORT bool qCompare(const KDbEscapedString &val1, const char *val2, const char *actual, const char *expected, const char *file, int line); KDBTESTUTILS_EXPORT bool qCompare(const char *val1, const KDbEscapedString &val2, const char *actual, const char *expected, const char *file, int line); KDBTESTUTILS_EXPORT bool qCompare(const KDbEscapedString &val1, const QString &val2, const char *actual, const char *expected, const char *file, int line); KDBTESTUTILS_EXPORT bool qCompare(const QString &val1, const KDbEscapedString &val2, const char *actual, const char *expected, const char *file, int line); } //! Calls @a call and verifies status of @a resultable //! On error displays the status on debug and does the same as QVERIFY with @a errorMessage #define KDB_VERIFY(resultable, call, errorMessage) \ do { \ bool KDB_VERIFY_ok = (call); \ const KDbResultable *KDB_VERIFY_resultablePtr = KDB_POINTER_WRAPPER(resultable); \ if (KDB_VERIFY_resultablePtr->result().isError()) { \ qDebug() << KDB_VERIFY_resultablePtr->result(); \ } \ if (!QTest::qVerify(KDB_VERIFY_ok && !KDB_VERIFY_resultablePtr->result().isError(), # call, (errorMessage), __FILE__, __LINE__)) {\ return; \ } \ } \ while (false) //! Calls @a call and verifies status of @a resultable //! On error displays the status on debug and does the same as QVERIFY with @a errorMessage #define KDB_EXPECT_FAIL(resultable, call, expectedErrorCode, errorMessage) \ do { \ bool KDB_VERIFY_ok = (call); \ const KDbResultable *KDB_VERIFY_resultablePtr = KDB_POINTER_WRAPPER(resultable); \ if (KDB_VERIFY_resultablePtr->result().isError()) { \ qDebug() << KDB_VERIFY_resultablePtr->result(); \ } \ QVERIFY(KDB_VERIFY_resultablePtr->result().isError()); \ if (!QTest::qVerify(!KDB_VERIFY_ok, # call, (errorMessage), __FILE__, __LINE__)) {\ return; \ } \ if (!QTest::qCompare(KDB_VERIFY_resultablePtr->result().code(), expectedErrorCode, # call, # expectedErrorCode, __FILE__, __LINE__)) {\ return; \ } \ } \ while (false) //! Declares method @a name that returns false on test failure, it can be called as utility function. //! Also declared internal method name ## Internal which performs the actual test. //! This way users of this method can call QVERIFY(utils.()); #define KDBTEST_METHOD_DECL(name, argsDecl, args) \ public: \ bool name argsDecl Q_REQUIRED_RESULT { name ## Internal args ; return !QTest::currentTestFailed(); } \ private Q_SLOTS: \ void name ## Internal argsDecl //! Test utilities that provide basic database features class KDBTESTUTILS_EXPORT KDbTestUtils : public QObject { Q_OBJECT public: KDbTestUtils(); ~KDbTestUtils(); KDbDriverManager manager; QPointer driver; - QScopedPointer connection; + + /** + * Returns associated connection + */ + KDbConnection* connection(); /** * Returns builder for generating KDb SQL statements */ KDbNativeStatementBuilder* kdbBuilder(); /** * Returns builder for generating driver-native SQL statements */ KDbNativeStatementBuilder* driverBuilder(); KDBTEST_METHOD_DECL(testDriverManager, (), ()); KDBTEST_METHOD_DECL(testSqliteDriver, (), ()); //! Connects to a database //! @since 3.2 KDBTEST_METHOD_DECL(testConnect, (const KDbConnectionData &cdata, const KDbConnectionOptions &options = KDbConnectionOptions()), (cdata, options)); KDBTEST_METHOD_DECL(testUse, (), ()); //! Convenience method that performs testConnect and testUse in one go //! @since 3.2 KDBTEST_METHOD_DECL(testConnectAndUse, (const KDbConnectionData &cdata, const KDbConnectionOptions &options = KDbConnectionOptions()), (cdata, options)); //! Overload of testConnectAndUse for file-based databases //! @since 3.2 KDBTEST_METHOD_DECL(testConnectAndUse, (const QString &path, const KDbConnectionOptions &options = KDbConnectionOptions()), (path, options)); //! Creates database with name @a dbName //! Does not use the database. //! @todo don't hardcode SQLite here //! @note dbName should not include ".kexi" extension or path KDBTEST_METHOD_DECL(testCreateDb, (const QString &dbName), (dbName)); //! Creates database with name @a dbName, then uses it and creates test tables //! The database stays used. //! @note dbName should not include ".kexi" extension or path KDBTEST_METHOD_DECL(testCreateDbWithTables, (const QString &dbName), (dbName)); KDBTEST_METHOD_DECL(testProperties, (), ()); KDBTEST_METHOD_DECL(testCreateTables, (), ()); KDBTEST_METHOD_DECL(testDisconnect, (), ()); KDBTEST_METHOD_DECL(testDropDb, (), ()); KDBTEST_METHOD_DECL(testDisconnectAndDropDb, (), ()); protected: void testDisconnectPrivate(); void testDriver(const QString &driverId, bool fileBased, const QStringList &mimeTypes); void testDriverManagerInternal(bool forceEmpty); private: Q_DISABLE_COPY(KDbTestUtils) class Private; Private * const d; }; #endif diff --git a/autotests/MissingTableTest.cpp b/autotests/MissingTableTest.cpp index 1332d771..9f333300 100644 --- a/autotests/MissingTableTest.cpp +++ b/autotests/MissingTableTest.cpp @@ -1,89 +1,89 @@ /* This file is part of the KDE project Copyright (C) 2018 Jarosław Staniek This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include #include class MissingTableTest : public QObject { Q_OBJECT private Q_SLOTS: void initTestCase(); void init(); //! Tests if the list of tables skips name for which physical table is missing. //! The missingTableTest.kexi file has "persons" table deleted. void testListTables(); void cleanupTestCase(); void cleanup(); private: //! Opens database needed for tests bool openDatabase(const QString &path); KDbTestUtils m_utils; }; void MissingTableTest::initTestCase() { } void MissingTableTest::init() { QString dir(QFile::decodeName(FILES_DATA_DIR)); QVERIFY(openDatabase(dir + "/missingTableTest.kexi")); } bool MissingTableTest::openDatabase(const QString &path) { KDbConnectionOptions options; options.setReadOnly(true); return m_utils.testConnectAndUse(path, options); } void MissingTableTest::testListTables() { const bool alsoSystemTables = true; bool ok; - QStringList foundTableNames = m_utils.connection->tableNames(alsoSystemTables, &ok); + QStringList foundTableNames = m_utils.connection()->tableNames(alsoSystemTables, &ok); QVERIFY(ok); // call again with ok == nullptr - QCOMPARE(foundTableNames, m_utils.connection->tableNames(alsoSystemTables)); + QCOMPARE(foundTableNames, m_utils.connection()->tableNames(alsoSystemTables)); // make sure missing table is not present std::sort(foundTableNames.begin(), foundTableNames.end()); const QStringList expectedTables( { "cars", "kexi__db", "kexi__fields", "kexi__objectdata", "kexi__objects" }); QCOMPARE(foundTableNames, expectedTables); } void MissingTableTest::cleanup() { QVERIFY(m_utils.testDisconnect()); } void MissingTableTest::cleanupTestCase() { } QTEST_GUILESS_MAIN(MissingTableTest) #include "MissingTableTest.moc" diff --git a/autotests/OrderByColumnTest.cpp b/autotests/OrderByColumnTest.cpp index 4376b5e5..47f6b636 100644 --- a/autotests/OrderByColumnTest.cpp +++ b/autotests/OrderByColumnTest.cpp @@ -1,213 +1,213 @@ /* This file is part of the KDE project Copyright (C) 2018 Jarosław Staniek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "OrderByColumnTest.h" #include #include #include #include #include #include QTEST_GUILESS_MAIN(OrderByColumnTest) void OrderByColumnTest::initTestCase() { } void OrderByColumnTest::testSelect1Query() { QVERIFY(utils.testCreateDbWithTables("OrderByColumnTest")); KDbQuerySchema query; KDbField *oneField = new KDbField; oneField->setExpression(KDbConstExpression(KDbToken::CHARACTER_STRING_LITERAL, "foo")); query.addField(oneField); KDbOrderByColumnList* orderBy = query.orderByColumnList(); QVERIFY(orderBy); QVERIFY(orderBy->isEmpty()); QCOMPARE(orderBy->count(), 0); orderBy->appendField(oneField); - KDbConnection *conn = utils.connection.data(); + KDbConnection *conn = utils.connection(); // automatic alias "expr1" KDbEscapedString sql; QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, "SELECT 'foo' AS expr1 ORDER BY expr1"); QVERIFY(!orderBy->isEmpty()); QCOMPARE(orderBy->count(), 1); const int indexOfField = query.indexOf(*oneField); QCOMPARE(indexOfField, 0); const QString alias(query.columnAlias(indexOfField)); QVERIFY(!alias.isEmpty()); KDbOrderByColumn *orderByColumn = orderBy->value(indexOfField); QVERIFY(orderByColumn); QVERIFY(!orderByColumn->column()); QCOMPARE(orderByColumn->field(), oneField); QVERIFY(!orderBy->value(orderBy->count() + 10)); KDbEscapedString orderBySqlOldApi = orderBy->toSqlString(true, conn, KDb::KDbEscaping); QCOMPARE(orderBySqlOldApi, ""); // alias is not used KDbEscapedString orderBySql = orderBy->toSqlString(true, conn, &query, KDb::KDbEscaping); QCOMPARE(orderBySql, alias); // alias is used to point to the column "'foo'" // change alias to something other than valid ID QVERIFY(query.setColumnAlias(indexOfField, "0")); QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, "SELECT 'foo' AS \"0\" ORDER BY \"0\""); orderBySqlOldApi = orderBy->toSqlString(true, conn, KDb::KDbEscaping); QCOMPARE(orderBySqlOldApi, ""); // alias is not used orderBySql = orderBy->toSqlString(true, conn, &query, KDb::KDbEscaping); QCOMPARE(orderBySql, "\"0\""); // alias is used to point to the column "'foo'" } void OrderByColumnTest::testOrderByIndex() { QVERIFY(utils.testCreateDbWithTables("OrderByColumnTest")); KDbQuerySchema query; - KDbTableSchema *carsTable = utils.connection->tableSchema("cars"); + KDbTableSchema *carsTable = utils.connection()->tableSchema("cars"); QVERIFY(carsTable); query.addTable(carsTable); query.addAsterisk(new KDbQueryAsterisk(&query)); KDbOrderByColumnList* orderBy = query.orderByColumnList(); - KDbConnection *conn = utils.connection.data(); + KDbConnection *conn = utils.connection(); // "SELECT * FROM cars ORDER BY model ASC, owner DESC" QVERIFY(query.orderByColumnList()->isEmpty()); QVERIFY(orderBy->appendColumn(conn, &query, KDbOrderByColumn::SortOrder::Ascending, 2)); QVERIFY(orderBy->appendColumn(conn, &query, KDbOrderByColumn::SortOrder::Descending, 1)); KDbEscapedString sql; QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, "SELECT cars.* FROM cars ORDER BY 3, 2 DESC"); QVERIFY2(!orderBy->appendColumn(conn, &query, KDbOrderByColumn::SortOrder::Ascending, 3), "appendField for null"); } void OrderByColumnTest::testOrderByColumnName() { QVERIFY(utils.testCreateDbWithTables("OrderByColumnTest")); KDbQuerySchema query; - KDbTableSchema *carsTable = utils.connection->tableSchema("cars"); + KDbTableSchema *carsTable = utils.connection()->tableSchema("cars"); QVERIFY(carsTable); query.addTable(carsTable); query.addAsterisk(new KDbQueryAsterisk(&query)); // "SELECT * FROM cars ORDER BY model, owner" QVERIFY(query.orderByColumnList()); QVERIFY(query.orderByColumnList()->isEmpty()); QCOMPARE(query.orderByColumnList()->count(), 0); KDbOrderByColumnList* orderBy = query.orderByColumnList(); QVERIFY(orderBy); QVERIFY(orderBy->isEmpty()); KDbField *modelField = carsTable->field("model"); QVERIFY(modelField); KDbField *ownerField = carsTable->field("owner"); QVERIFY(ownerField); orderBy->appendField(modelField); orderBy->appendField(ownerField); - KDbConnection *conn = utils.connection.data(); + KDbConnection *conn = utils.connection(); KDbEscapedString orderBySql = orderBy->toSqlString(true, conn, &query, KDb::KDbEscaping); QCOMPARE(orderBySql, "cars.model, cars.owner"); KDbEscapedString sql; QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, "SELECT cars.* FROM cars ORDER BY model, owner"); QVERIFY(utils.driverBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, "SELECT [cars].* FROM [cars] ORDER BY [model] COLLATE '', [owner]"); // "SELECT * FROM cars ORDER BY model ASC, owner DESC" orderBy->clear(); QVERIFY(query.orderByColumnList()->isEmpty()); orderBy->appendField(modelField, KDbOrderByColumn::SortOrder::Ascending); orderBy->appendField(ownerField, KDbOrderByColumn::SortOrder::Descending); QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); const char validSelect1[] = "SELECT cars.* FROM cars ORDER BY model, owner DESC"; QCOMPARE(sql, validSelect1); QVERIFY(utils.driverBuilder()->generateSelectStatement(&sql, &query)); const char validDriverSelect1[] = "SELECT [cars].* FROM [cars] ORDER BY [model] COLLATE '', [owner] DESC"; QCOMPARE(sql, validDriverSelect1); // The same query, adding null field orderBy->clear(); QVERIFY(query.orderByColumnList()->isEmpty()); orderBy->appendField(nullptr); QVERIFY2(query.orderByColumnList()->isEmpty(), "Adding null fields should not affect OREDR BY"); orderBy->appendField(modelField, KDbOrderByColumn::SortOrder::Ascending); orderBy->appendField(ownerField, KDbOrderByColumn::SortOrder::Descending); orderBy->appendField(nullptr); QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, validSelect1); QVERIFY(utils.driverBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, validDriverSelect1); // The same query, overload orderBy->clear(); QVERIFY(query.orderByColumnList()->isEmpty()); QVERIFY(orderBy->appendFields(conn, &query, "model", KDbOrderByColumn::SortOrder::Ascending, "owner", KDbOrderByColumn::SortOrder::Descending)); QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, validSelect1); QVERIFY(utils.driverBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, validDriverSelect1); // The same query, overload orderBy->clear(); QVERIFY(query.orderByColumnList()->isEmpty()); QVERIFY(orderBy->appendField(conn, &query, "model", KDbOrderByColumn::SortOrder::Ascending)); QVERIFY(orderBy->appendField(conn, &query, "owner", KDbOrderByColumn::SortOrder::Descending)); QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, validSelect1); QVERIFY(utils.driverBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, validDriverSelect1); QCOMPARE(orderBy->count(), 2); QTest::ignoreMessage(QtWarningMsg, "no such field \"\""); QVERIFY2(!orderBy->appendField(conn, &query, ""), "appendField for null"); QCOMPARE(orderBy->count(), 2); // The same query, overload orderBy->clear(); QCOMPARE(orderBy->count(), 0); QVERIFY(query.orderByColumnList()->isEmpty()); KDbQueryColumnInfo::Vector columns = query.fieldsExpanded(conn); KDbQueryColumnInfo *ownerColumnInfo = columns.value(1); QVERIFY(ownerColumnInfo); KDbQueryColumnInfo *modelColumnInfo = columns.value(2); QVERIFY(modelColumnInfo); orderBy->appendColumn(modelColumnInfo, KDbOrderByColumn::SortOrder::Ascending); orderBy->appendColumn(ownerColumnInfo, KDbOrderByColumn::SortOrder::Descending); QCOMPARE(orderBy->count(), 2); QVERIFY(utils.kdbBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, validSelect1); QVERIFY(utils.driverBuilder()->generateSelectStatement(&sql, &query)); QCOMPARE(sql, validDriverSelect1); } //! @todo Test KDbQuerySchema::setOrderByColumnList //! @todo Test more KDbOrderByColumnList and KDbOrderByColumn void OrderByColumnTest::cleanupTestCase() { } diff --git a/autotests/QuerySchemaTest.cpp b/autotests/QuerySchemaTest.cpp index 67fe66c1..acfd0ecc 100644 --- a/autotests/QuerySchemaTest.cpp +++ b/autotests/QuerySchemaTest.cpp @@ -1,67 +1,67 @@ /* This file is part of the KDE project Copyright (C) 2017 Jarosław Staniek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "QuerySchemaTest.h" #include #include #include #include #include #include #include QTEST_GUILESS_MAIN(QuerySchemaTest) void QuerySchemaTest::initTestCase() { } void QuerySchemaTest::testCaching() { QVERIFY(utils.testCreateDbWithTables("QuerySchemaTest")); KDbQuerySchema query; - KDbTableSchema *carsTable = utils.connection->tableSchema("cars"); + KDbTableSchema *carsTable = utils.connection()->tableSchema("cars"); QVERIFY(carsTable); query.addTable(carsTable); KDbField *idField = carsTable->field("id"); QVERIFY(idField); // "SELECT id, cars.* from cars" query.addField(idField); query.addAsterisk(new KDbQueryAsterisk(&query, *carsTable)); QCOMPARE(query.fieldCount(), 2); - const KDbQueryColumnInfo::Vector expandedAll1 = query.fieldsExpanded(utils.connection.data()); + const KDbQueryColumnInfo::Vector expandedAll1 = query.fieldsExpanded(utils.connection()); QCOMPARE(expandedAll1.count(), 4); const KDbQueryColumnInfo::Vector expandedUnique1 - = query.fieldsExpanded(utils.connection.data(), KDbQuerySchema::FieldsExpandedMode::Unique); + = query.fieldsExpanded(utils.connection(), KDbQuerySchema::FieldsExpandedMode::Unique); QCOMPARE(expandedUnique1.count(), 3); // remove the asterisk -> "SELECT id from cars" query.removeField(query.field(1)); QCOMPARE(query.fieldCount(), 1); - const KDbQueryColumnInfo::Vector expandedAll2 = query.fieldsExpanded(utils.connection.data()); + const KDbQueryColumnInfo::Vector expandedAll2 = query.fieldsExpanded(utils.connection()); QCOMPARE(expandedAll2.count(), 1); const KDbQueryColumnInfo::Vector expandedUnique2 - = query.fieldsExpanded(utils.connection.data(), KDbQuerySchema::FieldsExpandedMode::Unique); + = query.fieldsExpanded(utils.connection(), KDbQuerySchema::FieldsExpandedMode::Unique); QCOMPARE(expandedUnique2.count(), 1); } void QuerySchemaTest::cleanupTestCase() { } diff --git a/autotests/parser/SqlParserTest.cpp b/autotests/parser/SqlParserTest.cpp index 19ca85b6..c60a59a1 100644 --- a/autotests/parser/SqlParserTest.cpp +++ b/autotests/parser/SqlParserTest.cpp @@ -1,365 +1,365 @@ /* This file is part of the KDE project Copyright (C) 2012-2017 Jarosław Staniek This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "SqlParserTest.h" #include #include #include #include #include #include Q_DECLARE_METATYPE(KDbEscapedString) QTEST_GUILESS_MAIN(SqlParserTest) void SqlParserTest::initTestCase() { QString dir(QFile::decodeName(OUTPUT_DIR)); QString fname("errors.txt"); m_errorFile.setFileName(dir + QDir::separator() + fname); QVERIFY2(m_errorFile.open(QFile::WriteOnly | QFile::Text), qPrintable(QString("Cannot open %1 file").arg(m_errorFile.fileName()))); m_errorStream.setDevice(&m_errorFile); } bool SqlParserTest::openDatabase(const QString &path) { KDbConnectionOptions options; options.setReadOnly(true); if (!m_utils.testConnectAndUse(path, options)) { return false; } - m_parser.reset(new KDbParser(m_utils.connection.data())); + m_parser.reset(new KDbParser(m_utils.connection())); #if 0 if (m_conn->databaseExists(dbName)) { if (!m_conn->dropDatabase(dbName)) { m_conn->disconnect(); return false; } qDebug() << "Database" << dbName << "dropped."; } if (!m_conn->createDatabase(dbName)) { qDebug() << m_conn->result(); m_conn->disconnect(); return false; } #endif return true; } static void eatComment(QString* string) { if (!string->startsWith("--")) { return; } int i = 0; for (; i < string->length() && string->at(i) == '-'; ++i) ; QString result = string->mid(i).trimmed(); *string = result; } static void eatEndLines(QString* string) { if (!string->endsWith("--")) { return; } int i = string->length() - 1; for (; i >= 0 && string->at(i) == '-'; --i) ; *string = string->left(i+1).trimmed(); } static void eatEndComment(QString* string) { int pos = string->indexOf("; --"); if (pos == -1) { return; } string->truncate(pos); *string = string->trimmed() + ';'; } void SqlParserTest::testParse_data() { QTest::addColumn("fname"); QTest::addColumn("lineNum"); QTest::addColumn("sql"); QTest::addColumn("expectError"); QString dir(QFile::decodeName(FILES_DATA_DIR)); QString fname("statements.txt"); QFile input(dir + QDir::separator() + fname); bool ok = input.open(QFile::ReadOnly | QFile::Text); QVERIFY2(ok, qPrintable(QString("Could not open data file %1").arg(input.fileName()))); QTextStream in(&input); QString category; QString testName; bool expectError = false; int lineNum = 1; QString dbPath; bool clearTestName = false; for (; !in.atEnd(); ++lineNum) { QString line(in.readLine()); if (line.startsWith("--")) { // comment eatComment(&line); eatEndLines(&line); if (line.startsWith("TODO:")) { continue; } else if (line.startsWith("CATEGORY: ")) { if (clearTestName) { expectError = false; clearTestName = false; testName.clear(); } category = line.mid(QString("CATEGORY: ").length()).trimmed(); //qDebug() << "CATEGORY:" << category; } else if (line == "QUIT") { break; } else if (line.startsWith("SQLITEFILE: ")) { if (clearTestName) { expectError = false; clearTestName = false; testName.clear(); } ok = dbPath.isEmpty(); QVERIFY2(ok, qPrintable(QString("Error at line %1: SQLite file was already specified (%2)") .arg(lineNum).arg(dbPath))); dbPath = line.mid(QString("SQLITEFILE: ").length()).trimmed(); dbPath = dir + QDir::separator() + dbPath; ok = openDatabase(dbPath); QVERIFY2(ok, qPrintable(QString("Error at line %1: Could not open SQLite file %2") .arg(lineNum).arg(dbPath))); } else if (line.startsWith("ERROR: ")) { if (clearTestName) { clearTestName = false; testName.clear(); } expectError = true; testName = line.mid(QString("ERROR: ").length()).trimmed(); } else { if (clearTestName) { expectError = false; clearTestName = false; testName.clear(); } if (!testName.isEmpty()) { testName.append(" "); } testName.append(line); } } else { eatEndComment(&line); KDbEscapedString sql(line.trimmed()); clearTestName = true; if (sql.isEmpty()) { expectError = false; continue; } ok = !dbPath.isEmpty(); QVERIFY2(ok, qPrintable(QString("Error at line %1: SQLite file was not specified, " "could not execute statement").arg(lineNum))); QTest::newRow(qPrintable(QString("file %1:%2, category '%3', test '%4', sql '%5'%6") .arg(fname).arg(lineNum).arg(category).arg(testName).arg(sql.toString()) .arg(expectError ? ", error expected" : ""))) << fname << lineNum << sql << expectError; } } input.close(); } void SqlParserTest::testParse() { QFETCH(QString, fname); QFETCH(int, lineNum); QFETCH(KDbEscapedString, sql); QFETCH(bool, expectError); QString message; if (!sql.endsWith(';')) { message = QString("%1:%2: Missing ';' at the end of line").arg(fname).arg(lineNum); m_errorStream << fname << ':' << lineNum << ' ' << message << endl; QVERIFY2(sql.endsWith(';'), qPrintable(message)); } sql.chop(1); //qDebug() << "SQL:" << sql.toString() << expectError; // 1. Parse KDbParser *parser = m_parser.data(); bool ok = parser->parse(sql); QScopedPointer query(parser->query()); QCOMPARE(parser->query(), nullptr); // second call should always return nullptr ok = ok && query; if (ok) { // sucess, so error cannot be expected ok = !expectError; message = "Unexpected success of parsing SQL statement"; if (!ok) { m_errorStream << fname << ':' << lineNum << ' ' << message << endl; if (query) { const KDbConnectionAndQuerySchema connQuery(parser->connection(), *query); qDebug() << connQuery; m_errorStream << KDbUtils::debugString(connQuery) << endl; } } QVERIFY2(ok, qPrintable(message)); } else { // failure, so error should be expected ok = expectError; message = QString("%1; Failed to parse SQL Statement:\n\"%2\"\n %3^\n") .arg(KDbUtils::debugString(parser->error()), sql.toString(), QString(parser->error().position() - 1, QChar(' '))); if (ok) { qDebug() << parser->error(); } else { m_errorStream << fname << ':' << lineNum << message << endl; } QVERIFY2(ok, qPrintable(message)); } //! @todo support more drivers if (query) { // 2. Build native SQL for SQLite QList params; KDbEscapedString querySql; ok = m_utils.driverBuilder()->generateSelectStatement(&querySql, query.data(), params); QVERIFY2(ok, "Failed to generate native SQLite SQL statement from query"); //! @todo compare with template } if (query) { // 3. Build KDbSQL QList params; KDbEscapedString querySql; ok = m_utils.kdbBuilder()->generateSelectStatement(&querySql, query.data(), params); QVERIFY2(ok, "Failed to generate KDbSQL statement from query"); //! @todo compare with template // 3.1. Parse the generated KDbSQL again ok = parser->parse(querySql); QScopedPointer secondQuery(parser->query()); QCOMPARE(parser->query(), nullptr); // second call should always return nullptr ok = ok && secondQuery; QVERIFY2(ok, "Failed to parse generated KDbSQL statement again"); // 3.2. Compare the original query from step #1 with this query ok = *query == *secondQuery; QVERIFY2(ok, "Original query differs from repeatedly parsed query"); } } void SqlParserTest::testTokens() { KDbToken t = KDbToken::LEFT; //qDebug() << t << t.toChar() << t.value() << t.isValid(); t = '+'; //qDebug() << t << t.toChar() << t.value() << t.isValid(); t = KDbToken(); //qDebug() << t << t.toChar() << t.value() << t.isValid(); QCOMPARE(KDbToken::SQL_TYPE.value(), 258); QCOMPARE(KDbToken::AS.value(), 259); QCOMPARE(KDbToken::AS_EMPTY.value(), 260); QCOMPARE(KDbToken::ASC.value(), 261); QCOMPARE(KDbToken::AUTO_INCREMENT.value(), 262); QCOMPARE(KDbToken::BIT.value(), 263); QCOMPARE(KDbToken::BITWISE_SHIFT_LEFT.value(), 264); QCOMPARE(KDbToken::BITWISE_SHIFT_RIGHT.value(), 265); QCOMPARE(KDbToken::BY.value(), 266); QCOMPARE(KDbToken::CHARACTER_STRING_LITERAL.value(), 267); QCOMPARE(KDbToken::CONCATENATION.value(), 268); QCOMPARE(KDbToken::CREATE.value(), 269); QCOMPARE(KDbToken::DESC.value(), 270); QCOMPARE(KDbToken::DISTINCT.value(), 271); QCOMPARE(KDbToken::DOUBLE_QUOTED_STRING.value(), 272); QCOMPARE(KDbToken::FROM.value(), 273); QCOMPARE(KDbToken::JOIN.value(), 274); QCOMPARE(KDbToken::KEY.value(), 275); QCOMPARE(KDbToken::LEFT.value(), 276); QCOMPARE(KDbToken::LESS_OR_EQUAL.value(), 277); QCOMPARE(KDbToken::GREATER_OR_EQUAL.value(), 278); QCOMPARE(KDbToken::SQL_NULL.value(), 279); QCOMPARE(KDbToken::SQL_IS.value(), 280); QCOMPARE(KDbToken::SQL_IS_NULL.value(), 281); QCOMPARE(KDbToken::SQL_IS_NOT_NULL.value(), 282); QCOMPARE(KDbToken::ORDER.value(), 283); QCOMPARE(KDbToken::PRIMARY.value(), 284); QCOMPARE(KDbToken::SELECT.value(), 285); QCOMPARE(KDbToken::INTEGER_CONST.value(), 286); QCOMPARE(KDbToken::REAL_CONST.value(), 287); QCOMPARE(KDbToken::RIGHT.value(), 288); QCOMPARE(KDbToken::SQL_ON.value(), 289); QCOMPARE(KDbToken::DATE_CONST.value(), 290); QCOMPARE(KDbToken::DATETIME_CONST.value(), 291); QCOMPARE(KDbToken::TIME_CONST.value(), 292); QCOMPARE(KDbToken::TABLE.value(), 293); QCOMPARE(KDbToken::IDENTIFIER.value(), 294); QCOMPARE(KDbToken::IDENTIFIER_DOT_ASTERISK.value(), 295); QCOMPARE(KDbToken::QUERY_PARAMETER.value(), 296); QCOMPARE(KDbToken::VARCHAR.value(), 297); QCOMPARE(KDbToken::WHERE.value(), 298); QCOMPARE(KDbToken::SQL.value(), 299); QCOMPARE(KDbToken::SQL_TRUE.value(), 300); QCOMPARE(KDbToken::SQL_FALSE.value(), 301); QCOMPARE(KDbToken::UNION.value(), 302); QCOMPARE(KDbToken::SCAN_ERROR.value(), 303); QCOMPARE(KDbToken::AND.value(), 304); QCOMPARE(KDbToken::BETWEEN.value(), 305); QCOMPARE(KDbToken::NOT_BETWEEN.value(), 306); QCOMPARE(KDbToken::EXCEPT.value(), 307); QCOMPARE(KDbToken::SQL_IN.value(), 308); QCOMPARE(KDbToken::INTERSECT.value(), 309); QCOMPARE(KDbToken::LIKE.value(), 310); QCOMPARE(KDbToken::ILIKE.value(), 311); QCOMPARE(KDbToken::NOT_LIKE.value(), 312); QCOMPARE(KDbToken::NOT.value(), 313); QCOMPARE(KDbToken::NOT_EQUAL.value(), 314); QCOMPARE(KDbToken::NOT_EQUAL2.value(), 315); QCOMPARE(KDbToken::OR.value(), 316); QCOMPARE(KDbToken::SIMILAR_TO.value(), 317); QCOMPARE(KDbToken::NOT_SIMILAR_TO.value(), 318); QCOMPARE(KDbToken::XOR.value(), 319); QCOMPARE(KDbToken::UMINUS.value(), 320); //! @todo add extra tokens: BETWEEN_AND, NOT_BETWEEN_AND } void SqlParserTest::cleanupTestCase() { QVERIFY(m_utils.testDisconnect()); m_errorFile.close(); #if 0 if (!m_conn->dropDatabase()) { qDebug() << m_conn->result(); } qDebug() << "Database" << m_conn->data().databaseName() << "dropped."; #endif }