merage

kimi

2020-05-27 c007f0ca1785db093d48f4846cda82fe8e955765

merage

 .gitignore

@@ -33,3 +33,4 @@
mvnw.cmd
.mvn/
*.gz
mdm.log

 mdm.log

File was deleted

 src/main/java/com/highdatas/mdm/controller/MasterAuthorController.java

@@ -567,9 +567,7 @@
                        String maintainFieldId = masterAuthor.getMaintainFieldId();
                        String tableName = masterAuthor.getTableName();
                        List<Maintain> maintainByMaintainField = maintainFieldService.getMaintainByMaintainField(maintainFieldId, tableName);
                        if (maintainByMaintainField != null && !maintainByMaintainField.isEmpty()) {
                            maintainSet.addAll(maintainByMaintainField);
                        }
                    }
                    int unActiveCnt = masterAuthorUnactiveService.selectCount(new EntityWrapper<MasterAuthorUnactive>().in("maintain_id", maintainSet).eq("user_id", user.getUserId()));
                    if (maintainSet.size() != unActiveCnt) {

 src/main/java/com/highdatas/mdm/controller/MasterDataController.java

@@ -6,7 +6,10 @@
import com.highdatas.mdm.entity.Character;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.pojo.*;
import com.highdatas.mdm.pojo.CodeMsg;
import com.highdatas.mdm.pojo.Operate;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.pojo.SysAssembleUpdateType;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.DbUtils;
@@ -232,11 +235,9 @@
                jsonObject.remove(Constant.ID);
                datas = jsonObject.toJSONString();
                String updateSegment = masterDataService.getUpdateSegment(maintain.getTableName(), maintain.getTableName() + Constant.RECORD, datas);
                String tempTable = maintain.getTableName() + Constant.RECORD;
                Segment segment = new Segment(MessageFormat.format(Constant.Alias, tempTable, Constant.STD_ID), id);

                tableInfoMapper.update(tempTable, updateSegment, segment.toString());
                result = Result.success(null);
                Integer updateCount = tableInfoMapper.updateRecordByMaintainId(maintain.getTableName() + Constant.RECORD, updateSegment, DbUtils.quotedStr(maintainId));
                result = Result.success(updateCount);
                break;
            case create:
                JSONObject createObject = JSONObject.parseObject(datas);

 src/main/java/com/highdatas/mdm/controller/MenuMappingController.java

@@ -91,14 +91,17 @@
        String menuId = menuMapping.getMenuId();
        SysMenu menu = menuService.selectById(menuId);
        String preParentId = menu.getParentId();
        menu.setName(menuMapping.getName()).updateById();

        String themeId = menuMapping.getThemeId();
//        if (!preParentId.equalsIgnoreCase(themeId)) {
////            menu.setParentId(themeId);
////            menu.updateById();
////        }
        if (!preParentId.equalsIgnoreCase(themeId)) {
            menu.setParentId(themeId);
            menu.updateById();
        }
        boolean updated = menuMapping.updateById();
        if (updated) {



            TUser user = DbUtils.getUser(request);
            if (menu != null) {
                LinkedHashSet<String> parentIdSet = new LinkedHashSet<>();

 src/main/java/com/highdatas/mdm/controller/SettleController.java

New file
@@ -0,0 +1,772 @@
package com.highdatas.mdm.controller;



import com.alibaba.druid.pool.DruidPooledConnection;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONArray;

import com.alibaba.fastjson.JSONObject;



import com.highdatas.mdm.entity.TUser;

import com.highdatas.mdm.pojo.kettle.UnBigDataDataSourceInfo;

import com.highdatas.mdm.pojo.kettle.KettleDBTrans;

import com.highdatas.mdm.pojo.kettle.TableColumn;

import org.pentaho.di.core.KettleClientEnvironment;

import org.pentaho.di.core.database.Database;

import org.pentaho.di.core.database.DatabaseMeta;

import org.pentaho.di.core.logging.LoggingObjectInterface;

import org.pentaho.di.core.logging.LoggingObjectType;

import org.pentaho.di.core.logging.SimpleLoggingObject;

import org.pentaho.di.core.row.RowMetaInterface;

import org.pentaho.di.trans.Trans;

import org.pentaho.di.trans.TransHopMeta;

import org.pentaho.di.trans.TransMeta;

import org.pentaho.di.trans.step.StepMeta;

import org.pentaho.di.trans.steps.dummytrans.DummyTransMeta;



import org.pentaho.di.trans.steps.tableinput.TableInputMeta;

import org.pentaho.di.trans.steps.tableoutput.TableOutputMeta;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;



import javax.servlet.http.HttpServletResponse;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;



@Controller

@RequestMapping("/database")

//http://localhost:8080/users/addUser

public class SettleController {



	
    @Autowired

    private UnBigDataDataSourceInfo dataSourceConn;

	
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");

    private String STEP_READ_FROM_TABLE = "Read data from table";

    private String STEP_INSERT_UPDATE = "Insert or update";

    private String STEP_DUMMY = "Dummy";

	


    /**

     * 提取mongodb数据

     * @param response

     * @param transData

     * @return

     * @throws

     */

//    @RequestMapping("/drawMongoDB")

//    @ResponseBody

//    public String drawMongoDB(HttpServletResponse response, @RequestBody JSONObject transData) {

//        String returnStr = "";

//        try {

//             KettleClientEnvironment.init();

//

//             TransMeta transMeta = new TransMeta();

//             transMeta.setName("抽取mongodb数据");

//             //导出数据的数据库连接

//             DatabaseMeta dataBaseOutput = new DatabaseMeta("Output", dataSourceConn.getDbType(), "Native", dataSourceConn.getDbHostName(), dataSourceConn.getDbName(), dataSourceConn.getDbPort(),

//                                                            dataSourceConn.getUsername(), dataSourceConn.getPassword());

//             transMeta.addDatabase(dataBaseOutput);

//

//                 MongoDbInputMeta mongoDbInputMeta = new MongoDbInputMeta();

//                 mongoDbInputMeta.setHostnames(transData.getString("hostName"));

//                 mongoDbInputMeta.setAuthenticationDatabaseName(transData.getString("authDBName"));

//                 mongoDbInputMeta.setPort(transData.getString("portNum"));

//                 mongoDbInputMeta.setAuthenticationUser(transData.getString("userName"));

//                 mongoDbInputMeta.setAuthenticationPassword(transData.getString("pwd"));

//                 mongoDbInputMeta.setDbName(transData.getString("dbName"));

//                 mongoDbInputMeta.setCollection(transData.getString("collection"));

//                 //得到抽取字段

//                 ArrayList<String> fieldList = new ArrayList<String>(transData.getString("drawfield").split(",").length);

//                 Collections.addAll(fieldList, transData.getString("drawfield").split(","));

//                 //设置不取JSON字段

//                 mongoDbInputMeta.setOutputJson(false);

//             //设置提取字段名称、path、type

//             List<MongoField> normalList = new ArrayList<MongoField>();

//             for (String fieldStr : fieldList) {

//                  MongoField newField = new MongoField();

//                  newField.m_fieldName = fieldStr;

//                  newField.m_fieldPath = "$." + fieldStr;

//                  newField.m_kettleType = "String";

//                  normalList.add(newField);

//             }

//             //设置mongodb提取字段

//             mongoDbInputMeta.setMongoFields(normalList);

//             //设置mogodb步骤元

//             StepMeta inputMongoDBStep = new StepMeta(STEP_READ_FROM_TABLE, mongoDbInputMeta);

//             inputMongoDBStep.setLocation(50, 50);

//             inputMongoDBStep.setDraw(true);

//             //将mogodb步骤元加入转化中

//             transMeta.addStep(inputMongoDBStep);

//

//             //设置mysql元

//             TableOutputMeta tableOutputMeta = new TableOutputMeta();

//             //设置数据库元

//             tableOutputMeta.setDatabaseMeta(transMeta.findDatabase("Output"));

//             //mongodb中数据库表/集合,就是表名

//             tableOutputMeta.setTableName(transData.getString("collection"));

//             //将mysql元加入步骤元

//             StepMeta insertUpdateStep = new StepMeta(STEP_INSERT_UPDATE, tableOutputMeta);

//             insertUpdateStep.setLocation(150, 50);

//             insertUpdateStep.setDraw(true);

//

//             transMeta.addStep(insertUpdateStep);

//

//             //增加个空元，

//             DummyTransMeta dummyMeta = new DummyTransMeta();

//

//             //将空元加入步骤元

//             StepMeta dummyStep = new StepMeta(STEP_DUMMY,dummyMeta);

//             dummyStep.setLocation(200, 50);

//             dummyStep.setDraw(true);

//

//             transMeta.addStep(dummyStep);

//

//             //设置步骤直接的关系

//             TransHopMeta hop = new TransHopMeta(inputMongoDBStep, insertUpdateStep);

//             transMeta.addTransHop(hop);

//             TransHopMeta hop2 = new TransHopMeta(insertUpdateStep, dummyStep);

//             transMeta.addTransHop(hop2);

//

//             //开始执行数据抽取

//             //将转化元实例化转换

//             Trans trans = new Trans(transMeta);

//             trans.prepareExecution(null);

//

//             trans.startThreads();

//             trans.waitUntilFinished();

//

//             if (trans.getErrors() > 0) {

//                 System.out.println(">>>>>>>>>> ERROR");

//                 returnStr = "{result:\"fail\"}";

//             }

//             else {

//                 System.out.println(">>>>>>>>>> SUCCESS ");

//                 returnStr = "{result:\"success\"}";

//             }

//        } catch(Exception e) {

//             return "{result:\"fail\"}";

//        }

//        return returnStr;

//    }

//

//    /**

//     * 提取mongodb数据

//     * @param response

//     * @param transData

//     * @return

//     * @throws

//     */

//    @RequestMapping("/drawHbase")

//    @ResponseBody

//    public String drawHbase(HttpServletResponse response, @RequestBody JSONObject transData) {

//        String returnStr = "";

//        try {

//            KettleClientEnvironment.init();

//

//            TransMeta transMeta = new TransMeta();

//            transMeta.setName("抽取Hbase数据");

//            //导出数据的数据库连接

//            DatabaseMeta dataBaseOutput = new DatabaseMeta("Output", dataSourceConn.getDbType(), "Native", dataSourceConn.getDbHostName(), dataSourceConn.getDbName(), dataSourceConn.getDbPort(),

//                    dataSourceConn.getUsername(), dataSourceConn.getPassword());

//            transMeta.addDatabase(dataBaseOutput);

//            //HBaseInputMeta hBaseInputMeta= new HBaseInputMeta()

//

//            MongoDbInputMeta mongoDbInputMeta = new MongoDbInputMeta();

//            mongoDbInputMeta.setHostnames(transData.getString("hostName"));

//            mongoDbInputMeta.setAuthenticationDatabaseName(transData.getString("authDBName"));

//            mongoDbInputMeta.setPort(transData.getString("portNum"));

//            mongoDbInputMeta.setAuthenticationUser(transData.getString("userName"));

//            mongoDbInputMeta.setAuthenticationPassword(transData.getString("pwd"));

//            mongoDbInputMeta.setDbName(transData.getString("dbName"));

//            mongoDbInputMeta.setCollection(transData.getString("collection"));

//            //得到抽取字段

//            ArrayList<String> fieldList = new ArrayList<String>(transData.getString("drawfield").split(",").length);

//            Collections.addAll(fieldList, transData.getString("drawfield").split(","));

//            //设置不取JSON字段

//            mongoDbInputMeta.setOutputJson(false);

//            //设置提取字段名称、path、type

//            List<MongoField> normalList = new ArrayList<MongoField>();

//            for (String fieldStr : fieldList) {

//                MongoField newField = new MongoField();

//                newField.m_fieldName = fieldStr;

//                newField.m_fieldPath = "$." + fieldStr;

//                newField.m_kettleType = "String";

//                normalList.add(newField);

//            }

//            //设置mongodb提取字段

//            mongoDbInputMeta.setMongoFields(normalList);

//            //设置mogodb步骤元

//            StepMeta inputMongoDBStep = new StepMeta(STEP_READ_FROM_TABLE, mongoDbInputMeta);

//            inputMongoDBStep.setLocation(50, 50);

//            inputMongoDBStep.setDraw(true);

//            //将mogodb步骤元加入转化中

//            transMeta.addStep(inputMongoDBStep);

//

//            //设置mysql元

//            TableOutputMeta tableOutputMeta = new TableOutputMeta();

//            //设置数据库元

//            tableOutputMeta.setDatabaseMeta(transMeta.findDatabase("Output"));

//            //mongodb中数据库表/集合,就是表名

//            tableOutputMeta.setTableName(transData.getString("collection"));

//            //将mysql元加入步骤元

//            StepMeta insertUpdateStep = new StepMeta(STEP_INSERT_UPDATE, tableOutputMeta);

//            insertUpdateStep.setLocation(150, 50);

//            insertUpdateStep.setDraw(true);

//

//            transMeta.addStep(insertUpdateStep);

//

//            //增加个空元，

//            DummyTransMeta dummyMeta = new DummyTransMeta();

//

//            //将空元加入步骤元

//            StepMeta dummyStep = new StepMeta(STEP_DUMMY,dummyMeta);

//            dummyStep.setLocation(200, 50);

//            dummyStep.setDraw(true);

//

//            transMeta.addStep(dummyStep);

//

//            //设置步骤直接的关系

//            TransHopMeta hop = new TransHopMeta(inputMongoDBStep, insertUpdateStep);

//            transMeta.addTransHop(hop);

//            TransHopMeta hop2 = new TransHopMeta(insertUpdateStep, dummyStep);

//            transMeta.addTransHop(hop2);

//

//            //开始执行数据抽取

//            //将转化元实例化转换

//            Trans trans = new Trans(transMeta);

//            trans.prepareExecution(null);

//

//            trans.startThreads();

//            trans.waitUntilFinished();

//

//            if (trans.getErrors() > 0) {

//                System.out.println(">>>>>>>>>> ERROR");

//                returnStr = "{result:\"fail\"}";

//            }

//            else {

//                System.out.println(">>>>>>>>>> SUCCESS ");

//                returnStr = "{result:\"success\"}";

//            }

//        } catch(Exception e) {

//            return "{result:\"fail\"}";

//        }

//        return returnStr;

//    }



    /**

     * 测试数据库连接

     * @param response

     * @param transData

     * @return

     * @throws Exception

     */

    @RequestMapping("/connectionDB")

    @ResponseBody

    public String connectionDB(HttpServletResponse response, @RequestBody JSONObject transData, TUser users) throws Exception {

        //userService.addUser(users);

        KettleClientEnvironment.init();

        DatabaseMeta dataMeta = new DatabaseMeta("KettleDBRep", transData.getString("type"), "Native", transData.getString("hostName"), transData.getString("dbName"), transData.getString("portNum"),

                                                 transData.getString("userName"), transData.getString("pwd"));

        LoggingObjectInterface loggingObject = new SimpleLoggingObject("Database factory", LoggingObjectType.GENERAL, null );

        Database ds = new Database(loggingObject, dataMeta);

        ds.normalConnect(null);

        Connection conn = ds.getConnection(); 
/*        PreparedStatement stmt = conn.prepareStatement("select * from usr");

        ResultSet rslt = stmt.executeQuery();

        while (rslt.next()) {

            System.out.println(rslt.getString("username"));

        }*/

        ds.disconnect();

        return "{result:\"success\"}";

    }

	
    /**

     * 创建SQL中tablename

     * 返回表名

     */

    public String createSQLTable(DruidPooledConnection connSys, ResultSet rslt) throws Exception {

        List<TableColumn> columnNameAndType = new ArrayList<TableColumn>();

        ResultSetMetaData md = rslt.getMetaData();

        for (int i = 1; i <= md.getColumnCount(); i++) {

             TableColumn tableColumn = new TableColumn();

             tableColumn.setColumnName(md.getColumnName(i));

             tableColumn.setColumnType(md.getColumnTypeName(i));

             tableColumn.setColumnLength(String.valueOf(md.getColumnDisplaySize(i)));

             columnNameAndType.add(tableColumn);			 
        }

        //创建表

        String SQLStr = "", tableName = "";

        if (!columnNameAndType.isEmpty()) {

            tableName = "SQL_" + sdf.format(new Date());

            SQLStr = splicingSQL(tableName, columnNameAndType);

            PreparedStatement stmt = connSys.prepareStatement(SQLStr);

            stmt.execute();	
        }

        return tableName;	    
    }

	
    /**

     * 通过SQL提取数据

     */

    @RequestMapping("/sqlPick")

    @ResponseBody

    public String sqlPick(@RequestBody JSONObject dbData) {

        try {

             String tableName = "", sqlStr = "";



             Database dsInput = null;

             Database dsOutput = null;

             TableInputMeta tableInputMeta = new TableInputMeta();

             TableOutputMeta talbeOutputMeta = new TableOutputMeta();

             TransMeta transMeta = new TransMeta();

             KettleDBTrans kettleDBTrans = new KettleDBTrans();

             kettleDBTrans.setDsInput(dsInput);

             kettleDBTrans.setDsOutput(dsOutput);

             kettleDBTrans.setTableInputMeta(tableInputMeta);

             kettleDBTrans.setTalbeOutputMeta(talbeOutputMeta);

             kettleDBTrans.setTransMeta(transMeta);

			 
             kettleDBConn(kettleDBTrans);

		     
             //SQL提取数据

             tableName = "SQL_" + sdf.format(new Date());

             sqlStr = dbData.getString("sqlStr");

             dataExtraction(tableName, sqlStr, kettleDBTrans);

             kettleDBTrans.getDsInput().disconnect();

             kettleDBTrans.getDsOutput().disconnect();

        } catch(Exception e) {

             return "{result:\"fail\"}";	
        }

        return "{result:\"success\"}";

    }

    /**

     * 抽取SQL数据

     */

    public void  extractSQLData(DruidPooledConnection connSys, ResultSet rslt, String tableName) throws Exception {

        PreparedStatement stmtDes;

        int columnCount;

        String SQLStr = "", valueStr = "";

        columnCount = rslt.getMetaData().getColumnCount();

        SQLStr = " insert into "+tableName+" ( ";

        valueStr = " values (";

        for(int i = 0; i < columnCount; i++) {

            SQLStr = SQLStr + rslt.getMetaData().getColumnName(i+1) + ", ";

            valueStr = valueStr + "?, ";

        }

        SQLStr = SQLStr.substring(0, SQLStr.length() - 2) + ")";

        valueStr = valueStr.substring(0, valueStr.length() - 2) + ")";

        SQLStr = SQLStr + valueStr;

        stmtDes = connSys.prepareStatement(SQLStr);

        while (rslt.next()) {

               for(int i = 0; i < columnCount; i++) {

                   stmtDes.setString(i + 1, rslt.getString(i+1));

               }

               stmtDes.addBatch();

        }

        stmtDes.executeBatch();		
    }

    /**

     * 测试SQL语句正确性

     */

    @RequestMapping("/sqlTest")

    @ResponseBody

    public String sqlTest(@RequestBody JSONObject dbData) {

		
        try {

             //连接数据库

             String dbConn = dbData.getString("DBConn");

             JSONObject DBParam = JSONArray.parseObject(dbConn);

			 
             KettleClientEnvironment.init();

             DatabaseMeta dataMeta = new DatabaseMeta("KettleDBRep", DBParam.getString("type"), "Native", DBParam.getString("hostName"), DBParam.getString("dbName"), DBParam.getString("portNum"),

                                                       DBParam.getString("userName"), DBParam.getString("pwd"));

             LoggingObjectInterface loggingObject = new SimpleLoggingObject("Database factory", LoggingObjectType.GENERAL, null );

             Database ds = new Database(loggingObject, dataMeta);

             ds.connect();

             Connection conn = ds.getConnection();

             String sqlStr = dbData.getString("sqlStr");

             PreparedStatement stmt = conn.prepareStatement(sqlStr);

             stmt.executeQuery();	
             ds.disconnect();

        } catch(Exception e) {

             return "{result:\"fail\"}";	
        }

        return "{result:\"success\"}";		
    }

    /**

     * 当选中数据表选项卡，显示数据表及视图名称

     * @param response

     * @param transData

     * @return

     * @throws Exception

     */

    @RequestMapping("/showTableAndView")

    @ResponseBody

    public String showTableAndView(HttpServletResponse response, @RequestBody JSONObject transData) throws Exception {

        KettleClientEnvironment.init();

        DatabaseMeta dataMeta = new DatabaseMeta("KettleDBRep", transData.getString("type"), "Native", transData.getString("hostName"), transData.getString("dbName"), transData.getString("portNum"),

                                                 transData.getString("userName"), transData.getString("pwd"));

		
        LoggingObjectInterface loggingObject = new SimpleLoggingObject("Database factory", LoggingObjectType.GENERAL, null );

        Database ds = new Database(loggingObject, dataMeta);

        //ds.normalConnect(null);

        ds.connect();

        Connection conn = ds.getConnection();

        List<String> UTable = new ArrayList<String>();

        List<String> VTable = new ArrayList<String>();

        //得到数据库中的表

//        PreparedStatement stmt = conn.prepareStatement("select name from sysobjects where xtype='U'");

//        ResultSet rslt = stmt.executeQuery();

//        while (rslt.next()) {

//               UTable.add(rslt.getString("name"));

//        }

//        String[] UTableArray = ds.getTablenames("dbo", true);

//        for (int i = 0; i < UTableArray.length; i++) {

//             UTable.add(UTableArray[i].replace("dbo.", ""));

//        }

        String[] UTableArray = ds.getTablenames(true);

        for (int i = 0; i < UTableArray.length; i++) {

             int lastHao = UTableArray[i].lastIndexOf(".");

             String uTable = UTableArray[i];

             if (lastHao > 0) {

                 UTable.add(uTable.substring(lastHao + 1, uTable.length()));

             }

             else {

                 UTable.add(UTableArray[i]);

             }

		     
        }		
        String tableJson = JSON.toJSONString(UTable);

        //得到数据库中的视图

//        stmt = conn.prepareStatement("select name from sysobjects where xtype='V'");

//        rslt = stmt.executeQuery();

//        while (rslt.next()) {

//               VTable.add(rslt.getString("name"));

//        }	
        String[] VTableArray = ds.getViews("dbo", true);

        for (int i = 0; i < VTableArray.length; i++) {

             VTable.add(VTableArray[i].replace("dbo.", ""));

        }			
        String viewJson = JSON.toJSONString(VTable);

        ds.disconnect();

        return "{result:\"success\",table:["+tableJson+"],view:["+viewJson+"]}";

    }

    /**

     * 使用kettle创建表 
     */

    public void createTable(Database dsOutput, RowMetaInterface rm, String tableName) {

       try {

            System.out.println("开始创建表:" + tableName);

            String dbProName = dsOutput.getConnection().getMetaData().getDatabaseProductName();

            System.out.println("数据库类型:" + dbProName);

            String sql = dsOutput.getDDL(tableName, rm);

            dsOutput.execStatement(sql.replace(";", ""));

            System.out.println("创建表成功");		   
       } catch(Exception e) {

            System.out.println("创建表失败");

       }



    }

    /**

     * 新版抽取数据

     * dataExtraction(String tableName, String sqlStr, TransMeta transMeta, Database dsInput, Database dsOutput, TableInputMeta tableInputMeta, TableOutputMeta tableOutputMeta) throws Exception {

       tableInputMeta.setSQL(sqlStr);

     */

    public void dataExtraction(String tableName, String sqlStr, KettleDBTrans kettleDBTrans) throws Exception {

       kettleDBTrans.getTableInputMeta().setSQL(sqlStr);

	   
       StepMeta inputStep = new StepMeta(STEP_READ_FROM_TABLE, kettleDBTrans.getTableInputMeta());

       inputStep.setLocation(50, 50);

       inputStep.setDraw(true);

       kettleDBTrans.getTransMeta().addStep(inputStep);

	   
       //判断目标数据库中，是否存在表，如:存在重新命名表名，用新表名创建表，如:不存在,直接创建表

       boolean hasTable = kettleDBTrans.getDsOutput().checkTableExists(tableName);

       if (hasTable) {

           tableName = tableName + "_" + sdf.format(new Date());

       }

       //得到原始表结构

       PreparedStatement stmt = null;

       RowMetaInterface rm = null;

       stmt = kettleDBTrans.getDsInput().getConnection().prepareStatement(sqlStr);

       stmt.executeQuery();

       rm = kettleDBTrans.getDsInput().getQueryFields(sqlStr, false);

       //创建数据表

       createTable(kettleDBTrans.getDsOutput(), rm, tableName);

	   
       kettleDBTrans.getTalbeOutputMeta().setTableName(tableName);

	   
       StepMeta insertUpdateStep = new StepMeta(STEP_INSERT_UPDATE, kettleDBTrans.getTalbeOutputMeta());

       insertUpdateStep.setLocation(150, 50);

       insertUpdateStep.setDraw(true);

       kettleDBTrans.getTransMeta().addStep(insertUpdateStep);

	   
       DummyTransMeta dummyMeta = new DummyTransMeta();

	   
       StepMeta dummyStep = new StepMeta(STEP_DUMMY, dummyMeta);

       dummyStep.setLocation(200, 50);

       dummyStep.setDraw(true);

	   
       kettleDBTrans.getTransMeta().addStep(dummyStep);

	   
       //设置步骤直接的关系

       TransHopMeta hop = new TransHopMeta(inputStep, insertUpdateStep);

       kettleDBTrans.getTransMeta().addTransHop(hop);

       TransHopMeta hop2 = new TransHopMeta(insertUpdateStep, dummyStep);

       kettleDBTrans.getTransMeta().addTransHop(hop2);

	   
       //开始执行

       Trans trans = new Trans(kettleDBTrans.getTransMeta());

       trans.prepareExecution(null);

	   
       trans.startThreads();

	   
       trans.waitUntilFinished();

	   
       if (trans.getErrors() > 0) {

           System.out.println(">>>>>>>>>> ERROR");

       }

       else {

           System.out.println(">>>>>>>>>> SUCCESS ");

       }

    }

    /**

     * 创建集成方法

     */

    public void kettleDBConn(KettleDBTrans kettleDBTrans) throws Exception {

        //连接数据库

//        String dbConn = kettleDBTrans.getAssemble().getString("DBConn");\

        String dbConn= "";

        JSONObject DBParam = JSONArray.parseObject(dbConn);

        //初始化kettle环境

        KettleClientEnvironment.init();

        KettleClientEnvironment.init();

        //导入数据的数据库连接

        DatabaseMeta dataMetaInput = new DatabaseMeta("Input", DBParam.getString("type"), "Native", DBParam.getString("hostName"), DBParam.getString("dbName"), DBParam.getString("portNum"),

                                                      DBParam.getString("userName"), DBParam.getString("pwd"));

        //导出数据的数据库连接

        DatabaseMeta dataMetaOutput = new DatabaseMeta("Output", dataSourceConn.getDbType(), "Native", dataSourceConn.getDbHostName(), dataSourceConn.getDbName(), dataSourceConn.getDbPort(),

                                                       dataSourceConn.getUsername(), dataSourceConn.getPassword());

        //导出数据库连接

        LoggingObjectInterface loggingObject = new SimpleLoggingObject("Database factory", LoggingObjectType.GENERAL, null );

        kettleDBTrans.setDsInput(new Database(loggingObject, dataMetaInput));

        kettleDBTrans.getDsInput().connect();

        Connection connInput = kettleDBTrans.getDsInput().getConnection();

        //导入数据库连接

        kettleDBTrans.setDsOutput(new Database(loggingObject, dataMetaOutput));

        kettleDBTrans.getDsOutput().connect();

        Connection connOutput = kettleDBTrans.getDsOutput().getConnection();

		
        kettleDBTrans.getTransMeta().setName("数据抽取");

		
        kettleDBTrans.getTransMeta().addDatabase(dataMetaInput);

        kettleDBTrans.getTransMeta().addDatabase(dataMetaOutput);

		
        //导出数据

        kettleDBTrans.getTableInputMeta().setDatabaseMeta(kettleDBTrans.getTransMeta().findDatabase("Input"));

        //导入数据

        kettleDBTrans.getTalbeOutputMeta().setDatabaseMeta(kettleDBTrans.getTransMeta().findDatabase("Output"));		
    }

    /**

     * 1.得到要提取数据的表与视图名称

     * 2.在程序数据库中创建要提取数据的表与视图的表的名称

     * 3.将要提取表与视图中的数据存储到系统的实体表中

     * 4.最后，返回结果

     */

    //提取表、视图中的数据

    @RequestMapping("/extractDBData")

    @ResponseBody

    public String extractDBData(HttpServletResponse response, @RequestBody JSONObject dbData) throws Exception {

        //表

        int k = 0;

        String sqlStr = "", tableName = "";

		
        Database dsInput = null;

        Database dsOutput = null;

        TableInputMeta tableInputMeta = new TableInputMeta();

        TableOutputMeta talbeOutputMeta = new TableOutputMeta();

        TransMeta transMeta = new TransMeta();

        KettleDBTrans kettleDBTrans    = new KettleDBTrans();

//        kettleDBTrans.setDbData(dbData);

        kettleDBTrans.setDsInput(dsInput);

        kettleDBTrans.setDsOutput(dsOutput);

        kettleDBTrans.setTableInputMeta(tableInputMeta);

        kettleDBTrans.setTalbeOutputMeta(talbeOutputMeta);

        kettleDBTrans.setTransMeta(transMeta);

		
        kettleDBConn(kettleDBTrans);

		
        JSONArray uTable = dbData.getJSONArray("UTable");

        //循环实体表

        if (!uTable.isEmpty()) {

            for(k = 0; k < uTable.size(); k++) {

                tableName = uTable.getString(k);

                sqlStr = " select * from " + tableName;

                dataExtraction(tableName, sqlStr, kettleDBTrans);

            }

        }

		
        JSONArray vTable = dbData.getJSONArray("VTable");

        //循环视图

        if (!vTable.isEmpty()) {

            for(k = 0; k < vTable.size(); k++) {

                tableName = vTable.getString(k);

                sqlStr = " select * from " + tableName;

                dataExtraction(tableName, sqlStr, kettleDBTrans);

            }

        }		
        //关闭数据库连接

        kettleDBTrans.getDsInput().disconnect();

        kettleDBTrans.getDsOutput().disconnect();

        return "{result: \"success\"}";

    }

	
    /**

     *     抽取数据

     * extractData(connSys, realTableName, conn, tableName);

     * connSys 系统数据库

     * realTableName 系统数据库表名

     * conn 提取数据库

     * tableName 提取数据库表名 
     */

    public void extractData(DruidPooledConnection connSys, String tableNameDes, Connection conn, String tableNameSrc) throws Exception {

        PreparedStatement stmt, stmtDes;

        ResultSet rslt;

        int columnCount;

        String SQLStr = "", valueStr = "";

		
        SQLStr = " select * from "+tableNameSrc+" ";

        stmt = conn.prepareStatement(SQLStr);

        rslt = stmt.executeQuery();

        columnCount = rslt.getMetaData().getColumnCount();

        SQLStr = " insert into "+tableNameDes+" ( ";

        valueStr = " values (";

        for(int i = 0; i < columnCount; i++) {

            SQLStr = SQLStr + rslt.getMetaData().getColumnName(i+1) + ", ";

            valueStr = valueStr + "?, ";

        }

        SQLStr = SQLStr.substring(0, SQLStr.length() - 2) + ")";

        valueStr = valueStr.substring(0, valueStr.length() - 2) + ")";

        SQLStr = SQLStr + valueStr;

        stmtDes = connSys.prepareStatement(SQLStr);

        while (rslt.next()) {

               for(int i = 0; i < columnCount; i++) {

                   stmtDes.setString(i + 1, rslt.getString(i+1));

               }

               stmtDes.addBatch();

        }

        stmtDes.executeBatch();

    }

	
    /**

     * 根据数据库类型转换对应类型

     * 
     */

    public String getColumnStr(TableColumn tableColumn) throws Exception {

        StringBuffer sqlStr = new StringBuffer();

        String returnStr = "";

        if (tableColumn.getColumnType().contains("varchar")) {

            sqlStr.append(tableColumn.getColumnName() + " varchar(" + tableColumn.getColumnLength() + "),");

        }

        else if (tableColumn.getColumnType().contains("int")) {

            sqlStr.append(tableColumn.getColumnName() + " int(" + tableColumn.getColumnLength() + "),");

        }

        else if (tableColumn.getColumnType().contains("date")) {

            sqlStr.append(tableColumn.getColumnName() + " date,");

        }

        else if (tableColumn.getColumnType().contains("nvarchar")) {

            sqlStr.append(tableColumn.getColumnName() + " varchar(" + tableColumn.getColumnLength() + "),");

        }

        else if (tableColumn.getColumnType().contains("nchar")) {

            sqlStr.append(tableColumn.getColumnName() + " varchar(" + tableColumn.getColumnLength() + "),");

        }	
        return sqlStr.toString();

    }

	
    /**

     * 拼接创建新表的语句

     * 1.系统数据库是mysql,所以，需要将其它数据库的类型，转换成mysql可以识别的类型

     */

    public String splicingSQL(String tableName,  List<TableColumn> columnNameAndType) throws Exception {

        String sqlStr = "";

        //第一步,类型 识别类型

        sqlStr = "create table " + tableName + " (";

        StringBuffer columnStr = new StringBuffer();

        columnStr.append(sqlStr);

        for (TableColumn tableColumn : columnNameAndType) {

             columnStr.append(getColumnStr(tableColumn));

        }

        sqlStr = columnStr.toString();

        return sqlStr.substring(0, sqlStr.length() - 1) + ")";

    }

    /**

     * 创建表

     * 1.需要判段,系统数据库中是否已存在表名(1.有的话重新命名,tableName + 年月日时分秒

     */

    public String createTable(DruidPooledConnection connSys, String tableName, List<TableColumn> columnNameAndType) throws Exception {

        String SQLStr = "";

        if (!columnNameAndType.isEmpty()) {

            PreparedStatement stmt;

            ResultSet rslt;

			
            SQLStr = " select count(table_name) as tableNum "

                   + " from information_schema.tables "

                   + " where table_schema='ssm' and table_name='"+tableName+"'";

            stmt = connSys.prepareStatement(SQLStr);

            rslt = stmt.executeQuery();

            rslt.next();

            if (rslt.getInt("tableNum") > 0) {

                tableName = tableName + "_" + sdf.format(new Date());

            }

            SQLStr = splicingSQL(tableName, columnNameAndType);

            stmt = connSys.prepareStatement(SQLStr);

            stmt.execute();	
        }

        return tableName;

    }

	
	
    //得到抽取数据库表的字段名称及字段类型

    public List<TableColumn> getColumnNameAndType(Connection conn, String tableName, String type) throws Exception {

        List<TableColumn> columnNameAndType = new ArrayList<TableColumn>();

        //得到数据库中的表

        String SQLStr = " select c.name As ColumnsName , t.name as ColumnsType, c.length as ColumnsLength "

                       + " from SysObjects As o "

                       + " left join SysColumns As c on o.id=c.id "

                       + " left join SysTypes As t on c.xtype=t.xusertype "

                       + " where o.type = '"+type+"' and o.name='"+tableName+"' ";

	    
        PreparedStatement stmt = conn.prepareStatement(SQLStr);

        ResultSet rslt = stmt.executeQuery();

        while (rslt.next()) {

               TableColumn tableColumn = new TableColumn();

               tableColumn.setColumnName(rslt.getString("ColumnsName"));

               tableColumn.setColumnType(rslt.getString("ColumnsType"));

               tableColumn.setColumnLength(rslt.getString("ColumnsLength"));

               columnNameAndType.add(tableColumn);

        }

	    
        return columnNameAndType;

    }

	
	


/*    protected void sendJsonData(HttpServletResponse response) throws Exception{

        response.setContentType("text/javascript;charset=UTF-8");

        PrintWriter out = response.getWriter();

        out.println("alert(\"数据库连接成功!!!\")");

        out.flush();

        out.close();

    }*/	
	
}


 src/main/java/com/highdatas/mdm/entity/SysField.java

@@ -313,10 +313,10 @@
        if (!StringUtils.isEmpty(alias)) {
            hash += alias.hashCode();
        }
        if (visible != null) {
        if (visible == null) {
            hash += visible.hashCode();
        }
        if (orderNo != null) {
        if (orderNo == null) {
            hash += orderNo.hashCode();
        }
        if (!StringUtils.isEmpty(code)) {

 src/main/java/com/highdatas/mdm/mapper/TableInfoMapper.java

@@ -30,18 +30,18 @@

    List<Map<String,Object>> selectDistinct(@Param("tableName") String tableName, @Param("fields") String fields, @Param("where") String where);

    List<Map<String,Object>> selectByPageByVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields,@Param("A1fields") String A1fields, @Param("tempFields") String tempFields,@Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo, @Param("where") String where, @Param("limit") String limit);
    List<Map<String,Object>> selectByPageByVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("Hfields") String Hfields, @Param("A1fields") String A1fields, @Param("A2fields") String A2fields, @Param("tempHFields") String tempHFields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo, @Param("maintainId") String maintainId, @Param("where") String where, @Param("limit") String limit);

    List<Map<String,Object>> selectByPageByMaxVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("A1fields") String A1fields, @Param("tempFields") String tempFields, @Param("fromOrderNo") Integer fromOrderNo,   @Param("where") String where, @Param("limit") String limit);
    List<Map<String,Object>> selectByPageByMaxVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("Hfields") String Hfields, @Param("A1fields") String A1fields, @Param("A2fields") String A2fields, @Param("tempHFields") String tempHFields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo,@Param("maintainId") String maintainId,  @Param("where") String where, @Param("limit") String limit);


    List<Map<String,Object>> select(@Param("tableName") String tableName, @Param("fields") String fields, @Param("where") String where);

    Long getCount(@Param("tableName") String tableName,  @Param("where") String where);

    Long getCountByVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("A1fields") String A1fields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo,  @Param("where") String where);
    Long getCountByVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("Hfields") String Hfields,@Param("A1fields") String A1fields, @Param("A2fields") String A2fields, @Param("tempHFields") String tempHFields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo,@Param("maintainId") String maintainId,  @Param("where") String where);

    Long getCountByMaxVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("A1fields") String A1fields, @Param("fromOrderNo") Integer fromOrderNo, @Param("where") String where);
    Long getCountByMaxVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("Hfields") String Hfields,@Param("A1fields") String A1fields, @Param("A2fields") String A2fields, @Param("tempHFields") String tempHFields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo,@Param("maintainId") String maintainId, @Param("where") String where);

    void insert(@Param("tableName") String tableName, @Param("fields") String fields, @Param("values") String values);


 src/main/java/com/highdatas/mdm/pojo/CodeMsg.java

