#include "db_compare.h"
#include "db_manager_api/db_opt.h"
#include <QApplication>
#include <QSqlRecord>
#include "db_manager_api/kbdwaitprgdlg.h"
#include <QPushButton>
#include "pub_widget/MessageBox.h"
#include "db_manager_common.h"
#include "db_sysinfo_api/CDbSysInfo.h"

db_compare::db_compare(QWidget *parent){
    m_pDb_manager = parent;
    m_stationIdOrg = -1;
    m_subSystemIdOrg = -1;
    m_stationIdDst = -1;
    COMMONLOCATIONID = "LOCATION_ID";
    COMMONCHANNO = "CHAN_NO";
    COMMONRTUNO = "RTU_NO";
    COMMONFESRTUNO = "FES_RTU_NO";
    COMMONFESCHANNELPARA = "fes_channel_para";
    COMMONFESRTUPARA = "fes_rtu_para";
    COMMON61850KEY = "id";
    COMMONSCLFCDA = "scl_fcda";
    COMMONSCLDATASET = "scl_dataset";
    COMMONDATASETID = "DatasetID";
}

//********************************************      数据合并      ****************************************************
void db_compare::dataMerge(db_opt *pDbOpt_org, QString sDataBaseOrg, db_opt *pDbOpt_dst, QString sDataBaseDst, int subStationIdOrg, int subSystemIdOrg, int subStationIdDst )
{
    m_pSrcDbOpt = pDbOpt_org;
    m_pDstDbOpt = pDbOpt_dst;
    m_sDatabaseOrg = sDataBaseOrg;
    m_sDatabaseDst = sDataBaseDst;
    m_stationIdOrg = subStationIdOrg;
    m_subSystemIdOrg = subSystemIdOrg;
    m_stationIdDst = subStationIdDst;
    connect( m_pSrcDbOpt, SIGNAL(signalPercent(int)), this, SIGNAL(signalPercent(int) ) ,Qt::QueuedConnection);
    connect( m_pDstDbOpt, SIGNAL(signalPercent(int)), this, SIGNAL(signalPercent(int) ) ,Qt::QueuedConnection);
    tableMergeMap.clear();
    m_sclDatasetMap.clear();
    //pDbOpt_org->getTableName( sDataBaseOrg, m_listTable );
    //通过xml过滤历史表
    pDbOpt_org->filterTable( tableMergeMap );

    m_maxChanNo = getMaxId(pDbOpt_dst,m_sDatabaseDst,COMMONFESCHANNELPARA,COMMONCHANNO);
    m_maxRtuNo = getMaxId(pDbOpt_dst,m_sDatabaseDst,COMMONFESRTUPARA,COMMONRTUNO);
    mergeFunc();
    emit signalEnable();
}

void db_compare::mergeFunc()
{  
    m_pDstDbOpt->deleteAllTrigger_impl( m_sDatabaseDst, true);
    int mergeTables = 0;
    int nPercent = 0;
    int tableCount = tableMergeMap.size();
    emit signalPercent( nPercent );
    QMap<QString ,QString >::iterator it = tableMergeMap.begin();

    while (it != tableMergeMap.end())
    {
        mergeTables++;
        //此处只处理基础应用不含sub 和 非基础专业含sub（其余的过滤）,61850相关表当成基础表处理
        QString strSubSystem = "SUB_SYSTEM" ;
        QString tableName = it.key();
        bool hasSubSystem = hasColumn(m_pSrcDbOpt, m_sDatabaseOrg, tableName, strSubSystem );
        if(m_subSystemIdOrg == 1 && !hasSubSystem)
        {
            if(mergeTable( m_pSrcDbOpt, m_sDatabaseOrg, m_pDstDbOpt, m_sDatabaseDst, tableName, it.value() ) == -1)
            {
                break;
            }
        }
        else if(m_subSystemIdOrg != 1 && hasSubSystem)
        {
            if(mergeTable( m_pSrcDbOpt, m_sDatabaseOrg, m_pDstDbOpt, m_sDatabaseDst, tableName, it.value() ) == -1)
            {
                break;
            }
        }
        if( mergeTables * 100 / tableCount >= nPercent )
        {
            nPercent++;
            emit signalPercent( nPercent );
        }
        it++;
    }
    m_pDstDbOpt->recoverAllTrigger_impl( m_sDatabaseDst );
}

