1.修复因对齐线未清0导致点击子项自动移动的问题；

LAPTOP-SNT8I5JK\Boounion

2025-03-21 ef6c229b7dd70ef82a068ae198f23bc9a44dfad2

 SourceCode/Bond/Servo/SECSRuntimeManager.cpp

@@ -39,6 +39,115 @@
    return 0;
}

// 判断VID是否重复
bool SECSRuntimeManager::isIDDuplicate(int nID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
      return false;
    }

    // 定义要检查的表
    std::vector<std::string> tables = { "SystemSV", "EqpSV", "SystemDV", "EqpDV", "SystemEC", "EqpEC" };

    // 遍历表，检查是否有重复的 ID
    for (const auto& table : tables) {
        // 创建 SQL 查询
        std::string checkSQL = "SELECT COUNT(*) FROM " + table + " WHERE ID = " + std::to_string(nID) + ";";

        // 执行查询
        auto results = m_pDB->fetchResults(checkSQL);
        int count = (!results.empty() && !results[0].empty()) ? std::stoi(results[0][0]) : 0;

        // 如果找到了重复的 ID，则返回 true
        if (count > 0) {
            return true;
        }
    }

    // 如果没有重复，返回 false
    return false;
}

// 判断名称是否重复
bool SECSRuntimeManager::isNameDuplicate(const std::string& sName) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return false;
    }

    // 定义要检查的表
    std::vector<std::string> tables = { "SystemSV", "EqpSV", "SystemDV", "EqpDV", "SystemEC", "EqpEC" };

    // 遍历表，检查是否有重复的 Name
    for (const auto& table : tables) {
        // 创建 SQL 查询
        std::string checkSQL = "SELECT COUNT(*) FROM " + table + " WHERE Name = '" + sName + "';";

        // 执行查询
        auto results = m_pDB->fetchResults(checkSQL);
        int count = (!results.empty() && !results[0].empty()) ? std::stoi(results[0][0]) : 0;

        // 如果找到了重复的 Name，则返回 true
        if (count > 0) {
            return true;
        }
    }

    // 如果没有重复，返回 false
    return false;
}

// 删除指定表的所有数据
int SECSRuntimeManager::deleteAllDataFromTable(const std::string& tableName) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;
    }

    // 构建删除所有数据的 SQL 语句
    std::string deleteSQL = "DELETE FROM " + tableName + ";";
    if (!m_pDB->executeQuery(deleteSQL)) {
        return 2;
    }

    return 0; // 删除成功，返回 0 表示操作成功完成。
}

// 查询指定表所有数据
bool SECSRuntimeManager::getAllDataFromTable(const std::string& tableName, std::vector<std::vector<std::string>>& outData) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return false; // 数据库连接失败
    }

    // 查询 SQL 语句，获取指定表的所有数据
    std::string querySQL = "SELECT * FROM " + tableName + ";";
    outData = m_pDB->fetchResults(querySQL); // 使用输出参数赋值结果

    return true; // 查询成功
}

// 删除指定表中指定 ID 的数据
int SECSRuntimeManager::deleteDataByID(const std::string& tableName, int nID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1; // 数据库未连接，返回 1
    }

    // 检查 ID 是否存在
    if (!isIDDuplicate(nID)) {
        return 2; // ID 不存在，返回 2
    }

    // 构建删除 SQL 语句
    std::string deleteSQL = "DELETE FROM " + tableName + " WHERE ID = " + std::to_string(nID) + ";";
    if (!m_pDB->executeQuery(deleteSQL)) {
        return 3; // 删除失败，返回 3
    }

    return 0; // 删除成功，返回 0
}

// 设置数据库连接
void SECSRuntimeManager::setDatabase(BL::Database* db) {
    std::lock_guard<std::mutex> lock(m_mutex);
@@ -103,16 +212,16 @@
    }
}

