HIVE数仓数据血缘分析工具-SQL解析_数据仓库血缘分析工具-优快云博客

一、数仓经常会碰到的几类问题：
1、两个数据报表进行对比，结果差异很大，需要人工核对分析指标的维度信息，比如从头分析数据指标从哪里来，处理条件是什么，最后才能分析出问题原因。
2、基础数据表因某种原因需要修改字段，需要评估其对数仓的影响，费时费力，然后在做方案。

二、问题分析：
数据源长途跋涉，经过大量的处理和组件来传递，呈现在业务用户面前，对数据进行回溯其实很难。元数据回溯在有效决策、策略制定、差异分析等过程中很重要。这两类问题都属于数据血缘分析问题，第一类叫做数据回溯、第二类叫做影响分析，是数据回溯的逆向。

三、解决方法：
自己实现了一套基于hive数仓的数据血缘分析工具，来完成各个数据表、字段之间的关系梳理，进而解决上面两个问题。

工具主要目标：解析计算脚本中的HQL语句，分析得到输入输出表、输入输出字段和相应的处理条件，进行分析展现。
实现思路：对AST深度优先遍历，遇到操作的token则判断当前的操作，遇到子句则压栈当前处理，处理子句。子句处理完，栈弹出。处理字句的过程中，遇到子查询就保存当前子查询的信息，判断与其父查询的关系，最终形成树形结构；遇到字段或者条件处理则记录当前的字段和条件信息、组成Block，嵌套调用。
关键点解析：
1、遇到TOK_TAB或TOK_TABREF则判断出当前操作的表
2、压栈判断是否是join，判断join条件
3、定义数据结构Block,遇到在where\select\join时获得其下相应的字段和条件，组成Block
4、定义数据结构ColLine,遇到TOK_SUBQUERY保存当前的子查询信息，供父查询使用
5、定义数据结构ColLine,遇到TOK_UNION结束时，合并并截断当前的列信息
6、遇到select　或者未明确指出的字段，查询元数据进行辅助分析
7、解析结果进行相关校验

代码地址：http://download.youkuaiyun.com/detail/thomas0yang/9354943
https://download.youkuaiyun.com/download/thomas0yang/9369949
懒得改成github了☺

代码如下：
Block类

package com.xiaoju.products.parse;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import java.util.Map.Entry;
import java.util.LinkedHashSet;

import org.antlr.runtime.tree.Tree;
import org.apache.hadoop.hive.ql.parse.ASTNode;
import org.apache.hadoop.hive.ql.parse.BaseSemanticAnalyzer;
import org.apache.hadoop.hive.ql.parse.HiveParser;
import org.apache.hadoop.hive.ql.parse.ParseDriver;

import com.xiaoju.products.bean.Block;
import com.xiaoju.products.bean.ColLine;
import com.xiaoju.products.bean.QueryTree;
import com.xiaoju.products.exception.SQLParseException;
import com.xiaoju.products.exception.UnSupportedException;
import com.xiaoju.products.util.Check;
import com.xiaoju.products.util.MetaCache;
import com.xiaoju.products.util.NumberUtil;
import com.xiaoju.products.util.ParseUtil;
import com.xiaoju.products.util.PropertyFileUtil;

/**
 * hive sql解析类
 * 
 * 目的：实现HQL的语句解析，分析出输入输出表、字段和相应的处理条件。为字段级别的数据血缘提供基础。
 * 重点：获取SELECT操作中的表和列的相关操作。其他操作这判断到字段级别。
 * 实现思路：对AST深度优先遍历，遇到操作的token则判断当前的操作，遇到子句则压栈当前处理，处理子句。子句处理完，栈弹出。
 * 处理字句的过程中，遇到子查询就保存当前子查询的信息，判断与其父查询的关系，最终形成树形结构；
 * 遇到字段或者条件处理则记录当前的字段和条件信息、组成Block，嵌套调用。 
 * 关键点解析 
 * 		   1、遇到TOK_TAB或TOK_TABREF则判断出当前操作的表
 *         2、压栈判断是否是join，判断join条件
 *         3、定义数据结构Block,遇到在where\select\join时获得其下相应的字段和条件，组成Block
 *         4、定义数据结构ColLine,遇到TOK_SUBQUERY保存当前的子查询信息，供父查询使用
 *         5、定义数据结构ColLine,遇到TOK_UNION结束时，合并并截断当前的列信息
 *         6、遇到select *　或者未明确指出的字段，查询元数据进行辅助分析
 *         7、解析结果进行相关校验
 * 试用范围：
 * 1、支持标准SQL 
 * 2、不支持transform using script
 *        
 * @author yangyangthomas     
 *    
 */
public class LineParser {
	
	private static final String SPLIT_DOT = ".";
	private static final String SPLIT_COMMA = ",";
	private static final String SPLIT_AND = "&";
	private static final String TOK_EOF = "<EOF>";
	private static final String CON_WHERE = "WHERE:";
	private static final String TOK_TMP_FILE = "TOK_TMP_FILE";
	