//********************************************      车站复用      ****************************************************
void db_compare::dataReuse(db_opt* pSrcDbOpt, QString sDataBaseOrg, db_opt* pDstDbOpt, QString sDataBaseDst,
                           QString sSrcSubStation, QString sDstSubStation, QStringList sSubSystemList )
{  
    m_pSrcDbOpt      = pSrcDbOpt;
    m_pDstDbOpt      = pDstDbOpt;
    m_sDatabaseOrg   = sDataBaseOrg;
    m_sDatabaseDst   = sDataBaseDst;
    m_sSubSystemList = sSubSystemList;

    //获取车站ID等信息
    //==============================================================================================================
    m_nSrcStaId     = getSubStationId(pSrcDbOpt, sDataBaseOrg, sSrcSubStation);
    m_nDstStaId     = getSubStationId(pDstDbOpt, sDataBaseDst, sDstSubStation);
    m_sSrcStaTagName= getSerachStr(pSrcDbOpt, m_sDatabaseOrg, m_nSrcStaId , "tag_name");
    m_sSrcStaDesc   = getSerachStr(pSrcDbOpt, m_sDatabaseOrg, m_nSrcStaId , "description");
    m_sDstStaTagName= getSerachStr(pDstDbOpt, m_sDatabaseDst, m_nDstStaId , "tag_name");
    m_sDstStaDesc   = getSerachStr(pDstDbOpt, m_sDatabaseDst, m_nDstStaId , "description");

    if( m_sDstStaTagName.isEmpty() || m_sDstStaDesc.isEmpty() )
    {
        emit mergeRes(tr("目标车站信息为空,请检查数据库"), 1);
        emit signalEnable();
        return;
    }
    connect( m_pSrcDbOpt, SIGNAL(signalPercent(int)), this, SIGNAL(signalPercent(int) ) ,Qt::QueuedConnection);
    connect( m_pDstDbOpt, SIGNAL(signalPercent(int)), this, SIGNAL(signalPercent(int) ) ,Qt::QueuedConnection);
    m_listTable.clear();

    pSrcDbOpt->getTableName( sDataBaseOrg, m_listTable ); //获取源库所有表
    //pSrcDbOpt->filterTable( m_listTable );//通过xml过滤历史表
    pSrcDbOpt->filterTable( tableMergeMap );//通过xml过滤skip的表


    //转换专业id类型
    //==============================================================================================================
    QVector<int> subSystemIdVec;
    for( int i = 0; i < sSubSystemList.count(); i++ )
    {
        int subSystemId = sSubSystemList[i].toInt();
        subSystemIdVec.append(subSystemId);
    }
    m_vecSubSystemFlag.clear();
    m_vecSubSystemFlag = getSubSystemFlagById( subSystemIdVec );

	reuseFunc();
    emit signalEnable();
}

void db_compare::reuseFunc()
{
    m_pDstDbOpt->deleteAllTrigger_impl( m_sDatabaseDst, true);

    int reuseTables = 0;
    int nPercent = 0;
    int tableCount = m_listTable.count();
    emit signalPercent( nPercent );
    for( int i = 0; i < m_listTable.count(); i++ )
    {
        reuseTables++;
        QString curTableName = m_listTable[i];

        // 该表用来同步，并不需要
        if(curTableName =="dbop_list")
        {
            continue;
        }
        QStringList keyList    = getMainKeys( m_pSrcDbOpt, m_sDatabaseOrg, curTableName );//主键
        QStringList uniqueList  = getUniques( m_pSrcDbOpt, m_sDatabaseOrg, curTableName );//UNIQUE

        //获取表信息
        //==============================================================================================================
        STableModeInfo  stTableModelInfo ;
        if(is61850Table( m_pSrcDbOpt, m_sDatabaseOrg, curTableName, COMMON61850KEY))
        {
            //< 61850 表当成基础表处理,直接拷贝
            stTableModelInfo.nSubsystemFlag = 1;
        }
        // 目标中找不到的表直接忽略
        else if(false == CDbSysInfo::getTableModeByTableName(curTableName.toStdString(),stTableModelInfo) )
        {
            emit mergeRes(tr("数据库表[%1]复用忽略.").arg(curTableName), 0);
            continue;
        } else if( tableMergeMap[curTableName] == "skip" )
        {
            continue;
        }

        //如果符合专业,则处理，首先看这个表是否需要复制
        //==============================================================================================================
        if((m_nSubSystemFlag & (stTableModelInfo.nSubsystemFlag)) >0 ) //该表存在复制专业数据
        {
            bool bRet = checkTable( curTableName );
            if(!bRet)
            {
                continue;
            }
            bool bSelectByLocation  = stTableModelInfo.bSelectByLocation ;
            bool bSelectBySubsystem = stTableModelInfo.bSelectBySubsystem ;

            QString sSqlSelect = "select * from " + m_sDatabaseOrg + "." + curTableName;
            if(bSelectByLocation)//区分车站
            {
                sSqlSelect += QString(" where location_id = ") + QString::number(m_nSrcStaId);
            }      

            //区分专业
            if(bSelectBySubsystem)
            {
                QString sSubSystems = getSubSystemSQLStr(m_sSubSystemList, bSelectByLocation);
                sSqlSelect += sSubSystems;
            }

            //emit mergeRes(sSqlSelect);
            QSqlQuery objSqlQuery;
            QString sSelectError = "";
            if ( m_pSrcDbOpt->executeSql( sSqlSelect, objSqlQuery, sSelectError ) == false )
            {
                emit mergeRes(tr("从源数据库查询记录查询失败：%1").arg(sSelectError), 1);
                emit mergeRes(tr("表 :%1, 复用失败!").arg(curTableName), 1);
				continue;
            }
            if(objSqlQuery.size() <=0 ){
                continue ;//没有记录，返回
            }

            bool bReuseRet = true;
            //qDebug() << "表" << curTableName << "*****************记录数：" << objSqlQuery.size();
            while( objSqlQuery.next() )
            {
                QSqlRecord objSqlRecord = objSqlQuery.record();
                changeRecord( objSqlRecord, curTableName, m_nDstStaId, bSelectByLocation );//修改信息
                if(keyList.size() > 0 || uniqueList.size() > 0)//判断主键冲突
                {
                    bool keysConflict = ifKeysConflict(m_pDstDbOpt, m_sDatabaseDst, curTableName, keyList, uniqueList, objSqlRecord);
                    if(keysConflict)//删除冲突的记录
                    {
                        deleteConflictRecord(m_pDstDbOpt, m_sDatabaseDst, curTableName, keyList, uniqueList, objSqlRecord);
                    }
                }
                bReuseRet = insertRecord(m_pDstDbOpt, m_sDatabaseDst, curTableName, objSqlRecord);//插入记录
            }
            objSqlQuery.clear();
            if(bReuseRet)
            {
                emit mergeRes(tr("表:%1, 复用成功!").arg(curTableName), 0);
            }
            else
            {
                emit mergeRes(tr("表:%1, 复用失败!").arg(curTableName), 1);
				continue;
            }
        }
        if( reuseTables * 100 / tableCount >= nPercent )
        {
            nPercent++;
            emit signalPercent( nPercent );
        }
    }
    //恢复所有触发器
    m_pDstDbOpt->recoverAllTrigger_impl( m_sDatabaseDst );
}

