[SqliteWAL功能增强] SqliteWAL模式下多线程并发写入数据库程序更新

- 新增：`databasetest.cc` 和 `databasetest.hpp` 文件，增加了`DataBaseTest`类，用于测试数据库操作。
- 新增：`databaseutils.cc` 和 `databaseutils.hpp` 文件，提供了数据库连接和移除的工具函数。
- 修改：`main.cc` 文件，更新了多线程插入数据的方式，使用新的`DataBaseTest`类。
- 修改：`CMakeLists.txt` 和 `SqliteWAL.pro` 文件，添加了新的源文件和头文件。
- 删除：`sqlutils.cc` 和 `sqlutils.hpp` 文件，移除了旧的`SqlUtils`类。
- 更新：`README.md` 文件，对SqliteWAL模式的描述进行了更新和补充。

Author: RealChuan

README.md

@@ -150,17 +150,19 @@
 
 ## [SqliteWAL](SqliteWAL/)——Sqlite WAL 模式下多线程并发写入数据库程序
 
+1. 每个线程拥有独立的数据库连接（不同的连接名称），线程退出需要主动移除数据库连接，不然会产生大量的数据库连接；
+2. 在多线程下，依旧使用QMutex保证线程安全，在读的时候，可以考虑不使用QMutex，并发读应该没什么影响（对于写的时候，可以考虑使用QMutex）;
+
 ### WAL模式的优点
 
-1. 提高了并发性：WAL模式允许多个读取器和一个写入器同时访问数据库，可以提高并发性能和性能；
+1. 提高了并发性：WAL模式允许多个读取器和一个写入器同时访问数据库，可以提高并发性能；
 2. 崩溃恢复：WAL模式在发生崩溃时确保数据库保持一致，通过在提交事务之前将所有更改刷新到日志文件来实现；
-3. 改进了写入性能：WAL模式允许并发写入，可以比默认的回滚模式更好地改进写入性能；
 
 ### WAL模式的注意事项
 
 1. WAL模式仅适用于SQLite 3.35.5+版本；
 2. 增加了磁盘使用量：与回滚模式相比，WAL模式需要更多的磁盘空间，因为它在提交更改之前将所有更改都写入日志文件；
-3. 读取性能较慢：在WAL模式下，读取操作不会被写入操作阻塞，如果同时进行读取和写入操作，可能导致数据不一致。
+3. 读取性能较慢：读取操作不会被写入操作阻塞，如果同时进行读取和写入操作，可能导致数据不一致。
 
 ## [TableViewModel](TableViewModel/)——表格视图
 

SqliteWAL/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(PROJECT_SOURCES main.cc sqlutils.cc sqlutils.hpp)
+set(PROJECT_SOURCES databasetest.cc databasetest.hpp databaseutils.cc
+                    databaseutils.hpp main.cc)
 
 qt_add_executable(SqliteWAL MANUAL_FINALIZATION ${PROJECT_SOURCES})
 target_link_libraries(SqliteWAL PRIVATE Qt6::Core Qt6::Sql)

SqliteWAL/SqliteWAL.pro

@@ -7,13 +7,15 @@ CONFIG += c++17 cmdline
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
 
 SOURCES += \
-        main.cc \
-        sqlutils.cc
+        databasetest.cc \
+        databaseutils.cc \
+        main.cc
 
 # Default rules for deployment.
 qnx: target.path = /tmp/$${TARGET}/bin
 else: unix:!android: target.path = /opt/$${TARGET}/bin
 !isEmpty(target.path): INSTALLS += target
 
 HEADERS += \
-    sqlutils.hpp
+    databasetest.hpp \
+    databaseutils.hpp

SqliteWAL/databasetest.cc

