Java实现相似结构表算法

【产品需求】

对所有元数据进行分析,匹配出表字段相似度达到阈值的向相似结构表关系数据。

网上没有搜到相关算法实现,只能自己动手了。

 

【算法实现】

简单点实现的话,可以轮询所有表,每张表都和其它表进行匹配相似度,不过这是人干的事?如果有1W张表岂不要查询1W × 9999次?

 

1、先统计出相同字段、表、表字段数量,其中相同字段对应的多个表和表字段数量通过行合并成字符串用逗号分隔,BXX:表信息、BZD:表字段信息,查询SQL脚本和查询结果如下:

SELECT 
    *
FROM (
    SELECT BZD.ZDYWM, BZD.ZDZWM, BZD.ZDLX, count(1) AS "same", GROUP_CONCAT(BZD.B_ID) AS "bIds", GROUP_CONCAT(BXX.ZDSL) AS "zdsl"
    FROM BZD LEFT JOIN BXX ON BZD.B_ID = BXX.ID 
    WHERE BXX.SFSC = 'N' AND BZD.SFSC = 'N'
    GROUP BY BZD.ZDYWM, BZD.ZDZWM, BZD.ZDLX
) _ALL 
WHERE SAME > 1

 

 

 

2、现在已经知道了相同字段和表之间的联系

我们来分析一下,统计出来的一条数据,代表某个字段在多个表同时存在,表和表之间构成了一次相同字段

后面我们只需要把所有数据通过算法计算一边,计算统计数据中表和表之间两两存在相同字段的数量,并和表本身的字段数量比较,达到相似结构表阈值的两张表即互为相似结构表

具体算法如下:

/**
     * 相似结构表数据计算写入
     * 实现思路:
     * 1、group by字段信息表,查询存在重复的字段及表Id、表字段数量;
     * 2、查询出的一条数据代表某一字段多个表都存在;
     * 3、循环所有数据找出表和表之间存在相同字段的数量累加,数据结构如下;
     * -------------------------------------------------------------
     * 本表  本表字段数量  ->   可能存在相似结构的表1     相同字段数量
     *                         可能存在相似结构的表2     相同字段数量
     *                         可能存在相似结构的表3     相同字段数量
     *                         可能存在相似结构的表4     相同字段数量
     * -------------------------------------------------------------
     * 4、根据阈值计算符合相似结构表之间的关系;
     */
    @Override
    public void insert() {

        // 查询存在重复字段的表信息
        // --------------------------------------------------------------------------------
        // 字段英文名、字段中文名、字段类型、bId1,bId2,bId3,bId4、bzdsl1,bzdsl2,bzdsl3,bzdsl4
        // --------------------------------------------------------------------------------
        List<XsjgbzdxxDTO> xsjgbzdxxes = null;
        try {
            xsjgbzdxxes = xsjgbDao.selectColumnGroup();
        } catch (Exception e) {
            log.error("查询存在重复字段的表信息出错", e);
            return ;
        }

        // 非空效验
        if (CollectionUtils.isEmpty(xsjgbzdxxes)) {
            log.warn("没有查询到重复字段的表信息");
            return ;
        }

        // 统计相似结果表数据集合
        List<Xsjgbxx> xsjgbxxes = null;
        xsjgbxxes = new ArrayList<>();

        // 同一字段多个表都存在的表Id
        List<String> bIds = null;
        // 同一字段多个表都存在的表字段数量
        List<Integer> zdsl = null;

        Xsjgbxx b1, b2;

        // 每行数据都是一个字段多个表都存在的相同字段
        for (XsjgbzdxxDTO xsjgbzdxx : xsjgbzdxxes) {

            // 非空效验
            if (StringUtils.isEmpty(xsjgbzdxx.getBIds()) || StringUtils.isEmpty(xsjgbzdxx.getZdsl())) {
                log.warn("表Id为空或表字段数量为空, xsjgbzdxx[{}]", JSONObject.toJSONString(xsjgbzdxx));
                continue;
            }

            // 获取所有表Id
            bIds = Arrays.asList(xsjgbzdxx.getBIds().split(","));
            // 获取所有表字段数量
            zdsl = Arrays.asList(xsjgbzdxx.getZdsl().split(",")).stream().map(Integer::parseInt).collect(Collectors.toList());

            // 相同字段多个表两两配对
            for (int i=0 ; i<bIds.size() ; i++) {

                for (int j=(i+1) ; j<bIds.size() ; j++) {

                    // 查找当前匹配的两张表的相似结构表信息对象
                    b1 = find(xsjgbxxes, bIds.get(i), zdsl.get(i));
                    b2 = find(xsjgbxxes, bIds.get(j), zdsl.get(j));

                    // 当前循环中的两个中互为疑似相似表
                    // 增加疑似相似表及相似字段数量
                    this.addColumnNum(b1, b2.getBId());
                    this.addColumnNum(b2, b1.getBId());

                }
            }

        }

        List<Xsjgb> xsjgbs = this.filter(xsjgbxxes);

        // 相似结构表数据入库
        xsjgbDao.insertList(xsjgbs);

    }

    /**
     * 根据表Id在相似表统计集合中查找对应的相似结构表信息
     * @param xsjgbxxes
     * @param bId
     * @return
     */
    private Xsjgbxx find(List<Xsjgbxx> xsjgbxxes, String bId, Integer zdsl) {
        Xsjgbxx xsjgbxx = xsjgbxxes.stream().filter(item -> Objects.equals(item.getBId(), bId)).findFirst().orElse(null);
        if (Objects.isNull(xsjgbxx)) {
            xsjgbxx = new Xsjgbxx(bId, zdsl);
            xsjgbxxes.add(xsjgbxx);
        }
        return xsjgbxx;
    }

    /**
     * 增加表对应的疑似相似结构表相似字段数量
     * @param xsjgbxx
     * @param xsbId
     */
    private void addColumnNum(Xsjgbxx xsjgbxx, String xsbId) {
        // 找到相似表信息
        XsjgGxbxx xsjgGxbxx = xsjgbxx.getXsjgGxbxxes().stream().filter(item -> Objects.equals(item.getXsbId(), xsbId)).findFirst().orElse(null);
        // 判断是否存在相似表信息
        if (Objects.isNull(xsjgGxbxx)) {
            // 记录新的相似表信息
            xsjgbxx.getXsjgGxbxxes().add(new XsjgGxbxx(xsbId));
        } else {
            // 相似字段数量累加
            xsjgGxbxx.increment();
        }
    }

    /**
     * 根据统计出来的疑似相似结构表和相似度阈值过滤出相似结构表信息
     * @param xsjgbxxes
     * @return
     */
    private List<Xsjgb> filter(List<Xsjgbxx> xsjgbxxes) {

        List<Xsjgb> xsjgbs = null;
        xsjgbs = new ArrayList<>();

        for (Xsjgbxx xsjgbxx : xsjgbxxes) {

            for (XsjgGxbxx xsjgGxbxx : xsjgbxx.getXsjgGxbxxes()) {

                // 相似表的相似字段数量除以本表的字段数量
                // 大于相似度阈值的计入相似结构表
                if (new BigDecimal(xsjgGxbxx.getXszdsl()).divide(new BigDecimal(xsjgbxx.getZdsl()), 20, BigDecimal.ROUND_HALF_UP).compareTo(XsjgbServiceImpl.DISTANCE) >= 0) {
                    xsjgbs.add(new Xsjgb(xsjgbxx.getBId(), xsjgGxbxx.getXsbId()));
                }

            }

        }

        return xsjgbs;

    }

 

