RCiRoot
97462c8aab
增加halconGuard类，用于防止halcon算法的输入输出和程序不一致而引起的报错，并且会检查算法文件是否存在，如不存在则会弹窗提示。 增加handleAiGpuThreadGuard类，用于防止因重复调用同一个模型而引起的报错，并且支持不停机更新模型，支持初始化时检测模型文件是否存在。 增加内存占用显示控件。 用户管理增加root权限，默认密码为dseuiroot，模型热更新时需要此权限。 支持缓存界面上的检测数据。 相机模块新增在回调后的指定时间没有取图时则清空容器的功能。 增加等待结果汇总功能，在启用时同一个SN的图片会等待总结果后再进行存图。 存图线程修改为多线程编码，单线程储存，提高IO效率。并且增加根据内存占用的百分比更新存图逻辑的功能，默认占用超过70%不储存OK原图，超过80%不储存原图，超过90%时不储存所有图片。
457 lines
14 KiB
C++
457 lines
14 KiB
C++
#include <qfile.h>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <mutex>
|
|
#include <qdatetime.h>
|
|
#include <memory>
|
|
#include <qtextstream.h>
|
|
#include <QtSql/QSqlDatabase>
|
|
#include <QtSql/QSqlQuery>
|
|
#include <QtSql/QSqlError>
|
|
#include <QtSql/QSqlRecord>
|
|
#include <QVariant>
|
|
#include <QDebug>
|
|
#include <QString>
|
|
#include <QList>
|
|
#include <QMap>
|
|
#include <qcoreapplication.h>
|
|
#include <qdir.h>
|
|
#include <qtimer.h>
|
|
#include <chrono>
|
|
#include <qobject.h>
|
|
#include <generalJsonParsing.hpp>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <qelapsedtimer.h>
|
|
#include <QQueue>
|
|
#include <quuid.h>
|
|
#include <global.h>
|
|
#include <qthread.h>
|
|
#include <qmutex.h>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
#include <QJsonDocument>
|
|
|
|
class SQLiteDB {
|
|
public:
|
|
QSqlDatabase db;
|
|
// 改为递归互斥锁，解决嵌套调用问题
|
|
mutable QRecursiveMutex db_mutex;
|
|
|
|
SQLiteDB(const QString& dbPath)
|
|
: dbPath(dbPath) {
|
|
connect();
|
|
}
|
|
~SQLiteDB() { disconnect(); };
|
|
|
|
// 添加内部无锁版本，避免嵌套锁问题
|
|
bool execute_unsafe(const QString& queryStr, const QVariantList& args = {}) {
|
|
QSqlQuery query(db);
|
|
query.prepare(queryStr);
|
|
|
|
for (int i = 0; i < args.size(); ++i) {
|
|
query.bindValue(i, args[i]);
|
|
}
|
|
|
|
if (!query.exec()) {
|
|
qCritical() << "SQL error:" << query.lastError().text();
|
|
qCritical() << "Query:" << queryStr;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
QList<QMap<QString, QVariant>> query_unsafe(const QString& queryStr, const QVariantList& args = {}) {
|
|
QList<QMap<QString, QVariant>> results;
|
|
QSqlQuery query(db);
|
|
query.prepare(queryStr);
|
|
|
|
for (int i = 0; i < args.size(); ++i) {
|
|
query.bindValue(i, args[i]);
|
|
}
|
|
|
|
if (!query.exec()) {
|
|
qCritical() << "SQL error:" << query.lastError().text();
|
|
qCritical() << "Query:" << queryStr;
|
|
return results;
|
|
}
|
|
|
|
while (query.next()) {
|
|
QMap<QString, QVariant> row;
|
|
for (int i = 0; i < query.record().count(); ++i) {
|
|
row.insert(query.record().fieldName(i), query.value(i));
|
|
}
|
|
results.append(row);
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
// 公有方法保持加锁保护
|
|
bool execute(const QString& queryStr, const QVariantList& args = {}) {
|
|
QMutexLocker lock(&db_mutex);
|
|
return execute_unsafe(queryStr, args);
|
|
}
|
|
|
|
QList<QMap<QString, QVariant>> query(const QString& queryStr, const QVariantList& args = {}) {
|
|
QMutexLocker lock(&db_mutex);
|
|
return query_unsafe(queryStr, args);
|
|
}
|
|
|
|
bool createTable(const QString& tableName, const QList<std::pair<QString, QString>>& columns) {
|
|
QMutexLocker lock(&db_mutex);
|
|
if (columns.empty()) {
|
|
qDebug() << "Create table failed: columns are empty.";
|
|
return false;
|
|
}
|
|
|
|
QStringList columnDefinitions;
|
|
for (const auto& pair : columns) {
|
|
columnDefinitions << QString("%1 %2").arg(pair.first).arg(pair.second);
|
|
}
|
|
|
|
QString sql = QString("CREATE TABLE IF NOT EXISTS \"%1\" (%2)")
|
|
.arg(tableName)
|
|
.arg(columnDefinitions.join(", "));
|
|
|
|
return execute_unsafe(sql);
|
|
}
|
|
|
|
std::vector<QString> getTables() {
|
|
QMutexLocker lock(&db_mutex);
|
|
std::vector<QString> tables;
|
|
QString sql = "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';";
|
|
|
|
auto result = query_unsafe(sql);
|
|
for (const auto& row : result) {
|
|
tables.push_back(row.value("name").toString());
|
|
}
|
|
return tables;
|
|
}
|
|
|
|
bool dropTable(const QString& tableName) {
|
|
QMutexLocker lock(&db_mutex);
|
|
QString sql = QString("DROP TABLE IF EXISTS %1").arg(tableName);
|
|
return execute_unsafe(sql);
|
|
}
|
|
|
|
bool addColumn(const QString& tableName, const QString& columnName, const QString& columnType) {
|
|
QMutexLocker lock(&db_mutex);
|
|
if (columnName.isEmpty() || columnType.isEmpty()) {
|
|
qDebug() << "Add column failed: column name or type is empty.";
|
|
return false;
|
|
}
|
|
|
|
QString sql = QString("ALTER TABLE \"%1\" ADD COLUMN \"%2\" %3").arg(tableName, columnName, columnType);
|
|
|
|
if (!execute_unsafe(sql)) {
|
|
qDebug() << "Add column failed";
|
|
return false;
|
|
}
|
|
|
|
qDebug() << "Column" << columnName << "added to table" << tableName;
|
|
return true;
|
|
}
|
|
|
|
bool tableExists(const QString& tableName) {
|
|
QMutexLocker lock(&db_mutex);
|
|
QString sql = QString("SELECT name FROM sqlite_master WHERE type='table' AND name='%1';").arg(tableName);
|
|
|
|
QList<QMap<QString, QVariant>> result = query_unsafe(sql);
|
|
return !result.isEmpty();
|
|
}
|
|
|
|
// 添加批量操作支持，减少锁竞争
|
|
bool batchInsert(const QString& tableName, const std::vector<std::map<QString, QVariant>>& dataList) {
|
|
if (dataList.empty()) {
|
|
qDebug() << "Batch insert failed: data is empty.";
|
|
return false;
|
|
}
|
|
|
|
QMutexLocker lock(&db_mutex);
|
|
|
|
// 开始事务
|
|
if (!execute_unsafe("BEGIN TRANSACTION;")) {
|
|
return false;
|
|
}
|
|
|
|
bool allSuccess = true;
|
|
for (const auto& data : dataList) {
|
|
if (!_insert_unsafe(tableName, data)) {
|
|
allSuccess = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (allSuccess) {
|
|
execute_unsafe("COMMIT;");
|
|
} else {
|
|
execute_unsafe("ROLLBACK;");
|
|
}
|
|
|
|
return allSuccess;
|
|
}
|
|
|
|
bool _insert(const QString& tableName, const std::map<QString, QVariant>& data) {
|
|
QMutexLocker lock(&db_mutex);
|
|
return _insert_unsafe(tableName, data);
|
|
}
|
|
|
|
private:
|
|
bool _insert_unsafe(const QString& tableName, const std::map<QString, QVariant>& data) {
|
|
if (data.empty()) {
|
|
qDebug() << "Insert failed: data is empty.";
|
|
return false;
|
|
}
|
|
|
|
if (tableName.isEmpty()) {
|
|
qDebug() << "Insert failed: tableName is empty.";
|
|
return false;
|
|
}
|
|
|
|
QStringList columns, placeholders;
|
|
QVariantList values;
|
|
|
|
for (const auto& pair : data) {
|
|
columns << pair.first;
|
|
placeholders << "?";
|
|
values << pair.second;
|
|
}
|
|
|
|
QString sql = QString("INSERT INTO \"%1\" (%2) VALUES (%3)")
|
|
.arg(tableName)
|
|
.arg(columns.join(", "))
|
|
.arg(placeholders.join(", "));
|
|
|
|
return execute_unsafe(sql, values);
|
|
}
|
|
|
|
public:
|
|
bool _update(const QString& tableName,
|
|
const std::map<QString, QVariant>& data,
|
|
const std::map<QString, QVariant>& conditions) {
|
|
QMutexLocker lock(&db_mutex);
|
|
return _update_unsafe(tableName, data, conditions);
|
|
}
|
|
|
|
private:
|
|
bool _update_unsafe(const QString& tableName,
|
|
const std::map<QString, QVariant>& data,
|
|
const std::map<QString, QVariant>& conditions) {
|
|
if (data.empty() || conditions.empty()) {
|
|
qDebug() << "Update failed: data or conditions are empty.";
|
|
return false;
|
|
}
|
|
|
|
QStringList setClauses, whereClauses;
|
|
QVariantList values;
|
|
|
|
for (const auto& pair : data) {
|
|
setClauses << QString("%1 = ?").arg(pair.first);
|
|
values << pair.second;
|
|
}
|
|
|
|
for (const auto& pair : conditions) {
|
|
whereClauses << QString("%1 = ?").arg(pair.first);
|
|
values << pair.second;
|
|
}
|
|
|
|
QString sql = QString("UPDATE \"%1\" SET %2 WHERE %3")
|
|
.arg(tableName)
|
|
.arg(setClauses.join(", "))
|
|
.arg(whereClauses.join(" AND "));
|
|
|
|
return execute_unsafe(sql, values);
|
|
}
|
|
|
|
public:
|
|
bool _delete(const QString& tableName, const std::map<QString, QVariant>& conditions) {
|
|
QMutexLocker lock(&db_mutex);
|
|
return _delete_unsafe(tableName, conditions);
|
|
}
|
|
|
|
private:
|
|
bool _delete_unsafe(const QString& tableName, const std::map<QString, QVariant>& conditions) {
|
|
if (conditions.empty()) {
|
|
qDebug() << "Delete failed: conditions are empty.";
|
|
return false;
|
|
}
|
|
|
|
QStringList whereClauses;
|
|
QVariantList values;
|
|
|
|
for (const auto& pair : conditions) {
|
|
whereClauses << QString("%1 = ?").arg(pair.first);
|
|
values << pair.second;
|
|
}
|
|
|
|
QString sql = QString("DELETE FROM \"%1\" WHERE %2")
|
|
.arg(tableName)
|
|
.arg(whereClauses.join(" AND "));
|
|
|
|
return execute_unsafe(sql, values);
|
|
}
|
|
|
|
public:
|
|
std::vector<std::map<QString, QVariant>> _search(const QString& tableName,
|
|
const QStringList& columns,
|
|
const std::map<QString, QVariant>& conditions = {}) {
|
|
QMutexLocker lock(&db_mutex);
|
|
return _search_unsafe(tableName, columns, conditions);
|
|
}
|
|
|
|
private:
|
|
std::vector<std::map<QString, QVariant>> _search_unsafe(const QString& tableName,
|
|
const QStringList& columns,
|
|
const std::map<QString, QVariant>& conditions = {}) {
|
|
|
|
QStringList selectColumns = columns.isEmpty() ? QStringList("*") : columns;
|
|
QString sql = QString("SELECT %1 FROM \"%2\"").arg(selectColumns.join(", "), tableName);
|
|
|
|
QVariantList values;
|
|
if (!conditions.empty()) {
|
|
QStringList whereClauses;
|
|
for (const auto& pair : conditions) {
|
|
whereClauses << QString("%1 = ?").arg(pair.first);
|
|
values << pair.second;
|
|
}
|
|
sql += " WHERE " + whereClauses.join(" AND ");
|
|
}
|
|
|
|
auto result = query_unsafe(sql, values);
|
|
std::vector<std::map<QString, QVariant>> results;
|
|
|
|
for (const auto& row : result) {
|
|
std::map<QString, QVariant> rowMap;
|
|
for (auto it = row.begin(); it != row.end(); ++it) {
|
|
rowMap[it.key()] = it.value();
|
|
}
|
|
results.push_back(rowMap);
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
public:
|
|
QList<QMap<QString, QVariant>> queryTabelData(const QString& tableName) {
|
|
QMutexLocker lock(&db_mutex);
|
|
QString sql = QString("SELECT * FROM \"%1\"").arg(tableName);
|
|
return query_unsafe(sql);
|
|
}
|
|
|
|
// 移除外部 mutex 参数，避免锁顺序问题
|
|
bool exportTableToCSV(const QString& tableName, const QString& filePath) {
|
|
QMutexLocker lock(&db_mutex);
|
|
using namespace std::chrono;
|
|
|
|
auto start = high_resolution_clock::now();
|
|
QString sql = QString("SELECT * FROM \"%1\"").arg(tableName);
|
|
|
|
auto result = query_unsafe(sql);
|
|
if (result.isEmpty()) {
|
|
qDebug() << "No data found in table" << tableName;
|
|
return false;
|
|
}
|
|
|
|
QFile file(filePath);
|
|
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
qCritical() << "Failed to open file" << filePath;
|
|
return false;
|
|
}
|
|
|
|
QTextStream out(&file);
|
|
|
|
// 写入表头
|
|
if (!result.isEmpty()) {
|
|
QStringList columns = result.first().keys();
|
|
out << columns.join(",") << "\n";
|
|
|
|
// 写入数据
|
|
for (const auto& row : result) {
|
|
QStringList values;
|
|
for (const auto& column : columns) {
|
|
values << row.value(column).toString();
|
|
}
|
|
out << values.join(",") << "\n";
|
|
}
|
|
}
|
|
|
|
file.close();
|
|
auto end = high_resolution_clock::now();
|
|
auto duration = duration_cast<milliseconds>(end - start);
|
|
qDebug() << filePath << "EXPORT CSV COST: " << duration.count() << "ms";
|
|
return true;
|
|
}
|
|
|
|
bool setWALMode(bool enableWAL = true, int busyTimeoutMs = 3000) {
|
|
QMutexLocker lock(&db_mutex);
|
|
if (!db.isOpen()) {
|
|
qWarning() << "Database is not open, cannot set WAL mode.";
|
|
return false;
|
|
}
|
|
|
|
QString mode = enableWAL ? "WAL" : "DELETE";
|
|
if (!execute_unsafe(QString("PRAGMA journal_mode=%1;").arg(mode))) {
|
|
qWarning() << "Failed to set journal_mode";
|
|
return false;
|
|
}
|
|
qDebug() << "SQLite journal_mode set to" << mode;
|
|
|
|
if (enableWAL) {
|
|
execute_unsafe("PRAGMA synchronous=NORMAL;");
|
|
}
|
|
|
|
execute_unsafe(QString("PRAGMA busy_timeout=%1;").arg(busyTimeoutMs));
|
|
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
bool connect() {
|
|
m_connectionName = QUuid::createUuid().toString();
|
|
|
|
if (!QFile::exists(dbPath)) {
|
|
QFileInfo fi(dbPath);
|
|
QDir().mkpath(fi.absolutePath());
|
|
qDebug() << "Database file does not exist. Creating a new database:" << dbPath;
|
|
}
|
|
|
|
db = QSqlDatabase::addDatabase("QSQLITE", m_connectionName);
|
|
db.setDatabaseName(dbPath);
|
|
|
|
if (!db.open()) {
|
|
qCritical() << "Failed to open or create database:" << db.lastError().text();
|
|
return false;
|
|
}
|
|
|
|
qDebug() << "Connected to SQLite database:" << dbPath;
|
|
|
|
// 设置 WAL 模式和其他 PRAGMA
|
|
if (!execute_unsafe("PRAGMA journal_mode=WAL;")) {
|
|
qWarning() << "Failed to enable WAL mode";
|
|
} else {
|
|
qDebug() << "SQLite WAL mode enabled.";
|
|
}
|
|
execute_unsafe("PRAGMA synchronous=NORMAL;");
|
|
execute_unsafe("PRAGMA busy_timeout=3000;");
|
|
|
|
createTable("setting", {
|
|
{"id","INTEGER PRIMARY KEY AUTOINCREMENT"}
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
void disconnect() {
|
|
QSqlDatabase::removeDatabase(m_connectionName);
|
|
if (db.isOpen()) {
|
|
db.close();
|
|
qDebug() << "Database closed.";
|
|
}
|
|
}
|
|
|
|
QString m_connectionName;
|
|
QString dbPath;
|
|
};
|
|
|
|
#pragma once |