[SqliteWAL]：重命名类与文件，增加SQLite性能优化配置

- **文件重命名**：将`databasetest`和`databaseutils`统一重命名为`sqlitetest`和`sqliteutils`，提高命名一致性
- **增加读取功能**：在`SqliteTest`类中新增`readLastRecord()`方法，实现读取最后一条记录的功能
- **优化多线程处理**：
  - 明确写入操作需要`QMutex`锁保证线程安全
  - 读取操作不加锁，充分利用WAL模式的并发读特性
- **增强数据库配置**：在`sqliteutils`中增加多项PRAGMA优化设置：
  - 启用内存临时表(`temp_store=MEMORY`)
  - 配置WAL自动检查点(`wal_autocheckpoint`)
  - 设置内存映射(`mmap_size`)
  - 禁用缓存溢出(`cache_spill=false`)
- **完善资源管理**：
  - 程序启动时删除旧数据库文件
  - 数据库连接移除前执行`ANALYZE`和`incremental_vacuum`优化
  - 添加WAL检查点截断(`wal_checkpoint(TRUNCATE)`)
- **扩展测试数据**：在`main`函数中增加更多手机品牌，加强并发测试
- **增加能力检测**：添加`printDriverCapabilities`函数显示SQLite驱动特性支持情况
- **更新文档说明**：在README中明确WAL模式下读写操作的锁使用策略

Author: RealChuan

README.md

@@ -148,10 +148,12 @@
   <img src="SlipButton/picture/SlipButton_checked.png" width="40%" height="40%">
 </div>
 
-## [SqliteWAL](SqliteWAL/)——Sqlite WAL 模式下多线程并发写入数据库程序
+## [SqliteWAL](SqliteWAL/)——[Sqlite WAL](https://sqlite.org/wal.html) 模式下多线程并发写入数据库程序
 
 1. 每个线程拥有独立的数据库连接（不同的连接名称），线程退出需要主动移除数据库连接，不然会产生大量的数据库连接；
-2. 在多线程下，依旧使用QMutex保证线程安全，在读的时候，可以考虑不使用QMutex，并发读应该没什么影响（对于写的时候，可以考虑使用QMutex）;
+2. 多线程情况下：
+   1. 写入操作需要使用`QMutex`，使写入操作串行化，避免`SQLITE_BUSY`错误；
+   2. 读取操作不需要加锁，WAL模式下读取操作不会被写入操作阻塞，可以同时进行读取和写入操作，而且可以多个读取器同时访问数据库，可以提高并发性能;
 
 ### WAL模式的优点
 
@@ -160,7 +162,7 @@
 
 ### WAL模式的注意事项
 
-1. WAL模式仅适用于SQLite 3.35.5+版本；
+1. WAL模式仅适用于`SQLite` [version 3.7.0](https://sqlite.org/releaselog/3_7_0.html) (2010-07-21) 及更高版本；
 2. 增加了磁盘使用量：与回滚模式相比，WAL模式需要更多的磁盘空间，因为它在提交更改之前将所有更改都写入日志文件；
 3. 读取性能较慢：读取操作不会被写入操作阻塞，如果同时进行读取和写入操作，可能导致数据不一致。
 

SqliteWAL/CMakeLists.txt

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

SqliteWAL/SqliteWAL.pro

@@ -5,13 +5,13 @@ QT += core sql
 CONFIG += cmdline
 
 SOURCES += \
-        databasetest.cc \
-        databaseutils.cc \
-        main.cc
+        main.cc \
+        sqlitetest.cc \
+        sqliteutils.cc
 
 HEADERS += \
-    databasetest.hpp \
-    databaseutils.hpp
+    sqlitetest.hpp \
+    sqliteutils.hpp
 
 # Default rules for deployment.
 qnx: target.path = /tmp/$${TARGET}/bin

SqliteWAL/databasetest.hpp

@@ -1,4 +1,4 @@
-#include "databasetest.hpp"
+#include "sqlitetest.hpp"
 
 #include <QCoreApplication>
 #include <QSqlDatabase>
@@ -7,9 +7,10 @@
 
 void insertThread(const QString &brand)
 {
-    DataBaseTest test;
+    SqliteTest test;
     for (int i = 0; i < 1000; i++) {
         test.insert(brand, i);
+        test.readLastRecord();
     }
 }
 
@@ -22,7 +23,16 @@ int main(int argc, char *argv[])
         return -1;
     }
 
