1. 添加查询SV表，自定义SV表增删改

darker

2025-02-18 500103089e58ced03f4cecc22b0f362dbb8eae04

1. 添加查询SV表，自定义SV表增删改

 SourceCode/Bond/Servo/SECSRuntimeManager.cpp

@@ -249,6 +249,28 @@
    return 0;
}

// 获取指定 ID 的 SystemSV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getSystemSVByID(int nID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return {};
    }

    std::string query = "SELECT * FROM SystemSV WHERE ID = " + std::to_string(nID) + ";";
    return m_pDB->fetchResults(query);
}

// 获取所有 SystemSV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getAllSystemSV() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return {};
    }

    std::string query = "SELECT * FROM SystemSV;";
    return m_pDB->fetchResults(query);
}

// 更新指定 ID 的 SystemSV 数据
int SECSRuntimeManager::updateIDSystemSV(int nID, int sNewID) {
    std::lock_guard<std::mutex> lock(m_mutex);
@@ -468,6 +490,152 @@
    return 0; // 插入成功，返回 0 表示操作成功完成。
}

// 查找指定 ID 的 EqpSV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getEqpSVByID(int nID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return {};
    }

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

// 查找所有 EqpSV 数据
std::vector<std::vector<std::string>> SECSRuntimeManager::getAllEqpSV() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return {};
    }

    // 查询 SQL 语句，获取所有数据
    std::string querySQL = "SELECT * FROM EqpSV;";
    return m_pDB->fetchResults(querySQL); // 直接返回查询结果
}

// 更新指定 ID 的 EqpSV 数据
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) {
    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 EqpSV 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
}

// 删除指定 ID 的 EqpSV 数据
int SECSRuntimeManager::deleteEqpSVByID(int nID) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;
    }

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

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

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

// 删除 EqpSV 表中的所有数据
int SECSRuntimeManager::deleteAllEqpSV() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pDB == nullptr) {
        return 1;
    }

    // 构建删除所有数据的 SQL 语句
    std::string deleteSQL = "DELETE FROM EqpSV;";
    if (!m_pDB->executeQuery(deleteSQL)) {
        return 2; // 如果删除失败，返回错误代码 2
    }

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

