/**
*@file         CalcRtdbTableOperate.cpp
*@brief        计算量相关内存表操作类
*@author       焦晓东
*@date         2018-11-13
*/

#include "CalcRtdbTableOperate.h"

using namespace std;
using namespace iot_public;
using namespace iot_service;
using namespace iot_dbms;

iot_service::CalcRtdbTableOperate::CalcRtdbTableOperate(const iot_public::SRunAppInfo &stRunAppInfo)
    :m_stRunAppInfo(stRunAppInfo)
{
}

iot_service::CalcRtdbTableOperate::~CalcRtdbTableOperate()
{
    if(m_objCalcDefTable.isOpen())
    {
        m_objCalcDefTable.close();
    }
    if(m_objCalcInParaTable.isOpen())
    {
        m_objCalcInParaTable.close();
    }
    if(m_objCalcOutParaTable.isOpen())
    {
        m_objCalcOutParaTable.close();
    }
}

//初始化内存表操作
int iot_service::CalcRtdbTableOperate::initialize()
{
    if(!m_objCalcDefTable.open(m_stRunAppInfo.nAppId,CN_TN_CalcDef.c_str()))
    {
        LOGERROR("打开内存库失败.AppId=[%d],TableName=[%s]",m_stRunAppInfo.nAppId,CN_TN_CalcDef.c_str());
        return iotFailed;
    }
    if(!m_objCalcInParaTable.open(m_stRunAppInfo.nAppId,CN_TN_CalcInPara.c_str()))
    {
        LOGERROR("打开内存库失败.AppId=[%d],TableName=[%s]",m_stRunAppInfo.nAppId,CN_TN_CalcInPara.c_str());
        return iotFailed;
    }
    if(!m_objCalcOutParaTable.open(m_stRunAppInfo.nAppId,CN_TN_CalcOutPara.c_str()))
    {
        LOGERROR("打开内存库失败.AppId=[%d],TableName=[%s]",m_stRunAppInfo.nAppId,CN_TN_CalcOutPara.c_str());
        return iotFailed;
    }
    return iotSuccess;
}

int iot_service::CalcRtdbTableOperate::getCalcDefAllRecord(std::vector<STableCalcDef> &vecCalcDef)
{
    CTableLockGuard tableLock(m_objCalcDefTable);  //加锁保护表
    if(m_objCalcDefTable.selectJustAll(vecCalcDef))
    {
        return iotSuccess;
    }
    else
    {
        LOGERROR("获取内存表[%s]记录失败.Error=[%s]",CN_TN_CalcDef.c_str(),m_objCalcDefTable.getErrorMsg().c_str());
        return iotFailed;
    }
}

int CalcRtdbTableOperate::getCalcDefByKey(const string tagName,STableCalcDef &sCalcDef)
{
    vector<string> vecCol;
    vector<CONDINFO> vecCond;
    CRdbPublic::addCondInfo(vecCond, CALC_DEF_COL_CALC_NAME, tagName);

    vector<STableCalcDef> vecRecord;

    CTableLockGuard tableLock(m_objCalcDefTable);    //< 加锁保护表
    if (!m_objCalcDefTable.selectAllVec(vecCond, vecRecord, vecCol))
    {
        LOGERROR("查询表[%s]记录[%s=%s]失败.", CN_TN_CalcDef.c_str(), CALC_DEF_COL_CALC_NAME, tagName.c_str());
        return iotFailed;
    }
    if (vecRecord.size() != 1)  //< 查询正确的话，只会返回一条信息
    {
        LOGERROR("查询表[%s]记录[%s=%s]失败,预期记录数[1],实际[%llu].", CN_TN_CalcDef.c_str(),
                 CALC_DEF_COL_CALC_NAME, tagName.c_str(), (unsigned long long)vecRecord.size());
        return iotFailed;
    }
    sCalcDef = vecRecord[0];
    return iotSuccess;
}

int iot_service::CalcRtdbTableOperate::getCalcParaAllRecord(std::vector<STableCalcInPara> &vecCalcPara)
{
    CTableLockGuard tableLock(m_objCalcInParaTable);  //加锁保护表
    if(m_objCalcInParaTable.selectJustAll(vecCalcPara))
    {
        return iotSuccess;
    }
    else
    {
        LOGERROR("获取内存表[%s]记录失败.Error=[%s]",CN_TN_CalcInPara.c_str(),m_objCalcInParaTable.getErrorMsg().c_str());
        return iotFailed;
    }
}
int iot_service::CalcRtdbTableOperate::getCalcParaAllRecord(std::vector<STableCalcOutPara> &vecCalcPara)
{
    CTableLockGuard tableLock(m_objCalcOutParaTable);  //加锁保护表
    if(m_objCalcOutParaTable.selectJustAll(vecCalcPara))
    {
        return iotSuccess;
    }
    else
    {
        LOGERROR("获取内存表[%s]记录失败.Error=[%s]",CN_TN_CalcOutPara.c_str(),m_objCalcOutParaTable.getErrorMsg().c_str());
        return iotFailed;
    }
}

int iot_service::CalcRtdbTableOperate::updateCalcInParaByKey(const STableCalcInParaKey &stCalcParaKey, int calcParaFlag)
{
    std::vector<RSQL_UPD_COLUMN> vecCol;
    CRdbPublic::addUpColumnInfo(vecCol,CALC_COL_FLAG, calcParaFlag);
    CTableLockGuard tableLock(m_objCalcInParaTable);
    if(!m_objCalcInParaTable.updateRecordByKey(&stCalcParaKey,vecCol))
    {
        LOGERROR("更新[%s]记录失败.TagName=[%s] id=[%d]", CN_TN_CalcInPara.c_str(),
                 stCalcParaKey.szTagName,stCalcParaKey.nCalcParaId);
        return iotFailed;
    }
    return iotSuccess;
}
int iot_service::CalcRtdbTableOperate::updateCalcOutParaByKey(const STableCalcOutParaKey &stCalcParaKey, int calcParaFlag)
{
    std::vector<RSQL_UPD_COLUMN> vecCol;
    CRdbPublic::addUpColumnInfo(vecCol,CALC_COL_FLAG, calcParaFlag);
    CTableLockGuard tableLock(m_objCalcOutParaTable);
    if(!m_objCalcOutParaTable.updateRecordByKey(&stCalcParaKey,vecCol))
    {
        LOGERROR("更新[%s]记录失败.TagName=[%s]", CN_TN_CalcOutPara.c_str(),
                 stCalcParaKey.szTagName);
        return iotFailed;
    }
    return iotSuccess;
}