-    const QStringList brands{"Apple", "Samsung", "Xiaomi", "Huawei", "Oppo", "Vivo", "Realme"};
+    const QStringList brands{"Apple",
+                             "Samsung",
+                             "Xiaomi",
+                             "Redmi",
+                             "Oppo",
+                             "Vivo",
+                             "Realme",
+                             "IQOO",
+                             "OnePlus",
+                             "Pixel"};
     std::vector<std::thread> threads;
     for (const auto &brand : std::as_const(brands)) {
         threads.emplace_back(insertThread, brand);

SqliteWAL/databaseutils.cc

@@ -1,20 +1,25 @@
-#include "databasetest.hpp"
-#include "databaseutils.hpp"
+#include "sqlitetest.hpp"
+#include "sqliteutils.hpp"
 
 #include <QDir>
 #include <QMutex>
-#include <QSqlDriver>
 #include <QSqlError>
 #include <QSqlQuery>
 #include <QThread>
 
-class DataBaseTest::DataBaseTestPrivate
+#include <mutex>
+
+class SqliteTest::SqliteTestPrivate
 {
 public:
-    explicit DataBaseTestPrivate(DataBaseTest *q)
+    explicit SqliteTestPrivate(SqliteTest *q)
         : q_ptr(q)
     {
         dataBaseConnection.dataBasePath = QString("%1/%2").arg(QDir::tempPath()).arg("test.db");
+
+        static std::once_flag onceFlag;
+        std::call_once(onceFlag, [this]() { QFile::remove(this->dataBaseConnection.dataBasePath); });
+
         dataBaseConnection.connectionName = getDatabaseConnectionName();
 
         createTable();
@@ -23,7 +28,7 @@ class DataBaseTest::DataBaseTestPrivate
                 << QThread::currentThread();
     }
 
-    ~DataBaseTestPrivate() { removeDatabase(dataBaseConnection.connectionName); }
+    ~SqliteTestPrivate() { removeDatabase(dataBaseConnection); }
 
     bool createTable()
     {
@@ -41,12 +46,6 @@ class DataBaseTest::DataBaseTestPrivate
         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;
         }
@@ -59,37 +58,62 @@ class DataBaseTest::DataBaseTestPrivate
         return true;
     }
 
-    DataBaseTest *q_ptr;
+    SqliteTest *q_ptr;
 
-    DataBaseConnection dataBaseConnection;
+    SqliteConnection dataBaseConnection;
     const QString tableName = "phone";
 
     static QMutex mutex;
 };
 
-QMutex DataBaseTest::DataBaseTestPrivate::mutex;
+QMutex SqliteTest::SqliteTestPrivate::mutex;
 
-DataBaseTest::DataBaseTest(QObject *parent)
+SqliteTest::SqliteTest(QObject *parent)
     : QObject{parent}
-    , d_ptr(new DataBaseTestPrivate(this))
+    , d_ptr(new SqliteTestPrivate(this))
 {}
 
-DataBaseTest::~DataBaseTest() {}
+SqliteTest::~SqliteTest() {}
 
-bool DataBaseTest::insert(const QString &brand, int num)
+bool SqliteTest::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);
+
+    QMutexLocker locker(&d_ptr->mutex);
     if (!query.exec()) {
         qCritical() << query.lastError().text();
         return false;
     }
     qInfo() << "Last inserted id:" << query.lastInsertId().toInt();
     return true;
 }
+
+bool SqliteTest::readLastRecord()
+{
+    auto db = getDatabase(d_ptr->dataBaseConnection);
+    CHECK_DATABASE_VALIDITY(db)
+
+    QSqlQuery query(db);
+    if (!query.exec(QString("SELECT id, brand, num, create_time FROM %1 ORDER BY id DESC LIMIT 1")
+                        .arg(d_ptr->tableName))) {
+        qCritical() << query.lastError().text();
+        return false;
+    }
+    if (!query.next()) {
+        qWarning() << "No records found.";
+        return false;
+    }
+    auto text = QString("Last Record - ID: %1, Brand: %2, Num: %3, Created At: %4")
+                    .arg(QString::number(query.value("id").toInt()),
+                         query.value("brand").toString(),
+                         QString::number(query.value("num").toInt()),
+                         query.value("create_time").toString());
+    qDebug() << text;
+    return true;
+}

