GrpcPrint/PrintS/Config/dao/BaseConfigDao.cpp

#include "BaseConfigDao.h"
#include <vector>
#include <windows.h>
#include "../ConfigManager.h"

BaseConfigDao::BaseConfigDao(SQLite::Database* pdb) :BaseDao(pdb)
{
}


BaseConfigDao::~BaseConfigDao()
{
}

void BaseConfigDao::CreateTable() {
	if (m_pDB->tableExists(BaseConfig::TABLE_NAME))return;
	char buffer[1024];
	memset(buffer, '\0', sizeof(buffer));
	//SQLite::Transaction transaction(*m_pDB);
	string createsql = "CREATE TABLE %s(%s INTEGER PRIMARY KEY AUTOINCREMENT,%s  VARCHAR(20),%s VARCHAR(50),%s VARCHAR(100),UNIQUE(%s,%s))";
	sprintf_s(buffer, sizeof(buffer), createsql.c_str(),
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_ID.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str(),
		BaseConfig::FIELD_CONFIG_VALUE.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str()
	);
	m_pDB->exec(buffer);

	CoverCfg* coverCfg = ConfigManager::GetInstance()->GetCoverCfg();
	ExtCfg* extCfg = ConfigManager::GetInstance()->GetExtCfg();
	//ConfigManager::GetInstance()->GetMachine()->CheckCoverCfgWhenCreate(coverCfg);
	//ConfigManager::GetInstance()->GetMachine()->CheckExtCfgWhenCreate(extCfg);
}

void BaseConfigDao::FindValue(string configname, map<string, string>& valueMap)
{
	char buffer[1024];
	string strsql = "SELECT %s,%s,%s FROM %s WHERE %s='%s'";
	sprintf_s(buffer, sizeof(buffer), strsql.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str(),
		BaseConfig::FIELD_CONFIG_VALUE.c_str(),
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		configname.c_str());
	SQLite::Statement query(*m_pDB, buffer);
	while (query.executeStep()) {
		valueMap[query.getColumn(BaseConfig::FIELD_CONFIG_CODE.c_str()).getString()] = query.getColumn(BaseConfig::FIELD_CONFIG_VALUE.c_str()).getString();
	}
}

