WLG/dbaccess/sql_db.cpp

#include "sql_db.hpp"
#include <unistd.h>
#include <boost/algorithm/string.hpp>
#include <zlog.h>
#include <json/json.h>
#include "mqttclient/mqtt_client.h"
#include "common/global.hpp"
#include "utility/calculation.hpp"

extern zlog_category_t *zct;
extern zlog_category_t *zbt;
char  resend_mqttData[512000] = {0};
// clang-format off
const char *T_SENSOR_INFO1[] = {"t_sensor_info", "dataNodeNo",     "dataNodeName",    "initFlag",       "accFlag",       "zigbeeFlag",      "temTopFlag",   "temBotFlag",   "equipSta", "hardVersion", "softVersion",      "bpNo",
                                      "serialNo",      "firstPowerTime", "configFlag",      "startBrands",    "stopBrands",    "featureInterVal", "waveInterVal", "samplingRate", "scope",    "range",       "envelopeBandPass", "faultFrequency",
                                      "zigbeePanId",   "zigbeeChannel",  "zigbeeShortAddr", "zigbeeLongAddr", "zigbeeDesAddr", "status",          "timeStamp",    "viff",         "RSSI"};

const char *T_DATA_INFO1[] = {"t_data_info", "dataNodeNo", "channelID", "diagnosisPk", "integratPk", "integratRMS", "rmsValues",   "envelopEnergy", "Amp1",    "Amp2",      "Amp3",
                                    "Amp4",        "Amp5",       "Phase1",    "Phase2",      "Phase3",     "Phase4",      "StaticIndex", "timeStamp",     "sendMsg", "nodeResend"};

const char *T_DATASTATIC_INFO1[] = {"t_datastatic_info", "dataNodeNo", "channelID", "temTop", "temBot", "dip", "voltage", "StaticIndex", "timeStamp", "sendMsg", "nodeResend"};

const char *T_DATANODE_TIME1[] = {"t_datanode_time", "dataNodeNo", "shortaddr", "staticcycle", "wavecycle", "nodegroup", "nodeindex", "nodewaveindex", "statictime", "staticstarttime"};

const char *T_GATEWAY_INFO1[] = {"t_gateway_info", "gatewayMAC",     "sensorVersion", "gatewayLocation", "zigbeePanID", "zigbeeChannel", "communicationType", "signal", "localIP",
                                       "systemVersion",  "programVersion", "webVersion",    "serverIP",        "serverPort",  "status",        "gateWayUpdate",     "MAC2"};

const char *T_BATTERY_INFO1[] = {"t_battery_info", "dataNodeNo", "Dip", "temBot", "nodeWorkTime", "nodeSendTime", "batteryVoltage", "batteryUsage", "batteryRemain", "timeStamp"};
// clang-format on

SqliteDB::SqliteDB() {}

SqliteDB::~SqliteDB() {}