@@ -44,7 +44,6 @@
    public static CodeMsg ADDQUEUE_OVER = new CodeMsg(4012,"分发队列已满，暂不能添加");
    public static CodeMsg ADDQUEUE_FAIL = new CodeMsg(4011,"添加分发队列失败");
    public static CodeMsg MAINTAIN_UNFOUND_ERROR = new CodeMsg(4005,"未查到版本数据，或无权限");
    public static CodeMsg ACT_RUN_ERROR = new CodeMsg(4006,"已有版本审批中");

    public CodeMsg(int code, String msg) {
        this.code = code;

 src/main/java/com/highdatas/mdm/pojo/kettle/KettleDBTrans.java

New file
@@ -0,0 +1,72 @@
package com.highdatas.mdm.pojo.kettle;



import com.alibaba.fastjson.JSONObject;

import com.highdatas.mdm.entity.SysAssemble;

import org.pentaho.di.core.database.Database;

import org.pentaho.di.trans.TransMeta;

import org.pentaho.di.trans.steps.tableinput.TableInputMeta;

import org.pentaho.di.trans.steps.tableoutput.TableOutputMeta;



public class KettleDBTrans {



    private SysAssemble assemble;

    private TransMeta transMeta;

    private Database dsInput;

    private Database dsOutput;

    private TableInputMeta tableInputMeta;

    private TableOutputMeta talbeOutputMeta;



    public SysAssemble getAssemble() {

        return assemble;

    }



    public void setAssemble(SysAssemble assemble) {

        this.assemble = assemble;

    }



    public TransMeta getTransMeta() {

        return transMeta;

    }

	
    public void setTransMeta(TransMeta transMeta) {

        this.transMeta = transMeta;

    }

	
    public Database getDsInput() {

        return dsInput;

    }

	
    public void setDsInput(Database dsInput) {

        this.dsInput = dsInput;

    }

	
    public Database getDsOutput() {

        return dsOutput;

    }

	
    public void setDsOutput(Database dsOutput) {

        this.dsOutput = dsOutput;

    }

	
    public TableInputMeta getTableInputMeta() {

        return tableInputMeta;

    }

	
    public void setTableInputMeta(TableInputMeta tableInputMeta) {

        this.tableInputMeta = tableInputMeta;

    }

	
    public TableOutputMeta getTalbeOutputMeta() {

        return talbeOutputMeta;

    }

	
    public void setTalbeOutputMeta(TableOutputMeta talbeOutputMeta) {

        this.talbeOutputMeta = talbeOutputMeta;

    }

	
}












 src/main/java/com/highdatas/mdm/process/canvas/ProcessDiagramCanvas.java

 src/main/java/com/highdatas/mdm/process/canvas/ProcessDiagramGenerator.java

 src/main/java/com/highdatas/mdm/service/IMaintainService.java

@@ -64,6 +64,4 @@
    JSONObject compareField(String maintainId1, String maintainId2);

    Map<String, Object> getPreInfo(Maintain maintain, String id);

    boolean getCanAct(String tableName);
}

 src/main/java/com/highdatas/mdm/service/act/impl/IdentityServiceImpl.java