@@ -0,0 +1,95 @@
+#include "databasetest.hpp"
+#include "databaseutils.hpp"
+
+#include <QDir>
+#include <QMutex>
+#include <QSqlDriver>
+#include <QSqlError>
+#include <QSqlQuery>
+#include <QThread>
+
+class DataBaseTest::DataBaseTestPrivate
+{
+public:
+    explicit DataBaseTestPrivate(DataBaseTest *q)
+        : q_ptr(q)
+    {
+        dataBaseConnection.dataBasePath = QString("%1/%2").arg(QDir::tempPath()).arg("test.db");
+        dataBaseConnection.connectionName = getDatabaseConnectionName();
+
+        createTable();
+
+        qInfo() << "DataBaseTestPrivate connectionName: " << dataBaseConnection.connectionName
+                << QThread::currentThread();
+    }
+
+    ~DataBaseTestPrivate() { removeDatabase(dataBaseConnection.connectionName); }
+
+    bool createTable()
+    {
+        const auto createTable
+            = QString("CREATE TABLE [%1]("
+                      " [id] INTEGER NOT NULL ON CONFLICT REPLACE UNIQUE ON CONFLICT "
+                      "REPLACE COLLATE BINARY, "
+                      " [brand] TEXT, "
+                      " [num] TEXT, "
+                      " [create_time] TIMESTAMP DEFAULT CURRENT_TIMESTAMP, "
+                      " PRIMARY KEY([id] COLLATE [BINARY] ASC) ON CONFLICT REPLACE)")
+                  .arg(tableName);
+
+        QMutexLocker locker(&mutex);
+        auto db = getDatabase(dataBaseConnection);
+        CHECK_DATABASE_VALIDITY(db)
+
+        auto *driver = db.driver();
+        qInfo() << "Support Transactions: " << driver->hasFeature(QSqlDriver::Transactions)
+                << "Support LastInsertId: " << driver->hasFeature(QSqlDriver::LastInsertId)
+                << "Support BatchOperations: " << driver->hasFeature(QSqlDriver::BatchOperations)
+                << "Support SimpleLocking: " << driver->hasFeature(QSqlDriver::SimpleLocking);
+
+        if (db.tables().contains(tableName)) {
+            return true;
+        }
+
+        QSqlQuery query(db);
+        if (!query.exec(createTable)) {
+            qWarning() << query.lastError().text();
+            return false;
+        }
+        return true;
+    }
+
+    DataBaseTest *q_ptr;
+
+    DataBaseConnection dataBaseConnection;
+    const QString tableName = "phone";
+
+    static QMutex mutex;
+};
+
+QMutex DataBaseTest::DataBaseTestPrivate::mutex;
+
+DataBaseTest::DataBaseTest(QObject *parent)
+    : QObject{parent}
+    , d_ptr(new DataBaseTestPrivate(this))
+{}
+
+DataBaseTest::~DataBaseTest() {}
+
+bool DataBaseTest::insert(const QString &brand, int num)
+{
+    QMutexLocker locker(&d_ptr->mutex);
+    auto db = getDatabase(d_ptr->dataBaseConnection);
+    CHECK_DATABASE_VALIDITY(db)
+    QSqlQuery query(db);
+    query.prepare(
+        QString("INSERT INTO %1 (brand, num) VALUES (:brand, :num)").arg(d_ptr->tableName));
+    query.bindValue(":brand", brand);
+    query.bindValue(":num", num);
+    if (!query.exec()) {
+        qCritical() << query.lastError().text();
+        return false;
+    }
+    qInfo() << "Last inserted id:" << query.lastInsertId().toInt();
+    return true;
+}

SqliteWAL/databasetest.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <QObject>
+
+class DataBaseTest : public QObject
+{
+    Q_OBJECT
+public:
+    explicit DataBaseTest(QObject *parent = nullptr);
+    ~DataBaseTest();
+
+    bool insert(const QString &brand, int num);
+
+private:
+    class DataBaseTestPrivate;
+    QScopedPointer<DataBaseTestPrivate> d_ptr;
+};

SqliteWAL/databaseutils.cc

