commit udpate

许鹏程

2024-08-15 112f25b820aea7b0487197d1516974589d1d9979

commit udpate

 src/main/java/com/product/data/config/CmnConst.java

@@ -7,47 +7,50 @@
 */
public class CmnConst {

    //公共常量定义
    public static final String ID = "id"; // id   è‡ªå¢žä¸»é”®
    public static final String UUID = "uuid";                                    //uuid
    public static final String USER_ID = "user_id"; // ç”¨æˆ·id
    public static final String UPDATED_BY = "updated_by";                        //创建者
    public static final String UPDATED_UTC_DATETIME = "updated_utc_datetime";    //创建时间
    public static final String CREATED_BY = "created_by";                        //创建者
    public static final String CREATED_UTC_DATETIME = "created_utc_datetime";    //创建时间
    public static final String ORG_LEVEL_UUID = "org_level_uuid";    //创建时间
    public static final String ORG_LEVEL_CODE = "org_level_code";    //创建时间
    //公共常量定义
    public static final String ID = "id"; // id   è‡ªå¢žä¸»é”®
    public static final String UUID = "uuid";                                    //uuid
    public static final String USER_ID = "user_id"; // ç”¨æˆ·id
    public static final String UPDATED_BY = "updated_by";                        //创建者
    public static final String UPDATED_UTC_DATETIME = "updated_utc_datetime";    //创建时间
    public static final String CREATED_BY = "created_by";                        //创建者
    public static final String CREATED_UTC_DATETIME = "created_utc_datetime";    //创建时间
    public static final String ORG_LEVEL_UUID = "org_level_uuid";    //创建时间
    public static final String ORG_LEVEL_CODE = "org_level_code";    //创建时间


    public static final String TABLE_NAME = "table_name";    //表名
    public static final String TABLE_UUID = "table_uuid";    //表名
    public static final String TABLE_TYPE = "table_type";    //表名
    public static final String TABLE_DESCRIPTION = "table_description";    //表名
    public static final String TABLE_NAME = "table_name";    //表名
    public static final String TABLE_UUID = "table_uuid";    //表名
    public static final String TABLE_TYPE = "table_type";    //表名
    public static final String TABLE_DESCRIPTION = "table_description";    //表名

    public static final String BASIC_TABLE = "basic_table";    //基础表
    public static final String BASIC_TABLE = "basic_table";    //基础表


    public static final String FIELD_NAME = "field_name";    //字段名称
    public static final String FIELD_NAME = "field_name";    //字段名称

    public static final String FIELD_TYPE = "field_type";    //字段名称
    public static final String FIELD_TYPE = "field_type";    //字段名称

    public static final String TARGET_TABLE = "target_table";    //字段名称
    public static final String TARGET_TABLE = "target_table";    //字段名称

    public static final String SOURCE_TABLE = "source_table";    //字段名称
    public static final String SOURCE_TABLE = "source_table";    //字段名称

    public static final String TABLE_MODULE_TABLE = "product_sys_datamodel_table";
    public static final String TABLE_MODULE_TABLE = "product_sys_datamodel_table";

    public static final String TABLE_MODULE_FIELD = "product_sys_datamodel_field";
    public static final String TABLE_MODULE_FIELD = "product_sys_datamodel_field";

    public static final String TABLE_SYNC_MANAGER = "product_sys_data_sync_manager";
    public static final String TABLE_SYNC_MANAGER = "product_sys_data_sync_manager";

    public static final String TABLE_SYNC_MANAGER_SUB = "product_sys_data_sync_manager_sub";
    public static final String TABLE_SYNC_MANAGER_SUB = "product_sys_data_sync_manager_sub";

    public static final String PRODUCT_SYS_DATABASE_TABLENAME_FIELD = "product_sys_database_tablename_field";
    public static final String PRODUCT_SYS_DATABASE_TABLENAME_FIELD = "product_sys_database_tablename_field";

    public static final String TABLE_SYNC_MANAGER_FIELD = "product_sys_data_sync_manager_field";
    public static final String TABLE_SYNC_MANAGER_FIELD = "product_sys_data_sync_manager_field";

    public static final String TABLE_SYNC_MANAGER_LOG = "product_sys_data_sync_manager_log";
    public static final String TABLE_SYNC_MANAGER_LOG = "product_sys_data_sync_manager_log";

    public static final String TABLE_PROCESS_CONFIG = "product_sys_database_sync_processing_config";
    public static final String TABLE_PROCESS_CONFIG = "product_sys_database_sync_processing_config";

    public static final String TABLE_PRODUCT_SYS_DATASOURCE_CONFIG = "product_sys_datasource_config";
    public static final String TABLE_PRODUCT_SYS_DATASOURCE_CONFIG_FIELD = "product_sys_datasource_config_field";
}

 src/main/java/com/product/data/config/ErrorCode.java

@@ -9,77 +9,82 @@
 * @Desc é”™è¯¯æžšä¸¾ç±»
 */
public enum ErrorCode implements IEnum {
    SYSTEM_OPERATION_SUCCESS("成功", "200"),
    SYSTEM_FORM_COUNT("请求参数有误", "998"),
    SYSTEM_TABLE_NODATA("请求表名有误", "997"),
    SYSTEM_ACQUIRE_PARAM_FAIL("获取参数失败", "996"),
    SYSTEM_CPAGES_NOT_NULL("分页参数不能为空", "995"),
    SYSTEM_FORM_NODATA("请求参数为空", ModuleEnum.ORGSYSTEM.getValue() + "001"),
    GET_CONNECTION_FAIL("获取数据库连接失败", "001"),
    UNKNOWN_DATABASE_TYPE("不能识别的数据库类型", "002"),
    GET_ORACLE_SID_SERVERNAME_EMPTY("获取ORACLE数据库SID和SERVERNAME不能同时为空", "003"),
    SAVE_SYNC_CONNECTION_FAIL("保存同步数据连接配置失败", "004"),
    SAVE_SYNC_TABLE_FAIL("保存同步数据失败", "005"),
    GET_RESULTSET_COLUMN_COUNT_FAIL("获取数据集列数量错误", "006"),
    GET_RESULTSET_COLUMN_NAME_FAIL("获取数据集列名错误", "007"),
    CRATED_TIMED_TASK_FAIL("创建数据同步定时任务失败", "008"),
    SAVE_SYNC_TASK_FIELD_INFO_EMPTY("保存同步数据任务失败，同步字段不能为空", "009"),
    SYNC_DATA_UNIQUE_FIELD_NOT_EXIST("同步数据唯一标识字段不存在，请指定唯一标识字段", "010"),
    SYNC_DATA_INCREMENTAL_FIELD_NOT_EXIST("同步数据增量标识字段不存在，请指定增量标识字段", "011"),
    SYNC_DATA_EXECUTE_TASK_TARGET_NOT_EXIST("同步数据执行任务目标不存在", "012"),
    SYNC_DATA_CONNECTION_FIND_FAIL("同步数据连接配置获取失败", "013"),
    GET_TABLE_CACHE_FAIL("获取系统表失败，表不存在", "014"),
    GET_FIELD_CACHE_FAIL("获取系统表字段失败，字段不存在", "015"),
    SYNC_DATA_TARGET_FIELD_NOT_EXIST("同步目标表字段不存在", "016"),
    GET_CONNECTION_TIME_FAIL("获取连接时间失败", "016"),
    GET_TARGET_TABLE_PK_VALUE_FAIL("获取目标表最大主键值失败", "016"),
    GET_SAVE_BEFORE_BEAN_FAIL("获取保存前bean错误", "017"),
    GET_SAVE_BEFORE_METHOD_FAIL("获取保存前method错误", "018"),
    EXECUTE_BEFORE_SAVE_ERROR("执行保存前方法错误", "019"),
    GET_PREV_SYNC_END_TIME_FAIL("获取上一次同步结束时间失败", "020"),
    EXECUTE_SYNC_DATA_TASK_FAIL("执行同步数据任务失败", "021"),
    GET_SYNC_TARGET_TABLE_MAX_INCREMENT_VALUE_FAIL("获取同步目标表最大增量值失败", "022"),
    GET_SYNC_TARGET_UPDATE_MAX_VALUE_FAIL("获取更新标识字段最大值失败", "022"),
    SYNC_DATA_AFTER_PROCESS_SERVICE_INIT_FAIL("同步数据后处理失败，执行Service初始化失败", "023"),
    SYNC_DATA_AFTER_PROCESS_TARGET_TABLE_EMPTY("同步数据后处理失败，目标表名不能为空", "024"),
    SYNC_DATA_AFTER_PROCESS_QUERY_RESULT_FAIL_EMPTY("同步数据后处理失败，查询结果字段信息不能为空", "024"),
    SAVE_DATA_PROCESS_TABLE_NOT_EXISTS("保存同步数据处理配置失败，数据表不存在", "025"),
    FIND_SYNC_PROCESS_DATA_CONFIG_FAIL("获取同步数据处理配置失败", "026"),
    SAVE_SYNC_PROCESS_DATA_CONFIG_FAIL("保存同步数据处理配置失败", "026"),
    RESULT_COLUMN_EXISTS_SAME_FILED("结果列中不能包含名称为 \"{{fieldName}}\" çš„列", "026"),
    SYNC_FIELD_COLUMN_EXISTS_SAME_FIELD("同步字段列中不能包含名称为 \"{{fieldName}}\" çš„列", "027"),
    FIND_SYNC_TABLE_FAIL("查询同步数据失败", "028"),
    INCREMENTAL_UPDATE_CAN_NOT_SAME_FIELD("增量更新标识不能是同一字段", "029"),
    SYSTEM_OPERATION_SUCCESS("成功", "200"),
    SYSTEM_FORM_COUNT("请求参数有误", "998"),
    SYSTEM_TABLE_NODATA("请求表名有误", "997"),
    SYSTEM_ACQUIRE_PARAM_FAIL("获取参数失败", "996"),
    SYSTEM_CPAGES_NOT_NULL("分页参数不能为空", "995"),
    SYSTEM_FORM_NODATA("请求参数为空", ModuleEnum.ORGSYSTEM.getValue() + "001"),
    GET_CONNECTION_FAIL("获取数据库连接失败", "001"),
    UNKNOWN_DATABASE_TYPE("不能识别的数据库类型", "002"),
    GET_ORACLE_SID_SERVERNAME_EMPTY("获取ORACLE数据库SID和SERVERNAME不能同时为空", "003"),
    SAVE_SYNC_CONNECTION_FAIL("保存同步数据连接配置失败", "004"),
    SAVE_SYNC_TABLE_FAIL("保存同步数据失败", "005"),
    GET_RESULTSET_COLUMN_COUNT_FAIL("获取数据集列数量错误", "006"),
    GET_RESULTSET_COLUMN_NAME_FAIL("获取数据集列名错误", "007"),
    CRATED_TIMED_TASK_FAIL("创建数据同步定时任务失败", "008"),
    SAVE_SYNC_TASK_FIELD_INFO_EMPTY("保存同步数据任务失败，同步字段不能为空", "009"),
    SYNC_DATA_UNIQUE_FIELD_NOT_EXIST("同步数据唯一标识字段不存在，请指定唯一标识字段", "010"),
    SYNC_DATA_INCREMENTAL_FIELD_NOT_EXIST("同步数据增量标识字段不存在，请指定增量标识字段", "011"),
    SYNC_DATA_EXECUTE_TASK_TARGET_NOT_EXIST("同步数据执行任务目标不存在", "012"),
    SYNC_DATA_CONNECTION_FIND_FAIL("同步数据连接配置获取失败", "013"),
    GET_TABLE_CACHE_FAIL("获取系统表失败，表不存在", "014"),
    GET_FIELD_CACHE_FAIL("获取系统表字段失败，字段不存在", "015"),
    SYNC_DATA_TARGET_FIELD_NOT_EXIST("同步目标表字段不存在", "016"),
    GET_CONNECTION_TIME_FAIL("获取连接时间失败", "016"),
    GET_TARGET_TABLE_PK_VALUE_FAIL("获取目标表最大主键值失败", "016"),
    GET_SAVE_BEFORE_BEAN_FAIL("获取保存前bean错误", "017"),
    GET_SAVE_BEFORE_METHOD_FAIL("获取保存前method错误", "018"),
    EXECUTE_BEFORE_SAVE_ERROR("执行保存前方法错误", "019"),
    GET_PREV_SYNC_END_TIME_FAIL("获取上一次同步结束时间失败", "020"),
    EXECUTE_SYNC_DATA_TASK_FAIL("执行同步数据任务失败", "021"),
    GET_SYNC_TARGET_TABLE_MAX_INCREMENT_VALUE_FAIL("获取同步目标表最大增量值失败", "022"),
    GET_SYNC_TARGET_UPDATE_MAX_VALUE_FAIL("获取更新标识字段最大值失败", "022"),
    SYNC_DATA_AFTER_PROCESS_SERVICE_INIT_FAIL("同步数据后处理失败，执行Service初始化失败", "023"),
    SYNC_DATA_AFTER_PROCESS_TARGET_TABLE_EMPTY("同步数据后处理失败，目标表名不能为空", "024"),
    SYNC_DATA_AFTER_PROCESS_QUERY_RESULT_FAIL_EMPTY("同步数据后处理失败，查询结果字段信息不能为空", "024"),
    SAVE_DATA_PROCESS_TABLE_NOT_EXISTS("保存同步数据处理配置失败，数据表不存在", "025"),
    FIND_SYNC_PROCESS_DATA_CONFIG_FAIL("获取同步数据处理配置失败", "026"),
    SAVE_SYNC_PROCESS_DATA_CONFIG_FAIL("保存同步数据处理配置失败", "026"),
    RESULT_COLUMN_EXISTS_SAME_FILED("结果列中不能包含名称为 \"{{fieldName}}\" çš„列", "026"),
    SYNC_FIELD_COLUMN_EXISTS_SAME_FIELD("同步字段列中不能包含名称为 \"{{fieldName}}\" çš„列", "027"),
    FIND_SYNC_TABLE_FAIL("查询同步数据失败", "028"),
    INCREMENTAL_UPDATE_CAN_NOT_SAME_FIELD("增量更新标识不能是同一字段", "029"),