// 初始化 SystemSV 表
void SECSRuntimeManager::initSystemSVTable() {
// 初始化指定的 SystemV 表
void SECSRuntimeManager::initSystemVTable(const std::string& tableName) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }

    // 创建 SystemSV 表（如果不存在）
    // 创建表的 SQL 语句
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS SystemSV ("
        "CREATE TABLE IF NOT EXISTS " + tableName + " ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
@@ -121,9 +230,360 @@
        "Remark TEXT, "
        "SystemID INTEGER);";

    // 执行创建表操作
    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create SystemSV table.");
        throw std::runtime_error("Failed to create " + tableName + " table.");
    }
}

// 添加指定的 SystemV 表
int SECSRuntimeManager::addSystemVData(const std::string& tableName, int nID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSystemID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1; // 数据库未连接
    }

    // 检查 ID 和 Name 是否重复
    if (isIDDuplicate(nID)) {
        return 2; // ID 重复
    }

    if (isNameDuplicate(sName)) {
        return 3; // Name 重复
    }

    // 构建插入语句
    std::string insertSQL = "INSERT INTO " + tableName + " (ID, Name, DataType, Length, Unit, Remark, SystemID) VALUES ("
        + std::to_string(nID) + ", '"
        + sName + "', '"
        + sDataType + "', "
        + (nLength > 0 ? std::to_string(nLength) : "NULL") + ", "
        + ((sUnit == "NULL" || sUnit.empty()) ? "NULL" : "'" + sUnit + "'") + ", '"
        + sRemark + "', "
        + std::to_string(nSystemID) + ");";

    // 执行插入操作
    if (!m_pDB->executeQuery(insertSQL)) {
        return 4; // 插入失败
    }

    return 0; // 插入成功
}

// 获取指定 ID 的 SystemV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getSystemVByID(const std::string& tableName, int nID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return {};  // 如果数据库未连接，返回空结果
    }

    // 构建查询 SQL 语句
    std::string query = "SELECT * FROM " + tableName + " WHERE ID = " + std::to_string(nID) + ";";

    // 执行查询并返回结果
    return m_pDB->fetchResults(query);
}

// 获取 SystemV 的所有数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getAllSystemV(const std::string& tableName) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return {};  // 如果数据库未连接，返回空结果
    }

    // 构建查询 SQL 语句
    std::string query = "SELECT * FROM " + tableName + ";";

    // 执行查询并返回结果
    return m_pDB->fetchResults(query);
}

// 更新 SystemV 的 ID 数据
int SECSRuntimeManager::updateIDSystemV(const std::string& tableName, int nID, int sNewID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;
    }

    // 检查是否存在该 ID
    if (!isIDDuplicate(nID)) {
        return 2;
    }

    // 检查新 ID 是否重复
    if (isIDDuplicate(sNewID)) {
        return 3;
    }

    // 构建更新的 SQL 语句
    std::string updateSQL = "UPDATE " + tableName + " SET ID = " + std::to_string(sNewID) + " WHERE ID = " + std::to_string(nID) + ";";
    if (!m_pDB->executeQuery(updateSQL)) {
        return 4;
    }

    return 0;
}