void SqliteDB::SqliteInit(const char *pDbName) {
    char sql_exec[2048];

    //创建传感器信息存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);",
						T_SENSOR_INFO(TNAME),
						T_SENSOR_INFO(DATANODENO),
						T_SENSOR_INFO(DATANODENAME), 
					    T_SENSOR_INFO(INITFLAG), 
						T_SENSOR_INFO(ACCFLAG), 
						T_SENSOR_INFO(ZIGBEEFLAG), 
						T_SENSOR_INFO(TEMTOPFLAG),
						T_SENSOR_INFO(TEMBOTFLAG),
						T_SENSOR_INFO(EQUIPSTA),
						T_SENSOR_INFO(HARDVERSION),
						T_SENSOR_INFO(SOFTVERSION),
						T_SENSOR_INFO(BPNO),
						T_SENSOR_INFO(SERIALNO),
						T_SENSOR_INFO(FIRSTPOWERNO),
						"WakeupTime",
						"StaticTime",
						"WaveTime",
						"BateryV",
						"ProductNo",
				        T_SENSOR_INFO(CONFIGFLAG),
						T_SENSOR_INFO(STARTBRANDS),
						T_SENSOR_INFO(STOPBRANDS),
						T_SENSOR_INFO(FEATUREINTERVAL),
						T_SENSOR_INFO(WAVEINTERVAL),
						T_SENSOR_INFO(SAMPLINGRATE),
						T_SENSOR_INFO(SCOPE),
						T_SENSOR_INFO(RANGE),
						T_SENSOR_INFO(ENVELOPEBANDPASS),
						T_SENSOR_INFO(FAULTFREQUENCY),
						T_SENSOR_INFO(ZIGBEEPANID),
						T_SENSOR_INFO(ZIGBEECHANNEL),
						T_SENSOR_INFO(ZIGBEESHORTADDR),
						T_SENSOR_INFO(ZIGBEELONGADDR),
						T_SENSOR_INFO(ZIGBEEDESADDR),
						"ZigbeePower",
						"ZigbeeRetry",
						"ZigbeeRetryGap",
						"ACCSampleTime",
						T_SENSOR_INFO(STATUS),
						T_SENSOR_INFO(TIMESTAMP),
						T_SENSOR_INFO(VIFF),
    					T_SENSOR_INFO(RSSI),
						"UpdateFlag",
						"LooseValue",
						"batteryPower");
    CreateTable(sql_exec);

    int iRet = GetTableRows(" sqlite_master "," name = 't_sensor_info' and sql LIKE '%LooseValue%' ");
    if(iRet == 0){
    	CreateTable("ALTER TABLE t_sensor_info ADD COLUMN 'LooseValue'");
    }

    iRet = GetTableRows(" sqlite_master "," name = 't_sensor_info' and sql LIKE '%batteryPower%' ");
    if(iRet == 0){
        CreateTable("ALTER TABLE t_sensor_info ADD COLUMN 'batteryPower'");
    }
	iRet = GetTableRows(" sqlite_master "," name = 't_sensor_info' and sql LIKE '%MeasurementID%' ");
    if(iRet == 0){
        CreateTable("ALTER TABLE t_sensor_info ADD COLUMN 'MeasurementID'");
    }
	iRet = GetTableRows(" sqlite_master "," name = 't_sensor_info' and sql LIKE '%NodeWaveSend%' ");
    if(iRet == 0){
        CreateTable("ALTER TABLE t_sensor_info ADD COLUMN 'NodeWaveSend'");
    }
    iRet = GetTableRows(" sqlite_master "," name = 't_sensor_info' and sql LIKE '%upgradeStatus%' ");
    if(iRet == 0){
        CreateTable("ALTER TABLE t_sensor_info ADD COLUMN 'upgradeStatus'");
    }

	memset(sql_exec, 0, 2048);
	sprintf(sql_exec,"update t_sensor_info set MeasurementID = dataNodeNo where MeasurementID IS NULL ;");
	UpdateTableData(sql_exec);
	memset(sql_exec, 0, 2048);
	sprintf(sql_exec,"update t_sensor_info set MeasurementID = dataNodeNo where MeasurementID = '' ;");
	UpdateTableData(sql_exec);
    memset(sql_exec, 0, 2048);
	sprintf(sql_exec,"update t_sensor_info set NodeWaveSend = '0,0,0' where NodeWaveSend = '' ;");
	UpdateTableData(sql_exec);
	memset(sql_exec, 0, 2048);
	sprintf(sql_exec,"update t_sensor_info set NodeWaveSend = '0,0,0' where NodeWaveSend IS NULL ;");
	UpdateTableData(sql_exec);

    sprintf(sql_exec,"update t_sensor_info set upgradeStatus = '0' where upgradeStatus IS NULL ;");
	UpdateTableData(sql_exec);
    sprintf(sql_exec,"update t_sensor_info set upgradeStatus = '0' where upgradeStatus = '' ;");
	UpdateTableData(sql_exec);
    
    //创建传感器数据存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s integer,%s,%s,%s);",
                       T_DATA_INFO(TNAME),
                       T_DATA_INFO(DATANODENO),
                       T_DATA_INFO(CHANNELID), 
                       T_DATA_INFO(DIAGNOSISEAK), 
                       T_DATA_INFO(INTEGRATPK), 
                       T_DATA_INFO(INTEGRATRMS), 
                       T_DATA_INFO(RMSVALUES),
                       T_DATA_INFO(ENVELOPNERGY),
                       T_DATA_INFO(AMP1),
                       T_DATA_INFO(AMP2),
                       T_DATA_INFO(AMP3),
                       T_DATA_INFO(AMP4),
                       T_DATA_INFO(AMP5),
                       T_DATA_INFO(PHASE1),
                       T_DATA_INFO(PHASE2),
                       T_DATA_INFO(PHASE3),
                       T_DATA_INFO(PHASE4),
					   T_DATA_INFO(STATICINDEX),
                       T_DATA_INFO(TIMESTAMP),
					   T_DATA_INFO(SENDMSG),
					   T_DATA_INFO(NODERESEND));
    CreateTable(sql_exec);

    iRet = GetTableRows(" sqlite_master "," name = 't_data_info' and sql LIKE '%nodeResend%' ");
	if(iRet == 0){
		CreateTable("ALTER TABLE t_data_info ADD COLUMN 'nodeResend'");
	}

    //创建传感器静态数据存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s integer,%s,%s,%s);",
                       T_DATASTATIC_INFO(TNAME),
                       T_DATASTATIC_INFO(DATANODENO),
                       T_DATASTATIC_INFO(CHANNELID), 
                       T_DATASTATIC_INFO(TEMTOP), 
                       T_DATASTATIC_INFO(TEMBOT), 
                       T_DATASTATIC_INFO(DIP), 
                       T_DATASTATIC_INFO(VOLTAGE),
					   "Battery",
					   T_DATASTATIC_INFO(STATICINDEX),
                       T_DATASTATIC_INFO(TIMESTAMP),
					   T_DATASTATIC_INFO(SENDMSG),
					   T_DATASTATIC_INFO(NODERESEND));
    CreateTable(sql_exec);
    iRet = GetTableRows(" sqlite_master "," name = 't_datastatic_info' and sql LIKE '%nodeResend%' ");
	if(iRet == 0){
		CreateTable("ALTER TABLE t_datastatic_info ADD COLUMN 'nodeResend'");
	}

    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);",
    					T_GATEWAY_INFO(TNAME),
    					T_GATEWAY_INFO(GATEWAYMAC),
						T_GATEWAY_INFO(SENSORVER),
						T_GATEWAY_INFO(GATEWAYLOCATION),
						T_GATEWAY_INFO(ZIGBEEPANID),
						T_GATEWAY_INFO(ZIGBEECHANNEL),
						T_GATEWAY_INFO(COMMUNICATIONTYPE),
						T_GATEWAY_INFO(SIGNAL),
						T_GATEWAY_INFO(LOCALIP),
						T_GATEWAY_INFO(SYSTEMVERSION),
						T_GATEWAY_INFO(PROGRAMVERSION),
						T_GATEWAY_INFO(WEBVERSION),
						T_GATEWAY_INFO(SERVERIP),
						T_GATEWAY_INFO(SERVERPORT),
						T_GATEWAY_INFO(STATUS),
						T_GATEWAY_INFO(GATEWAYUPDATE),
						T_GATEWAY_INFO(MAC2));
   CreateTable(sql_exec);

   memset(sql_exec, 0, 2048);
   sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s);",
    		   	   "t_data_waveSend","channelID","waveName","timeStamp","sendMsg","save");
   CreateTable(sql_exec);

   iRet = GetTableRows(" sqlite_master "," name = 't_data_waveSend' and sql LIKE '%sendMsg%' ");
   if(iRet == 0){
   		CreateTable("ALTER TABLE t_data_waveSend ADD COLUMN 'sendMsg'");
   }
   iRet = GetTableRows(" sqlite_master "," name = 't_data_waveSend' and sql LIKE '%save%' ");
   if(iRet == 0){
	   CreateTable("ALTER TABLE t_data_waveSend ADD COLUMN 'save'");
   }
   iRet = GetTableRows(" sqlite_master "," name = 't_data_waveSend' and sql LIKE '%error_code%' ");
   if(iRet == 0){
	   CreateTable("ALTER TABLE t_data_waveSend ADD COLUMN 'error_code'");
   }

   memset(sql_exec, 0, 2048);
   sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s);",
    					T_BATTERY_INFO(TNAME),
    					T_BATTERY_INFO(DATANODENO),
						T_BATTERY_INFO(DIP),
						T_BATTERY_INFO(TEMBOT),
						T_BATTERY_INFO(NODEWORKTIME),
						T_BATTERY_INFO(NODESENDTIME),
						T_BATTERY_INFO(BATTERYVOLTAGE),
						T_BATTERY_INFO(BATTERYUSAGE),
						T_BATTERY_INFO(BATTERYREMAIN),
						T_BATTERY_INFO(TIMESTAMP));
    CreateTable(sql_exec);

    memset(sql_exec, 0, 2048);
	sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s);",
    					"t_battery_history",
    					T_BATTERY_INFO(DATANODENO),
						T_BATTERY_INFO(DIP),
						T_BATTERY_INFO(TEMBOT),
						T_BATTERY_INFO(NODEWORKTIME),
						T_BATTERY_INFO(NODESENDTIME),
						T_BATTERY_INFO(BATTERYVOLTAGE),
						T_BATTERY_INFO(BATTERYUSAGE),
						T_BATTERY_INFO(BATTERYREMAIN),
						T_BATTERY_INFO(TIMESTAMP));
   CreateTable(sql_exec);

   execute_sql_file("/opt/configenv/firmware_upgrade.sql");
        
   execute_sql_file("/opt/configenv/receive_wave_status.sql");
}

void SqliteDB::Createtable(const char *ptableName) {
    char sql_exec[2048];
    //创建传感器数据存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s integer,%s,%s,%s);", ptableName, T_DATA_INFO(DATANODENO), T_DATA_INFO(CHANNELID), T_DATA_INFO(DIAGNOSISEAK), T_DATA_INFO(INTEGRATPK), T_DATA_INFO(INTEGRATRMS),
            T_DATA_INFO(RMSVALUES), T_DATA_INFO(ENVELOPNERGY), T_DATA_INFO(AMP1), T_DATA_INFO(AMP2), T_DATA_INFO(AMP3), T_DATA_INFO(AMP4), T_DATA_INFO(AMP5), T_DATA_INFO(PHASE1), T_DATA_INFO(PHASE2), T_DATA_INFO(PHASE3), T_DATA_INFO(PHASE4), "StaticIndex", T_DATA_INFO(TIMESTAMP),
            "sendMsg", "nodeResend");
    CreateTable(sql_exec);
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "CREATE INDEX %s_1 ON %s (%s)", ptableName, ptableName, T_DATA_INFO(DATANODENO));
    CreateTable(sql_exec);
}

void SqliteDB::SqliteInitDel(const char *pDbName) {
    Deletetable(T_DATA_INFO(TNAME));
    Deletetable(T_DATASTATIC_INFO(TNAME));
    vec_t vecResult = GetDataMultiLineOfOneColumn(T_SENSOR_INFO(TNAME), " MeasurementID ", NULL);
    for (size_t i = 0; i < vecResult.size() && vecResult.size() > 0; i++) {
        char sztableName[100] = {0x00};
        sprintf(sztableName, "t_data_%s", vecResult[i].c_str());
        Deletetable(sztableName);
        sprintf(sztableName, "t_dataStatic_%s", vecResult[i].c_str());
        Deletetable(sztableName);
        
    }
}

