1. 添加ReportVIDs表的相关操作

darker

2025-02-18 a886343fc6eaecb4eccd35dc2a5b95fc84212dd5

1. 添加ReportVIDs表的相关操作

 SourceCode/Bond/Servo/SECSRuntimeManager.cpp

@@ -829,22 +829,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;
}

 SourceCode/Bond/Servo/SECSRuntimeManager.h

@@ -298,6 +298,125 @@
    */ 
    void initRPTIDTable();

    /**
     * 添加 RPTID 和 VID 的关系
     * @param nRPTID: 需要关联的 RPTID。
     * @param nVID: 需要关联的 VID，可以是 SystemSV 或 EqpSV 的 ID。
     * @return 1: 数据库未连接。
     * @return 2: RPTID 和 VID 的关系已存在，无法插入。
     * @return 3: Report 表插入数据失败。
     * @return 4: ReportVIDs 表插入数据失败。
     * @return 0: 插入成功，数据已添加到 ReportVIDs 表中。
     *
     * 此函数用于添加一个新的 RPTID 和 VID 的关联关系。如果该 RPTID 和 VID 的组合已存在于数据库中，
     * 则返回错误代码 2。否则，函数会插入新的关系，并返回 0 表示插入成功。
     */
    int addRPTIDVID(int nRPTID, int nVID);

    /**
     * 添加多个 VID 与一个 RPTID 的关系
     * @param nRPTID: 需要关联的 RPTID。
     * @param vecVID: 需要关联的多个 VID，可以是 SystemSV 或 EqpSV 的 ID 的集合。
     * @return 1: 数据库未连接。
     * @return 2: Report 表插入数据失败。
     * @return 3: ReportVIDs 表插入数据失败。
     * @return 0: 插入成功，数据已添加到 ReportVIDs 表中。
     *
     * 此函数用于将多个 VID 与 RPTID 关联。首先检查 `RPTID` 是否已经存在于 `Report` 表中，
     * 如果不存在，则先插入该 `RPTID`。然后，批量插入 `RPTID` 和 `VID` 的关系，确保同一个 `RPTID`
     * 下的 `VID` 不重复。
     */
    int addRPTIDVIDs(int nRPTID, const std::vector<int>& vecVID);

    /**
     * 删除指定 RPTID 和 VID 的关系
     * @param nRPTID: 需要删除的 RPTID。
     * @param nVID: 需要删除的 VID。
     * @return 1: 数据库未连接。
     * @return 2: RPTID 和 VID 的关系不存在，无法删除。
     * @return 3: 删除操作失败。
     * @return 0: 删除成功。
     *
     * 此函数用于删除指定的 RPTID 和 VID 的关联关系。如果该关系不存在，则返回错误代码 2。
     * 如果删除操作失败，则返回错误代码 3。删除成功后，返回 0 表示删除成功。
     */
    int deleteRPTIDVID(int nRPTID, int nVID);

    /**
     * 删除指定 RPTID 关联的所有记录
     * @param nRPTID: 需要删除的 RPTID。
     *
     * @return 1: 数据库未连接。
     * @return 2: 删除 ReportVIDs 表中的记录失败。
     * @return 3: 删除 Report 表中的 RPTID 失败。
     * @return 0: 删除成功，所有与该 RPTID 关联的记录已被删除。
     *
     * 此函数用于删除 ReportVIDs 表中所有与指定 RPTID 关联的记录，并根据需要删除 Report 表中的 RPTID。
     * - 首先，删除 ReportVIDs 表中所有与该 RPTID 关联的记录。
     * - 然后，可以选择是否删除 Report 表中对应的 RPTID。
     *
     * 若删除失败，则返回相应的错误代码。如果成功删除所有记录，则返回 0。
     */
    int deleteRPTID(int nRPTID);

    /**
     * 更新指定 RPTID 的 VID 关联记录
     * @param nRPTID: 需要更新的 RPTID。
     * @param nOldVID: 需要更新的旧 VID。
     * @param nNewVID: 新的 VID，替代旧的 VID。
     *
     * @return 1: 数据库未连接。
     * @return 2: 找不到指定的 RPTID 和旧 VID 组合。
     * @return 3: 新的 VID 已经存在于该 RPTID 下。
     * @return 4: 更新操作失败。
     * @return 0: 更新成功，VID 已被替换为新的 VID。
     *
     * 此函数用于更新 `ReportVIDs` 表中指定 `RPTID` 的旧 `VID` 为新的 `VID`。
     * - 首先，检查是否存在指定的 `RPTID` 和 `OldVID` 组合。
     * - 然后检查新的 `VID` 是否已经存在于相同的 `RPTID` 下，防止重复。
     * - 如果检查通过，则执行更新操作。
     */
    int updateRPTIDVID(int nRPTID, int nOldVID, int nNewVID);

    /**
     * 删除并重新添加指定 RPTID 下的多个 VID 关联记录
     * @param nRPTID: 需要更新记录的 RPTID。
     * @param vecVID: 需要重新添加的 VID 列表。
     *
     * @return 1: 数据库未连接。
     * @return 2: 删除操作失败，可能是某些 VID 不存在或数据库操作失败。
     * @return 3: 插入操作失败，可能是某些 VID 已经存在。
     * @return 0: 删除并重新添加成功，所有 VID 记录已更新。
     *
     * 此函数用于删除指定 `RPTID` 下的所有旧 VID 记录，然后重新添加新的 VID 记录。
     * - 首先，删除指定 `RPTID` 下的所有 VID 关联记录。
     * - 然后，检查新 `VID` 是否存在，若不存在则插入新记录。
     *
     * 如果操作成功，返回 0；如果删除或插入过程中遇到问题，返回相应的错误代码。
     */
    int updateRPTIDVIDs(int nRPTID, const std::vector<int>& vecVID);

    /**
    * 查询指定 RPTID 下的所有 VID
    * @param nRPTID: 需要查询的 RPTID。
    * @return std::vector<int>: 存储所有与 RPTID 关联的 VID。
    *
    * 此函数用于根据指定的 `RPTID` 查询所有与之关联的 `VID`。
    * - 查询 `ReportVIDs` 表，根据 `RPTID` 获取所有相关的 `VID`。
    * - 返回的结果是一个 `std::vector<int>`，包含所有对应的 `VID`。
    */
    std::vector<int> getVIDsByRPTID(int nRPTID);

    /**
     * 查询所有 Report 表中的 RPTID
     * @return std::vector<int>: 存储所有的 RPTID。
     *
     * 此函数用于查询 `Report` 表中的所有 `RPTID`。
     * - 查询 `Report` 表中的所有 `RPTID`。
     * - 返回的结果是一个 `std::vector<int>`，包含所有的 `RPTID`。
     */
    std::vector<int> getAllRPTIDs();

private:
    SECSRuntimeManager();
    ~SECSRuntimeManager();