// 更新 SystemV 的所有字段
int SECSRuntimeManager::updateAllSystemV(const std::string& tableName, int nID, int sNewID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSystemID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;
    }

    // 检查是否存在该 ID
    if (!isIDDuplicate(nID)) {
        return 2;
    }

    // 检查新的 ID 是否已存在，如果已存在，则返回错误代码 3。
    if (isIDDuplicate(sNewID)) {
        return 3;
    }

    // 构建更新的 SQL 语句
    std::string updateSQL = "UPDATE " + tableName + " SET ";

    bool firstField = true;

    // 如果新的 ID 被提供，更新 ID
    if (sNewID > 0) {
        if (!firstField) {
            updateSQL += ", ";
        }
        updateSQL += "ID = " + std::to_string(sNewID);
        firstField = false;
    }

    // 更新 Name
    if (!sName.empty()) {
        if (!firstField) {
            updateSQL += ", ";
        }
        updateSQL += "Name = '" + sName + "'";
        firstField = false;
    }

    // 更新 DataType
    if (!sDataType.empty()) {
        if (!firstField) {
            updateSQL += ", ";
        }
        updateSQL += "DataType = '" + sDataType + "'";
        firstField = false;
    }

    // 更新 Length
    if (nLength > 0) {
        if (!firstField) {
            updateSQL += ", ";
        }
        updateSQL += "Length = " + std::to_string(nLength);
        firstField = false;
    }

    // 更新 Unit
    if (sUnit != "NULL" && !sUnit.empty()) {
        if (!firstField) {
            updateSQL += ", ";
        }
        updateSQL += "Unit = '" + sUnit + "'";
        firstField = false;
    }
    else if (sUnit == "NULL") {
        if (!firstField) {
            updateSQL += ", ";
        }
        updateSQL += "Unit = NULL";
        firstField = false;
    }

    // 更新 Remark
    if (!sRemark.empty()) {
        if (!firstField) {
            updateSQL += ", ";
        }
        updateSQL += "Remark = '" + sRemark + "'";
        firstField = false;
    }

    // 更新 SystemID
    if (nSystemID > 0) {
        if (!firstField) {
            updateSQL += ", ";
        }
        updateSQL += "SystemID = " + std::to_string(nSystemID);
    }

    // 添加 WHERE 子句来指定更新哪个记录
    updateSQL += " WHERE ID = " + std::to_string(nID) + ";";

    // 执行更新操作
    if (!m_pDB->executeQuery(updateSQL)) {
        return 4;
    }

    return 0;
}

// 初始化指定的 EqpV 表
void SECSRuntimeManager::initEqpVTable(const std::string& tableName) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }

    // 创建设备表的 SQL 语句
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS " + tableName + " ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "Length INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SeqNo INTEGER);";

    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create " + tableName + " table.");
    }
}

// 添加指定 EqpV 表的数据
int SECSRuntimeManager::addEqpVData(const std::string& tableName, int nID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSeqNo) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;
    }

    // 检查 ID 是否重复
    if (isIDDuplicate(nID)) {
        return 2;
    }

    // 检查 Name 是否重复
    if (isNameDuplicate(sName)) {
        return 3;
    }

    // 构建 SQL 插入语句
    std::string insertSQL = "INSERT INTO " + tableName + " (ID, Name, DataType, Length, Unit, Remark, SeqNo) VALUES ("
        + std::to_string(nID) + ", '"
        + sName + "', '"
        + sDataType + "', "
        + ((nLength <= 0) ? "NULL" : std::to_string(nLength)) + ", "
        + ((sUnit == "NULL" || sUnit.empty()) ? "NULL" : "'" + sUnit + "'") + ", '"
        + sRemark + "', "
        + std::to_string(nSeqNo) + ");";

    // 执行插入操作
    if (!m_pDB->executeQuery(insertSQL)) {
        return 4;
    }

    return 0; // 插入成功，返回 0 表示操作成功完成。
}

// 查询指定 ID 的 EqpV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getEqpVDataByID(const std::string& tableName, int nID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return {};
    }

    // 查询 SQL 语句
    std::string querySQL = "SELECT * FROM " + tableName + " WHERE ID = " + std::to_string(nID) + ";";
    return m_pDB->fetchResults(querySQL); // 直接返回查询结果
}