void SqliteDB::Deletetable(const char *ptableName) {
    char sql_exec[2048];
    //创建传感器数据存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "DROP TABLE  %s ;", ptableName);
    int iRet = sqlite3_exec(GetDbHandle(), sql_exec, 0, 0, NULL);
    if (iRet != SQLITE_OK) {
        zlog_error(zbt, "fail to delete table:%s", ptableName);
    }
}

void SqliteDB::CreatedataStatictable(const char *ptableName) {
    char sql_exec[2048];
    //创建传感器数据存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s integer,%s,%s,%s,%s integer,%s,%s);", ptableName, T_DATASTATIC_INFO(DATANODENO), T_DATASTATIC_INFO(CHANNELID), T_DATASTATIC_INFO(TEMTOP), T_DATASTATIC_INFO(TEMBOT), T_DATASTATIC_INFO(DIP),
            T_DATASTATIC_INFO(VOLTAGE), "zigbeeSignal", "StaticIndex", T_DATASTATIC_INFO(TIMESTAMP), "sendMsg", "nodeResend", "zigbeeSignalNode", "statisticType", "timing");
    CreateTable(sql_exec);
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "CREATE INDEX %s_1 ON %s (%s)", ptableName, ptableName, T_DATA_INFO(DATANODENO));
    CreateTable(sql_exec);
}

bool SqliteDB::OpenDB(const char *pDbName) {
    int ret = 0;
    ret = sqlite3_open(pDbName, &mDBAcess);
    if (ret == SQLITE_OK) {
        sqlite3_exec(mDBAcess, "PRAGMA synchronous = NORMAL;", 0, 0, 0);
        sqlite3_exec(mDBAcess, "PRAGMA cache_size=8000;", 0, 0, 0);
        sqlite3_exec(mDBAcess, "PRAGMA temp_store = MEMORY;", 0, 0, 0);
        sqlite3_exec(mDBAcess, "PRAGMA auto_vacuum = 1;", 0, 0, 0);
        zlog_info(zbt, "Success To Open DataBase!");
    } else {
        zlog_error(zbt, "Fail To Open DataBase:%s, ret:%d", pDbName, ret);
        return false;
    }

    return true;
}

int SqliteDB::CloseDB() { return sqlite3_close(mDBAcess); }

sqlite3 *SqliteDB::GetDbHandle() { return mDBAcess; }

int SqliteDB::CreateTable(const char *sql) {
    zlog_info(zct, "%s", sql);
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(), sql, 0, 0, &msg);
    if (iRet != SQLITE_OK) {
        zlog_error(zbt, "[CreateTable] sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, sql);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::ExeSql(const char *sql) {
    zlog_info(zct, "%s", sql);
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(), sql, 0, 0, &msg);
    if (iRet != SQLITE_OK) {
        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, sql);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::GetTableColumnCount(const char *tablename) {
    std::string strSql = "select * from ";
    int count = 0;
    sqlite3_stmt *stmt;
    strSql = strSql + tablename + ";";
    zlog_info(zct, "%s", strSql.c_str());
    sqlite3_prepare_v2(GetDbHandle(), strSql.c_str(), -1, &stmt, 0);
    count = sqlite3_column_count(stmt);
    sqlite3_finalize(stmt);
    return count;
}

int SqliteDB::GetTableRows(const char *tablename, const char *whereCon) {
    int nRow = 0;
    std::string strSql = "select count(*) from ";
    if (whereCon != NULL) {
        strSql = strSql + tablename + " where " + whereCon + ";";
    } else {
        strSql = strSql + tablename + ";";
    }
    zlog_info(zct, "[GetTableRows] sql:%s", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:%s", sqlite3_errmsg(mDBAcess), strSql.c_str());
        sqlite3_finalize(stmt);
        return -1;
    }
    int retStep = sqlite3_step(stmt);
    if (retStep == SQLITE_ROW) {
        nRow = sqlite3_column_int(stmt, 0);
    }
    sqlite3_finalize(stmt);
    return nRow;
}

int SqliteDB::AlterTable(const char *tablename, const char *column, bool isAdd) {
    int iRet = SQLITE_ERROR;
    if (isAdd) {
        std::string strSql = "alter table ";
        strSql = strSql + tablename + " add " + column + ";";
        zlog_info(zct, "[AlterTable] sql:%s", strSql.c_str());
        iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, NULL);
        if (iRet != SQLITE_OK) {
            zlog_error(zct, "sqlite3_exec ret:%d, sql:[%s]", iRet, strSql.c_str());
        }
    }
    return iRet;
}

vec_t SqliteDB::GetDataSingleLine(const char *tablename, const char *column, const char *whereCon) {
    vec_t vecResult;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    } else {
        strSql = strSql + column + " from " + tablename + ";";
    }
    zlog_info(zct, "[GetDataSingleLine] sql:%s", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
        sqlite3_finalize(stmt);
        return vecResult;
    }
    int retStep = sqlite3_step(stmt);
    int column_count = sqlite3_column_count(stmt);
    if (retStep == SQLITE_ROW) {
        for (int iCol = 0; iCol < column_count; iCol++) {
            char *columninfo = (char *)sqlite3_column_text(stmt, iCol);
            std::string str = columninfo != NULL ? columninfo : "";
            vecResult.push_back(str);
        }
    }
    sqlite3_finalize(stmt);
    return vecResult;
}

std::string SqliteDB::GetData(const char *tablename, const char *column, const char *whereCon) {
    std::string strRes = "";
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    } else {
        strSql = strSql + column + " from " + tablename + ";";
    }
    zlog_info(zct, "[GetData] sql:%s", strSql.c_str());
    sqlite3_stmt *stmt;

    mtx_.lock();
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
        sqlite3_finalize(stmt);
        mtx_.unlock();
        return strRes;
    }
    int retStep = sqlite3_step(stmt);
    if (retStep == SQLITE_ROW) {
        char *columninfo = (char *)sqlite3_column_text(stmt, 0);
        strRes = columninfo != NULL ? columninfo : "";
    }
    sqlite3_finalize(stmt);
    mtx_.unlock();
    return strRes;
}
array_t SqliteDB::GetDataMultiLine(const char *sql){
    array_t arrResult;
    zlog_info(zct, "[GetDataMultiLine] sql:%s", sql);
    sqlite3_stmt *stmt;
    mtx_.lock();
    if (sqlite3_prepare_v2(mDBAcess, sql, -1, &stmt, 0) != SQLITE_OK) {
        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), sql);
        sqlite3_finalize(stmt);
        mtx_.unlock();
        return arrResult;
    }
    int retStep = sqlite3_step(stmt);
    int column_count = sqlite3_column_count(stmt);
    while (retStep == SQLITE_ROW) {
        vec_t vecResult;
        for (int iCol = 0; iCol < column_count; iCol++) {
            char *columninfo = (char *)sqlite3_column_text(stmt, iCol);
            std::string str = columninfo != NULL ? columninfo : "";
            vecResult.push_back(str);
        }
        arrResult.push_back(vecResult);
        retStep = sqlite3_step(stmt);
    }
    sqlite3_finalize(stmt);
    mtx_.unlock();
    return arrResult;
}
array_t SqliteDB::GetDataMultiLine(const char *tablename, const char *column, const char *whereCon) {
    array_t arrResult;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    } else {
        strSql = strSql + column + " from " + tablename + ";";
    }

    zlog_info(zct, "[GetDataMultiLine] sql:%s", strSql.c_str());
    sqlite3_stmt *stmt;
    mtx_.lock();
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
        sqlite3_finalize(stmt);
        mtx_.unlock();
        return arrResult;
    }
    int retStep = sqlite3_step(stmt);
    int column_count = sqlite3_column_count(stmt);
    while (retStep == SQLITE_ROW) {
        vec_t vecResult;
        for (int iCol = 0; iCol < column_count; iCol++) {
            char *columninfo = (char *)sqlite3_column_text(stmt, iCol);
            std::string str = columninfo != NULL ? columninfo : "";
            vecResult.push_back(str);
        }
        arrResult.push_back(vecResult);
        retStep = sqlite3_step(stmt);
    }
    sqlite3_finalize(stmt);
    mtx_.unlock();
    return arrResult;
}