    NONSUPPORT_DATABASE_TYPE("不支持的数据库类型", "030"),
    ;
    NONSUPPORT_DATABASE_TYPE("不支持的数据库类型", "030"),

    private String errorMsg;

    private String errorCode;
    SAVE_DATASOURCE_CONFIG_SAVE_FAIL("保存数据源配置失败", "031"),

    ErrorCode(String errorMsg, String errorCode) {
        this.errorMsg = errorMsg;
        this.errorCode = errorCode;
    }

    /**
     * èŽ·å–枚举类型实例要显示的文本。
     *
     * @return è¿”回枚举类型实例的文本。
     */
    @Override
    public String getText() {
        return this.errorMsg;
    }
    ;

    /**
     * èŽ·å–枚举类型实例的值。
     *
     * @return è¿”回枚举类型实例的值。
     */
    @Override
    public String getValue() {
        return ModuleEnum.DATA.getValue() + this.errorCode;
    }
    private String errorMsg;

    private String errorCode;

    ErrorCode(String errorMsg, String errorCode) {
        this.errorMsg = errorMsg;
        this.errorCode = errorCode;
    }

    /**
     * èŽ·å–枚举类型实例要显示的文本。
     *
     * @return è¿”回枚举类型实例的文本。
     */
    @Override
    public String getText() {
        return this.errorMsg;
    }

    /**
     * èŽ·å–枚举类型实例的值。
     *
     * @return è¿”回枚举类型实例的值。
     */
    @Override
    public String getValue() {
        return ModuleEnum.DATA.getValue() + this.errorCode;
    }
}

 src/main/java/com/product/data/controller/DataSourceConfigController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,50 @@
package com.product.data.controller;

import com.product.core.entity.FieldSetEntity;
import com.product.core.exception.BaseException;
import com.product.data.config.CmnConst;
import com.product.data.config.ErrorCode;
import com.product.data.service.impl.IDataSourceConfigService;
import com.product.module.sys.version.ApiVersion;
import com.product.util.BaseUtil;
import com.product.util.support.AbstractBaseController;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

/**
 * @Author cheng
 * @Date 2024/8/13 18:18
 * @Desc æ•°æ®æºé…ç½®
 */
@RequestMapping("/data-center/datasource-config")
@RestController
public class DataSourceConfigController extends AbstractBaseController {

    @Resource
    private IDataSourceConfigService dataSourceConfigService;

    @PostMapping("/save/{version}")
    @ApiVersion(1)
    public String saveConfig(HttpServletRequest request) {

        try {
            FieldSetEntity fse = BaseUtil.getFieldSetEntity(request, CmnConst.TABLE_PRODUCT_SYS_DATASOURCE_CONFIG);
            IDataSourceConfigService service = (IDataSourceConfigService) getProxyInstance(dataSourceConfigService);
            service.save(fse);
            return OK();
        } catch (BaseException e) {
            e.printStackTrace();
            return error(e);
        } catch (Exception e) {
            e.printStackTrace();
            return error(ErrorCode.SAVE_DATASOURCE_CONFIG_SAVE_FAIL, e);
        }
    }


}

 src/main/java/com/product/data/entity/DatabaseEntity.java

@@ -2,6 +2,7 @@

import com.product.common.lang.StringUtils;
import com.product.core.entity.FieldSetEntity;
import com.product.data.config.CmnConst;
import com.product.data.config.DatabaseType;

/**
@@ -11,174 +12,184 @@
 */
public class DatabaseEntity {

    private Class<?> DbTypeBase;
    private Class<?> DbTypeBase;

    private int DbType;
    private int DbType;

    private String userName;
    private String userName;

    private String passWord;
    private String passWord;

    private String ip;
    private String ip;

    private String port;
    private String port;

    private String DbName;
    /**
     * å®žä¾‹å
     * mysql oracle æ— ç”¨
     */
    private String DbInstance;
    private String DbName;
    /**
     * å®žä¾‹å
     * mysql oracle æ— ç”¨
     */
    private String DbInstance;

    /**
     * è‡ªå®šä¹‰å‚æ•°
     * sqlserver oracle æ— ç”¨
     */
    private String customParams;
    /**
     * è‡ªå®šä¹‰å‚æ•°
     * sqlserver oracle æ— ç”¨
     */
    private String customParams;

    /**
     * ä»…Oracle使用
     */
    private String serverName;
    /**
     * ä»…Oracle使用
     */
    private String serverName;


    /**
     * ä»…Oracle使用
     */
    private String sid;
    /**
     * ä»…Oracle使用
     */
    private String sid;

    public String getServerName() {
        return serverName;
    }
    public String getServerName() {
        return serverName;
    }

    public void setServerName(String serverName) {
        this.serverName = serverName;
    }
    public void setServerName(String serverName) {
        this.serverName = serverName;
    }

    public String getSid() {
        return sid;
    }
    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }
    public void setSid(String sid) {
        this.sid = sid;
    }

    public DatabaseEntity(int dbType) {
        DbType = dbType;
    }
    public DatabaseEntity(int dbType) {
        DbType = dbType;
    }

    @Override
    public String toString() {
        return "DatabaseEntity{" +
                "DbType=" + DbType == null ? null : getDbType().getValue() +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", ip='" + ip + '\'' +
                ", port='" + port + '\'' +
                ", DbName='" + DbName + '\'' +
                ", DbInstance='" + DbInstance + '\'' +
                ", customParams='" + customParams + '\'' +
                ", serverName='" + serverName + '\'' +
                ", sid='" + sid + '\'' +
                '}';
    }
    @Override
    public String toString() {
        return "DatabaseEntity{" +
                "DbType=" + DbType == null ? null : getDbType().getValue() +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", ip='" + ip + '\'' +
                ", port='" + port + '\'' +
                ", DbName='" + DbName + '\'' +
                ", DbInstance='" + DbInstance + '\'' +
                ", customParams='" + customParams + '\'' +
                ", serverName='" + serverName + '\'' +
                ", sid='" + sid + '\'' +
                '}';
    }


    public DatabaseEntity(FieldSetEntity fse) {
        this.DbTypeBase = DatabaseType.class;
        init(fse);
    }
    public DatabaseEntity(FieldSetEntity fse) {
        this.DbTypeBase = DatabaseType.class;
        init(fse);
    }

    protected void init(FieldSetEntity fse) {
        DbType = fse.getInteger("db_type");
        userName = fse.getString("user_name");
        passWord = fse.getString("pass_word");
        ip = fse.getString("ip");
        port = fse.getString("port");
        DbName = StringUtils.isEmpty(fse.getString("db_name")) ? fse.getString("user_name") : fse.getString("db_name");
        serverName = fse.getString("server_name");
        sid = fse.getString("sid");
        customParams = fse.getString("custom_params");
        DbInstance = fse.getString("instance");
    }
    protected void init(FieldSetEntity fse) {
        if (CmnConst.TABLE_PRODUCT_SYS_DATASOURCE_CONFIG.equals(fse.getTableName())) {
            DbType = fse.getInteger("datasource_type");
            userName = fse.getString("username");
            passWord = fse.getString("password");
            ip = fse.getString("ip_address");
            port = fse.getString("database_port");
            customParams = fse.getString("link_params");
            DbInstance = fse.getString("instance_name");
            return;
        }
        DbType = fse.getInteger("db_type");
        userName = fse.getString("user_name");
        passWord = fse.getString("pass_word");
        ip = fse.getString("ip");
        port = fse.getString("port");
        DbName = StringUtils.isEmpty(fse.getString("db_name")) ? fse.getString("user_name") : fse.getString("db_name");
        serverName = fse.getString("server_name");
        sid = fse.getString("sid");
        customParams = fse.getString("custom_params");
        DbInstance = fse.getString("instance");
    }

    public String getCustomParams() {
    public String getCustomParams() {

        if (this.getDbType().equals(DatabaseType.MySql) && !StringUtils.isEmpty(this.customParams)) {
            if (!"?".equals(this.customParams.substring(1))) {
                return "?" + this.customParams;
            }
        }
        return customParams == null ? "" : this.customParams;
    }
        if (this.getDbType().equals(DatabaseType.MySql) && !StringUtils.isEmpty(this.customParams)) {
            if (!"?".equals(this.customParams.substring(1))) {
                return "?" + this.customParams;
            }
        }
        return customParams == null ? "" : this.customParams;
    }

    public int getDbTypeByInt() {
        return this.DbType;
    }
    public int getDbTypeByInt() {
        return this.DbType;
    }

    public String getOnlyKey() {
        String[] params = {DbType + "", ip, port, DbName, serverName, sid, DbInstance};
        StringBuilder str = new StringBuilder();
        for (String param : params) {
            str.append(param == null ? "" : param).append("-");
        }
        return str.toString();
    }
    public String getOnlyKey() {
        String[] params = {DbType + "", ip, port, DbName, serverName, sid, DbInstance};
        StringBuilder str = new StringBuilder();
        for (String param : params) {
            str.append(param == null ? "" : param).append("-");
        }
        return str.toString();
    }


    public void setCustomParams(String customParams) {
        this.customParams = customParams;
    }
    public void setCustomParams(String customParams) {
        this.customParams = customParams;
    }

    public DatabaseType getDbType() {
        return DatabaseType.getDataBaseType(this.DbType);
    }
    public DatabaseType getDbType() {
        return DatabaseType.getDataBaseType(this.DbType);
    }

    public String getUserName() {
        return userName;
    }
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }
    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public String getIp() {
        return ip;
    }
    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }
    public void setIp(String ip) {
        this.ip = ip;
    }

    public String getDbName() {
        return DbName;
    }
    public String getDbName() {
        return DbName;
    }

    public void setDbName(String dbName) {
        DbName = dbName;
    }
    public void setDbName(String dbName) {
        DbName = dbName;
    }

    public String getDbInstance() {
        return DbInstance;
    }
    public String getDbInstance() {
        return DbInstance;
    }

    public void setDbInstance(String dbInstance) {
        DbInstance = dbInstance;
    }
    public void setDbInstance(String dbInstance) {
        DbInstance = dbInstance;
    }

    public String getPort() {
        return port;
    }
    public String getPort() {
        return port;
    }

    public void setPort(String port) {
        this.port = port;
    }
    public void setPort(String port) {
        this.port = port;
    }
}

 src/main/java/com/product/data/service/DataSourceConfigService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,87 @@
package com.product.data.service;

import cn.hutool.core.lang.UUID;
import com.product.admin.service.PublicService;
import com.product.common.lang.StringUtils;
import com.product.core.dao.BaseDao;
import com.product.core.entity.DataTableEntity;
import com.product.core.entity.FieldSetEntity;
import com.product.core.exception.BaseException;
import com.product.core.service.support.AbstractBaseService;
import com.product.data.config.CmnConst;
import com.product.data.config.DatabaseType;
import com.product.data.connection.ConnectionManager;
import com.product.data.entity.DatabaseEntity;
import com.product.data.service.impl.IDataSourceConfigService;
import com.product.data.utli.QueryDataService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.sql.Connection;
import java.util.List;
import java.util.Map;

/**
 * @Author cheng
 * @Date 2024/8/13 18:20
 * @Desc æ•°æ®æºé…ç½®ä¸šåŠ¡å±‚
 */
@Service
public class DataSourceConfigService extends AbstractBaseService implements IDataSourceConfigService {


    @Resource
    private SyncDataConfigService syncDataConfigService;
    @Resource
    private PublicService publicService;

    @Override
    public void save(FieldSetEntity fse) throws BaseException {
        DatabaseEntity dbe = new DatabaseEntity(fse);
        String uuid = fse.getUUID();
        if (StringUtils.isEmpty(uuid)) {
            fse.setValue("~type~", "add");
            fse.setValue("uuid", UUID.randomUUID().toString());
            uuid = fse.getUUID();
        }
        String finalUuid = uuid;
        try (Connection connection = ConnectionManager.getConnection(dbe)) {
            if (connection != null) {
                QueryDataService queryDataService = new QueryDataService(connection);
                String[] tableName = syncDataConfigService.getTableName(queryDataService, dbe);
                if ((tableName != null && tableName.length > 0) || DatabaseType.PSQL.equals(dbe.getDbType()) || DatabaseType.Oracle.equals(dbe.getDbType())) {
                    Map<String, String> fieldTypeReference = syncDataConfigService.getFieldTypeReference(dbe.getDbType());
                    DataTableEntity dt = new DataTableEntity();
                    if (DatabaseType.Oracle.equals(dbe.getDbType())) {
                        Map<String, List<Map<String, Object>>> tableFieldMap = syncDataConfigService.getOracleFieldInfo(queryDataService);
                        tableFieldMap.forEach((k, v) -> {
                            syncDataConfigService.getFieldName(CmnConst.TABLE_PRODUCT_SYS_DATASOURCE_CONFIG_FIELD, queryDataService, k, dbe, finalUuid, dt, fieldTypeReference, v);
                        });
                    } else if (DatabaseType.PSQL.equals(dbe.getDbType())) {
                        Map<String, List<Map<String, Object>>> pSqlFieldInfo = syncDataConfigService.getPSqlFieldInfo(dbe.getDbInstance(), queryDataService);
                        pSqlFieldInfo.forEach((k, v) -> {
                            syncDataConfigService.getFieldName(CmnConst.TABLE_PRODUCT_SYS_DATASOURCE_CONFIG_FIELD, queryDataService, k, dbe, finalUuid, dt, fieldTypeReference, v);
                        });
                    } else {
                        for (String table : tableName) {
                            syncDataConfigService.getFieldName(CmnConst.TABLE_PRODUCT_SYS_DATASOURCE_CONFIG_FIELD, queryDataService, table, dbe, finalUuid, dt, fieldTypeReference, null);
                        }
                    }
                    if (!DataTableEntity.isEmpty(dt)) {
                        fse.addSubDataTable(dt);
                    }
                }
                getBaseDao().saveFieldSetEntity(fse);
            }
        } catch (BaseException e) {
            throw e;
        } catch (Exception e) {
            throw new BaseException(e);
        }
    }

