Pig源码分析: 逻辑执行计划模块

Whole View

本文分析的是Pig Logical模块的代码(newplan package下),具体每种逻辑执行的实现类不会做具体分析。



Architecture

关键类/接口关系图


下面对关键类/接口具体实现做分析


Operator

public abstract class Operator {
    protected SourceLocation location; // The location of the operator in the original pig script.
    
    protected String name;
    protected OperatorPlan plan; // plan that contains this operator
    protected Map<String, Object> annotations;
    protected final int hashPrime = 31;

Operator的变量:

对name和plan提供get函数,构造函数传入name和plan。

对annotations提供get,annote,remove方法,来得到、添加、移除注释。

对locaiton提供get和set函数,且构造函数new SourceLocation()。


Operstor抽象方法:

主要方法为accept(PlanVisitor v),在PlanWalker里常用到。

还提供一个isEqual方法。

 

继承结构


主要看两类实现 LogicalExpression和LogicalRelationalOperator


LogicalExpression

public abstract class LogicalExpression extends Operator {

    static long nextUid = 1;
    protected LogicalSchema.LogicalFieldSchema fieldSchema;
    protected LogicalSchema.LogicalFieldSchema uidOnlyFieldSchema;

deepCopy()方法需要子类实现

 

继承结构:


子类实现略


LogicalRelationalOperator

LogicalRelationalOperator代表关系型操作,关系型操作有Schema。以下是主要变量,LogicalRelationalOperator为他们提供了一些get/set方法。

abstract public class LogicalRelationalOperator extends Operator {
    
    protected LogicalSchema schema;
    protected int requestedParallelism;
    protected String alias;
    protected int lineNum;
    
    /**
     * Name of the customPartitioner if one is used, this is set to null otherwise.
     */
    protected String mCustomPartitioner = null;
    
    /**
     * A HashSet to indicate whether an option (such a Join Type) was pinned
     * by the user or can be chosen at runtime by the optimizer.
     */
    protected HashSet<Integer> mPinnedOptions = new HashSet<Integer>();

关于LogicalSchema类:

内部类LogicalFieldSchema具体表示每一个field的结构,可以看到与LogicalSchema是嵌套的。LogicalSchema维护一个List<LogicalFieldSchema>

    public static class LogicalFieldSchema {
        public String alias;
        public byte type;
        public long uid;
        public LogicalSchema schema;

提供基本方法如下:



除了基本方法外,还提供一套merge schema的方法


继承结构:


子类实现略。


OperatorPlan

OperatorPlan是一个接口,定义了对Operator的图操作(Graph Operations)。

罗列了所有方法之后发现,Operator类虽然没有结构,只是一个普通的VO类。但是OperatorPlan这个接口定义的以下这套图操作,使OperstorOperator组成了一个Graph



实现结构:


下面展开分析。


OperatorSubPlan

OperatorSubPlan代表的是一个OperatorPlan的一个子集的视图,OperatorSubPlan只有一个实现,使用在Rule的match过程里。所以OperatorSubPlan的作用就是提供一个子Plan,用于匹配操作。


BaseOperatorPlan

BaseOperatorPlan实现了OperatorPlan接口,具体实现了各个图操作方法,把Operator之间的关系(包括softLink关系)用PlanEdge表示,图操作方法都借助PlanEdge类表达和实现。

public abstract class BaseOperatorPlan implements OperatorPlan {

    protected List<Operator> ops;
    protected PlanEdge fromEdges;
    protected PlanEdge toEdges;
    protected PlanEdge softFromEdges;
    protected PlanEdge softToEdges;

    private List<Operator> roots;
    private List<Operator> leaves;

比如:

toEdges.get(op)                  返回op的前辈

toEdges.get(op)==null       的op为root

fromEdges.get(op)             返回op的后辈

fromEdges.get(op)==null  的op为leave


PlanEdge类的实现:

public class PlanEdge extends MultiMap<Operator, Operator>

这里的MultiMap是Pig自己的工具类,Pig表示不使用Apache common的MultiMap是因为不支持序列化。

public class MultiMap<K, V> implements Serializable {