@@ -136,9 +136,6 @@
        }
        try {
            User user = identityService.newUser(id);

            identityService.saveUser(user);
            user.setFirstName("");
            identityService.saveUser(user);
            return Result.success(null);
        }catch (Exception e){
@@ -165,8 +162,6 @@
        try {
            Group group = identityService.newGroup(id);
            identityService.saveGroup(group);
            group.setName("");
            identityService.saveGroup(group);
            return Result.success(null);
        }catch (Exception e){
            e.printStackTrace();
@@ -190,16 +185,11 @@
            if (user == null) {
                return Result.error(new CodeMsg(3001, "当前用户不存在,请先创建用户"));
            }
            Group group = identityService.createGroupQuery().groupId(roleId).singleResult();
            if (group == null) {
                return Result.error(new CodeMsg(3001, "当前角色不存在,请先创建用户"));
            }

            Map<String, String> memberShip = tableInfoMapper.selectActMemberShip(userId, roleId);
            if (memberShip != null) {
                return Result.success(null);
            }

            identityService.createMembership(userId,roleId);
            return Result.success(null);
        }
@@ -286,6 +276,7 @@
    @Transactional(rollbackFor = {RuntimeException.class, Error.class})
    public Result deleteUserRole(String roleId, String userId) {
        try {

            Map<String, String> memberShip = tableInfoMapper.selectActMemberShip(userId, roleId);
            if (memberShip == null) {
                return Result.success(null);

 src/main/java/com/highdatas/mdm/service/impl/FlowsServiceImpl.java

@@ -144,8 +144,8 @@
            if (flows.getBusinessType().equals(ActivitiBusinessType.maintain)){
                String maintainId = flows.getBusinessId();
                log.info("flow-maintain:" + maintainId);
                //masterModifiedService.dealFlow(maintainId, flows.getStatus());
               //log.info("flow-masterModifiedService end");
                masterModifiedService.dealFlow(maintainId, flows.getStatus());
                log.info("flow-masterModifiedService end");
                maintainService.dealFlow(maintainId, flows.getStatus());
                log.info("flow-maintainService end");
                viewService.dealFlow(maintainId, flows.getStatus());

 src/main/java/com/highdatas/mdm/service/impl/MaintainServiceImpl.java

@@ -142,7 +142,7 @@
                return;
            }
            String fields = masterDataService.getTempFields(null, tableName);
            String tempFields = masterDataService.getFields(tableName + Constant.RECORD, Constant.T);
            String tempFields = masterDataService.getFields(tableName + Constant.RECORD);

            String tableTempName = tableName + Constant.RECORD;
            // insert 2 std
@@ -563,20 +563,6 @@
            }
        }
        return result;
    }

    @Override
    public boolean getCanAct(String tableName) {
        List<Maintain> maintainList = selectList(new EntityWrapper<Maintain>().eq("table_name", tableName));

        long count = maintainList.stream()
                .filter(one -> one.getFlowId() != null)
                .filter(one -> flowsService.getStatusByBusinessId(one.getId()).equals(ActivitiStatus.working)).count();
        if (count == 0) {
            return true;
        } else {
            return false;
        }
    }



 src/main/java/com/highdatas/mdm/service/impl/MasterAuthorServiceImpl.java

 src/main/java/com/highdatas/mdm/service/impl/SysAssembleServiceImpl.java

@@ -137,15 +137,6 @@
            }
        }

        String tableNameByMenu = menuMappingService.getTableNameByMenu(assemble.getMenuId());
        boolean canAct = maintainService.getCanAct(tableNameByMenu);
        if (!canAct) {
            XxlJobLogger.log("当前有流程正在运行,暂时无法汇集下次数据");
            assemble.setPreMsg("当前有流程正在运行,暂时无法汇集下次数据");
            assemble.updateById();
            return  Result.error(new CodeMsg(6009,"当前有流程正在运行,暂时无法汇集下次数据"));
        }

        Boolean bigData = assemble.getBigdata();
        Date scheduleDate = new Date();
        XxlJobLogger.log("log info:  start assemble");
