From 34d112062c7c316d2c1744e54fb8e43ad201b29f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Fischer?= Date: Thu, 14 Nov 2019 14:46:44 +0100 Subject: [PATCH 1/6] add function for UPDATE, needs to be edited --- src/serversdk/databaseutils.cpp | 32 ++++++++++++++++++++++++++++++++ src/serversdk/databaseutils.h | 3 +++ 2 files changed, 35 insertions(+) diff --git a/src/serversdk/databaseutils.cpp b/src/serversdk/databaseutils.cpp index 5de8838..57e2180 100644 --- a/src/serversdk/databaseutils.cpp +++ b/src/serversdk/databaseutils.cpp @@ -141,6 +141,38 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri return res; } +QSqlQuery DatabaseUtils::updateTable(const DatabaseTable *table, const QString table_name) const +{ + QString columnsAndValues; + + // tepmporary, for edit ( add one more parameter to func sth like QList with conditions + QString conditions; + conditions = "id = :id"; + + QVariantMap valueMap = table->toVariantMap(); + + + auto keys = valueMap.keys(); + for (auto key : keys) { + if (!columnsAndValues.isEmpty()) { + columnsAndValues += ", "; + } + columnsAndValues += key + "= :" + key; + } + + QSqlQuery query(mDatabaseManager->database()); + QString queryText = QString("UPDATE %1 SET %2 WHERE %3 );").arg(table_name).arg(columnsAndValues).arg(conditions); + query.prepare(queryText); + + for (auto key : keys ) { + auto value = valueMap.value(key); + query.bindValue(":"+key, value); + } + + QSqlQuery res = mDatabaseManager->executeQuery(query); + return res; +} + QList> DatabaseUtils::listMapFromQuery(QSqlQuery query) const { diff --git a/src/serversdk/databaseutils.h b/src/serversdk/databaseutils.h index 58572f5..125441d 100644 --- a/src/serversdk/databaseutils.h +++ b/src/serversdk/databaseutils.h @@ -22,6 +22,9 @@ public: QSqlQuery createTable(const DatabaseTable *table, const QString table_name) const; QSqlQuery insertIntoTable(const DatabaseTable *table, const QString table_name) const; + + QSqlQuery updateTable(const DatabaseTable *table, const QString table_name) const; + QList> listMapFromQuery(QSqlQuery query) const; QString sqlType() const; From 793bfde1debe70a9972809532889a571f019b4af Mon Sep 17 00:00:00 2001 From: Filip Bucek Date: Mon, 18 Nov 2019 10:41:24 +0100 Subject: [PATCH 2/6] Example in tst_databasetable how to handle different Json / Table data + camel case handling --- src/serversdk/databasetable.cpp | 20 +++--- src/serversdk/databasetable.h | 4 +- src/serversdk/databaseutils.cpp | 33 ++++++++-- src/serversdk/databaseutils.h | 5 ++ test/auto/database/tst_databasetable.cpp | 82 ++++++++++++++++++++++++ test/auto/database/tst_databaseutils.cpp | 14 ++++ test/auto/database/tst_sqlite.cpp | 4 +- 7 files changed, 143 insertions(+), 19 deletions(-) diff --git a/src/serversdk/databasetable.cpp b/src/serversdk/databasetable.cpp index 3e3b2f1..b03e8d9 100644 --- a/src/serversdk/databasetable.cpp +++ b/src/serversdk/databasetable.cpp @@ -19,6 +19,16 @@ QByteArray DatabaseTable::jsonData() const return doc.toJson(QJsonDocument::Compact); } +bool DatabaseTable::fromJson(const QByteArray &data) +{ + // in: JSON ( e.g. {"id": 300} ) + QJsonDocument doc = QJsonDocument::fromJson(data); + QVariantMap variant = qvariant_cast(doc.toVariant()); + + // Populate this object data + bool res = fromVariantMap(variant); + return res; +} /** Creates universal variant structure to hold key / value pairs */ QVariantMap DatabaseTable::toVariantMap() const @@ -76,16 +86,6 @@ QList > DatabaseTable::fromListVariantMap(const Q return list; } -bool DatabaseTable::fromJson(const QByteArray &data) -{ - // in: JSON ( e.g. {"id": 300} ) - QJsonDocument doc = QJsonDocument::fromJson(data); - QVariantMap variant = qvariant_cast(doc.toVariant()); - - // Populate this object data - bool res = fromVariantMap(variant); - return res; -} QString DatabaseTable::textSQLIteType(QVariant::Type type) const { diff --git a/src/serversdk/databasetable.h b/src/serversdk/databasetable.h index bd6dea4..018ea98 100644 --- a/src/serversdk/databasetable.h +++ b/src/serversdk/databasetable.h @@ -84,13 +84,13 @@ public: * @brief Creates JSON from QMetaObject data ( Q_PROPERTY ) -> TABLE_PROPERTY * @return text json e.g. { "id": 00344 } */ - QByteArray jsonData() const; + virtual QByteArray jsonData() const; /** * @brief Populates object with JSON {"id": 300} ) * @return true if success TODO: not implemented corrrectly */ - bool fromJson(const QByteArray &data); + virtual bool fromJson(const QByteArray &data); /** * @brief Creates VariantMap from QMetaObject data ( Q_PROPERTY ) diff --git a/src/serversdk/databaseutils.cpp b/src/serversdk/databaseutils.cpp index 235fb5c..5bfb0a3 100644 --- a/src/serversdk/databaseutils.cpp +++ b/src/serversdk/databaseutils.cpp @@ -56,7 +56,7 @@ QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString if (!prop.isUser()) continue; - QString name = prop.name(); + QString name = fromCamelCase(prop.name()); QVariant::Type type = prop.type(); QString textType; @@ -116,9 +116,12 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri QVariantMap valueMap = table->toVariantMap(); - + // in: id / 23233 + // out: columns: id + // out: values: :id auto keys = valueMap.keys(); - for (auto key : keys) { + for (auto _key : keys) { + QString key = fromCamelCase(_key); if (!columns.isEmpty()) { columns += ", "; values += ", "; @@ -152,7 +155,8 @@ QSqlQuery DatabaseUtils::updateTable(const DatabaseTable *table, const QString t auto keys = valueMap.keys(); - for (auto key : keys) { + for (auto _key : keys) { + QString key = fromCamelCase(_key); if (!columnsAndValues.isEmpty()) { columnsAndValues += ", "; } @@ -184,6 +188,27 @@ void DatabaseUtils::setSqlType(const QString &sqlType) mSqlType = sqlType; } +QString DatabaseUtils::fromCamelCase(const QString &s) +{ + static QRegularExpression regExp1 {"(.)([A-Z][a-z]+)"}; + static QRegularExpression regExp2 {"([a-z0-9])([A-Z])"}; + + QString result = s; + result.replace(regExp1, "\\1_\\2"); + result.replace(regExp2, "\\1_\\2"); + + return result.toLower(); +} + +QString serversdk::DatabaseUtils::toCamelCase(const QString &s) +{ + QStringList parts = s.split('_', QString::SkipEmptyParts); + for (int i=1; i +#include #include #include @@ -48,6 +49,9 @@ public: QString sqlType() const; void setSqlType(const QString &sqlType); + static QString fromCamelCase(const QString &s); + static QString toCamelCase(const QString& s); + private: QString createTableText(const DatabaseTable *table, const QString table_name) const; @@ -56,5 +60,6 @@ private: QString mSqlType; }; + } // namespace serversdk diff --git a/test/auto/database/tst_databasetable.cpp b/test/auto/database/tst_databasetable.cpp index d58dabc..0aa5aa8 100644 --- a/test/auto/database/tst_databasetable.cpp +++ b/test/auto/database/tst_databasetable.cpp @@ -13,6 +13,58 @@ class BookTable : public serversdk::DatabaseTable }; +QString enumjson = R"({"authErrors":255,"flags":["Enabled","NoValidity"],"subjectId":"1438aade-3aa6-4885-8e0f-138dedae727a"})"; + + +class EnumTest : public serversdk::DatabaseTable +{ + Q_OBJECT + TABLE_PROPERTY(int, authErrors, setAuthErrors, 0); + TABLE_PROPERTY(bool, enabled, setEnabled, false); + TABLE_PROPERTY(bool, noValidity, setNoValidity, false); + TABLE_PROPERTY(QString, subjectId, setSubjectId, QString()); +public: + QByteArray jsonData() const override + { + auto variantMap = this->toVariantMap(); + auto enabled = variantMap["enabled"].toBool(); + auto noValidity = variantMap["noValidity"].toBool(); + variantMap.remove("enabled"); + variantMap.remove("noValidity"); + QVariantList flags; + if ( enabled ) { + flags << "Enabled"; + } + if ( noValidity ) { + flags << "NoValidity"; + } + variantMap.insert("flags", flags); + + QJsonDocument doc = QJsonDocument::fromVariant(variantMap); + return doc.toJson(QJsonDocument::Compact); + } + bool fromJson(const QByteArray &data) override + { + QJsonDocument doc = QJsonDocument::fromJson(data); + QVariantMap variant = qvariant_cast(doc.toVariant()); + + QVariantList flags = variant["flags"].toList(); + for (auto value : flags) { + if ( value.toString() == "Enabled") { + variant.insert("enabled", true); + } + if ( value.toString() == "NoValidity") { + variant.insert("noValidity", true); + } + } + variant.remove("flags"); + + // Populate this object data + bool res = fromVariantMap(variant); + return res; + } +}; + class DatabaseTableTest : public QObject { @@ -26,6 +78,7 @@ private slots: void constructor_test(); void qvariant_test(); void json_test(); + void enum_test(); }; @@ -61,6 +114,35 @@ void DatabaseTableTest::json_test() QCOMPARE(table->jsonData(), expected); } +void DatabaseTableTest::enum_test() +{ + auto table = std::make_unique(); + table->setAuthErrors(255); + table->setNoValidity(true); + table->setEnabled(true); + table->setSubjectId("1438aade-3aa6-4885-8e0f-138dedae727a"); + + QCOMPARE(table->jsonData(), enumjson.toUtf8()); + + EnumTest jsonTest; + + jsonTest.fromJson(enumjson.toUtf8()); + + QCOMPARE(jsonTest.authErrors(), 255); + QCOMPARE(jsonTest.noValidity(), true); + QCOMPARE(jsonTest.enabled(), true); + QCOMPARE(jsonTest.subjectId(), QStringLiteral("1438aade-3aa6-4885-8e0f-138dedae727a")); + +} + + + + + + + + + QTEST_APPLESS_MAIN(DatabaseTableTest) #include "tst_databasetable.moc" diff --git a/test/auto/database/tst_databaseutils.cpp b/test/auto/database/tst_databaseutils.cpp index 8d2618a..442f8c3 100644 --- a/test/auto/database/tst_databaseutils.cpp +++ b/test/auto/database/tst_databaseutils.cpp @@ -33,6 +33,8 @@ public: private slots: void createTable_test(); + void toCamelCase_test(); + void fromCamelCase_test(); }; @@ -64,6 +66,18 @@ void DatabaseUtilsTest::createTable_test() QCOMPARE(sql, expected); } +void DatabaseUtilsTest::toCamelCase_test() +{ + QString test1 = "id_name"; + QCOMPARE(serversdk::DatabaseUtils::toCamelCase(test1), QStringLiteral("idName")); +} + +void DatabaseUtilsTest::fromCamelCase_test() +{ + QString test1 = "idName"; + QCOMPARE(serversdk::DatabaseUtils::fromCamelCase(test1), QStringLiteral("id_name")); +} + QTEST_APPLESS_MAIN(DatabaseUtilsTest) diff --git a/test/auto/database/tst_sqlite.cpp b/test/auto/database/tst_sqlite.cpp index bfc9c4e..6480e04 100644 --- a/test/auto/database/tst_sqlite.cpp +++ b/test/auto/database/tst_sqlite.cpp @@ -90,9 +90,7 @@ void SqliteTest::createTable_test() // ENSURE SAME QCOMPARE(list.count(), 1); - auto first = list.first(); - QVERIFY(first); - auto names_tab = std::dynamic_pointer_cast(first); + auto names_tab = list.first(); QVERIFY(names_tab); QCOMPARE(names_tab->name(), QStringLiteral("Testname")); From 7071d874b066b95f140ecece6609d21d4707fc98 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Fischer?= Date: Mon, 18 Nov 2019 17:06:49 +0100 Subject: [PATCH 3/6] fix error caused by using toCamelCase --- src/serversdk/databaseutils.cpp | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/serversdk/databaseutils.cpp b/src/serversdk/databaseutils.cpp index 5bfb0a3..298fe11 100644 --- a/src/serversdk/databaseutils.cpp +++ b/src/serversdk/databaseutils.cpp @@ -134,8 +134,9 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri QString queryText = QString("INSERT INTO %1 ( %2 ) VALUES ( %3 );").arg(table_name).arg(columns).arg(values); query.prepare(queryText); - for (auto key : keys ) { - auto value = valueMap.value(key); + for (auto _key : keys ) { + QString key = fromCamelCase(_key); + auto value = valueMap.value(_key); query.bindValue(":"+key, value); } @@ -153,22 +154,22 @@ QSqlQuery DatabaseUtils::updateTable(const DatabaseTable *table, const QString t QVariantMap valueMap = table->toVariantMap(); - auto keys = valueMap.keys(); for (auto _key : keys) { QString key = fromCamelCase(_key); if (!columnsAndValues.isEmpty()) { columnsAndValues += ", "; } - columnsAndValues += key + "= :" + key; + columnsAndValues += key + " = :" + key; } QSqlQuery query(mDatabaseManager->database()); - QString queryText = QString("UPDATE %1 SET %2 WHERE %3 );").arg(table_name).arg(columnsAndValues).arg(conditions); + QString queryText = QString("UPDATE %1 SET %2 WHERE %3;").arg(table_name).arg(columnsAndValues).arg(conditions); query.prepare(queryText); - for (auto key : keys ) { - auto value = valueMap.value(key); + for (auto _key : keys ) { + QString key = fromCamelCase(_key); + auto value = valueMap.value(_key); query.bindValue(":"+key, value); } From 583a652cff34f9be0e939ef278d4ee6be4443803 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Fischer?= Date: Tue, 19 Nov 2019 09:15:45 +0100 Subject: [PATCH 4/6] add create query --- src/serversdk/databasemanager.cpp | 6 ++++++ src/serversdk/databasemanager.h | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/serversdk/databasemanager.cpp b/src/serversdk/databasemanager.cpp index a5299e7..628fa8d 100644 --- a/src/serversdk/databasemanager.cpp +++ b/src/serversdk/databasemanager.cpp @@ -116,6 +116,12 @@ QSqlQuery DatabaseManager::executeQuery(QSqlQuery &query, const QString &sqlText return query; } +QSqlQuery DatabaseManager::createQuery() +{ + QSqlQuery query(mDatabase); + return query; +} + QSqlQuery DatabaseManager::processResult(int res, const QSqlQuery &query) const { if ( !res ) { diff --git a/src/serversdk/databasemanager.h b/src/serversdk/databasemanager.h index e082e7c..1e4139c 100644 --- a/src/serversdk/databasemanager.h +++ b/src/serversdk/databasemanager.h @@ -25,7 +25,6 @@ public: bool dryMode() const; void setDryMode(bool dryMode); - bool openSQLite(const QString &path, const QString &connectionName = QStringLiteral("qt_sql_default_connection")); bool openPostgres(const QString& host, const QString& dbName, const QString& user, const QString& password, const QString &connectionName = QStringLiteral("qt_sql_default_connection")); bool isValid() const; @@ -35,6 +34,7 @@ public: // SQL handling QSqlQuery execPlainSql(const QString &sqlText); QSqlQuery executeQuery(QSqlQuery &query, const QString &sqlText = QString()); + QSqlQuery createQuery(); QSqlDatabase database() const; From e266b8a8b407f342decec145013bfbe97f710c7e Mon Sep 17 00:00:00 2001 From: Filip Bucek Date: Tue, 19 Nov 2019 09:40:40 +0100 Subject: [PATCH 5/6] Not using Quid --- test/auto/database/tst_databasetable.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/auto/database/tst_databasetable.cpp b/test/auto/database/tst_databasetable.cpp index 0aa5aa8..72f8e39 100644 --- a/test/auto/database/tst_databasetable.cpp +++ b/test/auto/database/tst_databasetable.cpp @@ -7,7 +7,7 @@ class BookTable : public serversdk::DatabaseTable { Q_OBJECT - TABLE_PROPERTY(QUuid, uuid, setUuid, QUuid()); + TABLE_PROPERTY(QString, uuid, setUuid, QString()); TABLE_PROPERTY(int, id, setId, 0); TABLE_PROPERTY(QString, name, setName, "Test"); }; @@ -110,7 +110,7 @@ void DatabaseTableTest::json_test() QCOMPARE(table->id(), 0); QCOMPARE(table->name(), QStringLiteral("Test")); - QByteArray expected(R"({"id":0,"name":"Test","uuid":"{00000000-0000-0000-0000-000000000000}"})"); + QByteArray expected(R"({"id":0,"name":"Test","uuid":""})"); QCOMPARE(table->jsonData(), expected); } From 9cc150d50b37a494067e34aeb8ebed197e6bd98e Mon Sep 17 00:00:00 2001 From: Filip Bucek Date: Tue, 19 Nov 2019 10:17:22 +0100 Subject: [PATCH 6/6] fixing unittest ( update unittest, primary key, camelCase ) --- src/serversdk/databaseutils.cpp | 18 +++--- src/serversdk/databaseutils.h | 4 +- test/auto/database/tst_databaseutils.cpp | 2 +- test/auto/database/tst_postgresql.cpp | 8 +-- test/auto/database/tst_sqlite.cpp | 75 ++++++++++++++++++------ 5 files changed, 77 insertions(+), 30 deletions(-) diff --git a/src/serversdk/databaseutils.cpp b/src/serversdk/databaseutils.cpp index 298fe11..d4fa87d 100644 --- a/src/serversdk/databaseutils.cpp +++ b/src/serversdk/databaseutils.cpp @@ -79,7 +79,7 @@ QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString // in: PRIMARY KEY // out: "CREATE TABLE colnod_subject ( id TEXT PRIMARY KEY" if (first) { // first row - sql += " PRIMARY KEY"; + sql += " PRIMARY KEY NOT NULL"; first = false; } @@ -105,6 +105,7 @@ QSqlQuery DatabaseUtils::createTable(const DatabaseTable *table, const QString t { // CREATE TABLE ... QString sql = createTableText(table, tableName); + qCDebug(sdkdb) << "SQL:" << sql; return mDatabaseManager->execPlainSql(sql); } @@ -147,14 +148,17 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri QSqlQuery DatabaseUtils::updateTable(const DatabaseTable *table, const QString table_name) const { QString columnsAndValues; - - // tepmporary, for edit ( add one more parameter to func sth like QList with conditions - QString conditions; - conditions = "id = :id"; + QString primaryKeyCondition; QVariantMap valueMap = table->toVariantMap(); - auto keys = valueMap.keys(); + + Q_ASSERT(!keys.isEmpty()); + // Primary key is first user property ( first VariantMap item ) + // in ( primary key ): id + // out: id = :id + primaryKeyCondition = keys.at(0) + " = :" + keys.at(0); + for (auto _key : keys) { QString key = fromCamelCase(_key); if (!columnsAndValues.isEmpty()) { @@ -164,7 +168,7 @@ QSqlQuery DatabaseUtils::updateTable(const DatabaseTable *table, const QString t } QSqlQuery query(mDatabaseManager->database()); - QString queryText = QString("UPDATE %1 SET %2 WHERE %3;").arg(table_name).arg(columnsAndValues).arg(conditions); + QString queryText = QString("UPDATE %1 SET %2 WHERE %3;").arg(table_name).arg(columnsAndValues).arg(primaryKeyCondition); query.prepare(queryText); for (auto _key : keys ) { diff --git a/src/serversdk/databaseutils.h b/src/serversdk/databaseutils.h index 99c686e..0aefe71 100644 --- a/src/serversdk/databaseutils.h +++ b/src/serversdk/databaseutils.h @@ -35,7 +35,9 @@ public: int total = rec.count(); QMap map; for (int column = 0; column < total; ++column) { - map.insert(rec.fieldName(column), query.value(column)); + QString columnName = rec.fieldName(column); + QString propertyName = toCamelCase(columnName); + map.insert(propertyName, query.value(column)); } auto data = std::make_shared(); diff --git a/test/auto/database/tst_databaseutils.cpp b/test/auto/database/tst_databaseutils.cpp index 442f8c3..6b2547b 100644 --- a/test/auto/database/tst_databaseutils.cpp +++ b/test/auto/database/tst_databaseutils.cpp @@ -55,7 +55,7 @@ void DatabaseUtilsTest::createTable_test() QString sql = utils.createTableText(table.get(), "subjects"); QString expected = "CREATE TABLE subjects ( " - "id TEXT PRIMARY KEY, " + "id TEXT PRIMARY KEY NOT NULL, " "description TEXT, " "last_update INTEGER, " "name TEXT, " diff --git a/test/auto/database/tst_postgresql.cpp b/test/auto/database/tst_postgresql.cpp index 11efa56..bf1833b 100644 --- a/test/auto/database/tst_postgresql.cpp +++ b/test/auto/database/tst_postgresql.cpp @@ -6,7 +6,7 @@ // add necessary includes here -class Names : public serversdk::DatabaseTable { +class Name : public serversdk::DatabaseTable { Q_OBJECT TABLE_PROPERTY(int, id, set_id, 0); TABLE_PROPERTY(QString, name, set_name, 0); @@ -68,7 +68,7 @@ void PostgresqlTest::createTable_test() QVERIFY(db.isValid()); QVERIFY(db.isOpen()); - Names names; + Name names; //Have to drop tabel QSqlQuery dropQuery = db.execPlainSql("DROP TABLE names"); @@ -87,13 +87,13 @@ void PostgresqlTest::createTable_test() // SELECT FROM TABLE QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names"); - auto list = utils.tableFromQuery(selectSQL); + auto list = utils.tableFromQuery(selectSQL); // ENSURE SAME auto first = list.first(); // Problem is that fromListvariantMap returns shared_ptr of class DataTable // Must subclass. - auto names_tab = std::dynamic_pointer_cast(first); + auto names_tab = std::dynamic_pointer_cast(first); QCOMPARE(list.count(), 1); QCOMPARE(names_tab->name(), QStringLiteral("Testname")); diff --git a/test/auto/database/tst_sqlite.cpp b/test/auto/database/tst_sqlite.cpp index 6480e04..f0dab35 100644 --- a/test/auto/database/tst_sqlite.cpp +++ b/test/auto/database/tst_sqlite.cpp @@ -6,10 +6,12 @@ // add necessary includes here -class Names : public serversdk::DatabaseTable { +class Name : public serversdk::DatabaseTable { Q_OBJECT + TABLE_PROPERTY(QString, uuid, set_uuid, QString()); TABLE_PROPERTY(int, id, set_id, 0); - TABLE_PROPERTY(QString, name, set_name, 0); + TABLE_PROPERTY(QString, name, set_name, ""); + TABLE_PROPERTY(QString, vehicleName, set_vehicle_name, "Škodouliňkaťoučký"); }; @@ -18,24 +20,14 @@ class SqliteTest : public QObject Q_OBJECT public: - SqliteTest(); - ~SqliteTest(); + SqliteTest() = default; private slots: void createDb_test(); void createTable_test(); - + void updateTable_test(); }; -SqliteTest::SqliteTest() -{ - -} - -SqliteTest::~SqliteTest() -{ - -} void SqliteTest::createDb_test() { @@ -72,27 +64,76 @@ void SqliteTest::createTable_test() db.openSQLite(dbpath); QVERIFY(db.isOpen()); - Names names; + Name name_A, name_B; + + // CREATE TABLE + serversdk::DatabaseUtils utils(&db); + QSqlQuery query = utils.createTable(&name_A, "names"); + + // INSERT INTO TABLE + const QString uuidA = "48f64fab-ba2a-40b5-8fbb-75361099dfb6"; + const QString uuidB = "d70143ab-8c14-4ee0-85cb-f0d1b72df104"; + name_A.set_uuid(uuidA); + name_A.set_id(2); + name_A.set_name("TestnameA"); + name_B.set_uuid(uuidB); + name_B.set_id(2); + name_B.set_name("TestnameB"); + + utils.insertIntoTable(&name_A, "names"); + utils.insertIntoTable(&name_B, "names"); + + // SELECT FROM TABLE + QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names"); + auto list = utils.tableFromQuery(selectSQL); + + + // ENSURE SAME + QCOMPARE(list.count(), 2); + auto names_tab = list.first(); + qDebug() << "Uuid" << names_tab->uuid(); + QVERIFY(names_tab); + QCOMPARE(names_tab->name(), QStringLiteral("TestnameA")); + + QCOMPARE(list.first()->jsonData(), name_A.jsonData()); +} + +void SqliteTest::updateTable_test() +{ + // Prepare temporary path for database + QTemporaryDir dir; + QString dbpath = dir.path() + "/testdb.sqlite"; + serversdk::DatabaseManager db; + db.openSQLite(dbpath); + QVERIFY(db.isOpen()); + + Name names; // CREATE TABLE serversdk::DatabaseUtils utils(&db); QSqlQuery query = utils.createTable(&names, "names"); // INSERT INTO TABLE + const QString uuidA = "48f64fab-ba2a-40b5-8fbb-75361099dfb6"; + names.set_uuid(uuidA); names.set_id(2); names.set_name("Testname"); utils.insertIntoTable(&names, "names"); + // NOW UPDATING TABLE WITH name: NewName + names.set_name("NewName"); + utils.updateTable(&names, "names"); + // SELECT FROM TABLE QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names"); - auto list = utils.tableFromQuery(selectSQL); + auto list = utils.tableFromQuery(selectSQL); // ENSURE SAME QCOMPARE(list.count(), 1); auto names_tab = list.first(); QVERIFY(names_tab); - QCOMPARE(names_tab->name(), QStringLiteral("Testname")); + QCOMPARE(names_tab->name(), QStringLiteral("NewName")); QCOMPARE(list.first()->jsonData(), names.jsonData()); }