    // Change this if you modify the class.
    static final long serialVersionUID = 2L;

    protected Map<K, ArrayList<V>> mMap = null;

    public MultiMap() {
        mMap = new HashMap<K, ArrayList<V>>();
    }

因为MultiMap的value部分使用的是ArrayList,所以使得某些图操作支持position信息,如:

public Pair<Integer, Integer> disconnect(Operator from, Operator to)
public void connect(Operator from, int fromPos, Operator to, int toPos)

除了实现图操作方法外,BaseOperatorPlan还提供了explain()方法,子类会使用dpumper或printer来打印输出Operators层次结构。


继承结构:


主要看下LogicalPlan和LogicalExpressionPlan两个实现类。


LogicalPlan

LogicalPlan只包含关系型操作,也就是说涉及到的Operator都是LogicalRelationalOperator。

 

explain()方法既支持LogicalPlanPrinter的visit实现,也支持DotLOPrinter的dpump实现。

LogicalPlanPrinter是PlanVisitor的子类, LogicalPlanPrinter内部有一个PrintStream,在visit()过程中边遍历,边记录。

DotLOPrinter是DotPlanDumper的子类,DotPlanDumper是PlanDumper的子类,根据graphviz的dot algorithm,输出符合DOT格式的plan。


LogicalExpressionPlan

LogicalExpressionPlan处理的是LogicalExpressionOperators。

 

explain()方法借助LogicalPlanPrinter实现


PlanVisitor

访问者机制,用于操作一个plan。

内部有一个PlanWalker双向队列,PlanWalker会按照某种顺序遍历访问传入的OperatorPlan,让plan的每个operation accept该Visitor。

PlanVisitor可以进行push和pop walker的操作。visit()方法调用的是walker.walk(this)方法。



继承结构很可观


主要看LogicalExpressionVisitor、LogicalRelationalNodesVisitor这两大体系。前者访问expression plans,后者访问logical plans。


LogicalExpressionVisitor

LogicalExpressionVisitor初始化的时候会判断传入的OperatorPlan是否是LogicalExpressionPlan的子类。visit()方法们通过多态,接受LogicalExpression的子类。


LogicalRelationalNodesVisitor

LogicalRelationalNodesVisitor接受的OperatorPlan必须每个operator都是LogicalRelationalOperator的子类(初始化的时候会得到operator iterator对每个进行校验,不满足就抛异常)。visit()方法们通过多态,接受LogicalRelationalOperator的实现子类。


PlanWalker

PlanWalker提供的是遍历访问一个plan的能力。

PlanWalker的子类主要实现两个方法:

public abstract void walk(PlanVisitor visitor) throws FrontendException;

public abstract PlanWalker spawnChildWalker(OperatorPlan plan);

walk()方法在子类的实现中,会以不同的顺序遍历plan,最后的结果是遍历到的节点Operator会调op.accept(visitor)接受本Visitor


继承结构


接下来具体介绍各子类遍历能力的实现。


DependencyOrderWalker

DependencyOrderWalker按照依赖顺序访问plan,即一个node被访问的前提是它的前辈们已经被访问过了。这个访问顺序相当于,按照拓扑顺序访问图上的节点。


@Override
public PlanWalker spawnChildWalker(OperatorPlan plan) {
return new DependencyOrderWalker(plan);
}

walk()方法通过plan.getSinks()方法得到所有的leave节点,即没有后辈的节点,然后遍历他们,获取每个节点的所有前辈,再递归前辈的前辈,从而实现把所有的节点都访问一遍,最后得到结果就是一个FIFO的List。代码里的这个Graph依赖遍历的方式很不高效,但是因为访问的图的节点少,所以可接受。

递归的过程如下