// 更新指定的 EqpV 数据
int SECSRuntimeManager::updateEqpV(const std::string& tableName, int nID, int nNewID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSeqNo) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1; // 如果数据库未连接，返回 1
    }

    // 检查是否存在该 ID
    if (!isIDDuplicate(nID)) {
        return 2; // 如果 ID 不存在，返回错误代码 2
    }

    // 检查新的 ID 是否已存在
    if (isIDDuplicate(nNewID) && nNewID != nID) {
        return 3; // 如果新 ID 已存在，返回错误代码 3
    }

    // 构建更新 SQL 语句
    std::string updateSQL = "UPDATE " + tableName + " SET ";

    bool firstField = true;

    // 如果新的 ID 被提供，更新 ID
    if (nNewID > 0 && nNewID != nID) {
        updateSQL += "ID = " + std::to_string(nNewID);
        firstField = false;
    }

    // 更新 Name
    if (!sName.empty()) {
        if (!firstField) updateSQL += ", ";
        updateSQL += "Name = '" + sName + "'";
        firstField = false;
    }

    // 更新 DataType
    if (!sDataType.empty()) {
        if (!firstField) updateSQL += ", ";
        updateSQL += "DataType = '" + sDataType + "'";
        firstField = false;
    }

    // 更新 Length
    if (nLength > 0) {
        if (!firstField) updateSQL += ", ";
        updateSQL += "Length = " + std::to_string(nLength);
        firstField = false;
    }

    // 更新 Unit
    if (sUnit != "NULL" && !sUnit.empty()) {
        if (!firstField) updateSQL += ", ";
        updateSQL += "Unit = '" + sUnit + "'";
        firstField = false;
    }
    else if (sUnit == "NULL") {
        if (!firstField) updateSQL += ", ";
        updateSQL += "Unit = NULL";
        firstField = false;
    }

    // 更新 Remark
    if (!sRemark.empty()) {
        if (!firstField) updateSQL += ", ";
        updateSQL += "Remark = '" + sRemark + "'";
        firstField = false;
    }

    // 更新 SeqNo
    if (nSeqNo > 0) {
        if (!firstField) updateSQL += ", ";
        updateSQL += "SeqNo = " + std::to_string(nSeqNo);
    }

    // 添加 WHERE 子句，更新指定 ID 的数据
    updateSQL += " WHERE ID = " + std::to_string(nID) + ";";

    // 执行更新操作
    if (!m_pDB->executeQuery(updateSQL)) {
        return 4; // 如果更新失败，返回错误代码 4
    }

    return 0; // 更新成功，返回 0
}

// 初始化 SystemSV 表
void SECSRuntimeManager::initSystemSVTable() {
    initSystemVTable("SystemSV");

    // 预定义的 SV 数据
    std::vector<std::tuple<int, std::string, std::string, int, std::string, std::string, int>> svData = {
@@ -159,73 +619,149 @@
    }
}

// 添加 SystemSV 数据
int SECSRuntimeManager::addSystemSV(int nID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSystemID) {
    return addSystemVData("SystemSV", nID, sName, sDataType, nLength, sUnit, sRemark, nSystemID);
}

// 获取指定 ID 的 SystemSV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getSystemSVByID(int nID) {
    return getSystemVByID("SystemSV", nID);
}

// 获取所有 SystemSV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getAllSystemSV() {
    return getAllSystemV("SystemSV");
}

// 更新 SystemSV 表中的 ID
int SECSRuntimeManager::updateIDSystemSV(int nID, int sNewID) {
    return updateIDSystemV("SystemSV", nID, sNewID);
}

// 更新所有 SystemSV 数据
int SECSRuntimeManager::updateAllSystemSV(int nID, int sNewID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSystemID) {
    return updateAllSystemV("SystemSV", nID, sNewID, sName, sDataType, nLength, sUnit, sRemark, nSystemID);
}

// 删除指定 ID 的 SystemSV 数据
int SECSRuntimeManager::deleteSystemSVByID(int nID) {
    return deleteDataByID("SystemSV", nID);
}

// 删除所有 SystemSV 数据
int SECSRuntimeManager::deleteAllSystemSV() {
    return deleteAllDataFromTable("SystemSV");
}