SqliteWAL/main.cc

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

SqliteWAL/databasetest.cc SqliteWAL/sqlitetest.ccSqliteWAL/databasetest.cc renamed to SqliteWAL/sqlitetest.cc

@@ -0,0 +1,97 @@
+#include "sqliteutils.hpp"
+
+#include <QFile>
+#include <QSqlDriver>
+#include <QSqlError>
+#include <QSqlQuery>
+
+#include <mutex>
+
+void printDriverCapabilities(QSqlDriver *driver)
+{
+    static std::once_flag once;
+    std::call_once(once, [driver] {
+        qInfo().noquote() << "SQLite driver capabilities:\n"
+                          << "  Transactions    :" << driver->hasFeature(QSqlDriver::Transactions)
+                          << '\n'
+                          << "  LastInsertId    :" << driver->hasFeature(QSqlDriver::LastInsertId)
+                          << '\n'
+                          << "  BatchOperations :"
+                          << driver->hasFeature(QSqlDriver::BatchOperations) << '\n'
+                          << "  SimpleLocking   :" << driver->hasFeature(QSqlDriver::SimpleLocking);
+    });
+}
+
+void queryOptions(QSqlQuery &query, const QStringList &options)
+{
+    for (const auto &option : std::as_const(options)) {
+        if (!query.exec(option)) {
+            qWarning() << "Failed to execute " << option << ":" << query.lastError().text();
+        }
+    }
+}
+
+QSqlDatabase getDatabase(const SqliteConnection &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();
+        }
+        static const QStringList options = {
+            "PRAGMA journal_mode = WAL;",          // 启用WAL模式
+            "PRAGMA optimize = 0x10002;",          // 启用自动索引和查询优化
+            "PRAGMA auto_vacuum = INCREMENTAL;",   // 启用自动VACUUM
+            "PRAGMA default_temp_store = MEMORY;", // 启用内存临时表
+            "PRAGMA temp_store = MEMORY;",         // 启用内存临时表
+            "PRAGMA page_size = 4096;",            // 设置页面大小
+            "PRAGMA cache_size = -32768;",         // 设置缓存大小，单位为KB
+            "PRAGMA wal_autocheckpoint = 1000;",   // 设置WAL自动检查点间隔
+            "PRAGMA mmap_size = 268435456;",       // 启用内存映射，最大256MB
+            "PRAGMA cache_spill = false;"          // 禁用缓存溢出
+            // "PRAGMA synchronous = NORMAL;",        // 性能提升，耐久性略降
+            // "PRAGMA locking_mode = EXCLUSIVE;",    // 独占锁，适合单进程
+            // "PRAGMA foreign_keys = ON;",           // 启用外键约束
+        };
+        QSqlQuery query(db);
+        queryOptions(query, options);
+
+        printDriverCapabilities(db.driver());
+    }
+
+    return db;
+}
+
+void removeDatabase(const SqliteConnection &dataBaseConnection)
+{
+    auto connectionName = dataBaseConnection.connectionName;
+    if (!QSqlDatabase::contains(connectionName)) {
+        return;
+    }
+    static const QStringList options = {
+        "ANALYZE;",                             // 分析数据库
+        "PRAGMA optimize;",                     // 优化数据库
+        "PRAGMA incremental_vacuum;",           // 增量VACUUM
+        "PRAGMA journal_size_limit = 8388608;", // 限制日志文件大小为8MB
+        "PRAGMA wal_checkpoint(TRUNCATE);",     // 检查点并截断WAL文件
+        "PRAGMA shrink_memory;",                // 释放内存
+    };
+    {
+        QSqlQuery query(getDatabase(dataBaseConnection));
+        queryOptions(query, options);
+    }
+
+    QSqlDatabase::removeDatabase(connectionName);
+}
+
+QString getDatabaseConnectionName()
+{
+    static std::atomic_llong id = 1;
+    return QString("connection_%1").arg(id.fetch_add(1));
+}