void BaseConfigDao::FindExtCfg(ExtCfg& ecfg)
{
	map<string, string> valuemap;
	FindValue(ExtCfg::CONFIG_NAME,valuemap);
	char buffer[512];
	string strtemp = "INSERT INTO %s(%s,%s,%s) VALUES('%s',";
	sprintf_s(buffer, sizeof(buffer), strtemp.c_str(),
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str(),
		BaseConfig::FIELD_CONFIG_VALUE.c_str(),
		ExtCfg::CONFIG_NAME.c_str()
	);
	string strsql = string(buffer) + "'%s','%s')";
	vector<string> needins;
	
	if (valuemap.find(ExtCfg::FIELD_LIMIT_CODE)!= valuemap.end()) {
		ecfg.m_LimitCode = (unsigned short)stoi(valuemap[ExtCfg::FIELD_LIMIT_CODE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_LIMIT_CODE.c_str(), to_string(ecfg.m_LimitCode).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_OXYGEN_ID) != valuemap.end()) {
		ecfg.m_OxygenAdc.id = stoi(valuemap[ExtCfg::FIELD_OXYGEN_ID]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_OXYGEN_ID.c_str(), to_string(ecfg.m_OxygenAdc.id).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_OXYGEN_CODE) != valuemap.end()) {
		ecfg.m_OxygenAdc.code = valuemap[ExtCfg::FIELD_OXYGEN_CODE];
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_OXYGEN_CODE.c_str(), ecfg.m_OxygenAdc.code.c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_OXYGEN_SLOPE) != valuemap.end()) {
		ecfg.m_OxygenAdc.slope = stod(valuemap[ExtCfg::FIELD_OXYGEN_SLOPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_OXYGEN_SLOPE.c_str(),to_string(ecfg.m_OxygenAdc.slope).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(ExtCfg::FIELD_OXYGEN_INTERCEPT) != valuemap.end()) {
		ecfg.m_OxygenAdc.intercept = stod(valuemap[ExtCfg::FIELD_OXYGEN_INTERCEPT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_OXYGEN_INTERCEPT.c_str(), to_string(ecfg.m_OxygenAdc.intercept).c_str());
		needins.push_back(buffer);
	}
	ecfg.m_AdcCfgs[ecfg.m_OxygenAdc.id] = &ecfg.m_OxygenAdc;

	if (valuemap.find(ExtCfg::FIELD_AMBIENTTEMP_ID) != valuemap.end()) {
		ecfg.m_AmbientTempAdc.id = stoi(valuemap[ExtCfg::FIELD_AMBIENTTEMP_ID]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_AMBIENTTEMP_ID.c_str(), to_string(ecfg.m_AmbientTempAdc.id).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_AMBIENTTEMP_CODE) != valuemap.end()) {
		ecfg.m_AmbientTempAdc.code = valuemap[ExtCfg::FIELD_AMBIENTTEMP_CODE];
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_AMBIENTTEMP_CODE.c_str(), ecfg.m_AmbientTempAdc.code.c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_AMBIENTTEMP_SLOPE) != valuemap.end()) {
		ecfg.m_AmbientTempAdc.slope = stod(valuemap[ExtCfg::FIELD_AMBIENTTEMP_SLOPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_AMBIENTTEMP_SLOPE.c_str(), to_string(ecfg.m_AmbientTempAdc.slope).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_AMBIENTTEMP_INTERCEPT) != valuemap.end()) {
		ecfg.m_AmbientTempAdc.intercept = stod(valuemap[ExtCfg::FIELD_AMBIENTTEMP_INTERCEPT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_AMBIENTTEMP_INTERCEPT.c_str(), to_string(ecfg.m_AmbientTempAdc.intercept).c_str());
		needins.push_back(buffer);
	}
	ecfg.m_AdcCfgs[ecfg.m_AmbientTempAdc.id] = &ecfg.m_AmbientTempAdc;

	if (valuemap.find(ExtCfg::FIELD_INNERTEMP_ID) != valuemap.end()) {
		ecfg.m_InnerTempAdc.id = stoi(valuemap[ExtCfg::FIELD_INNERTEMP_ID]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_INNERTEMP_ID.c_str(), to_string(ecfg.m_InnerTempAdc.id).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_INNERTEMP_CODE) != valuemap.end()) {
		ecfg.m_InnerTempAdc.code = valuemap[ExtCfg::FIELD_INNERTEMP_CODE];
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_INNERTEMP_CODE.c_str(), ecfg.m_InnerTempAdc.code.c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_INNERTEMP_SLOPE) != valuemap.end()) {
		ecfg.m_InnerTempAdc.slope = stod(valuemap[ExtCfg::FIELD_INNERTEMP_SLOPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_INNERTEMP_SLOPE.c_str(), to_string(ecfg.m_InnerTempAdc.slope).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(ExtCfg::FIELD_INNERTEMP_INTERCEPT) != valuemap.end()) {
		ecfg.m_InnerTempAdc.intercept = stod(valuemap[ExtCfg::FIELD_INNERTEMP_INTERCEPT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_INNERTEMP_INTERCEPT.c_str(), to_string(ecfg.m_InnerTempAdc.intercept).c_str());
		needins.push_back(buffer);
	}
	ecfg.m_AdcCfgs[ecfg.m_InnerTempAdc.id] = &ecfg.m_InnerTempAdc;

	if (valuemap.find(ExtCfg::FIELD_BLOW_ID) != valuemap.end()) {
		ecfg.m_BlowAdc.id = stoi(valuemap[ExtCfg::FIELD_BLOW_ID]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_BLOW_ID.c_str(), to_string(ecfg.m_BlowAdc.id).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_BLOW_CODE) != valuemap.end()) {
		ecfg.m_BlowAdc.code = valuemap[ExtCfg::FIELD_BLOW_CODE];
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_BLOW_CODE.c_str(),ecfg.m_BlowAdc.code.c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(ExtCfg::FIELD_BLOW_SLOPE) != valuemap.end()) {
		ecfg.m_BlowAdc.slope = stod(valuemap[ExtCfg::FIELD_BLOW_SLOPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_BLOW_SLOPE.c_str(), to_string(ecfg.m_BlowAdc.slope).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_BLOW_INTERCEPT) != valuemap.end()) {
		ecfg.m_BlowAdc.intercept = stod(valuemap[ExtCfg::FIELD_BLOW_INTERCEPT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_BLOW_INTERCEPT.c_str(), to_string(ecfg.m_BlowAdc.intercept).c_str());
		needins.push_back(buffer);
	}
	ecfg.m_AdcCfgs[ecfg.m_BlowAdc.id] = &ecfg.m_BlowAdc;

	if (valuemap.find(ExtCfg::FIELD_FAN_ID) != valuemap.end()) {
		ecfg.m_FanId = stoi(valuemap[ExtCfg::FIELD_FAN_ID]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_FAN_ID.c_str(), to_string(ecfg.m_FanId).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(ExtCfg::FIELD_ARGON_CODE) != valuemap.end()) {
		ecfg.m_ArgonFit.code = valuemap[ExtCfg::FIELD_ARGON_CODE];
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_ARGON_CODE.c_str(), ecfg.m_ArgonFit.code.c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(ExtCfg::FIELD_ARGON_SLOPE) != valuemap.end()) {
		ecfg.m_ArgonFit.slope = stod(valuemap[ExtCfg::FIELD_ARGON_SLOPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_ARGON_SLOPE.c_str(), to_string(ecfg.m_ArgonFit.slope).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_ARGON_INTERCEPT) != valuemap.end()) {
		ecfg.m_ArgonFit.intercept = stod(valuemap[ExtCfg::FIELD_ARGON_INTERCEPT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_ARGON_INTERCEPT.c_str(), to_string(ecfg.m_ArgonFit.intercept).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_ARGON_CHECK_WIND_OFFSET) != valuemap.end()) {
		ecfg.m_ArgonFit.checkWindOffset = stof(valuemap[ExtCfg::FIELD_ARGON_CHECK_WIND_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_ARGON_CHECK_WIND_OFFSET.c_str(), to_string(ecfg.m_ArgonFit.checkWindOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_ARGON_TARGET_WIND) != valuemap.end()) {
		ecfg.m_ArgonFit.targeWind = stof(valuemap[ExtCfg::FIELD_ARGON_TARGET_WIND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_ARGON_TARGET_WIND.c_str(), to_string(ecfg.m_ArgonFit.targeWind).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_ARGON_WIND_LOWER_LIMIT) != valuemap.end()) {
		ecfg.m_ArgonFit.alarmWind = stof(valuemap[ExtCfg::FIELD_ARGON_WIND_LOWER_LIMIT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_ARGON_WIND_LOWER_LIMIT.c_str(), to_string(ecfg.m_ArgonFit.alarmWind).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_NITROGEN_CODE) != valuemap.end()) {
		ecfg.m_NitrogenFit.code = valuemap[ExtCfg::FIELD_NITROGEN_CODE];
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_NITROGEN_CODE.c_str(), ecfg.m_NitrogenFit.code.c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_NITROGEN_SLOPE) != valuemap.end()) {
		ecfg.m_NitrogenFit.slope = stod(valuemap[ExtCfg::FIELD_NITROGEN_SLOPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_NITROGEN_SLOPE.c_str(), to_string(ecfg.m_NitrogenFit.slope).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_NITROGEN_INTERCEPT) != valuemap.end()) {
		ecfg.m_NitrogenFit.intercept = stod(valuemap[ExtCfg::FIELD_NITROGEN_INTERCEPT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_NITROGEN_INTERCEPT.c_str(), to_string(ecfg.m_NitrogenFit.intercept).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_NITROGEN_CHECK_WIND_OFFSET) != valuemap.end()) {
		ecfg.m_NitrogenFit.checkWindOffset = stof(valuemap[ExtCfg::FIELD_NITROGEN_CHECK_WIND_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_NITROGEN_CHECK_WIND_OFFSET.c_str(), to_string(ecfg.m_NitrogenFit.checkWindOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_NITROGEN_TARGET_WIND) != valuemap.end()) {
		ecfg.m_NitrogenFit.targeWind = stof(valuemap[ExtCfg::FIELD_NITROGEN_TARGET_WIND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_NITROGEN_TARGET_WIND.c_str(), to_string(ecfg.m_NitrogenFit.targeWind).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_NITROGEN_WIND_LOWER_LIMIT) != valuemap.end()) {
		ecfg.m_NitrogenFit.alarmWind = stof(valuemap[ExtCfg::FIELD_NITROGEN_WIND_LOWER_LIMIT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_NITROGEN_WIND_LOWER_LIMIT.c_str(), to_string(ecfg.m_NitrogenFit.alarmWind).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_NITROGEN_CHECK_ALARM_PERCENT) != valuemap.end()) {
		ecfg.m_NitrogenFit.checkAlarmPercent = stof(valuemap[ExtCfg::FIELD_NITROGEN_CHECK_ALARM_PERCENT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_NITROGEN_CHECK_ALARM_PERCENT.c_str(), to_string(ecfg.m_NitrogenFit.checkAlarmPercent).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_ARGON_CHECK_ALARM_PERCENT) != valuemap.end()) {
		ecfg.m_ArgonFit.checkAlarmPercent = stof(valuemap[ExtCfg::FIELD_ARGON_CHECK_ALARM_PERCENT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_ARGON_CHECK_ALARM_PERCENT.c_str(), to_string(ecfg.m_ArgonFit.checkAlarmPercent).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SELECTED_FAN_WIND_FIT) != valuemap.end()) {
		ecfg.m_SelectedFanWindFit = stoi(valuemap[ExtCfg::FIELD_SELECTED_FAN_WIND_FIT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SELECTED_FAN_WIND_FIT.c_str(), to_string(ecfg.m_SelectedFanWindFit).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(ExtCfg::FIELD_PRESSURE_ID) != valuemap.end()) {
		ecfg.m_PressureAdc.id = stoi(valuemap[ExtCfg::FIELD_PRESSURE_ID]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_PRESSURE_ID.c_str(), to_string(ecfg.m_PressureAdc.id).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_PRESSURE_CODE) != valuemap.end()) {
		ecfg.m_PressureAdc.code = valuemap[ExtCfg::FIELD_PRESSURE_CODE];
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_PRESSURE_CODE.c_str(), ecfg.m_PressureAdc.code.c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_PRESSURE_SLOPE) != valuemap.end()) {
		ecfg.m_PressureAdc.slope = stod(valuemap[ExtCfg::FIELD_PRESSURE_SLOPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_PRESSURE_SLOPE.c_str(), to_string(ecfg.m_PressureAdc.slope).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_PRESSURE_INTERCEPT) != valuemap.end()) {
		ecfg.m_PressureAdc.intercept = stod(valuemap[ExtCfg::FIELD_PRESSURE_INTERCEPT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_PRESSURE_INTERCEPT.c_str(), to_string(ecfg.m_PressureAdc.intercept).c_str());
		needins.push_back(buffer);
	}

	ecfg.m_AdcCfgs[ecfg.m_PressureAdc.id] = &ecfg.m_PressureAdc;
	
	if (valuemap.find(ExtCfg::FIELD_COM_GET_OXYGEN) != valuemap.end()) {
		ecfg.m_ComGetOxygen = (stoi(valuemap[ExtCfg::FIELD_COM_GET_OXYGEN])>0?true:false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_COM_GET_OXYGEN.c_str(), ecfg.m_ComGetOxygen?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CHECK_DATA_WHEN_IMPORT) != valuemap.end()) {
		ecfg.m_CheckDataWhenInport = (stoi(valuemap[ExtCfg::FIELD_CHECK_DATA_WHEN_IMPORT]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CHECK_DATA_WHEN_IMPORT.c_str(), ecfg.m_CheckDataWhenInport ? "1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CAMERA_TYPE) != valuemap.end()) {
		ecfg.m_CameraType = stoi(valuemap[ExtCfg::FIELD_CAMERA_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CAMERA_TYPE.c_str(), to_string(ecfg.m_CameraType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CAMERA_IS_GAIN_AUTO) != valuemap.end()) {
		ecfg.m_IsGainAuto = stoi(valuemap[ExtCfg::FIELD_CAMERA_IS_GAIN_AUTO]) > 0 ? true : false;
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CAMERA_IS_GAIN_AUTO.c_str(), ecfg.m_IsGainAuto ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CAMERA_EXPOSURE_TIME) != valuemap.end()) {
		ecfg.m_ExposureTime = stod(valuemap[ExtCfg::FIELD_CAMERA_EXPOSURE_TIME]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CAMERA_EXPOSURE_TIME.c_str(), to_string(ecfg.m_ExposureTime).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CAMERA_EXPOSURE_TIME_MIN) != valuemap.end()) {
		ecfg.m_ExposureTimeMin = stod(valuemap[ExtCfg::FIELD_CAMERA_EXPOSURE_TIME_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CAMERA_EXPOSURE_TIME_MIN.c_str(), to_string(ecfg.m_ExposureTimeMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CAMERA_EXPOSURE_TIME_MAX) != valuemap.end()) {
		ecfg.m_ExposureTimeMax = stod(valuemap[ExtCfg::FIELD_CAMERA_EXPOSURE_TIME_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CAMERA_EXPOSURE_TIME_MAX.c_str(), to_string(ecfg.m_ExposureTimeMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CAMERA_IS_EXPOSURE_AUTO) != valuemap.end()) {
		ecfg.m_IsExposureAuto = stoi(valuemap[ExtCfg::FIELD_CAMERA_IS_EXPOSURE_AUTO]) > 0 ? true : false;
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CAMERA_IS_EXPOSURE_AUTO.c_str(), ecfg.m_IsExposureAuto ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CAMERA_LOG_RATIO) != valuemap.end()) {
		ecfg.m_LogRatio = stof(valuemap[ExtCfg::FIELD_CAMERA_LOG_RATIO]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CAMERA_LOG_RATIO.c_str(), to_string(ecfg.m_LogRatio).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_UV0X) != valuemap.end()) {
		ecfg.m_ShowImageUV0x = stof(valuemap[ExtCfg::FIELD_SHOW_IMAGE_UV0X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_UV0X.c_str(), to_string(ecfg.m_ShowImageUV0x).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_UV0Y) != valuemap.end()) {
		ecfg.m_ShowImageUV0y = stof(valuemap[ExtCfg::FIELD_SHOW_IMAGE_UV0Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_UV0Y.c_str(), to_string(ecfg.m_ShowImageUV0y).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_UV1X) != valuemap.end()) {
		ecfg.m_ShowImageUV1x = stof(valuemap[ExtCfg::FIELD_SHOW_IMAGE_UV1X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_UV1X.c_str(), to_string(ecfg.m_ShowImageUV1x).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_UV1Y) != valuemap.end()) {
		ecfg.m_ShowImageUV1y = stof(valuemap[ExtCfg::FIELD_SHOW_IMAGE_UV1Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_UV1Y.c_str(), to_string(ecfg.m_ShowImageUV1y).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_ROTATE_ANGLE) != valuemap.end()) {
		ecfg.m_ShowImageRotateAngle = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_ROTATE_ANGLE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_ROTATE_ANGLE.c_str(), to_string(ecfg.m_ShowImageRotateAngle).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_SCRALE_X) != valuemap.end()) {
		ecfg.m_ShowImageScaleX = stof(valuemap[ExtCfg::FIELD_SHOW_IMAGE_SCRALE_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_SCRALE_X.c_str(), to_string(ecfg.m_ShowImageScaleX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_SCRALE_Y) != valuemap.end()) {
		ecfg.m_ShowImageScaleY = stof(valuemap[ExtCfg::FIELD_SHOW_IMAGE_SCRALE_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_SCRALE_Y.c_str(), to_string(ecfg.m_ShowImageScaleY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_IS_CAMERA_COLORFUL) != valuemap.end()) {
		ecfg.m_IsCameralColorful = stoi(valuemap[ExtCfg::FIELD_IS_CAMERA_COLORFUL]) > 0 ? true : false;
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_IS_CAMERA_COLORFUL.c_str(), ecfg.m_IsCameralColorful ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_MODEL_ENABLE) != valuemap.end()) {
		ecfg.m_model_enable = (stoi(valuemap[ExtCfg::FIELD_MODEL_ENABLE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_MODEL_ENABLE.c_str(), to_string(ecfg.m_model_enable).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_MODEL_SCAN_MODE) != valuemap.end()) {
		ecfg.m_model_scan_mode = stoi(valuemap[ExtCfg::FIELD_MODEL_SCAN_MODE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_MODEL_SCAN_MODE.c_str(), to_string(ecfg.m_model_scan_mode).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_MODEL_SCAN_TYPE) != valuemap.end()) {
		ecfg.m_model_scan_type = valuemap[ExtCfg::FIELD_MODEL_SCAN_TYPE];
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_MODEL_SCAN_TYPE.c_str(), ecfg.m_model_scan_type.c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_MODEL_LASER_POWER) != valuemap.end()) {
		ecfg.m_model_laser_power = stoi(valuemap[ExtCfg::FIELD_MODEL_LASER_POWER]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_MODEL_LASER_POWER.c_str(), to_string(ecfg.m_model_laser_power).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_MODEL_LASER_POWER_MIN) != valuemap.end()) {
		ecfg.m_model_laser_power_min = stoi(valuemap[ExtCfg::FIELD_MODEL_LASER_POWER_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_MODEL_LASER_POWER_MIN.c_str(), to_string(ecfg.m_model_laser_power_min).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_MODEL_LASER_POWER_MAX) != valuemap.end()) {
		ecfg.m_model_laser_power_max = stoi(valuemap[ExtCfg::FIELD_MODEL_LASER_POWER_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_MODEL_LASER_POWER_MAX.c_str(), to_string(ecfg.m_model_laser_power_max).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_MODEL_LASER_SPEED) != valuemap.end()) {
		ecfg.m_model_laser_speed = stod(valuemap[ExtCfg::FIELD_MODEL_LASER_SPEED]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_MODEL_LASER_SPEED.c_str(), to_string(ecfg.m_model_laser_speed).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_MODEL_BORDER_TYPE) != valuemap.end()) {
		ecfg.m_model_border_type = stoi(valuemap[ExtCfg::FIELD_MODEL_BORDER_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_MODEL_BORDER_TYPE.c_str(), to_string(ecfg.m_model_border_type).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_USE_CAMERA) != valuemap.end()) {
		ecfg.m_UseCamera = (stoi(valuemap[ExtCfg::FIELD_USE_CAMERA])>0?true:false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_USE_CAMERA.c_str(), ecfg.m_UseCamera?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_FAN_FREQUENCY_SLOPE) != valuemap.end()) {
		ecfg.m_FanFrequencySlope = stof(valuemap[ExtCfg::FIELD_FAN_FREQUENCY_SLOPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_FAN_FREQUENCY_SLOPE.c_str(), to_string(ecfg.m_FanFrequencySlope).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_FAN_FREQUENCY_INTERCEPT) != valuemap.end()) {
		ecfg.m_FanFrequencyIntercept = stof(valuemap[ExtCfg::FIELD_FAN_FREQUENCY_INTERCEPT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_FAN_FREQUENCY_INTERCEPT.c_str(), to_string(ecfg.m_FanFrequencyIntercept).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_TEST_EMISSION_TIME) != valuemap.end()) {
		ecfg.m_TestEmissionTime = stoul(valuemap[ExtCfg::FIELD_TEST_EMISSION_TIME]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_TEST_EMISSION_TIME.c_str(), to_string(ecfg.m_TestEmissionTime).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_USE_DATA_SEQ) != valuemap.end()) {
		ecfg.m_UseDataSeq = (stoi(valuemap[ExtCfg::FIELD_USE_DATA_SEQ])>0?true:false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_USE_DATA_SEQ.c_str(), to_string(ecfg.m_UseDataSeq).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_AUTO_COVER_SLOW_WIND) != valuemap.end()) {
		ecfg.m_AutoCoverSlowWind = (stoi(valuemap[ExtCfg::FIELD_AUTO_COVER_SLOW_WIND])>0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_AUTO_COVER_SLOW_WIND.c_str(), to_string(ecfg.m_AutoCoverSlowWind).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_OXYGEN1_SENSOR_TYPE) != valuemap.end()) {
		ecfg.m_Oxygen1SensorType = stoi(valuemap[ExtCfg::FIELD_OXYGEN1_SENSOR_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_OXYGEN1_SENSOR_TYPE.c_str(), to_string(ecfg.m_Oxygen1SensorType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_OXYGEN2_SENSOR_TYPE) != valuemap.end()) {
		ecfg.m_Oxygen2SensorType = stoi(valuemap[ExtCfg::FIELD_OXYGEN2_SENSOR_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_OXYGEN2_SENSOR_TYPE.c_str(), to_string(ecfg.m_Oxygen2SensorType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_OUT_OXYGEN_SENSOR_TYPE) != valuemap.end()) {
		ecfg.m_OutOxygenSensorType = stoi(valuemap[ExtCfg::FIELD_OUT_OXYGEN_SENSOR_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_OUT_OXYGEN_SENSOR_TYPE.c_str(), to_string(ecfg.m_OutOxygenSensorType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_CLEAN_BOX_OXYGEN_SENSOR_TYPE) != valuemap.end()) {
		ecfg.m_CleanBoxOxygenSensorType = stoi(valuemap[ExtCfg::FIELD_CLEAN_BOX_OXYGEN_SENSOR_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_CLEAN_BOX_OXYGEN_SENSOR_TYPE.c_str(), to_string(ecfg.m_CleanBoxOxygenSensorType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_HAS_CLEAN_BOX_OXYGEN_SENSOR) != valuemap.end()) {
		ecfg.m_HasCleanBoxOxygenSensor = (stoi(valuemap[ExtCfg::FIELD_HAS_CLEAN_BOX_OXYGEN_SENSOR])>0?true:false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_HAS_CLEAN_BOX_OXYGEN_SENSOR.c_str(), ecfg.m_HasCleanBoxOxygenSensor ?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_AFT_LASER_POWER_WAIT_SECOND) != valuemap.end()) {
		ecfg.m_AftLaserPowerWaitSecond = stoul(valuemap[ExtCfg::FIELD_AFT_LASER_POWER_WAIT_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_AFT_LASER_POWER_WAIT_SECOND.c_str(), to_string(ecfg.m_AftLaserPowerWaitSecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_AFT_LASER_START_WAIT_SECOND) != valuemap.end()) {
		ecfg.m_AftLaserStartWaitSecond = stoul(valuemap[ExtCfg::FIELD_AFT_LASER_START_WAIT_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_AFT_LASER_START_WAIT_SECOND.c_str(), to_string(ecfg.m_AftLaserStartWaitSecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_AFT_LASER_ENABLE_WAIT_SECOND) != valuemap.end()) {
		ecfg.m_AftLaserEnableWaitSecond = stoul(valuemap[ExtCfg::FIELD_AFT_LASER_ENABLE_WAIT_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_AFT_LASER_ENABLE_WAIT_SECOND.c_str(), to_string(ecfg.m_AftLaserEnableWaitSecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_USE_POWDER_STICK) != valuemap.end()) {
		ecfg.m_UsePowderStick = (stoi(valuemap[ExtCfg::FIELD_USE_POWDER_STICK]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_USE_POWDER_STICK.c_str(), ecfg.m_UsePowderStick ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_IS_SUPPLY_ONE_WAY) != valuemap.end()) {
		ecfg.m_IsSupplyOneWay = (stoi(valuemap[ExtCfg::FIELD_IS_SUPPLY_ONE_WAY]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_IS_SUPPLY_ONE_WAY.c_str(), ecfg.m_IsSupplyOneWay ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_HEATING_ALARM_PERCENT) != valuemap.end()) {
		ecfg.m_HeatingAlarmPercent = stof(valuemap[ExtCfg::FIELD_HEATING_ALARM_PERCENT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_HEATING_ALARM_PERCENT.c_str(), to_string(ecfg.m_HeatingAlarmPercent).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_FRAME_RATE_ENABLE) != valuemap.end()) {
		ecfg.m_FrameRateEnable = (stoi(valuemap[ExtCfg::FIELD_FRAME_RATE_ENABLE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_FRAME_RATE_ENABLE.c_str(), ecfg.m_FrameRateEnable ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_FRAME_RATE) != valuemap.end()) {
		ecfg.m_FrameRate = stod(valuemap[ExtCfg::FIELD_FRAME_RATE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_FRAME_RATE.c_str(), to_string(ecfg.m_FrameRate).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_LASER_CHILLER_TYPE) != valuemap.end()) {
		ecfg.m_LaserChillerType = stoi(valuemap[ExtCfg::FIELD_LASER_CHILLER_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_LASER_CHILLER_TYPE.c_str(), to_string(ecfg.m_LaserChillerType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_PURIFIER_CHILLER_TYPE) != valuemap.end()) {
		ecfg.m_PurifierChillerType = stoi(valuemap[ExtCfg::FIELD_PURIFIER_CHILLER_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_PURIFIER_CHILLER_TYPE.c_str(), to_string(ecfg.m_PurifierChillerType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_ANGLE) != valuemap.end()) {
		ecfg.m_ShowImageAngle = stod(valuemap[ExtCfg::FIELD_SHOW_IMAGE_ANGLE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_ANGLE.c_str(), to_string(ecfg.m_ShowImageAngle).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_USE_SHOW_IMAGE_WARP_PERSPECTIVE) != valuemap.end()) {
		ecfg.m_UseShowImageWarpPerspective = (stoi(valuemap[ExtCfg::FIELD_USE_SHOW_IMAGE_WARP_PERSPECTIVE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_USE_SHOW_IMAGE_WARP_PERSPECTIVE.c_str(), ecfg.m_UseShowImageWarpPerspective ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_TOP_LEFT_X) != valuemap.end()) {
		ecfg.m_ShowImageTopLeftX = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_TOP_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_TOP_LEFT_X.c_str(), to_string(ecfg.m_ShowImageTopLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_TOP_LEFT_Y) != valuemap.end()) {
		ecfg.m_ShowImageTopLeftY = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_TOP_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_TOP_LEFT_Y.c_str(), to_string(ecfg.m_ShowImageTopLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_TOP_RIGHT_X) != valuemap.end()) {
		ecfg.m_ShowImageTopRightX = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_TOP_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_TOP_RIGHT_X.c_str(), to_string(ecfg.m_ShowImageTopRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_TOP_RIGHT_Y) != valuemap.end()) {
		ecfg.m_ShowImageTopRightY = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_TOP_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_TOP_RIGHT_Y.c_str(), to_string(ecfg.m_ShowImageTopRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_LEFT_X) != valuemap.end()) {
		ecfg.m_ShowImageBottomLeftX = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_LEFT_X.c_str(), to_string(ecfg.m_ShowImageBottomLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_LEFT_Y) != valuemap.end()) {
		ecfg.m_ShowImageBottomLeftY = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_LEFT_Y.c_str(), to_string(ecfg.m_ShowImageBottomLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_RIGHT_X) != valuemap.end()) {
		ecfg.m_ShowImageBottomRightX = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_RIGHT_X.c_str(), to_string(ecfg.m_ShowImageBottomRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_RIGHT_Y) != valuemap.end()) {
		ecfg.m_ShowImageBottomRightY = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_BOTTOM_RIGHT_Y.c_str(), to_string(ecfg.m_ShowImageBottomRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_PERSPECTIVE_WIDTH) != valuemap.end()) {
		ecfg.m_ShowImagePerspectiveWidth = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_PERSPECTIVE_WIDTH]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_PERSPECTIVE_WIDTH.c_str(), to_string(ecfg.m_ShowImagePerspectiveWidth).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SHOW_IMAGE_PERSPECTIVE_HEIGH) != valuemap.end()) {
		ecfg.m_ShowImagePerspectiveHeigh = stoi(valuemap[ExtCfg::FIELD_SHOW_IMAGE_PERSPECTIVE_HEIGH]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SHOW_IMAGE_PERSPECTIVE_HEIGH.c_str(), to_string(ecfg.m_ShowImagePerspectiveHeigh).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_SCAN_POWER_TYPE) != valuemap.end()) {
		ecfg.m_ScanPowerType = stod(valuemap[ExtCfg::FIELD_SCAN_POWER_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_SCAN_POWER_TYPE.c_str(), to_string(ecfg.m_ScanPowerType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ExtCfg::FIELD_LASER_TYPE) != valuemap.end()) {
		ecfg.m_LaserType = stoi(valuemap[ExtCfg::FIELD_LASER_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ExtCfg::FIELD_LASER_TYPE.c_str(), to_string(ecfg.m_LaserType).c_str());
		needins.push_back(buffer);
	}

	if (!needins.empty()) {
		SQLite::Transaction transaction(*m_pDB);
		for (size_t i = 0; i < needins.size(); ++i) {
			m_pDB->exec(needins[i]);
		}
		transaction.commit();
	}
}


void BaseConfigDao::FindRunCfg(RunCfg& rcfg)
{
	map<string, string> valuemap;
	FindValue(RunCfg::CONFIG_NAME, valuemap);
	char buffer[512];
	string strtemp = "INSERT INTO %s(%s,%s,%s) VALUES('%s',";
	sprintf_s(buffer, sizeof(buffer), strtemp.c_str(),
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str(),
		BaseConfig::FIELD_CONFIG_VALUE.c_str(),
		RunCfg::CONFIG_NAME.c_str()
	);
	string strsql = string(buffer) + "'%s','%s')";
	vector<string> needins;

	if (valuemap.find(RunCfg::FIELD_IS_DEBUG_MODE) != valuemap.end()) {
		rcfg.m_IsDebugMode = (stoi(valuemap[RunCfg::FIELD_IS_DEBUG_MODE])>0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_IS_DEBUG_MODE.c_str(), rcfg.m_IsDebugMode?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_TARGE_OXYGEN) != valuemap.end()) {
		rcfg.m_TargeOxygen = stof(valuemap[RunCfg::FIELD_TARGE_OXYGEN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_TARGE_OXYGEN.c_str(), to_string(rcfg.m_TargeOxygen).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_WARN_OXYGEN) != valuemap.end()) {
		rcfg.m_WarnOxygen = stof(valuemap[RunCfg::FIELD_WARN_OXYGEN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_WARN_OXYGEN.c_str(), to_string(rcfg.m_WarnOxygen).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_ALARM_OXYGEN) != valuemap.end()) {
		rcfg.m_AlarmOxygen = stof(valuemap[RunCfg::FIELD_ALARM_OXYGEN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_OXYGEN.c_str(), to_string(rcfg.m_AlarmOxygen).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_START_CYCLE_OXYGEN) != valuemap.end()) {
		rcfg.m_StartCycleOxygen = stof(valuemap[RunCfg::FIELD_START_CYCLE_OXYGEN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_START_CYCLE_OXYGEN.c_str(), to_string(rcfg.m_StartCycleOxygen).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_DANGEROUS_OXYGEN) != valuemap.end()) {
		rcfg.m_DangerousOxygen = stof(valuemap[RunCfg::FIELD_DANGEROUS_OXYGEN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_DANGEROUS_OXYGEN.c_str(), to_string(rcfg.m_DangerousOxygen).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_ALARM_TEMPERTURE) != valuemap.end()) {
		rcfg.m_AlarmTemperture = stof(valuemap[RunCfg::FIELD_ALARM_TEMPERTURE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_TEMPERTURE.c_str(), to_string(rcfg.m_AlarmTemperture).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_ALARM_TEMPERTURE_MIN) != valuemap.end()) {
		rcfg.m_AlarmTempertureMin = (float)stod(valuemap[RunCfg::FIELD_ALARM_TEMPERTURE_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_TEMPERTURE_MIN.c_str(), to_string(rcfg.m_AlarmTempertureMin).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_ALARM_TEMPERTURE_MAX) != valuemap.end()) {
		rcfg.m_AlarmTempertureMax = (float)stod(valuemap[RunCfg::FIELD_ALARM_TEMPERTURE_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_TEMPERTURE_MAX.c_str(), to_string(rcfg.m_AlarmTempertureMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_ALARM_WATER_TEMP_DOWN) != valuemap.end()) {
		rcfg.m_AlarmWaterTempDown = (float)stod(valuemap[RunCfg::FIELD_ALARM_WATER_TEMP_DOWN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_WATER_TEMP_DOWN.c_str(), to_string(rcfg.m_AlarmWaterTempDown).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_ALARM_WATER_TEMP_DOWN_MIN) != valuemap.end()) {
		rcfg.m_AlarmWaterTempDownMin = (float)stod(valuemap[RunCfg::FIELD_ALARM_WATER_TEMP_DOWN_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_WATER_TEMP_DOWN_MIN.c_str(), to_string(rcfg.m_AlarmWaterTempDownMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_ALARM_WATER_TEMP_DOWN_MAX) != valuemap.end()) {
		rcfg.m_AlarmWaterTempDownMax = (float)stod(valuemap[RunCfg::FIELD_ALARM_WATER_TEMP_DOWN_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_WATER_TEMP_DOWN_MAX.c_str(), to_string(rcfg.m_AlarmWaterTempDownMax).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_ALARM_WATER_TEMP_UP) != valuemap.end()) {
		rcfg.m_AlarmWaterTempUp = (float)stod(valuemap[RunCfg::FIELD_ALARM_WATER_TEMP_UP]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_WATER_TEMP_UP.c_str(), to_string(rcfg.m_AlarmWaterTempUp).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_ALARM_WATER_TEMP_UP_MIN) != valuemap.end()) {
		rcfg.m_AlarmWaterTempUpMin = (float)stod(valuemap[RunCfg::FIELD_ALARM_WATER_TEMP_UP_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_WATER_TEMP_UP_MIN.c_str(), to_string(rcfg.m_AlarmWaterTempUpMin).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_ALARM_WATER_TEMP_UP_MAX) != valuemap.end()) {
		rcfg.m_AlarmWaterTempUpMax = (float)stod(valuemap[RunCfg::FIELD_ALARM_WATER_TEMP_UP_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ALARM_WATER_TEMP_UP_MAX.c_str(), to_string(rcfg.m_AlarmWaterTempUpMax).c_str());
		needins.push_back(buffer);
	}
	
	
	if (valuemap.find(RunCfg::FIELD_LOG_PERSIST_INTEVAL) != valuemap.end()) {
		rcfg.m_LogPersistInteval = stoi(valuemap[RunCfg::FIELD_LOG_PERSIST_INTEVAL]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_LOG_PERSIST_INTEVAL.c_str(), to_string(rcfg.m_LogPersistInteval).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_STATISTICS_INTEVAL) != valuemap.end()) {
		rcfg.m_StatisticsInteval = stoi(valuemap[RunCfg::FIELD_STATISTICS_INTEVAL]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_STATISTICS_INTEVAL.c_str(), to_string(rcfg.m_StatisticsInteval).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_STABLE_WIND_STEP) != valuemap.end()) {
		rcfg.m_StableWindStep = stof(valuemap[RunCfg::FIELD_STABLE_WIND_STEP]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_STABLE_WIND_STEP.c_str(), to_string(rcfg.m_StableWindStep).c_str());
		needins.push_back(buffer);
	}

	
	if (valuemap.find(RunCfg::FIELD_SSR_TIME_LIMIT) != valuemap.end()) {
		rcfg.m_SSRTimeLimit = stoi(valuemap[RunCfg::FIELD_SSR_TIME_LIMIT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SSR_TIME_LIMIT.c_str(), to_string(rcfg.m_SSRTimeLimit).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_SSR_TIME_LIMIT_MIN) != valuemap.end()) {
		rcfg.m_SSRTimeLimitMin = stoi(valuemap[RunCfg::FIELD_SSR_TIME_LIMIT_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SSR_TIME_LIMIT_MIN.c_str(), to_string(rcfg.m_SSRTimeLimitMin).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_SSR_TIME_LIMIT_MAX) != valuemap.end()) {
		rcfg.m_SSRTimeLimitMax = stoi(valuemap[RunCfg::FIELD_SSR_TIME_LIMIT_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SSR_TIME_LIMIT_MAX.c_str(), to_string(rcfg.m_SSRTimeLimitMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_HEATING_DELAY_DISABLE_MINUTE) != valuemap.end()) {
		rcfg.m_HeatingDeleyDisableMinute = stoi(valuemap[RunCfg::FIELD_HEATING_DELAY_DISABLE_MINUTE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_HEATING_DELAY_DISABLE_MINUTE.c_str(), to_string(rcfg.m_HeatingDeleyDisableMinute).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_HIGH_OXYGEN_HEATING_TEMP) != valuemap.end()) {
		rcfg.m_HighOxygenHeatingTemp = stof(valuemap[RunCfg::FIELD_HIGH_OXYGEN_HEATING_TEMP]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_HIGH_OXYGEN_HEATING_TEMP.c_str(), to_string(rcfg.m_HighOxygenHeatingTemp).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_LOW_OXYGEN_HEATING_TEMP) != valuemap.end()) {
		rcfg.m_LowOxygenHeatingTemp = stof(valuemap[RunCfg::FIELD_LOW_OXYGEN_HEATING_TEMP]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_LOW_OXYGEN_HEATING_TEMP.c_str(), to_string(rcfg.m_LowOxygenHeatingTemp).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_USE_HEATING_MOTION) != valuemap.end()) {
		rcfg.m_UseHeatingMotion = (stoi(valuemap[RunCfg::FIELD_USE_HEATING_MOTION]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_USE_HEATING_MOTION.c_str(), rcfg.m_UseHeatingMotion ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_HEATING_MOTION_PERIOD_SECOND) != valuemap.end()) {
		rcfg.m_HeatingMotionPeriodSecond = stoul(valuemap[RunCfg::FIELD_HEATING_MOTION_PERIOD_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_HEATING_MOTION_PERIOD_SECOND.c_str(), to_string(rcfg.m_HeatingMotionPeriodSecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_HEATING_MOTION_DISTANCE) != valuemap.end()) {
		rcfg.m_HeatingMotionDistance = stod(valuemap[RunCfg::FIELD_HEATING_MOTION_DISTANCE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_HEATING_MOTION_DISTANCE.c_str(), to_string(rcfg.m_HeatingMotionDistance).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_FAN_VOLTAGE_OVER_LIMIT) != valuemap.end()) {
		rcfg.m_FanVoltageOverLimit = stof(valuemap[RunCfg::FIELD_FAN_VOLTAGE_OVER_LIMIT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_FAN_VOLTAGE_OVER_LIMIT.c_str(), to_string(rcfg.m_FanVoltageOverLimit).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_IS_AUTO_RELEASE_PRESSURE_WHEN_FINISH) != valuemap.end()) {
		rcfg.m_IsAutoReleasePressureWhenFinish = (stoi(valuemap[RunCfg::FIELD_IS_AUTO_RELEASE_PRESSURE_WHEN_FINISH])>0?true:false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_IS_AUTO_RELEASE_PRESSURE_WHEN_FINISH.c_str(), rcfg.m_IsAutoReleasePressureWhenFinish?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_RELEASE_PRESSURE_SECONDS) != valuemap.end()) {
		rcfg.m_ReleasePressureSeconds = stoul(valuemap[RunCfg::FIELD_RELEASE_PRESSURE_SECONDS]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_RELEASE_PRESSURE_SECONDS.c_str(), to_string(rcfg.m_ReleasePressureSeconds).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_RELEASE_PRESSURE_TARGE_VALUE) != valuemap.end()) {
		rcfg.m_ReleasePressureTargeValue = stof(valuemap[RunCfg::FIELD_RELEASE_PRESSURE_TARGE_VALUE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_RELEASE_PRESSURE_TARGE_VALUE.c_str(), to_string(rcfg.m_ReleasePressureTargeValue).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PRINT_REST_ENABLE) != valuemap.end()) {
		rcfg.m_PrintRestEnable = (stoi(valuemap[RunCfg::FIELD_PRINT_REST_ENABLE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PRINT_REST_ENABLE.c_str(), rcfg.m_PrintRestEnable ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PRINT_CONTINUE_MINUTES) != valuemap.end()) {
		rcfg.m_PrintContinueMinute = stoul(valuemap[RunCfg::FIELD_PRINT_CONTINUE_MINUTES]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PRINT_CONTINUE_MINUTES.c_str(), to_string(rcfg.m_PrintContinueMinute).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PRINT_REST_MINUTES) != valuemap.end()) {
		rcfg.m_PrintRestMinutes = stoul(valuemap[RunCfg::FIELD_PRINT_REST_MINUTES]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PRINT_REST_MINUTES.c_str(), to_string(rcfg.m_PrintRestMinutes).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_BLOW_BACK_NOTIFY_TIMEOUT) != valuemap.end()) {
		rcfg.m_BlowbackNotifyTimeout = stoul(valuemap[RunCfg::FIELD_BLOW_BACK_NOTIFY_TIMEOUT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_BLOW_BACK_NOTIFY_TIMEOUT.c_str(), to_string(rcfg.m_BlowbackNotifyTimeout).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_BLOW_BACK_TIMEOUT_EXECUTE) != valuemap.end()) {
		rcfg.m_BlowbackTimeoutExecute = (stoi(valuemap[RunCfg::FIELD_BLOW_BACK_TIMEOUT_EXECUTE])>0?true:false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_BLOW_BACK_TIMEOUT_EXECUTE.c_str(), rcfg.m_BlowbackTimeoutExecute?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_DOWM_SKIN_STOP_TIMES) != valuemap.end()) {
		rcfg.m_DownSkinStopTimes = stoul(valuemap[RunCfg::FIELD_DOWM_SKIN_STOP_TIMES]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_DOWM_SKIN_STOP_TIMES.c_str(), to_string(rcfg.m_DownSkinStopTimes).c_str());
		needins.push_back(buffer);
	}
	
	if (valuemap.find(RunCfg::FIELD_TIME_POWER_COMPENSATE_ENABLE) != valuemap.end()) {
		rcfg.m_TimePowerCompensateEnable = (stoi(valuemap[RunCfg::FIELD_TIME_POWER_COMPENSATE_ENABLE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_TIME_POWER_COMPENSATE_ENABLE.c_str(), rcfg.m_TimePowerCompensateEnable ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_IS_PREPARE_PRINT) != valuemap.end()) {
		rcfg.m_IsPreparePrint = (stoi(valuemap[RunCfg::FIELD_IS_PREPARE_PRINT]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_IS_PREPARE_PRINT.c_str(), rcfg.m_IsPreparePrint ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PREPARE_PARAM_TYPE) != valuemap.end()) {
		rcfg.m_PrepareParamType = stoi(valuemap[RunCfg::FIELD_PREPARE_PARAM_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PREPARE_PARAM_TYPE.c_str(), to_string(rcfg.m_PrepareParamType).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_WARN_ALARM_NOTIFY_SECOND) != valuemap.end()) {
		rcfg.m_WarnAlarmNotifySecond = stoul(valuemap[RunCfg::FIELD_WARN_ALARM_NOTIFY_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_WARN_ALARM_NOTIFY_SECOND.c_str(), to_string(rcfg.m_WarnAlarmNotifySecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_POWDER_ALARM_POS) != valuemap.end()) {
		rcfg.m_PowderAlarmPos = stoi(valuemap[RunCfg::FIELD_POWDER_ALARM_POS]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_POWDER_ALARM_POS.c_str(), to_string(rcfg.m_PowderAlarmPos).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_VOLTAGE_ALARM_OFFSET) != valuemap.end()) {
		rcfg.m_VoltageAlarmOffset = stof(valuemap[RunCfg::FIELD_VOLTAGE_ALARM_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_VOLTAGE_ALARM_OFFSET.c_str(), to_string(rcfg.m_VoltageAlarmOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_SCANNER_POWER_LOG_TICK) != valuemap.end()) {
		rcfg.m_ScannerPowerLogTick = stoul(valuemap[RunCfg::FIELD_SCANNER_POWER_LOG_TICK]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SCANNER_POWER_LOG_TICK.c_str(), to_string(rcfg.m_ScannerPowerLogTick).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_SCANNER_POWER_LOG_COUNT) != valuemap.end()) {
		rcfg.m_ScannerPowerLogCount = stoul(valuemap[RunCfg::FIELD_SCANNER_POWER_LOG_COUNT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SCANNER_POWER_LOG_COUNT.c_str(), to_string(rcfg.m_ScannerPowerLogCount).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_SCANNER_VOLTAGE_MIN_LIMIT) != valuemap.end()) {
		rcfg.m_ScannerVoltageMinLimit = stof(valuemap[RunCfg::FIELD_SCANNER_VOLTAGE_MIN_LIMIT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SCANNER_VOLTAGE_MIN_LIMIT.c_str(), to_string(rcfg.m_ScannerVoltageMinLimit).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_SCANNER_VOLTAGE_MAX_LIMIT) != valuemap.end()) {
		rcfg.m_ScannerVoltageMaxLimit = stof(valuemap[RunCfg::FIELD_SCANNER_VOLTAGE_MAX_LIMIT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SCANNER_VOLTAGE_MAX_LIMIT.c_str(), to_string(rcfg.m_ScannerVoltageMaxLimit).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PRINT_AUTO_RENEWAL_GAS) != valuemap.end()) {
		rcfg.m_PrintAutoRenewalGas = (stoi(valuemap[RunCfg::FIELD_PRINT_AUTO_RENEWAL_GAS])>0?true:false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PRINT_AUTO_RENEWAL_GAS.c_str(),rcfg.m_PrintAutoRenewalGas?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_MOLD_DEOXYGEN_ENABLE) != valuemap.end()) {
		rcfg.m_MoldDeoxygenEnable = (stoi(valuemap[RunCfg::FIELD_MOLD_DEOXYGEN_ENABLE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_MOLD_DEOXYGEN_ENABLE.c_str(), rcfg.m_MoldDeoxygenEnable ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_ADD_POWDER_WARN_POS) != valuemap.end()) {
		rcfg.m_AddPowderWarnPos = stof(valuemap[RunCfg::FIELD_ADD_POWDER_WARN_POS]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_ADD_POWDER_WARN_POS.c_str(), to_string(rcfg.m_AddPowderWarnPos).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_POWDER_STICK_LOW_LEVEL_ALARM_POS) != valuemap.end()) {
		rcfg.m_PowderStickLowLevelAlarmPos = stof(valuemap[RunCfg::FIELD_POWDER_STICK_LOW_LEVEL_ALARM_POS]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_POWDER_STICK_LOW_LEVEL_ALARM_POS.c_str(), to_string(rcfg.m_PowderStickLowLevelAlarmPos).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_USE_COVER_WIND_SIGNAL) != valuemap.end()) {
		rcfg.m_UseCoverWindSignal = (stoi(valuemap[RunCfg::FIELD_USE_COVER_WIND_SIGNAL]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_USE_COVER_WIND_SIGNAL.c_str(), rcfg.m_UseCoverWindSignal ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_MOLD_SERVO_POS_WARN_OFFSET) != valuemap.end()) {
		rcfg.m_MoldServoPosWarnOffset = stoul(valuemap[RunCfg::FIELD_MOLD_SERVO_POS_WARN_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_MOLD_SERVO_POS_WARN_OFFSET.c_str(), to_string(rcfg.m_MoldServoPosWarnOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_LAYER_LINEAR_POS_ALARM_OFFSET) != valuemap.end()) {
		rcfg.m_LayerLinearPosAlarmOffset = stoul(valuemap[RunCfg::FIELD_LAYER_LINEAR_POS_ALARM_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_LAYER_LINEAR_POS_ALARM_OFFSET.c_str(), to_string(rcfg.m_LayerLinearPosAlarmOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PRINT_LINEAR_ACC_DEV_ALARM_OFFSET) != valuemap.end()) {
		rcfg.m_PrintLinearAccDevAlarmOffset = stoul(valuemap[RunCfg::FIELD_PRINT_LINEAR_ACC_DEV_ALARM_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PRINT_LINEAR_ACC_DEV_ALARM_OFFSET.c_str(), to_string(rcfg.m_PrintLinearAccDevAlarmOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_USE_LINEAR_JUDGE_POS) != valuemap.end()) {
		rcfg.m_UseLinearJudgePos = stoi(valuemap[RunCfg::FIELD_USE_LINEAR_JUDGE_POS])>0?true:false;
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_USE_LINEAR_JUDGE_POS.c_str(),rcfg.m_UseLinearJudgePos?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_COVER_SIMULATE_TIME_OFFSET) != valuemap.end()) {
		rcfg.m_CoverSimulateTimeOffset = stod(valuemap[RunCfg::FIELD_COVER_SIMULATE_TIME_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_COVER_SIMULATE_TIME_OFFSET.c_str(), to_string(rcfg.m_CoverSimulateTimeOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_COVER_WIND_SIMULATE_TIME_OFFSET) != valuemap.end()) {
		rcfg.m_CoverWindSimulateTimeOffset = stod(valuemap[RunCfg::FIELD_COVER_WIND_SIMULATE_TIME_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_COVER_WIND_SIMULATE_TIME_OFFSET.c_str(), to_string(rcfg.m_CoverWindSimulateTimeOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_LOG_DEBUG_INFO) != valuemap.end()) {
		rcfg.m_LogDebugInfo = stoi(valuemap[RunCfg::FIELD_LOG_DEBUG_INFO]) > 0 ? true : false;
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_LOG_DEBUG_INFO.c_str(), rcfg.m_LogDebugInfo ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_AUTO_SHUTDOWN_POWER) != valuemap.end()) {
		rcfg.m_AutoShutdownPower = (stoi(valuemap[RunCfg::FIELD_AUTO_SHUTDOWN_POWER]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_AUTO_SHUTDOWN_POWER.c_str(), rcfg.m_AutoShutdownPower ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_FILTER_OXYGEN_ALARM_VALUE) != valuemap.end()) {
		rcfg.m_FilterOxygenAlarmValue = stof(valuemap[RunCfg::FIELD_FILTER_OXYGEN_ALARM_VALUE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_FILTER_OXYGEN_ALARM_VALUE.c_str(), to_string(rcfg.m_FilterOxygenAlarmValue).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_FAN_FREQ_LOW_LIMIT) != valuemap.end()) {
		rcfg.m_FanFreqLowLimit = stof(valuemap[RunCfg::FIELD_FAN_FREQ_LOW_LIMIT]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_FAN_FREQ_LOW_LIMIT.c_str(), to_string(rcfg.m_FanFreqLowLimit).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PRINT_LAYER_DELAY) != valuemap.end()) {
		rcfg.m_PrintLayerDelay = stoul(valuemap[RunCfg::FIELD_PRINT_LAYER_DELAY]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PRINT_LAYER_DELAY.c_str(), to_string(rcfg.m_PrintLayerDelay).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_COVER_LAYER_DELAY) != valuemap.end()) {
		rcfg.m_CoverLayerDelay = stoul(valuemap[RunCfg::FIELD_COVER_LAYER_DELAY]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_COVER_LAYER_DELAY.c_str(), to_string(rcfg.m_CoverLayerDelay).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_SMART_COVER_ENABLE) != valuemap.end()) {
		rcfg.m_SmartCoverEnable = (stoi(valuemap[RunCfg::FIELD_SMART_COVER_ENABLE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SMART_COVER_ENABLE.c_str(), rcfg.m_SmartCoverEnable ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_POWDER_STICK_CALC_LENGTH) != valuemap.end()) {
		rcfg.m_PowderStickCalcLength = stod(valuemap[RunCfg::FIELD_POWDER_STICK_CALC_LENGTH]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_POWDER_STICK_CALC_LENGTH.c_str(), to_string(rcfg.m_PowderStickCalcLength).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PURIFIER_FILTER_NOTIFY_HOUR) != valuemap.end()) {
		rcfg.m_PurifierFilterNotifyHour = stoi(valuemap[RunCfg::FIELD_PURIFIER_FILTER_NOTIFY_HOUR]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PURIFIER_FILTER_NOTIFY_HOUR.c_str(), to_string(rcfg.m_PurifierFilterNotifyHour).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_CHECK_DISK_SPACE_G) != valuemap.end()) {
		rcfg.m_CheckDiskSpaceG = stod(valuemap[RunCfg::FIELD_CHECK_DISK_SPACE_G]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_CHECK_DISK_SPACE_G.c_str(), to_string(rcfg.m_CheckDiskSpaceG).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PERLAYER_SPACE_K) != valuemap.end()) {
		rcfg.m_PerlayerSpaceK = stod(valuemap[RunCfg::FIELD_PERLAYER_SPACE_K]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PERLAYER_SPACE_K.c_str(), to_string(rcfg.m_PerlayerSpaceK).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_SHOW_UNLOAD_HAND_POS) != valuemap.end()) {
		rcfg.m_ShowUnloadHandPos = (stoi(valuemap[RunCfg::FIELD_SHOW_UNLOAD_HAND_POS]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_SHOW_UNLOAD_HAND_POS.c_str(), rcfg.m_ShowUnloadHandPos ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PURIFIER_DISCONNECT_ALARM_JUDGE_SECOND) != valuemap.end()) {
		rcfg.m_PurifierDisconnectAlarmJudgeSecond = stoul(valuemap[RunCfg::FIELD_PURIFIER_DISCONNECT_ALARM_JUDGE_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PURIFIER_DISCONNECT_ALARM_JUDGE_SECOND.c_str(), to_string(rcfg.m_PurifierDisconnectAlarmJudgeSecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_PURIFIER_KEEP_ALIVE_ALARM_JUDGE_SECOND) != valuemap.end()) {
		rcfg.m_PurifierKeepAliveAlarmJudgeSecond = stoul(valuemap[RunCfg::FIELD_PURIFIER_KEEP_ALIVE_ALARM_JUDGE_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_PURIFIER_KEEP_ALIVE_ALARM_JUDGE_SECOND.c_str(), to_string(rcfg.m_PurifierKeepAliveAlarmJudgeSecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_OXYGEN_SENSOR_DISCONNECT_ALARM_JUDGE_SECOND) != valuemap.end()) {
		rcfg.m_OxygenSensorDisconnectAlarmJudgeSecond = stoul(valuemap[RunCfg::FIELD_OXYGEN_SENSOR_DISCONNECT_ALARM_JUDGE_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_OXYGEN_SENSOR_DISCONNECT_ALARM_JUDGE_SECOND.c_str(), to_string(rcfg.m_OxygenSensorDisconnectAlarmJudgeSecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_HEATING_DISCONNECT_ALARM_JUDGE_SECOND) != valuemap.end()) {
		rcfg.m_HeatingDisconnectAlarmJudgeSecond = stoul(valuemap[RunCfg::FIELD_HEATING_DISCONNECT_ALARM_JUDGE_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_HEATING_DISCONNECT_ALARM_JUDGE_SECOND.c_str(), to_string(rcfg.m_HeatingDisconnectAlarmJudgeSecond).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RunCfg::FIELD_CHILLER_DISCONNECT_ALARM_JUDGE_SECOND) != valuemap.end()) {
		rcfg.m_ChillerDisconnectAlarmJudgeSecond = stoul(valuemap[RunCfg::FIELD_CHILLER_DISCONNECT_ALARM_JUDGE_SECOND]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RunCfg::FIELD_CHILLER_DISCONNECT_ALARM_JUDGE_SECOND.c_str(), to_string(rcfg.m_ChillerDisconnectAlarmJudgeSecond).c_str());
		needins.push_back(buffer);
	}

	if (!needins.empty()) {
		SQLite::Transaction transaction(*m_pDB);
		for (size_t i = 0; i < needins.size(); ++i) {
			m_pDB->exec(needins[i]);
		}
		transaction.commit();
	}
	
}



void BaseConfigDao::FindFavoriteCfg(FavoriteCfg& fcfg)
{
	map<string, string> valuemap;
	FindValue(FavoriteCfg::CONFIG_NAME, fcfg.mFavoriteMap);
}

void BaseConfigDao::FindPowderEstimate(PowderEstimateCfg& cfg)
{
	map<string, string> valuemap;
	FindValue(PowderEstimateCfg::CONFIG_NAME, valuemap);
	char buffer[512];
	string strtemp = "INSERT INTO %s(%s,%s,%s) VALUES('%s',";
	sprintf_s(buffer, sizeof(buffer), strtemp.c_str(),
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str(),
		BaseConfig::FIELD_CONFIG_VALUE.c_str(),
		PowderEstimateCfg::CONFIG_NAME.c_str()
	);
	string strsql = string(buffer) + "'%s','%s')";
	vector<string> needins;
	if (valuemap.find(PowderEstimateCfg::FIELD_POWDER_PER_GRID) != valuemap.end()) {
		cfg.m_PowderPerGrid = stoul(valuemap[PowderEstimateCfg::FIELD_POWDER_PER_GRID]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_POWDER_PER_GRID.c_str(), to_string(cfg.m_PowderPerGrid).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_SPACE_GRID1) != valuemap.end()) {
		cfg.m_PE1.m_SpaceGrid = stoul(valuemap[PowderEstimateCfg::FIELD_SPACE_GRID1]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_SPACE_GRID1.c_str(), to_string(cfg.m_PE1.m_SpaceGrid).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_SPACE_GRID2) != valuemap.end()) {
		cfg.m_PE2.m_SpaceGrid = stoul(valuemap[PowderEstimateCfg::FIELD_SPACE_GRID2]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_SPACE_GRID2.c_str(), to_string(cfg.m_PE2.m_SpaceGrid).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_SPACE_GRID3) != valuemap.end()) {
		cfg.m_PE3.m_SpaceGrid = stoul(valuemap[PowderEstimateCfg::FIELD_SPACE_GRID3]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_SPACE_GRID3.c_str(), to_string(cfg.m_PE3.m_SpaceGrid).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_SPACE_GRID4) != valuemap.end()) {
		cfg.m_PE4.m_SpaceGrid = stoul(valuemap[PowderEstimateCfg::FIELD_SPACE_GRID4]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_SPACE_GRID4.c_str(), to_string(cfg.m_PE4.m_SpaceGrid).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_SPACE_GRID5) != valuemap.end()) {
		cfg.m_PE5.m_SpaceGrid = stoul(valuemap[PowderEstimateCfg::FIELD_SPACE_GRID5]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_SPACE_GRID5.c_str(), to_string(cfg.m_PE5.m_SpaceGrid).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_POWDER_PERCENT1) != valuemap.end()) {
		cfg.m_PE1.m_PowderPercent = stof(valuemap[PowderEstimateCfg::FIELD_POWDER_PERCENT1]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_POWDER_PERCENT1.c_str(), to_string(cfg.m_PE1.m_PowderPercent).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_POWDER_PERCENT2) != valuemap.end()) {
		cfg.m_PE2.m_PowderPercent = stof(valuemap[PowderEstimateCfg::FIELD_POWDER_PERCENT2]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_POWDER_PERCENT2.c_str(), to_string(cfg.m_PE2.m_PowderPercent).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_POWDER_PERCENT3) != valuemap.end()) {
		cfg.m_PE3.m_PowderPercent = stof(valuemap[PowderEstimateCfg::FIELD_POWDER_PERCENT3]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_POWDER_PERCENT3.c_str(), to_string(cfg.m_PE3.m_PowderPercent).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_POWDER_PERCENT4) != valuemap.end()) {
		cfg.m_PE4.m_PowderPercent = stof(valuemap[PowderEstimateCfg::FIELD_POWDER_PERCENT4]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_POWDER_PERCENT4.c_str(), to_string(cfg.m_PE4.m_PowderPercent).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_POWDER_PERCENT5) != valuemap.end()) {
		cfg.m_PE5.m_PowderPercent = stof(valuemap[PowderEstimateCfg::FIELD_POWDER_PERCENT5]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_POWDER_PERCENT5.c_str(), to_string(cfg.m_PE5.m_PowderPercent).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_REMAIN_POWDER_GRID) != valuemap.end()) {
		cfg.m_RemainPowderGrid = stoul(valuemap[PowderEstimateCfg::FIELD_REMAIN_POWDER_GRID]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_REMAIN_POWDER_GRID.c_str(), to_string(cfg.m_RemainPowderGrid).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_START_SUPPLY_POS) != valuemap.end()) {
		cfg.m_StartSupplyPos = stoi(valuemap[PowderEstimateCfg::FIELD_START_SUPPLY_POS]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_START_SUPPLY_POS.c_str(), to_string(cfg.m_StartSupplyPos).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_STOP_SUPPLY_POS) != valuemap.end()) {
		cfg.m_StopSupplyPos = stoi(valuemap[PowderEstimateCfg::FIELD_STOP_SUPPLY_POS]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_STOP_SUPPLY_POS.c_str(), to_string(cfg.m_StopSupplyPos).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_AUTO_SUPPLY_ENABLE) != valuemap.end()) {
		cfg.m_AutoSupplyEnable = (stoi(valuemap[PowderEstimateCfg::FIELD_AUTO_SUPPLY_ENABLE])>0?true:false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_AUTO_SUPPLY_ENABLE.c_str(), cfg.m_AutoSupplyEnable?"1":"0");
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_AUTO_SUPPLY_TIMEOUT_MINUTE) != valuemap.end()) {
		cfg.m_AutoSupplyTimeoutMinute = stol(valuemap[PowderEstimateCfg::FIELD_AUTO_SUPPLY_TIMEOUT_MINUTE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_AUTO_SUPPLY_TIMEOUT_MINUTE.c_str(), to_string(cfg.m_AutoSupplyTimeoutMinute).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_START_SUPPLY_QTY) != valuemap.end()) {
		cfg.m_StartSupplyQty = stof(valuemap[PowderEstimateCfg::FIELD_START_SUPPLY_QTY]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_START_SUPPLY_QTY.c_str(), to_string(cfg.m_StartSupplyQty).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(PowderEstimateCfg::FIELD_STOP_SUPPLY_QTY) != valuemap.end()) {
		cfg.m_StopSupplyQty = stof(valuemap[PowderEstimateCfg::FIELD_STOP_SUPPLY_QTY]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), PowderEstimateCfg::FIELD_STOP_SUPPLY_QTY.c_str(), to_string(cfg.m_StopSupplyQty).c_str());
		needins.push_back(buffer);
	}

	for (size_t i = 0; i < cfg.m_PEVec.size(); i++) {
		cfg.m_TotalGrids += (cfg.m_PEVec[i]->m_SpaceGrid);
	}

	if (!needins.empty()) {
		SQLite::Transaction transaction(*m_pDB);
		for (size_t i = 0; i < needins.size(); ++i) {
			m_pDB->exec(needins[i]);
		}
		transaction.commit();
	}
}

void BaseConfigDao::FindRecoatCheckCfg(RecoatCheckCfg& ecfg)
{
	map<string, string> valuemap;
	FindValue(RecoatCheckCfg::CONFIG_NAME, valuemap);
	char buffer[512];
	string strtemp = "INSERT INTO %s(%s,%s,%s) VALUES('%s',";
	sprintf_s(buffer, sizeof(buffer), strtemp.c_str(),
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str(),
		BaseConfig::FIELD_CONFIG_VALUE.c_str(),
		RecoatCheckCfg::CONFIG_NAME.c_str()
	);
	string strsql = string(buffer) + "'%s','%s')";
	vector<string> needins;

	if (valuemap.find(RecoatCheckCfg::FIELD_MASK_TOP_LEFT_X) != valuemap.end()) {
		ecfg.m_MaskTopLeftX = stoi(valuemap[RecoatCheckCfg::FIELD_MASK_TOP_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_MASK_TOP_LEFT_X.c_str(), to_string(ecfg.m_MaskTopLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_MASK_TOP_LEFT_Y) != valuemap.end()) {
		ecfg.m_MaskTopLeftY = stoi(valuemap[RecoatCheckCfg::FIELD_MASK_TOP_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_MASK_TOP_LEFT_Y.c_str(), to_string(ecfg.m_MaskTopLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_MASK_TOP_RIGHT_X) != valuemap.end()) {
		ecfg.m_MaskTopRightX = stoi(valuemap[RecoatCheckCfg::FIELD_MASK_TOP_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_MASK_TOP_RIGHT_X.c_str(), to_string(ecfg.m_MaskTopRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_MASK_TOP_RIGHT_Y) != valuemap.end()) {
		ecfg.m_MaskTopRightY = stoi(valuemap[RecoatCheckCfg::FIELD_MASK_TOP_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_MASK_TOP_RIGHT_Y.c_str(), to_string(ecfg.m_MaskTopRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_MASK_BOTTOM_LEFT_X) != valuemap.end()) {
		ecfg.m_MaskBottomLeftX = stoi(valuemap[RecoatCheckCfg::FIELD_MASK_BOTTOM_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_MASK_BOTTOM_LEFT_X.c_str(), to_string(ecfg.m_MaskBottomLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_MASK_BOTTOM_LEFT_Y) != valuemap.end()) {
		ecfg.m_MaskBottomLeftY = stoi(valuemap[RecoatCheckCfg::FIELD_MASK_BOTTOM_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_MASK_BOTTOM_LEFT_Y.c_str(), to_string(ecfg.m_MaskBottomLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_MASK_BOTTOM_RIGHT_X) != valuemap.end()) {
		ecfg.m_MaskBottomRightX = stoi(valuemap[RecoatCheckCfg::FIELD_MASK_BOTTOM_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_MASK_BOTTOM_RIGHT_X.c_str(), to_string(ecfg.m_MaskBottomRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_MASK_BOTTOM_RIGHT_Y) != valuemap.end()) {
		ecfg.m_MaskBottomRightY = stoi(valuemap[RecoatCheckCfg::FIELD_MASK_BOTTOM_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_MASK_BOTTOM_RIGHT_Y.c_str(), to_string(ecfg.m_MaskBottomRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_TRANSFORM_TOP_LEFT_X) != valuemap.end()) {
		ecfg.m_TransformTopLeftX = stof(valuemap[RecoatCheckCfg::FIELD_TRANSFORM_TOP_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_TRANSFORM_TOP_LEFT_X.c_str(), to_string(ecfg.m_TransformTopLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_TRANSFORM_TOP_LEFT_Y) != valuemap.end()) {
		ecfg.m_TransformTopLeftY = stof(valuemap[RecoatCheckCfg::FIELD_TRANSFORM_TOP_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_TRANSFORM_TOP_LEFT_Y.c_str(), to_string(ecfg.m_TransformTopLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_TRANSFORM_TOP_RIGHT_X) != valuemap.end()) {
		ecfg.m_TransformTopRightX = stof(valuemap[RecoatCheckCfg::FIELD_TRANSFORM_TOP_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_TRANSFORM_TOP_RIGHT_X.c_str(), to_string(ecfg.m_TransformTopRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_TRANSFORM_TOP_RIGHT_Y) != valuemap.end()) {
		ecfg.m_TransformTopRightY = stof(valuemap[RecoatCheckCfg::FIELD_TRANSFORM_TOP_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_TRANSFORM_TOP_RIGHT_Y.c_str(), to_string(ecfg.m_TransformTopRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_LEFT_X) != valuemap.end()) {
		ecfg.m_TransformBottomLeftX = stof(valuemap[RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_LEFT_X.c_str(), to_string(ecfg.m_TransformBottomLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_LEFT_Y) != valuemap.end()) {
		ecfg.m_TransformBottomLeftY = stof(valuemap[RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_LEFT_Y.c_str(), to_string(ecfg.m_TransformBottomLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_RIGHT_X) != valuemap.end()) {
		ecfg.m_TransformBottomRightX = stof(valuemap[RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_RIGHT_X.c_str(), to_string(ecfg.m_TransformBottomRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_RIGHT_Y) != valuemap.end()) {
		ecfg.m_TransformBottomRightY = stof(valuemap[RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_TRANSFORM_BOTTOM_RIGHT_Y.c_str(), to_string(ecfg.m_TransformBottomRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_ISLAND_THRESHOLD) != valuemap.end()) {
		ecfg.m_PerIslandCntThreshold = stoi(valuemap[RecoatCheckCfg::FIELD_ISLAND_THRESHOLD]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_ISLAND_THRESHOLD.c_str(), to_string(ecfg.m_PerIslandCntThreshold).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_AREA_FACTOR) != valuemap.end()) {
		ecfg.m_AreaThresholdFactor = stof(valuemap[RecoatCheckCfg::FIELD_AREA_FACTOR]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_AREA_FACTOR.c_str(), to_string(ecfg.m_AreaThresholdFactor).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_LENGTH_FACTOR) != valuemap.end()) {
		ecfg.m_LengthThresholdFactor = stof(valuemap[RecoatCheckCfg::FIELD_LENGTH_FACTOR]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_LENGTH_FACTOR.c_str(), to_string(ecfg.m_LengthThresholdFactor).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_RETRY_TIMES) != valuemap.end()) {
		ecfg.m_RetryTimes = stoi(valuemap[RecoatCheckCfg::FIELD_RETRY_TIMES]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_RETRY_TIMES.c_str(), to_string(ecfg.m_RetryTimes).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_BINARY_THRESHOLD) != valuemap.end()) {
		ecfg.m_BinaryThreshold = stoi(valuemap[RecoatCheckCfg::FIELD_BINARY_THRESHOLD]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_BINARY_THRESHOLD.c_str(), to_string(ecfg.m_BinaryThreshold).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_ENABLE) != valuemap.end()) {
		ecfg.m_Enable = stoi(valuemap[RecoatCheckCfg::FIELD_ENABLE]) > 0;
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_ENABLE.c_str(), to_string(ecfg.m_Enable).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_CHECK_ON_POWDER_TEST) != valuemap.end()) {
		ecfg.m_CheckOnPowderTest = stoi(valuemap[RecoatCheckCfg::FIELD_CHECK_ON_POWDER_TEST]) > 0;
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_CHECK_ON_POWDER_TEST.c_str(), to_string(ecfg.m_CheckOnPowderTest).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_CHECK_TYPE) != valuemap.end()) {
		ecfg.m_CheckType = stoi(valuemap[RecoatCheckCfg::FIELD_CHECK_TYPE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_CHECK_TYPE.c_str(), to_string(ecfg.m_CheckType).c_str());
		needins.push_back(buffer);
	}


	if (valuemap.find(RecoatCheckCfg::FIELD_UNCOVER_PERCENTAGE) != valuemap.end()) {
		ecfg.m_UncoverPercentage = stof(valuemap[RecoatCheckCfg::FIELD_UNCOVER_PERCENTAGE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_UNCOVER_PERCENTAGE.c_str(), to_string(ecfg.m_UncoverPercentage).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_IS_UP_PART_NOT_LIGHT) != valuemap.end()) {
		ecfg.m_IsUpPartNotLight = (stoi(valuemap[RecoatCheckCfg::FIELD_IS_UP_PART_NOT_LIGHT]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_IS_UP_PART_NOT_LIGHT.c_str(), ecfg.m_IsUpPartNotLight ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_IMAGE_SCALE) != valuemap.end()) {
		ecfg.m_ImageScale = stoi(valuemap[RecoatCheckCfg::FIELD_IMAGE_SCALE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_IMAGE_SCALE.c_str(), to_string(ecfg.m_ImageScale).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(RecoatCheckCfg::FIELD_GRAY_OFFSET) != valuemap.end()) {
		ecfg.m_GrayOffset = stoi(valuemap[RecoatCheckCfg::FIELD_GRAY_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), RecoatCheckCfg::FIELD_GRAY_OFFSET.c_str(), to_string(ecfg.m_GrayOffset).c_str());
		needins.push_back(buffer);
	}

	if (!needins.empty()) {
		SQLite::Transaction transaction(*m_pDB);
		for (size_t i = 0; i < needins.size(); ++i) {
			m_pDB->exec(needins[i]);
		}
		transaction.commit();
	}
}

void BaseConfigDao::FindParamLimitCfg(ParamLimitCfg& cfg)
{
	map<string, string> valuemap;
	FindValue(ParamLimitCfg::CONFIG_NAME, valuemap);
	char buffer[512];
	string strtemp = "INSERT INTO %s(%s,%s,%s) VALUES('%s',";
	sprintf_s(buffer, sizeof(buffer), strtemp.c_str(),
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str(),
		BaseConfig::FIELD_CONFIG_VALUE.c_str(),
		ParamLimitCfg::CONFIG_NAME.c_str()
	);
	string strsql = string(buffer) + "'%s','%s')";
	vector<string> needins;

	if (valuemap.find(ParamLimitCfg::FIELD_SCAN_SPEED_MIN) != valuemap.end()) {
		cfg.m_ScanSpeedMin = stof(valuemap[ParamLimitCfg::FIELD_SCAN_SPEED_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SCAN_SPEED_MIN.c_str(), to_string(cfg.m_ScanSpeedMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SCAN_SPEED_MAX) != valuemap.end()) {
		cfg.m_ScanSpeedMax = stof(valuemap[ParamLimitCfg::FIELD_SCAN_SPEED_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SCAN_SPEED_MAX.c_str(), to_string(cfg.m_ScanSpeedMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SCAN_POWER_MIN) != valuemap.end()) {
		cfg.m_ScanPowerMin= stof(valuemap[ParamLimitCfg::FIELD_SCAN_POWER_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SCAN_POWER_MIN.c_str(), to_string(cfg.m_ScanPowerMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SCAN_POWER_MAX) != valuemap.end()) {
		cfg.m_ScanPowerMax = stof(valuemap[ParamLimitCfg::FIELD_SCAN_POWER_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SCAN_POWER_MAX.c_str(), to_string(cfg.m_ScanPowerMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SCAN_DIAMETER_MIN) != valuemap.end()) {
		cfg.m_ScanDiameterMin = stof(valuemap[ParamLimitCfg::FIELD_SCAN_DIAMETER_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SCAN_DIAMETER_MIN.c_str(), to_string(cfg.m_ScanDiameterMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SCAN_DIAMETER_MAX) != valuemap.end()) {
		cfg.m_ScanDiameterMax = stof(valuemap[ParamLimitCfg::FIELD_SCAN_DIAMETER_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SCAN_DIAMETER_MAX.c_str(), to_string(cfg.m_ScanDiameterMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LAYER_THICKNESS_MIN) != valuemap.end()) {
		cfg.m_LayerThicknessMin = stoul(valuemap[ParamLimitCfg::FIELD_LAYER_THICKNESS_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LAYER_THICKNESS_MIN.c_str(), to_string(cfg.m_LayerThicknessMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LAYER_THICKNESS_MAX) != valuemap.end()) {
		cfg.m_LayerThicknessMax = stoul(valuemap[ParamLimitCfg::FIELD_LAYER_THICKNESS_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LAYER_THICKNESS_MAX.c_str(), to_string(cfg.m_LayerThicknessMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_POWDER_MIN) != valuemap.end()) {
		cfg.m_SupplyPowderMin = stoul(valuemap[ParamLimitCfg::FIELD_SUPPLY_POWDER_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_POWDER_MIN.c_str(), to_string(cfg.m_SupplyPowderMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_POWDER_MAX) != valuemap.end()) {
		cfg.m_SupplyPowderMax = stoul(valuemap[ParamLimitCfg::FIELD_SUPPLY_POWDER_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_POWDER_MAX.c_str(), to_string(cfg.m_SupplyPowderMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SCAN_TIMES_MIN) != valuemap.end()) {
		cfg.m_ScanTimesMin = stoi(valuemap[ParamLimitCfg::FIELD_SCAN_TIMES_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SCAN_TIMES_MIN.c_str(), to_string(cfg.m_ScanTimesMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SCAN_TIMES_MAX) != valuemap.end()) {
		cfg.m_ScanTimesMax = stoi(valuemap[ParamLimitCfg::FIELD_SCAN_TIMES_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SCAN_TIMES_MAX.c_str(), to_string(cfg.m_ScanTimesMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_MOLD_SPEED_MIN) != valuemap.end()) {
		cfg.m_MoldSpeedMin = stof(valuemap[ParamLimitCfg::FIELD_MOLD_SPEED_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_MOLD_SPEED_MIN.c_str(), to_string(cfg.m_MoldSpeedMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_MOLD_SPEED_MAX) != valuemap.end()) {
		cfg.m_MoldSpeedMax = stof(valuemap[ParamLimitCfg::FIELD_MOLD_SPEED_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_MOLD_SPEED_MAX.c_str(), to_string(cfg.m_MoldSpeedMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_MOLD_ACC_MIN) != valuemap.end()) {
		cfg.m_MoldAccMin = stof(valuemap[ParamLimitCfg::FIELD_MOLD_ACC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_MOLD_ACC_MIN.c_str(), to_string(cfg.m_MoldAccMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_MOLD_ACC_MAX) != valuemap.end()) {
		cfg.m_MoldAccMax = stof(valuemap[ParamLimitCfg::FIELD_MOLD_ACC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_MOLD_ACC_MAX.c_str(), to_string(cfg.m_MoldAccMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_MOLD_DEC_MIN) != valuemap.end()) {
		cfg.m_MoldDecMin = stof(valuemap[ParamLimitCfg::FIELD_MOLD_DEC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_MOLD_DEC_MIN.c_str(), to_string(cfg.m_MoldDecMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_MOLD_DEC_MAX) != valuemap.end()) {
		cfg.m_MoldDecMax = stof(valuemap[ParamLimitCfg::FIELD_MOLD_DEC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_MOLD_DEC_MAX.c_str(), to_string(cfg.m_MoldDecMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_MOLD_POINT_STEP_MIN) != valuemap.end()) {
		cfg.m_MoldPointStepMin = stof(valuemap[ParamLimitCfg::FIELD_MOLD_POINT_STEP_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_MOLD_POINT_STEP_MIN.c_str(), to_string(cfg.m_MoldPointStepMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_MOLD_POINT_STEP_MAX) != valuemap.end()) {
		cfg.m_MoldPointStepMax = stof(valuemap[ParamLimitCfg::FIELD_MOLD_POINT_STEP_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_MOLD_POINT_STEP_MAX.c_str(), to_string(cfg.m_MoldPointStepMax).c_str());
		needins.push_back(buffer);
	}


	if (valuemap.find(ParamLimitCfg::FIELD_LOAD_SPEED_MIN) != valuemap.end()) {
		cfg.m_LoadSpeedMin = stof(valuemap[ParamLimitCfg::FIELD_LOAD_SPEED_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LOAD_SPEED_MIN.c_str(), to_string(cfg.m_LoadSpeedMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LOAD_SPEED_MAX) != valuemap.end()) {
		cfg.m_LoadSpeedMax = stof(valuemap[ParamLimitCfg::FIELD_LOAD_SPEED_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LOAD_SPEED_MAX.c_str(), to_string(cfg.m_LoadSpeedMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LOAD_ACC_MIN) != valuemap.end()) {
		cfg.m_LoadAccMin = stof(valuemap[ParamLimitCfg::FIELD_LOAD_ACC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LOAD_ACC_MIN.c_str(), to_string(cfg.m_LoadAccMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LOAD_ACC_MAX) != valuemap.end()) {
		cfg.m_LoadAccMax = stof(valuemap[ParamLimitCfg::FIELD_LOAD_ACC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LOAD_ACC_MAX.c_str(), to_string(cfg.m_LoadAccMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LOAD_DEC_MIN) != valuemap.end()) {
		cfg.m_LoadDecMin = stof(valuemap[ParamLimitCfg::FIELD_LOAD_DEC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LOAD_DEC_MIN.c_str(), to_string(cfg.m_LoadDecMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LOAD_DEC_MAX) != valuemap.end()) {
		cfg.m_LoadDecMax = stof(valuemap[ParamLimitCfg::FIELD_LOAD_DEC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LOAD_DEC_MAX.c_str(), to_string(cfg.m_LoadDecMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LOAD_POINT_STEP_MIN) != valuemap.end()) {
		cfg.m_LoadPointStepMin = stof(valuemap[ParamLimitCfg::FIELD_LOAD_POINT_STEP_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LOAD_POINT_STEP_MIN.c_str(), to_string(cfg.m_LoadPointStepMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_LOAD_POINT_STEP_MAX) != valuemap.end()) {
		cfg.m_LoadPointStepMax = stof(valuemap[ParamLimitCfg::FIELD_LOAD_POINT_STEP_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_LOAD_POINT_STEP_MAX.c_str(), to_string(cfg.m_LoadPointStepMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CLEAN_SPEED_MIN) != valuemap.end()) {
		cfg.m_CleanSpeedMin = stof(valuemap[ParamLimitCfg::FIELD_CLEAN_SPEED_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CLEAN_SPEED_MIN.c_str(), to_string(cfg.m_CleanSpeedMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CLEAN_SPEED_MAX) != valuemap.end()) {
		cfg.m_CleanSpeedMax = stof(valuemap[ParamLimitCfg::FIELD_CLEAN_SPEED_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CLEAN_SPEED_MAX.c_str(), to_string(cfg.m_CleanSpeedMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CLEAN_ACC_MIN) != valuemap.end()) {
		cfg.m_CleanAccMin = stof(valuemap[ParamLimitCfg::FIELD_CLEAN_ACC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CLEAN_ACC_MIN.c_str(), to_string(cfg.m_CleanAccMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CLEAN_ACC_MAX) != valuemap.end()) {
		cfg.m_CleanAccMax = stof(valuemap[ParamLimitCfg::FIELD_CLEAN_ACC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CLEAN_ACC_MAX.c_str(), to_string(cfg.m_CleanAccMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CLEAN_DEC_MIN) != valuemap.end()) {
		cfg.m_CleanDecMin = stof(valuemap[ParamLimitCfg::FIELD_CLEAN_DEC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CLEAN_DEC_MIN.c_str(), to_string(cfg.m_CleanDecMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CLEAN_DEC_MAX) != valuemap.end()) {
		cfg.m_CleanDecMax = stof(valuemap[ParamLimitCfg::FIELD_CLEAN_DEC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CLEAN_DEC_MAX.c_str(), to_string(cfg.m_CleanDecMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CLEAN_POINT_STEP_MIN) != valuemap.end()) {
		cfg.m_CleanPointStepMin = stof(valuemap[ParamLimitCfg::FIELD_CLEAN_POINT_STEP_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CLEAN_POINT_STEP_MIN.c_str(), to_string(cfg.m_CleanPointStepMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CLEAN_POINT_STEP_MAX) != valuemap.end()) {
		cfg.m_CleanPointStepMax = stof(valuemap[ParamLimitCfg::FIELD_CLEAN_POINT_STEP_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CLEAN_POINT_STEP_MAX.c_str(), to_string(cfg.m_CleanPointStepMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_ARM_SPEED_MIN) != valuemap.end()) {
		cfg.m_ArmSpeedMin = stof(valuemap[ParamLimitCfg::FIELD_ARM_SPEED_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_ARM_SPEED_MIN.c_str(), to_string(cfg.m_ArmSpeedMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_ARM_SPEED_MAX) != valuemap.end()) {
		cfg.m_ArmSpeedMax = stof(valuemap[ParamLimitCfg::FIELD_ARM_SPEED_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_ARM_SPEED_MAX.c_str(), to_string(cfg.m_ArmSpeedMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_ARM_ACC_MIN) != valuemap.end()) {
		cfg.m_ArmAccMin = stof(valuemap[ParamLimitCfg::FIELD_ARM_ACC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_ARM_ACC_MIN.c_str(), to_string(cfg.m_ArmAccMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_ARM_ACC_MAX) != valuemap.end()) {
		cfg.m_ArmAccMax = stof(valuemap[ParamLimitCfg::FIELD_ARM_ACC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_ARM_ACC_MAX.c_str(), to_string(cfg.m_ArmAccMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_ARM_DEC_MIN) != valuemap.end()) {
		cfg.m_ArmDecMin = stof(valuemap[ParamLimitCfg::FIELD_ARM_DEC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_ARM_DEC_MIN.c_str(), to_string(cfg.m_ArmDecMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_ARM_DEC_MAX) != valuemap.end()) {
		cfg.m_ArmDecMax = stof(valuemap[ParamLimitCfg::FIELD_ARM_DEC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_ARM_DEC_MAX.c_str(), to_string(cfg.m_ArmDecMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_ARM_POINT_STEP_MIN) != valuemap.end()) {
		cfg.m_ArmPointStepMin = stof(valuemap[ParamLimitCfg::FIELD_ARM_POINT_STEP_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_ARM_POINT_STEP_MIN.c_str(), to_string(cfg.m_ArmPointStepMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_ARM_POINT_STEP_MAX) != valuemap.end()) {
		cfg.m_ArmPointStepMax = stof(valuemap[ParamLimitCfg::FIELD_ARM_POINT_STEP_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_ARM_POINT_STEP_MAX.c_str(), to_string(cfg.m_ArmPointStepMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_SPEED_MIN) != valuemap.end()) {
		cfg.m_SupplySpeedMin = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_SPEED_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_SPEED_MIN.c_str(), to_string(cfg.m_SupplySpeedMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_SPEED_MAX) != valuemap.end()) {
		cfg.m_SupplySpeedMax = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_SPEED_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_SPEED_MAX.c_str(), to_string(cfg.m_SupplySpeedMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_ACC_MIN) != valuemap.end()) {
		cfg.m_SupplyAccMin = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_ACC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_ACC_MIN.c_str(), to_string(cfg.m_SupplyAccMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_ACC_MAX) != valuemap.end()) {
		cfg.m_SupplyAccMax = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_ACC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_ACC_MAX.c_str(), to_string(cfg.m_SupplyAccMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_DEC_MIN) != valuemap.end()) {
		cfg.m_SupplyDecMin = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_DEC_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_DEC_MIN.c_str(), to_string(cfg.m_SupplyDecMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_DEC_MAX) != valuemap.end()) {
		cfg.m_SupplyDecMax = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_DEC_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_DEC_MAX.c_str(), to_string(cfg.m_SupplyDecMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_POINT_STEP_MIN) != valuemap.end()) {
		cfg.m_SupplyPointStepMin = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_POINT_STEP_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_POINT_STEP_MIN.c_str(), to_string(cfg.m_SupplyPointStepMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_POINT_STEP_MAX) != valuemap.end()) {
		cfg.m_SupplyPointStepMax = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_POINT_STEP_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_POINT_STEP_MAX.c_str(), to_string(cfg.m_SupplyPointStepMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_FIX_GAP_MIN) != valuemap.end()) {
		cfg.m_FixGapMin = stof(valuemap[ParamLimitCfg::FIELD_FIX_GAP_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_FIX_GAP_MIN.c_str(), to_string(cfg.m_FixGapMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_FIX_GAP_MAX) != valuemap.end()) {
		cfg.m_FixGapMax = stof(valuemap[ParamLimitCfg::FIELD_FIX_GAP_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_FIX_GAP_MAX.c_str(), to_string(cfg.m_FixGapMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_WAIT_TIME_MIN) != valuemap.end()) {
		cfg.m_SupplyWaitTimeMin = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_WAIT_TIME_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_WAIT_TIME_MIN.c_str(), to_string(cfg.m_SupplyWaitTimeMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_WAIT_TIME_MAX) != valuemap.end()) {
		cfg.m_SupplyWaitTimeMax = stof(valuemap[ParamLimitCfg::FIELD_SUPPLY_WAIT_TIME_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_WAIT_TIME_MAX.c_str(), to_string(cfg.m_SupplyWaitTimeMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_COUNT_MIN) != valuemap.end()) {
		cfg.m_SupplyCountMin = stoi(valuemap[ParamLimitCfg::FIELD_SUPPLY_COUNT_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_COUNT_MIN.c_str(), to_string(cfg.m_SupplyCountMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_SUPPLY_COUNT_MAX) != valuemap.end()) {
		cfg.m_SupplyCountMax = stoi(valuemap[ParamLimitCfg::FIELD_SUPPLY_COUNT_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_SUPPLY_COUNT_MAX.c_str(), to_string(cfg.m_SupplyCountMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_COVER_DISTANCE_MIN) != valuemap.end()) {
		cfg.m_CoverDistanceMin = stof(valuemap[ParamLimitCfg::FIELD_COVER_DISTANCE_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_COVER_DISTANCE_MIN.c_str(), to_string(cfg.m_CoverDistanceMin).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_COVER_DISTANCE_MAX) != valuemap.end()) {
		cfg.m_CoverDistanceMax = stof(valuemap[ParamLimitCfg::FIELD_COVER_DISTANCE_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_COVER_DISTANCE_MAX.c_str(), to_string(cfg.m_CoverDistanceMax).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(ParamLimitCfg::FIELD_CTRL_LAYER_THICKNESS_MIN) != valuemap.end()) {
		cfg.m_CtrlLayerThicknessMin = stof(valuemap[ParamLimitCfg::FIELD_CTRL_LAYER_THICKNESS_MIN]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CTRL_LAYER_THICKNESS_MIN.c_str(), to_string(cfg.m_CtrlLayerThicknessMin).c_str());
		needins.push_back(buffer);
	}


	if (valuemap.find(ParamLimitCfg::FIELD_CTRL_LAYER_THICKNESS_MAX) != valuemap.end()) {
		cfg.m_CtrlLayerThicknessMax = stof(valuemap[ParamLimitCfg::FIELD_CTRL_LAYER_THICKNESS_MAX]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ParamLimitCfg::FIELD_CTRL_LAYER_THICKNESS_MAX.c_str(), to_string(cfg.m_CtrlLayerThicknessMax).c_str());
		needins.push_back(buffer);
	}


	if (!needins.empty()) {
		SQLite::Transaction transaction(*m_pDB);
		for (size_t i = 0; i < needins.size(); ++i) {
			m_pDB->exec(needins[i]);
		}
		transaction.commit();
	}
}

void BaseConfigDao::FindCameraCalibrationCfg(CameraCalibrationCfg& cfg)
{
	map<string, string> valuemap;
	FindValue(CameraCalibrationCfg::CONFIG_NAME, valuemap);
	char buffer[512];
	string strtemp = "INSERT INTO %s(%s,%s,%s) VALUES('%s',";
	sprintf_s(buffer, sizeof(buffer), strtemp.c_str(),
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_CODE.c_str(),
		BaseConfig::FIELD_CONFIG_VALUE.c_str(),
		CameraCalibrationCfg::CONFIG_NAME.c_str()
	);
	string strsql = string(buffer) + "'%s','%s')";
	vector<string> needins;

	if (valuemap.find(CameraCalibrationCfg::FIELD_HAD_CALIBRATION) != valuemap.end()) {
		cfg.m_HadCalibration = stoi(valuemap[CameraCalibrationCfg::FIELD_HAD_CALIBRATION]) > 0 ? true : false;
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_HAD_CALIBRATION.c_str(), cfg.m_HadCalibration ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CALIBRATION_H_POINTS) != valuemap.end()) {
		cfg.m_CalibrationHPoints = stoul(valuemap[CameraCalibrationCfg::FIELD_CALIBRATION_H_POINTS]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CALIBRATION_H_POINTS.c_str(), to_string(cfg.m_CalibrationHPoints).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CALIBRATION_V_POINTS) != valuemap.end()) {
		cfg.m_CalibrationVPoints = stoul(valuemap[CameraCalibrationCfg::FIELD_CALIBRATION_V_POINTS]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CALIBRATION_V_POINTS.c_str(), to_string(cfg.m_CalibrationVPoints).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CALIBRATION_GRID_H_SIZE) != valuemap.end()) {
		cfg.m_CalibrationGridHSize = stoul(valuemap[CameraCalibrationCfg::FIELD_CALIBRATION_GRID_H_SIZE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CALIBRATION_GRID_H_SIZE.c_str(), to_string(cfg.m_CalibrationGridHSize).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CALIBRATION_GRID_V_SIZE) != valuemap.end()) {
		cfg.m_CalibrationGridVSize = stoul(valuemap[CameraCalibrationCfg::FIELD_CALIBRATION_GRID_V_SIZE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CALIBRATION_GRID_V_SIZE.c_str(), to_string(cfg.m_CalibrationGridVSize).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_00) != valuemap.end()) {
		cfg.m_CameraMatrix00 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_00]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_00.c_str(), to_string(cfg.m_CameraMatrix00).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_01) != valuemap.end()) {
		cfg.m_CameraMatrix01 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_01]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_01.c_str(), to_string(cfg.m_CameraMatrix01).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_02) != valuemap.end()) {
		cfg.m_CameraMatrix02 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_02]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_02.c_str(), to_string(cfg.m_CameraMatrix02).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_10) != valuemap.end()) {
		cfg.m_CameraMatrix10 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_10]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_10.c_str(), to_string(cfg.m_CameraMatrix10).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_11) != valuemap.end()) {
		cfg.m_CameraMatrix11 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_11]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_11.c_str(), to_string(cfg.m_CameraMatrix11).c_str());
		needins.push_back(buffer);
	}
	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_12) != valuemap.end()) {
		cfg.m_CameraMatrix12 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_12]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_12.c_str(), to_string(cfg.m_CameraMatrix12).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_20) != valuemap.end()) {
		cfg.m_CameraMatrix20 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_20]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_20.c_str(), to_string(cfg.m_CameraMatrix20).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_21) != valuemap.end()) {
		cfg.m_CameraMatrix21 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_21]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_21.c_str(), to_string(cfg.m_CameraMatrix21).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_CAMERA_MATRIX_22) != valuemap.end()) {
		cfg.m_CameraMatrix22 = stod(valuemap[CameraCalibrationCfg::FIELD_CAMERA_MATRIX_22]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_CAMERA_MATRIX_22.c_str(), to_string(cfg.m_CameraMatrix22).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_DIST_COEFFS_0) != valuemap.end()) {
		cfg.m_DistCoeffs0 = stod(valuemap[CameraCalibrationCfg::FIELD_DIST_COEFFS_0]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_DIST_COEFFS_0.c_str(), to_string(cfg.m_DistCoeffs0).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_DIST_COEFFS_1) != valuemap.end()) {
		cfg.m_DistCoeffs1 = stod(valuemap[CameraCalibrationCfg::FIELD_DIST_COEFFS_1]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_DIST_COEFFS_1.c_str(), to_string(cfg.m_DistCoeffs1).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_DIST_COEFFS_2) != valuemap.end()) {
		cfg.m_DistCoeffs2 = stod(valuemap[CameraCalibrationCfg::FIELD_DIST_COEFFS_2]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_DIST_COEFFS_2.c_str(), to_string(cfg.m_DistCoeffs2).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_DIST_COEFFS_3) != valuemap.end()) {
		cfg.m_DistCoeffs3 = stod(valuemap[CameraCalibrationCfg::FIELD_DIST_COEFFS_3]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_DIST_COEFFS_3.c_str(), to_string(cfg.m_DistCoeffs3).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_DIST_COEFFS_4) != valuemap.end()) {
		cfg.m_DistCoeffs4 = stod(valuemap[CameraCalibrationCfg::FIELD_DIST_COEFFS_4]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_DIST_COEFFS_4.c_str(), to_string(cfg.m_DistCoeffs4).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_FITTING_MAG_X) != valuemap.end()) {
		cfg.m_FittingMagX = stoul(valuemap[CameraCalibrationCfg::FIELD_FITTING_MAG_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_FITTING_MAG_X.c_str(), to_string(cfg.m_FittingMagX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_IMAGE_TOP_LEFT_X) != valuemap.end()) {
		cfg.m_ImageTopLeftX = stoi(valuemap[CameraCalibrationCfg::FIELD_IMAGE_TOP_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_IMAGE_TOP_LEFT_X.c_str(), to_string(cfg.m_ImageTopLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_IMAGE_TOP_LEFT_Y) != valuemap.end()) {
		cfg.m_ImageTopLeftY = stoi(valuemap[CameraCalibrationCfg::FIELD_IMAGE_TOP_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_IMAGE_TOP_LEFT_Y.c_str(), to_string(cfg.m_ImageTopLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_IMAGE_TOP_RIGHT_X) != valuemap.end()) {
		cfg.m_ImageTopRightX = stoi(valuemap[CameraCalibrationCfg::FIELD_IMAGE_TOP_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_IMAGE_TOP_RIGHT_X.c_str(), to_string(cfg.m_ImageTopRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_IMAGE_TOP_RIGHT_Y) != valuemap.end()) {
		cfg.m_ImageTopRightY = stoi(valuemap[CameraCalibrationCfg::FIELD_IMAGE_TOP_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_IMAGE_TOP_RIGHT_Y.c_str(), to_string(cfg.m_ImageTopRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_LEFT_X) != valuemap.end()) {
		cfg.m_ImageBottomLeftX = stoi(valuemap[CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_LEFT_X.c_str(), to_string(cfg.m_ImageBottomLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_LEFT_Y) != valuemap.end()) {
		cfg.m_ImageBottomLeftY = stoi(valuemap[CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_LEFT_Y.c_str(), to_string(cfg.m_ImageBottomLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_RIGHT_X) != valuemap.end()) {
		cfg.m_ImageBottomRightX = stoi(valuemap[CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_RIGHT_X.c_str(), to_string(cfg.m_ImageBottomRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_RIGHT_Y) != valuemap.end()) {
		cfg.m_ImageBottomRightY = stoi(valuemap[CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_IMAGE_BOTTOM_RIGHT_Y.c_str(), to_string(cfg.m_ImageBottomRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_PLATFORM_TOP_LEFT_X) != valuemap.end()) {
		cfg.m_PlatformTopLeftX = stoi(valuemap[CameraCalibrationCfg::FIELD_PLATFORM_TOP_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_PLATFORM_TOP_LEFT_X.c_str(), to_string(cfg.m_PlatformTopLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_PLATFORM_TOP_LEFT_Y) != valuemap.end()) {
		cfg.m_PlatformTopLeftY = stoi(valuemap[CameraCalibrationCfg::FIELD_PLATFORM_TOP_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_PLATFORM_TOP_LEFT_Y.c_str(), to_string(cfg.m_PlatformTopLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_PLATFORM_TOP_RIGHT_X) != valuemap.end()) {
		cfg.m_PlatformTopRightX = stoi(valuemap[CameraCalibrationCfg::FIELD_PLATFORM_TOP_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_PLATFORM_TOP_RIGHT_X.c_str(), to_string(cfg.m_PlatformTopRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_PLATFORM_TOP_RIGHT_Y) != valuemap.end()) {
		cfg.m_PlatformTopRightY = stoi(valuemap[CameraCalibrationCfg::FIELD_PLATFORM_TOP_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_PLATFORM_TOP_RIGHT_Y.c_str(), to_string(cfg.m_PlatformTopRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_LEFT_X) != valuemap.end()) {
		cfg.m_PlatformBottomLeftX = stoi(valuemap[CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_LEFT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_LEFT_X.c_str(), to_string(cfg.m_PlatformBottomLeftX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_LEFT_Y) != valuemap.end()) {
		cfg.m_PlatformBottomLeftY = stoi(valuemap[CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_LEFT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_LEFT_Y.c_str(), to_string(cfg.m_PlatformBottomLeftY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_RIGHT_X) != valuemap.end()) {
		cfg.m_PlatformBottomRightX = stoi(valuemap[CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_RIGHT_X]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_RIGHT_X.c_str(), to_string(cfg.m_PlatformBottomRightX).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_RIGHT_Y) != valuemap.end()) {
		cfg.m_PlatformBottomRightY = stoi(valuemap[CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_RIGHT_Y]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_PLATFORM_BOTTOM_RIGHT_Y.c_str(), to_string(cfg.m_PlatformBottomRightY).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_BINARY_THRESHOLD_OFFSET) != valuemap.end()) {
		cfg.m_BinaryThresholdOffset = stoi(valuemap[CameraCalibrationCfg::FIELD_BINARY_THRESHOLD_OFFSET]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_BINARY_THRESHOLD_OFFSET.c_str(), to_string(cfg.m_BinaryThresholdOffset).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_GRAY_REF) != valuemap.end()) {
		cfg.m_GrayRef = stoi(valuemap[CameraCalibrationCfg::FIELD_GRAY_REF]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_GRAY_REF.c_str(), to_string(cfg.m_GrayRef).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_MAGNIFY_SCALE) != valuemap.end()) {
		cfg.m_MagnifyScale = stoul(valuemap[CameraCalibrationCfg::FIELD_MAGNIFY_SCALE]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_MAGNIFY_SCALE.c_str(), to_string(cfg.m_MagnifyScale).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_MATCH_RATIO) != valuemap.end()) {
		cfg.m_MatchRatio = stof(valuemap[CameraCalibrationCfg::FIELD_MATCH_RATIO]);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_MATCH_RATIO.c_str(), to_string(cfg.m_MatchRatio).c_str());
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_BLACK_FACE) != valuemap.end()) {
		cfg.m_BlackFace = (stoi(valuemap[CameraCalibrationCfg::FIELD_BLACK_FACE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_BLACK_FACE.c_str(), cfg.m_BlackFace ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_SHOW_BIN_IMAGE) != valuemap.end()) {
		cfg.m_ShowBinImage = (stoi(valuemap[CameraCalibrationCfg::FIELD_SHOW_BIN_IMAGE]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_SHOW_BIN_IMAGE.c_str(), cfg.m_ShowBinImage ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_SHOW_CORNERS) != valuemap.end()) {
		cfg.m_ShowCorners = (stoi(valuemap[CameraCalibrationCfg::FIELD_SHOW_CORNERS]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_SHOW_CORNERS.c_str(), cfg.m_ShowCorners ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_SHOW_ASSIST) != valuemap.end()) {
		cfg.m_ShowAssist = (stoi(valuemap[CameraCalibrationCfg::FIELD_SHOW_ASSIST]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_SHOW_ASSIST.c_str(), cfg.m_ShowAssist ? "1" : "0");
		needins.push_back(buffer);
	}

	if (valuemap.find(CameraCalibrationCfg::FIELD_COVER_IMAGE_JOIN) != valuemap.end()) {
		cfg.m_CoverImageJoin = (stoi(valuemap[CameraCalibrationCfg::FIELD_COVER_IMAGE_JOIN]) > 0 ? true : false);
	}
	else {
		sprintf_s(buffer, sizeof(buffer), strsql.c_str(), CameraCalibrationCfg::FIELD_COVER_IMAGE_JOIN.c_str(), cfg.m_CoverImageJoin ? "1" : "0");
		needins.push_back(buffer);
	}

	if (!needins.empty()) {
		SQLite::Transaction transaction(*m_pDB);
		for (size_t i = 0; i < needins.size(); ++i) {
			m_pDB->exec(needins[i]);
		}
		transaction.commit();
	}
}


void BaseConfigDao::SaveRecoatCheckCfg(RecoatCheckCfg& ccfg)
{
	vector<string> updates;
	ccfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		m_pDB->exec(updates[i]);
	}
}

void BaseConfigDao::SaveParamLimitCfg(ParamLimitCfg& fcfg)
{
	vector<string> updates;
	fcfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		m_pDB->exec(updates[i]);
	}
}

void BaseConfigDao::SaveCameraCalibrationCfg(CameraCalibrationCfg& cfg)
{
	vector<string> updates;
	cfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		m_pDB->exec(updates[i]);
	}
}

void BaseConfigDao::ExportRecoatCheckCfg(RecoatCheckCfg& rcfg, stringstream &sql)
{
	vector<string> updates;
	rcfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		sql << updates[i] << "\n";
	}
}


void BaseConfigDao::SaveExtCfg(ExtCfg& ecfg)
{
	vector<string> updates;
	ecfg.GetUpdateSql(updates);
	
	for (size_t i = 0; i < updates.size();++i) {
		m_pDB->exec(updates[i]);
	}
}


void BaseConfigDao::SaveRunCfg(RunCfg& rcfg)
{
	vector<string> updates;
	rcfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		m_pDB->exec(updates[i]);
	}
}

void BaseConfigDao::SaveFavoriteCfg(FavoriteCfg& fcfg)
{
	char buffer[512];
	sprintf_s(buffer, sizeof(buffer), "DELETE FROM %s WHERE %s = '%s'", 
		BaseConfig::TABLE_NAME.c_str(),
		BaseConfig::FIELD_CONFIG_NAME.c_str(),
		FavoriteCfg::CONFIG_NAME.c_str());
	m_pDB->exec(string(buffer));

	vector<string> updates;
	fcfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		m_pDB->exec(updates[i]);
	}
}

void BaseConfigDao::SavePowderEstimate(PowderEstimateCfg& rcfg)
{
	vector<string> updates;
	rcfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		m_pDB->exec(updates[i]);
	}
}

void BaseConfigDao::ExportExtCfg(ExtCfg& ecfg, stringstream &sql)
{
	vector<string> updates;
	ecfg.GetUpdateSql(updates);
	
	for (size_t i = 0; i < updates.size();++i) {
		sql << updates[i] <<"\n";
	}
}

void BaseConfigDao::ExportParamLimitCfg(ParamLimitCfg& ecfg, stringstream &sql)
{
	vector<string> updates;
	ecfg.GetUpdateSql(updates);

	for (size_t i = 0; i < updates.size(); ++i) {
		sql << updates[i] << "\n";
	}
}

void BaseConfigDao::ExportRunCfg(RunCfg& rcfg, stringstream &sql)
{
	vector<string> updates;
	rcfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		sql << updates[i] << "\n";
	}
}

void BaseConfigDao::ExportFavoriteCfg(FavoriteCfg& fcfg, stringstream &sql)
{
	vector<string> updates;
	fcfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		sql << updates[i] << "\n";
	}
}

void BaseConfigDao::ExportPowderEstimate(PowderEstimateCfg& rcfg, stringstream &sql)
{
	vector<string> updates;
	rcfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		sql << updates[i] << "\n";
	}
}


void BaseConfigDao::ExportCameraCalibrationCfg(CameraCalibrationCfg& cfg, stringstream &sql)
{
	vector<string> updates;
	cfg.GetUpdateSql(updates);
	for (size_t i = 0; i < updates.size(); ++i) {
		sql << updates[i] << "\n";
	}
}