diff --git a/dbaccess/sql_db.cpp b/dbaccess/sql_db.cpp
index 0136aea..b6731a5 100644
--- a/dbaccess/sql_db.cpp
+++ b/dbaccess/sql_db.cpp
@@ -11,7 +11,7 @@ SqliteDB::SqliteDB() {}
 
 SqliteDB::~SqliteDB() {}
 
-void SqliteDB::SqliteInit(const char *pDbName, bool isDB2) {
+void SqliteDB::SqliteInit(const char *pDbName) {
     char sql_exec[2048];
     memset(sql_exec, 0, 2048);
 
@@ -22,7 +22,7 @@ void SqliteDB::SqliteInit(const char *pDbName, bool isDB2) {
             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, isDB2);
+        CreateTable(sql_exec);
 
     int iRet = GetTableRows(" sqlite_master ", " name = 't_sensor_info' and sql LIKE '%LooseValue%' ");
     if (iRet == 0) {
@@ -44,17 +44,17 @@ void SqliteDB::SqliteInit(const char *pDbName, bool isDB2) {
 
     memset(sql_exec, 0, 2048);
     sprintf(sql_exec, "update t_sensor_info set MeasurementID = dataNodeNo where MeasurementID IS NULL ;");
-    UpdateTableData(sql_exec, isDB2);
+    UpdateTableData(sql_exec);
     memset(sql_exec, 0, 2048);
     sprintf(sql_exec, "update t_sensor_info set MeasurementID = dataNodeNo where MeasurementID = '' ;");
-    UpdateTableData(sql_exec, isDB2);
+    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);", 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, isDB2);
+    CreateTable(sql_exec);
 
     iRet = GetTableRows(" sqlite_master ", " name = 't_data_info' and sql LIKE '%nodeResend%' ");
     if (iRet == 0) {
@@ -65,7 +65,7 @@ void SqliteDB::SqliteInit(const char *pDbName, bool isDB2) {
     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);", 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, isDB2);
+    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'");
@@ -75,11 +75,11 @@ void SqliteDB::SqliteInit(const char *pDbName, bool isDB2) {
     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, isDB2);
+    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, isDB2);
+    CreateTable(sql_exec);
 
     iRet = GetTableRows(" sqlite_master ", " name = 't_data_waveSend' and sql LIKE '%sendMsg%' ");
     if (iRet == 0) {
@@ -93,12 +93,12 @@ void SqliteDB::SqliteInit(const char *pDbName, bool isDB2) {
     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, isDB2);
+    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, isDB2);
+    CreateTable(sql_exec);
 }
 
 void SqliteDB::Createtable(const char *ptableName) {
@@ -110,9 +110,7 @@ void SqliteDB::Createtable(const char *ptableName) {
             "sendMsg", "nodeResend");
     CreateTable(sql_exec, 0);
     memset(sql_exec, 0, 2048);
-    sprintf(sql_exec, "CREATE INDEX %s_1 \
-	    ON %s (%s)",
-            ptableName, ptableName, T_DATA_INFO(DATANODENO));
+    sprintf(sql_exec, "CREATE INDEX %s_1 ON %s (%s)", ptableName, ptableName, T_DATA_INFO(DATANODENO));
     CreateTable(sql_exec, 0);
 }
 
@@ -136,7 +134,7 @@ void SqliteDB::Deletetable(const char *ptableName) {
     sprintf(sql_exec, "DROP TABLE  %s ;", ptableName);
     int iRet = sqlite3_exec(GetDbHandle(false), sql_exec, 0, 0, NULL);
     if (iRet != SQLITE_OK) {
-        perror_info("sqlite3_exec");
+        zlog_error(zbt, "fail to delete table:%s", ptableName);
     }
 }
 
@@ -148,81 +146,60 @@ void SqliteDB::CreatedataStatictable(const char *ptableName) {
             T_DATASTATIC_INFO(VOLTAGE), "zigbeeSignal", "StaticIndex", T_DATASTATIC_INFO(TIMESTAMP), "sendMsg", "nodeResend", "zigbeeSignalNode", "statisticType", "timing");
     CreateTable(sql_exec, 0);
     memset(sql_exec, 0, 2048);
-    sprintf(sql_exec, "CREATE INDEX %s_1 ON %s (%s)",
-            ptableName, ptableName, T_DATA_INFO(DATANODENO));
+    sprintf(sql_exec, "CREATE INDEX %s_1 ON %s (%s)", ptableName, ptableName, T_DATA_INFO(DATANODENO));
     CreateTable(sql_exec, 0);
 }
 
-bool SqliteDB::OpenDB(const char *pDbName, bool isDB2) {
-    if (isDB2 == false) {
-        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);
-            print_info("Success To Open DataBase!\n");
-        } else {
-            zlog_error(zbt, "DB2 false, Fail To Open DataBase:%s, ret:%d", pDbName, ret);
-            return false;
-        }
+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);
+        print_info("Success To Open DataBase!\n");
     } else {
-        int ret = 0;
-        ret = sqlite3_open(pDbName, &mDb2);
-        if (ret == SQLITE_OK) {
-            sqlite3_exec(mDb2, "PRAGMA synchronous = NORMAL;", 0, 0, 0);
-            sqlite3_exec(mDb2, "PRAGMA cache_size=8000;", 0, 0, 0);
-            sqlite3_exec(mDb2, "PRAGMA temp_store = MEMORY;", 0, 0, 0);
-            sqlite3_exec(mDb2, "PRAGMA auto_vacuum = 1;", 0, 0, 0);
-            print_info("Success To Open DataBase!\n");
-        } else {
-            zlog_error(zbt, "DB2 true, Fail To Open DataBase:%s, ret:%d", pDbName, ret);
-            return false;
-        }
+        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(bool isDB2) {
-    if (isDB2 == false) {
-        return mDBAcess;
-    } else {
-        return mDb2;
-    }
-}
+sqlite3 *SqliteDB::GetDbHandle() { return mDBAcess; }
 
-int SqliteDB::CreateTable(const char *sql, bool isDB2) {
-    print_light_green("%s\n", sql);
+int SqliteDB::CreateTable(const char *sql) {
+    zlog_info(zct, "%s", sql);
     char *msg;
-    int iRet = sqlite3_exec(GetDbHandle(isDB2), sql, 0, 0, &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]\n", iRet, msg, sql);
+        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, bool isDB2) {
-    print_light_green("%s\n", sql);
+int SqliteDB::ExeSql(const char *sql) {
+    zlog_info(zct, "%s", sql);
     char *msg;
-    int iRet = sqlite3_exec(GetDbHandle(isDB2), sql, 0, 0, &msg);
+    int iRet = sqlite3_exec(GetDbHandle(), sql, 0, 0, &msg);
     if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
+        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, bool isDB2) {
+int SqliteDB::GetTableColumnCount(const char *tablename) {
     std::string strSql = "select * from ";
     int count = 0;
     sqlite3_stmt *stmt;
     strSql = strSql + tablename + ";";
     print_light_green("%s\n", strSql.c_str());
-    sqlite3_prepare_v2(GetDbHandle(isDB2), strSql.c_str(), -1, &stmt, 0);
+    sqlite3_prepare_v2(GetDbHandle(), strSql.c_str(), -1, &stmt, 0);
     count = sqlite3_column_count(stmt);
     sqlite3_finalize(stmt);
     return count;
@@ -236,10 +213,10 @@ int SqliteDB::GetTableRows(const char *tablename, const char *whereCon) {
     } else {
         strSql = strSql + tablename + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+    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) {
-        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
+        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:%s", sqlite3_errmsg(mDBAcess), strSql.c_str());
         sqlite3_finalize(stmt);
         return -1;
     }
@@ -251,17 +228,16 @@ int SqliteDB::GetTableRows(const char *tablename, const char *whereCon) {
     return nRow;
 }
 
-int SqliteDB::AlterTable(const char *tablename, const char *column, bool isAdd, bool isDB2) {
+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 + ";";
-        print_light_green("%s\n", strSql.c_str());
-        iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, NULL);
+        zlog_info(zct, "[AlterTable] sql:%s", strSql.c_str());
+        iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, NULL);
         if (iRet != SQLITE_OK) {
-            perror_info("sqlite3_exec");
+            zlog_error(zct, "sqlite3_exec ret:%d, sql:[%s]", iRet, strSql.c_str());
         }
-    } else {
     }
     return iRet;
 }
@@ -274,10 +250,10 @@ vec_t SqliteDB::GetDataSingleLine(const char *tablename, const char *column, con
     } else {
         strSql = strSql + column + " from " + tablename + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+    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) {
-        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
+        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
         sqlite3_finalize(stmt);
         return vecResult;
     }
@@ -302,11 +278,12 @@ char *SqliteDB::GetDataChar(const char *tablename, const char *column, const cha
     } else {
         strSql = strSql + column + " from " + tablename + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+
+    zlog_info(zct, "[GetDataChar] sql:%s", strSql.c_str());
     sqlite3_stmt *stmt;
     g_tDbMutex.Lock();
     if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
-        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
+        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
         sqlite3_finalize(stmt);
         g_tDbMutex.UnLock();
         return NULL;
@@ -329,11 +306,11 @@ std::string SqliteDB::GetData(const char *tablename, const char *column, const c
     } else {
         strSql = strSql + column + " from " + tablename + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+    zlog_info(zct, "[GetData] sql:%s", strSql.c_str());
     sqlite3_stmt *stmt;
     g_tDbMutex.Lock();
     if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
-        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
+        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
         sqlite3_finalize(stmt);
         g_tDbMutex.UnLock();
         return strRes;
@@ -357,11 +334,11 @@ array_t SqliteDB::GetDataMultiLine(const char *tablename, const char *column, co
         strSql = strSql + column + " from " + tablename + ";";
     }
 
-    print_light_green("%s\n", strSql.c_str());
+    zlog_info(zct, "[GetDataMultiLine] sql:%s", strSql.c_str());
     sqlite3_stmt *stmt;
     g_tDbMutex.Lock();
     if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
-        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
+        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
         sqlite3_finalize(stmt);
         g_tDbMutex.UnLock();
         return arrResult;
@@ -391,11 +368,11 @@ array_t SqliteDB::GetDataMultiLineTransaction(const char *tablename, const char
     } else {
         strSql = strSql + column + " from " + tablename + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+    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) {
-        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
+        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
         sqlite3_finalize(stmt);
         return arrResult;
     }
@@ -426,10 +403,10 @@ vec_t SqliteDB::GetDataMultiLineOfOneColumn(const char *tablename, const char *c
     } else {
         strSql = strSql + column + " from " + tablename + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+    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) {
-        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
+        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
         sqlite3_finalize(stmt);
         return vecResult;
     }
@@ -452,10 +429,11 @@ vec_Value SqliteDB::GetDataMultiLineOfOneColumnDouble(const char *tablename, con
     } else {
         strSql = strSql + column + " from " + tablename + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+
+    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) {
-        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
+        zlog_error(zct, "sqlite3_prepare_v2:%s, sql:[%s]", sqlite3_errmsg(mDBAcess), strSql.c_str());
         sqlite3_finalize(stmt);
         return vecResult;
     }
@@ -469,44 +447,44 @@ vec_Value SqliteDB::GetDataMultiLineOfOneColumnDouble(const char *tablename, con
     return vecResult;
 }
 
-int SqliteDB::DeleteTableData(const char *tablename, const char *whereCond, bool isDB2) {
+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 + ";";
     }
-    //   LOG_INFO("strSql = %s",strSql.c_str());
-    print_light_green("%s\n", strSql.c_str());
+
+    zlog_info(zct, "[DeleteTableData] sql:%s", strSql.c_str());
     char *msg;
-    int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
+    int iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);
 
     if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
+        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, bool isDB2) {
+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 + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+    zlog_info(zct, "[DeleteTableDataOneConditon] sql:%s", strSql.c_str());
     char *msg;
-    int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
+    int iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);
 
     if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
+        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, bool isDB2) {
+int SqliteDB::UpdateNodeNameData(const char *tablename, const char *updateColumn, const char *whereCond) {
     std::string strSql = "update ";
     char szSql[1024] = {0x00};
     strcat(szSql, "update ");
@@ -521,66 +499,66 @@ int SqliteDB::UpdateNodeNameData(const char *tablename, const char *updateColumn
     } else {
         strSql = strSql + tablename + " set " + updateColumn + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+    zlog_info(zct, "[UpdateNodeNameData] sql:%s", strSql.c_str());
     char *msg;
-    int iRet = sqlite3_exec(GetDbHandle(isDB2), szSql, 0, 0, &msg);
+    int iRet = sqlite3_exec(GetDbHandle(), szSql, 0, 0, &msg);
 
     if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
+        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, bool isDB2) {
+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 + ";";
     }
-    print_light_green("%s\n", strSql.c_str());
+    zlog_info(zct, "[UpdateTableData] sql:%s", strSql.c_str());
     char *msg;
     g_tDbMutex.Lock();
-    int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
+    int iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);
 
     if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
+        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, strSql.c_str());
         sqlite3_free(msg);
     }
     g_tDbMutex.UnLock();
     return iRet;
 }
 