// 初始化 EqpSV 表
void SECSRuntimeManager::initEqpSVTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
    initEqpVTable("EqpSV");
}

    // 创建 EqpSV 表
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS EqpSV ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "Length INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SeqNo INTEGER);";
// 添加 EqpSV 数据
int SECSRuntimeManager::addEqpSV(int nID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSeqNo) {
    return addEqpVData("EqpSV", nID, sName, sDataType, nLength, sUnit, sRemark, nSeqNo);
}

    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create EqpSV table.");
    }
// 查找指定 ID 的 EqpSV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getEqpSVByID(int nID) {
    return getEqpVDataByID("EqpSV", nID);
}

// 查找所有 EqpSV 数据
bool SECSRuntimeManager::getAllEqpSV(std::vector<std::vector<std::string>>& outEqpSV) {
    return getAllDataFromTable("EqpSV", outEqpSV);
}

// 更新 EqpSV 表指定 ID 的数据
int SECSRuntimeManager::updateEqpSV(int nID, int nNewID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSeqNo) {
    return updateEqpV("EqpSV", nID, nNewID, sName, sDataType, nLength, sUnit, sRemark, nSeqNo);
}

// 删除 EqpSV 表指定 ID 的数据
int SECSRuntimeManager::deleteEqpSVByID(int nID) {
    return deleteDataByID("EqpSV", nID);
}

// 删除 EqpSV 表中的所有数据
int SECSRuntimeManager::deleteAllEqpSV() {
    return deleteAllDataFromTable("EqpSV");
}

// 初始化 SystemDV 表
void SECSRuntimeManager::initSystemDVTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
    initSystemVTable("SystemDV");
}

    // 创建 SystemDV 表
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS SystemDV ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "Length INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SystemID INTEGER);";
// 添加 SystemDV 数据
int SECSRuntimeManager::addSystemDV(int nID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSystemID) {
    return addSystemVData("SystemDV", nID, sName, sDataType, nLength, sUnit, sRemark, nSystemID);
}

    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create SystemDV table.");
    }
// 获取指定 ID 的 SystemDV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getSystemDVByID(int nID) {
    return getSystemVByID("SystemDV", nID);
}

// 获取所有 SystemDV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getAllSystemDV() {
    return getAllSystemV("SystemDV");
}

// 更新 SystemDV 表中的 ID
int SECSRuntimeManager::updateIDSystemDV(int nID, int sNewID) {
    return updateIDSystemV("SystemDV", nID, sNewID);
}

// 更新所有 SystemDV 数据
int SECSRuntimeManager::updateAllSystemDV(int nID, int sNewID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSystemID) {
    return updateAllSystemV("SystemDV", nID, sNewID, sName, sDataType, nLength, sUnit, sRemark, nSystemID);
}

// 删除指定 ID 的 SystemDV 数据
int SECSRuntimeManager::deleteSystemDVByID(int nID) {
    return deleteDataByID("SystemDV", nID);
}

// 删除所有 SystemDV 数据
int SECSRuntimeManager::deleteAllSystemDV() {
    return deleteAllDataFromTable("SystemDV");
}

// 初始化 EqpDV 表
void SECSRuntimeManager::initEqpDVTable() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }
    initEqpVTable("EqpDV");
}

    // 创建 EqpDV 表
    std::string createTableSQL =
        "CREATE TABLE IF NOT EXISTS EqpDV ("
        "ID INTEGER PRIMARY KEY, "
        "Name TEXT UNIQUE NOT NULL, "
        "DataType TEXT NOT NULL, "
        "Length INTEGER NULL, "
        "Unit TEXT NULL, "
        "Remark TEXT, "
        "SeqNo INTEGER);";
// 添加 EqpDV 数据
int SECSRuntimeManager::addEqpDV(int nID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSeqNo) {
    return addEqpVData("EqpDV", nID, sName, sDataType, nLength, sUnit, sRemark, nSeqNo);
}

    if (!m_pDB->executeQuery(createTableSQL)) {
        throw std::runtime_error("Failed to create EqpDV table.");
    }