array_t SqliteDB::GetDataMultiLineTransaction(const char *tablename, const char *column, const char *whereCon) {
    array_t arrResult;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    } else {
        strSql = strSql + column + " from " + tablename + ";";
    }
    zlog_info(zct, "[GetDataMultiLineTransaction] sql:%s", strSql.c_str());
    sqlite3_exec(mDBAcess, "BEGIN", 0, 0, NULL);
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
        sqlite3_finalize(stmt);
        return arrResult;
    }
    sqlite3_reset(stmt);
    sqlite3_bind_int(stmt, 1, 0);
    int retStep = sqlite3_step(stmt);
    int column_count = sqlite3_column_count(stmt);
    while (retStep == SQLITE_ROW) {
        vec_t vecResult;
        for (int iCol = 0; iCol < column_count; iCol++) {
            char *columninfo = (char *)sqlite3_column_text(stmt, iCol);
            std::string str = columninfo != NULL ? columninfo : "";
            vecResult.push_back(str);
        }
        arrResult.push_back(vecResult);
        retStep = sqlite3_step(stmt);
    }
    sqlite3_finalize(stmt);
    sqlite3_exec(mDBAcess, "COMMIT", 0, 0, NULL);
    return arrResult;
}

vec_t SqliteDB::GetDataMultiLineOfOneColumn(const char *tablename, const char *column, const char *whereCon) {
    vec_t vecResult;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    } else {
        strSql = strSql + column + " from " + tablename + ";";
    }
    zlog_info(zct, "[GetDataMultiLineOfOneColumn] sql:%s", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
        sqlite3_finalize(stmt);
        return vecResult;
    }
    int retStep = sqlite3_step(stmt);
    while (retStep == SQLITE_ROW) {
        char *columninfo = (char *)sqlite3_column_text(stmt, 0);
        std::string str = columninfo != NULL ? columninfo : "";
        vecResult.push_back(str);
        retStep = sqlite3_step(stmt);
    }
    sqlite3_finalize(stmt);
    return vecResult;
}

vec_Value SqliteDB::GetDataMultiLineOfOneColumnDouble(const char *tablename, const char *column, const char *whereCon) {
    vec_Value vecResult;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    } else {
        strSql = strSql + column + " from " + tablename + ";";
    }

    zlog_info(zct, "[GetDataMultiLineOfOneColumnDouble] sql:%s", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
        sqlite3_finalize(stmt);
        return vecResult;
    }
    int retStep = sqlite3_step(stmt);
    while (retStep == SQLITE_ROW) {
        double columninfo = sqlite3_column_double(stmt, 0);
        vecResult.push_back(columninfo);
        retStep = sqlite3_step(stmt);
    }
    sqlite3_finalize(stmt);
    return vecResult;
}

int SqliteDB::DeleteTableData(const char *tablename, const char *whereCond) {
    std::string strSql = "delete from ";
    if (whereCond != NULL) {
        strSql = strSql + tablename + " where " + whereCond + ";";
    } else {
        strSql = strSql + tablename + ";";
    }

    zlog_info(zct, "[DeleteTableData] sql:%s", strSql.c_str());
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, strSql.c_str());
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::DeleteTableDataOneConditon(const char *tablename, const char *condColumnName, const char *condColumnValue) {
    std::string strSql = "delete from ";
    if (condColumnName != NULL) {
        strSql = strSql + tablename + " where " + condColumnName + "='" + condColumnValue + "';";
    } else {
        strSql = strSql + tablename + ";";
    }
    zlog_info(zct, "[DeleteTableDataOneConditon] sql:%s", strSql.c_str());
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, strSql.c_str());
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::UpdateNodeNameData(const char *tablename, const char *updateColumn, const char *whereCond) {
    std::string strSql = "update ";
    char szSql[1024] = {0x00};
    strcat(szSql, "update ");
    if (whereCond != NULL) {
        strcat(szSql, tablename);
        strcat(szSql, " set ");
        strcat(szSql, updateColumn);
        strcat(szSql, " where ");
        strcat(szSql, whereCond);
        strcat(szSql, ";");
        strSql = strSql + tablename + " set " + updateColumn + " where " + whereCond + ";";
    } else {
        strSql = strSql + tablename + " set " + updateColumn + ";";
    }
    zlog_info(zct, "[UpdateNodeNameData] sql:%s", strSql.c_str());
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(), szSql, 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, strSql.c_str());
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::UpdateTableData(const char *tablename, const char *updateColumn, const char *whereCond) {
    std::string strSql = "update ";
    if (whereCond != NULL) {
        strSql = strSql + tablename + " set " + updateColumn + " where " + whereCond + ";";
    } else {
        strSql = strSql + tablename + " set " + updateColumn + ";";
    }
    zlog_info(zct, "[UpdateTableData] sql:%s", strSql.c_str());
    char *msg;
    mtx_.lock();
    int iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, strSql.c_str());
        sqlite3_free(msg);
    }
    mtx_.unlock();
    return iRet;
}

int SqliteDB::UpdateTableData(const char *directSql) {
    zlog_info(zct, "[UpdateTableData] sql:%s", directSql);
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(), directSql, 0, 0, &msg);
    if (iRet != SQLITE_OK) {
        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, directSql);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::UpdateTableDataOneColumn(const char *tablename, const char *columnName, const char *columnValue, const char *whereColName, const char *whereColValue) {
    std::string strSql = "update ";
    if (whereColName != NULL) {
        strSql = strSql + tablename + " set " + columnName + "='" + columnValue + "'" + " where " + whereColName + "='" + whereColValue + "';";
    } else {
        strSql = strSql + tablename + " set " + columnName + "='" + columnValue + "';";
    }
    zlog_info(zct, "[UpdateTableDataOneColumn] sql:%s", strSql.c_str());
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);
    if (iRet != SQLITE_OK) {
        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, strSql.c_str());
        sqlite3_free(msg);
    }
    return iRet;
}
int callback(void *data, int argc, char **argv, char **azColName) {
    // 如果需要处理查询结果，可以在此回调函数中进行操作
    for (int i = 0; i < argc; i++) {
        zlog_error(zct,"%s = %s", azColName[i], argv[i] ? argv[i] : "NULL");
    }
    return 0;
}

int SqliteDB::execute_sql_file(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (file == NULL) {
        zlog_error(zct,"无法打开 SQL 文件");
        return 1;
    }

    // 获取文件大小
    fseek(file, 0, SEEK_END);
    long file_size = ftell(file);
    fseek(file, 0, SEEK_SET);

    // 为文件内容分配内存
    char *sql = (char *)malloc(file_size + 1);
    if (sql == NULL) {
        zlog_error(zct,"内存分配失败");
        fclose(file);
        return 2;
    }

    // 读取文件内容到内存
    fread(sql, 1, file_size, file);
    sql[file_size] = '\0';  // 确保字符串结尾

    fclose(file);

    // 执行 SQL 文件中的语句
    char *err_msg = NULL;
    if (sqlite3_exec(GetDbHandle(), sql, callback, 0, &err_msg) != SQLITE_OK) {
        zlog_error(zct, "执行 SQL 错误: %s", err_msg);
        sqlite3_free(err_msg);
        free(sql);
        return 3;
    }
    free(sql);
    return 0;
}
int SqliteDB::InsertData(const char *tablename, const char *insertValues, int replace, bool expandable) {
    char *msg;
    int iRet = 0;
    if (expandable) {
        char *strSql = (char *)malloc(4096);
        if (strSql == NULL) {
            zlog_error(zct, "malloc error");
            abort();
        }
        char strReplace[] = "replace into ";
        memset(strSql, 0, 4096);
        if (replace == 0) {
            memset(strReplace, 0, sizeof(strSql));
        }
        sprintf(strSql, "%s %s%s %s %s %s", "insert into", strReplace, tablename, "values(", insertValues, ");");
        zlog_info(zct, "[InsertData] expandable sql:%s", strSql);

        iRet = sqlite3_exec(GetDbHandle(), strSql, 0, 0, &msg);
        if (iRet != SQLITE_OK) {
            zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, strSql);
            sqlite3_free(msg);
        }
        free(strSql);
    } else {
        std::string strSql = "insert into ";
        if (replace != 0) {
            strSql = "replace into ";
        }
        strSql = strSql + tablename + " values(" + insertValues + ");";
        zlog_info(zct, "[InsertData] nonexpandable sql:%s", strSql.c_str());

        iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);
        if (iRet != SQLITE_OK) {
            zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, strSql.c_str());
            sqlite3_free(msg);
        }
    }

    return iRet;
}