-int SqliteDB::UpdateTableData(const char *directSql, bool isDB2) {
-    print_light_green("%s\n", directSql);
+int SqliteDB::UpdateTableData(const char *directSql) {
+    zlog_info(zct, "[UpdateTableData] sql:%s", directSql);
     char *msg;
-    int iRet = sqlite3_exec(GetDbHandle(isDB2), directSql, 0, 0, &msg);
+    int iRet = sqlite3_exec(GetDbHandle(), directSql, 0, 0, &msg);
     if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
+        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, bool isDB2) {
+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 + "';";
     }
-    print_light_green("%s\n", strSql.c_str());
+    zlog_info(zct, "[UpdateTableDataOneColumn] sql:%s", strSql.c_str());
     char *msg;
-    int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
+    int iRet = sqlite3_exec(GetDbHandle(), strSql.c_str(), 0, 0, &msg);
     if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
+        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 *tablename, const char *insertValues, int replace, bool expandable, bool isDB2) {
+int SqliteDB::InsertData(const char *tablename, const char *insertValues, int replace, bool expandable) {
     char *msg;
     int iRet = 0;
     if (expandable) {
@@ -595,10 +573,13 @@ int SqliteDB::InsertData(const char *tablename, const char *insertValues, int re
             memset(strReplace, 0, sizeof(strSql));
         }
         sprintf(strSql, "%s %s%s %s %s %s", "insert into", strReplace, tablename, "values(", insertValues, ");");
-        print_light_green("%s\n", strSql);
-
-        iRet = sqlite3_exec(GetDbHandle(isDB2), strSql, 0, 0, &msg);
+        zlog_info(zct, "[InsertData] expandable sql:%s", strSql.c_str());
 
+        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 ";
@@ -606,14 +587,15 @@ int SqliteDB::InsertData(const char *tablename, const char *insertValues, int re
             strSql = "replace into ";
         }
         strSql = strSql + tablename + " values(" + insertValues + ");";
-        print_light_green("%s\n", strSql.c_str());
+        zlog_info(zct, "[InsertData] nonexpandable sql:%s", strSql.c_str());
 
-        iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
-    }
-    if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
-        sqlite3_free(msg);
+        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;
 }
 
@@ -621,14 +603,14 @@ int SqliteDB::InsertData(const char *insertSql) {
     char *msg;
     int iRet = sqlite3_exec(GetDbHandle(false), insertSql, 0, 0, &msg);
     if (iRet != SQLITE_OK) {
-        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
+        zlog_error(zct, "sqlite3 error: code=%d msg=%s sql=[%s]", iRet, msg, insertSql);
         sqlite3_free(msg);
     }
     return iRet;
 }
 
 int SqliteDB::CalculateBattery() {
-    LOG_INFO("CalculateBattery start\n");
+    zlog_info(zct, "CalculateBattery start");
     char whereCon[1024] = {0};
     char selectSql[1024] = {0};
     memset(whereCon, 0x00, sizeof(whereCon));
@@ -636,7 +618,7 @@ int SqliteDB::CalculateBattery() {
     char updateSql[1024] = {0};
     sprintf(selectSql, " dataNodeNo,StaticTime,WaveTime,featureInterVal,waveInterVal,samplingRate,batteryPower ");
     array_t vecRes = GetDataMultiLine(T_SENSOR_INFO(TNAME), selectSql, NULL);
-    print_info("res = %d\n", vecRes.size());
+    zlog_info(zct, "res = %d", vecRes.size());
     if (vecRes.size() > 0) {
         for (int i = 0; i < vecRes.size(); i++) {
             float capacity = 0.0, startCapacity = 0.0;
@@ -669,12 +651,12 @@ int SqliteDB::CalculateBattery() {
                 capacity = atof(vecResSig[7].c_str());
             }
 
-            print_info("dip = %d\n", atoi(vecResSig[1].c_str()));
+            zlog_info(zct, "dip = %d", atoi(vecResSig[1].c_str()));
 
-            print_info("capacity = %f\n", capacity);
+            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);
-            print_info("vecResbattery size = %d\n", vecResbattery.size());
+            zlog_info(zct, "vecResbattery size = %d", vecResbattery.size());
             if (vecResbattery.size() <= 0) {
                 continue;
             }
@@ -689,7 +671,7 @@ int SqliteDB::CalculateBattery() {
             std::vector<long> vecworkTime;
             std::vector<long> vecsendTime;
             float to_math = 0.0;
-            print_info("vecResbattery = %d,temp = %s\n", vecResbattery.size(), vecResbattery[0][2].c_str());
+            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;
@@ -701,7 +683,7 @@ int SqliteDB::CalculateBattery() {
                 to_math += cost_h;
             }
 
-            print_info("自放电 = %f\n", to_math);
+            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];
@@ -709,22 +691,22 @@ int SqliteDB::CalculateBattery() {
             for (size_t j = 0; j < vecsendTime.size(); j++) {
                 sumsendTime += vecsendTime[j];
             }
-            print_info("sumworkTime = %ld,sumsendTime = %ld\n", sumworkTime, sumsendTime);
+            zlog_info(zct, "sumworkTime = %ld,sumsendTime = %ld", sumworkTime, sumsendTime);
 
             float usageworkTime = ((float)sumworkTime / 3600000) * 4;
             float usagesendTime = ((float)sumsendTime / 3600000) * 39;
-            print_info("work = %f,send = %f\n", usageworkTime, usagesendTime);
+            zlog_info(zct, "work = %f,send = %f", usageworkTime, usagesendTime);
 
             if (to_math < 0) to_math = 0;
             float usageBattery = usageworkTime + usagesendTime + to_math;
-            print_info("已经使用 = %f\n", atof(vecResSig[6].c_str()));
+            zlog_info(zct, "已经使用 = %f", atof(vecResSig[6].c_str()));
 
             float remainBattery = capacity - usageBattery * 0.2;
             if (remainBattery < 10) {
                 remainBattery = 10;
             }
 
-            LOG_INFO("dataNodeNo = %s,batteryUsage = %f,batteryRemain = %f\n", vecRes[i][0].c_str(), atof(vecResSig[6].c_str()), remainBattery);
+            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 = sqlite_db_ctrl::instance().GetData(T_BATTERY_INFO(TNAME), " timeStamp ", whereCon);
@@ -756,8 +738,7 @@ int SqliteDB::CalculateBattery() {
             data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
         }
     }
-    LOG_INFO("CalculateBattery end\n");
-
+    zlog_info(zct, "CalculateBattery end");
     return 0;
 }
 
@@ -774,12 +755,12 @@ int SqliteDB::CalculateDip() {
     GetTimeNet(localtimestamp, 1);
     readStringValue("config", "loose", looseValue, (char *)GlobalConfig::Config_G.c_str());
     vecRes = GetDataMultiLine(T_SENSOR_INFO(TNAME), " * ", NULL);
-    print_info("vecRes111 = %d\n", vecRes.size());
+    zlog_info(zct, "vecRes111 = %d", vecRes.size());
     for (int i = 0; i < vecRes.size(); i++) {
         std::vector<std::string> vParam;
-        print_info("vecRes  =%s\n", vecRes[i][42].c_str());
+        zlog_info(zct, "vecRes = %s", vecRes[i][42].c_str());
         boost::split(vParam, vecRes[i][42], boost::is_any_of(","), boost::token_compress_on);
-        print_info("vParam size = %d\n", vParam.size());
+        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());
@@ -794,12 +775,12 @@ int SqliteDB::CalculateDip() {
             } else if (vParam[1] == "1") {                                              //松动状态
                 continue;
             }
-            print_info("vParam[0]= %s,vParam[1]=%s\n", vParam[0].c_str(), vParam[1].c_str());
+            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);
-            print_info("sample_variance = %f\n", sample_variance);
+            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());
@@ -811,7 +792,7 @@ int SqliteDB::CalculateDip() {
                 }
             } else if (vParam[1] == "1") {
             } else if (vParam[1] == "2") {
-                print_info("localtimestamp = %ld,vParam[2]=%d,%ld\n", atol(localtimestamp), atol(vParam[2].c_str()), atol(localtimestamp) - atol(vParam[2].c_str()));
+                zlog_info(zct, "localtimestamp = %ld,vParam[2]=%d,%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 {
@@ -828,7 +809,7 @@ int SqliteDB::CalculateDip() {
 
         UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
     }
-    print_info("CalculateDip \n");
+    zlog_info(zct, "CalculateDip");
 }
 
 int SqliteDB::InintGateway() {
@@ -851,7 +832,7 @@ int SqliteDB::InintGateway() {
 	    		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());
         sqlite_db_ctrl::instance().InsertData(strSql);
-        print_info("strSql = %s\n", strSql);
+        zlog_info(zct, "strSql = %s", strSql);
     } else {
         char whereCon[1024] = {0};
         char updateSql[1024] = {0};
@@ -979,7 +960,7 @@ int SqliteDB::QueryofflineData() {
         sprintf(StaticTableName, "t_dataStatic_%s", arrRetdataNode[i][0].c_str());
 
         array_t arrRetData = GetDataMultiLine(StaticTableName, "*", "sendMsg = '0' order by timeStamp asc");
-        LOG_INFO("mqttresend check datanodeNo %s,data count %d\n", arrRetdataNode[i][0].c_str(), arrRetData.size());
+        zlog_info(zct, "mqttresend check datanodeNo %s,data count %d", arrRetdataNode[i][0].c_str(), arrRetData.size());
         if (arrRetData.size() < 1) continue;
         for (int j = 0; j < arrRetData.size(); j++) {
             char dataTableName[50] = {0x00};
@@ -1049,7 +1030,7 @@ int SqliteDB::QueryofflineData() {
     char whereCon[1024] = {0x00};
     sprintf(whereCon, " SendMsg = 0 ");
     array_t arrRetData = GetDataMultiLine("t_data_waveSend", "*", whereCon);
-    LOG_INFO("mqttresend check wave count %d\n", arrRetData.size());
+    zlog_info(zct, "mqttresend check wave count %d", arrRetData.size());
     if (arrRetData.size() > 0) {
         for (int i = 0; i < arrRetData.size(); i++) {
             std::string strWaveData = "";
@@ -1122,7 +1103,7 @@ int SqliteDB::CalculateData() {
 
             sql = "timeStamp >= strftime('%s', 'now', '-1 day', 'start of day','utc') AND timeStamp < strftime('%s', 'now', '-1 day','start of day','utc','+24 hours') and statisticType = '1' and timing = '0'";
             int TimingCount = GetTableRows(tableName, sql);
-            print_info("nodeWaveSend = %s,waveInterVal = %s\n", vecRet[i][2].c_str(), vecRet[i][4].c_str());
+            zlog_info(zct, "nodeWaveSend = %s,waveInterVal = %s", vecRet[i][2].c_str(), vecRet[i][4].c_str());
             if (vecRet[i][2] == "") continue;
             std::vector<std::string> nodeWaveSend;
             boost::split(nodeWaveSend, vecRet[i][2], boost::is_any_of(","), boost::token_compress_on);
@@ -1145,7 +1126,7 @@ int SqliteDB::CalculateData() {
             if (nodeWaveSend[0] == "0") {
                 sprintf(whereCon, " and channelID = '%s-X'", vecRet[i][1].c_str());
                 std::string strsql = std::string(sql1) + std::string(whereCon);
-                printf("sql = %s\n", strsql.c_str());
+                zlog_info(zct, "sql = %s", strsql.c_str());
                 CountWaveX = GetTableRows(tableName, strsql.c_str());
                 sprintf(whereCon, " and channelID = '%s-X'", vecRet[i][1].c_str());
                 strsql = std::string(sql2) + std::string(whereCon);
@@ -1199,19 +1180,19 @@ int SqliteDB::CalculateData() {
             CountWaveXTotal += CountWaveX;
             CountWaveYTotal += CountWaveY;
             CountWaveZTotal += CountWaveZ;
-            LOG_INFO("dataNodeNo = %s , Statistic Count = %d , 06 Count = %d , Timing Count = %d , CountWaveX = %d , CountWaveY = %d , CountWaveZ = %d , featureInterVal = %s , waveInterVal = %s , NodeWaveSend = %s\n", vecRet[i][0].c_str(), StatisticCount, SixCount, TimingCount,
-                     CountWaveX, CountWaveY, CountWaveZ, vecRet[i][3].c_str(), vecRet[i][4].c_str(), vecRet[i][2].c_str());
+            zlog_info(zct, "dataNodeNo = %s , Statistic Count = %d , 06 Count = %d , Timing Count = %d , CountWaveX = %d , CountWaveY = %d , CountWaveZ = %d , featureInterVal = %s , waveInterVal = %s , NodeWaveSend = %s", vecRet[i][0].c_str(), StatisticCount, SixCount,
+                      TimingCount, CountWaveX, CountWaveY, CountWaveZ, vecRet[i][3].c_str(), vecRet[i][4].c_str(), vecRet[i][2].c_str());
 
             int zigbeepowerEnable = readIntValue("config", "zigbeepowerEnable", (char *)GlobalConfig::Config_G.c_str());
             if (zigbeepowerEnable) {
-                LOG_INFO("rateX = %d,rateY = %d,rateZ = %d,zigbeepower = %s \n", rateX, rateY, rateZ, vecRet[i][5].c_str());
+                zlog_info(zct, "rateX = %d,rateY = %d,rateZ = %d,zigbeepower = %s", rateX, rateY, rateZ, vecRet[i][5].c_str());
                 if (rateX != -1 && rateY != -1 && rateZ != -1 && vecRet[i][5] == "3") {
                     char updateSql[50] = {0x00};
                     sprintf(updateSql, "ZigbeePower = '2',UpdateFlag = 0 ");
                     memset(whereCon, 0x00, sizeof(whereCon));
                     sprintf(whereCon, " dataNodeNo = '%s'", vecRet[i][0].c_str());
                     UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
-                    LOG_INFO("2 update ZigbeePower ");
+                    zlog_info(zct, "2 update ZigbeePower ");
                 }
 
                 if ((rateX == -1 || rateY == -1 || rateZ == -1) && vecRet[i][5] == "2") {
@@ -1220,15 +1201,15 @@ int SqliteDB::CalculateData() {
                     memset(whereCon, 0x00, sizeof(whereCon));
                     sprintf(whereCon, " dataNodeNo = '%s'", vecRet[i][0].c_str());
                     UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
-                    LOG_INFO("3 update ZigbeePower ");
+                    zlog_info(zct, "3 update ZigbeePower ");
                 }
             }
             featureInterVal = atoi(vecRet[i][3].c_str());
             waveInterVal = atoi(vecRet[i][4].c_str());
         }
-        LOG_INFO("Node Count = %d , featureInterVal = %d , waveInterVal = %d\n", vecRet.size(), featureInterVal, waveInterVal);
-        LOG_INFO("plan Statistic Count = %d , 06 Count = %d , Timing Count = %d , CountWaveX = %d ", planCountStatistic * vecRet.size(), planCount * vecRet.size(), planCount * vecRet.size(), planCount * vecRet.size());
-        LOG_INFO("reality Statistic Count = %d , 06 Count = %d , Timing Count = %d , CountWaveX = %d ,CountWaveY = %d ,CountWaveZ = %d ", StatisticCountTotal, SixCountTotal, TimingCountTotal, CountWaveXTotal, CountWaveYTotal, CountWaveZTotal);
+        zlog_info(zct, "Node Count = %d , featureInterVal = %d , waveInterVal = %d", vecRet.size(), featureInterVal, waveInterVal);
+        zlog_info(zct, "plan Statistic Count = %d , 06 Count = %d , Timing Count = %d , CountWaveX = %d ", planCountStatistic * vecRet.size(), planCount * vecRet.size(), planCount * vecRet.size(), planCount * vecRet.size());
+        zlog_info(zct, "reality Statistic Count = %d , 06 Count = %d , Timing Count = %d , CountWaveX = %d ,CountWaveY = %d ,CountWaveZ = %d ", StatisticCountTotal, SixCountTotal, TimingCountTotal, CountWaveXTotal, CountWaveYTotal, CountWaveZTotal);
     }
 }
 
@@ -1237,12 +1218,3 @@ 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); }
-
-void SqliteDB::HandError(int code) {
-    if (code == SQLITE_CORRUPT) {
-        /*
-        * 用system 删除数据库
-        */
-        exit(1);
-    }
-}
diff --git a/dbaccess/sql_db.hpp b/dbaccess/sql_db.hpp
index e6ced41..6a35afa 100644
--- a/dbaccess/sql_db.hpp
+++ b/dbaccess/sql_db.hpp
@@ -25,8 +25,8 @@ class SqliteDB {
 public:
     explicit SqliteDB();
     virtual ~SqliteDB();
-    bool OpenDB(const char *pDbName, bool isDB2 = false);
-    void SqliteInit(const char *pDbName, bool isDB2 = false);
+    bool OpenDB(const char *pDbName);
+    void SqliteInit(const char *pDbName);
     void SqliteInitDel(const char *pDbName);
     void Createtable(const char *ptableName);
     void Deletetable(const char *ptableName);
@@ -34,11 +34,11 @@ public:
     int TransBegin();
     int TransRollback();
     int TransCommit();
-    int CreateTable(const char *sql, bool isDB2 = false);
-    int ExeSql(const char *sql, bool isDB2 = false);
-    int GetTableColumnCount(const char *tablename, bool isDB2 = false);
+    int CreateTable(const char *sql);
+    int ExeSql(const char *sql);
+    int GetTableColumnCount(const char *tablename);
     int GetTableRows(const char *tablename, const char *whereCon);
-    int AlterTable(const char *tablename, const char *column, bool isAdd = true, bool isDB2 = false);
+    int AlterTable(const char *tablename, const char *column, bool isAdd = true);
     vec_t GetDataSingleLine(const char *tablename, const char *column, const char *whereCon);
     std::string GetData(const char *tablename, const char *column, const char *whereCon);
     char *GetDataChar(const char *tablename, const char *column, const char *whereCon);
@@ -46,13 +46,13 @@ public:
     array_t GetDataMultiLineTransaction(const char *tablename, const char *column, const char *whereCon);
     vec_t GetDataMultiLineOfOneColumn(const char *tablename, const char *column, const char *whereCon);
     vec_Value GetDataMultiLineOfOneColumnDouble(const char *tablename, const char *column, const char *whereCon);
-    int DeleteTableData(const char *tablename, const char *whereCond = NULL, bool isDB2 = false);
-    int DeleteTableDataOneConditon(const char *tablename, const char *condColumnName, const char *condColumnValue, bool isDB2 = false);
-    int UpdateTableData(const char *tablename, const char *updateColumn, const char *whereCond, bool isDB2 = false);
-    int UpdateNodeNameData(const char *tablename, const char *updateColumn, const char *whereCond, bool isDB2 = false);
-    int UpdateTableDataOneColumn(const char *tablename, const char *columnName, const char *columnValue, const char *whereColName = NULL, const char *whereColValue = NULL, bool isDB2 = false);
-    int UpdateTableData(const char *directSql, bool isDB2 = false);
-    int InsertData(const char *tablename, const char *insertValues, int replace = 0, bool expandalbe = false, bool isDB2 = false);
+    int DeleteTableData(const char *tablename, const char *whereCond = NULL);
+    int DeleteTableDataOneConditon(const char *tablename, const char *condColumnName, const char *condColumnValue);
+    int UpdateTableData(const char *tablename, const char *updateColumn, const char *whereCond);
+    int UpdateNodeNameData(const char *tablename, const char *updateColumn, const char *whereCond);
+    int UpdateTableDataOneColumn(const char *tablename, const char *columnName, const char *columnValue, const char *whereColName = NULL, const char *whereColValue = NULL);
+    int UpdateTableData(const char *directSql);
+    int InsertData(const char *tablename, const char *insertValues, int replace = 0, bool expandalbe = false);
     int InsertData(const char *insertSql);
     int CalculateBattery();
     int CalculateDip();
@@ -64,10 +64,8 @@ public:
     int CloseDB();
 
 private:
-    sqlite3 *GetDbHandle(bool isDB2);
-    void HandError(int code);
+    sqlite3 *GetDbHandle();
     sqlite3 *mDBAcess;
-    sqlite3 *mDb2;
 };
 
 typedef boost::container::dtl::singleton_default<SqliteDB> sqlite_db_ctrl;