    @Override
    public void delete(FieldSetEntity fse) throws BaseException {
        publicService.delete(fse);
    }
}

 src/main/java/com/product/data/service/SyncDataConfigService.java

@@ -42,915 +42,922 @@
@Service
public class SyncDataConfigService extends AbstractBaseService implements ISyncDataConfigService {

    @Autowired
    SysJobService sysJobService;
    @Autowired
    SysJobService sysJobService;

    @Autowired
    DataModelService dataModelService;
    @Autowired
    DataModelService dataModelService;

    @Autowired(required = false)
    IRemoteService remoteService;
    @Autowired(required = false)
    IRemoteService remoteService;


    public FieldSetEntity findSyncTaskDetail(String uuid) {
        FieldSetEntity fse = getBaseDao().getFieldSetEntity(CmnConst.TABLE_SYNC_MANAGER_SUB, uuid, false);
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT ");
        sql.append(" uuid, source_field,a.field_type field_tag,target_field,master_uuid,b.* ");
        sql.append(" FROM ");
        sql.append(" product_sys_data_sync_manager_field a ");
        sql.append(" JOIN ( ");
        sql.append(" SELECT ");
        sql.append(" `field`.uuid field_uuid, ");
        sql.append(" table_name, ");
        sql.append(" `table`.uuid table_uuid, ");
        sql.append(" field_name, ");
        sql.append(" field_description, ");
        sql.append(" field_show_name, ");
        sql.append(" field_type, ");
        sql.append(" field_unit, ");
        sql.append(" field_length, ");
        sql.append(" is_filter, ");
        sql.append(" field_reference ");
        sql.append(" FROM ");
        sql.append(" product_sys_datamodel_table `table` ");
        sql.append(" JOIN product_sys_datamodel_field `field` ON `table`.uuid = `field`.table_uuid ");
        sql.append(" ) b ON a.master_uuid=? and  b.table_name=? and  a.target_field = b.field_name ");
        DataTableEntity dt = getBaseDao().listTable(sql.toString(), new Object[]{fse.getUUID(), fse.getString(CmnConst.TARGET_TABLE)});
        dt.getMeta().setTableName(new Object[]{CmnConst.TABLE_SYNC_MANAGER_FIELD});
        fse.addSubDataTable(dt);
        fse.addSubDataTable(getBaseDao().listTable(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX, "table_uuid=?", new Object[]{dt.getString(0, CmnConst.TABLE_UUID)}));
        return fse;
    }
    public FieldSetEntity findSyncTaskDetail(String uuid) {
        FieldSetEntity fse = getBaseDao().getFieldSetEntity(CmnConst.TABLE_SYNC_MANAGER_SUB, uuid, false);
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT ");
        sql.append(" uuid, source_field,a.field_type field_tag,target_field,master_uuid,b.* ");
        sql.append(" FROM ");
        sql.append(" product_sys_data_sync_manager_field a ");
        sql.append(" JOIN ( ");
        sql.append(" SELECT ");
        sql.append(" `field`.uuid field_uuid, ");
        sql.append(" table_name, ");
        sql.append(" `table`.uuid table_uuid, ");
        sql.append(" field_name, ");
        sql.append(" field_description, ");
        sql.append(" field_show_name, ");
        sql.append(" field_type, ");
        sql.append(" field_unit, ");
        sql.append(" field_length, ");
        sql.append(" is_filter, ");
        sql.append(" field_reference ");
        sql.append(" FROM ");
        sql.append(" product_sys_datamodel_table `table` ");
        sql.append(" JOIN product_sys_datamodel_field `field` ON `table`.uuid = `field`.table_uuid ");
        sql.append(" ) b ON a.master_uuid=? and  b.table_name=? and  a.target_field = b.field_name ");
        DataTableEntity dt = getBaseDao().listTable(sql.toString(), new Object[]{fse.getUUID(), fse.getString(CmnConst.TARGET_TABLE)});
        dt.getMeta().setTableName(new Object[]{CmnConst.TABLE_SYNC_MANAGER_FIELD});
        fse.addSubDataTable(dt);
        fse.addSubDataTable(getBaseDao().listTable(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX, "table_uuid=?", new Object[]{dt.getString(0, CmnConst.TABLE_UUID)}));
        return fse;
    }