bool db_compare::checkTable( QString& sTableName )
{
    //判断表是否存在
    if(!ifExistTable(m_pDstDbOpt, m_sDatabaseDst, sTableName ) )
    {
        emit mergeRes(tr("目标数据库中不存在表：%1").arg(sTableName), 1);
        return false;
    }
    //判断源表与目标表字段是否一致
    int columnNum_org = getColumnNum(m_pSrcDbOpt, m_sDatabaseOrg, sTableName);
    int columnNum_dst = getColumnNum(m_pDstDbOpt, m_sDatabaseDst, sTableName);
    if(columnNum_org != columnNum_dst)
    {
        emit mergeRes(tr("源数据库与目标数据库的表：%1字段结构不一致！").arg(sTableName), 1);
        return false;
    }
    //判断源表与目标表主键是否一致
    QStringList keys_org = getMainKeys(m_pSrcDbOpt, m_sDatabaseOrg, sTableName);
    QStringList keys_dst = getMainKeys(m_pDstDbOpt, m_sDatabaseDst, sTableName);
    int key_num_org = keys_org.size();
    int key_num_dst = keys_dst.size();
    if(key_num_org != key_num_dst)
    {
        emit mergeRes(tr("源数据库与目标数据库的表：%1主键数量不一致！").arg(sTableName), 1);
        return  false;
    }
    else
    {
        bool keysColums = false;
        for(int j = 0; j < key_num_dst; j++)
        {
            if(QString::compare(keys_org[j], keys_dst[j]) != 0)
            {
                keysColums = true;
                break;
            }
        }
        if(keysColums)
        {
            emit mergeRes(tr("源数据库与目标数据库的表：%1主键字段不一致！").arg(sTableName), 1);
            return false;
        }
    }
	return true;
}

bool db_compare::hasColumn(db_opt *pDb_opt, QString &sDatabaseName, QString &sTableName, QString &sColumn)
{
    QString sql = QString("DESCRIBE %1.%2 %3;").arg(sDatabaseName).arg(sTableName).arg(sColumn);
    QSqlQuery result;
    QString error;
    if ( pDb_opt->executeSql( sql, result, error ) == false )
    {
        emit mergeRes(tr("判断表是否存在字段失败 %1").arg(error), 1);
        qDebug() << "判断表是否存在字段失败： sql == " << sql;
        return false;
    }
    
    if(result.size() == 0)
        return false;
    
    return true;
}

bool db_compare::is61850Table(db_opt *pDb_opt, QString &sDatabaseName, QString &sTableName, QString columnName)
{
    if(sTableName.startsWith("cfg_", Qt::CaseInsensitive))
    {
        return true;
    }
    if(sTableName.startsWith("scl_", Qt::CaseInsensitive))
    {
        return true;
    }
    return false;
}

//******************************************** 合并数据库表主函数  *****************************************************
int db_compare::mergeTable(db_opt* pSrcDbOpt, QString dataBaseOrg, db_opt* pDstDbOpt, QString dataBaseDst, QString sTableName, QString mergeWay )
{
    //判断如果为clear 则先删除此表所有数据，然后进行其他操作
    if(mergeWay.compare("clear") == 0)
    {
        clearAllDataByTableName(pDstDbOpt,dataBaseDst,sTableName);
    }
    //主键
    QStringList keyList = getMainKeys( pSrcDbOpt, dataBaseOrg, sTableName );
    //UNIQUE
    QStringList uniqueList = getUniques( pSrcDbOpt, dataBaseOrg, sTableName );
    QString sSqlSelect;
    m_hasLocationId = hasColumn(m_pSrcDbOpt, dataBaseOrg, sTableName, COMMONLOCATIONID);
    m_hasChanNo     = hasColumn(m_pSrcDbOpt, dataBaseOrg, sTableName, COMMONCHANNO);
    m_hasRtuNo      = hasColumn(m_pSrcDbOpt, dataBaseOrg, sTableName, COMMONRTUNO);
    m_hasFesRtuNo   = hasColumn(m_pSrcDbOpt, dataBaseOrg, sTableName, COMMONFESRTUNO);
    m_is61850Table  = is61850Table(m_pSrcDbOpt, dataBaseOrg, sTableName, COMMON61850KEY);

    if ( keyList.size() <= 0 ) //数据表没有主键
    {
        sSqlSelect = "select * from " + dataBaseOrg + "." + sTableName;
        QSqlQuery objSqlQuery;
        QString sSelectError = "";
        if ( pSrcDbOpt->executeSql( sSqlSelect, objSqlQuery, sSelectError ) == false )
        {
            emit mergeRes(tr("判断表是否没有主键查询失败：%1").arg(sSelectError), 1);
            return -1;
        }
        int size_Org = objSqlQuery.size();
        for(int i = 0; i < size_Org; i++)
        {
            objSqlQuery.seek(i);
            QSqlRecord objSqlRecord = objSqlQuery.record();
            if(!insertRecord(pDstDbOpt, dataBaseDst, sTableName, objSqlRecord))
            {
                return -1;
            }
        }
        objSqlQuery.clear();
    }
    else
    {
        //以第一个主键作为排序字符串
        QString orderStr = keyList.at(0);
        getSelectSqlString( dataBaseOrg, sTableName , orderStr, sSqlSelect );
        //查找源数据库
        QSqlQuery objSqlQuery;
        QString sSelectError = "";
        if ( pSrcDbOpt->executeSql( sSqlSelect, objSqlQuery, sSelectError ) == false )
        {
            qDebug() << "src db select error ============================ sql == " << sSqlSelect;
            emit mergeRes(tr("查找源数据库失败%1").arg(sSelectError), 1);
            return -1;
        }
        m_max61850Id = 0;
        if(m_is61850Table && ifExistColumn(m_pSrcDbOpt,dataBaseOrg,sTableName,COMMON61850KEY))
        {
            m_max61850Id = getMaxId(pDstDbOpt, dataBaseDst, sTableName, COMMON61850KEY);
        }

        while( objSqlQuery.next() )
        {
            QSqlRecord objSqlRecord = objSqlQuery.record();
            dealData(objSqlRecord,sTableName);
            //判断目标数据库中是否有主键冲突的记录
            if( keyList.size() > 0 || uniqueList.size() > 0 )
            {
                if(ifKeysConflict(pDstDbOpt, dataBaseDst, sTableName, keyList, uniqueList, objSqlRecord))
                {
                    //此处不再弹窗请求如何合并，所有的合并全部根据配置文件去决定
                    emit mergeRes(m_keysConflict,0);
                    if(mergeWay.compare("skip") == 0)
                    {
                        continue;
                    }
                    else if(mergeWay.compare("fill") == 0)
                    {
                        deleteConflictRecord(pDstDbOpt, dataBaseDst, sTableName, keyList, uniqueList, objSqlRecord);
                    }
                    else if(mergeWay.compare("clear") == 0)
                    {
                        emit mergeRes(tr("合并出错,%1").arg(m_keysConflict),1);
                        return -1;
                    }
                    else
                    {
                        emit mergeRes(tr("配置出错,跳过,%1").arg(m_keysConflict),1);
                        return -1;
                    }
                }
            }
            if(!insertRecord(pDstDbOpt, dataBaseDst, sTableName, objSqlRecord))
            {
                return -1;
            }
        }
        objSqlQuery.clear();
    }
    return 0;
}

