3815 lines
148 KiB
C
3815 lines
148 KiB
C
/*****************************************************************************
|
||
* @copyright 2024-2024, . POWER SUPPLY CO., LTD.
|
||
* @file kit_db.c
|
||
* @brief sqlite3数据库操作方法
|
||
* @author Gary
|
||
* @date 2024/09/10
|
||
* @remark 去掉sqlite3_get_table即将过期的方法，补充了设备、协议和点位表的查询方法
|
||
*****************************************************************************/
|
||
#include <string.h>
|
||
#include <dirent.h>
|
||
#include <sys/stat.h>
|
||
#include <pthread.h>
|
||
#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;
|
||
} |