/***************************************************************************** * @copyright 2024-2024, . POWER SUPPLY CO., LTD. * @file kit_db.c * @brief sqlite3数据库操作方法 * @author Gary * @date 2024/09/10 * @remark 去掉sqlite3_get_table即将过期的方法，补充了设备、协议和点位表的查询方法 *****************************************************************************/ #include #include #include #include #include "utextend.h" #include "kit_log.h" #include "kit_string.h" #include "kit_db.h" #define CONFIG_SQLITE_PATH "/opt/company_ems/db/sqlite3.db" // 配置数据库 #define BUSINESS_SQLITE_PATH "/opt/company_ems/db/business.db" // 业务数据库 static sqlite3 *config_db; // 全局变量，数据库句柄 static sqlite3 *business_db; // 全局变量，业务数据库句柄 pthread_mutex_t config_db_mutex = PTHREAD_MUTEX_INITIALIZER; // 全局变量，配置数据库线程锁 pthread_mutex_t business_db_mutex = PTHREAD_MUTEX_INITIALIZER; // 全局变量，业务数据库线程锁 // 设备配置信息icd static UT_icd ems_dev_config_icd = { sizeof(ems_dev_config_t), NULL, NULL, NULL, }; // 设备信息的icd static UT_icd dev_icd = { sizeof(dev_info_t), // 设备结构体大小 NULL, // 初始化函数 NULL, // 复制函数 NULL, // 销毁函数 }; // 点位信息icd static UT_icd point_icd = { sizeof(point_t), NULL, NULL, NULL, }; // 时序数据的icd static UT_icd timed_data_config_icd = { sizeof(timed_data_config_t), NULL, NULL, NULL, }; // 故障数据的icd static UT_icd faults_data_config_icd = { sizeof(faults_data_config_t), NULL, NULL, NULL, }; // 北向配置信息icd static UT_icd north_config_icd = { sizeof(north_config_t), NULL, NULL, NULL, }; // 削峰填谷日期配置信息icd static UT_icd pv_date_config_icd = { sizeof(pv_date_config_t), NULL, NULL, NULL, }; // 设备拓扑结构信息icd static UT_icd topology_icd = { sizeof(topology_t), NULL, NULL, NULL, }; static UT_icd advanced_setting_icd = { sizeof(advanced_setting_t), NULL, NULL, NULL, }; // MQTT断点记录信息icd static UT_icd break_record_icd = { sizeof(break_record_t), NULL, NULL, NULL, }; // DIDO逻辑设置信息的icd static UT_icd di_do_logic_set_icd = { sizeof(di_do_logic_set_t), NULL, NULL, NULL, }; /***************************************************************************** * @brief 检查文件夹是否存在 * @param[in] path：文件夹路径 * @return 存在-true，不存在-false *****************************************************************************/ static bool file_exists(const char *const path) { struct stat buf = {0}; if (-1 != stat(path, &buf) && S_ISDIR(buf.st_mode)) { return true; } else { return false; } } /***************************************************************************** * @brief 拼接路径，将源路径拼接到目标路径的指定位置 * @param[in] dst: 目标路径字符串 * @param[in] offset: 拼接的起始位置（即从目标路径的何处开始拼接） * @param[in] max_size: 目标路径的最大长度（缓冲区大小） * @param[in] src: 源路径字符串 * @return 返回拼接后的路径长度；如果拼接失败，则返回 -1 *****************************************************************************/ static int path_cat(char *dst, int offset, int max_size, const char *src) { int len = strlen(src); // 检查目标缓冲区是否足够容纳新拼接的路径 if (offset + len >= max_size) { return -1; } // 将源路径复制到目标路径的指定位置 strcpy(dst + offset, src); return offset + len; } /***************************************************************************** * @brief 读取文件内容并存储为字符串 * @param[in] path: 文件路径 * @param[out] sql: 指向读取的字符串的指针，内存由该函数分配，调用者需负责释放 * @return 0 表示成功，非 0 表示失败 *****************************************************************************/ static int read_file_string(const char *path, char **sql) { FILE *fp = fopen(path, "r"); if (fp == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "打开文件'%s'失败", path); return 1; // 打开文件失败 } // 获取文件大小 fseek(fp, 0, SEEK_END); long size = ftell(fp); rewind(fp); // 分配足够的内存来存储文件内容 *sql = malloc(size + 1); if (*sql == NULL) { fclose(fp); KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); return 1; // 内存分配失败 } // 读取文件内容到内存中并检查读取结果 size_t read_size = fread(*sql, 1, size, fp); if (read_size != size) { KITLOG(LOG_KIT_EN, ERROR_EN, "读取文件内容失败"); free(*sql); fclose(fp); return 1; // 读取文件内容失败 } (*sql)[size] = '\0'; // 添加字符串终止符 fclose(fp); return 0; } /***************************************************************************** * @brief 判断字符串是否以指定后缀结尾 * @param[in] str: 要检查的字符串 * @param[in] suffix: 指定的后缀 * @return 如果字符串以指定后缀结尾则返回 true，否则返回 false *****************************************************************************/ static bool ends_with(const char *str, const char *suffix) { // 如果字符串的长度小于后缀的长度，直接返回 false if (strlen(str) < strlen(suffix)) { return false; } // 比较字符串的结尾部分与后缀是否相等 return strcmp(str + strlen(str) - strlen(suffix), suffix) == 0; } /***************************************************************************** * @brief 比较两个 schema 文件名，用于排序 * @param[in] a: 第一个文件名 * @param[in] b: 第二个文件名 * @return 比较结果，用于排序函数 *****************************************************************************/ static int schema_sort_cmp(const void *a, const void *b) { return strcmp(*(char **)a, *(char **)b); } /***************************************************************************** * @brief 收集目录中的所有 SQL 文件 * @param[in] dir: 目录路径 * @return 包含所有 SQL 文件名的 UT_array 指针；如果失败，则返回 NULL *****************************************************************************/ static UT_array *collect_schemas(const char *dir) { DIR *dirp = NULL; struct dirent *dent = NULL; UT_array *files = NULL; // 打开目录 if ((dirp = opendir(dir)) == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "文件夹打开失败: %s", dir); return NULL; } // 初始化 UT_array 用于存储文件名 utarray_new(files, &ut_str_icd); // 遍历目录中的所有文件，筛选出以 ".sql" 结尾的文件 while (NULL != (dent = readdir(dirp))) { if (ends_with(dent->d_name, ".sql")) { char *file = strdup(dent->d_name); // strdup 自动分配并拷贝字符串 if (file == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "strdup 失败"); continue; } // 将副本指针推入 UT_array utarray_push_back(files, &file); } } // 关闭目录 closedir(dirp); return files; } /***************************************************************************** * @brief 执行目录中的所有 SQL 文件 * @param[in] dir: 存储 SQL 文件的目录路径 * @param[in] db: 数据库句柄 * @return 0 表示成功，非 0 表示失败 *****************************************************************************/ static int execute_sql_files(const char *dir, sqlite3 *db) { char *sql = NULL; int ret = 0; if (!file_exists(dir)) { KITLOG(LOG_KIT_EN, ERROR_EN, "sql 文件 `%s` 不存在", dir); return 1; } // 获取目录下的所有 SQL 文件 UT_array *files = collect_schemas(dir); if (NULL == files) { return 1; // 目录读取失败 } // 对文件名进行排序 utarray_sort(files, schema_sort_cmp); // 遍历每个 SQL 文件 utarray_foreach(files, char **, file) { char *path = NULL; path = calloc(PATH_MAX_SIZE, sizeof(char)); if (NULL == path) { KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); return 1; } // 拼接文件路径 if (PATH_MAX_SIZE <= path_cat(path, 0, PATH_MAX_SIZE, dir) || PATH_MAX_SIZE <= path_cat(path, strlen(dir), PATH_MAX_SIZE, *file)) { // 修正了路径拼接问题 KITLOG(LOG_KIT_EN, ERROR_EN, "路径过长: %s", path); free(path); return 1; } // 读取 SQL 文件内容 ret = read_file_string(path, &sql); if (0 != ret) { free(path); continue; // 读取失败，跳过该文件 } // 执行 SQL 语句 char *err_msg = NULL; ret = sqlite3_exec(db, sql, NULL, NULL, &err_msg); if (SQLITE_OK != ret) { KITLOG(LOG_KIT_EN, ERROR_EN, "执行 %s 失败: (%d)%s", path, ret, err_msg); sqlite3_free(err_msg); ret = 1; free(path); free(sql); continue; } free(path); free(sql); } // 释放文件列表内存 utarray_free(files); return ret; } /***************************************************************************** * @brief 初始化 SQLite 数据库 * @param[in] schema_dir: 存储 SQL 文件的目录路径 * @param[in] db: 待初始化数据库 * @return 0 表示成功，1 表示失败 *****************************************************************************/ static int init_db_handle(const char *schema_dir, sqlite3 *db) { int ret = 0; // 设置忙时超时时间 ret = sqlite3_busy_timeout(db, 120 * 1000); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "设置忙时超时失败: %s", sqlite3_errmsg(db)); sqlite3_close(db); return 1; } // 启用外键支持 ret = sqlite3_exec(db, "PRAGMA foreign_keys=ON", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "数据库外键启动失败: %s", sqlite3_errmsg(db)); sqlite3_close(db); return 1; } // 设置 WAL 模式 ret = sqlite3_exec(db, "PRAGMA journal_mode=WAL", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "数据库 journal_mode WAL 启动失败: %s", sqlite3_errmsg(db)); sqlite3_close(db); return 1; } #ifdef INIT_DB // 执行目录中的所有 SQL 文件 ret = execute_sql_files(schema_dir, db); if (ret != 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "执行 SQL 文件失败"); sqlite3_close(db); return 1; } #endif return 0; } /***************************************************************************** * @brief 根据北向上报下发设备Id获取点位信息 * @param[in] upDisDevDbId: 上报下发设备Id * @param[out] p_upDisDev: 用于存储北向配置信息的指针, 包含上报点位和下发设备信息 * @return 0-成功 1-失败 *****************************************************************************/ static int kit_get_updis_dev_point(int upDisDevDbId, up_dis_dev_t *p_upDisDev) { int ret = 0; sqlite3_stmt *stmt = NULL; char *query = "SELECT udd.dev_type, d.code, udp.cloud_code, " "udp.cloud_name, udp.point_code " "FROM up_dis_dev udd " "LEFT JOIN device d ON udd.dev_id = d.id " "LEFT JOIN up_dis_point udp ON udd.id = udp.up_dis_id " "WHERE udd.id = ?"; if (sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL) != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询失败: %s", sqlite3_errmsg(config_db)); return 1; } if (sqlite3_bind_int(stmt, 1, upDisDevDbId) != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定upDisDevDbId失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); return 1; } int step; while ((step = sqlite3_step(stmt)) == SQLITE_ROW) { up_dis_point_t *temp = realloc(p_upDisDev->upDisPointArr, (p_upDisDev->upDisPointNum + 1) * sizeof(up_dis_point_t)); if (temp == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); ret = 1; break; } p_upDisDev->upDisPointArr = temp; up_dis_point_t *point = &p_upDisDev->upDisPointArr[p_upDisDev->upDisPointNum++]; point->devType = (dev_type_e)sqlite3_column_int(stmt, 0); point->devId = sqlite3_column_int(stmt, 1); snprintf((char *)point->cloudCode, MAX_CODE_BUF_LEN, "%s", sqlite3_column_text(stmt, 2)); snprintf((char *)point->cloudName, MAX_NAME_BUF_LEN, "%s", sqlite3_column_text(stmt, 3)); point->pointId = sqlite3_column_int(stmt, 4); } if (step != SQLITE_DONE && ret == 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询上报下发点位信息失败: %s", sqlite3_errmsg(config_db)); ret = 1; } sqlite3_finalize(stmt); return ret; } /***************************************************************************** * @brief 根据北向配置ID获取上报下发配置信息 * @param[in] northConfigDbId: 北向配置表数据库ID * @param[out] northConfig: 用于存储北向配置信息的指针, 包含上报点位和下发点位信息 * @return 0-成功 1-失败 *****************************************************************************/ static int kit_get_north_config_by_id(int northConfigDbId, north_config_t *northConfig) { int ret = 0; int upDisDevId; sqlite3_stmt *stmt = NULL; char *query = "SELECT udd.up_dis_config_type, udd.dev_type, d.code, " "udd.id " "FROM up_dis_dev udd " "LEFT JOIN device d ON udd.dev_id = d.id " "WHERE udd.north_config_id = ?"; // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) // config_db: 全局数据库连接 { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); return 1; } // 绑定参数到预编译语句 if (SQLITE_OK != sqlite3_bind_int(stmt, 1, northConfigDbId)) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定 northConfigId 失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); return 1; // 返回错误代码 } // 执行查询并处理结果 int step = sqlite3_step(stmt); while (SQLITE_ROW == step) { // 获取上报下发配置类型 up_dis_config_type_e upDisConfigType = sqlite3_column_int(stmt, 0); // 根据配置类型分配内存并存储点位信息 switch (upDisConfigType) { case kUp_Dis_Cfg_Type_Up: // 上报点位 northConfig->upDevNum++; // 分配内存以存储新的上报设备信息 up_dis_dev_t *tempUp = (up_dis_dev_t *)realloc(northConfig->upDevArr, northConfig->upDevNum * sizeof(up_dis_dev_t)); if (tempUp == NULL) { // 内存分配失败，记录错误信息并返回 KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); ret = 1; goto error; } northConfig->upDevArr = tempUp; // 获取上报配置信息 northConfig->upDevArr[northConfig->upDevNum - 1].devType = (dev_type_e)sqlite3_column_int(stmt, 1); // 设备类型 northConfig->upDevArr[northConfig->upDevNum - 1].devId = sqlite3_column_int(stmt, 2); // 设备编号 upDisDevId = sqlite3_column_int(stmt, 3); // 上报下发设备Id kit_get_updis_dev_point(upDisDevId, &northConfig->upDevArr[northConfig->upDevNum - 1]); break; case kUp_Dis_Cfg_Type_Dis_Point: // 下发控制点位 northConfig->disDevNum++; // 分配内存以存储新的下发设备信息 up_dis_dev_t *tempDis = (up_dis_dev_t *)realloc(northConfig->disDevArr, northConfig->disDevNum * sizeof(up_dis_dev_t)); if (tempDis == NULL) { // 内存分配失败，记录错误信息并返回 KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); ret = 1; goto error; } northConfig->disDevArr = tempDis; // 获取下发配置信息 northConfig->disDevArr[northConfig->disDevNum - 1].devType = (dev_type_e)sqlite3_column_int(stmt, 1); // 设备类型 northConfig->disDevArr[northConfig->disDevNum - 1].devId = sqlite3_column_int(stmt, 2); // 设备编号 upDisDevId = sqlite3_column_int(stmt, 3); // 上报下发设备Id kit_get_updis_dev_point(upDisDevId, &northConfig->disDevArr[northConfig->upDevNum - 1]); break; default: KITLOG(LOG_KIT_EN, ERROR_EN, "未知的上报下发配置类型: %d", upDisConfigType); ret = 1; break; } if (ret != 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "填充上报下发信息失败"); sqlite3_finalize(stmt); return 1; } step = sqlite3_step(stmt); } if (step != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询上报下发配置信息失败: %s", sqlite3_errmsg(config_db)); ret = 1; } error: // 清理资源 sqlite3_finalize(stmt); return ret; } /* ############################################################################### 配置数据库操作 ############################################################################### */ /***************************************************************************** * @brief 初始化 SQLite 数据库 * @param[in] schema_dir: 存储 SQL 文件的目录路径 * @return 0-成功 1-失败 *****************************************************************************/ int kit_init_db(const char *schema_dir) { int ret = 0; // 打开配置数据库，如果不存在则创建 // ret = sqlite3_open(CONFIG_SQLITE_PATH, &config_db); ret = sqlite3_open_v2(CONFIG_SQLITE_PATH, &config_db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_WAL, NULL); if (SQLITE_OK != ret) { KITLOG(LOG_KIT_EN, ERROR_EN, "打开数据库 `%s` 失败: %s", CONFIG_SQLITE_PATH, sqlite3_errstr(ret)); return 1; } char config_schema_dir[PATH_MAX_SIZE]; // 假设路径不会超过 PATH_MAX_SIZE 字符 snprintf(config_schema_dir, PATH_MAX_SIZE, "%s/config/", schema_dir); ret = init_db_handle(config_schema_dir, config_db); if (0 != ret) { KITLOG(LOG_KIT_EN, ERROR_EN, "初始化数据库 `%s` 失败", CONFIG_SQLITE_PATH); return 1; } // 打开业务数据库，如果不存在则创建 // ret = sqlite3_open(BUSINESS_SQLITE_PATH, &business_db); ret = sqlite3_open_v2(BUSINESS_SQLITE_PATH, &business_db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_WAL, NULL); if (SQLITE_OK != ret) { KITLOG(LOG_KIT_EN, ERROR_EN, "打开数据库 `%s` 失败: %s", BUSINESS_SQLITE_PATH, sqlite3_errstr(ret)); return 1; } char business_schema_dir[PATH_MAX_SIZE]; // 假设路径不会超过 PATH_MAX_SIZE 字符 snprintf(business_schema_dir, PATH_MAX_SIZE, "%s/business/", schema_dir); ret = init_db_handle(business_schema_dir, business_db); if (0 != ret) { KITLOG(LOG_KIT_EN, ERROR_EN, "初始化数据库 `%s` 失败", BUSINESS_SQLITE_PATH); return 1; } #ifdef INIT_DB kit_sync_dev_data(); // 同步设备信息 kit_sync_point_data(); // 同步点位信息 #endif return 0; } /***************************************************************************** * @brief 释放 SQLite 数据库连接 * @return 0 表示成功，1 表示失败 *****************************************************************************/ int kit_uninit_db() { if (config_db != NULL) { sqlite3_close(config_db); config_db = NULL; return 0; } if (business_db != NULL) { sqlite3_close(business_db); business_db = NULL; return 0; } return 1; } /***************************************************************************** * @brief 从 SQLite 数据库中获取数据表数据。使用准备好的语句（Prepared Statement）从 SQLite数据库中 * 获取数据表数据，避免使用 `sqlite3_get_table`，因为它是一个过时的接口，存在安全和性能问题。 * @param[out] outData: 用于存储查询结果的结构体指针。 * @param[in] tableName: 数据表名称。 * @param[in] columnsName: 要查询的列名数组，可以为 NULL 或空数组，表示查询所有列。 * @param[in] columnNum: 要查询的列名数量。 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_db_data(db_table_data_t *outData, const char *tableName, const char *columnsName[], int columnNum) { sqlite3_stmt *stmt = NULL; int ret = 0; char *sql = NULL; char *sql_columns = NULL; // 构建 SQL 查询语句 if (columnsName == NULL || columnNum == 0) { sql = sqlite3_mprintf("SELECT * FROM %s", tableName); } else { sql_columns = kit_join_text(columnNum, columnsName, ","); if (sql_columns == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "构建列名失败"); return 1; } sql = sqlite3_mprintf("SELECT %s FROM %s", sql_columns, tableName); free(sql_columns); // 释放拼接好的列名字符串 } if (sql == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "构建 SQL 语句失败: sqlite3_mprintf 失败"); return 1; } // 准备 SQL 语句 sqlite3_free(sql); // 释放 SQL 字符串 if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备语句失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); // 结束语句 return 1; } // 获取查询结果 outData->nrow = 0; outData->ncolumn = sqlite3_column_count(stmt); // 获取列数 // 如果有列，继续处理 if (outData->ncolumn > 0) { // 先检查有多少行 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) { outData->nrow++; } // 如果没有找到行 if (outData->nrow == 0) { KITLOG(LOG_KIT_EN, INFO_EN, "没有找到匹配的行"); sqlite3_finalize(stmt); return 0; } // 为结果表分配内存 outData->dbresult = (char **)sqlite3_malloc(outData->nrow * outData->ncolumn * sizeof(char *)); if (outData->dbresult == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "分配结果表内存失败"); sqlite3_finalize(stmt); return 1; } // 重置语句，重新开始读取 sqlite3_reset(stmt); // 读取数据行并存储结果 int row = 0; while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) { for (int i = 0; i < outData->ncolumn; i++) { const char *text = (const char *)sqlite3_column_text(stmt, i); outData->dbresult[row * outData->ncolumn + i] = text ? sqlite3_mprintf("%s", text) : NULL; } row++; } if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "执行语句失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); return 1; } } // 结束语句 sqlite3_finalize(stmt); return 0; } /***************************************************************************** * @brief 释放 `db_table_data_t` 结构体中分配的内存。 * 该函数用于释放 `kitGetDbData` 函数获取的查询结果数据所占用的内存。 * 它会依次释放 `dbresult`、`errmsg` 和 `db` 指针指向的内存。 * @param data 指向 `db_table_data_t` 结构体的指针。 *****************************************************************************/ void kit_free_table_data(db_table_data_t *data) { if (data == NULL) { // 如果 `data` 指针为空，则直接返回。 return; } // 释放 `dbresult` 指向的内存，如果 `dbresult` 不为空。 if (data->dbresult != NULL) { sqlite3_free_table(data->dbresult); data->dbresult = NULL; } // 释放 `errmsg` 指向的内存，如果 `errmsg` 不为空。 if (data->errmsg != NULL) { sqlite3_free(data->errmsg); data->errmsg = NULL; } // 函数执行完毕，返回。 return; } /***************************************************************************** * @brief: 执行多条 SQL 语句，函数内关闭连接。 * 该函数用于执行多个 SQL 语句，并处理执行过程中的错误。 * 它会依次执行传入的 SQL 语句数组，并在执行失败时记录错误信息。 * 函数执行完毕后会关闭数据库连接。 * @param[in] tableName: 数据表名称（未使用，可以忽略）。 * @param[in] sql: 包含多个 SQL 语句的字符串数组。 * @param[in] sql_num: SQL 语句的数量。 * @return 0-成功 1-失败 *****************************************************************************/ int kit_exec_db_data(char *tableName, char *sql[], int sql_num) { sqlite3 *db = NULL; // 数据库连接指针 int ret = 0; // sqlite3_exec 函数返回值 char *zErrMsg = 0; // 错误信息指针 // 循环执行每个 SQL 语句 for (int i = 0; i < sql_num; i++) { // printf("%s\n",sql[i]); // 可选：打印每个 SQL 语句 ret = sqlite3_exec(db, sql[i], NULL, 0, &zErrMsg); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "执行 SQL 语句[%d] 失败: %s.", i, zErrMsg); sqlite3_free(zErrMsg); // 释放错误信息内存 return 1; } } sqlite3_free(zErrMsg); // 释放错误信息内存 return 0; // 返回执行结果标志 } /***************************************************************************** * @brief 从数据库查询电站数据 * @param[in] p_station：电站信息的指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_station_db_data(station_t *p_station) { sqlite3_stmt *stmt = NULL; char *query = sqlite3_mprintf("SELECT name, address, lng, lat, time_zone FROM station DESC LIMIT 1"); if (query == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); return 1; } if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_free(query); return 1; // 返回错误代码 } int step = sqlite3_step(stmt); if (step == SQLITE_ROW) { snprintf((char *)p_station->name, MAX_NAME_BUF_LEN, "%s", (const char *)sqlite3_column_text(stmt, 0)); // 电站名称 snprintf((char *)p_station->address, MAX_ADDR_BUF_LEN, "%s", (const char *)sqlite3_column_text(stmt, 1)); // 电站地址 p_station->lng = sqlite3_column_double(stmt, 2); // 经度 p_station->lat = sqlite3_column_double(stmt, 3); // 纬度 snprintf((char *)p_station->timeZone, MAX_CODE_BUF_LEN, "%s", (const char *)sqlite3_column_text(stmt, 4)); // 时区 } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败，错误码: %d, 错误信息: %s", step, sqlite3_errmsg(config_db)); } sqlite3_finalize(stmt); sqlite3_free(query); return (step == SQLITE_ROW) ? 0 : 1; // 返回成功或失败代码 } /***************************************************************************** * @brief 从数据库获取设备信息 * @param[out] devPointInfo: 用于存储设备信息的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_dev_db_data(UT_array **devPointInfo) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *query; // 查询语句 utarray_new(*devPointInfo, &dev_icd); // 创建新的 UT_array 用于存储设备点位信息 // 构建查询语句 query = "SELECT id, type, code, protocol_type, name, " "sort_order, template_id " "FROM device WHERE 1=1 "; // 基础查询语句 // 添加结果排序 query = sqlite3_mprintf("%s ORDER BY type, protocol_type, id ASC", query); // 按 id 升序排序 // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 执行查询并处理结果 int step = sqlite3_step(stmt); while (SQLITE_ROW == step) // 遍历每一行结果 { // 从数据库中获取每一列的值 dev_info_t dev_info = {0}; // 初始化设备点位结构体 dev_info.devDbId = sqlite3_column_int(stmt, 0); dev_info.devType = sqlite3_column_int(stmt, 1); dev_info.devId = sqlite3_column_int(stmt, 2); dev_info.protocolType = sqlite3_column_int(stmt, 3); snprintf((char *)dev_info.devName, MAX_NAME_BUF_LEN, "%s", (const char *)sqlite3_column_text(stmt, 4)); dev_info.sortOrder = sqlite3_column_int(stmt, 5); dev_info.templateId = sqlite3_column_int(stmt, 6); // 将设备点位信息添加到 UT_array 中 utarray_push_back(*devPointInfo, &dev_info); // 继续处理下一行 step = sqlite3_step(stmt); } // 检查是否完成所有行的处理 if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 清理资源 sqlite3_finalize(stmt); // 释放预编译语句 return 0; // 成功返回 error: sqlite3_finalize(stmt); // 确保释放预编译语句 utarray_free(*devPointInfo); // 释放 UT_array devPointInfo = NULL; // 设置为 NULL return 1; // 返回错误代码 } /***************************************************************************** * @brief 将 config_db 中的 device 表数据复制到 business_db 中的 device 表 * @return 0-成功 1-失败 *****************************************************************************/ int kit_sync_dev_data() { sqlite3_stmt *stmt_select = NULL; // 用于 SELECT 语句 sqlite3_stmt *stmt_insert = NULL; // 用于 INSERT 语句 const char *sql_delete; const char *sql_select; const char *sql_insert; int ret; pthread_mutex_lock(&config_db_mutex); // 给配置库操作上锁 pthread_mutex_lock(&business_db_mutex); // 给业务库操作上锁 // 清空 business_db 中的 device 表 sql_delete = "DELETE FROM device"; ret = sqlite3_exec(business_db, sql_delete, NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "清空 business_db 中的 device 表失败: %s", sqlite3_errmsg(business_db)); goto error; } // 从 config_db 中选择数据 sql_select = "SELECT id, sn, type, code, name, protocol_type, template_id, sort_order, remark, status FROM device"; ret = sqlite3_prepare_v2(config_db, sql_select, -1, &stmt_select, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", sql_select, sqlite3_errmsg(config_db)); goto error; } // 准备插入语句 sql_insert = "INSERT INTO device (id, sn, type, code, name, protocol_type, template_id, sort_order, remark, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"; ret = sqlite3_prepare_v2(business_db, sql_insert, -1, &stmt_insert, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备插入语句 `%s` 失败: %s", sql_insert, sqlite3_errmsg(business_db)); goto error; } // 循环插入数据 while ((ret = sqlite3_step(stmt_select)) == SQLITE_ROW) { // 绑定参数 sqlite3_bind_int(stmt_insert, 1, sqlite3_column_int(stmt_select, 0)); sqlite3_bind_text(stmt_insert, 2, (const char *)sqlite3_column_text(stmt_select, 1), -1, SQLITE_STATIC); sqlite3_bind_int(stmt_insert, 3, sqlite3_column_int(stmt_select, 2)); sqlite3_bind_int(stmt_insert, 4, sqlite3_column_int(stmt_select, 3)); sqlite3_bind_text(stmt_insert, 5, (const char *)sqlite3_column_text(stmt_select, 4), -1, SQLITE_STATIC); sqlite3_bind_int(stmt_insert, 6, sqlite3_column_int(stmt_select, 5)); sqlite3_bind_int(stmt_insert, 7, sqlite3_column_int(stmt_select, 6)); sqlite3_bind_int(stmt_insert, 8, sqlite3_column_int(stmt_select, 7)); sqlite3_bind_text(stmt_insert, 9, (const char *)sqlite3_column_text(stmt_select, 8), -1, SQLITE_STATIC); sqlite3_bind_int(stmt_insert, 10, sqlite3_column_int(stmt_select, 9)); // 执行插入 ret = sqlite3_step(stmt_insert); sqlite3_reset(stmt_insert); // 重置语句以进行下一次插入 if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入数据失败: %s", sqlite3_errmsg(business_db)); goto error; } } // 检查是否有错误发生在sqlite3_step(stmt_select)中 if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询数据失败: %s", sqlite3_errmsg(config_db)); goto error; } // 清理资源 sqlite3_finalize(stmt_select); sqlite3_finalize(stmt_insert); pthread_mutex_unlock(&config_db_mutex); // 给配置库操作释放锁 pthread_mutex_unlock(&business_db_mutex); // 给业务库操作释放锁 return 0; error: sqlite3_finalize(stmt_select); sqlite3_finalize(stmt_insert); pthread_mutex_unlock(&config_db_mutex); // 给配置库操作释放锁 pthread_mutex_unlock(&business_db_mutex); // 给业务库操作释放锁 return 1; } /***************************************************************************** * @brief 从数据库获取协议信息。 * 该函数从数据库中获取与指定设备 ID 关联的协议信息。 * 它使用准备好的语句（Prepared Statement）来执行查询，并绑定设备 ID 参数。 * 函数会返回获取到的协议信息，并处理查询过程中的错误。 * @param[in] templateType: 模板类别（0设备配置, 1北向配置）。 * @param[in] relatedId: 关联数据库 ID。 * @param[out] protoContent: 用于存储协议信息的字符数组。 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_protocol_db_data(const template_type_e templateType, const uint64_t relatedId, char protoContent[MAX_CONFIG_CONTENT_LEN]) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 char *query = sqlite3_mprintf("SELECT content FROM protocol WHERE 1=1 AND template_type=? AND related_id=? LIMIT 1"); // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_free(query); // 释放查询字符串 return 1; // 返回错误代码 } // 绑定参数到预编译语句 if (SQLITE_OK != sqlite3_bind_int(stmt, 1, templateType)) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定 template_type 失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); sqlite3_free(query); // 释放查询字符串 return 1; // 返回错误代码 } if (SQLITE_OK != sqlite3_bind_int64(stmt, 2, relatedId)) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定 related_id 失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); sqlite3_free(query); // 释放查询字符串 return 1; // 返回错误代码 } // 执行查询并处理结果 int step = sqlite3_step(stmt); if (step == SQLITE_ROW || step == SQLITE_DONE) { snprintf(protoContent, MAX_CONFIG_CONTENT_LEN, "%s", sqlite3_column_text(stmt, 0)); } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); sqlite3_free(query); // 释放查询字符串 return 1; // 返回错误代码 } // 清理资源 sqlite3_finalize(stmt); // 释放预编译语句 sqlite3_free(query); // 释放查询字符串 return 0; // 成功返回 } /***************************************************************************** * @brief 从数据库获取点位信息 * @param[in] templateId: 模板Id * @param[out] points: 用于存储点位信息的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_point_db_data(const uint64_t templateId, UT_array **points) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *query; // 查询语句 utarray_new(*points, &point_icd); // 创建新的 UT_array 用于存储设备点位信息 // 构建查询语句 query = "SELECT group_type, code, name, data_type, " "attribute, func, reg_addr, bit_pos, bit_num, endian, " "precision, ratio, offset, is_persisted, storage_interval, " "mutate_bound, default_value, min_value, max_value, dev_type,id " "FROM point WHERE 1=1 "; // 基础查询语句 // 检查并添加设备Id条件 query = sqlite3_mprintf("%s AND template_id=?", query); // 动态添加设备Id条件 // 添加结果排序 query = sqlite3_mprintf("%s ORDER BY func, reg_addr ASC", query); // 按 id 升序排序 // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 绑定参数到预编译语句 int param_index = 1; // 参数索引 if (SQLITE_OK != sqlite3_bind_int64(stmt, param_index++, templateId)) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定 `%s` 的参数 dev_id 失败: %s", query, sqlite3_errmsg(config_db)); goto error; // 处理错误 } // printf("%s\n",query); // 执行查询并处理结果 int step = sqlite3_step(stmt); while (SQLITE_ROW == step) // 遍历每一行结果 { // 从数据库中获取每一列的值 point_t point_info = {0}; // 初始化设备点位结构体 point_info.groupType = (point_group_type_e)sqlite3_column_int(stmt, 0); point_info.pointId = (uint16_t)sqlite3_column_int(stmt, 1); snprintf((char *)point_info.pointName, MAX_POINT_NAME_LEN, "%s", (const char *)sqlite3_column_text(stmt, 2)); point_info.dataType = (data_type_e)sqlite3_column_int(stmt, 3); point_info.attribute = (point_attribute_e)sqlite3_column_int(stmt, 4); point_info.func = (uint32_t)sqlite3_column_int(stmt, 5); point_info.regAddr = (uint16_t)sqlite3_column_int(stmt, 6); point_info.bitPos = (uint8_t)sqlite3_column_int(stmt, 7); point_info.bitNum = (uint8_t)sqlite3_column_int(stmt, 8); point_info.endian = (data_endian_e)sqlite3_column_int(stmt, 9); point_info.precision = sqlite3_column_double(stmt, 10); point_info.ratio = sqlite3_column_double(stmt, 11); point_info.offset = sqlite3_column_double(stmt, 12); point_info.isPersisted = (uint8_t)sqlite3_column_int(stmt, 13); point_info.storageInterval = (storage_interval_type_e)sqlite3_column_int(stmt, 14); point_info.mutateBound = sqlite3_column_double(stmt, 15); point_info.defaultValue = sqlite3_column_double(stmt, 16); point_info.minValue = sqlite3_column_double(stmt, 17); point_info.maxValue = sqlite3_column_double(stmt, 18); point_info.devType = sqlite3_column_int(stmt, 19); point_info.pointDbId = sqlite3_column_int(stmt, 20); // point_info.devDbId = sqlite3_column_int(stmt, 20); // 将设备点位信息添加到 UT_array 中 utarray_push_back(*points, &point_info); // 继续处理下一行 step = sqlite3_step(stmt); } // 检查是否完成所有行的处理 if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 清理资源 sqlite3_finalize(stmt); // 释放预编译语句 return 0; // 成功返回 error: sqlite3_finalize(stmt); // 确保释放预编译语句 utarray_free(*points); // 释放 UT_array points = NULL; // 设置为 NULL return 1; // 返回错误代码 } /***************************************************************************** * @brief 从 config_db 获取点位信息并同步到 business_db * @param[out] 无 * @return 0-成功 1-失败 *****************************************************************************/ int kit_sync_point_data() { sqlite3_stmt *stmt_config = NULL; // config_db 中的预编译语句句柄 sqlite3_stmt *stmt_business = NULL; // business_db 中的预编译语句句柄 const char *query_config; // 从 config_db 查询点位信息的 SQL 语句 const char *query_clear = "DELETE FROM point"; // 清空 business_db 中的 point 表的 SQL 语句 int step; // 查询结果步骤 pthread_mutex_lock(&config_db_mutex); // 给配置库操作上锁 pthread_mutex_lock(&business_db_mutex); // 给业务库操作上锁 // 清空 business_db 中的 point 表 if (SQLITE_OK != sqlite3_exec(business_db, query_clear, NULL, NULL, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "清空 business_db 中的 point 表失败: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&config_db_mutex); // 给配置库操作释放锁 pthread_mutex_unlock(&business_db_mutex); // 给业务库操作释放锁 return 1; // 处理错误 } // 构建查询语句从 config_db 获取所有点位信息 query_config = "SELECT template_id, protocol_type, dev_type, group_type, code, name, " "data_type, attribute, func, reg_addr, bit_pos, bit_num, endian, precision, " "ratio, offset, is_persisted, storage_interval, mutate_bound, default_value, " "min_value, max_value, unit, is_show FROM point ORDER BY id ASC"; // 准备从 config_db 执行查询语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query_config, -1, &stmt_config, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query_config, sqlite3_errmsg(config_db)); pthread_mutex_unlock(&config_db_mutex); // 给配置库操作释放锁 pthread_mutex_unlock(&business_db_mutex); // 给业务库操作释放锁 return 1; // 处理错误 } // 准备向 business_db 插入数据的 SQL 语句 const char *insert_query = "INSERT INTO point (template_id, protocol_type, dev_type, group_type, " "code, name, data_type, attribute, func, reg_addr, bit_pos, bit_num, endian, " "precision, ratio, offset, is_persisted, storage_interval, mutate_bound, " "default_value, min_value, max_value, unit, is_show) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"; // 准备向 business_db 插入数据 if (SQLITE_OK != sqlite3_prepare_v2(business_db, insert_query, -1, &stmt_business, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备插入 `%s` 失败: %s", insert_query, sqlite3_errmsg(business_db)); sqlite3_finalize(stmt_config); // 确保释放预编译语句 pthread_mutex_unlock(&config_db_mutex); // 给配置库操作释放锁 pthread_mutex_unlock(&business_db_mutex); // 给业务库操作释放锁 return 1; // 处理错误 } // 执行查询并插入数据 step = sqlite3_step(stmt_config); while (SQLITE_ROW == step) // 遍历每一行结果 { // 从 config_db 中获取每一列的值 int param_index = 1; // 参数索引 // 绑定参数到插入语句 if (SQLITE_OK != sqlite3_bind_int64(stmt_business, param_index++, sqlite3_column_int64(stmt_config, 0))) // template_id goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 1))) // protocol_type goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 2))) // dev_type goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 3))) // group_type goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 4))) // code goto error; if (SQLITE_OK != sqlite3_bind_text(stmt_business, param_index++, sqlite3_column_text(stmt_config, 5), -1, SQLITE_STATIC)) // name goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 6))) // data_type goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 7))) // attribute goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 8))) // func goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 9))) // reg_addr goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 10))) // bit_pos goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 11))) // bit_num goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 12))) // endian goto error; if (SQLITE_OK != sqlite3_bind_double(stmt_business, param_index++, sqlite3_column_double(stmt_config, 13))) // precision goto error; if (SQLITE_OK != sqlite3_bind_double(stmt_business, param_index++, sqlite3_column_double(stmt_config, 14))) // ratio goto error; if (SQLITE_OK != sqlite3_bind_double(stmt_business, param_index++, sqlite3_column_double(stmt_config, 15))) // offset goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 16))) // is_persisted goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 17))) // storage_interval goto error; if (SQLITE_OK != sqlite3_bind_double(stmt_business, param_index++, sqlite3_column_double(stmt_config, 18))) // mutate_bound goto error; if (SQLITE_OK != sqlite3_bind_double(stmt_business, param_index++, sqlite3_column_double(stmt_config, 19))) // default_value goto error; if (SQLITE_OK != sqlite3_bind_double(stmt_business, param_index++, sqlite3_column_double(stmt_config, 20))) // min_value goto error; if (SQLITE_OK != sqlite3_bind_double(stmt_business, param_index++, sqlite3_column_double(stmt_config, 21))) // max_value goto error; if (SQLITE_OK != sqlite3_bind_text(stmt_business, param_index++, sqlite3_column_text(stmt_config, 22), -1, SQLITE_STATIC)) // unit goto error; if (SQLITE_OK != sqlite3_bind_int(stmt_business, param_index++, sqlite3_column_int(stmt_config, 23))) // is_show goto error; // 执行插入操作 if (SQLITE_DONE != sqlite3_step(stmt_business)) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入数据失败: %s", sqlite3_errmsg(business_db)); goto error; } // 重置插入语句以便于重新绑定参数 sqlite3_reset(stmt_business); // 继续处理下一行 step = sqlite3_step(stmt_config); } // 检查是否完成所有行的处理 if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 清理资源 sqlite3_finalize(stmt_config); // 释放 config_db 预编译语句 sqlite3_finalize(stmt_business); // 释放 business_db 预编译语句 pthread_mutex_unlock(&config_db_mutex); // 给配置库操作释放锁 pthread_mutex_unlock(&business_db_mutex); // 给业务库操作释放锁 return 0; // 成功返回 error: sqlite3_finalize(stmt_config); // 确保释放预编译语句 sqlite3_finalize(stmt_business); // 确保释放预编译语句 pthread_mutex_unlock(&config_db_mutex); // 给配置库操作释放锁 pthread_mutex_unlock(&business_db_mutex); // 给业务库操作释放锁 return 1; // 返回错误代码 } /***************************************************************************** * @brief 从数据库获取读取时序数据配置 * @param[out] timedDataConfigs: 用于指定存储间隔类型的的时序数据配置的数据 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_tdata_config(UT_array **timedDataConfigs) { sqlite3_stmt *stmt = NULL; char *query = sqlite3_mprintf("SELECT p.id, p.code, p.name, p.storage_interval, d.name, d.type, d.id, d.code FROM point p LEFT JOIN device d ON p.template_id = d.template_id ORDER BY p.storage_interval ASC"); int ret; ret = sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_free(query); return 1; } utarray_new(*timedDataConfigs, &timed_data_config_icd); while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) { timed_data_config_t data_info = {0}; data_info.pointDbId = sqlite3_column_int(stmt, 0); data_info.pointId = sqlite3_column_int(stmt, 1); snprintf((char *)data_info.pointName, MAX_POINT_NAME_LEN, "%s", (const char *)sqlite3_column_text(stmt, 2)); data_info.storageInterval = (storage_interval_type_e)sqlite3_column_int(stmt, 3); snprintf((char *)data_info.devName, MAX_NAME_BUF_LEN, "%s", (const char *)sqlite3_column_text(stmt, 4)); data_info.devType = sqlite3_column_int(stmt, 5); data_info.devDbId = sqlite3_column_int(stmt, 6); data_info.devId = sqlite3_column_int(stmt, 7); utarray_push_back(*timedDataConfigs, &data_info); } if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); sqlite3_free(query); utarray_free(*timedDataConfigs); *timedDataConfigs = NULL; return 1; } sqlite3_finalize(stmt); sqlite3_free(query); return 0; } /***************************************************************************** * @brief 从数据库获取故障点位配置 * @param[out] faultsDataConfigs: 用于存储故障配置点位的数据 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_faults_config(UT_array **faultsDataConfigs) { sqlite3_stmt *stmt = NULL; char *query = sqlite3_mprintf("SELECT p.id, p.code, p.name, d.name, d.type, d.id, d.code FROM point p LEFT JOIN device d ON p.template_id = d.template_id WHERE p.group_type = ? ORDER BY p.storage_interval ASC"); int ret; ret = sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_free(query); return 1; } // 绑定参数 if (SQLITE_OK != sqlite3_bind_int(stmt, 1, kPoint_SOE)) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定 group_type 失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); return 1; // 返回错误代码 } utarray_new(*faultsDataConfigs, &faults_data_config_icd); while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) { timed_data_config_t data_info = {0}; data_info.pointDbId = sqlite3_column_int(stmt, 0); data_info.pointId = sqlite3_column_int(stmt, 1); snprintf((char *)data_info.pointName, MAX_POINT_NAME_LEN, "%s", (const char *)sqlite3_column_text(stmt, 2)); snprintf((char *)data_info.devName, MAX_NAME_BUF_LEN, "%s", (const char *)sqlite3_column_text(stmt, 3)); data_info.devType = sqlite3_column_int(stmt, 4); data_info.devDbId = sqlite3_column_int(stmt, 5); data_info.devId = sqlite3_column_int(stmt, 6); utarray_push_back(*faultsDataConfigs, &data_info); } if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); sqlite3_free(query); utarray_free(*faultsDataConfigs); *faultsDataConfigs = NULL; return 1; } sqlite3_finalize(stmt); sqlite3_free(query); return 0; } /***************************************************************************** * @brief 从数据库获取EMS设备配置信息 * @param[out] emsDevConfigs: 用于设备配置信息的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_config_db_data(UT_array **emsDevConfigs) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *query; // 查询语句 utarray_new(*emsDevConfigs, &ems_dev_config_icd); // 创建新的 UT_array 用于存储设备点位信息 // 构建查询语句 query = "SELECT id, type, content " "FROM ems_device_config WHERE 1=1 "; // 基础查询语句 // 添加结果排序 query = sqlite3_mprintf("%s ORDER BY type ASC", query); // 按 type 升序排序 // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 执行查询并处理结果 int step = sqlite3_step(stmt); while (SQLITE_ROW == step) // 遍历每一行结果 { // 从数据库中获取每一列的值 ems_dev_config_t dev_config = {0}; // 初始化设备配置结构体 dev_config.dbId = (uint16_t)sqlite3_column_int(stmt, 0); dev_config.type = (ems_dev_config_type_e)sqlite3_column_int(stmt, 1); snprintf((char *)dev_config.content, MAX_CONFIG_CONTENT_LEN, "%s", (const char *)sqlite3_column_text(stmt, 2)); // 将设备配置信息添加到 UT_array 中 utarray_push_back(*emsDevConfigs, &dev_config); // 继续处理下一行 step = sqlite3_step(stmt); } // 检查是否完成所有行的处理 if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 清理资源 sqlite3_finalize(stmt); // 释放预编译语句 return 0; // 成功返回 error: sqlite3_finalize(stmt); // 确保释放预编译语句 utarray_free(*emsDevConfigs); // 释放 UT_array emsDevConfigs = NULL; // 设置为 NULL return 1; // 返回错误代码 } /***************************************************************************** * @brief 根据指定配置类型Type从数据库获取 EMS 设备配置信息 * @param[in] type: 配置类型 * @param[out] emsDevConfig: 用于存储设备配置信息的指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_config_by_type(ems_dev_config_type_e type, ems_dev_config_t *emsDevConfig) { int ret = 0; // 返回代码 sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *query; // 查询语句 // 构建查询语句 query = "SELECT content " "FROM ems_device_config WHERE type = ? LIMIT 1"; // 根据 TYPE 查询 // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); return 1; // 返回错误代码 } if (SQLITE_OK != sqlite3_bind_int(stmt, 1, (int)type)) // 使用 sqlite3_bind_int { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定 `%s` 的参数 type 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); // 确保释放预编译语句 return 1; // 返回错误代码 } // 执行查询并处理结果 int step = sqlite3_step(stmt); if (SQLITE_ROW == step) // 如果找到结果 { // 从数据库中获取每一列的值 snprintf((char *)emsDevConfig->content, MAX_CONFIG_CONTENT_LEN, "%s", (const char *)sqlite3_column_text(stmt, 0)); } else if (SQLITE_DONE == step) // 如果没有找到结果 { KITLOG(LOG_KIT_EN, ERROR_EN, "未找到配置类型 Type 为 %d 的设备配置", type); ret = 1; // 设置返回代码为失败 } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); ret = 1; // 设置返回代码为失败 } // 清理资源 sqlite3_finalize(stmt); // 释放预编译语句 return ret; // 返回结果 } /***************************************************************************** * @brief 根据协议类型获取北向配置信息 * @param[out] northConfigs: 用于存储北向配置信息的数组, 使用 UT_array 存储 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_north_config_arr(UT_array **northConfigs) { int ret = 0; sqlite3_stmt *stmt = NULL; const char *query = "SELECT nc.id, nc.protocol_type, nc.config_type " "FROM north_config nc "; // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) // config_db: 全局数据库连接 { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); KITPTF(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); return 1; } utarray_new(*northConfigs, &north_config_icd); // 创建新的 UT_array 用于北向信息 // 执行查询 int step = sqlite3_step(stmt); while (SQLITE_ROW == step) { north_config_t northConfig = {0}; // 获取北向配置信息 northConfig.dbId = sqlite3_column_int(stmt, 0); northConfig.protocolType = (protocol_type_slave_e)sqlite3_column_int(stmt, 1); northConfig.configType = (north_config_type_e)sqlite3_column_int(stmt, 2); // 获取上报下发配置信息 ret = kit_get_north_config_by_id(sqlite3_column_int(stmt, 0), &northConfig); if (ret != 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "获取上报下发配置信息失败"); goto error; // 处理错误 } // 将北向配置信息添加到 UT_array 中 utarray_push_back(*northConfigs, &northConfig); step = sqlite3_step(stmt); } // 检查是否完成所有行的处理 if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询北向配置信息失败: %s", sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 清理资源 sqlite3_finalize(stmt); return ret; error: // 清理资源 sqlite3_finalize(stmt); utarray_free(*northConfigs); // 释放 UT_array northConfigs = NULL; return 1; // 返回错误代码 } /***************************************************************************** * @brief 获取所有削峰填谷的日期配置 * @param[out] pvDateConfigs: 削峰填谷的日期配置数组, 使用 UT_array 存储 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_pv_date_cfg_db_data(UT_array **pvDateConfigs) { int ret = 0; sqlite3_stmt *stmt = NULL; // SQL 查询语句，获取 pv_date_config 表中的数据 const char *query = "SELECT pdc.pv_time_config_id, pdc.start_date, pdc.end_date " "FROM pv_date_config pdc " "ORDER BY pdc.start_date"; // 创建新的 UT_array 用于存储削峰填谷的日期配置, 使用 pv_date_config_icd 初始化 utarray_new(*pvDateConfigs, &pv_date_config_icd); // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) // global_db: 全局数据库连接 { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); return 1; } // 执行查询并处理结果 int step = sqlite3_step(stmt); // 执行查询 while (SQLITE_ROW == step) // 遍历每一行结果 { // 从数据库中获取每一列的值 pv_date_config_t pv_date_config_info = {0}; // 削峰填谷的日期配置结构体 // 获取开始日期和结束日期 int snprintf_ret1 = snprintf((char *)pv_date_config_info.startDate, sizeof(pv_date_config_info.startDate), "%s", (const char *)sqlite3_column_text(stmt, 1)); int snprintf_ret2 = snprintf((char *)pv_date_config_info.endDate, sizeof(pv_date_config_info.endDate), "%s", (const char *)sqlite3_column_text(stmt, 2)); // 检查 snprintf 是否成功 if (snprintf_ret1 < 0 || snprintf_ret2 < 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "格式化日期失败"); goto error; } // 根据 pv_time_config_id 获取时间配置信息 if (kit_get_pv_time_cfg_db_data(sqlite3_column_int(stmt, 0), &pv_date_config_info) != 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "获取时间配置信息失败"); goto error; } // 将设备点位信息添加到 UT_array 中 utarray_push_back(*pvDateConfigs, &pv_date_config_info); // 继续处理下一行 step = sqlite3_step(stmt); } // 检查是否完成所有行的处理 if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 清理资源 sqlite3_finalize(stmt); // 释放预编译语句 return ret; error: // 处理查询过程中出现的错误 sqlite3_finalize(stmt); // 确保释放预编译语句 utarray_free(*pvDateConfigs); // 释放 UT_array pvDateConfigs = NULL; // 设置为 NULL return 1; // 返回错误代码 } /***************************************************************************** * @brief 根据削峰填谷时间配置的数据库Id获取削峰填谷时间执行配置 * @param[in] pvTimeCfgDbId: 削峰填谷时间配置的数据库Id * @param[out] pvDateConfig: 用于存储削峰填谷的日期配置, 包含一个 pv_time_config_t 类型的数组 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_pv_time_cfg_db_data(int pvDateCfgDbId, pv_date_config_t *pvDateConfig) { int ret = 0; sqlite3_stmt *stmt = NULL; // SQL 查询语句，根据 time_section_config_id 获取 pv_time_exe 表中的数据 char *query = "SELECT pte.start_time, pte.end_time, pte.power " "FROM pv_time_exe pte " "WHERE pte.time_section_config_id = ? " "ORDER BY pte.start_time"; // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) // config_db: 全局数据库连接 { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); return 1; } // 绑定参数 if (SQLITE_OK != sqlite3_bind_int(stmt, 1, pvDateCfgDbId)) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定 pvDateCfgDbId 失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); return 1; // 返回错误代码 } // 执行查询并处理结果 int step = sqlite3_step(stmt); // 执行查询 while (SQLITE_ROW == step) // 遍历每一行结果 { pvDateConfig->timeCfgLen++; // 重新分配内存以存储新的时间配置信息 pv_time_config_t *temp = (pv_time_config_t *)realloc(pvDateConfig->timeCfgTab, pvDateConfig->timeCfgLen * sizeof(pv_time_config_t)); if (temp == NULL) { // 内存分配失败，记录错误信息并返回 KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); ret = 1; goto error; } pvDateConfig->timeCfgTab = temp; // 获取时间配置信息 pvDateConfig->timeCfgTab[pvDateConfig->timeCfgLen - 1].startTime = sqlite3_column_int(stmt, 0); pvDateConfig->timeCfgTab[pvDateConfig->timeCfgLen - 1].endTime = sqlite3_column_int(stmt, 1); // pvDateConfig->timeCfgTab[pvDateConfig->timeCfgLen - 1].workMode = sqlite3_column_int(stmt, 2); pvDateConfig->timeCfgTab[pvDateConfig->timeCfgLen - 1].power = sqlite3_column_double(stmt, 2); step = sqlite3_step(stmt); } // 检查查询是否完成 if (step != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询削峰填谷时间配置执行信息失败: %s", sqlite3_errmsg(config_db)); ret = 1; } error: // 清理资源 sqlite3_finalize(stmt); return ret; } /***************************************************************************** * @brief 设置所有削峰填谷的日期配置 * @param[out] pvDateTimeConfigs: 削峰填谷的日期配置、时间配置数组, 使用 UT_array 存储 * @return 0-成功 1-失败 *****************************************************************************/ int kit_set_pv_date_time_cfg(UT_array **pvDateTimeConfigs) { int ret = 0; sqlite3_stmt* stmt_date = NULL, * stmt_time = NULL, * stmt_exe = NULL; // SQL 删除语句，删除 pv_date_config 表中的数据 const char* sql_delete_date = "DELETE FROM pv_date_config"; // SQL 查询语句，删除 pv_time_config 表中的数据 const char* sql_delete_time = "DELETE FROM pv_time_config"; // SQL 查询语句，删除 pv_time_exe 表中的数据 const char* sql_delete_exe = "DELETE FROM pv_time_exe"; // SQL 插入语句，插入 pv_date_config 表中的数据 const char* sql_insert_date = "INSERT INTO pv_date_config(pv_time_config_id, start_date, end_date, remark) VALUES (?, ?, ?, ?)"; // SQL 插入语句，插入 pv_time_config 表中的数据 const char* sql_insert_time = "INSERT INTO pv_time_config(name, remark) VALUES (?, ?)"; // SQL 插入语句，插入 pv_time_exe 表中的数据 const char* sql_insert_exe = "INSERT INTO pv_time_exe(time_section_config_id, start_time, end_time, power, remark) VALUES (?, ?, ?, ?,?)"; pthread_mutex_lock(&config_db_mutex); // 开始事务 ret = sqlite3_exec(config_db, "BEGIN TRANSACTION", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "开启事务失败: %s", sqlite3_errmsg(config_db)); goto cleanup; } // 清空表数据 if (sqlite3_exec(config_db, sql_delete_date, NULL, NULL, NULL) != SQLITE_OK || sqlite3_exec(config_db, sql_delete_time, NULL, NULL, NULL) != SQLITE_OK || sqlite3_exec(config_db, sql_delete_exe, NULL, NULL, NULL) != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "清空表失败: %s", sqlite3_errmsg(config_db)); goto cleanup; } // 准备插入语句 if (sqlite3_prepare_v2(config_db, sql_insert_date, -1, &stmt_date, NULL) != SQLITE_OK || sqlite3_prepare_v2(config_db, sql_insert_time, -1, &stmt_time, NULL) != SQLITE_OK || sqlite3_prepare_v2(config_db, sql_insert_exe, -1, &stmt_exe, NULL) != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "预编译插入语句失败: %s", sqlite3_errmsg(config_db)); goto cleanup; } // 遍历需要插入的数据 utarray_foreach(*pvDateTimeConfigs, pv_date_config_t *, p_pvDateConfig) { char timeConfigName[50]; // 存储时间配置名称 snprintf(timeConfigName, sizeof(timeConfigName), "%s-%s", p_pvDateConfig->startDate, p_pvDateConfig->endDate); // 插入 pv_time_config sqlite3_bind_text(stmt_time, 1, timeConfigName, -1, SQLITE_STATIC); if (sqlite3_step(stmt_time) != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入 pv_time_config 表失败: %s", sqlite3_errmsg(config_db)); goto cleanup; } long long timeConfigId = sqlite3_last_insert_rowid(config_db); // 获取最后插入行的 ID sqlite3_reset(stmt_time); // 插入 pv_time_exe for (int i = 0; i < p_pvDateConfig->timeCfgLen; i++) { sqlite3_bind_int64(stmt_exe, 1, timeConfigId); sqlite3_bind_int(stmt_exe, 2, p_pvDateConfig->timeCfgTab[i].startTime); sqlite3_bind_int(stmt_exe, 3, p_pvDateConfig->timeCfgTab[i].endTime); sqlite3_bind_double(stmt_exe, 4, p_pvDateConfig->timeCfgTab[i].power); if (sqlite3_step(stmt_exe) != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入 pv_time_exe 表失败: %s", sqlite3_errmsg(config_db)); goto cleanup; } sqlite3_reset(stmt_exe); } // 插入 pv_date_config sqlite3_bind_int64(stmt_date, 1, timeConfigId); sqlite3_bind_text(stmt_date, 2, (const char *)p_pvDateConfig->startDate, -1, SQLITE_STATIC); sqlite3_bind_text(stmt_date, 3, (const char *)p_pvDateConfig->endDate, -1, SQLITE_STATIC); if (sqlite3_step(stmt_date) != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入 pv_date_config 表失败: %s", sqlite3_errmsg(config_db)); goto cleanup; } sqlite3_reset(stmt_date); } // 提交事务 if (sqlite3_exec(config_db, "COMMIT TRANSACTION", NULL, NULL, NULL) != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(config_db)); goto cleanup; } ret = 0; // 成功 cleanup: if (ret != 0) { // 回滚事务 sqlite3_exec(config_db, "ROLLBACK TRANSACTION", NULL, NULL, NULL); } // 释放资源 sqlite3_finalize(stmt_date); sqlite3_finalize(stmt_time); sqlite3_finalize(stmt_exe); pthread_mutex_unlock(&config_db_mutex); // 释放 UT_array 资源 if (ret != 0) { utarray_free(*pvDateTimeConfigs); *pvDateTimeConfigs = NULL; } return ret; } /***************************************************************************** * @brief 从数据库获取EMS拓扑结构信息 * @param[out] topologys: 用于存储ems拓扑信息结构体的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_topology_db_data(UT_array **topologies) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *query; // 查询语句 query = "SELECT tpy.id, tpy.parent_id, tpy.menu_tree, tpy.sort_order, " "CASE " " WHEN tpy.menu_tree = 0 THEN tpy.name " " WHEN tpy.menu_tree = 1 THEN dev.name ELSE NULL " "END AS name, " "CASE " " WHEN tpy.menu_tree = 0 THEN NULL " " WHEN tpy.menu_tree = 1 THEN dev.sn ELSE NULL " "END AS sn, " "CASE " " WHEN tpy.menu_tree = 0 THEN NULL " " WHEN tpy.menu_tree = 1 THEN dev.type ELSE NULL " "END AS dev_type " "FROM " "topology tpy " "LEFT JOIN device dev ON tpy.dev_id = dev.id"; utarray_new(*topologies, &topology_icd); // 创建新的 UT_array 用于存储ems拓扑信息 // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); // 确保释放预编译语句 return 1; // 返回错误代码 } // 执行查询并处理结果 int step = sqlite3_step(stmt); while (SQLITE_ROW == step) // 遍历每一行结果 { // 从数据库中获取每一列的值 topology_t topology_info = {0}; // 初始化拓扑结构的结构体 topology_info.dbId = sqlite3_column_int(stmt, 0); if (sqlite3_column_type(stmt, 1) == SQLITE_NULL) { topology_info.parentId = -999; } else { topology_info.parentId = sqlite3_column_int(stmt, 1); } topology_info.menuTree = (menu_tree_e)sqlite3_column_int(stmt, 2); topology_info.sortOrder = sqlite3_column_int(stmt, 3); const char *name = (const char *)sqlite3_column_text(stmt, 4); snprintf((char *)topology_info.name, MAX_NAME_BUF_LEN, "%s", name ? name : ""); const char *sn = (const char *)sqlite3_column_text(stmt, 5); snprintf((char *)topology_info.sn, MAX_CODE_BUF_LEN, "%s", sn ? sn : ""); topology_info.devType = (dev_type_e)sqlite3_column_int(stmt, 6); // 将设备点位信息添加到 UT_array 中 utarray_push_back(*topologies, &topology_info); // 继续处理下一行 step = sqlite3_step(stmt); } // 检查是否完成所有行的处理 if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 清理资源 sqlite3_finalize(stmt); // 释放预编译语句 return 0; // 成功返回 error: sqlite3_finalize(stmt); // 确保释放预编译语句 utarray_free(*topologies); // 释放 UT_array topologies = NULL; // 设置为 NULL return 1; // 返回错误代码 } /***************************************************************************** * @brief 从数据库里获取保护算法的控制参数 * @param[in] p_protectAlgo：保护算法结构体指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_protect_algorithm(protect_algorithm_t *p_protectAlgo) { sqlite3_stmt *stmt = NULL; char *query = "SELECT transformer_capacity, ol_warn_limit_value, ol_shutdown_value, " "max_power, demand_switch, target_demand, de_warn_limit_value, " "de_shutdown_value, backflow_switch, bf_warn_limit_value, " "bf_shutdown_value, soc_forbid_chg, soc_forbid_dischg, " "id " "FROM protect_algorithm " "ORDER BY id DESC " "LIMIT 1"; if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); return 1; // 返回错误代码 } int step = sqlite3_step(stmt); if (SQLITE_ROW == step) { p_protectAlgo->transCapacity = sqlite3_column_double(stmt, 0); // 变压器总容量(KW) p_protectAlgo->olWarnLimitVal = sqlite3_column_double(stmt, 1); // 过载预警限流值(KW) p_protectAlgo->olShutdownVal = sqlite3_column_double(stmt, 2); // 过载关机值(KW) p_protectAlgo->maxPower = sqlite3_column_double(stmt, 3); // 充放电功率上限(KW) p_protectAlgo->demandSwitch = sqlite3_column_int(stmt, 4); // 防需量开关 p_protectAlgo->targetDemand = sqlite3_column_double(stmt, 5); // 目标需量 p_protectAlgo->deWarnLimitVal = sqlite3_column_double(stmt, 6); // 需量预警限流值(KW) p_protectAlgo->deShutdownVal = sqlite3_column_double(stmt, 7); // 需量关机值(KW) p_protectAlgo->backflowSwitch = sqlite3_column_int(stmt, 8); // 防逆流开关 p_protectAlgo->bfWarnLimitVal = sqlite3_column_double(stmt, 9); // 防逆流预警限流值(KW) p_protectAlgo->bfShutdownVal = sqlite3_column_double(stmt, 10); // 防逆流关机值(KW) p_protectAlgo->socForbidChg = sqlite3_column_int(stmt, 11); // 禁充SOC [55%-100%] p_protectAlgo->socForbidDischg = sqlite3_column_int(stmt, 12); // 禁放SOC [0%-45%] p_protectAlgo->dbId = sqlite3_column_int(stmt, 13); // 数据库Id } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败或者无数据，错误码: %d, 错误信息: %s", step, sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); return 1; // 返回错误代码 } sqlite3_finalize(stmt); return 0; // 返回成功代码 } /***************************************************************************** * @brief 更新数据库的保护算法数据 * @param[in] p_protectAlgo：保护算法结构体指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_set_protect_algorithm(protect_algorithm_t *p_protectAlgo) { int ret = 0; sqlite3_stmt *stmt = NULL; char *sql = sqlite3_mprintf( "UPDATE protect_algorithm SET transformer_capacity = ?, ol_warn_limit_value = ?, ol_shutdown_value = ?, " "max_power = ?, demand_switch = ?, target_demand = ?, de_warn_limit_value = ?, " "de_shutdown_value = ?, backflow_switch = ?, bf_warn_limit_value = ?, " "bf_shutdown_value = ?, soc_forbid_chg = ?, soc_forbid_dischg = ? WHERE id = ?"); if (SQLITE_OK != sqlite3_prepare_v2(config_db, sql, -1, &stmt, NULL)) { fprintf(stderr, "SQL语句预编译失败: %s\n", sqlite3_errmsg(config_db)); sqlite3_free(sql); return 1; } sqlite3_bind_double(stmt, 1, p_protectAlgo->transCapacity); sqlite3_bind_double(stmt, 2, p_protectAlgo->olWarnLimitVal); sqlite3_bind_double(stmt, 3, p_protectAlgo->olShutdownVal); sqlite3_bind_double(stmt, 4, p_protectAlgo->maxPower); sqlite3_bind_int(stmt, 5, p_protectAlgo->demandSwitch); sqlite3_bind_double(stmt, 6, p_protectAlgo->targetDemand); sqlite3_bind_double(stmt, 7, p_protectAlgo->deWarnLimitVal); sqlite3_bind_double(stmt, 8, p_protectAlgo->deShutdownVal); sqlite3_bind_int(stmt, 9, p_protectAlgo->backflowSwitch); sqlite3_bind_double(stmt, 10, p_protectAlgo->bfWarnLimitVal); sqlite3_bind_double(stmt, 11, p_protectAlgo->bfShutdownVal); sqlite3_bind_int(stmt, 12, p_protectAlgo->socForbidChg); sqlite3_bind_int(stmt, 13, p_protectAlgo->socForbidDischg); sqlite3_bind_int(stmt, 14, p_protectAlgo->dbId); pthread_mutex_lock(&config_db_mutex); int step = sqlite3_step(stmt); if (step != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句执行失败"); if (step == SQLITE_ERROR) { KITLOG(LOG_KIT_EN, ERROR_EN, "%s", sqlite3_errmsg(config_db)); } else { KITLOG(LOG_KIT_EN, ERROR_EN, "错误代码: %d", step); } ret = 1; goto cleanup; } if (sqlite3_changes(config_db) == 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "没有更新任何行。请检查 dbId 是否正确"); ret = 1; goto cleanup; } cleanup: pthread_mutex_unlock(&config_db_mutex); sqlite3_finalize(stmt); sqlite3_free(sql); return ret; } /***************************************************************************** * @brief 从数据库里获取调试模式算法的控制参数 * @param[in] p_debugAlgo：调试模式算法结构体指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_debug_algorithm(debug_algorithm_t *p_debugAlgo) { sqlite3_stmt *stmt = NULL; char *query = "SELECT active_power, reactive_power, pcs_switch, id, protect_switch " "FROM debug_algorithm " "ORDER BY id DESC " "LIMIT 1"; if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); return 1; // 返回错误代码 } int step = sqlite3_step(stmt); if (SQLITE_ROW == step) { p_debugAlgo->activePower = sqlite3_column_double(stmt, 0); // 目标有功功率(KW) p_debugAlgo->reactivePower = sqlite3_column_double(stmt, 1); // 目标无功功率(KW) p_debugAlgo->pcsSwitch = sqlite3_column_int(stmt, 2); // 充放电开关 p_debugAlgo->dbId = sqlite3_column_int(stmt, 3); // 数据库Id p_debugAlgo->protectSwitch = sqlite3_column_int(stmt, 4); // 保护算法开关 } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败，错误码: %d, 错误信息: %s", step, sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); return 1; // 返回错误代码 } sqlite3_finalize(stmt); return 0; // 返回成功代码 } /***************************************************************************** * @brief 更新数据库的调试模式算法数据 * @param[in] p_debugAlgo：调试模式算法结构体指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_set_debug_algorithm(debug_algorithm_t *p_debugAlgo) { int ret = 0; sqlite3_stmt *stmt = NULL; const char *sql = sqlite3_mprintf("UPDATE debug_algorithm SET active_power = ?, reactive_power = ?, pcs_switch = ?, protect_switch = ? WHERE id = ? "); if (SQLITE_OK != sqlite3_prepare_v2(config_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句预编译失败: %s", sqlite3_errmsg(config_db)); return 1; } sqlite3_bind_double(stmt, 1, p_debugAlgo->activePower); sqlite3_bind_double(stmt, 2, p_debugAlgo->reactivePower); sqlite3_bind_int(stmt, 3, p_debugAlgo->pcsSwitch); sqlite3_bind_int(stmt, 4, p_debugAlgo->protectSwitch); sqlite3_bind_int(stmt, 5, p_debugAlgo->dbId); pthread_mutex_lock(&config_db_mutex); // 加锁，确保单线程访问 int step = sqlite3_step(stmt); if (step != SQLITE_DONE) { if (step == SQLITE_ERROR) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句执行失败: %s", sqlite3_errmsg(config_db)); } else if (step == SQLITE_ROW) { KITLOG(LOG_KIT_EN, ERROR_EN, "UPDATE操作中出现意外的SQLITE_ROW返回值"); } else { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL更新失败，错误代码: %d", step); } pthread_mutex_unlock(&config_db_mutex); // 解锁 sqlite3_finalize(stmt); return 1; } // 检查是否实际更新了任何行。SQLITE_DONE 并不保证这一点。 if (sqlite3_changes(config_db) == 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "没有更新任何行。请检查 dbId 是否正确。"); pthread_mutex_unlock(&config_db_mutex); // 解锁 return 1; } pthread_mutex_unlock(&config_db_mutex); // 解锁 sqlite3_finalize(stmt); return ret; } /***************************************************************************** * @brief 从数据库查询功率分配数据 * @param[in] p_allocatePower：功率分配的指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_allocate_power(allocate_power_t *p_allocatePower) { sqlite3_stmt *stmt = NULL; char *query = sqlite3_mprintf("SELECT pcs_num, chg_direction, id, allocate_mode FROM allocate_power ORDER BY id DESC LIMIT 1"); if (query == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); return 1; } if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_free(query); return 1; // 返回错误代码 } int step = sqlite3_step(stmt); if (step == SQLITE_ROW) { p_allocatePower->pcsNum = sqlite3_column_int(stmt, 0); // pcs数量 p_allocatePower->chgDirection = sqlite3_column_int(stmt, 1); // 充放电方向：1(正放 负充) -1(正充 负放) p_allocatePower->dbId = sqlite3_column_int(stmt, 2); // 数据库Id p_allocatePower->allocateMode = sqlite3_column_int(stmt, 3); // 下发功率开关：总功率（0），分相功率（1） } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败或者无数据，错误码: %d, 错误信息: %s", step, sqlite3_errmsg(config_db)); } sqlite3_finalize(stmt); sqlite3_free(query); return (step == SQLITE_ROW) ? 0 : 1; // 返回成功或失败代码 } /***************************************************************************** * @brief 更新数据库的功率分配数据 * @param[in] p_allocatePower：功率分配的指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_set_allocate_power(allocate_power_t *p_allocatePower) { int ret = 0; sqlite3_stmt *stmt = NULL; const char *sql = sqlite3_mprintf("UPDATE allocate_power SET pcs_num = ?, chg_direction = ?, allocate_mode = ? WHERE id = ? "); if (SQLITE_OK != sqlite3_prepare_v2(config_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句预编译失败: %s", sqlite3_errmsg(config_db)); return 1; } sqlite3_bind_int(stmt, 1, p_allocatePower->pcsNum); sqlite3_bind_int(stmt, 2, p_allocatePower->chgDirection); sqlite3_bind_int(stmt, 3, p_allocatePower->allocateMode); sqlite3_bind_int(stmt, 4, p_allocatePower->dbId); pthread_mutex_lock(&config_db_mutex); // 加锁，确保单线程访问 int step = sqlite3_step(stmt); if (step != SQLITE_DONE) { if (step == SQLITE_ERROR) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句执行失败: %s", sqlite3_errmsg(config_db)); } else if (step == SQLITE_ROW) { KITLOG(LOG_KIT_EN, ERROR_EN, "UPDATE操作中出现意外的SQLITE_ROW返回值"); } else { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL更新失败，错误代码: %d", step); } pthread_mutex_unlock(&config_db_mutex); // 解锁 sqlite3_finalize(stmt); return 1; } // 检查是否实际更新了任何行。SQLITE_DONE 并不保证这一点。 if (sqlite3_changes(config_db) == 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "没有更新任何行。请检查 dbId 是否正确。"); pthread_mutex_unlock(&config_db_mutex); // 解锁 return 1; } pthread_mutex_unlock(&config_db_mutex); // 解锁 sqlite3_finalize(stmt); return ret; } /***************************************************************************** * @brief 从数据库查询工作模式数据 * @param[in] p_workModeSet：工作模式的指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_work_mode_set(work_mode_set_t *p_workModeSet) { sqlite3_stmt *stmt = NULL; char *query = sqlite3_mprintf("SELECT work_mode, id FROM work_mode_set DESC LIMIT 1"); if (query == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); return 1; } if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_free(query); return 1; // 返回错误代码 } int step = sqlite3_step(stmt); if (step == SQLITE_ROW) { p_workModeSet->workMode = (work_mode_e)sqlite3_column_int(stmt, 0); // 工作模式 p_workModeSet->dbId = sqlite3_column_int(stmt, 1); // 数据库Id } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败，错误码: %d, 错误信息: %s", step, sqlite3_errmsg(config_db)); } sqlite3_finalize(stmt); sqlite3_free(query); return (step == SQLITE_ROW) ? 0 : 1; // 返回成功或失败代码 } /***************************************************************************** * @brief 更新数据库的工作模式数据 * @param[in] p_workModeSet：工作模式的指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_set_work_mode(work_mode_set_t *p_workModeSet) { int ret = 0; sqlite3_stmt *stmt = NULL; const char *sql = sqlite3_mprintf("UPDATE work_mode_set SET work_mode = ? WHERE id = ? "); if (SQLITE_OK != sqlite3_prepare_v2(config_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句预编译失败: %s", sqlite3_errmsg(config_db)); return 1; } sqlite3_bind_int(stmt, 1, (uint8_t)p_workModeSet->workMode); sqlite3_bind_int(stmt, 2, p_workModeSet->dbId); pthread_mutex_lock(&config_db_mutex); // 加锁，确保单线程访问 int step = sqlite3_step(stmt); if (step != SQLITE_DONE) { if (step == SQLITE_ERROR) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句执行失败: %s", sqlite3_errmsg(config_db)); } else if (step == SQLITE_ROW) { KITLOG(LOG_KIT_EN, ERROR_EN, "UPDATE操作中出现意外的SQLITE_ROW返回值"); } else { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL更新失败，错误代码: %d", step); } pthread_mutex_unlock(&config_db_mutex); // 解锁 sqlite3_finalize(stmt); return 1; } // 检查是否实际更新了任何行。SQLITE_DONE 并不保证这一点。 if (sqlite3_changes(config_db) == 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "没有更新任何行。请检查 dbId 是否正确。"); pthread_mutex_unlock(&config_db_mutex); // 解锁 return 1; } pthread_mutex_unlock(&config_db_mutex); // 解锁 sqlite3_finalize(stmt); return ret; } /***************************************************************************** * @brief 从数据库查询DIDO逻辑设置数据 * @param[in] diDoSets：DIDO逻辑设置结构体的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_di_do_set_arr(UT_array **diDoSets) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *query; // 查询语句 query = "SELECT seq, type, cabinet_code, strategy_seq " "FROM di_do_set "; // 准备 SQL 语句 if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); return 1; } utarray_new(*diDoSets, &di_do_logic_set_icd); // 创建新的 UT_array 用于存储DIDO逻辑设置信息 // 执行查询并处理结果 int step = sqlite3_step(stmt); while (SQLITE_ROW == step) // 遍历每一行结果 { // 从数据库中获取每一列的值 di_do_logic_set_t di_do_set_logic_info = {0}; // 初始化DIDO逻辑设置的结构体 di_do_set_logic_info.dIDOseq = sqlite3_column_int(stmt, 0); di_do_set_logic_info.dIDOType = (di_do_type_e)sqlite3_column_int(stmt, 1); di_do_set_logic_info.cabinetCode = sqlite3_column_int(stmt, 2); if (di_do_set_logic_info.dIDOType == kDi) { di_do_set_logic_info.strategySeqDi = (diFuc_e)sqlite3_column_int(stmt, 3); } else { di_do_set_logic_info.strategySeqDo = (doFuc_e)sqlite3_column_int(stmt, 3); } // 将DIDO逻辑设置添加到 UT_array 中 utarray_push_back(*diDoSets, &di_do_set_logic_info); // 继续处理下一行 step = sqlite3_step(stmt); } // 检查是否完成所有行的处理 if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询未完成，错误信息: %s", sqlite3_errmsg(config_db)); goto error; // 处理错误 } // 清理资源 sqlite3_finalize(stmt); // 释放预编译语句 return 0; // 成功返回 error: sqlite3_finalize(stmt); // 确保释放预编译语句 utarray_free(*diDoSets); // 释放 UT_array diDoSets = NULL; // 设置为 NULL return 1; // 返回错误代码 } /***************************************************************************** * @brief 从数据库里获取温控算法的控制参数 * @param[in] p_tempCtrlAlgo：温控算法结构体指针 * @return 0-成功，非0-失败（具体错误码可通过日志或其他机制获取） *****************************************************************************/ int kit_get_temp_ctrl_algorithm(temp_ctrl_algorithm_t *p_tempCtrlAlgo) { int ret = 0; sqlite3_stmt *stmt = NULL; if (p_tempCtrlAlgo == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "传入的结构体指针为空"); return 1; // 返回错误代码 } char *query = "SELECT mod, work_cool_trig_temp, work_cool_hys, " "work_heat_trig_temp, work_heat_hys, standby_cool_trig_temp, " "standby_cool_hys, standby_heat_trig_temp, standby_heat_hys, " "standby_max_limit, standby_min_limit, standby_maxback_limit, " "standby_minback_limit, temp_cmd_normal, temp_cmd_heat, temp_cmd_cold, " "temp_cmd_open, temp_cmd_close, id " "FROM temp_ctrl_algorithm " "ORDER BY id DESC " "LIMIT 1"; int rc = sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL); if (rc != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); ret = rc; // 记录sqlite3的错误码 goto cleanup; } int step = sqlite3_step(stmt); if (step == SQLITE_ROW) { p_tempCtrlAlgo->mod = (temperature_ctrl_mod_e)sqlite3_column_int(stmt, 0); p_tempCtrlAlgo->workCoolTrigTemp = (float)sqlite3_column_double(stmt, 1); p_tempCtrlAlgo->workCoolHys = (float)sqlite3_column_double(stmt, 2); p_tempCtrlAlgo->workHeatTrigTemp = (float)sqlite3_column_double(stmt, 3); p_tempCtrlAlgo->workHeatHys = (float)sqlite3_column_double(stmt, 4); p_tempCtrlAlgo->standbyCoolTrigTemp = (float)sqlite3_column_double(stmt, 5); p_tempCtrlAlgo->standbyCoolHys = (float)sqlite3_column_double(stmt, 6); p_tempCtrlAlgo->standbyHeatTrigTemp = (float)sqlite3_column_double(stmt, 7); p_tempCtrlAlgo->standbyHeatHys = (float)sqlite3_column_double(stmt, 8); p_tempCtrlAlgo->standbyMaxLimit = (float)sqlite3_column_double(stmt, 9); p_tempCtrlAlgo->standbyMinLimit = (float)sqlite3_column_double(stmt, 10); p_tempCtrlAlgo->standbyMaxbackLimit = (float)sqlite3_column_double(stmt, 11); p_tempCtrlAlgo->standbyMinbackLimit = (float)sqlite3_column_double(stmt, 12); p_tempCtrlAlgo->tempCmdNormal = sqlite3_column_int(stmt, 13); p_tempCtrlAlgo->tempCmdHeat = sqlite3_column_int(stmt, 14); p_tempCtrlAlgo->tempCmdCold = sqlite3_column_int(stmt, 15); p_tempCtrlAlgo->tempCmdOpen = sqlite3_column_int(stmt, 16); p_tempCtrlAlgo->tempCmdClose = sqlite3_column_int(stmt, 17); p_tempCtrlAlgo->dbId = sqlite3_column_int64(stmt, 18); } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败，错误码: %d, 错误信息: %s", step, sqlite3_errmsg(config_db)); ret = step; // 记录sqlite3的错误码 } cleanup: sqlite3_finalize(stmt); return ret; } /***************************************************************************** * @brief 更新数据库的温控算法数据 * @param[in] p_tempCtrlAlgo：温控算法结构体指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_set_temp_ctrl_algorithm(temp_ctrl_algorithm_t *p_tempCtrlAlgo) { int ret = 0; sqlite3_stmt *stmt = NULL; // 使用互斥锁保护数据库访问，防止多线程竞争 pthread_mutex_lock(&config_db_mutex); // SQL语句，使用占位符防止SQL注入，并根据实际情况选择合适的更新策略 (UPDATE or INSERT) char *query = "UPDATE temp_ctrl_algorithm SET mod = ?, work_cool_trig_temp = ?, work_cool_hys = ?, " "work_heat_trig_temp = ?, work_heat_hys = ?, standby_cool_trig_temp = ?, " "standby_cool_hys = ?, standby_heat_trig_temp = ?, standby_heat_hys = ?, " "standby_max_limit = ?, standby_min_limit = ?, standby_maxback_limit = ?, " "standby_minback_limit = ?, temp_cmd_normal = ?, temp_cmd_heat = ?, temp_cmd_cold = ?, " "temp_cmd_open = ?, temp_cmd_close = ? " "WHERE id = ?;"; // 更新最新的记录 // 准备SQL语句 int rc = sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL); if (rc != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备SQL语句失败: %s", sqlite3_errmsg(config_db)); ret = 1; goto unlock_and_return; } // 绑定参数 ret = sqlite3_bind_int(stmt, 1, p_tempCtrlAlgo->mod); // 温度控制模式 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 2, p_tempCtrlAlgo->workCoolTrigTemp); // 制冷触发温度 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 3, p_tempCtrlAlgo->workCoolHys); // 制冷回差 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 4, p_tempCtrlAlgo->workHeatTrigTemp); // 制热触发温度 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 5, p_tempCtrlAlgo->workHeatHys); // 制热回差 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 6, p_tempCtrlAlgo->standbyCoolTrigTemp); // 制冷触发温度 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 7, p_tempCtrlAlgo->standbyCoolHys); // 制冷回差 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 8, p_tempCtrlAlgo->standbyHeatTrigTemp); // 制热触发温度 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 9, p_tempCtrlAlgo->standbyHeatHys); // 制热回差 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 10, p_tempCtrlAlgo->standbyMaxLimit); // 开启自循环高温 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 11, p_tempCtrlAlgo->standbyMinLimit); // 开启自循环低温 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 12, p_tempCtrlAlgo->standbyMaxbackLimit); // 自循环高温回温 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_double(stmt, 13, p_tempCtrlAlgo->standbyMinbackLimit); // 自循环低温回温 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_int(stmt, 14, p_tempCtrlAlgo->tempCmdNormal); // 循环控制字 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_int(stmt, 15, p_tempCtrlAlgo->tempCmdHeat); // 制热控制字 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_int(stmt, 16, p_tempCtrlAlgo->tempCmdCold); // 制冷控制字 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_int(stmt, 17, p_tempCtrlAlgo->tempCmdOpen); // 开控制字 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_int(stmt, 18, p_tempCtrlAlgo->tempCmdClose); // 关控制字 if (ret != SQLITE_OK) goto error; ret = sqlite3_bind_int64(stmt, 19, p_tempCtrlAlgo->dbId); // 数据库Id if (ret != SQLITE_OK) goto error; // 执行SQL语句 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "执行SQL语句失败: %s", sqlite3_errmsg(config_db)); goto error; } // 检查是否实际更新了任何行 if (sqlite3_changes(config_db) == 0) { KITLOG(LOG_KIT_EN, WARN_EN, "没有更新任何行。请检查数据是否存在。"); ret = 1; } sqlite3_finalize(stmt); goto unlock_and_return; error: sqlite3_finalize(stmt); ret = 1; unlock_and_return: pthread_mutex_unlock(&config_db_mutex); // 解锁 return ret; } /***************************************************************************** * @brief 从数据库获取高级设置 * @param[out] advancedSettings: 用于存储高级设置的数据 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_advanced_setting(UT_array **advancedSettings) { sqlite3_stmt *stmt = NULL; char *query = sqlite3_mprintf("SELECT key, value FROM advanced_setting ORDER BY key ASC"); int ret; ret = sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_free(query); return 1; } utarray_new(*advancedSettings, &advanced_setting_icd); while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) { advanced_setting_t setting_info = {0}; snprintf((char *)setting_info.key, MAX_KEY_LEN, "%s", (const char *)sqlite3_column_text(stmt, 0)); snprintf((char *)setting_info.value, MAX_VALUE_LEN, "%s", (const char *)sqlite3_column_text(stmt, 1)); utarray_push_back(*advancedSettings, &setting_info); } if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败: %s", sqlite3_errmsg(config_db)); sqlite3_finalize(stmt); sqlite3_free(query); utarray_free(*advancedSettings); *advancedSettings = NULL; return 1; } sqlite3_finalize(stmt); sqlite3_free(query); return 0; } /***************************************************************************** * @brief 从数据库查询升级记录数据 * @param[in] p_upgradeRecord：升级记录的指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_get_upgrade_record(upgrade_record_t *p_upgradeRecord) { sqlite3_stmt *stmt = NULL; char *query = sqlite3_mprintf("SELECT id, path FROM upgrade_record Where status = 0 LIMIT 1"); if (query == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); return 1; } if (SQLITE_OK != sqlite3_prepare_v2(config_db, query, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "准备查询 `%s` 失败: %s", query, sqlite3_errmsg(config_db)); sqlite3_free(query); return 1; // 返回错误代码 } int step = sqlite3_step(stmt); if (step == SQLITE_ROW) { p_upgradeRecord->dbId = sqlite3_column_int(stmt, 0); // 数据库Id snprintf((char *)p_upgradeRecord->path, MAX_UPGRADE_PATH_LEN, "%s", sqlite3_column_text(stmt, 1)); // 升级包文件路径 } else { KITLOG(LOG_KIT_EN, ERROR_EN, "查询失败，错误码: %d, 错误信息: %s", step, sqlite3_errmsg(config_db)); } sqlite3_finalize(stmt); sqlite3_free(query); return (step == SQLITE_ROW) ? 0 : 1; // 返回成功或失败代码 } /***************************************************************************** * @brief 更新数据库的升级记录数据 * @param[in] p_upgradeRecord：升级记录的指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_update_upgrade_record(upgrade_record_t *p_upgradeRecord) { int ret = 0; sqlite3_stmt *stmt = NULL; const char *sql = sqlite3_mprintf("UPDATE upgrade_record SET status = ?, err_msg = ? WHERE id = ? "); if (SQLITE_OK != sqlite3_prepare_v2(config_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句预编译失败: %s", sqlite3_errmsg(config_db)); return 1; } sqlite3_bind_int(stmt, 1, (uint8_t)p_upgradeRecord->status); sqlite3_bind_text(stmt, 2, (const char *)p_upgradeRecord->errMsg, -1, SQLITE_STATIC); sqlite3_bind_int(stmt, 3, p_upgradeRecord->dbId); pthread_mutex_lock(&config_db_mutex); // 加锁，确保单线程访问 int step = sqlite3_step(stmt); if (step != SQLITE_DONE) { if (step == SQLITE_ERROR) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句执行失败: %s", sqlite3_errmsg(config_db)); } else if (step == SQLITE_ROW) { KITLOG(LOG_KIT_EN, ERROR_EN, "UPDATE操作中出现意外的SQLITE_ROW返回值"); } else { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL更新失败，错误代码: %d", step); } pthread_mutex_unlock(&config_db_mutex); // 解锁 sqlite3_finalize(stmt); return 1; } // 检查是否实际更新了任何行。SQLITE_DONE 并不保证这一点。 if (sqlite3_changes(config_db) == 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "没有更新任何行。请检查 dbId 是否正确。"); pthread_mutex_unlock(&config_db_mutex); // 解锁 return 1; } pthread_mutex_unlock(&config_db_mutex); // 解锁 sqlite3_finalize(stmt); return ret; } /* ############################################################################### 业务数据库操作 ############################################################################### */ /***************************************************************************** * @brief 批量插入时序数据存储 * @param[in] timedDatas: 用于存储备份数据的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_insert_timed_data(UT_array *timedDatas) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *sql = "INSERT INTO timed_data_storage (dev_type, dev_id, point_id, timed_value, storage_interval, created_time) VALUES (?, ?, ?, ?, ?, strftime('%Y-%m-%d %H:%M:%S', 'now'))"; int ret = 0; int total_count = utarray_len(timedDatas); // 总记录数 int batch_size = 100; // 每批插入的条数 int i; pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法开始事务: %s", sqlite3_errmsg(business_db)); return 1; } // 预编译SQL语句 ret = sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL预编译失败: %s", sqlite3_errmsg(business_db)); return 1; } // 批量插入 for (i = 0; i < total_count; i++) { timed_data_storage_t *timedData = (timed_data_storage_t *)utarray_eltptr(timedDatas, i); // 绑定参数 sqlite3_bind_int(stmt, 1, timedData->devType); sqlite3_bind_int(stmt, 2, timedData->devDbId); sqlite3_bind_int(stmt, 3, timedData->pointDbId); // sqlite3_bind_text(stmt, 4, (const char *)timedData->devName, -1, SQLITE_STATIC); // sqlite3_bind_text(stmt, 5, (const char *)timedData->pointName, -1, SQLITE_STATIC); sqlite3_bind_double(stmt, 4, timedData->timedValue); sqlite3_bind_int(stmt, 5, timedData->storageInterval); // 执行插入 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入数据失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 重置语句，以便下次使用 sqlite3_reset(stmt); // 每 batch_size 条记录提交一次事务 if ((i + 1) % batch_size == 0) { ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 重新开始事务 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法重新开始事务: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } } } // 提交剩余数据 ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); pthread_mutex_unlock(&business_db_mutex); // 解锁 if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 释放预编译语句 sqlite3_finalize(stmt); utarray_free(timedDatas); return 0; // 成功 } /***************************************************************************** * @brief 根据日期时间条件，删除该日期时间之前timed_data_storage的数据 * @param[in] storage_interval：存储周期 * @param[in] date_time_string：日期时间 * @return 0-成功 1-失败 *****************************************************************************/ int kit_del_timed_data_by_date(int storage_interval, const char *date_time_string) { sqlite3_stmt *stmt = NULL; // SQLite语句句柄 int ret = 0; // 返回值 char sql[256]; // SQL语句缓冲区 // 参数校验，确保日期字符串不为NULL if (date_time_string == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "日期时间字符串为NULL"); return 1; } // 使用sqlite3_snprintf构建SQL语句，防止SQL注入 sqlite3_snprintf(sizeof(sql), sql, "DELETE FROM timed_data_storage WHERE storage_interval = %d AND created_time < '%q';", storage_interval, date_time_string); pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务，确保数据一致性 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法开始事务: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; // 直接返回，不继续执行 } // 准备SQL语句，避免直接使用sqlite3_exec ret = sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句准备失败: %s SQL: %s", sqlite3_errmsg(business_db), sql); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 执行SQL语句 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) // SQLITE_DONE表示成功执行完语句 { KITLOG(LOG_KIT_EN, ERROR_EN, "删除数据失败: %s SQL: %s", sqlite3_errmsg(business_db), sql); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); // 释放SQLite语句句柄 return 1; } // 提交事务，确保操作生效 ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 sqlite3_finalize(stmt); // 释放SQLite语句句柄 pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } pthread_mutex_unlock(&business_db_mutex); // 解锁 // 释放SQLite语句句柄，避免内存泄漏 sqlite3_finalize(stmt); return 0; // 返回0表示成功 } /***************************************************************************** * @brief 批量插入故障数据存储 * @param[in] faultsDatas: 用于存储故障数据的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_insert_faults_data(UT_array *faultsDatas) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *sql = "INSERT INTO faults_record (dev_type, dev_id, point_id, faults_value, created_time) VALUES (?, ?, ?, ?, strftime('%Y-%m-%d %H:%M:%S', 'now'))"; int ret = 0; int total_count = utarray_len(faultsDatas); // 总记录数 int batch_size = 100; // 每批插入的条数 int i; pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法开始事务: %s", sqlite3_errmsg(business_db)); return 1; } // 预编译SQL语句 ret = sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL预编译失败: %s", sqlite3_errmsg(business_db)); return 1; } // 批量插入 for (i = 0; i < total_count; i++) { faults_data_storage_t *faultsData = (faults_data_storage_t *)utarray_eltptr(faultsDatas, i); // 绑定参数 sqlite3_bind_int(stmt, 1, faultsData->devType); sqlite3_bind_int(stmt, 2, faultsData->devDbId); sqlite3_bind_int(stmt, 3, faultsData->pointDbId); sqlite3_bind_double(stmt, 4, faultsData->faultsValue); // 执行插入 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入数据失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 重置语句，以便下次使用 sqlite3_reset(stmt); // 每 batch_size 条记录提交一次事务 if ((i + 1) % batch_size == 0) { ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 重新开始事务 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法重新开始事务: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } } } // 提交剩余数据 ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); pthread_mutex_unlock(&business_db_mutex); // 解锁 if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 释放预编译语句 sqlite3_finalize(stmt); utarray_free(faultsDatas); return 0; // 成功 } /***************************************************************************** * @brief 根据日期时间条件，删除该日期时间之前faults_data_storage的数据 * @param[in] date_time_string：日期时间 * @return 0-成功 1-失败 *****************************************************************************/ int kit_del_faults_data_by_date(const char *date_time_string) { sqlite3_stmt *stmt = NULL; // SQLite语句句柄 int ret = 0; // 返回值 char sql[256]; // SQL语句缓冲区 // 参数校验，确保日期字符串不为NULL if (date_time_string == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "日期时间字符串为NULL"); return 1; } // 使用sqlite3_snprintf构建SQL语句，防止SQL注入 sqlite3_snprintf(sizeof(sql), sql, "DELETE FROM faults_record WHERE created_time < '%q';", date_time_string); pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务，确保数据一致性 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法开始事务: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; // 直接返回，不继续执行 } // 准备SQL语句，避免直接使用sqlite3_exec ret = sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句准备失败: %s SQL: %s", sqlite3_errmsg(business_db), sql); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 执行SQL语句 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) // SQLITE_DONE表示成功执行完语句 { KITLOG(LOG_KIT_EN, ERROR_EN, "删除数据失败: %s SQL: %s", sqlite3_errmsg(business_db), sql); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); // 释放SQLite语句句柄 return 1; } // 提交事务，确保操作生效 ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 sqlite3_finalize(stmt); // 释放SQLite语句句柄 pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } pthread_mutex_unlock(&business_db_mutex); // 解锁 // 释放SQLite语句句柄，避免内存泄漏 sqlite3_finalize(stmt); return 0; // 返回0表示成功 } /******************************************************************************* * @brief 删除指定时间字符串之前的断点保存数据 * @param[in] date_time_string 日期时间字符串，格式为"YYYY-MM-DD HH:MM:SS" * @return 0-成功 1-失败 *****************************************************************************/ int kit_del_break_data_by_date(const char *date_time_string) { char sql1[256], sql2[256]; // SQL语句缓冲区 sqlite3_stmt *stmt1 = NULL, *stmt2 = NULL; // SQLite语句句柄 int ret = 0; // 返回值 // 参数校验，确保日期时间字符串不为NULL if (date_time_string == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "日期时间字符串为NULL"); return 1; } pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务，确保数据一致性 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法开始事务: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; // 直接返回，不继续执行 } // 使用sqlite3_snprintf构建SQL语句，防止SQL注入 sqlite3_snprintf(sizeof(sql1), sql1, "DELETE FROM break_record WHERE created_time < ?;"); sqlite3_snprintf(sizeof(sql2), sql2, "DELETE FROM break_data_storage WHERE created_time < ?;"); // 准备并执行第一个 DELETE 语句 // 准备SQL语句 ret = sqlite3_prepare_v2(business_db, sql1, -1, &stmt1, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句准备失败: %s SQL: %s", sqlite3_errmsg(business_db), sql1); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 绑定参数 ret = sqlite3_bind_text(stmt1, 1, date_time_string, -1, SQLITE_STATIC); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定参数失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt1); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 执行SQL语句 ret = sqlite3_step(stmt1); if (ret != SQLITE_DONE) // SQLITE_DONE表示成功执行完语句 { KITLOG(LOG_KIT_EN, ERROR_EN, "删除数据失败: %s SQL: %s", sqlite3_errmsg(business_db), sql1); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt1); // 释放SQLite语句句柄 return 1; } // 准备并执行第二个 DELETE 语句 // 准备SQL语句 ret = sqlite3_prepare_v2(business_db, sql2, -1, &stmt2, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句准备失败: %s SQL: %s", sqlite3_errmsg(business_db), sql2); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 绑定参数 ret = sqlite3_bind_text(stmt2, 1, date_time_string, -1, SQLITE_STATIC); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "绑定参数失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt2); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 执行SQL语句 ret = sqlite3_step(stmt2); if (ret != SQLITE_DONE) // SQLITE_DONE表示成功执行完语句 { KITLOG(LOG_KIT_EN, ERROR_EN, "删除数据失败: %s SQL: %s", sqlite3_errmsg(business_db), sql2); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt2); // 释放SQLite语句句柄 return 1; } // 提交事务，确保操作生效 ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } pthread_mutex_unlock(&business_db_mutex); // 解锁 // 释放SQLite语句句柄，避免内存泄漏 sqlite3_finalize(stmt1); return 0; // 返回0表示成功 } /***************************************************************************** * @brief 查询MQTT断开记录，根据isUploaded字段筛选。 * @param[in] isUploaded: 要查询的is_uploaded字段值。如果为255，则查询所有记录。 * @param[out] breakRecord: 用于存储查询结果的UT_array指针。 * @return 0-成功 1-失败 *****************************************************************************/ int kit_query_break_records(uint8_t isUploaded, UT_array **breakRecord) { sqlite3_stmt *stmt = NULL; char *sql; if (isUploaded == 255) { sql = sqlite3_mprintf("SELECT id, reason, is_uploaded FROM break_record ORDER BY created_time ASC;"); } else { sql = sqlite3_mprintf("SELECT id, reason, is_uploaded FROM break_record WHERE is_uploaded = %d ORDER BY created_time ASC;", isUploaded); } if (SQLITE_OK != sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL预编译失败: %s", sqlite3_errmsg(business_db)); sqlite3_free(sql); return 1; } sqlite3_free(sql); utarray_new(*breakRecord, &break_record_icd); // 初始化UT_array // 执行查询并处理结果 int step = sqlite3_step(stmt); while (SQLITE_ROW == step) { break_record_t record = {0}; /* //永远不可能为空 if (&record == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "内存分配失败"); utarray_free(*breakRecord); sqlite3_finalize(stmt); return 1; } */ record.dbId = sqlite3_column_int64(stmt, 0); strncpy((char *)record.reason, (const char *)sqlite3_column_text(stmt, 1), MAX_NAME_BUF_LEN - 1); record.reason[MAX_NAME_BUF_LEN - 1] = '\0'; // 确保字符串结尾为\0 record.isUploaded = sqlite3_column_int(stmt, 2); utarray_push_back(*breakRecord, &record); step = sqlite3_step(stmt); } if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL执行失败: %s", sqlite3_errmsg(business_db)); utarray_free(*breakRecord); sqlite3_finalize(stmt); return 1; } sqlite3_finalize(stmt); return 0; } /***************************************************************************** * @brief 插入MQTT断开记录，包括中断原因、是否已上传以及断开开始和结束时间。返回插入记录的ID。 * @param[in] breakRecord: 包含MQTT断开信息的结构体指针：该结构体必须包含中断原因(reason) * @return 插入记录的ID；-1-插入记录失败（包括SQL预编译失败和SQL执行失败）。 *****************************************************************************/ long long kit_insert_break_record(break_record_t *breakRecord) { sqlite3_stmt *stmt = NULL; const char *sql = "INSERT INTO break_record(reason, is_uploaded, start_time) VALUES(?, 0, strftime('%Y-%m-%d %H:%M:%S', 'now'));"; // 注意分号 if (SQLITE_OK != sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL预编译失败: %s", sqlite3_errmsg(business_db)); return -1; // 返回-1表示失败 } sqlite3_bind_text(stmt, 1, (const char *)breakRecord->reason, -1, SQLITE_STATIC); pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 int step = sqlite3_step(stmt); if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入数据失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return -1; // 返回-1表示失败 } long long last_insert_rowid = sqlite3_last_insert_rowid(business_db); // 获取最后插入行的rowid pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); return last_insert_rowid; // 返回插入记录的ID } /***************************************************************************** * @brief 更新MQTT断开记录的上传状态。此函数更新数据库中MQTT断开记录的`is_uploaded`字段。 * @param[in] breakRecord: 指向包含MQTT断开信息的结构体指针。该结构体必须包含断开记录在数据库中的ID (`dbId`) 和新的上传状态 (`isUploaded`)。 * @return 0-成功更新记录；1-更新记录失败（包括SQL语句预编译失败、SQL语句执行失败或未找到匹配的记录）。如果SQL语句执行成功，但没有更新任何行（例如，`dbId`不存在），则返回1，并记录警告日志。 *****************************************************************************/ int kit_update_break_record(break_record_t *breakRecord) { int ret = 0; sqlite3_stmt *stmt = NULL; const char *sql = sqlite3_mprintf("UPDATE break_record SET is_uploaded = ? WHERE id = ?"); if (SQLITE_OK != sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句预编译失败: %s", sqlite3_errmsg(business_db)); return 1; } sqlite3_bind_int(stmt, 1, breakRecord->isUploaded); sqlite3_bind_int64(stmt, 2, breakRecord->dbId); pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 int step = sqlite3_step(stmt); if (step != SQLITE_DONE) { if (step == SQLITE_ERROR) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句执行失败: %s", sqlite3_errmsg(business_db)); } else if (step == SQLITE_ROW) { KITLOG(LOG_KIT_EN, ERROR_EN, "UPDATE操作中出现意外的SQLITE_ROW返回值"); } else { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL更新失败，错误代码: %d", step); } pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); return 1; } // 检查是否实际更新了任何行。SQLITE_DONE 并不保证这一点。 if (sqlite3_changes(business_db) == 0) { KITLOG(LOG_KIT_EN, ERROR_EN, "没有更新任何行。请检查 dbId 是否正确。"); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); return ret; } /***************************************************************************** * @brief 批量插入MQTT断联时的历史数据存储 * @param[in] breakDbId：MQTT断联的数据库Id * @param[in] timedDatas: 用于历史数据存储的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_insert_break_data_storage(uint64_t breakDbId, UT_array **timedDatas) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *sql = "INSERT INTO break_data_storage(break_id, content, is_uploaded, created_time) VALUES (?, ?, 0, strftime('%Y-%m-%d %H:%M:%S', 'now'))"; int ret = 0; int total_count = utarray_len(*timedDatas); // 总记录数 int batch_size = 100; // 每批插入的条数 int i; pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法开始事务: %s", sqlite3_errmsg(business_db)); return 1; } // 预编译SQL语句 ret = sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL预编译失败: %s", sqlite3_errmsg(business_db)); return 1; } // 批量插入 for (i = 0; i < total_count; i++) { break_data_storage_t *timedData = (break_data_storage_t *)utarray_eltptr(*timedDatas, i); // 绑定参数 sqlite3_bind_int64(stmt, 1, breakDbId); sqlite3_bind_text(stmt, 2, (const char *)timedData->content, -1, SQLITE_STATIC); // 执行插入 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入数据失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 重置语句，以便下次使用 sqlite3_reset(stmt); // 每 batch_size 条记录提交一次事务 if ((i + 1) % batch_size == 0) { ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 重新开始事务 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法重新开始事务: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } } } // 提交剩余数据 ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); pthread_mutex_unlock(&business_db_mutex); // 解锁 if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 释放预编译语句 sqlite3_finalize(stmt); return 0; // 成功 } /***************************************************************************** * @brief 根据断开记录ID和行号范围查询断开数据。 * @param[in] breakDbId: MQTT断开记录的数据库ID。 * @param[out] timedDatas: 用于存储查询数据的UT_array指针。必须在调用之前初始化。 * @return 0-成功；1-失败（数据库错误或其他问题）。 *****************************************************************************/ int kit_query_break_data(uint64_t breakDbId, UT_array **timedDatas) { sqlite3_stmt *stmt = NULL; char *sql = NULL; int ret = 0; // 构造SQL查询语句，使用LIMIT子句进行分页 // 将 SELECT 子句改为选择 id 和 content 两个字段 sql = sqlite3_mprintf("SELECT id, content FROM break_data_storage WHERE break_id = %d AND is_uploaded = 0 ORDER BY created_time LIMIT 100", breakDbId); if (SQLITE_OK != sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句预编译失败: %s", sqlite3_errmsg(business_db)); sqlite3_free(sql); return 1; } while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) { break_data_storage_t timedData = {0}; snprintf((char *)timedData.content, MAX_JSON_STR_LEN, "%s", (uint8_t *)sqlite3_column_text(stmt, 1)); uint64_t id = sqlite3_column_int(stmt, 0); timedData.breakDbId = id; utarray_push_back(*timedDatas, &timedData); } if (ret != SQLITE_DONE && ret != SQLITE_ROW) { // 添加对非SQLITE_DONE和SQLITE_ROW情况的检查 KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句执行失败: %s, 错误码: %d", sqlite3_errmsg(business_db), ret); sqlite3_finalize(stmt); sqlite3_free(sql); return 1; } sqlite3_finalize(stmt); sqlite3_free(sql); return 0; } /***************************************************************************** * @brief 批量更新断开数据的上传状态，使用事务保证数据一致性。 * @param[in] break_id: MQTT断开记录的break_id。 * @param[in] ids: storage的id数组。 * @param[in] length: storage的id数组长度。 * @return 0-成功；1-失败 *****************************************************************************/ int kit_update_break_data(uint16_t break_id, uint64_t ids[], int length) { if (length <= 0 || ids == NULL) { // 如果传入的id数组为空或长度为0, 无需执行更新。 return 0; } sqlite3_stmt *stmt = NULL; int ret = 0; int i = 0; char *sql = NULL; char *in_clause = NULL; pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务 if (SQLITE_OK != sqlite3_exec(business_db, "BEGIN TRANSACTION", NULL, NULL, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "开始事务失败: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); return 1; } // 构建 IN 子句字符串 in_clause = sqlite3_mprintf("("); for (i = 0; i < length; i++) { in_clause = sqlite3_mprintf("%s%s?", in_clause, (i > 0) ? "," : ""); } in_clause = sqlite3_mprintf("%s)", in_clause); // 创建 SQL 语句 sql = sqlite3_mprintf("UPDATE break_data_storage SET is_uploaded = 1 WHERE break_id = ? AND id IN %s", in_clause); sqlite3_free(in_clause); if (SQLITE_OK != sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句预编译失败: %s", sqlite3_errmsg(business_db)); sqlite3_free(sql); sqlite3_exec(business_db, "ROLLBACK TRANSACTION", NULL, NULL, NULL); pthread_mutex_unlock(&business_db_mutex); return 1; } sqlite3_free(sql); // 绑定 break_id 参数 sqlite3_bind_int(stmt, 1, break_id); // 绑定 ID 参数 for (i = 0; i < length; i++) { sqlite3_bind_int64(stmt, i + 2, ids[i]); // IDs 从第二个参数开始 } // 执行 SQL 语句 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句执行失败: %s, 错误码: %d", sqlite3_errmsg(business_db), ret); sqlite3_finalize(stmt); sqlite3_exec(business_db, "ROLLBACK TRANSACTION", NULL, NULL, NULL); pthread_mutex_unlock(&business_db_mutex); return 1; } sqlite3_finalize(stmt); // 提交事务 if (SQLITE_OK != sqlite3_exec(business_db, "COMMIT TRANSACTION", NULL, NULL, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); return 1; } pthread_mutex_unlock(&business_db_mutex); return 0; } /***************************************************************************** * @brief 批量插入插入功率数据 * @param[in] powerDatas: 用于存储备份数据的 UT_array 指针 * @return 0-成功 1-失败 *****************************************************************************/ int kit_insert_power_data(UT_array *powerDatas) { sqlite3_stmt *stmt = NULL; // 预编译语句句柄 const char *sql = "INSERT INTO power_data_storage(dev_type, dev_code, point_code, value, created_time) VALUES(?, ?, ?, ?, strftime('%Y-%m-%d %H:%M:%S', 'now'));"; int ret = 0; int total_count = utarray_len(powerDatas); // 总记录数 int batch_size = 100; // 每批插入的条数 int i; pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法开始事务: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 预编译SQL语句 ret = sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL预编译失败: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 批量插入 for (i = 0; i < total_count; i++) { power_data_storage_t *powerData = (power_data_storage_t *)utarray_eltptr(powerDatas, i); // 绑定参数 sqlite3_bind_int(stmt, 1, powerData->devType); sqlite3_bind_int(stmt, 2, powerData->devId); sqlite3_bind_int(stmt, 3, powerData->pointId); sqlite3_bind_double(stmt, 4, powerData->value); // 执行插入 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入数据失败: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); return 1; } // 重置语句，以便下次使用 sqlite3_reset(stmt); // 每 batch_size 条记录提交一次事务 if ((i + 1) % batch_size == 0) { ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); return 1; } // 重新开始事务 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法重新开始事务: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); return 1; } } } // 提交剩余数据 ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); pthread_mutex_unlock(&business_db_mutex); // 解锁 if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; } // 释放预编译语句 sqlite3_finalize(stmt); utarray_free(powerDatas); return 0; // 成功 } /***************************************************************************** * @brief 根据日期时间条件，删除该日期时间之前power_data_storage的数据 * @param[in] date_time_string：日期时间 * @return 0-成功 1-失败 *****************************************************************************/ int kit_del_power_data_by_date(const char *date_time_string) { sqlite3_stmt *stmt = NULL; // SQLite语句句柄 int ret = 0; // 返回值 char sql[256]; // SQL语句缓冲区 // 参数校验，确保日期字符串不为NULL if (date_time_string == NULL) { KITLOG(LOG_KIT_EN, ERROR_EN, "日期时间字符串为NULL"); return 1; } // 使用sqlite3_snprintf构建SQL语句，防止SQL注入 sqlite3_snprintf(sizeof(sql), sql, "DELETE FROM power_data_storage WHERE created_time < '%q';", date_time_string); pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 // 开始事务，确保数据一致性 ret = sqlite3_exec(business_db, "BEGIN TRANSACTION;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "无法开始事务: %s", sqlite3_errmsg(business_db)); pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; // 直接返回，不继续执行 } // 准备SQL语句，避免直接使用sqlite3_exec ret = sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL语句准备失败: %s SQL: %s", sqlite3_errmsg(business_db), sql); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 return 1; } // 执行SQL语句 ret = sqlite3_step(stmt); if (ret != SQLITE_DONE) // SQLITE_DONE表示成功执行完语句 { KITLOG(LOG_KIT_EN, ERROR_EN, "删除数据失败: %s SQL: %s", sqlite3_errmsg(business_db), sql); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); // 释放SQLite语句句柄 return 1; } // 提交事务，确保操作生效 ret = sqlite3_exec(business_db, "COMMIT;", NULL, NULL, NULL); if (ret != SQLITE_OK) { KITLOG(LOG_KIT_EN, ERROR_EN, "提交事务失败: %s", sqlite3_errmsg(business_db)); sqlite3_exec(business_db, "ROLLBACK;", NULL, NULL, NULL); // 回滚事务 pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); // 释放SQLite语句句柄 return 1; } pthread_mutex_unlock(&business_db_mutex); // 解锁 // 释放SQLite语句句柄，避免内存泄漏 sqlite3_finalize(stmt); return 0; // 返回0表示成功 } /***************************************************************************** * @brief 获取指定表中特定dbId的记录数量 * @param[in] db: SQLite3 数据库连接对象 * @param[in] tabName: 查询表的名称 * @param[in] dbid: 用于查询记录的dbId值 * @return 记录数量（成功返回记录数量；失败返回-1） *****************************************************************************/ int kit_get_record_count_by_dbid(sqlite3 *db, const char *tabName, uint64_t dbid) { sqlite3_stmt *stmt; char sql[256]; int result = 0; int rc; // 使用 snprintf 合成 SQL 查询字符串 snprintf(sql, sizeof(sql), "SELECT COUNT(*) FROM %s WHERE db_id = ?", tabName); // 预编译SQL语句 rc = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL); if (rc != SQLITE_OK) { printf("Failed to prepare statement: %s\n", sqlite3_errmsg(db)); return -1; } // 绑定参数 sqlite3_bind_int64(stmt, 1, dbid); // 执行SQL查询 if ((rc = sqlite3_step(stmt)) == SQLITE_ROW) { result = sqlite3_column_int(stmt, 0); } else { printf("Failed to execute query: %s\n", sqlite3_errmsg(db)); } // 清理和释放资源 sqlite3_finalize(stmt); return result; } /***************************************************************************** * @brief 插入北向断开记录，记录最新连接状态。 * @param[in] connectStatus: 连接状态 * @return 0-成功 1-失败。 *****************************************************************************/ int kit_insert_lost_contact_record(const char* connectStatus) { sqlite3_stmt *stmt = NULL; const char *sql = "INSERT INTO lost_contact_record(connect_status, created_time) VALUES(?, strftime('%Y-%m-%d %H:%M:%S', 'now'));"; if (SQLITE_OK != sqlite3_prepare_v2(business_db, sql, -1, &stmt, NULL)) { KITLOG(LOG_KIT_EN, ERROR_EN, "SQL预编译失败: %s", sqlite3_errmsg(business_db)); return 1; // 返回1表示失败 } sqlite3_bind_text(stmt, 1, connectStatus, -1, SQLITE_STATIC); pthread_mutex_lock(&business_db_mutex); // 加锁，确保单线程访问 int step = sqlite3_step(stmt); if (SQLITE_DONE != step) { KITLOG(LOG_KIT_EN, ERROR_EN, "插入数据失败: %s", sqlite3_errmsg(business_db)); sqlite3_finalize(stmt); return 1; // 返回1表示失败 } pthread_mutex_unlock(&business_db_mutex); // 解锁 sqlite3_finalize(stmt); return 0; }