void db_compare::clearAllDataByTableName(db_opt *pDstDbOpt, QString dataBaseDst, const QString &tableName)
{
    QString sqlDel = "delete from " + dataBaseDst + "." +tableName;
    QString error ;
    if( pDstDbOpt->executeSql(sqlDel, error ) == false )
    {
        emit mergeRes(tr("删除表：%1数据失败").arg(tableName) + error, 1);
        emit mergeRes(tr("SQL语句为：%1").arg(sqlDel), 1);
        qDebug() << sqlDel;
        //        emit mergeRes(sSql_Insert, 0);
    }
}

void db_compare::dealData(QSqlRecord &objSqlRecord, const QString &sTableName)
{
    if(m_hasLocationId)
    {
        objSqlRecord.setValue(COMMONLOCATIONID,m_stationIdDst);
    }
    if(m_hasChanNo)
    {
        //由于通道号默认从0开始，所以此处需要+1
        int searchChanno = objSqlRecord.value(COMMONCHANNO).toInt();
        searchChanno += m_maxChanNo;
        searchChanno += 1;
        objSqlRecord.setValue(COMMONCHANNO,searchChanno);
    }
    if(m_hasRtuNo)
    {
        //由于RTU号默认从0开始，所以此处需要+1
        int searchRtuno = objSqlRecord.value(COMMONRTUNO).toInt();
        searchRtuno += m_maxRtuNo;
        searchRtuno += 1;
        objSqlRecord.setValue(COMMONRTUNO,searchRtuno);
    }
    if(m_hasFesRtuNo)
    {
        //由于RTU号默认从0开始，所以此处需要+1
        int searchRtuno = objSqlRecord.value(COMMONFESRTUNO).toInt();
        searchRtuno += m_maxRtuNo;
        searchRtuno += 1;
        objSqlRecord.setValue(COMMONFESRTUNO,searchRtuno);
    }
    if(m_is61850Table)
    {
        //< cfg_dev_type_map无id
        if(m_max61850Id > 0)
        {
            int searchId = objSqlRecord.value(COMMON61850KEY).toInt();
            int newId = searchId + m_max61850Id;
            objSqlRecord.setValue(COMMON61850KEY,newId);
            if(sTableName == COMMONSCLDATASET)
            {
                m_sclDatasetMap.insert(searchId,newId);
            }
        }
        if(sTableName == COMMONSCLFCDA)
        {
            int datasetId = objSqlRecord.value(COMMONDATASETID).toInt();
            QMap<int,int>::iterator iter = m_sclDatasetMap.find(datasetId);
            if(iter != m_sclDatasetMap.end())
            {
                objSqlRecord.setValue(COMMONDATASETID,iter.value());
            }
        }
    }
}

void db_compare::getSelectSqlString( QString& sDatabaseName, QString& sTableName, QString& orderStr, QString& sSql )
{
    QString strLocatonId = "LOCATION_ID";
    QString strSubSystem = "SUB_SYSTEM" ;
    bool hasStation = hasColumn(m_pSrcDbOpt, sDatabaseName, sTableName, strLocatonId);
    bool hasSubSystem = hasColumn(m_pSrcDbOpt, sDatabaseName, sTableName, strSubSystem );
    
    if(hasStation && hasSubSystem)
    {
        sSql = "select * from " + sDatabaseName + "." + sTableName + " where location_id = " + QString::number(m_stationIdOrg) + " and  sub_system = " + QString::number(m_subSystemIdOrg)  \
                + " order by convert(" + orderStr + " using gbk) asc";
    }else if(hasStation && !hasSubSystem)
    {
        sSql = "select * from " + sDatabaseName + "." + sTableName + " where location_id = " + QString::number(m_stationIdOrg)  \
                + " order by convert(" + orderStr + " using gbk) asc";
    }else if(!hasStation && hasSubSystem)
    {
        sSql = "select * from " + sDatabaseName + "." + sTableName + " where sub_system = " + QString::number(m_subSystemIdOrg)  \
                + " order by convert(" + orderStr + " using gbk) asc";
    }else if(!hasStation && !hasSubSystem)
    {
        sSql = "select * from " + sDatabaseName + "." + sTableName  \
                + " order by convert(" + orderStr + " using gbk) asc";
    }
}