public class XsjgGxbxx implements Serializable {

    private static final long serialVersionUID = -8772273934672363080L;

    /**
     * 可能存在相似结构的表Id
     */
    private String xsbId;

    /**
     * 相似字段数量
     */
    private Integer xszdsl;

    public XsjgGxbxx(String xsbId) {
        this.xsbId = xsbId;
        this.xszdsl = new Integer(1);
    }

    public void increment() {
        this.xszdsl += 1;
    }

}

 

public class Xsjgb extends EntityBean {

    @Transient
    private static final long serialVersionUID = 1L;
    /**
     * 表Id
     */private String bId;

    /**
     * 数据包标识 (可作为表名的组成部分)
     */private String xsjgbId;

    public Xsjgb(@NotEmpty String bId, @NotEmpty String xsjgbId) {
        this.bId = bId;
        this.xsjgbId = xsjgbId;
    }
}

 

public class Xsjgbxx implements Serializable {

    private static final long serialVersionUID = -6162813536053634882L;

    /**
     * 表Id
     */
    private String bId;

    /**
     * 表字段数量
     */
    private Integer zdsl;

    /**
     * 可能存在相似结构的表
     */
    private List<XsjgGxbxx> xsjgGxbxxes;

    public Xsjgbxx(String bId, Integer zdsl) {
        this.bId = bId;
        this.zdsl = zdsl;
        this.xsjgGxbxxes = new ArrayList<>();
    }
}

 

public class XsjgbzdxxDTO implements Serializable {

    private static final long serialVersionUID = 8209530764411503009L;

    /**
     * 字段英文名
     */
    private String zdywm;

    /**
     * 字段中文名
     */
    private String zdzwm;

    /**
     * 字段类型
     */
    private String zdlx;

    /**
     * 相同字段的表Id,英文逗号分隔
     */
    private String bIds;

    /**
     * 相同字段的表字段数量,英文逗号分隔
     */
    private String zdsl;

}

 

posted @ 2020-09-04 18:47  codest  阅读(193)  评论(0编辑  收藏  举报