@@ -608,6 +599,8 @@

    private Result checkTempData(SysAssemble assemble) {
        try {


            SysAssembleCheckType checkType = assemble.getCheckType();
            if (checkType == null) {
                return Result.error(new CodeMsg(6009, "规则校验类型为空"));

 src/main/java/com/highdatas/mdm/service/impl/SysDispenseLogsServiceImpl.java

@@ -73,12 +73,10 @@
                .setTopicId(mqEntity.getMsgTopicName())
                .setTagId(mqEntity.getMsgTagName())
                .setKeyId(mqEntity.getMsgKey());

        int totalSize = mqEntity.getTotalSize();
        if (totalSize > 0) {
            sysDispenseLogs.setTotal(totalSize);
        }

        AtomicInteger pageNo = mqEntity.getPageNo();
        if (pageNo != null) {
            sysDispenseLogs.setPageNo(pageNo.get());

 src/main/java/com/highdatas/mdm/service/impl/SysViewServiceImpl.java

@@ -96,10 +96,7 @@
            int length = tableSchemaResult.getLength();
            totalLength += length;
        }
        int pageSize = 20;
       if (totalLength != 0) {
           pageSize = Constant.MaxDispenseSize / totalLength;
       }
        int pageSize = Constant.MaxDispenseSize / totalLength;
        page.setPageSize(pageSize);
        Long viewCount = getViewCount(sysView);
        if (viewCount == 0) {

 src/main/java/com/highdatas/mdm/util/Constant.java

@@ -140,5 +140,4 @@
    String MT = "mt";
    String IDX_TEMPLATE = "IDX_{0}_{1}";

    String T = "t";
}

 src/main/java/com/highdatas/mdm/util/HttpUtils.java

@@ -53,14 +53,13 @@
        if (mediaType == null){
            headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
            MultiValueMap<String, String> vals = new LinkedMultiValueMap();
            if (formParams != null) {

                Set<String> keySet = formParams.keySet();
                for (String key : keySet) {
                    String s = formParams.get(key);
                    List<String> strings = new ArrayList<>();
                    strings.add(s);
                    vals.put(key,strings);
                }
            }

            requestEntity = new HttpEntity<MultiValueMap<String, String>>(vals, headers);
@@ -120,7 +119,7 @@
        }
        String s = sb.toString();
        if (s.endsWith("&")) {
            s = org.apache.commons.lang3.StringUtils.substringBeforeLast(s, "&");
            s = org.apache.commons.lang.StringUtils.substringBeforeLast(s, "&");
        }
        return s;
    }

 src/main/java/com/highdatas/mdm/util/RuleClient.java

@@ -14,7 +14,6 @@
import org.springframework.http.client.SimpleClientHttpRequestFactory;

import org.springframework.http.converter.StringHttpMessageConverter;

import org.springframework.stereotype.Component;

import org.springframework.util.MultiValueMap;

import org.springframework.util.StringUtils;

import org.springframework.web.client.RestTemplate;



@@ -40,11 +39,10 @@
    public HashMap<String,Boolean> execuImmeForCollect(String tableName,String userId) {

        //TODO

        String url = this.url + prefix + "execuImmeForCollect";

        HashMap<String, Object> params = new HashMap<>();

        HashMap<String, String> params = new HashMap<>();

        params.put("tableName",tableName);

        params.put("createUserId",userId);

        String urlParamsByMap = HttpUtils.getUrlParamsByMap(params);

        String s = HttpUtils.HttpRestClient(url, HttpMethod.POST, null, urlParamsByMap, null);

        params.put("createUserId",tableName);

        String s = HttpRestClient(url, HttpMethod.POST, params, null, null);

        JSONObject result = (JSONObject) JSON.parse(s);

        String sucess = result.getString(Constant.Success);

        JSONObject dataObject = result.getJSONObject(Constant.Data);

@@ -80,7 +78,7 @@
        params.put("tableName",tableName);

        params.put("pageNum",pageNo.toString());

        params.put("pageSize",pageSize.toString());

        String s = HttpUtils.HttpRestClient(url, HttpMethod.POST, params, null, null);

        String s = HttpRestClient(url, HttpMethod.POST, params, null, null);

        JSONObject result = (JSONObject) JSON.parse(s);

        String sucess = result.getString(Constant.Success);

        if (StringUtils.isEmpty(sucess) || !Boolean.valueOf(sucess)) {

@@ -96,7 +94,7 @@
        params.put("tableName",tableName);

        params.put("isTemp",isTemp);



        String s = HttpUtils.HttpRestClient(url, HttpMethod.POST, params,null, MediaType.APPLICATION_JSON);

        String s = HttpRestClient(url, HttpMethod.POST, params,null, MediaType.APPLICATION_JSON);

        JSONObject result = (JSONObject) JSON.parse(s);

        boolean sucess = result.getBoolean(Constant.Success);

        if (!sucess) {

@@ -122,7 +120,7 @@
    }





    public String HttpRestClient(String url, HttpMethod method, MultiValueMap<String, String> formParams, String getParams,  MediaType mediaType) {

    public String HttpRestClient(String url, HttpMethod method, HashMap<String, String> formParams, String getParams,  MediaType mediaType) {

        if (!StringUtils.isEmpty(getParams)) {

            url = url + Constant.QUESTION + getParams;

        }

@@ -138,7 +136,7 @@
            headers.setContentType(mediaType);

        }



        HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<MultiValueMap<String, String>>(formParams, headers);

        HttpEntity<HashMap<String, String>> requestEntity = new HttpEntity<HashMap<String, String>>(formParams, headers);

        //  执行HTTP请求

        ResponseEntity<String> response = client.exchange(url, method, requestEntity, String.class);




 src/main/java/com/highdatas/mdm/util/pool/MqEntity.java

@@ -178,7 +178,6 @@
            }

            Date createTime = logByMqEntity.getCreateTime();

            long schedule = new Date().getTime() - createTime.getTime();

            schedule = Math.abs(schedule);

            logByMqEntity.setSchedule(schedule);

            logByMqEntity.updateById();

        }


 src/main/java/com/highdatas/mdm/util/pool/MqMessage.java

@@ -109,7 +109,6 @@
            object.fluentPut("pages", page.getPageCount());

            object.fluentPut("current", page.getPageNo());

            object.fluentPut("records", maps);

            mqEntity.getMsgBody().setTotal(Long.valueOf(page.getRecordCount()).intValue());

            content = JSONObject.toJSONString(object);

        } else {

            Result result = DbUtils.masterDataService.selectListByPageByVersion(user, maintain.getTableName(), fieldList, filter, pageNo.get(), pageSize.get(), maintain.getVersion(), false);

@@ -122,7 +121,6 @@
            object.fluentPut("current", grid.get("current"));

            object.fluentPut("records", grid.get("record"));



            mqEntity.getMsgBody().setTotal(grid.getInteger("total"));

            content = JSONObject.toJSONString(object);



        }

@@ -166,7 +164,6 @@
    private void sendOneViewPackage(AtomicInteger pageNo, AtomicInteger pageSize, SysView sysView) throws Exception {

        Result viewData = DbUtils.viewService.getViewData(sysView, pageNo.get(), pageSize.get());

        JSONObject object = (JSONObject) viewData.getData();

        mqEntity.getMsgBody().setTotal(object.getInteger("total"));

        String content = JSONObject.toJSONString(object);

        sendMqBody(pageSize.get(), content);

    }

@@ -193,7 +190,7 @@
//        String mqBody = content;

        MqEntity.MsgBodyBean msgBody = mqEntity.getMsgBody();

        msgBody.setData(mqBody);



        msgBody.setTotal(pageSize);

        mqEntity.setMsgBody(msgBody);

//        Thread.sleep(1000 * 60 * 3);

        mqEntity.send2Mq();


 src/main/resources/application-dev.yml

@@ -1,5 +1,5 @@
server:
  port: 9998
  port: 9999
#url: jdbc:mysql://180.169.94.250:8306/data_admin?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC&nullCatalogMeansCurrent=true
img:
  url: D:/mdm/process

 src/main/resources/application-pro.yml

@@ -32,7 +32,7 @@
        max-active: 100
        max-wait: 1000
  activiti:
    database-schema-update: true
    database-schema-update: flase

  thymeleaf:
    cache: false
@@ -60,7 +60,7 @@
  url: http://127.0.0.1:9107

user:
  url: http://180.169.94.250:9107
  url: http://127.0.0.1:9107
mq:
  url: http://127.0.0.1:9107

@@ -92,6 +92,7 @@
    admin:
      addresses: http://127.0.0.1:8090/xxl-job-admin


master:
  unbigdata:
    db:

 src/main/resources/mapping/MenuMappingMapper.xml

@@ -20,7 +20,7 @@

    <select id="getMapping" resultType="java.util.Map">
        SELECT
        m.id,m.code, m.name, system_id as systemId, m.audit as audit, m.desc,
        m.id,m.code, m.name, system_id as systemId, m.audit as audit,

        c2.name as cname1, c2.id as cid1, c1.name as cname2, c1.id as cid2, c.name as cname3, c.id as cid3,
        start_time as startTime, end_time as endTime, m.create_time as createTime, m.update_time as updateTime,

 src/main/resources/mapping/TableInfoMapper.xml

@@ -6,8 +6,7 @@
        show TABLES like #{tableName}
    </select>

    <select id="selectIdxByTableName" parameterType="java.lang.String" resultType="java.util.Map"
            statementType="STATEMENT">
    <select id="selectIdxByTableName" parameterType="java.lang.String"   resultType="java.util.Map" statementType="STATEMENT">
        SELECT * FROM mysql.`innodb_index_stats` a WHERE  a.table_name =  ${tableName}
    </select>

@@ -15,8 +14,7 @@
        select COLUMN_NAME as fieldName,DATA_TYPE as dbType, character_maximum_length as length from information_schema.COLUMNS where table_name = #{tableName} and table_schema = (select database())
    </select>

    <select id="getTableFieldFromDb" parameterType="com.highdatas.mdm.entity.TableSchema"
            resultType="com.highdatas.mdm.entity.TableSchemaResult">
    <select id="getTableFieldFromDb" parameterType="com.highdatas.mdm.entity.TableSchema" resultType="com.highdatas.mdm.entity.TableSchemaResult">
        select COLUMN_NAME as fieldName,DATA_TYPE as dbType,character_maximum_length as length from information_schema.COLUMNS where table_name = #{tableName} and table_schema = #{dbName}
    </select>

@@ -30,132 +28,174 @@

    <select id="selectByPageByVersion" resultType="java.util.Map" statementType="STATEMENT">
        <![CDATA[
         SELECT ${fields}
FROM
    (SELECT ${A1fields}
    FROM ${tableName} a1
        select  ${fields} from (
        SELECT
         ${A1fields} from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN flows f on maintain.flow_id = f.id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          and operate = 'create'
          AND tm.std_id = m.id
          AND f.status = 'open'
          and maintain.table_name = '${tableName}'
          ) ) a1
    LEFT JOIN
        (SELECT DISTINCT mt1.std_id
        FROM ${tableTempName} mt1
        LEFT JOIN maintain_detail md
            ON md.pre_merge_id = mt1.id
        LEFT JOIN maintain m
            ON m.id = md.parent_id
        WHERE m.order_no <= ${fromOrderNo}
                AND m.order_no > ${toOrderNo}
                AND m.table_name = '${tableName}'
                AND (operate = 'create'
                OR operate = 'update') ) v
            ON v.std_id = a1.id
        WHERE v.std_id IS NULL
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT MIN(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on m.flow_id = f.id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and  m.table_name = '${tableName}'
        and operate = 'update'
        AND f.status = 'open'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is null
        UNION
        SELECT ${tempFields}
        FROM
            (SELECT mt.*,
         m.order_no
            FROM ${tableTempName} mt
            LEFT JOIN maintain_detail md
                ON md.pre_merge_id = mt.id
            LEFT JOIN maintain m
                ON md.parent_id = m.id
            WHERE m.order_no <= ${fromOrderNo}
                    AND m.order_no > ${toOrderNo}
                    AND m.table_name = '${tableName}'
                    AND operate = 'update' ) AS a1
            INNER JOIN
                (SELECT std_id,
         min(order_no) AS order_no
                FROM
                    (SELECT mt.id,
         std_id,
         m.order_no
                    FROM ${tableTempName} mt
                    LEFT JOIN maintain_detail md
                        ON md.pre_merge_id = mt.id
                    LEFT JOIN maintain m
                        ON md.parent_id = m.id
                    WHERE m.order_no <= ${fromOrderNo}
                                AND m.order_no > ${toOrderNo}
                            AND m.table_name = '${tableName}'
                            AND operate = 'update'
                            AND NOT EXISTS
                        (SELECT mt1.id
                        FROM ${tableTempName} mt1
                        LEFT JOIN maintain_detail md
                            ON md.pre_merge_id = mt1.id
                        LEFT JOIN maintain m
                            ON m.id = md.parent_id
                        WHERE m.order_no <= ${fromOrderNo}
                                AND m.order_no > ${toOrderNo}
                                AND m.table_name = '${tableName}'
        SELECT
         ${A2fields}
        from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          LEFT JOIN flows f on maintain.flow_id = f.id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          and operate = 'create'
          AND f.status = 'open'
          AND tm.std_id = m.id
          and maintain.table_name = '${tableName}'
          ) ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT MIN(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on m.flow_id = f.id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and m.table_name = '${tableName}'
        and operate = 'update'
        AND f.status = 'open'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is not null
            UNION
        SELECT ${tempFields} FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo} AND operate = 'delete'
         AND f.status = 'open'
         and  maintain.table_name = '${tableName}'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            LEFT JOIN flows f on maintain.flow_id = f.id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
                                AND operate = 'create'
                                AND mt1.std_id = mt.std_id ) ) AS gz
                        GROUP BY  std_id ) AS zb
                            ON a1.std_id = zb.std_id
                                AND a1.order_no = zb.order_no
                        UNION
                        SELECT DISTINCT ${tempFields}
                        FROM ${tableTempName} a1
                        LEFT JOIN maintain_detail md
                            ON md.pre_merge_id = a1.id
                        LEFT JOIN maintain m
                            ON m.id = md.parent_id
                        LEFT JOIN
                            (SELECT DISTINCT mt1.std_id
                            FROM ${tableTempName} mt1
                            LEFT JOIN maintain_detail md
                                ON md.pre_merge_id = mt1.id
                            LEFT JOIN maintain m
                                ON m.id = md.parent_id
                            WHERE m.order_no <= ${fromOrderNo}
                                    AND m.order_no > ${toOrderNo}
                                    AND m.table_name = '${tableName}'
                                    AND (operate = 'create'
                                    OR operate = 'update') ) zb
                                ON zb.std_id = a1.std_id
                            WHERE zb.std_id is null
                                    AND md.operate = 'delete'
                                    AND m.order_no <= ${fromOrderNo}
                                    AND m.order_no > ${toOrderNo}
                                    AND m.table_name = '${tableName}' ) a
                        WHERE ${where} ${limit}
            AND f.status = 'open'
            AND mt.std_id = mt1.std_id
            and  maintain.table_name = '${tableName}'
        )
        )a where  ${where} ${limit}
        ]]>
    </select>

    <select id="selectByPageByMaxVersion" resultType="java.util.Map" statementType="STATEMENT">
         <![CDATA[

       select  ${fields},operate, status from (
       SELECT ${tempFields}, md.operate, f.`status` from ${tableTempName} a1
        LEFT JOIN maintain_detail md on md.pre_merge_id = a1.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.id is null
        UNION
        SELECT  ${tempFields}, md.operate, f.`status` from ${tableTempName} a1
        LEFT JOIN maintain_detail md on md.pre_merge_id = a1.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.`status` = 'working'

        union
        SELECT  ${A1fields}, '', '' from ${tableName} a1
        SELECT
         ${A1fields}, '' as operate, '' as status from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          AND tm.std_id = m.id
          and  maintain.table_name = '${tableName}'
          ) ) a1
        LEFT JOIN
        (
        SELECT DISTINCT std_id from ${tableTempName} mt
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT max(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.id is null
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and  m.table_name = '${tableName}'
        and operate = 'update'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is null
        UNION
        SELECT DISTINCT std_id  from ${tableTempName} mt
        SELECT
         ${A2fields}, 'update' as operate, a2.status as status
        from (
        SELECT ${fields} from ${tableName} m
        ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields}, f.status from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on m.flow_id = f.id
        INNER JOIN (
        SELECT max(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.`status` = 'working'
        ) a on a.std_id  = a1.id where a.std_id is null
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and  m.table_name = '${tableName}'
        and operate = 'update'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is not null
        UNION
        SELECT ${tempFields}, 'create' as operate, f.status as status FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo} AND operate = 'create'
        and  maintain.table_name = '${tableName}'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'delete'
            AND mt.std_id = mt1.std_id
            and maintain.table_name = '${tableName}'
        )
        UNION
        SELECT ${tempFields}, 'delete' as operate, f.status as status FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo} AND operate = 'delete'
         and maintain.table_name = '${tableName}'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'create'
            AND mt.std_id = mt1.std_id
            and  maintain.table_name = '${tableName}'
        )
        )a where  ${where} ${limit}

        ]]>
    </select>