    private Map<String /*table*/, List<String/*column*/>> dbMap = new HashMap<String, List<String>>();
    private List<QueryTree> queryTreeList = new ArrayList<QueryTree>(); //子查询树形关系保存
    
    private Stack<Set<String>> conditionsStack = new Stack<Set<String>>();
    private Stack<List<ColLine>> colsStack = new Stack<List<ColLine>>();
    
    private Map<String, List<ColLine>> resultQueryMap = new HashMap<String,  List<ColLine>>();
	private Set<String> conditions = new HashSet<String>(); //where or join 条件缓存
	private List<ColLine> cols = new ArrayList<ColLine>(); //一个子查询内的列缓存
	
	private Stack<String> tableNameStack = new Stack<String>();
    private Stack<Boolean> joinStack = new Stack<Boolean>();
    private Stack<ASTNode> joinOnStack = new Stack<ASTNode>();
    
    private Map<String, QueryTree> queryMap = new HashMap<String, QueryTree>();
    private boolean joinClause = false;
    private ASTNode joinOn = null;
    private String nowQueryDB = "default"; //hive的默认库
    private boolean isCreateTable = false;
    
    //结果
    private List<ColLine> colLines = new ArrayList<ColLine>();  
    private Set<String> outputTables = new HashSet<String>();
    private Set<String> inputTables = new HashSet<String>();
    
    private List<ColLine> tmpColLines = new ArrayList<ColLine>();  
    private Set<String> tmpOutputTables = new HashSet<String>();
    private Set<String> tmpInputTables = new HashSet<String>();
    
    public List<ColLine> getColLines() {
 		return colLines;
 	}
    public Set<String> getOutputTables() {
		return outputTables;
	}
	public Set<String> getInputTables() {
		return inputTables;
	}

    private void parseIteral(ASTNode ast) {
        prepareToParseCurrentNodeAndChilds(ast);
        parseChildNodes(ast);
        parseCurrentNode(ast);
        endParseCurrentNode(ast);
    }

    /**
     * 解析当前节点
     * @param ast
     * @param set
     * @return
     */
    private void parseCurrentNode(ASTNode ast){
        if (ast.getToken() != null) {
            switch (ast.getToken().getType()) {
		    case HiveParser.TOK_CREATETABLE: //outputtable
		    	isCreateTable = true;
		    	String tableOut = fillDB(BaseSemanticAnalyzer.getUnescapedName((ASTNode) ast.getChild(0)));
		    	tmpOutputTables.add(tableOut);
		    	MetaCache.getInstance().init(tableOut); //初始化数据，供以后使用
		    	break;
            case HiveParser.TOK_TAB:// outputTable
                String tableTab = BaseSemanticAnalyzer.getUnescapedName((ASTNode) ast.getChild(0));
                String tableOut2 = fillDB(tableTab);
                tmpOutputTables.add(tableOut2);
                MetaCache.getInstance().init(tableOut2); //初始化数据，供以后使用
                break;
            case HiveParser.TOK_TABREF:// inputTable
                ASTNode tabTree = (ASTNode) ast.getChild(0);
                String tableInFull = fillDB((tabTree.getChildCount() == 1) ?  
                		BaseSemanticAnalyzer.getUnescapedName((ASTNode) tabTree.getChild(0))
                		: BaseSemanticAnalyzer.getUnescapedName((ASTNode) tabTree.getChild(0))
                        + SPLIT_DOT + BaseSemanticAnalyzer.getUnescapedName((ASTNode) tabTree.getChild(1))
                		);
                String tableIn = tableInFull.substring(tableInFull.indexOf(SPLIT_DOT) + 1);	
                tmpInputTables.add(tableInFull);
                MetaCache.getInstance().init(tableInFull); //初始化数据，供以后使用
                queryMap.clear();
                String alia = null;
                if (ast.getChild(1) != null) { //(TOK_TABREF (TOK_TABNAME detail usersequence_client) c) 
                    alia = ast.getChild(1).getText().toLowerCase();
                    QueryTree qt = new QueryTree();
                    qt.setCurrent(alia);
                    qt.getTableSet().add(tableInFull);
                    QueryTree pTree = getSubQueryParent(ast);
                    qt.setpId(pTree.getpId());
                    qt.setParent(pTree.getParent());
                    queryTreeList.add(qt);
                    if (joinClause && ast.getParent() == joinOn) { // TOK_SUBQUERY join TOK_TABREF ,此处的TOK_SUBQUERY信息不应该清楚
                        for (QueryTree entry : queryTreeList) { //当前的查询范围
    						if (qt.getParent().equals(entry.getParent())) {
    							queryMap.put(entry.getCurrent(), entry);
    						}
    					}
					} else {
						queryMap.put(qt.getCurrent(), qt);
					}