//******************************************** 插入记录函数 ***********************************************************
bool db_compare::insertRecord(db_opt* pDb_option, QString dataBase, QString table_name, QSqlRecord& record)
{
    //获取表的所有字段名,并添加对应的值
    QString sSql_allColumnName = "show columns from " + dataBase + "." + table_name;
    QSqlQuery query_allColumnName;
    QString sError_allColumnName = "";
    QString sSql_allColnameWithValue = "";
    //emit mergeRes(sSql_allColumnName);

    if( pDb_option->executeSql(sSql_allColumnName, query_allColumnName, sError_allColumnName) == false )
    {
        emit mergeRes( tr("获取表的所有字段名失败：%1").arg(sError_allColumnName), 1 );
        return false;
    }
    while(query_allColumnName.next())
    {
        QString columnName = query_allColumnName.value(0).toString();
        //转换数据类型
        QVariant vType = record.field(columnName).type();
        if(QString( vType.typeName() ) == "int")
        {
            sSql_allColnameWithValue += columnName + " = \'" + QString::number(record.value(columnName).toInt()) + "\',";
        }
        else if(QString( vType.typeName() ) == "uint")
        {
            sSql_allColnameWithValue += columnName + " = \'" + QString::number(record.value(columnName).toUInt()) + "\',";
        }
        else if(QString( vType.typeName() ) == "qlonglong")
        {
            sSql_allColnameWithValue += columnName + " = \'" + QString::number(record.value(columnName).toLongLong()) + "\',";
        }
        else if(QString( vType.typeName() ) == "qulonglong")
        {
            sSql_allColnameWithValue += columnName + " = \'" + QString::number(record.value(columnName).toULongLong()) + "\',";
        }
        else if(QString( vType.typeName() ) == "QString" || QString( vType.typeName() ) == "char")
        {
            if( columnName.compare("LB_DIR", Qt::CaseInsensitive) == 0
                    && record.value( columnName ).toString().endsWith("\\") )
                sSql_allColnameWithValue += columnName + " = \'" + record.value(columnName).toString().replace( "'", "\\'" ) + "\\',";
            else
                sSql_allColnameWithValue += columnName + " = \'" + record.value(columnName).toString().replace( "'", "\\'" ) + "\',";
        }
        else if(QString( vType.typeName() ) == "QDateTime")
        {
            sSql_allColnameWithValue += columnName + " = \'" + record.value(columnName).toDateTime().toString("yyyy-MM-dd hh:mm:ss") + "\',";
        }
        else if(QString( vType.typeName() ) == "double")
        {
            sSql_allColnameWithValue += columnName + " = \'" + record.value(columnName).toString() + "\',";
        }
        else
        {
            sSql_allColnameWithValue += columnName + " = \'" + record.value(columnName).toString() + "\',";
        }
    }
    //去掉末尾的最后一个逗号
    sSql_allColnameWithValue.chop(1);
    //emit mergeRes(sSql_allColnameWithValue);
    //插入记录
    QString sSql_Insert = "insert into " + dataBase + "." + table_name + " set " + sSql_allColnameWithValue;
    //emit mergeRes(sSql_Insert);
    QSqlQuery query_Insert;
    QString sError_Insert = "";
    if( pDb_option->executeSql(sSql_Insert, query_Insert, sError_Insert ) == false )
    {
        emit mergeRes(tr("插入记录语句执行失败：%1").arg(sError_Insert), 1);
        emit mergeRes(tr("SQL语句为：%1").arg(sSql_Insert), 1);
        qDebug() << sSql_Insert;
        //        emit mergeRes(sSql_Insert, 0);
        return false;
    }
    query_allColumnName.clear();
    query_Insert.clear();
    return true;
}
//******************************************** 获取最大的id号函数 ******************************************************
int db_compare::getMaxId(db_opt* pDb_option, QString dataBase, QString table_name, QString columnName)
{
    int ret;
    QString sSql_maxId = "select max(" + columnName + ") from " + dataBase + "." + table_name;
    QSqlQuery query_maxId;
    QString sError_maxId = "";
    if( pDb_option->executeSql(sSql_maxId, query_maxId, sError_maxId ) == false )
    {
        //        slotShowMsg( sError_maxId, 1 );
        return -1;
    }
    while(query_maxId.next())
    {
        QString max_Id = query_maxId.value(0).toString();
        ret = max_Id.toInt();
    }
    query_maxId.clear();
    return ret;
}
//******************************************** 获取车站ID函数 *********************************************************
int db_compare::getSubStationId(db_opt* pDb_option, QString dataBase, QString SubStation)
{
    int ret = -1;
    SubStation = SubStation.section('(', 0, 0);   //截取左括号前的子串
    QString sSql_SubStationId = "select location_id from " + dataBase + ".sys_model_location_info where tag_name = \'" + SubStation + "\'";
    QSqlQuery query_SubStationId;
    QString sError_SubStationId = "";
    if( pDb_option->executeSql(sSql_SubStationId, query_SubStationId, sError_SubStationId) == false )
    {
        emit mergeRes(sError_SubStationId, 1);
        return ret;
    }
    while(query_SubStationId.next()){
        QString SubStationId = query_SubStationId.value(0).toString();
        ret = SubStationId.toInt();
    }
    query_SubStationId.clear();
    return ret;
}
//******************************************** 获取专业ID函数 *********************************************************
int db_compare::getSubSystemId(db_opt* pDb_option, QString dataBase, QString SubSystem)
{
    int ret = -1;
    SubSystem = SubSystem.section('(', 0, 0);   //截取左括号前的子串
    QString sSql_SubSystemId = "select sub_system_id from " + dataBase + ".sys_model_sub_system_info where tag_name = \'" + SubSystem + "\'";
    QSqlQuery query_SubSystemId;
    QString sError_SubSystemId = "";
    if( pDb_option->executeSql(sSql_SubSystemId, query_SubSystemId, sError_SubSystemId) == false )
    {
        emit mergeRes(sError_SubSystemId, 1);
        return ret;
    }
    while(query_SubSystemId.next()){
        QString SubSystemId = query_SubSystemId.value(0).toString();
        ret = SubSystemId.toInt();
    }
    query_SubSystemId.clear();
    return ret;
}