// 初始化 SystemDV 表
void SECSRuntimeManager::initSystemDVTable() {
    std::lock_guard<std::mutex> lock(m_mutex);

 SourceCode/Bond/Servo/SECSRuntimeManager.h

@@ -59,6 +59,29 @@
    int addSystemSV(int nID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSystemID);

    /**
     * 获取指定 ID 的 SystemSV 数据
     * @param nID: 需要查找的 SystemSV 的 ID。
     * @return std::vector<std::vector<std::string>>: 返回一个二维字符串向量，表示查询结果。每行代表一条记录，每列代表该记录的一个字段值。
     *          如果指定的 ID 存在，则返回该 ID 对应的记录；如果不存在，则返回空的二维向量。
     *
     * 此函数用于通过指定的 `ID` 从 SystemSV 表中查找对应的数据。首先根据传入的 `ID` 构造查询 SQL 语句，
     * 然后执行查询操作，返回查询结果。查询结果是一个二维字符串向量，表示查询到的记录。每行是一个
     * 字符串向量，每个元素是该行中的一列数据。如果找不到对应的数据，函数将返回一个空的二维向量。
     */
    std::vector<std::vector<std::string>> getSystemSVByID(int nID);

    /**
    * 获取所有 SystemSV 数据
    * @return std::vector<std::vector<std::string>>: 返回一个二维字符串向量，表示查询结果。每行代表一条记录，每列代表该记录的一个字段值。
    *          如果表中有数据，则返回所有记录；如果表为空，则返回空的二维向量。
    *
    * 此函数用于从 SystemSV 表中获取所有的数据。通过构造 SQL 查询语句来选择所有记录，并执行查询操作。
    * 返回的结果是一个二维字符串向量，表示表中的所有记录。每行数据是一个字符串向量，其中包含该记录的各个字段。
    * 如果表中没有数据，函数将返回一个空的二维向量。
    */
    std::vector<std::vector<std::string>> getAllSystemSV();

    /**
     * 更新指定 ID 的 SystemSV 数据
     * @param nID: 需要更新的 SystemSV 的当前 ID。
     * @param sNewID: 要更新为的新 ID。
@@ -126,7 +149,7 @@
    int deleteAllSystemSV();

    /**
    * 初始化Eqp表
    * 初始化 EqpSV 表
    */
    void initEqpSVTable();

@@ -152,48 +175,126 @@
     */
    int addEqpSV(int nID, const std::string& sName, const std::string& sDataType, int nLength, const std::string& sUnit, const std::string& sRemark, int nSeqNo);


    /**
    * 获取指定 ID 的 EqpSV 数据
    * @param nID: 需要查找的 EqpSV 的 ID。
    * @return std::vector<std::vector<std::string>>: 返回一个二维字符串向量，表示查询结果。每行代表一条记录，每列代表该记录的一个字段值。
    *          如果指定的 ID 存在，则返回该 ID 对应的记录；如果不存在，则返回空的二维向量。
    *
    * 此函数用于通过指定的 `ID` 从 EqpSV 表中查找对应的数据。首先根据传入的 `ID` 构造查询 SQL 语句，
    * 然后执行查询操作，返回查询结果。查询结果是一个二维字符串向量，表示查询到的记录。每行是一个
    * 字符串向量，每个元素是该行中的一列数据。如果找不到对应的数据，函数将返回一个空的二维向量。
    */
    std::vector<std::vector<std::string>> SECSRuntimeManager::getEqpSVByID(int nID);

    /**
    * 获取所有 EqpSV 数据
    * @return std::vector<std::vector<std::string>>: 返回一个二维字符串向量，表示查询结果。每行代表一条记录，每列代表该记录的一个字段值。
    *          如果表中有数据，则返回所有记录；如果表为空，则返回空的二维向量。
    *
    * 此函数用于从 EqpSV 表中获取所有的数据。通过构造 SQL 查询语句来选择所有记录，并执行查询操作。
    * 返回的结果是一个二维字符串向量，表示表中的所有记录。每行数据是一个字符串向量，其中包含该记录的各个字段。
    * 如果表中没有数据，函数将返回一个空的二维向量。
    */
    std::vector<std::vector<std::string>> SECSRuntimeManager::getAllEqpSV();

    /**
     * 更新指定 ID 的 EqpSV 数据
     * @param nID: 需要更新的 EqpSV 的 ID，必须是已存在的 ID。
     * @param nNewID: 更新后的 ID，必须是唯一的。
     * @param sName: 更新后的 EqpSV 名称，必须是唯一的。
     * @param sDataType: 更新后的数据类型，表示该设备值的类型，例如 "ASCII"、"UINT_1" 等。
     * @param nLength: 更新后的设备值的数据长度，通常为一个正整数，用于表示该数据的长度。
     * @param sUnit: 更新后的设备值的单位。如果为空或者为 "NULL"，则插入数据库中的 NULL 值。
     * @param sRemark: 更新后的备注信息，描述该设备值的其他信息，可用于说明该字段的用途或特性。
     * @param nSeqNo: 更新后的该数据的序号，用于排序。
     * @return 1: 数据库未连接。
     * @return 2: ID 不存在，无法更新数据。
     * @return 3: 新 ID 重复，无法更新数据。
     * @return 4: 更新数据失败。
     * @return 0: 更新成功，数据已更新到 EqpSV 表中。
     *
     * 此函数用于更新指定 ID 的 EqpSV 数据。首先检查 `ID` 是否存在，如果不存在则返回错误代码 2。
     * 然后检查新的 `ID` 是否已存在，如果已存在则返回错误代码 3。接下来，构造更新 SQL 语句，包含
     * 需要更新的字段，并执行更新操作。如果更新失败，则返回错误代码 4。如果一切顺利，返回 0 表示
     * 数据成功更新。
     */
    int 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);

    /**
    * 初始化SystemDV表
     * 更新指定 ID 的 EqpSV 数据
     * @param nID: 需要更新的 EqpSV 的当前 ID。
     * @param sNewID: 要更新为的新 ID。
     * @return 1: 数据库未连接。
     * @return 2: 未找到指定的 ID。
     * @return 3: 新的 ID 已经存在，无法更新。
     * @return 4: 更新操作失败。
     * @return 0: 更新成功。
     *
     * 此函数用于更新 `EqpSV` 表中指定 `nID` 的记录，将其 `ID` 字段更新为 `sNewID`。
     * 在执行更新前，函数会检查：
     * 1. 当前的 `nID` 是否存在于表中。
     * 2. 新的 `sNewID` 是否已经存在于表中，如果存在，则无法进行更新。
     *
     * 如果 `nID` 不存在，则返回错误代码 2。如果 `sNewID` 已经存在，则返回错误代码 3。
     * 如果数据库更新失败，则返回错误代码 4。成功时，返回 0 表示操作成功。
     */
    int deleteEqpSVByID(int nID);

    /**
    * 删除所有 EqpSV 数据
    * @return 1: 数据库未连接。
    * @return 2: 删除操作失败。
    * @return 0: 删除成功。
    *
    * 此函数用于删除 `EqpSV` 表中的所有记录。如果数据库未连接，则返回错误代码 1。
    * 如果删除操作失败，则返回错误代码 2。删除成功后，返回 0 表示删除成功。
    */ 
    int deleteAllEqpSV();

    /**
    * 初始化 SystemDV 表
    */ 
    void initSystemDVTable();

    /**
    * 初始化EqpDV表
    * 初始化 EqpDV 表
    */ 
    void initEqpDVTable();

    /**
    * 初始化SystemEC表
    * 初始化 SystemEC 表
    */ 
    void initSystemECTable();

    /**
    * 初始化EqpEC表
    * 初始化 EqpEC 表
    */
    void initEqpECTable();

    /**
    * 初始化SystemEvent表
    * 初始化 SystemEvent 表
    */
    void initSystemEventTable();

    /**
    * 初始化EqpEvent表
    * 初始化 EqpEvent 表
    */
    void initEqpEventTable();

    /**
    * 初始化EventLink表
    * 初始化 EventLink 表
    */
    void initEventLinkTable();

    /**
     * 初始化PPID表
     * 初始化 PPID 表
     */
    void initPPIDTable();

    /**
    * 初始化RPTID表
    * 初始化 RPTID 表
    */ 
    void initRPTIDTable();