@@ -0,0 +1,37 @@
+#include "databaseutils.hpp"
+
+#include <QFile>
+#include <QSqlQuery>
+
+QSqlDatabase getDatabase(const DataBaseConnection &dataBaseConnection)
+{
+    auto db = QSqlDatabase::database(dataBaseConnection.connectionName);
+    if (!db.isValid()) {
+        db = QSqlDatabase::addDatabase("QSQLITE", dataBaseConnection.connectionName);
+        db.setDatabaseName(dataBaseConnection.dataBasePath);
+    }
+
+    if (!db.isOpen()) {
+        if (!db.open()) {
+            QFile(dataBaseConnection.dataBasePath).remove();
+            db.open();
+        }
+        QSqlQuery walQuery(db);
+        walQuery.exec("PRAGMA journal_mode = WAL;");
+    }
+
+    return db;
+}
+
+void removeDatabase(const QString &connectionName)
+{
+    if (QSqlDatabase::contains(connectionName)) {
+        QSqlDatabase::removeDatabase(connectionName);
+    }
+}
+
+QString getDatabaseConnectionName()
+{
+    static std::atomic_llong id = 1;
+    return QString("connection_%1").arg(id.fetch_add(1, std::memory_order_seq_cst));
+}

SqliteWAL/databaseutils.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <QSqlDatabase>
+
+struct DataBaseConnection
+{
+    QString connectionName;
+    QString dataBasePath;
+};
+
+QSqlDatabase getDatabase(const DataBaseConnection &dataBaseConnection);
+
+void removeDatabase(const QString &connectionName);
+
+QString getDatabaseConnectionName();
+
+#define CHECK_DATABASE_VALIDITY(database) \
+    if (!(database).isValid()) { \
+        qWarning() << (database).lastError().text(); \
+        return false; \
+    }

SqliteWAL/main.cc

@@ -1,52 +1,15 @@
-#include "sqlutils.hpp"
+#include "databasetest.hpp"
 
 #include <QCoreApplication>
-#include <QMutex>
 #include <QSqlDatabase>
-#include <QWaitCondition>
 
 #include <thread>
 
-class CountDownLatch
+void insertThread(const QString &brand)
 {
-    Q_DISABLE_COPY_MOVE(CountDownLatch)
-public:
-    explicit CountDownLatch(int count)
-        : m_count(count)
-    {}
-    void countDown()
-    {
-        QMutexLocker lock(&m_mutex);
-        if (--m_count == 0) {
-            m_condition.wakeAll();
-        }
-    }
-    int count() const
-    {
-        QMutexLocker lock(&m_mutex);
-        return m_count;
-    }
-
-    void wait()
-    {
-        QMutexLocker lock(&m_mutex);
-        while (m_count > 0) {
-            m_condition.wait(&m_mutex);
-        }
-    }
-
-private:
-    mutable QMutex m_mutex;
-    QWaitCondition m_condition;
-    int m_count;
-};
-
-void insertThread(const QString &brand, CountDownLatch &countDown)
-{
-    SqlUtils sqlUtils;
-    countDown.wait();
-    for (int i = 0; i < 500; i++) {
-        sqlUtils.insert(brand, i);
+    DataBaseTest test;
+    for (int i = 0; i < 1000; i++) {
+        test.insert(brand, i);
     }
 }
 
@@ -60,12 +23,10 @@ int main(int argc, char *argv[])
     }
 
     const QStringList brands{"Apple", "Samsung", "Xiaomi", "Huawei", "Oppo", "Vivo", "Realme"};
-    CountDownLatch countDown(1);
     std::vector<std::thread> threads;
-    for (const auto &brand : brands) {
-        threads.emplace_back(insertThread, brand, std::ref(countDown));
+    for (const auto &brand : std::as_const(brands)) {
+        threads.emplace_back(insertThread, brand);
     }
-    countDown.countDown();
     for (auto &thread : threads) {
         if (thread.joinable()) {
             thread.join();