int db_compare::getSubSystemFlagById( int id )
{
    int ret = 1;
    for(int i = 0; i < id - 1; i++ )
    {
        ret *= 2;
    }
    return ret;
}

QVector<int> db_compare::getSubSystemFlagById( QVector<int> idVec )
{
    QVector<int> ret;
    QVector<int>::iterator itr;
    m_nSubSystemFlag = 0 ;
    for( itr = idVec.begin(); itr != idVec.end(); itr++ )
    {
        int flag = getSubSystemFlagById( *itr );
        ret.append( flag );
        m_nSubSystemFlag += flag;
    }
    return ret;
}

//******************************************** 对比主键函数 ***********************************************************
bool db_compare::compKey(QStringList Org, QStringList Dst, int n)
{
    bool ret = true;
    for(int i = 0; i < n; i++)
    {
        bool tmp;
        if(QString::compare( Org.at(i), Dst.at(i) ) == 0)
        {
            tmp = true;
        }else
        {
            ret = false;
            break;
        }
        ret = ret & tmp;
    }
    return ret;
}
//*********************************************修改记录函数************************************************************
void db_compare::changeRecord( QSqlRecord& record, QString& sTableName, int StaId_dst, bool distinguishStation)
{
    for( int i = 0; i < record.count(); i++ )
    {
        if(distinguishStation)
        {
            record.setValue("LOCATION_ID", QString::number(StaId_dst));
        }

        //        if(QString::compare(sTableName, "sys_model_location_info") == 0)
        //        {
        //            record.setValue("DOMAIN_ID", domain_id);
        //            record.setValue("LOCATION_NO", location_no);
        //        }

        if( record.fieldName(i).contains("tag", Qt::CaseInsensitive ) || record.fieldName(i).contains("desc", Qt::CaseInsensitive ) || record.fieldName(i).contains("device", Qt::CaseInsensitive ) || record.fieldName(i).contains("name", Qt::CaseInsensitive ) ||
                record.fieldName(i).compare("LINKAGE_STRING", Qt::CaseInsensitive ) == 0 || record.fieldName(i).compare("OPT_HANDOVER_GROUP", Qt::CaseInsensitive ) == 0 || (sTableName.compare("trigger_condition_define", Qt::CaseInsensitive ) == 0 && record.fieldName(i).contains("PARAM", Qt::CaseInsensitive) ) )
        {
            if( record.value( i ).toString().contains(m_sSrcStaTagName, Qt::CaseInsensitive) )
            {
                QString sRecordValue = record.value( i ).toString();
                sRecordValue.replace(m_sSrcStaTagName, m_sDstStaTagName );
                record.setValue( record.fieldName(i), sRecordValue );
            }
            if( record.value( i ).toString().contains(m_sSrcStaDesc, Qt::CaseInsensitive) )
            {
                QString sRecordValue = record.value( i ).toString();
                sRecordValue.replace(m_sSrcStaDesc, m_sDstStaDesc );
                record.setValue( ( record.fieldName(i) ), sRecordValue );
            }
        }
    }
}
//************************从sys_model_location_info表中获取TAG_NAME/DESCRIPTION****************************************
QString db_compare::getSerachStr(db_opt* pDb_opt, QString sDataBase, int StaId , QString searchStr)
{
    QString ret;
    QString sSql = "select " + searchStr + " from " + sDataBase + ".sys_model_location_info where location_id = \'" + QString::number(StaId) + "\'";
    QSqlQuery query;
    QString sError = "";
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(sError, 1);
        //        return;
    }
    while(query.next()){
        ret = query.value(0).toString();

    }
    query.clear();
    return ret;
}