int SqliteDB::InsertData(const char *insertSql) {
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(), insertSql, 0, 0, &msg);
    if (iRet != SQLITE_OK) {
        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, insertSql);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::CalculateBattery() {
    zlog_info(zct, "CalculateBattery start");
    char whereCon[1024] = {0};
    char selectSql[1024] = {0};
    memset(whereCon, 0x00, sizeof(whereCon));
    memset(selectSql, 0x00, sizeof(selectSql));
    char updateSql[1024] = {0};
    int res = 0;
    sprintf(selectSql, " dataNodeNo,StaticTime,WaveTime,featureInterVal,waveInterVal,samplingRate,batteryPower ");
    array_t vecRes = GetDataMultiLine(T_SENSOR_INFO(TNAME), selectSql, NULL);
    zlog_info(zct, "Size = %d", vecRes.size());
    if (vecRes.size() > 0) {
        for (size_t i = 0; i < vecRes.size(); i++) {
            float capacity = 0.0, startCapacity = 0.0;
            memset(whereCon, 0x00, sizeof(whereCon));
            memset(selectSql, 0x00, sizeof(selectSql));
            sprintf(whereCon, " dataNodeNo = '%s' and batteryRemain <> '' order by timeStamp desc limit 0,1 ", vecRes[i][0].c_str());
            vec_t vecResSig = sqlite_db_ctrl::instance().GetDataSingleLine(T_BATTERY_INFO(TNAME), " * ", whereCon);
            std::vector<std::string> vParam;
            boost::split(vParam, vecRes[i][6], boost::is_any_of(","), boost::token_compress_on);
            if (vParam.size() <= 0 || vecResSig.size() <= 0) { //第一次计算
                memset(whereCon, 0x00, sizeof(whereCon));
                sprintf(whereCon, "dataNodeNo = '%s' ", vecRes[i][0].c_str());
                std::string Dip = sqlite_db_ctrl::instance().GetData(T_DATASTATIC_INFO(TNAME), " dip ", whereCon);
                if (Dip == "") {
                    continue;
                }
                capacity = (0.9 + 0.1 * (90 - atoi(Dip.c_str())) / 90) * 19000; // mAh //电池总量
                startCapacity = capacity;

                sprintf(updateSql, "batteryPower = '%f,%f' ", startCapacity, startCapacity);

                res = UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
                if(res !=0 ){
                    zlog_error(zct, "res = %d", res);
                    break;
                }
                memset(whereCon, 0x00, sizeof(whereCon));
                sprintf(whereCon, " dataNodeNo = '%s' order by timeStamp asc limit 0,1 ", vecRes[i][0].c_str());
                vecResSig = sqlite_db_ctrl::instance().GetDataSingleLine(T_BATTERY_INFO(TNAME), " * ", whereCon);
                if (vecResSig.size() <= 0) { //一条数据都没有
                    continue;
                }
            } else {
                capacity = atof(vecResSig[7].c_str());
            }

            zlog_info(zct, "dip = %d", atoi(vecResSig[1].c_str()));

            zlog_info(zct, "capacity = %f", capacity);
            sprintf(whereCon, " dataNodeNo = '%s' and timeStamp > '%s'", vecRes[i][0].c_str(), vecResSig[8].c_str());
            array_t vecResbattery = GetDataMultiLine(T_BATTERY_INFO(TNAME), " * ", whereCon);
            zlog_info(zct, "vecResbattery size = %d", vecResbattery.size());
            if (vecResbattery.size() <= 0) {
                continue;
            }
            int y10_mins = 10 * 365 * 24 * 60;
            int d200_mins = 200 * 24 * 60;
            int x1 = 25, x2 = 60;
            int y1 = 2;
            float y2 = (float)y10_mins / (float)d200_mins;

            float k = (y2 - y1) / (x2 - x1);
            std::vector<float> vecb;
            std::vector<long> vecworkTime;
            std::vector<long> vecsendTime;
            float to_math = 0.0;
            zlog_info(zct, "vecResbattery = %d,temp = %s", vecResbattery.size(), vecResbattery[0][2].c_str());

            for (size_t j = 0; j < vecResbattery.size(); j++) {
                float b = 2 - 25 * k;
                float dpm = k * atoi(vecResbattery[j][2].c_str()) + b; //温度
                float cost_e = dpm * atoi(vecRes[i][3].c_str());       //特征值时间间隔
                float cost_h = cost_e / 60;
                vecworkTime.push_back(atol(vecResbattery[j][3].c_str()));
                vecsendTime.push_back(atol(vecResbattery[j][4].c_str()));
                to_math += cost_h;
            }

            zlog_info(zct, "自放电 = %f", to_math);
            long sumworkTime = 0.0, sumsendTime = 0.0;
            for (size_t j = 0; j < vecworkTime.size(); j++) {
                sumworkTime += vecworkTime[j];
            }
            for (size_t j = 0; j < vecsendTime.size(); j++) {
                sumsendTime += vecsendTime[j];
            }
            zlog_info(zct, "sumworkTime = %ld,sumsendTime = %ld", sumworkTime, sumsendTime);

            float usageworkTime = ((float)sumworkTime / 3600000) * 4;
            float usagesendTime = ((float)sumsendTime / 3600000) * 39;
            zlog_info(zct, "work = %f,send = %f", usageworkTime, usagesendTime);

            if (to_math < 0) to_math = 0;
            float usageBattery = usageworkTime + usagesendTime + to_math;
            zlog_info(zct, "已经使用 = %f", atof(vecResSig[6].c_str()));

            float remainBattery = capacity - usageBattery * 0.2;
            if (remainBattery < 10) {
                remainBattery = 10;
            }

            zlog_info(zct, "dataNodeNo = %s,batteryUsage = %f,batteryRemain = %f", vecRes[i][0].c_str(), atof(vecResSig[6].c_str()), remainBattery);
            memset(whereCon, 0x00, sizeof(whereCon));
            sprintf(whereCon, " dataNodeNo = '%s'  order by timeStamp desc limit 0,1 ", vecRes[i][0].c_str());
            std::string strtimeStamp = GetData(T_BATTERY_INFO(TNAME), " timeStamp ", whereCon);

            sprintf(updateSql, "batteryUsage='%f',batteryRemain='%f'", usageBattery, remainBattery);
            memset(whereCon, 0x00, sizeof(whereCon));
            sprintf(whereCon, "dataNodeNo ='%s' and timeStamp = '%s'", vecRes[i][0].c_str(), strtimeStamp.c_str());
            res = UpdateTableData(T_BATTERY_INFO(TNAME), updateSql, whereCon);
            if(res !=0 ){
                zlog_error(zct, "res = %d", res);
                break;
            }
            memset(whereCon, 0x00, sizeof(whereCon));
            memset(updateSql, 0x00, sizeof(updateSql));

            char insertSql[1024] = {0x00}, deleteSql[1024] = {0x00};
            sprintf(insertSql, "insert into t_battery_history select * from t_battery_info where timeStamp < '%s' and dataNodeNo = '%s'", strtimeStamp.c_str(), vecRes[i][0].c_str());
            res = ExeSql(insertSql);
            if(res !=0 ){
                zlog_error(zct, "res = %d", res);
                break;
            }
            sprintf(deleteSql, "delete  from t_battery_info where timeStamp < '%s' and dataNodeNo = '%s'", strtimeStamp.c_str(), vecRes[i][0].c_str());
            res = ExeSql(deleteSql);
            if(res !=0 ){
                zlog_error(zct, "res = %d", res);
                break;
            }
            sprintf(whereCon, "dataNodeNo = '%s' ", vecRes[i][0].c_str());
            if (startCapacity > 0) {
                sprintf(updateSql, "batteryPower = '%f,%f' ", startCapacity, remainBattery);
            } else {
                sprintf(updateSql, "batteryPower = '%s,%f' ", vParam[0].c_str(), remainBattery);
            }

            UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
            std::string strData = sqlite_db_ctrl::instance().GetNodeConfigureInfor(whereCon);
            res = data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
            if(res !=0 ){
                zlog_error(zct, "data_publish res = %d", res);
                break;
            }
        }
    }
    zlog_info(zct, "CalculateBattery end");
    return res;
}