@@ -164,15 +204,13 @@
    </select>

    <select id="tempDeal" statementType="STATEMENT" resultType="java.lang.Integer">
         UPDATE ${tableTempName} mt
        INNER JOIN (
        SELECT pre_merge_id from
        maintain_detail
        WHERE maintain_detail.parent_id = ${maintainId}
        )md on mt.id = md.pre_merge_id
        set mt.deal = 1


        UPDATE ${tableTempName} t
        SET deal = 1
        where EXISTS (
        SELECT pre_merge_id from maintain_detail WHERE parent_id = ${maintainId}
        and maintain_detail.pre_merge_id = t.id
        )
        </select>

    <select id="getCount" resultType="java.lang.Long" statementType="STATEMENT">
@@ -181,133 +219,180 @@

    <select id="getCountByVersion" resultType="java.lang.Long" statementType="STATEMENT">
        <![CDATA[
       SELECT count(1)
FROM
    (SELECT ${A1fields}
    FROM ${tableName} a1
        select count(1) from (
        SELECT
         ${A1fields}
        from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          LEFT JOIN flows f on maintain.flow_id = f.id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          and  maintain.table_name = '${tableName}'
          AND f.status = 'open'
          and operate = 'create'
          AND tm.std_id = m.id
          ) ) a1
    LEFT JOIN
        (SELECT DISTINCT mt1.std_id
        FROM ${tableTempName} mt1
        LEFT JOIN maintain_detail md
            ON md.pre_merge_id = mt1.id
        LEFT JOIN maintain m
            ON m.id = md.parent_id
        WHERE m.order_no <= ${fromOrderNo}
                AND m.order_no > ${toOrderNo}
                AND m.table_name = '${tableName}'
                AND (operate = 'create'
                OR operate = 'update') ) v
            ON v.std_id = a1.id
        WHERE v.std_id IS NULL
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT MIN(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on m.flow_id = f.id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and  m.table_name = '${tableName}'
        and operate = 'update'
        AND f.status = 'open'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is null
        UNION
        SELECT ${tempFields}
        FROM
            (SELECT mt.*,
         m.order_no
            FROM ${tableTempName} mt
            LEFT JOIN maintain_detail md
                ON md.pre_merge_id = mt.id
            LEFT JOIN maintain m
                ON md.parent_id = m.id
            WHERE m.order_no <= ${fromOrderNo}
                    AND m.order_no > ${toOrderNo}
                    AND m.table_name = '${tableName}'
                    AND operate = 'update' ) AS a1
            INNER JOIN
                (SELECT std_id,
         min(order_no) AS order_no
                FROM
                    (SELECT mt.id,
         std_id,
         m.order_no
                    FROM ${tableTempName} mt
                    LEFT JOIN maintain_detail md
                        ON md.pre_merge_id = mt.id
                    LEFT JOIN maintain m
                        ON md.parent_id = m.id
                    WHERE m.order_no <= ${fromOrderNo}
                                AND m.order_no > ${toOrderNo}
                            AND m.table_name = '${tableName}'
                            AND operate = 'update'
                            AND NOT EXISTS
                        (SELECT mt1.id
                        FROM ${tableTempName} mt1
                        LEFT JOIN maintain_detail md
                            ON md.pre_merge_id = mt1.id
                        LEFT JOIN maintain m
                            ON m.id = md.parent_id
                        WHERE m.order_no <= ${fromOrderNo}
                                AND m.order_no > ${toOrderNo}
                                AND m.table_name = '${tableName}'
        SELECT
         ${A2fields}
        from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          LEFT JOIN flows f on maintain.flow_id = f.id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
           and maintain.table_name = '${tableName}'
           AND f.status = 'open'
          and operate = 'create'
          AND tm.std_id = m.id
          ) ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT MIN(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on m.flow_id = f.id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo}  and m.table_name = '${tableName}'
        and operate = 'update'
        AND f.status = 'open'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is not null
        UNION
        SELECT ${tempFields} FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
        and  maintain.table_name = '${tableName}'
        AND f.status = 'open'
        AND operate = 'delete'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            LEFT JOIN flows f on maintain.flow_id = f.id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
                                AND operate = 'create'
                                AND mt1.std_id = mt.std_id ) ) AS gz
                        GROUP BY  std_id ) AS zb
                            ON a1.std_id = zb.std_id
                                AND a1.order_no = zb.order_no
                        UNION
                        SELECT DISTINCT ${tempFields}
                        FROM ${tableTempName} a1
                        LEFT JOIN maintain_detail md
                            ON md.pre_merge_id = a1.id
                        LEFT JOIN maintain m
                            ON m.id = md.parent_id
                        LEFT JOIN
                            (SELECT DISTINCT mt1.std_id
                            FROM ${tableTempName} mt1
                            LEFT JOIN maintain_detail md
                                ON md.pre_merge_id = mt1.id
                            LEFT JOIN maintain m
                                ON m.id = md.parent_id
                            WHERE m.order_no <= ${fromOrderNo}
                                    AND m.order_no > ${toOrderNo}
                                    AND m.table_name = '${tableName}'
                                    AND (operate = 'create'
                                    OR operate = 'update') ) zb
                                ON zb.std_id = a1.std_id
                            WHERE zb.std_id is null
                                    AND md.operate = 'delete'
                                    AND m.order_no <= ${fromOrderNo}
                                    AND m.order_no > ${toOrderNo}
                                    AND m.table_name = '${tableName}' ) a
                        WHERE ${where}

            AND f.status = 'open'
            AND mt.std_id = mt1.std_id
            and  maintain.table_name = '${tableName}'
        )
        )a where  ${where}
        ]]>
    </select>

    <select id="getCountByMaxVersion" resultType="java.lang.Long" statementType="STATEMENT">
       <![CDATA[

       select  count(1) from (
       SELECT ${tempFields}, md.operate, f.`status` from ${tableTempName} a1
        LEFT JOIN maintain_detail md on md.pre_merge_id = a1.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.id is null
        UNION
        SELECT  ${tempFields}, md.operate, f.`status` from ${tableTempName} a1
        LEFT JOIN maintain_detail md on md.pre_merge_id = a1.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.`status` = 'working'

        union
        SELECT  ${A1fields}, '', '' from ${tableName} a1
        SELECT
         ${A1fields}, '' as operate, '' as status from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          and  maintain.table_name = '${tableName}'
          AND tm.std_id = m.id
          ) ) a1
        LEFT JOIN
        (
        SELECT DISTINCT std_id from ${tableTempName} mt
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT max(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.id is null
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo}
        and  m.table_name = '${tableName}'
        and operate = 'update'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is null
        UNION
        SELECT DISTINCT std_id  from ${tableTempName} mt
        SELECT
         ${A2fields}, 'update' as operate, a2.status as status
        from (
        SELECT ${fields} from ${tableName} m
        ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields}, f.status from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on m.flow_id = f.id
        INNER JOIN (
        SELECT max(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.`status` = 'working'
        ) a on a.std_id  = a1.id where a.std_id is null
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo}
        and  m.table_name = '${tableName}'
        and operate = 'update'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is not null
        UNION
        SELECT ${tempFields}, 'create' as operate, f.status as status FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
        AND   maintain.table_name = '${tableName}'
        AND operate = 'create'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'delete'
            AND mt.std_id = mt1.std_id
            AND   maintain.table_name = '${tableName}'
        )
        UNION
        SELECT ${tempFields}, 'delete' as operate, f.status as status FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
         AND   maintain.table_name = '${tableName}'
         AND operate = 'delete'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'create'
            AND mt.std_id = mt1.std_id
            and  maintain.table_name = '${tableName}'
        )
        )a where  ${where}

        ]]>
    </select>