// 查找指定 ID 的 EqpDV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getEqpDVByID(int nID) {
    return getEqpVDataByID("EqpDV", nID);
}

// 获取所有 EqpDV 数据
bool SECSRuntimeManager::getAllEqpDV(std::vector<std::vector<std::string>>& outEqpDV) {
    return getAllDataFromTable("EqpDV", outEqpDV);
}

// 更新 EqpDV 表指定 ID 的数据
int SECSRuntimeManager::updateEqpDV(int nID, int nNewID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSeqNo) {
    return updateEqpV("EqpDV", nID, nNewID, sName, sDataType, nLength, sUnit, sRemark, nSeqNo);
}

// 删除 EqpDV 表指定 ID 的数据
int SECSRuntimeManager::deleteEqpDVByID(int nID) {
    return deleteDataByID("EqpDV", nID);
}

// 删除 EqpDV 表中的所有数据
int SECSRuntimeManager::deleteAllEqpDV() {
    return deleteAllDataFromTable("EqpDV");
}

// 初始化 SystemEC 表
@@ -375,22 +911,251 @@
        throw std::runtime_error("Database not connected.");
    }

    // 创建 RPTID 相关表
    // 创建 Report 表
    std::string createReportTableSQL =
        "CREATE TABLE IF NOT EXISTS Report ("
        "RPTID INTEGER PRIMARY KEY);";

    // 创建 ReportVIDs 表，保证同一个 RPTID 下的 VID 唯一
    std::string createReportVIDsTableSQL =
        "CREATE TABLE IF NOT EXISTS ReportVIDs ("
        "ID INTEGER PRIMARY KEY AUTOINCREMENT, "
        "RPTID INTEGER NOT NULL, "
        "VID INTEGER NOT NULL, "
        "FOREIGN KEY (RPTID) REFERENCES Report(RPTID));";
        "FOREIGN KEY (RPTID) REFERENCES Report(RPTID), "
        "UNIQUE(RPTID, VID));";

    // 执行创建表操作
    if (!m_pDB->executeQuery(createReportTableSQL)) {
        throw std::runtime_error("Failed to create Report table.");
    }
    if (!m_pDB->executeQuery(createReportVIDsTableSQL)) {
        throw std::runtime_error("Failed to create ReportVIDs table.");
    }
}

// 添加 RPTID 数据
int SECSRuntimeManager::addRPTIDVID(int nRPTID, int nVID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;
    }

    // 检查 RPTID 和 VID 的组合是否已经存在
    std::string checkExistSQL = "SELECT COUNT(*) FROM ReportVIDs WHERE RPTID = " + std::to_string(nRPTID) + " AND VID = " + std::to_string(nVID) + ";";
    int count = getIntFromDB(checkExistSQL);
    if (count > 0) {
        return 2;  // 如果关系已存在，返回错误代码 2
    }

    // 检查 Report 表中是否存在该 RPTID
    std::string checkReportExistSQL = "SELECT COUNT(*) FROM Report WHERE RPTID = " + std::to_string(nRPTID) + ";";
    int reportCount = getIntFromDB(checkReportExistSQL);

    if (reportCount == 0) {
        // 如果 RPTID 不存在，插入 RPTID
        std::string insertReportSQL = "INSERT INTO Report (RPTID) VALUES (" + std::to_string(nRPTID) + ");";
        if (!m_pDB->executeQuery(insertReportSQL)) {
            return 3;  // 插入失败，返回错误代码 3
        }
    }

    // 构造插入 SQL 语句
    std::string insertSQL = "INSERT INTO ReportVIDs (RPTID, VID) VALUES ("
        + std::to_string(nRPTID) + ", "
        + std::to_string(nVID) + ");";

    // 执行插入操作
    if (!m_pDB->executeQuery(insertSQL)) {
        return 4;  // 插入失败，返回错误代码 4
    }

    return 0;  // 插入成功，返回 0
}