int SqliteDB::CalculateDip() {
    char whereCon[1024] = {0};
    char selectSql[1024] = {0};
    char updateSql[1024] = {0};
    memset(whereCon, 0x00, sizeof(whereCon));
    memset(selectSql, 0x00, sizeof(selectSql));
    sprintf(selectSql, " DataNodeNo");
    array_t vecRes;
    char looseValue[10] = {0x00};
    char localtimestamp[32] = {0};
    GetTimeNet(localtimestamp, 1);
    int res = 0;
    readStringValue("config", "loose", looseValue, (char *)GlobalConfig::Config_G.c_str());
    vecRes = GetDataMultiLine(T_SENSOR_INFO(TNAME), " * ", NULL);
    zlog_info(zct, "vecRes111 = %d", vecRes.size());
    for (size_t i = 0; i < vecRes.size(); i++) {
        std::vector<std::string> vParam;
        zlog_info(zct, "vecRes = %s", vecRes[i][42].c_str());
        boost::split(vParam, vecRes[i][42], boost::is_any_of(","), boost::token_compress_on);
        zlog_info(zct, "vParam size = %d", vParam.size());
        if (vParam.size() < 2) {
            sprintf(updateSql, "LooseValue = '%f,0' ", atof(vParam[0].c_str()));
            sprintf(whereCon, "dataNodeNo = '%s' ", vecRes[i][0].c_str());
            res = UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
            if(res !=0 ){
                zlog_error(zct, "res = %d", res);
                break;
            }
        } else {
            char szTablename[32] = {0x00};
            memset(whereCon, 0x00, sizeof(whereCon));
            if (vParam[1] == "2") { //人工干预
                sprintf(whereCon, " timeStamp > '%ld' ", atol(vParam[2].c_str()));
            } else if (vParam[1] == "0") {                                              //正常状态
                sprintf(whereCon, " timeStamp > '%ld' ", atol(localtimestamp) - 86400); //一天数据
            } else if (vParam[1] == "1") {                                              //松动状态
                continue;
            }
            zlog_info(zct, "vParam[0]=%s,vParam[1]=%s", vParam[0].c_str(), vParam[1].c_str());

            sprintf(szTablename, "t_dataStatic_%s", vecRes[i][0].c_str());
            vec_Value vecResDip = GetDataMultiLineOfOneColumnDouble(szTablename, " Dip ", whereCon);
            float sample_variance = Calculation::getSample_variance(vecResDip);
            zlog_info(zct, "sample_variance = %f", sample_variance);
            memset(whereCon, 0x00, sizeof(whereCon));
            memset(updateSql, 0x00, sizeof(updateSql));
            sprintf(whereCon, "dataNodeNo = '%s' ", vecRes[i][0].c_str());
            if (vParam[1] == "0") {
                if (sample_variance > atol(looseValue)) {
                    sprintf(updateSql, "LooseValue = '%f,1' ", sample_variance);
                } else {
                    sprintf(updateSql, "LooseValue = '%f,0' ", sample_variance);
                }
            } else if (vParam[1] == "1") {
            } else if (vParam[1] == "2") {
                zlog_info(zct, "localtimestamp = %ld,vParam[2]=%ld,%ld", atol(localtimestamp), atol(vParam[2].c_str()), atol(localtimestamp) - atol(vParam[2].c_str()));
                if (atol(localtimestamp) - atol(vParam[2].c_str()) > 86400) {
                    sprintf(updateSql, "LooseValue = '%f,0' ", atof(vParam[0].c_str()));
                } else {
                    sprintf(updateSql, "LooseValue = '%f,2,", atof(vParam[0].c_str()));
                    std::string strUpdateSql = std::string(updateSql) + vParam[2] + "' ";
                    memset(updateSql, 0x00, sizeof(updateSql));
                    memcpy(updateSql, strUpdateSql.c_str(), sizeof(updateSql));
                }
                if (sample_variance > atol(looseValue)) {
                    sprintf(updateSql, "LooseValue = '%f,1' ", sample_variance);
                }
            }
        }

        res = UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
        if(res !=0 ){
            zlog_error(zct, "res = %d", res);
            break;
        }
    }
    zlog_info(zct, "CalculateDip");
    return res;
}