@@ -342,8 +427,10 @@


    <delete id="deleteTempByMaintainId">
        DELETE tm FROM ${tableTempName} tm , maintain_detail md WHERE tm.id = md.pre_merge_id
        and md.parent_id = ${maintainId};
        DELETE FROM ${tableTempName}  where EXISTS (
        SELECT pre_merge_id from maintain_detail d
        where parent_id = ${maintainId} and d.pre_merge_id = ${tableTempName}.id
        )
    </delete>

    <!-- temp 2 standrad-->
@@ -352,9 +439,15 @@
        SELECT
        ${tempFields}
         from ${tableTempName} t
         inner join maintain_detail md on t.id = md.pre_merge_id
         where  md.parent_id = ${maintainId} and md.operate = 'create'

         where
         EXISTS
        (
        SELECT  std_id from ${tableTempName} tm
        LEFT JOIN maintain_detail on tm.id = maintain_detail.pre_merge_id
        WHERE maintain_detail.parent_id = ${maintainId}
        and operate = 'create'
        and tm.id = t.id
        )
    </insert>

    <select id="getTempIdByStdId" statementType="STATEMENT" resultType="java.lang.String">
@@ -398,10 +491,15 @@
        SELECT
        ${fields}
        from ${tableTempName} t
        inner join maintain_detail md on md.pre_merge_id = t.id
        where md.parent_id = ${maintainId}
        where
        EXISTS
        (
        SELECT  pre_merge_id from maintain_detail
        LEFT JOIN maintain on maintain.id = maintain_detail.parent_id
        WHERE maintain.id = ${maintainId}
        and operate = ${operate}

        and maintain_detail.pre_merge_id = t.id
        )
    </select>

    <update id="updateRecordByMaintainId" statementType="STATEMENT">