// 获取指定 RPTID 的所有 VID
int SECSRuntimeManager::addRPTIDVIDs(int nRPTID, const std::vector<int>& vecVID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;
    }

    // 检查 Report 表中是否存在该 RPTID
    std::string checkReportExistSQL = "SELECT COUNT(*) FROM Report WHERE RPTID = " + std::to_string(nRPTID) + ";";
    int reportCount = getIntFromDB(checkReportExistSQL);

    if (reportCount == 0) {
        // 如果 RPTID 不存在，插入 RPTID
        std::string insertReportSQL = "INSERT INTO Report (RPTID) VALUES (" + std::to_string(nRPTID) + ");";
        if (!m_pDB->executeQuery(insertReportSQL)) {
            return 2;  // 插入失败，返回错误代码 3
        }
    }

    // 批量插入 VID 和 RPTID 关系
    for (int nVID : vecVID) {
        // 检查当前 RPTID 和 VID 的组合是否已经存在
        std::string checkExistSQL = "SELECT COUNT(*) FROM ReportVIDs WHERE RPTID = " + std::to_string(nRPTID) + " AND VID = " + std::to_string(nVID) + ";";
        int count = getIntFromDB(checkExistSQL);
        if (count == 0) {
            // 如果关系不存在，插入
            std::string insertSQL = "INSERT INTO ReportVIDs (RPTID, VID) VALUES ("
                + std::to_string(nRPTID) + ", "
                + std::to_string(nVID) + ");";

            if (!m_pDB->executeQuery(insertSQL)) {
                return 3;  // 插入失败，返回错误代码 3
            }
        }
    }

    return 0;  // 插入成功，返回 0
}

// 获取指定 RPTID 的所有 VID
int SECSRuntimeManager::deleteRPTIDVID(int nRPTID, int nVID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;  // 数据库未连接
    }

    // 检查 ReportVIDs 表中是否存在该 RPTID 和 VID 组合
    std::string checkExistSQL = "SELECT COUNT(*) FROM ReportVIDs WHERE RPTID = " + std::to_string(nRPTID) + " AND VID = " + std::to_string(nVID) + ";";
    int count = getIntFromDB(checkExistSQL);
    if (count == 0) {
        return 2;  // 记录不存在
    }

    // 删除 ReportVIDs 表中指定 RPTID 和 VID 的关系
    std::string deleteSQL = "DELETE FROM ReportVIDs WHERE RPTID = " + std::to_string(nRPTID) + " AND VID = " + std::to_string(nVID) + ";";
    if (!m_pDB->executeQuery(deleteSQL)) {
        return 3;  // 删除失败
    }

    return 0;  // 删除成功
}

// 删除指定 RPTID 的所有 VID6
int SECSRuntimeManager::deleteRPTID(int nRPTID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;  // 数据库未连接
    }

    // 删除 ReportVIDs 表中所有与该 RPTID 相关的记录
    std::string deleteReportVIDsSQL = "DELETE FROM ReportVIDs WHERE RPTID = " + std::to_string(nRPTID) + ";";
    if (!m_pDB->executeQuery(deleteReportVIDsSQL)) {
        return 2;  // 删除失败
    }

    // 可选择是否删除 Report 表中的 RPTID，以下是删除 Report 表中的 RPTID 的 SQL
    std::string deleteReportSQL = "DELETE FROM Report WHERE RPTID = " + std::to_string(nRPTID) + ";";
    if (!m_pDB->executeQuery(deleteReportSQL)) {
        return 3;  // 删除失败
    }

    return 0;  // 删除成功
}