    protected void doAllPredecessors(Operator node,
                                   Set<Operator> seen,
                                   Collection<Operator> fifo) throws FrontendException {
        if (!seen.contains(node)) {
            // We haven't seen this one before.
            Collection<Operator> preds = Utils.mergeCollection(plan.getPredecessors(node), plan.getSoftLinkPredecessors(node));
            if (preds != null && preds.size() > 0) {
                // Do all our predecessors before ourself
                for (Operator op : preds) {
                    doAllPredecessors(op, seen, fifo);
                }
            }
            // Now do ourself
            seen.add(node);
            fifo.add(node);
        }
    }


DepthFirstWalk

DepthFirstWalker是深度优先遍历(由上而下的深度优先

@Override
public PlanWalker spawnChildWalker(OperatorPlan plan) {
return new DepthFirstWalker(plan);
}

walk()方法通过plan.getSources()得到所有的root节点,然后遍历他们,遍历的时候获取他们的所有后辈,递归遍历。

递归过程如下:

    private void depthFirst(Operator node,
                            Collection<Operator> successors,
                            Set<Operator> seen,
                            PlanVisitor visitor) throws FrontendException {
        if (successors == null) return;

        for (Operator suc : successors) {
            if (seen.add(suc)) {
                suc.accept(visitor);
                Collection<Operator> newSuccessors = Utils.mergeCollection(plan.getSuccessors(suc), plan.getSoftLinkSuccessors(suc));
                depthFirst(suc, newSuccessors, seen, visitor);
            }
        }
    }

PreOrderDepthFirstWalker

PreOrderDepthFirstWalker即前序深度优先(由下而上的深度优先


子Walker是深度优先

public PlanWalker spawnChildWalker(OperatorPlan plan) {
return new DepthFirstWalker(plan);
}

walk()方法是通过plan.getSinks()得到所有leave节点,然后遍历每个leave节点,获得他的前辈,并递归进行深度优先(向上)遍历。

递归操作如下:

    private void depthFirst(Operator node, Collection<Operator> predecessors, Set<Operator> seen,
            PlanVisitor visitor) throws FrontendException {
        if (predecessors == null)
            return;

        boolean thisBranchFlag = branchFlag;
        for (Operator pred : predecessors) {
            if (seen.add(pred)) {
                branchFlag = thisBranchFlag;
                pred.accept(visitor);
                Collection<Operator> newPredecessors = Utils.mergeCollection(plan.getPredecessors(pred), plan.getSoftLinkPredecessors(pred));
                depthFirst(pred, newPredecessors, seen, visitor);
            }
        }
    }

ReserveDependencyOrderWalker

ReserveDependencyOrderWalker是逆向的依赖顺序遍历,即一个节点访问之后才能访问它依赖的节点,即N节点要想被访问,需要依赖N节点的节点先被访问。

@Override
public PlanWalker spawnChildWalker(OperatorPlan plan) {
return new ReverseDependencyOrderWalker(plan);
}

walk()方法的访问模式类似DependencyOrderWalker,区别在于先获得所有的root节点,然后进行遍历操作,遍历root节点的所有后辈,递归后辈的后辈,使root节点最后访问。

递归如下:

    protected void doAllSuccessors(Operator node,
                                   Set<Operator> seen,
                                   Collection<Operator> fifo) throws FrontendException {
        if (!seen.contains(node)) {
            // We haven't seen this one before.
            Collection<Operator> succs = Utils.mergeCollection(plan.getSuccessors(node), plan.getSoftLinkSuccessors(node));
            if (succs != null && succs.size() > 0) {
                // Do all our successors before ourself
                for (Operator op : succs) {
                    doAllSuccessors(op, seen, fifo);
                }
            }
            // Now do ourself
            seen.add(node);
            fifo.add(node);
        }
    }

ReverseDependencyOrderWalkerWOSeenChk

ReverseDependencyOrderWalkerWOSeenChk也是逆向的依赖顺序遍历,同ReserveDependencyOrderWalker一样。

 

子Walker是ReserveDependencyOrderWalker

@Override
public PlanWalker spawnChildWalker(OperatorPlan plan) {
return new ReverseDependencyOrderWalker(plan);
}

walk()方法和ReserveDependencyOrderWalker的区别在于,每次遍历的时候不记录一个seen的Set<Operator>集。



全文完 :)


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值