@@ -430,30 +528,34 @@

    <select id="getOneTempFieldDataByMaintainExtent" statementType="STATEMENT" resultType="java.util.Map">
         <![CDATA[

        SELECT DISTINCT ${field} FROM  ${tempTableName} t
        LEFT JOIN maintain_detail md on md.pre_merge_id = t.id
        LEFT JOIN maintain m on m.id = md.parent_id

        SELECT DISTINCT ${field} FROM  ${tempTableName} t  WHERE  EXISTS (
          SELECT pre_merge_id  FROM ( SELECT  pre_merge_id FROM  maintain_detail  WHERE EXISTS (
            SELECT  id  FROM  ( SELECT  id  FROM  `maintain`  WHERE
              table_name = ${tableName}
              AND order_no >= ${fromOrderNo}
              AND order_no <  ${toOrderNo}
              ) a
        WHERE
         m.table_name = ${tableName}
         AND m.order_no >= ${fromOrderNo}
         AND m.order_no <  ${toOrderNo}
            a.id = maintain_detail.parent_id  )
          ) a
        WHERE t.id = a.pre_merge_id)

        ]]>
    </select>

    <select id="getTempDataByMaintainExtent" statementType="STATEMENT" resultType="java.util.Map">
        <![CDATA[
     SELECT  t.* FROM  ${tempTableName} t
            LEFT JOIN maintain_detail md on md.pre_merge_id = t.id
            LEFT JOIN maintain m on m.id = md.parent_id

        SELECT *  FROM  ${tempTableName} t  WHERE  EXISTS (
          SELECT pre_merge_id  FROM ( SELECT  pre_merge_id FROM  maintain_detail  WHERE EXISTS (
            SELECT  id  FROM  ( SELECT  id  FROM  `maintain`  WHERE
              table_name = ${tableName}
              AND order_no >= ${fromOrderNo}
              AND order_no <  ${toOrderNo}
              ) a
            WHERE
             m.table_name = ${tableName}
             AND m.order_no >= ${fromOrderNo}
             AND m.order_no <  ${toOrderNo}

            a.id = maintain_detail.parent_id  )
          ) a
        WHERE t.id = a.pre_merge_id)

        ]]>
    </select>