//***************************************判断某个表中是否存在某个字段*****************************************************
bool db_compare::ifExistColumn(db_opt* pDb_opt, QString sDataBase, QString tableName, QString columnName)
{
    bool ret = false;
    QString sSql = "show columns from " + sDataBase + "." + tableName;
    //emit mergeRes(sSql);
    QSqlQuery query;
    QString sError;
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("判断%1字段是否存在:%2").arg(columnName).arg(sError), 1);
        return ret;
    }
    while(query.next())
    {
        QString tmpStr = query.value(0).toString();
        if(QString::compare(tmpStr, columnName) == 0)
        {
            ret = true;
            return ret;
        }
    }
    return ret;
}
//******************************************获取专业部分SQL字符串*******************************************************
QString db_compare::getSubSystemSQLStr(QStringList sSubSystem, bool existStation)
{
    QString sub_systems;
    if(sSubSystem.size() == 0)
    {
        sub_systems = "";
    }
    else
    {
        if(existStation)
        {
            if(sSubSystem.size() == 1)
            {
                sub_systems = " and ";
                sub_systems += "sub_system = " + sSubSystem.at(0);
            }
            else
            {
                sub_systems = " and (";
                for(int i = 0; i < sSubSystem.size(); i++)
                {
                    if(i == 0)
                    {
                        sub_systems += "sub_system = " + sSubSystem.at(i);
                    }
                    else if(i == sSubSystem.size() - 1)
                    {
                        sub_systems += " or sub_system = " + sSubSystem.at(i) + ")";
                    }
                    else
                    {
                        sub_systems += " or sub_system = " + sSubSystem.at(i);
                    }
                }
            }
        }
        else
        {
            sub_systems = " where ";
            for(int i = 0; i < sSubSystem.size(); i++)
            {
                if(i == 0)
                {
                    sub_systems += "sub_system = " + sSubSystem.at(i);
                }
                else
                {
                    sub_systems += " or sub_system = " + sSubSystem.at(i);
                }
            }
        }
    }
    return sub_systems;
}
//**************************************判断记录在目标数据库中是否主键冲突*************************************************
bool db_compare::ifKeysConflict(db_opt* pDb_opt, QString sDataBase, QString sTableName, QStringList keys, QStringList uniques, QSqlRecord& record)
{
    bool ret = false;
    //判断UNIQUE记录冲突
    if( uniques.size() > 0 )
    {
        QString condition_u;
        for(int i = 0; i < uniques.size(); i++)
        {
            if(i == 0)
            {
                condition_u += uniques.at(i) + " = \'" + record.value(uniques.at(i)).toString() + "\'";
            }
            else
            {
                condition_u += " or " + uniques.at(i) + " = \'" + record.value(uniques.at(i)).toString() + "\'";
            }
        }
        QString sSql_u = "select * from " + sDataBase + "." + sTableName + " where " + condition_u;
        QSqlQuery query_u;
        QString sError_u = "";
        if( pDb_opt->executeSql(sSql_u, query_u, sError_u) == false )
        {
            emit mergeRes(tr("判断UNIQUE记录冲突查询失败：%1").arg(sError_u), 1);
            return false;
        }
        if(query_u.size() > 0)
        {
            ret = true;
            m_keysConflict =QString("表[%1],条件[%2],unique冲突!").arg(sTableName.toStdString().c_str()).arg(condition_u.toStdString().c_str());
            LOGERROR("表[%s],条件[%s],unique冲突!",sTableName.toStdString().c_str(),condition_u.toStdString().c_str());
            //qDebug() << "表" << sTableName << "unique冲突";
            return ret;
        }
        query_u.clear();
    }
    //***********************************************************************************************************
    //判断主键冲突
    QString condition_k;
    for(int i = 0; i < keys.size(); i++)
    {
        if(i == 0)
        {
            condition_k += keys.at(i) + " = \'" + record.value(keys.at(i)).toString() + "\'";
        }
        else
        {
            condition_k += " and " + keys.at(i) + " = \'" + record.value(keys.at(i)).toString() + "\'";
        }
    }
    QString sSql_k = "select * from " + sDataBase + "." + sTableName + " where " + condition_k;
    QSqlQuery query_k;
    QString sError_k = "";
    if( pDb_opt->executeSql(sSql_k, query_k, sError_k) == false )
    {
        emit mergeRes(tr("判断主键冲突查询失败：%1").arg(sError_k), 1);
    }
    if(query_k.size() > 0)
    {
        ret = true;
        m_keysConflict =QString("表[%1],条件[%2],主键冲突!").arg(sTableName.toStdString().c_str()).arg(condition_k.toStdString().c_str());
        LOGERROR("表[%s],条件[%s],主键冲突!",sTableName.toStdString().c_str(),condition_k.toStdString().c_str());
        return ret;
    }
    query_k.clear();
    return ret;
}
//**********************************************删除冲突的记录**********************************************************
void db_compare::deleteConflictRecord(db_opt* pDb_opt, QString sDataBase, QString sTableName, QStringList keys, QStringList uniques, QSqlRecord& record)
{
    //删除UNIQUE唯一的记录
    if(uniques.size() > 0)
    {
        QString condition_u;
        for(int i = 0; i < uniques.size(); i++)
        {
            if(i == 0)
            {
                condition_u += uniques.at(i) + " = \'" + record.value(uniques.at(i)).toString() + "\'";
            }
            else
            {
                condition_u += " or " + uniques.at(i) + " = \'" + record.value(uniques.at(i)).toString() + "\'";
            }
        }
        QString sSql_u = "delete from " + sDataBase + "." + sTableName + " where " + condition_u;
        //emit mergeRes(sSql_u);
        QSqlQuery query_u;
        QString sError_u = "";
        if( pDb_opt->executeSql(sSql_u, query_u, sError_u) == false )
        {
            emit mergeRes(tr("删除UNIQUE冲突记录失败：%1").arg(sError_u), 1);
        }
        query_u.clear();
    }
    //********************************************************************************************************
    //删除主键冲突的
    QString condition_k;
    for(int i = 0; i < keys.size(); i++)
    {
        if(i == 0)
        {
            condition_k += keys.at(i) + " = \'" + record.value(keys.at(i)).toString() + "\'";
        }
        else
        {
            condition_k += " and " + keys.at(i) + " = \'" + record.value(keys.at(i)).toString() + "\'";
        }
    }
    QString sSql_k = "delete from " + sDataBase + "." + sTableName + " where " + condition_k;
    QSqlQuery query_k;
    QString sError_k = "";
    if( pDb_opt->executeSql(sSql_k, query_k, sError_k) == false )
    {
        emit mergeRes(tr("删除主键冲突记录失败：%1").arg(sError_k), 1);
    }
    query_k.clear();
}
//*********************************************获取表字段的数量*********************************************************
int db_compare::getColumnNum(db_opt* pDb_opt, QString sDataBase, QString sTableName)
{
    int ret;
    QString sSql = "select count(*) from information_schema.COLUMNS where TABLE_SCHEMA = \'" + sDataBase + "\' and table_name = \'" + sTableName + "\'";
    QSqlQuery query;
    QString sError;
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("查询字段数量失败：%1").arg(sError), 1);
    }
    while(query.next())
    {
        ret = query.value(0).toInt();
    }
    query.clear();
    return ret;
}
//***********************************************获取表的主键***********************************************************
QStringList db_compare::getMainKeys(db_opt* pDb_opt, QString sDataBase, QString sTableName)
{
    QStringList ret;
    QString sSql = "select column_name from information_schema.KEY_COLUMN_USAGE WHERE TABLE_NAME = \'" + sTableName + "\' and TABLE_SCHEMA = \'" + sDataBase + "\' and CONSTRAINT_NAME = 'primary'";
    //emit mergeRes(sSql_getKeys);
    qDebug()<<sSql;
    QSqlQuery query;
    QString sError = "";
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("获取主键查询失败：%1").arg(sError), 1);
    }

    while(query.next())
    {
        ret.append(query.value(0).toString());
    }
    query.clear();
    return ret;
}
//*************************获取表属性为UNIQUE的字段**************************************
QStringList db_compare::getUniques(db_opt* pDb_opt, QString sDataBaseName, QString sTableName)
{
    //    show index from database.table where key_name =
    //    (select distinct CONSTRAINT_NAME from information_schema.TABLE_CONSTRAINTS
    //    where table_name = 'table' and CONSTRAINT_SCHEMA = 'database' and constraint_type = 'UNIQUE');
    QStringList ret;
    QString sSql = "show index from " + sDataBaseName + "." + sTableName + " where key_name = (select distinct CONSTRAINT_NAME from information_schema.TABLE_CONSTRAINTS where table_name = \'" \
            + sTableName + "\' and constraint_schema = \'" + sDataBaseName + "\' and constraint_type = \'UNIQUE\');";
    qDebug() << "get uniques sql = " << sSql;
    QSqlQuery query;
    QString sError = "";
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("查询UNIQUE字段失败：%1").arg(sError), 1);
    }

    while(query.next())
    {
        ret.append( query.value("Column_name").toString() );
    }
    query.clear();
    return ret;
}