// 更新指定 RPTID 的 VID
int SECSRuntimeManager::updateRPTIDVID(int nRPTID, int nOldVID, int nNewVID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;  // 数据库未连接
    }

    // 检查指定的 RPTID 和 OldVID 是否存在
    std::string checkExistSQL = "SELECT COUNT(*) FROM ReportVIDs WHERE RPTID = " + std::to_string(nRPTID) + " AND VID = " + std::to_string(nOldVID) + ";";
    int count = getIntFromDB(checkExistSQL);
    if (count == 0) {
        return 2;  // 记录不存在，不能更新
    }

    // 检查新的 VID 是否已经存在于相同的 RPTID 下，防止重复
    std::string checkNewVIDExistSQL = "SELECT COUNT(*) FROM ReportVIDs WHERE RPTID = " + std::to_string(nRPTID) + " AND VID = " + std::to_string(nNewVID) + ";";
    int newVIDCount = getIntFromDB(checkNewVIDExistSQL);
    if (newVIDCount > 0) {
        return 3;  // 新的 VID 已经存在，不能重复
    }

    // 执行更新操作，替换 OldVID 为 NewVID
    std::string updateSQL = "UPDATE ReportVIDs SET VID = " + std::to_string(nNewVID) + " WHERE RPTID = " + std::to_string(nRPTID) + " AND VID = " + std::to_string(nOldVID) + ";";
    if (!m_pDB->executeQuery(updateSQL)) {
        return 4;  // 更新失败
    }

    return 0;  // 更新成功
}

// 更新指定 RPTID 的所有 VID
int SECSRuntimeManager::updateRPTIDVIDs(int nRPTID, const std::vector<int>& vecVID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;  // 数据库未连接
    }

    // 1. 先删除 RPTID 下所有的 VID 关联记录
    int deleteResult = deleteRPTID(nRPTID);
    if (deleteResult != 0) {
        return deleteResult;  // 删除失败，返回删除的错误码
    }

    // 2. 添加新的 VID 关联记录
    int addResult = addRPTIDVIDs(nRPTID, vecVID);
    if (addResult != 0) {
        return 3;  // 插入失败
    }

    return 0;  // 删除并添加成功
}

// 获取指定 RPTID 的所有 VID
std::vector<int> SECSRuntimeManager::getVIDsByRPTID(int nRPTID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    std::vector<int> vecVIDs;

    if (m_pDB == nullptr) {
        return {};
    }

    // 构建查询 SQL，查询指定 RPTID 下的所有 VID
    std::string querySQL = "SELECT VID FROM ReportVIDs WHERE RPTID = " + std::to_string(nRPTID) + ";";

    // 执行查询
    std::vector<std::vector<std::string>> results = m_pDB->fetchResults(querySQL);

    // 处理查询结果并填充到 vecVIDs 中
    for (const auto& row : results) {
        if (!row.empty()) {
            int nVID = std::stoi(row[0]);  // 将字符串类型的 VID 转换为 int
            vecVIDs.push_back(nVID);        // 将 VID 加入结果向量
        }
    }

    return vecVIDs;
}

// 获取所有 RPTID
std::vector<int> SECSRuntimeManager::getAllRPTIDs() {
    std::lock_guard<std::mutex> lock(m_mutex);
    std::vector<int> vecRPTIDs;

    if (m_pDB == nullptr) {
        throw std::runtime_error("Database not connected.");
    }

    // 构建查询 SQL，查询 Report 表中的所有 RPTID
    std::string querySQL = "SELECT RPTID FROM Report;";

    // 执行查询
    std::vector<std::vector<std::string>> results = m_pDB->fetchResults(querySQL);

    // 处理查询结果并填充到 vecRPTIDs 中
    for (const auto& row : results) {
        if (!row.empty()) {
            int nRPTID = std::stoi(row[0]);  // 将字符串类型的 RPTID 转换为 int
            vecRPTIDs.push_back(nRPTID);     // 将 RPTID 加入结果向量
        }
    }

    return vecRPTIDs;
}