int SqliteDB::InintGateway() {
    //更新网关配置表
    std::string strIP = GetGwIp_("eth0");
    std::string strServerIP = ReadStrByOpt(SERVERCONFIG, "Server", "localServerIpAddress");
    std::string strServerPort = ReadStrByOpt(SERVERCONFIG, "Server", "localServerPort");
    std::string strwebVersion = ReadStrByOpt(SYSTEMINFOFILE, "Version", "WebVersion");
    std::string strsystemVersion = ReadStrByOpt(SYSTEMINFOFILE, "Version", "SystemVersion");
    std::string strGatewayVersion = ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayVersion");
    std::string strchan = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");
    std::string strPanID = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "PanID");
    int res = 0;
    if (strPanID == "") {
        strPanID = GlobalConfig::MacAddr_G.substr(8);
    }
    if (0 == sqlite_db_ctrl::instance().GetTableRows(T_GATEWAY_INFO(TNAME), NULL)) {
        char strSql[1024] = {0};
        sprintf(strSql, "insert into t_gateway_info(gatewayMAC,zigbeePanID,zigbeeChannel,\
	    		localIP,systemVersion,programVersion,webVersion,serverIP,serverPort,MAC2)\
	    		values('%s','%s','%s','%s','%s','%s','%s','%s','%s','%s');",
                GlobalConfig::MacAddr_G.c_str(), strPanID.c_str(), strchan.c_str(), strIP.c_str(), strsystemVersion.c_str(), strGatewayVersion.c_str(), strwebVersion.c_str(), strServerIP.c_str(), strServerPort.c_str(), GlobalConfig::MacAddr_G2.c_str());
        res = sqlite_db_ctrl::instance().InsertData(strSql);
        if(res !=0 ){
            zlog_error(zct, "res = %d", res);
        }
        zlog_info(zct, "strSql = %s", strSql);
    } else {
        char whereCon[1024] = {0};
        char updateSql[1024] = {0};
        sprintf(updateSql, "zigbeePanID = '%s',zigbeeChannel = '%s',localIP = '%s',systemVersion='%s',programVersion='%s',webVersion='%s',serverIP='%s',serverPort='%s'", strPanID.c_str(), strchan.c_str(), strIP.c_str(), strsystemVersion.c_str(), strGatewayVersion.c_str(),
                strwebVersion.c_str(), strServerIP.c_str(), strServerPort.c_str());
        sprintf(whereCon, "gatewayMAC='%s'", GlobalConfig::MacAddr_G.c_str());
        res = sqlite_db_ctrl::instance().UpdateTableData(T_GATEWAY_INFO(TNAME), updateSql, whereCon);
        if(res !=0 ){
            zlog_error(zct, "res = %d", res);
        }
    }

    //上传网关配置到MQTT
    Json::Value jsSystemSetting;
    Json::Value jsBody;
    Json::FastWriter showValue;
    Json::Value jsonVal;
    jsonVal.clear();

    jsonVal["cmd"] = "23";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsSystemSetting["WebVersion"] = strwebVersion;
    jsSystemSetting["SystemVersion"] = strsystemVersion;
    jsSystemSetting["GateWayVersion"] = strGatewayVersion;
    jsBody["localServerIpAddress"] = ReadStrByOpt(SERVERCONFIG, "Server", "localServerIpAddress");
    jsBody["localServerPort"] = atoi(ReadStrByOpt(SERVERCONFIG, "Server", "localServerPort").c_str());
    jsBody["CommMode"] = atoi(ReadStrByOpt(SERVERCONFIG, "Server", "CommMode").c_str());
    jsBody["Password"] = (ReadStrByOpt(SERVERCONFIG, "Server", "Password"));
    jsBody["UserName"] = (ReadStrByOpt(SERVERCONFIG, "Server", "UserName"));
    std::string dataBody = showValue.write(jsBody);
    jsonVal["cmdBody"] = dataBody;
    res = data_publish(showValue.write(jsonVal).c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
    if(res !=0 ){
        zlog_warn(zct, "data_publish res = %d", res);
    }
    jsBody.clear();
    jsonVal["cmd"] = "25";
    jsBody["dnsName"] = ReadStrByOpt(NETWORKCONFIG, "Net", "dnsName");
    jsBody["networkPortStatus"] = ReadStrByOpt(NETWORKCONFIG, "Net", "networkPortStatus");
    jsBody["gateway"] = ReadStrByOpt(NETWORKCONFIG, "Net", "gateway");
    jsBody["subnetMask"] = ReadStrByOpt(NETWORKCONFIG, "Net", "subnetMask");
    jsBody["dataWatchIpAddress"] = ReadStrByOpt(NETWORKCONFIG, "Net", "ipAddress");
    jsBody["hostName"] = ReadStrByOpt(NETWORKCONFIG, "Net", "hostName");

    dataBody = showValue.write(jsBody);
    jsonVal["cmdBody"] = dataBody;
    res = data_publish(showValue.write(jsonVal).c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
    if(res !=0 ){
        zlog_warn(zct, "data_publish res = %d", res);
    }
    return res;
}

std::string SqliteDB::GetNodeConfigureInfor(const char *whereCon) {
    Json::Value jsonVal;
    Json::FastWriter showValue;
    jsonVal.clear();
    jsonVal["cmd"] = "26";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = "查询成功";
    Json::Value jsArray;
    array_t arrRes;
    arrRes = sqlite_db_ctrl::instance().GetDataMultiLine(T_SENSOR_INFO(TNAME), "*", whereCon);
    int iResult = arrRes.size();
    if (iResult > 0) {
        for (int j = 0; j < iResult; j++) {
            Json::Value jsSensorData;
            jsSensorData["dataNodeNo"] = arrRes[j][44];
            jsSensorData["dataNodeName"] = arrRes[j][1];
            jsSensorData["initFlag"] = atoi(arrRes[j][2].c_str());
            jsSensorData["accFlag"] = atoi(arrRes[j][3].c_str());
            jsSensorData["zigbeeFlag"] = atoi(arrRes[j][4].c_str());
            jsSensorData["temTopFlag"] = atoi(arrRes[j][5].c_str());
            jsSensorData["temBotFlag"] = atoi(arrRes[j][6].c_str());
            jsSensorData["equipsta"] = atoi(arrRes[j][7].c_str());
            jsSensorData["hardVersion"] = arrRes[j][8];
            jsSensorData["softVersion"] = arrRes[j][9];
            jsSensorData["bpNo"] = arrRes[j][10];
            jsSensorData["serialNo"] = arrRes[j][11];
            jsSensorData["firstPowerTime"] = arrRes[j][12];
            jsSensorData["WakeupTime"] = atoi(arrRes[j][13].c_str());
            jsSensorData["StaticTime"] = atoi(arrRes[j][14].c_str());
            jsSensorData["WaveTime"] = atoi(arrRes[j][15].c_str());
            jsSensorData["BateryV"] = arrRes[j][16];
            jsSensorData["ProductNo"] = arrRes[j][17];
            jsSensorData["configFlag"] = atoi(arrRes[j][18].c_str());
            jsSensorData["startBrands"] = arrRes[j][19];
            jsSensorData["stopBrands"] = arrRes[j][20];
            jsSensorData["featureInterVal"] = (arrRes[j][21]);
            jsSensorData["waveInterVal"] = atoi(arrRes[j][22].c_str());
            jsSensorData["samplingRate"] = atoi(arrRes[j][23].c_str());
            jsSensorData["range"] = atoi(arrRes[j][25].c_str());
            jsSensorData["envelopeBandPass"] = arrRes[j][26];
            jsSensorData["faultFrequency"] = arrRes[j][27];
            jsSensorData["zigbeePanId"] = arrRes[j][28];
            jsSensorData["zigbeeChannel"] = (arrRes[j][29]);
            jsSensorData["zigbeeAddr"] = arrRes[j][30];
            jsSensorData["zigbeeLongAddr"] = arrRes[j][31];
            jsSensorData["zigbeeDesAddr"] = arrRes[j][32];
            jsSensorData["ZigbeePower"] = atoi(arrRes[j][33].c_str());
            jsSensorData["ZigbeeRetry"] = atoi(arrRes[j][34].c_str());
            jsSensorData["ZigbeeRetryGap"] = atoi(arrRes[j][35].c_str());
            jsSensorData["ACCSampleTime"] = atoi(arrRes[j][36].c_str());
            jsSensorData["status"] = atoi(arrRes[j][37].c_str());
            jsSensorData["timeStamp"] = arrRes[j][38];
            jsSensorData["viff"] = atoi(arrRes[j][39].c_str());
            jsSensorData["RSSI"] = arrRes[j][40];
            jsSensorData["Update"] = atoi(arrRes[j][41].c_str());
            jsSensorData["looseValue"] = arrRes[j][42];
            jsSensorData["battery"] = arrRes[j][43];
            jsSensorData["MeasurementID"] = arrRes[j][44];
            jsSensorData["nodeWaveSend"] = arrRes[j][45];
            jsArray.append(jsSensorData);
        }
    } else {
        jsArray.resize(0);
        jsonVal["success"] = false;
        jsonVal["message"] = "查询失败";
    }

    Json::Value jsBody;
    jsBody["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsBody["dataNodeArray"] = jsArray;
    std::string dataBody = showValue.write(jsBody);
    jsonVal["cmdBody"] = dataBody;
    return showValue.write(jsonVal);
}

int SqliteDB::QueryofflineData() {
    int res = 0;
    array_t arrRetdataNode = GetDataMultiLine(T_SENSOR_INFO(TNAME), " dataNodeNo,MeasurementID ", NULL);
    for (size_t i = 0; i < arrRetdataNode.size(); i++) {
        char StaticTableName[50] = {0x00};
        sprintf(StaticTableName, "t_dataStatic_%s", arrRetdataNode[i][0].c_str());

        array_t arrRetData = GetDataMultiLine(StaticTableName, "*", "sendMsg = '0' order by timeStamp asc");
        zlog_info(zct, "mqttresend check datanodeNo %s,data count %d", arrRetdataNode[i][0].c_str(), arrRetData.size());
        if (arrRetData.size() < 1) continue;
        for (size_t j = 0; j < arrRetData.size(); j++) {
            char dataTableName[50] = {0x00};
            sprintf(dataTableName, "t_data_%s", arrRetdataNode[i][0].c_str());
            char tmpWhere[128] = {0x00};
            sprintf(tmpWhere, "sendMsg = '0' and timeStamp = '%s'", arrRetData[j][8].c_str());
            array_t arrRet = GetDataMultiLine(dataTableName, "*", "sendMsg = '0'");
            if (arrRet.size() > 0) {
                Json::Value valNodeData;
                Json::Value valNodeFeature;
                for (size_t k = 0; k < arrRet.size(); k++) {
                    valNodeFeature["dataNodeNo"] = arrRetdataNode[i][1].c_str();
                    valNodeFeature["ChannelId"] = arrRet[k][1].c_str();
                    valNodeFeature["diagnosisPk"] = atof(arrRet[k][2].c_str());
                    valNodeFeature["integratPk"] = atof(arrRet[k][3].c_str());
                    valNodeFeature["integratRMS"] = atof(arrRet[k][4].c_str());
                    valNodeFeature["rmsValues"] = atof(arrRet[k][5].c_str());
                    valNodeFeature["envelopEnergy"] = atof(arrRet[k][6].c_str());
                    valNodeFeature["Amp1"] = atof(arrRet[k][7].c_str());
                    valNodeFeature["Amp2"] = atof(arrRet[k][8].c_str());
                    valNodeFeature["Amp3"] = atof(arrRet[k][9].c_str());
                    valNodeFeature["Amp4"] = atof(arrRet[k][10].c_str());
                    valNodeFeature["Amp5"] = atof(arrRet[k][1].c_str());
                    valNodeFeature["Phase1"] = atof(arrRet[k][12].c_str());
                    valNodeFeature["Phase2"] = atof(arrRet[k][13].c_str());
                    valNodeFeature["Phase3"] = atof(arrRet[k][14].c_str());
                    valNodeFeature["Phase4"] = atof(arrRet[k][15].c_str());
                    valNodeFeature["timeStamp"] = atoi(arrRet[k][17].c_str());
                    valNodeData.append(valNodeFeature);
                }
            }
            //无线传感器信息
            Json::Value root;
            Json::Value valdatastatic;
            Json::Value valNodeData;
            valdatastatic["TemperatureTop"] = atof(arrRetData[j][2].c_str());
            valdatastatic["TemperatureBot"] = atof(arrRetData[j][3].c_str());
            valdatastatic["Dip"] = atof(arrRetData[j][4].c_str());
            valdatastatic["Voltage"] = atof(arrRetData[j][5].c_str());
            valdatastatic["ChannelType"] = "STATUS";
            valdatastatic["ChannelId"] = (arrRetData[j][1].c_str());
            valdatastatic["TimeStamp"] = atoi(arrRetData[j][8].c_str());

            valdatastatic["dataNodeNo"] = arrRetData[j][0].c_str();
            valNodeData.append(valdatastatic);

            root["data"] = valNodeData;
            root["TimeStamp"] = atoi(arrRetData[j][8].c_str());
            root["dataNodeNo"] = arrRetdataNode[i][1].c_str();
            root["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
            root["status"] = "resend";
            Json::FastWriter featureValue;
            std::string strstatisticData = featureValue.write(root);

            int iRet = data_publish(strstatisticData.c_str(), GlobalConfig::Topic_G.mPubData.c_str());
            if (iRet == 0) {
                char updateSql[1024] = {0};
                char whereCon[64] = {0};
                memset(whereCon, 0, 64);
                sprintf(whereCon, "dataNodeNo = '%s' and TimeStamp = '%s'", arrRetData[j][0].c_str(), arrRetData[j][8].c_str());
                memcpy(updateSql, "sendMsg='1'", 11);
                res = sqlite_db_ctrl::instance().UpdateTableData(StaticTableName, updateSql, whereCon);
                if(res !=0 ){
                    zlog_error(zct, "res = %d", res);
                }
                res = sqlite_db_ctrl::instance().UpdateTableData(dataTableName, updateSql, whereCon);
                if(res !=0 ){
                    zlog_error(zct, "res = %d", res);
                }
            }else{
                zlog_error(zct, "data_publish res = %d", res);    
            }
        }
    }
    
    float frTemp = 0.0f;
    std::string sample;
    char whereCon[1024] = {0x00};
    char buf[30]={0};
    sprintf(whereCon, " SendMsg = 0 ");
    array_t arrRetData = GetDataMultiLine("t_data_waveSend", "*", whereCon);
    zlog_info(zct, "mqttresend check wave count %d", arrRetData.size());
    if (arrRetData.size() > 0) {
        for (size_t i = 0; i < arrRetData.size(); i++) {
            std::string strWaveData = "";
            if (access(arrRetData[i][1].c_str(), 0) >= 0) {
                std::vector<float> vecWave;
                char localtimestamp[32] = {0};
                float fTemp = 0;
                std::ifstream inFile(arrRetData[i][1].c_str(), std::ios::in | std::ios::binary);
                inFile.read((char *)localtimestamp, sizeof(localtimestamp));
                while (inFile.read((char *)&fTemp, sizeof(fTemp))) {
                    vecWave.push_back(fTemp);
                }
                memset(whereCon,0,sizeof(whereCon));
                std::string MeasurementID = arrRetData[i][0].erase(arrRetData[i][0].length() - 2);
                sprintf(whereCon," MeasurementID = '%s'",MeasurementID.c_str());
                sample = GetData(T_SENSOR_INFO(TNAME), " samplingRate ", whereCon);
                

                int id =  0;
                memset(resend_mqttData,0,sizeof(resend_mqttData));
                for (size_t i = 0; i < vecWave.size(); i++) {
                    memset(buf, 0x00, sizeof(buf));
                    sprintf(buf, "%.2f", frTemp);
                    if (i != vecWave.size() -1){
                        strncpy(resend_mqttData + id ,buf,strlen(buf));
                        id = id + strlen(buf);
                        strncpy(resend_mqttData + id,",",1);
                        id = id + 1;
                    }else{
                        strncpy(resend_mqttData + id ,buf,strlen(buf));
                    }
                }

                inFile.close();
            }
            Json::Value valWaveData;
            valWaveData["number"] = atoi(sample.c_str());
            valWaveData["channelId"] = arrRetData[i][0];
            valWaveData["dataNodeNo"] = arrRetData[i][0].substr(0, arrRetData[i][0].length() - 2);
            valWaveData["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
            valWaveData["SensorEngineeringUnit"] = "";
            valWaveData["timeStamp"] = arrRetData[i][2];
            valWaveData["waveData"] = resend_mqttData;
            Json::FastWriter WaveValue;
            std::string WaveData = WaveValue.write(valWaveData);
            int iRet = data_publish(WaveData.c_str(), GlobalConfig::Topic_G.mPubWaveData.c_str());
            if (iRet == 0) {
                char whereCon[1024] = {0x00};
                char updateSql[1024] = {0x00};
                sprintf(whereCon, "channelID='%s' and timeStamp = '%s' ", arrRetData[i][0].c_str(), arrRetData[i][2].c_str());
                sprintf(updateSql, "SendMsg = 1");
                res = sqlite_db_ctrl::instance().UpdateTableData("t_data_waveSend", updateSql, whereCon);
                if(res !=0 ){
                    zlog_error(zct, "res = %d", res);
                }
                std::string strCmd = "rm " + arrRetData[i][1];
                system(strCmd.c_str());
            }else{
                zlog_error(zct, "data_publish res = %d", res);
            }
        }
    }
    return res;
}

int SqliteDB::TransBegin() { return sqlite3_exec(mDBAcess, "begin;", 0, 0, 0); }

int SqliteDB::TransRollback() { return sqlite3_exec(mDBAcess, "rollback;", 0, 0, 0); }

int SqliteDB::TransCommit() { return sqlite3_exec(mDBAcess, "commit;", 0, 0, 0); }