//*******************************************判断数据库中是否存在表*******************************************************
bool db_compare::ifExistTable(db_opt* pDb_opt, QString sDataBase, QString sTableName)
{
    bool ret = false;
    QString sSql = "show tables from " + sDataBase;

    QSqlQuery query;
    QString sError = "";
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("获取主键查询失败：%1").arg(sError), 1);
    }
    while(query.next())
    {
        if(QString::compare(query.value(0).toString(), sTableName) == 0)
        {
            ret = true;
        }
    }
    query.clear();
    return ret;
}

bool db_compare::ifSubSystemSame( db_opt* pDb_opt, QString& sDatabaseName, QString& sTableName, int subSystemFlag )
{
    QString sSql = "select SUBSYSTEM_FLAG from " + sDatabaseName + ".rt_table_mode where NAME = \'" + sTableName + "\';";
    QSqlQuery query;
    QString sError = "";
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("查询专业是否匹配出错,%1").arg(sError), 1);
        return false;
    }
    while(query.next())
    {
        if(query.value(0).toInt() == subSystemFlag)
            return true;
    }
    return false;
}

bool db_compare::ifSubSystemSame( db_opt* pDb_opt, QString& sDatabaseName, QString& sTableName, QVector<int> subSystemFlagVec )
{
    QString sSql = "select SUBSYSTEM_FLAG from " + sDatabaseName + ".rt_table_mode where NAME = \'" + sTableName + "\';";
    QSqlQuery query;
    QString sError = "";
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("查询专业是否匹配出错,%1").arg(sError), 1);
        return false;
    }
    while(query.next())
    {
        if( subSystemFlagVec.contains( query.value(0).toInt() ) )
            return true;
    }
    return false;
}

bool db_compare::ifDistinguishStation( db_opt* pDb_opt, QString& sDatabaseName, QString& sTableName )
{
    QString sSql = "select SELECT_BY_LOCATION from " + sDatabaseName + ".rt_table_mode where NAME = \'" + sTableName + "\';";
    QSqlQuery query;
    QString sError = "";
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("查询专业是否匹配出错,%1").arg(sError), 1);
        return false;
    }
    while(query.next())
    {
        if(query.value(0).toInt() == 1)
            return true;
    }
    return false;
}

bool db_compare::ifDistinguishSubSystem( db_opt* pDb_opt, QString& sDatabaseName, QString& sTableName )
{
    QString sSql = "select SELECT_BY_SUBSYSTEM from " + sDatabaseName + ".rt_table_mode where NAME = \'" + sTableName + "\';";
    QSqlQuery query;
    QString sError = "";
    if( pDb_opt->executeSql(sSql, query, sError) == false )
    {
        emit mergeRes(tr("查询专业是否匹配出错,%1").arg(sError), 1);
        return false;
    }
    while(query.next())
    {
        if(query.value(0).toInt() == 1)
            return true;
    }
    return false;
}