    /**
     * åˆ é™¤åŒæ­¥è¡¨é…ç½®
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    @Transactional
    @Override
    public void delSyncTableConfig(FieldSetEntity fse) throws BaseException, SchedulerException {
        Object[] params = new Object[]{fse.getUUID()};
        getBaseDao().delete(fse.getTableName(), params);
        //查询同步配置相关的定时任务并删除
        FieldSetEntity timeTaskFieldSet = getBaseDao().getFieldSetEntityBySQL(
                "SELECT * FROM product_sys_timed_task WHERE uuid= (SELECT time_task_uuid from product_sys_data_sync_manager_sub where uuid =?)", params, false);
        if (timeTaskFieldSet != null) {
            sysJobService.deleteJob(timeTaskFieldSet);
        }
    }
    /**
     * åˆ é™¤åŒæ­¥è¡¨é…ç½®
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    @Transactional
    @Override
    public void delSyncTableConfig(FieldSetEntity fse) throws BaseException, SchedulerException {
        Object[] params = new Object[]{fse.getUUID()};
        getBaseDao().delete(fse.getTableName(), params);
        //查询同步配置相关的定时任务并删除
        FieldSetEntity timeTaskFieldSet = getBaseDao().getFieldSetEntityBySQL(
                "SELECT * FROM product_sys_timed_task WHERE uuid= (SELECT time_task_uuid from product_sys_data_sync_manager_sub where uuid =?)", params, false);
        if (timeTaskFieldSet != null) {
            sysJobService.deleteJob(timeTaskFieldSet);
        }
    }


    /**
     * æ“ä½œè¡¨
     *
     * @param fse
     * @throws BaseException
     */
    private FieldSetEntity operationTable(FieldSetEntity fse, boolean update) throws BaseException {
        FieldSetEntity table = new FieldSetEntity();
        table.setTableName(CmnConst.TABLE_MODULE_TABLE);
        // è¡¨å
        table.setValue(CmnConst.TABLE_NAME, fse.getString(CmnConst.TARGET_TABLE));
        // è¡¨ç±»åž‹
        table.setValue(CmnConst.TABLE_TYPE, 1);
        table.setValue("sequence", 1);
        table.setValue(CmnConst.TABLE_DESCRIPTION, "数据库同步表，来源表:" + fse.getString(CmnConst.SOURCE_TABLE));
        table.addSubDataTable(fse.getSubDataTable(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX));
        DataTableEntity subDataTable = fse.getSubDataTable(CmnConst.TABLE_SYNC_MANAGER_FIELD);
    /**
     * æ“ä½œè¡¨
     *
     * @param fse
     * @throws BaseException
     */
    private FieldSetEntity operationTable(FieldSetEntity fse, boolean update) throws BaseException {
        FieldSetEntity table = new FieldSetEntity();
        table.setTableName(CmnConst.TABLE_MODULE_TABLE);
        // è¡¨å
        table.setValue(CmnConst.TABLE_NAME, fse.getString(CmnConst.TARGET_TABLE));
        // è¡¨ç±»åž‹
        table.setValue(CmnConst.TABLE_TYPE, 1);
        table.setValue("sequence", 1);
        table.setValue(CmnConst.TABLE_DESCRIPTION, "数据库同步表，来源表:" + fse.getString(CmnConst.SOURCE_TABLE));
        table.addSubDataTable(fse.getSubDataTable(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX));
        DataTableEntity subDataTable = fse.getSubDataTable(CmnConst.TABLE_SYNC_MANAGER_FIELD);

        DataTableEntity field = new DataTableEntity();
        List<String> fieldName = new ArrayList<>();
        boolean isPk = false;
        for (int i = 0; i < subDataTable.getRows(); i++) {
            if (i == 0) {
                table.setValue(CmnConst.UUID, subDataTable.getString(i, CmnConst.TABLE_UUID));
            }
            String field_type = subDataTable.getString(i, CmnConst.FIELD_TYPE);
            //将 sync_manager_field å­è¡¨ä¸­ field_tag è¿˜åŽŸåˆ° field_type ä¸­
            subDataTable.setFieldValue(i, CmnConst.FIELD_TYPE, subDataTable.getString(i, "field_tag"));
            FieldSetEntity fs = subDataTable.getFieldSetEntity(i).clones();
            fs.setValue(CmnConst.FIELD_TYPE, field_type);
            fs.setTableName(CmnConst.TABLE_MODULE_FIELD);
            // å°† field_uuid å†™åˆ°uuid字段中
            fs.setValue(CmnConst.UUID, fs.getString("field_uuid"));
            field.addFieldSetEntity(fs);
            fieldName.add(fs.getString(CmnConst.FIELD_NAME));
            if ("pk".equalsIgnoreCase(fs.getString(CmnConst.FIELD_TYPE))) {
                isPk = true;
            }
        }
        if (!update) {
            if (fieldName.contains("uuid")) {
                throw new BaseException(ErrorCode.SYNC_FIELD_COLUMN_EXISTS_SAME_FIELD.getValue(), ErrorCode.SYNC_FIELD_COLUMN_EXISTS_SAME_FIELD.getText().replace("{{fieldName}}", "uuid"));
            } else {
                FieldSetEntity d = new FieldSetEntity();
                d.setTableName(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_FIELD);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_NAME, "uuid");
                d.setValue("field_show_name", "唯一标识");
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_TYPE, "string");
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_LENGTH, 80);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_UNIT, 0);
                d.setValue(com.product.tool.table.config.CmnConst.IS_REQUIRED, 1);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_DESCRIPTION, "唯一标识");
                field.addFieldSetEntity(d);
                d = new FieldSetEntity();
                d.setTableName(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX);
                d.setValue("index_name", "uuid_unique_" + IdUtil.simpleUUID().substring(0, 5));
                d.setValue("index_fields", "uuid");
                d.setValue("index_type", 1);
                DataTableEntity indexSub = table.getSubDataTable(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX);
                if (indexSub == null) {
                    indexSub = new DataTableEntity();
                }
                indexSub.addFieldSetEntity(d);
                table.addSubDataTable(indexSub);
        DataTableEntity field = new DataTableEntity();
        List<String> fieldName = new ArrayList<>();
        boolean isPk = false;
        for (int i = 0; i < subDataTable.getRows(); i++) {
            if (i == 0) {
                table.setValue(CmnConst.UUID, subDataTable.getString(i, CmnConst.TABLE_UUID));
            }
            String field_type = subDataTable.getString(i, CmnConst.FIELD_TYPE);
            //将 sync_manager_field å­è¡¨ä¸­ field_tag è¿˜åŽŸåˆ° field_type ä¸­
            subDataTable.setFieldValue(i, CmnConst.FIELD_TYPE, subDataTable.getString(i, "field_tag"));
            FieldSetEntity fs = subDataTable.getFieldSetEntity(i).clones();
            fs.setValue(CmnConst.FIELD_TYPE, field_type);
            fs.setTableName(CmnConst.TABLE_MODULE_FIELD);
            // å°† field_uuid å†™åˆ°uuid字段中
            fs.setValue(CmnConst.UUID, fs.getString("field_uuid"));
            field.addFieldSetEntity(fs);
            fieldName.add(fs.getString(CmnConst.FIELD_NAME));
            if ("pk".equalsIgnoreCase(fs.getString(CmnConst.FIELD_TYPE))) {
                isPk = true;
            }
        }
        if (!update) {
            if (fieldName.contains("uuid")) {
                throw new BaseException(ErrorCode.SYNC_FIELD_COLUMN_EXISTS_SAME_FIELD.getValue(), ErrorCode.SYNC_FIELD_COLUMN_EXISTS_SAME_FIELD.getText().replace("{{fieldName}}", "uuid"));
            } else {
                FieldSetEntity d = new FieldSetEntity();
                d.setTableName(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_FIELD);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_NAME, "uuid");
                d.setValue("field_show_name", "唯一标识");
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_TYPE, "string");
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_LENGTH, 80);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_UNIT, 0);
                d.setValue(com.product.tool.table.config.CmnConst.IS_REQUIRED, 1);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_DESCRIPTION, "唯一标识");
                field.addFieldSetEntity(d);
                d = new FieldSetEntity();
                d.setTableName(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX);
                d.setValue("index_name", "uuid_unique_" + IdUtil.simpleUUID().substring(0, 5));
                d.setValue("index_fields", "uuid");
                d.setValue("index_type", 1);
                DataTableEntity indexSub = table.getSubDataTable(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX);
                if (indexSub == null) {
                    indexSub = new DataTableEntity();
                }
                indexSub.addFieldSetEntity(d);
                table.addSubDataTable(indexSub);

            }
            if (!isPk) {
                String pkField = "id";
                int i = 1;
                while (fieldName.contains(pkField)) {
                    pkField = "id" + i;
                    i++;
                }
                FieldSetEntity d = new FieldSetEntity();
                d.setTableName(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_FIELD);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_NAME, pkField);
                d.setValue("field_show_name", "自增主键");
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_TYPE, "pk");
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_LENGTH, 11);
                d.setValue(com.product.tool.table.config.CmnConst.IS_REQUIRED, 1);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_UNIT, 0);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_DESCRIPTION, "自增主键");
                field.addFieldSetEntity(d);
            }
        }
        table.addSubDataTable(field);
        return table;
    }
            }
            if (!isPk) {
                String pkField = "id";
                int i = 1;
                while (fieldName.contains(pkField)) {
                    pkField = "id" + i;
                    i++;
                }
                FieldSetEntity d = new FieldSetEntity();
                d.setTableName(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_FIELD);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_NAME, pkField);
                d.setValue("field_show_name", "自增主键");
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_TYPE, "pk");
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_LENGTH, 11);
                d.setValue(com.product.tool.table.config.CmnConst.IS_REQUIRED, 1);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_UNIT, 0);
                d.setValue(com.product.tool.table.config.CmnConst.FIELD_DESCRIPTION, "自增主键");
                field.addFieldSetEntity(d);
            }
        }
        table.addSubDataTable(field);
        return table;
    }

    /**
     * ä¿å­˜åŒæ­¥è¡¨é…ç½®
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    @Transactional
    @Override
    public String saveSyncTableConfig(FieldSetEntity fse) throws BaseException {
        fse.setValue("query_type", 0);
        BaseUtil.createCreatorAndCreationTime(fse);
        boolean update = true;
        if (StringUtils.isEmpty(fse.getUUID())) {
            fse.setValue(CmnConst.UUID, IdUtil.randomUUID());
            update = false;
        }
        DataTableEntity subDataTable = fse.getSubDataTable(CmnConst.TABLE_SYNC_MANAGER_FIELD);
        if (DataTableEntity.isEmpty(subDataTable)) {
            throw new BaseException(ErrorCode.SAVE_SYNC_TASK_FIELD_INFO_EMPTY);
        }
    /**
     * ä¿å­˜åŒæ­¥è¡¨é…ç½®
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    @Transactional
    @Override
    public String saveSyncTableConfig(FieldSetEntity fse) throws BaseException {
        fse.setValue("query_type", 0);
        BaseUtil.createCreatorAndCreationTime(fse);
        boolean update = true;
        if (StringUtils.isEmpty(fse.getUUID())) {
            fse.setValue(CmnConst.UUID, IdUtil.randomUUID());
            update = false;
        }
        DataTableEntity subDataTable = fse.getSubDataTable(CmnConst.TABLE_SYNC_MANAGER_FIELD);
        if (DataTableEntity.isEmpty(subDataTable)) {
            throw new BaseException(ErrorCode.SAVE_SYNC_TASK_FIELD_INFO_EMPTY);
        }

        FieldSetEntity tableData = operationTable(fse, update);
        //增量同步
        if (1 == fse.getInteger("sync_type")) {
            //唯一字段
            boolean unique_field = false;
            //增量标识字段
            boolean incremental_field = false;
        FieldSetEntity tableData = operationTable(fse, update);
        //增量同步
        if (1 == fse.getInteger("sync_type")) {
            //唯一字段
            boolean unique_field = false;
            //增量标识字段
            boolean incremental_field = false;

            boolean update_field = false;
            for (int i = 0; i < subDataTable.getRows(); i++) {
                String field_type = subDataTable.getString(i, CmnConst.FIELD_TYPE);
                if (!unique_field || !incremental_field) {
                    List<String> templateType = Arrays.asList(field_type.split(","));
                    if (templateType.contains("2")) {
                        unique_field = true;
                    } else if (templateType.contains("1") && templateType.contains("3")) {
                        //增量标识和更新标识为同一字段
                        incremental_field = true;
                        update_field = true;
            boolean update_field = false;
            for (int i = 0; i < subDataTable.getRows(); i++) {
                String field_type = subDataTable.getString(i, CmnConst.FIELD_TYPE);
                if (!unique_field || !incremental_field) {
                    List<String> templateType = Arrays.asList(field_type.split(","));
                    if (templateType.contains("2")) {
                        unique_field = true;
                    } else if (templateType.contains("1") && templateType.contains("3")) {
                        //增量标识和更新标识为同一字段
                        incremental_field = true;
                        update_field = true;
//                        throw new BaseException(ErrorCode.INCREMENTAL_UPDATE_CAN_NOT_SAME_FIELD);
                    } else if (templateType.contains("1")) {
                        incremental_field = true;
                    } else if (templateType.contains("3")) {
                        update_field = true;
                    }
                } else {
                    break;
                }
            }
            if (update_field && !unique_field) {
                throw new BaseException(ErrorCode.SYNC_DATA_UNIQUE_FIELD_NOT_EXIST);
            }
            if (!incremental_field) {
                throw new BaseException(ErrorCode.SYNC_DATA_INCREMENTAL_FIELD_NOT_EXIST);
            }
        }
        fse.removeSubData(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX);
        try {
            //因为uuid是自己生成的（定时任务需要这个uuid）所以要判断 å¦åˆ™è°ƒç”¨saveFieldSet ä¼šæ‰§è¡Œæ›´æ–°
            boolean clearTaskUuid = false;
            if (StringUtils.isEmpty(fse.getString("time_task_uuid"))) {
                // å…ˆå†™å…¥ä¸´æ—¶çš„（占位）定时任务表uuid é¿å…ä¿å­˜æŠ¥é”™å®šæ—¶ä»»åŠ¡åŠ å…¥é˜Ÿåˆ—后无法删除（connection è¢«å…³é—­ï¼‰
                fse.setValue("time_task_uuid", "tempUuid");
                clearTaskUuid = true;
            }
            if (update) {
                getBaseDao().saveFieldSetEntity(fse);
            } else {
                getBaseDao().add(fse);
            }
            if (clearTaskUuid) {
                fse.setValue("time_task_uuid", null);
            }
                    } else if (templateType.contains("1")) {
                        incremental_field = true;
                    } else if (templateType.contains("3")) {
                        update_field = true;
                    }
                } else {
                    break;
                }
            }
            if (update_field && !unique_field) {
                throw new BaseException(ErrorCode.SYNC_DATA_UNIQUE_FIELD_NOT_EXIST);
            }
            if (!incremental_field) {
                throw new BaseException(ErrorCode.SYNC_DATA_INCREMENTAL_FIELD_NOT_EXIST);
            }
        }
        fse.removeSubData(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX);
        try {
            //因为uuid是自己生成的（定时任务需要这个uuid）所以要判断 å¦åˆ™è°ƒç”¨saveFieldSet ä¼šæ‰§è¡Œæ›´æ–°
            boolean clearTaskUuid = false;
            if (StringUtils.isEmpty(fse.getString("time_task_uuid"))) {
                // å…ˆå†™å…¥ä¸´æ—¶çš„（占位）定时任务表uuid é¿å…ä¿å­˜æŠ¥é”™å®šæ—¶ä»»åŠ¡åŠ å…¥é˜Ÿåˆ—后无法删除（connection è¢«å…³é—­ï¼‰
                fse.setValue("time_task_uuid", "tempUuid");
                clearTaskUuid = true;
            }
            if (update) {
                getBaseDao().saveFieldSetEntity(fse);
            } else {
                getBaseDao().add(fse);
            }
            if (clearTaskUuid) {
                fse.setValue("time_task_uuid", null);
            }

            if (update && !StringUtils.isEmpty(tableData.getUUID())) {
                FieldSetEntity uuidField = BaseUtil.getSingleInfoByCache("表字段信息", new String[]{tableData.getUUID(), "uuid"});
                tableData.getSubData().get("product_sys_datamodel_field").addFieldSetEntity(uuidField);
                FieldSetEntity f = getBaseDao().getFieldSetEntityByFilter("product_sys_datamodel_table_index", "table_uuid =? and index_type=1 and index_fields ='uuid'  ", new Object[]{tableData.getUUID()}, false);
                if (f != null && !StringUtils.isEmpty(f.getUUID())) {
                    DataTableEntity indexSub = tableData.getSubDataTable(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX);
                    if (indexSub == null) {
                        indexSub = new DataTableEntity();
                    }
                    List<FieldSetEntity> fieldSetEntity = indexSub.getFieldSetEntity(f.getUUID());
                    if (fieldSetEntity == null || fieldSetEntity.size() <= 0) {
                        indexSub.addFieldSetEntity(f);
                        tableData.addSubDataTable(indexSub);
                    }
                }
            }
            dataModelService.dataModelOperation(tableData);
            //创建同步定时任务
            FieldSetEntity timeTaskFieldSet = createdTimeTask(fse.getString("target_table"), fse.getString("execute_time"), fse.getUUID(), fse.getString("time_task_uuid"));
            fse.getSubData().clear();
            //回写定时任务uuid
            fse.setValue("time_task_uuid", timeTaskFieldSet.getUUID());
            getBaseDao().saveFieldSetEntity(fse);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return fse.getUUID();
    }
            if (update && !StringUtils.isEmpty(tableData.getUUID())) {
                FieldSetEntity uuidField = BaseUtil.getSingleInfoByCache("表字段信息", new String[]{tableData.getUUID(), "uuid"});
                tableData.getSubData().get("product_sys_datamodel_field").addFieldSetEntity(uuidField);
                FieldSetEntity f = getBaseDao().getFieldSetEntityByFilter("product_sys_datamodel_table_index", "table_uuid =? and index_type=1 and index_fields ='uuid'  ", new Object[]{tableData.getUUID()}, false);
                if (f != null && !StringUtils.isEmpty(f.getUUID())) {
                    DataTableEntity indexSub = tableData.getSubDataTable(com.product.tool.table.config.CmnConst.PRODUCT_SYS_DATAMODEL_TABLE_INDEX);
                    if (indexSub == null) {
                        indexSub = new DataTableEntity();
                    }
                    List<FieldSetEntity> fieldSetEntity = indexSub.getFieldSetEntity(f.getUUID());
                    if (fieldSetEntity == null || fieldSetEntity.size() <= 0) {
                        indexSub.addFieldSetEntity(f);
                        tableData.addSubDataTable(indexSub);
                    }
                }
            }
            dataModelService.dataModelOperation(tableData);
            //创建同步定时任务
            FieldSetEntity timeTaskFieldSet = createdTimeTask(fse.getString("target_table"), fse.getString("execute_time"), fse.getUUID(), fse.getString("time_task_uuid"));
            fse.getSubData().clear();
            //回写定时任务uuid
            fse.setValue("time_task_uuid", timeTaskFieldSet.getUUID());
            getBaseDao().saveFieldSetEntity(fse);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return fse.getUUID();
    }


    /**
     * ä¿å­˜åŒæ­¥è¿žæŽ¥é…ç½®
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    @Transactional
    @Override
    public String saveSyncConnectionConfig(FieldSetEntity fse) throws BaseException {
        BaseUtil.createCreatorAndCreationTime(fse);
        getBaseDao().saveFieldSetEntity(fse);
        if (fse.getInteger("db_type") != null && fse.getInteger("db_type") == 5) {
            // redis ä»…仅连接一哈
            try {
    /**
     * ä¿å­˜åŒæ­¥è¿žæŽ¥é…ç½®
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    @Transactional
    @Override
    public String saveSyncConnectionConfig(FieldSetEntity fse) throws BaseException {
        BaseUtil.createCreatorAndCreationTime(fse);
        getBaseDao().saveFieldSetEntity(fse);
        if (fse.getInteger("db_type") != null && fse.getInteger("db_type") == 5) {
            // redis ä»…仅连接一哈
            try {
//                System.out.println(fse.getString("ip"));
//                System.out.println(fse.getString("port"));
//                System.out.println(fse.getString("pass_word"));
//                System.out.println(fse.getString("instance"));
                Jedis jedis = new Jedis(fse.getString("ip"), fse.getInteger("port"));
                if (!StringUtils.isEmpty(fse.getString("pass_word"))) {
                    jedis.auth(fse.getString("pass_word"));
                }
                int dbIndex = StringUtils.isEmpty(fse.getString("instance")) ? 0 : fse.getInteger("instance");
                jedis.select(dbIndex);
                jedis.connect();
                jedis.close();
            } catch (Exception e) {
                throw new BaseException(ErrorCode.GET_CONNECTION_FAIL);
            }
        } else if (fse.getInteger("db_type") != null && fse.getInteger("db_type") == 6) {
                Jedis jedis = new Jedis(fse.getString("ip"), fse.getInteger("port"));
                if (!StringUtils.isEmpty(fse.getString("pass_word"))) {
                    jedis.auth(fse.getString("pass_word"));
                }
                int dbIndex = StringUtils.isEmpty(fse.getString("instance")) ? 0 : fse.getInteger("instance");
                jedis.select(dbIndex);
                jedis.connect();
                jedis.close();
            } catch (Exception e) {
                throw new BaseException(ErrorCode.GET_CONNECTION_FAIL);
            }
        } else if (fse.getInteger("db_type") != null && fse.getInteger("db_type") == 6) {
//            Set<String> sentinels = new HashSet<>();
//            System.out.println(fse.getString("ip"));
//            System.out.println(fse.getString("port"));
//            System.out.println(fse.getString("pass_word"));
//            System.out.println(fse.getString("instance"));
            String[] ip = fse.getString("ip").split(",");
            String[] ip = fse.getString("ip").split(",");

//            sentinels.add("127.0.0.1:26390");
//            sentinels.add("127.0.0.1:26391");
//            sentinels.add("127.0.0.1:26392");
            GenericObjectPoolConfig<Jedis> poolConfig = new GenericObjectPoolConfig<>();
            poolConfig.setMaxIdle(100);
            poolConfig.setMaxWaitMillis(10000);
            poolConfig.setTestOnBorrow(true);
            int connectionTimeout = 5000;
            int soTimeout = 5000;
            String password = null;
            int database = 0;
            try (JedisSentinelPool jsPool = new JedisSentinelPool(fse.getString("user_name"), Sets.newHashSet(ip), poolConfig,
                    connectionTimeout, soTimeout, password, database); Jedis jedis = jsPool.getResource()) {
                jedis.connect();
            } catch (Exception e) {
                throw new BaseException(ErrorCode.GET_CONNECTION_FAIL);
            }
        } else {
            DatabaseEntity databaseEntity = new DatabaseEntity(fse);
            this.addTask(databaseEntity, fse.getUUID());
        }
        if (remoteService != null) {
            remoteService.saveSyncConnectionConfig(fse);
        }
        return fse.getUUID();
    }
            GenericObjectPoolConfig<Jedis> poolConfig = new GenericObjectPoolConfig<>();
            poolConfig.setMaxIdle(100);
            poolConfig.setMaxWaitMillis(10000);
            poolConfig.setTestOnBorrow(true);
            int connectionTimeout = 5000;
            int soTimeout = 5000;
            String password = null;
            int database = 0;
            try (JedisSentinelPool jsPool = new JedisSentinelPool(fse.getString("user_name"), Sets.newHashSet(ip), poolConfig,
                    connectionTimeout, soTimeout, password, database); Jedis jedis = jsPool.getResource()) {
                jedis.connect();
            } catch (Exception e) {
                throw new BaseException(ErrorCode.GET_CONNECTION_FAIL);
            }
        } else {
            DatabaseEntity databaseEntity = new DatabaseEntity(fse);
            this.addTask(databaseEntity, fse.getUUID());
        }
        if (remoteService != null) {
            remoteService.saveSyncConnectionConfig(fse);
        }
        return fse.getUUID();
    }

    public synchronized void addTableField(DatabaseEntity dbe, String connectionConfigUuid, String tableName) throws BaseException {
        try (Connection connection = ConnectionManager.getConnection(dbe)) {
            DataTableEntity dt = new DataTableEntity();
            QueryDataService queryDataService = new QueryDataService(connection);
            getFieldName(queryDataService, tableName, dbe, connectionConfigUuid, dt, getFieldTypeReference(dbe.getDbType()), null);
            if (!DataTableEntity.isEmpty(dt)) {
                getBaseDao().add(dt);
            }
        } catch (Exception e) {
            throw new BaseException(e);
        }
    }
    public synchronized void addTableField(DatabaseEntity dbe, String connectionConfigUuid, String tableName) throws BaseException {
        try (Connection connection = ConnectionManager.getConnection(dbe)) {
            DataTableEntity dt = new DataTableEntity();
            QueryDataService queryDataService = new QueryDataService(connection);
            getFieldName(queryDataService, tableName, dbe, connectionConfigUuid, dt, getFieldTypeReference(dbe.getDbType()), null);
            if (!DataTableEntity.isEmpty(dt)) {
                getBaseDao().add(dt);
            }
        } catch (Exception e) {
            throw new BaseException(e);
        }
    }

    /**
     * èŽ·å–来源表字段
     *
     * @param dbe
     * @param uuid
     */
    private synchronized void addTask(DatabaseEntity dbe, String uuid) {
        BaseDao baseDao = getBaseDao();
        try (Connection connection = ConnectionManager.getConnection(dbe)) {
            if (connection != null) {
                QueryDataService queryDataService = new QueryDataService(connection);
                String[] tableName = getTableName(queryDataService, dbe);
                if ((tableName != null && tableName.length > 0) || DatabaseType.PSQL.equals(dbe.getDbType()) || DatabaseType.Oracle.equals(dbe.getDbType())) {
                    Map<String, String> fieldTypeReference = getFieldTypeReference(dbe.getDbType());
                    DataTableEntity dt = new DataTableEntity();
                    if (DatabaseType.Oracle.equals(dbe.getDbType())) {
                        Map<String, List<Map<String, Object>>> tableFieldMap = getOracleFieldInfo(queryDataService);
                        tableFieldMap.forEach((k, v) -> {
                            getFieldName(queryDataService, k, dbe, uuid, dt, fieldTypeReference, v);
                        });
                    } else if (DatabaseType.PSQL.equals(dbe.getDbType())) {
                        Map<String, List<Map<String, Object>>> pSqlFieldInfo = getPSqlFieldInfo(dbe.getDbInstance(), queryDataService);
                        pSqlFieldInfo.forEach((k, v) -> {
                            getFieldName(queryDataService, k, dbe, uuid, dt, fieldTypeReference, v);
                        });
                    } else {
                        for (String table : tableName) {
                            getFieldName(queryDataService, table, dbe, uuid, dt, fieldTypeReference, null);
                        }
                    }
    /**
     * èŽ·å–来源表字段
     *
     * @param dbe
     * @param uuid
     */
    private synchronized void addTask(DatabaseEntity dbe, String uuid) {
        BaseDao baseDao = getBaseDao();
        try (Connection connection = ConnectionManager.getConnection(dbe)) {
            if (connection != null) {
                QueryDataService queryDataService = new QueryDataService(connection);
                String[] tableName = getTableName(queryDataService, dbe);
                if ((tableName != null && tableName.length > 0) || DatabaseType.PSQL.equals(dbe.getDbType()) || DatabaseType.Oracle.equals(dbe.getDbType())) {
                    Map<String, String> fieldTypeReference = getFieldTypeReference(dbe.getDbType());
                    DataTableEntity dt = new DataTableEntity();
                    if (DatabaseType.Oracle.equals(dbe.getDbType())) {
                        Map<String, List<Map<String, Object>>> tableFieldMap = getOracleFieldInfo(queryDataService);
                        tableFieldMap.forEach((k, v) -> {
                            getFieldName(queryDataService, k, dbe, uuid, dt, fieldTypeReference, v);
                        });
                    } else if (DatabaseType.PSQL.equals(dbe.getDbType())) {
                        Map<String, List<Map<String, Object>>> pSqlFieldInfo = getPSqlFieldInfo(dbe.getDbInstance(), queryDataService);
                        pSqlFieldInfo.forEach((k, v) -> {
                            getFieldName(queryDataService, k, dbe, uuid, dt, fieldTypeReference, v);
                        });
                    } else {
                        for (String table : tableName) {
                            getFieldName(queryDataService, table, dbe, uuid, dt, fieldTypeReference, null);
                        }
                    }

                    if (!DataTableEntity.isEmpty(dt)) {
                        baseDao.delete(CmnConst.PRODUCT_SYS_DATABASE_TABLENAME_FIELD, "sync_manager_uuid=?", new Object[]{uuid});
                        baseDao.add(dt);
                    }
                }
                    if (!DataTableEntity.isEmpty(dt)) {
                        baseDao.delete(CmnConst.PRODUCT_SYS_DATABASE_TABLENAME_FIELD, "sync_manager_uuid=?", new Object[]{uuid});
                        baseDao.add(dt);
                    }
                }

            }
        } catch (BaseException e) {
            throw e;
        } catch (Exception e) {
            throw new BaseException(e);
        }
    }
            }
        } catch (BaseException e) {
            throw e;
        } catch (Exception e) {
            throw new BaseException(e);
        }
    }

    /**
     * åˆ›å»ºå®šæ—¶ä»»åŠ¡
     *
     * @param target_table ç›®æ ‡è¡¨
     * @param execute_time corn è¡¨è¾¾å¼
     * @param task_uuid    åŒæ­¥æ•°æ®é…ç½® uuid  product_sys_data_sync_manager_sub
     * @param timeTaskUuid å®šæ—¶ä»»åŠ¡uuid
     */
    private FieldSetEntity createdTimeTask(String target_table, String execute_time, String task_uuid, String timeTaskUuid) throws BaseException {
        //
        FieldSetEntity fse = new FieldSetEntity();
        try {
            fse.setTableName("product_sys_timed_task");
            fse.setValue("uuid", timeTaskUuid);
            fse.setValue("job_name", target_table + "表数据同步");//任务名称
            fse.setValue("job_group", "system");//分组
            fse.setValue("invoke_target", "syncDataManager.executeDataSyncTask('" + task_uuid + "')");//调用目标字符串
            fse.setValue("cron_expression", execute_time);//cron表达式
            fse.setValue("misfire_policy", "3");//错误执行策略  åªæ‰§è¡Œä¸€æ¬¡
            fse.setValue("concurrent", 0);//不允许并发执行
            fse.setValue("remark", target_table + "表数据同步");
            fse.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fse.setValue("created_utc_datetime", new Date());
            fse.setValue("status", 1);
            fse.setValue("is_conceal", 1);
            if (!StringUtils.isEmpty(timeTaskUuid)) {
                sysJobService.updateJob(fse);
            } else {
                sysJobService.insertJob(fse);
            }
            return fse;
        } catch (Exception e) {
            e.printStackTrace();
            throw new BaseException(ErrorCode.CRATED_TIMED_TASK_FAIL);
        }
    /**
     * åˆ›å»ºå®šæ—¶ä»»åŠ¡
     *
     * @param target_table ç›®æ ‡è¡¨
     * @param execute_time corn è¡¨è¾¾å¼
     * @param task_uuid    åŒæ­¥æ•°æ®é…ç½® uuid  product_sys_data_sync_manager_sub
     * @param timeTaskUuid å®šæ—¶ä»»åŠ¡uuid
     */
    private FieldSetEntity createdTimeTask(String target_table, String execute_time, String task_uuid, String timeTaskUuid) throws BaseException {
        //
        FieldSetEntity fse = new FieldSetEntity();
        try {
            fse.setTableName("product_sys_timed_task");
            fse.setValue("uuid", timeTaskUuid);
            fse.setValue("job_name", target_table + "表数据同步");//任务名称
            fse.setValue("job_group", "system");//分组
            fse.setValue("invoke_target", "syncDataManager.executeDataSyncTask('" + task_uuid + "')");//调用目标字符串
            fse.setValue("cron_expression", execute_time);//cron表达式
            fse.setValue("misfire_policy", "3");//错误执行策略  åªæ‰§è¡Œä¸€æ¬¡
            fse.setValue("concurrent", 0);//不允许并发执行
            fse.setValue("remark", target_table + "表数据同步");
            fse.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fse.setValue("created_utc_datetime", new Date());
            fse.setValue("status", 1);
            fse.setValue("is_conceal", 1);
            if (!StringUtils.isEmpty(timeTaskUuid)) {
                sysJobService.updateJob(fse);
            } else {
                sysJobService.insertJob(fse);
            }
            return fse;
        } catch (Exception e) {
            e.printStackTrace();
            throw new BaseException(ErrorCode.CRATED_TIMED_TASK_FAIL);
        }
//
    }
    }

    /**
     * ä¿å­˜å­—段
     *
     * @param uuid
     * @param fieldMap
     * @return
     */
    @Deprecated
    private DataTableEntity saveTableField(String uuid, Map<String, String[]> fieldMap) {
        DataTableEntity dt = new DataTableEntity();
        fieldMap.forEach((k, v) -> {
            for (String fieldName : v) {
                FieldSetEntity field = new FieldSetEntity();
                field.setTableName(CmnConst.PRODUCT_SYS_DATABASE_TABLENAME_FIELD);
                field.setValue("sync_manager_uuid", uuid);
                //表名
                field.setValue("table_name", k);
                //字段名
                field.setValue("field_name", fieldName);
                dt.addFieldSetEntity(field);
            }
    /**
     * ä¿å­˜å­—段
     *
     * @param uuid
     * @param fieldMap
     * @return
     */
    @Deprecated
    private DataTableEntity saveTableField(String uuid, Map<String, String[]> fieldMap) {
        DataTableEntity dt = new DataTableEntity();
        fieldMap.forEach((k, v) -> {
            for (String fieldName : v) {
                FieldSetEntity field = new FieldSetEntity();
                field.setTableName(CmnConst.PRODUCT_SYS_DATABASE_TABLENAME_FIELD);
                field.setValue("sync_manager_uuid", uuid);
                //表名
                field.setValue("table_name", k);
                //字段名
                field.setValue("field_name", fieldName);
                dt.addFieldSetEntity(field);
            }

        });
        return dt;
        });
        return dt;

    }
    }

    private Map<String, String> getFieldTypeReference(DatabaseType dbt) {
        Map<String, String> fieldType = new CaseInsensitiveMap<>();
        if (dbt == null) {
            return fieldType;
        }
        DataTableEntity dt = getBaseDao().listTable("product_sys_field_type_reference", "db_type=?", new Object[]{dbt.getValue()});
        if (DataTableEntity.isEmpty(dt)) {
            return fieldType;
        }
        for (int i = 0; i < dt.getRows(); i++) {
            fieldType.put(dt.getString(i, "db_field_type").trim(), dt.getString(i, "sys_field_type").trim());
        }
        return fieldType;
    }
    public Map<String, String> getFieldTypeReference(DatabaseType dbt) {
        Map<String, String> fieldType = new CaseInsensitiveMap<>();
        if (dbt == null) {
            return fieldType;
        }
        DataTableEntity dt = getBaseDao().listTable("product_sys_field_type_reference", "db_type=?", new Object[]{dbt.getValue()});
        if (DataTableEntity.isEmpty(dt)) {
            return fieldType;
        }
        for (int i = 0; i < dt.getRows(); i++) {
            fieldType.put(dt.getString(i, "db_field_type").trim(), dt.getString(i, "sys_field_type").trim());
        }
        return fieldType;
    }

    /**
     * oracle å­—段元信息
     *
     * @param queryDataService
     * @return
     */
    private Map<String, List<Map<String, Object>>> getOracleFieldInfo(QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT ");
        sql.append(" T .column_name AS column_name,  ");//--列名
        sql.append(" T .column_type AS column_type,  ");//字段类型
        sql.append(" T .data_length AS column_length,  ");//字段长度
        sql.append(" T .data_scale AS column_scale,  ");//字段精度
        sql.append(" T .column_comment AS column_comment, ");//字段注释
        sql.append(" T .table_name AS table_name ");//字段注释
        sql.append(" FROM ");
        sql.append(" ( ");
        sql.append(" SELECT ");
        sql.append(" UB.tablespace_name AS database_name, ");
        sql.append(" UTC.table_name AS table_name, ");
        sql.append(" UTC.column_name AS column_name, ");
        sql.append(" UTC.data_length AS data_length, ");
        sql.append(" UTC.data_type AS column_type, ");
        sql.append(" utc.data_scale AS data_scale, ");
        sql.append(" ucc.comments AS column_comment, ");
        sql.append(" utc.column_id, ");
        sql.append(" utc.nullable ");
        sql.append(" FROM ");
        sql.append(" user_tables ub ");
        sql.append(" LEFT JOIN user_tab_columns utc ON ub.table_name = UTC.table_name ");
        sql.append(" LEFT JOIN user_col_comments ucc ON utc.column_name = ucc.column_name ");
        sql.append(" AND utc.table_name = ucc.table_name ");
        sql.append(" ) T ");
        sql.append(" LEFT JOIN ( ");
        sql.append(" SELECT ");
        sql.append(" UCC.table_name AS table_name, ");
        sql.append(" ucc.column_name AS column_name, ");
        sql.append(" wm_concat (UC.constraint_type) AS constraint_type ");
        sql.append(" FROM ");
        sql.append(" user_cons_columns ucc ");
        sql.append(" LEFT JOIN user_constraints uc ON UCC.constraint_name = UC.constraint_name ");
        sql.append(" GROUP BY ");
        sql.append(" UCC.table_name, ");
        sql.append(" ucc.column_name ");
        sql.append(" ) b ON T .table_name = b.TABLE_NAME ");
        sql.append(" AND T .column_name = b.column_name ");
    /**
     * oracle å­—段元信息
     *
     * @param queryDataService
     * @return
     */
    public Map<String, List<Map<String, Object>>> getOracleFieldInfo(QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT ");
        sql.append(" T .column_name AS column_name,  ");//--列名
        sql.append(" T .column_type AS column_type,  ");//字段类型
        sql.append(" T .data_length AS column_length,  ");//字段长度
        sql.append(" T .data_scale AS column_scale,  ");//字段精度
        sql.append(" T .column_comment AS column_comment, ");//字段注释
        sql.append(" T .table_name AS table_name ");//字段注释
        sql.append(" FROM ");
        sql.append(" ( ");
        sql.append(" SELECT ");
        sql.append(" UB.tablespace_name AS database_name, ");
        sql.append(" UTC.table_name AS table_name, ");
        sql.append(" UTC.column_name AS column_name, ");
        sql.append(" UTC.data_length AS data_length, ");
        sql.append(" UTC.data_type AS column_type, ");
        sql.append(" utc.data_scale AS data_scale, ");
        sql.append(" ucc.comments AS column_comment, ");
        sql.append(" utc.column_id, ");
        sql.append(" utc.nullable ");
        sql.append(" FROM ");
        sql.append(" user_tables ub ");
        sql.append(" LEFT JOIN user_tab_columns utc ON ub.table_name = UTC.table_name ");
        sql.append(" LEFT JOIN user_col_comments ucc ON utc.column_name = ucc.column_name ");
        sql.append(" AND utc.table_name = ucc.table_name ");
        sql.append(" ) T ");
        sql.append(" LEFT JOIN ( ");
        sql.append(" SELECT ");
        sql.append(" UCC.table_name AS table_name, ");
        sql.append(" ucc.column_name AS column_name, ");
        sql.append(" wm_concat (UC.constraint_type) AS constraint_type ");
        sql.append(" FROM ");
        sql.append(" user_cons_columns ucc ");
        sql.append(" LEFT JOIN user_constraints uc ON UCC.constraint_name = UC.constraint_name ");
        sql.append(" GROUP BY ");
        sql.append(" UCC.table_name, ");
        sql.append(" ucc.column_name ");
        sql.append(" ) b ON T .table_name = b.TABLE_NAME ");
        sql.append(" AND T .column_name = b.column_name ");
//        sql.append(" where T.table_name='" + tableName + "' ");
        QueryResultEntity queryResult = queryDataService.getResult(sql.toString());
        List<Map<String, Object>> resultList = queryResult.getResult();
        Map<String, List<Map<String, Object>>> result = new HashMap<>();
        for (Map<String, Object> map : resultList) {
            String tableName = map.get("table_name") == null ? (String) map.get("table_name".toUpperCase()) : (String) map.get("table_name");
            if (tableName == null || tableName.length() == 0) {
                continue;
            }
            List<Map<String, Object>> table_name = result.get(tableName);
            if (table_name == null) {
                table_name = new ArrayList<>();
                result.put(tableName, table_name);
            }
            table_name.add(map);
        }
        return result;
    }
        QueryResultEntity queryResult = queryDataService.getResult(sql.toString());
        List<Map<String, Object>> resultList = queryResult.getResult();
        Map<String, List<Map<String, Object>>> result = new HashMap<>();
        for (Map<String, Object> map : resultList) {
            String tableName = map.get("table_name") == null ? (String) map.get("table_name".toUpperCase()) : (String) map.get("table_name");
            if (tableName == null || tableName.length() == 0) {
                continue;
            }
            List<Map<String, Object>> table_name = result.get(tableName);
            if (table_name == null) {
                table_name = new ArrayList<>();
                result.put(tableName, table_name);
            }
            table_name.add(map);
        }
        return result;
    }

    /**
     * Mysql  æ•°æ®åº“ å­—段名称 ç±»åž‹ é•¿åº¦ æ³¨é‡Š
     *
     * @param tableName
     * @param queryDataService
     * @return
     */
    private List<Map<String, Object>> getMysqlFieldInfo(String tableName, QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT ");
        sql.append(" COLUMN_NAME column_name, ");
        sql.append(" data_type column_type, ");
        sql.append(" column_type length_info, ");
        sql.append(" column_comment ");
        sql.append(" FROM ");
        sql.append(" INFORMATION_SCHEMA.COLUMNS ");
        sql.append(" WHERE ");
        sql.append(" TABLE_NAME = '" + tableName + "' ");
        sql.append(" AND TABLE_SCHEMA = (select database()) ");
        QueryResultEntity queryResult = queryDataService.getResult(sql.toString());
        List<Map<String, Object>> resultList = queryResult.getResult();
        for (int i = 0; i < resultList.size(); i++) {
            Map<String, Object> map = resultList.get(i);
            String length_info = (String) map.get("length_info");
            Object[] length = {0, 0};
            if (length_info.indexOf("(") != -1) {
                length_info = length_info.substring(length_info.indexOf("(") + 1, length_info.indexOf(")"));
                if (length_info.indexOf(",") != -1) {
                    //有小数
                    length = length_info.split(",");
                } else {
                    length[0] = length_info;
                }
            }
            map.put("column_length", length[0]);
            map.put("column_scale", length[1]);
        }
        return resultList;
    }
    /**
     * Mysql  æ•°æ®åº“ å­—段名称 ç±»åž‹ é•¿åº¦ æ³¨é‡Š
     *
     * @param tableName
     * @param queryDataService
     * @return
     */
    public List<Map<String, Object>> getMysqlFieldInfo(String tableName, QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT ");
        sql.append(" COLUMN_NAME column_name, ");
        sql.append(" data_type column_type, ");
        sql.append(" column_type length_info, ");
        sql.append(" column_comment ");
        sql.append(" FROM ");
        sql.append(" INFORMATION_SCHEMA.COLUMNS ");
        sql.append(" WHERE ");
        sql.append(" TABLE_NAME = '" + tableName + "' ");
        sql.append(" AND TABLE_SCHEMA = (select database()) ");
        QueryResultEntity queryResult = queryDataService.getResult(sql.toString());
        List<Map<String, Object>> resultList = queryResult.getResult();
        for (int i = 0; i < resultList.size(); i++) {
            Map<String, Object> map = resultList.get(i);
            String length_info = (String) map.get("length_info");
            Object[] length = {0, 0};
            if (length_info.indexOf("(") != -1) {
                length_info = length_info.substring(length_info.indexOf("(") + 1, length_info.indexOf(")"));
                if (length_info.indexOf(",") != -1) {
                    //有小数
                    length = length_info.split(",");
                } else {
                    length[0] = length_info;
                }
            }
            map.put("column_length", length[0]);
            map.put("column_scale", length[1]);
        }
        return resultList;
    }

    /**
     * sqlserver æ•°æ®åº“ å­—段名称 ç±»åž‹ é•¿åº¦ æ³¨é‡Š
     *
     * @param tableName
     * @param queryDataService
     * @return
     */
    private List<Map<String, Object>> getSqlServerFieldInfo(String tableName, QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT c.name as column_name,t.name as column_type,isnull(c.prec ,0)column_length,isnull(c.scale,0) column_scale ");
        sql.append(" FROM sysobjects o ");
        sql.append(" JOIN syscolumns c on o.id=c.id ");
        sql.append(" JOIN systypes t on c.xusertype=t.xusertype where o.type ='u' and o.name='" + tableName + "' ");
    /**
     * sqlserver æ•°æ®åº“ å­—段名称 ç±»åž‹ é•¿åº¦ æ³¨é‡Š
     *
     * @param tableName
     * @param queryDataService
     * @return
     */
    public List<Map<String, Object>> getSqlServerFieldInfo(String tableName, QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT c.name as column_name,t.name as column_type,isnull(c.prec ,0)column_length,isnull(c.scale,0) column_scale ");
        sql.append(" FROM sysobjects o ");
        sql.append(" JOIN syscolumns c on o.id=c.id ");
        sql.append(" JOIN systypes t on c.xusertype=t.xusertype where o.type ='u' and o.name='" + tableName + "' ");

        QueryResultEntity queryResult = queryDataService.getResult(sql.toString());
        List<Map<String, Object>> resultList = queryResult.getResult();
        return resultList;
    }
        QueryResultEntity queryResult = queryDataService.getResult(sql.toString());
        List<Map<String, Object>> resultList = queryResult.getResult();
        return resultList;
    }


    /**
     * æŸ¥è¯¢INFORMIX数据库 å­—段名称 ç±»åž‹ é•¿åº¦ æ³¨é‡Š
     *
     * @param tableName
     * @param queryDataService
     * @return
     */
    private List<Map<String, Object>> getInformixFieldInfo(String dbName, String tableName, QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" select c.colname column_name, ");
        sql.append(" case c.coltype ");
        sql.append(" when '0' then 'CHAR' ");
        sql.append(" when '1' then 'SMALLINT' ");
        sql.append(" when '2' then 'INTEGER' ");
        sql.append(" when '3' then 'FLOAT' ");
        sql.append(" when '4' then 'SMALLFLOAT' ");
        sql.append(" when '5' then 'DECIMAL' ");
        sql.append(" when '6' then 'SERIAL' ");
        sql.append(" when '7' then 'DATE' ");
        sql.append(" when '8' then 'MONEY' ");
        sql.append(" when '9' then 'NULL' ");
        sql.append(" when '10' then 'DATETIME' ");
        sql.append(" when '11' then 'BYTE' ");
        sql.append(" when '12' then 'TEXT' ");
        sql.append(" when '13' then 'VARCHAR' ");
        sql.append(" when '14' then 'INTERVAL' ");
        sql.append(" when '15' then 'NCHAR' ");
        sql.append(" when '16' then 'NVARCHAR' ");
        sql.append(" when '17' then 'INT8' ");
        sql.append(" when '18' then 'SERIAL8' ");
        sql.append(" when '19' then 'SET' ");
        sql.append(" when '20' then 'MULTISET' ");
        sql.append(" when '21' then 'LIST' ");
        sql.append(" when '22' then 'Unnamed ROW' ");
        sql.append(" when '40' then 'LVARCHAR' ");
        sql.append(" when '41' then 'CLOB' ");
        sql.append(" when '43' then 'BLOB' ");
        sql.append(" when '44' then 'BOOLEAN' ");
        sql.append(" when '256' then 'CHAR' ");
        sql.append(" when '257' then 'SMALLINT' ");
        sql.append(" when '258' then 'INTEGER' ");
        sql.append(" when '259' then 'FLOAT' ");
        sql.append(" when '260' then 'REAL' ");
        sql.append(" when '261' then 'DECIMAL' ");
        sql.append(" when '262' then 'SERIAL' ");
        sql.append(" when '263' then 'DATE' ");
        sql.append(" when '264' then 'MONEY' ");
        sql.append(" when '266' then 'DATETIME' ");
        sql.append(" when '267' then 'BYTE' ");
        sql.append(" when '268' then 'TEXT' ");
        sql.append(" when '269' then 'VARCHAR' ");
        sql.append(" when '270' then 'INTERVAL' ");
        sql.append(" when '271' then 'NCHAR' ");
        sql.append(" when '272' then 'NVARCHAR' ");
        sql.append(" when '273' then 'INT8' ");
        sql.append(" when '274' then 'SERIAL8' ");
        sql.append(" when '275' then 'SET' ");
        sql.append(" when '276' then 'MULTISET' ");
        sql.append(" when '277' then 'LIST' ");
        sql.append(" when '278' then 'Unnamed ROW' ");
        sql.append(" when '296' then 'LVARCHAR' ");
        sql.append(" when '297' then 'CLOB' ");
        sql.append(" when '298' then 'BLOB' ");
        sql.append(" when '299' then 'BOOLEAN' ");
        sql.append(" when '4118' then 'Named ROW' ");
        sql.append(" end column_type,c.collength column_length ");
        sql.append(" from ( ");
        sql.append(" select * from systables ");
        sql.append(" where tabtype='T' and owner =? and tabname=? ");
        sql.append(" ) t ");
        sql.append(" left join syscolumns c on t.tabid=c.tabid ");
        QueryResultEntity queryResult = queryDataService.getResult(sql.toString(), new Object[]{dbName, tableName}, null);
        List<Map<String, Object>> result = queryResult.getResult();
        for (int i = 0; i < result.size(); i++) {
            Map<String, Object> fieldInfo = new CaseInsensitiveMap<>(result.get(i));
            result.set(i, fieldInfo);
            String columnType = (String) fieldInfo.get("column_type");
            if (columnType != null) {
                columnType = columnType.trim();
                fieldInfo.put("column_type", columnType);
            }
            //
            if ("prppmain".equalsIgnoreCase(tableName) && "paytimes".equalsIgnoreCase((String) fieldInfo.get("column_name"))) {
                System.out.println(1);
            }
            //日期处理
            if ("DATETIME".equalsIgnoreCase(columnType) || "DATE".equalsIgnoreCase(columnType)) {
                fieldInfo.put("column_length", 0);
            } else if ("DECIMAL".equalsIgnoreCase(columnType) || "FLOAT".equalsIgnoreCase(columnType) || "SMALLFLOAT".equalsIgnoreCase(columnType) || "MONEY".equalsIgnoreCase(columnType)) {
                if (fieldInfo.get("column_length") != null) {
                    fieldInfo.put("column_length", fieldInfo.get("column_length").toString());
                }
                String columnLength = (String) fieldInfo.get("column_length");
                if (!NumberUtil.isNumber(columnLength)) {
                    fieldInfo.put("column_length", 11);
                    fieldInfo.put("column_scale", 2);
                    continue;
                } else {
                    int colLength = NumberUtil.parseInt(columnLength);
                    int column_length = colLength >> 8;
                    int column_scale = colLength & 255;
                    if (column_scale > 30) {
                        column_scale = 30;
                    }
                    if (column_length < column_scale) {
                        column_length = column_scale;
                    }
                    fieldInfo.put("column_length", column_length);
                    fieldInfo.put("column_scale", column_scale);
                }
    /**
     * æŸ¥è¯¢INFORMIX数据库 å­—段名称 ç±»åž‹ é•¿åº¦ æ³¨é‡Š
     *
     * @param tableName
     * @param queryDataService
     * @return
     */
    public List<Map<String, Object>> getInformixFieldInfo(String dbName, String tableName, QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" select c.colname column_name, ");
        sql.append(" case c.coltype ");
        sql.append(" when '0' then 'CHAR' ");
        sql.append(" when '1' then 'SMALLINT' ");
        sql.append(" when '2' then 'INTEGER' ");
        sql.append(" when '3' then 'FLOAT' ");
        sql.append(" when '4' then 'SMALLFLOAT' ");
        sql.append(" when '5' then 'DECIMAL' ");
        sql.append(" when '6' then 'SERIAL' ");
        sql.append(" when '7' then 'DATE' ");
        sql.append(" when '8' then 'MONEY' ");
        sql.append(" when '9' then 'NULL' ");
        sql.append(" when '10' then 'DATETIME' ");
        sql.append(" when '11' then 'BYTE' ");
        sql.append(" when '12' then 'TEXT' ");
        sql.append(" when '13' then 'VARCHAR' ");
        sql.append(" when '14' then 'INTERVAL' ");
        sql.append(" when '15' then 'NCHAR' ");
        sql.append(" when '16' then 'NVARCHAR' ");
        sql.append(" when '17' then 'INT8' ");
        sql.append(" when '18' then 'SERIAL8' ");
        sql.append(" when '19' then 'SET' ");
        sql.append(" when '20' then 'MULTISET' ");
        sql.append(" when '21' then 'LIST' ");
        sql.append(" when '22' then 'Unnamed ROW' ");
        sql.append(" when '40' then 'LVARCHAR' ");
        sql.append(" when '41' then 'CLOB' ");
        sql.append(" when '43' then 'BLOB' ");
        sql.append(" when '44' then 'BOOLEAN' ");
        sql.append(" when '256' then 'CHAR' ");
        sql.append(" when '257' then 'SMALLINT' ");
        sql.append(" when '258' then 'INTEGER' ");
        sql.append(" when '259' then 'FLOAT' ");
        sql.append(" when '260' then 'REAL' ");
        sql.append(" when '261' then 'DECIMAL' ");
        sql.append(" when '262' then 'SERIAL' ");
        sql.append(" when '263' then 'DATE' ");
        sql.append(" when '264' then 'MONEY' ");
        sql.append(" when '266' then 'DATETIME' ");
        sql.append(" when '267' then 'BYTE' ");
        sql.append(" when '268' then 'TEXT' ");
        sql.append(" when '269' then 'VARCHAR' ");
        sql.append(" when '270' then 'INTERVAL' ");
        sql.append(" when '271' then 'NCHAR' ");
        sql.append(" when '272' then 'NVARCHAR' ");
        sql.append(" when '273' then 'INT8' ");
        sql.append(" when '274' then 'SERIAL8' ");
        sql.append(" when '275' then 'SET' ");
        sql.append(" when '276' then 'MULTISET' ");
        sql.append(" when '277' then 'LIST' ");
        sql.append(" when '278' then 'Unnamed ROW' ");
        sql.append(" when '296' then 'LVARCHAR' ");
        sql.append(" when '297' then 'CLOB' ");
        sql.append(" when '298' then 'BLOB' ");
        sql.append(" when '299' then 'BOOLEAN' ");
        sql.append(" when '4118' then 'Named ROW' ");
        sql.append(" end column_type,c.collength column_length ");
        sql.append(" from ( ");
        sql.append(" select * from systables ");
        sql.append(" where tabtype='T' and owner =? and tabname=? ");
        sql.append(" ) t ");
        sql.append(" left join syscolumns c on t.tabid=c.tabid ");
        QueryResultEntity queryResult = queryDataService.getResult(sql.toString(), new Object[]{dbName, tableName}, null);
        List<Map<String, Object>> result = queryResult.getResult();
        for (int i = 0; i < result.size(); i++) {
            Map<String, Object> fieldInfo = new CaseInsensitiveMap<>(result.get(i));
            result.set(i, fieldInfo);
            String columnType = (String) fieldInfo.get("column_type");
            if (columnType != null) {
                columnType = columnType.trim();
                fieldInfo.put("column_type", columnType);
            }
            //
            if ("prppmain".equalsIgnoreCase(tableName) && "paytimes".equalsIgnoreCase((String) fieldInfo.get("column_name"))) {
                System.out.println(1);
            }
            //日期处理
            if ("DATETIME".equalsIgnoreCase(columnType) || "DATE".equalsIgnoreCase(columnType)) {
                fieldInfo.put("column_length", 0);
            } else if ("DECIMAL".equalsIgnoreCase(columnType) || "FLOAT".equalsIgnoreCase(columnType) || "SMALLFLOAT".equalsIgnoreCase(columnType) || "MONEY".equalsIgnoreCase(columnType)) {
                if (fieldInfo.get("column_length") != null) {
                    fieldInfo.put("column_length", fieldInfo.get("column_length").toString());
                }
                String columnLength = (String) fieldInfo.get("column_length");
                if (!NumberUtil.isNumber(columnLength)) {
                    fieldInfo.put("column_length", 11);
                    fieldInfo.put("column_scale", 2);
                    continue;
                } else {
                    int colLength = NumberUtil.parseInt(columnLength);
                    int column_length = colLength >> 8;
                    int column_scale = colLength & 255;
                    if (column_scale > 30) {
                        column_scale = 30;
                    }
                    if (column_length < column_scale) {
                        column_length = column_scale;
                    }
                    fieldInfo.put("column_length", column_length);
                    fieldInfo.put("column_scale", column_scale);
                }

            } else {
                Object columnLength = fieldInfo.get("column_length");
                if (columnLength != null && NumberUtil.parseInt(columnLength.toString()) > 8000) {
                    fieldInfo.put("column_length", 8000);
                }
                fieldInfo.put("column_scale", 0);
            }
        }
        return result;
    }
            } else {
                Object columnLength = fieldInfo.get("column_length");
                if (columnLength != null && NumberUtil.parseInt(columnLength.toString()) > 8000) {
                    fieldInfo.put("column_length", 8000);
                }
                fieldInfo.put("column_scale", 0);
            }
        }
        return result;
    }

    /**
     * æŸ¥è¯¢PSQL数据库 å­—段名称 ç±»åž‹ é•¿åº¦ æ³¨é‡Š
     *
     * @param queryDataService
     * @return
     */
    private Map<String, List<Map<String, Object>>> getPSqlFieldInfo(String instance, QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT case when column_length<0  then 0 else  column_length end as column_length,table_name,\"column_name\",column_type,column_comment FROM ( ");
        sql.append(" SELECT C ");
        sql.append(" .relname AS \"table_name\", ");
        sql.append(" A.attname AS \"column_name\", ");
        sql.append(" ( CASE WHEN A.attlen > 0 THEN A.attlen ELSE A.atttypmod - 4 END ) AS \"column_length\", ");
        sql.append(" replace(format_type ( A.atttypid, A.atttypmod ),substring(format_type ( A.atttypid, A.atttypmod ),\"position\"(format_type ( A.atttypid, A.atttypmod ),'('),\"position\"" +
                "(format_type ( A.atttypid, A.atttypmod ),')')),'') AS \"column_type\", ");
        sql.append(" d.description AS \"column_comment\" ");
        sql.append(" FROM ");
        sql.append(" pg_attribute ");
        sql.append(" A LEFT JOIN pg_description d ON d.objoid = A.attrelid ");
        sql.append(" AND d.objsubid = A.attnum ");
        sql.append(" LEFT JOIN pg_class C ON A.attrelid = C.oid ");
        sql.append(" LEFT JOIN pg_type T ON A.atttypid = T.oid ");
        sql.append(" WHERE ");
        sql.append(" A.attnum >= 0 ");
        sql.append(" AND C.relname IN ( SELECT \"tablename\" FROM pg_tables WHERE schemaname = ? ) ");
        sql.append(" ) A ");
    /**
     * æŸ¥è¯¢PSQL数据库 å­—段名称 ç±»åž‹ é•¿åº¦ æ³¨é‡Š
     *
     * @param queryDataService
     * @return
     */
    public Map<String, List<Map<String, Object>>> getPSqlFieldInfo(String instance, QueryDataService queryDataService) {
        StringBuilder sql = new StringBuilder();
        sql.append(" SELECT case when column_length<0  then 0 else  column_length end as column_length,table_name,\"column_name\",column_type,column_comment FROM ( ");
        sql.append(" SELECT C ");
        sql.append(" .relname AS \"table_name\", ");
        sql.append(" A.attname AS \"column_name\", ");
        sql.append(" ( CASE WHEN A.attlen > 0 THEN A.attlen ELSE A.atttypmod - 4 END ) AS \"column_length\", ");
        sql.append(" replace(format_type ( A.atttypid, A.atttypmod ),substring(format_type ( A.atttypid, A.atttypmod ),\"position\"(format_type ( A.atttypid, A.atttypmod ),'('),\"position\"" +
                "(format_type ( A.atttypid, A.atttypmod ),')')),'') AS \"column_type\", ");
        sql.append(" d.description AS \"column_comment\" ");
        sql.append(" FROM ");
        sql.append(" pg_attribute ");
        sql.append(" A LEFT JOIN pg_description d ON d.objoid = A.attrelid ");
        sql.append(" AND d.objsubid = A.attnum ");
        sql.append(" LEFT JOIN pg_class C ON A.attrelid = C.oid ");
        sql.append(" LEFT JOIN pg_type T ON A.atttypid = T.oid ");
        sql.append(" WHERE ");
        sql.append(" A.attnum >= 0 ");
        sql.append(" AND C.relname IN ( SELECT \"tablename\" FROM pg_tables WHERE schemaname = ? ) ");
        sql.append(" ) A ");

        QueryResultEntity queryResult = queryDataService.getResult(sql.toString(), new Object[]{instance}, null);
        List<Map<String, Object>> resultList = queryResult.getResult();
        Map<String, List<Map<String, Object>>> result = new HashMap<>();
        for (int i = 0; i < resultList.size(); i++) {
            Map<String, Object> fieldInfo = new CaseInsensitiveMap<>(resultList.get(i));
            resultList.set(i, fieldInfo);
            String column_type = (String) fieldInfo.get("column_type");
            if (fieldInfo.get("column_length") == null) {
                fieldInfo.put("column_length", 20);
            }
            String tableName = (String) fieldInfo.get("table_name");
            if (StringUtils.isEmpty(tableName)) {
                continue;
            }
            //小数需要转换
            if (column_type.toLowerCase().indexOf("numeric") != -1 && NumberUtil.isNumber(fieldInfo.get("column_length").toString())) {
                int columnLength = NumberUtil.parseInt(fieldInfo.get("column_length").toString());
                int column_length = columnLength >> 16;
                int column_scale = columnLength & 255;
                if (column_scale > 30) {
                    column_scale = 30;
                }
                if (column_length < column_scale) {
                    column_length = column_scale;
                }
                fieldInfo.put("column_length", column_length);
                fieldInfo.put("column_scale", column_scale);
            } else if ("date".equalsIgnoreCase(column_type)) {
                //日期
                fieldInfo.put("column_length", 0);
                fieldInfo.put("column_scale", 0);
            } else if ("real".equalsIgnoreCase(column_type)) {
                //可变精度 å°†å°æ•° å’Œé•¿åº¦éƒ½è®¾ä¸ºä¸€è‡´  PSQL æ•°æ®åº“ float æœ€å¤§æ”¯æŒ 15位 MYSQL 30位
                fieldInfo.put("column_length", fieldInfo.get("column_length"));
                fieldInfo.put("column_scale", fieldInfo.get("column_length"));
            } else if ("text".equalsIgnoreCase(column_type)) {
                fieldInfo.put("column_length", 8000);
            } else {
                fieldInfo.put("column_scale", 0);
            }
            List<Map<String, Object>> table_name = result.get(tableName);
            if (table_name == null) {
                table_name = new ArrayList<>();
                result.put(tableName, table_name);
            }
            table_name.add(fieldInfo);
        }
        return result;
    }
        QueryResultEntity queryResult = queryDataService.getResult(sql.toString(), new Object[]{instance}, null);
        List<Map<String, Object>> resultList = queryResult.getResult();
        Map<String, List<Map<String, Object>>> result = new HashMap<>();
        for (int i = 0; i < resultList.size(); i++) {
            Map<String, Object> fieldInfo = new CaseInsensitiveMap<>(resultList.get(i));
            resultList.set(i, fieldInfo);
            String column_type = (String) fieldInfo.get("column_type");
            if (fieldInfo.get("column_length") == null) {
                fieldInfo.put("column_length", 20);
            }
            String tableName = (String) fieldInfo.get("table_name");
            if (StringUtils.isEmpty(tableName)) {
                continue;
            }
            //小数需要转换
            if (column_type.toLowerCase().indexOf("numeric") != -1 && NumberUtil.isNumber(fieldInfo.get("column_length").toString())) {
                int columnLength = NumberUtil.parseInt(fieldInfo.get("column_length").toString());
                int column_length = columnLength >> 16;
                int column_scale = columnLength & 255;
                if (column_scale > 30) {
                    column_scale = 30;
                }
                if (column_length < column_scale) {
                    column_length = column_scale;
                }
                fieldInfo.put("column_length", column_length);
                fieldInfo.put("column_scale", column_scale);
            } else if ("date".equalsIgnoreCase(column_type)) {
                //日期
                fieldInfo.put("column_length", 0);
                fieldInfo.put("column_scale", 0);
            } else if ("real".equalsIgnoreCase(column_type)) {
                //可变精度 å°†å°æ•° å’Œé•¿åº¦éƒ½è®¾ä¸ºä¸€è‡´  PSQL æ•°æ®åº“ float æœ€å¤§æ”¯æŒ 15位 MYSQL 30位
                fieldInfo.put("column_length", fieldInfo.get("column_length"));
                fieldInfo.put("column_scale", fieldInfo.get("column_length"));
            } else if ("text".equalsIgnoreCase(column_type)) {
                fieldInfo.put("column_length", 8000);
            } else {
                fieldInfo.put("column_scale", 0);
            }
            List<Map<String, Object>> table_name = result.get(tableName);
            if (table_name == null) {
                table_name = new ArrayList<>();
                result.put(tableName, table_name);
            }
            table_name.add(fieldInfo);
        }
        return result;
    }

    /**
     * èŽ·å–字段名称
     *
     * @param queryDataService
     * @param tableName
     * @param dbe
     * @return
     */
    private void getFieldName(QueryDataService queryDataService, String tableName, DatabaseEntity dbe, String uuid, DataTableEntity dt, Map<String, String> fieldTypeReference, List<Map<String, Object>> resultList) {
        DatabaseType dbt = dbe.getDbType();
        if (DatabaseType.MySql.equals(dbt)) {
            resultList = getMysqlFieldInfo(tableName, queryDataService);
        } else if (DatabaseType.Oracle.equals(dbt)) {
    public void getFieldName(String saveTableName, QueryDataService queryDataService, String tableName, DatabaseEntity dbe, String uuid, DataTableEntity dt, Map<String, String> fieldTypeReference, List<Map<String, Object>> resultList) {
        DatabaseType dbt = dbe.getDbType();
        if (DatabaseType.MySql.equals(dbt)) {
            resultList = getMysqlFieldInfo(tableName, queryDataService);
        } else if (DatabaseType.Oracle.equals(dbt)) {
//            resultList = getOracleFieldInfoSql(tableName, queryDataService);
        } else if (DatabaseType.SqlServer.equals(dbt)) {
            resultList = getSqlServerFieldInfo(tableName, queryDataService);
        } else if (DatabaseType.Informix.equals(dbt)) {
        } else if (DatabaseType.SqlServer.equals(dbt)) {
            resultList = getSqlServerFieldInfo(tableName, queryDataService);
        } else if (DatabaseType.Informix.equals(dbt)) {
//            QueryResultEntity queryResult = queryDataService.getResult(" SELECT colname COLUMN_NAME from \"informix\".syscolumns where tabid = ( " +
//                    String.format(" SELECT tabid FROM \"informix\".systables WHERE tabname = '%s') ", tableName));
            resultList = getInformixFieldInfo(dbe.getDbName(), tableName, queryDataService);
        } else if (DatabaseType.PSQL.equals(dbt)) {
            resultList = getInformixFieldInfo(dbe.getDbName(), tableName, queryDataService);
        } else if (DatabaseType.PSQL.equals(dbt)) {

        } else {
            return;
        }
        if (resultList != null) {
            for (int i = 0; i < resultList.size(); i++) {
                // å­—段名
                Object column_mame = resultList.get(i).get("column_name");
                if (column_mame == null) {
                    column_mame = resultList.get(i).get("column_name".toUpperCase());
                }
                // æ³¨é‡Š
                Object column_comment = resultList.get(i).get("column_comment");
                if (column_comment == null) {
                    column_comment = resultList.get(i).get("column_comment".toUpperCase());
                }
                // ç±»åž‹
                Object column_type = resultList.get(i).get("column_type");
                if (column_type == null) {
                    column_type = resultList.get(i).get("column_type".toUpperCase());
                }
                //长度
                Object column_length = resultList.get(i).get("column_length");
                if (column_length == null) {
                    column_length = resultList.get(i).get("column_length".toUpperCase());
                }
                // ç²¾åº¦
                Object column_scale = resultList.get(i).get("column_scale");
                if (column_scale == null) {
                    column_scale = resultList.get(i).get("column_scale".toUpperCase());
                }
                FieldSetEntity field = new FieldSetEntity();
                field.setTableName(CmnConst.PRODUCT_SYS_DATABASE_TABLENAME_FIELD);
                field.setValue("sync_manager_uuid", uuid);
                //表名
                field.setValue("table_name", tableName.toLowerCase());
                //字段名
                field.setValue("field_name", column_mame.toString().toLowerCase());
                //字段描述
                field.setValue("field_desc", column_comment);
                //字段长度
                field.setValue("field_length", "text".equalsIgnoreCase(column_type != null ? column_type.toString() : "") ? 0 : column_length);
                //字段精度
                field.setValue("field_unit", column_scale);
                //字段类型
                String field_type = fieldTypeReference == null ? null : fieldTypeReference.get(column_type);
                if (field_type == null) {
                    System.out.println(field_type);
                }
                field.setValue(CmnConst.FIELD_TYPE, field_type == null ? "string" : field_type);
        } else {
            return;
        }
        if (resultList != null) {
            for (int i = 0; i < resultList.size(); i++) {
                // å­—段名
                Object column_mame = resultList.get(i).get("column_name");
                if (column_mame == null) {
                    column_mame = resultList.get(i).get("column_name".toUpperCase());
                }
                // æ³¨é‡Š
                Object column_comment = resultList.get(i).get("column_comment");
                if (column_comment == null) {
                    column_comment = resultList.get(i).get("column_comment".toUpperCase());
                }
                // ç±»åž‹
                Object column_type = resultList.get(i).get("column_type");
                if (column_type == null) {
                    column_type = resultList.get(i).get("column_type".toUpperCase());
                }
                //长度
                Object column_length = resultList.get(i).get("column_length");
                if (column_length == null) {
                    column_length = resultList.get(i).get("column_length".toUpperCase());
                }
                // ç²¾åº¦
                Object column_scale = resultList.get(i).get("column_scale");
                if (column_scale == null) {
                    column_scale = resultList.get(i).get("column_scale".toUpperCase());
                }
                FieldSetEntity field = new FieldSetEntity();
                field.setTableName(saveTableName);
                if (CmnConst.PRODUCT_SYS_DATABASE_TABLENAME_FIELD.equals(saveTableName)) {
                    field.setValue("sync_manager_uuid", uuid);
                }
                //表名
                field.setValue("table_name", tableName.toLowerCase());
                //字段名
                field.setValue("field_name", column_mame.toString().toLowerCase());
                //字段描述
                field.setValue("field_desc", column_comment);
                //字段长度
                field.setValue("field_length", "text".equalsIgnoreCase(column_type != null ? column_type.toString() : "") ? 0 : column_length);
                //字段精度
                field.setValue("field_unit", column_scale);
                //字段类型
                String field_type = fieldTypeReference == null ? null : fieldTypeReference.get(column_type);
                if (field_type == null) {
                    System.out.println(field_type);
                }
                field.setValue(CmnConst.FIELD_TYPE, field_type == null ? "string" : field_type);

                dt.addFieldSetEntity(field);
            }
        }
    }
                dt.addFieldSetEntity(field);
            }
        }

    /**
     * èŽ·å–表名
     *
     * @param queryDataService
     * @param dbe
     * @return
     */
    private String[] getTableName(QueryDataService queryDataService, DatabaseEntity dbe) {
        if (dbe != null && dbe.getDbType() != null) {
            DatabaseType dbt = dbe.getDbType();
            String sql = null;
            if (DatabaseType.MySql.equals(dbt)) {             //数据库名称
                sql = String.format("select TABLE_NAME as table_name from information_schema.COLUMNS WHERE TABLE_SCHEMA = '%s' group by TABLE_NAME", dbe.getDbName());
            } else if (DatabaseType.Oracle.equals(dbt)) {                                //用户名 åˆ†å¤§å°å†™
    }

    /**
     * èŽ·å–字段名称
     *
     * @param queryDataService
     * @param tableName
     * @param dbe
     * @return
     */
    public void getFieldName(QueryDataService queryDataService, String tableName, DatabaseEntity dbe, String uuid, DataTableEntity dt, Map<String, String> fieldTypeReference, List<Map<String, Object>> resultList) {
        getFieldName(CmnConst.PRODUCT_SYS_DATABASE_TABLENAME_FIELD, queryDataService, tableName, dbe, uuid, dt, fieldTypeReference, resultList);
    }

    /**
     * èŽ·å–表名
     *
     * @param queryDataService
     * @param dbe
     * @return
     */
    public String[] getTableName(QueryDataService queryDataService, DatabaseEntity dbe) {
        if (dbe != null && dbe.getDbType() != null) {
            DatabaseType dbt = dbe.getDbType();
            String sql = null;
            if (DatabaseType.MySql.equals(dbt)) {             //数据库名称
                sql = String.format("select TABLE_NAME as table_name from information_schema.COLUMNS WHERE TABLE_SCHEMA = '%s' group by TABLE_NAME", dbe.getDbName());
            } else if (DatabaseType.Oracle.equals(dbt)) {                                //用户名 åˆ†å¤§å°å†™
//                sql = String.format("select TABLE_NAME as table_name from user_tab_columns  GROUP BY TABLE_NAME  ");
                //oracle使用一次性查询方式获取表字段
                return null;
            } else if (DatabaseType.SqlServer.equals(dbt)) {
                //数据库名称
                sql = String.format("SELECT name as table_name  FROM %s..SysObjects Where XType='U' ", dbe.getDbName());
            } else if (DatabaseType.Informix.equals(dbt)) {                            //数据库名称
                sql = String.format("SELECT tabname as table_name FROM \"informix\".systables WHERE tabtype = 'T' AND tabid >= 100  and owner ='%s'", dbe.getDbName());
            } else if (DatabaseType.PSQL.equals(dbt)) {
                //PSQL使用一次性查询方式获取表字段
                return null;
            }
            if (sql != null && queryDataService != null) {
                QueryResultEntity queryResult = queryDataService.getResult(sql);
                List<Map<String, Object>> resultList = queryResult.getResult();
                String[] tableName = new String[resultList.size()];
                for (int i = 0; i < resultList.size(); i++) {
                    Object table_name = resultList.get(i).get("table_name");
                    if (table_name == null) {
                        table_name = resultList.get(i).get("table_name".toUpperCase());
                    }
                    tableName[i] = (String) table_name;
                }
                return tableName;
            }
        }
        return new String[]{};
    }
                //oracle使用一次性查询方式获取表字段
                return null;
            } else if (DatabaseType.SqlServer.equals(dbt)) {
                //数据库名称
                sql = String.format("SELECT name as table_name  FROM %s..SysObjects Where XType='U' ", dbe.getDbName());
            } else if (DatabaseType.Informix.equals(dbt)) {                            //数据库名称
                sql = String.format("SELECT tabname as table_name FROM \"informix\".systables WHERE tabtype = 'T' AND tabid >= 100  and owner ='%s'", dbe.getDbName());
            } else if (DatabaseType.PSQL.equals(dbt)) {
                //PSQL使用一次性查询方式获取表字段
                return null;
            }
            if (sql != null && queryDataService != null) {
                QueryResultEntity queryResult = queryDataService.getResult(sql);
                List<Map<String, Object>> resultList = queryResult.getResult();
                String[] tableName = new String[resultList.size()];
                for (int i = 0; i < resultList.size(); i++) {
                    Object table_name = resultList.get(i).get("table_name");
                    if (table_name == null) {
                        table_name = resultList.get(i).get("table_name".toUpperCase());
                    }
                    tableName[i] = (String) table_name;
                }
                return tableName;
            }
        }
        return new String[]{};
    }


    private void getSourceTableField(Connection connection, DatabaseType dbt, String uuid) {
        String sql = null;
    private void getSourceTableField(Connection connection, DatabaseType dbt, String uuid) {
        String sql = null;
//        if (DatabaseType.MySql.equals(dbt)) {             //数据库名称
//            sql = "select COLUMN_NAME from information_schema.COLUMNS WHERE TABLE_SCHEMA = '" + configField.getString(CmnConst.DATABASE_NAME) + "' AND TABLE_NAME = '" + tableName + "'";
//        } else if (DatabaseType.Oracle.equals(dbt)) {                                //用户名 åˆ†å¤§å°å†™
@@ -963,5 +970,5 @@
//            sql = " SELECT colname COLUMN_NAME from \"informix\".syscolumns where tabid = ( " +
//                    " SELECT tabid FROM \"informix\".systables WHERE tabname = '" + tableName + "'); ";
//        }
    }
    }
}

 src/main/java/com/product/data/service/impl/IDataSourceConfigService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package com.product.data.service.impl;

import com.product.core.entity.FieldSetEntity;
import com.product.core.exception.BaseException;

/**
 * @Author cheng
 * @Date 2024/8/13 18:20
 * @Desc æ•°æ®æºé…ç½®
 */
public interface IDataSourceConfigService {

    void save(FieldSetEntity fse) throws BaseException;


    void delete(FieldSetEntity fse) throws BaseException;
}