import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
public Map<OperatorKey, OperatorKey> match(OperatorPlan<Operator> plan1,
                                           OperatorPlan<Operator> plan2,
                                           StringBuilder messages) {
    // Find plan1.OperatorSet - plan2.OperatorSet
    int diff1 = diffKeys(plan1, plan2, messages, "plan2") ;

    // Find plan2.OperatorSet - plan1.OperatorSet
    int diff2 = diffKeys(plan2, plan1, messages, "plan1") ;

    // If there is a problem, just finish here
    if ( (diff1 != 0) || (diff2 != 0) ) {
        return null ;
    }

    // if no problem, we just return exact matching
    Iterator<Operator> iter = plan1.getKeys().values().iterator() ;
    Map<OperatorKey, OperatorKey> outputMap
                            = new HashMap<OperatorKey, OperatorKey>() ;
    while(iter.hasNext()) {
        Operator op = iter.next() ;
        outputMap.put(op.getOperatorKey(), op.getOperatorKey()) ;
    }

    return outputMap;
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
public Map<OperatorKey, OperatorKey> match(OperatorPlan plan1,
                                           OperatorPlan plan2,
                                           StringBuilder messages) {

    List<OperatorKey> keyList1 = getSortedKeyList(plan1) ;
    List<OperatorKey> keyList2 = getSortedKeyList(plan2) ;

    // This matching logic only works when both plans have
    // the same number of operators
    if (keyList1.size() != keyList2.size()) {
        messages.append("Two plans have different size") ;
        return null ;
    }

    // Populating the output map
    Map<OperatorKey, OperatorKey> outputMap
                            = new HashMap<OperatorKey, OperatorKey>() ;
    for(int i=0; i< keyList1.size() ; i++) {
        outputMap.put(keyList1.get(i), keyList2.get(i)) ;
    }

    return outputMap ;
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
/**
 * Return true if the given plan has nodes that match the pattern 
 * represented by this class
 * If a match is found, the PatterNodes in the plan will return non 
 * null node for getMatch(). 
 * @param inpPlan - input plan to match
 * @return true if match is found
 */
public boolean match(OperatorPlan<? extends Operator<?>> inpPlan){
    reset();

    PatternPlan pattern = this;
    currentPlan = inpPlan;

    if(pattern.size() == 0){
        return true;
    }

    PatternNode ptNode = (PatternNode) pattern.getSinks().get(0);
    //try matching the pattern with the plan, starting with ptNode
    Iterator it = currentPlan.iterator();
    while(it.hasNext()){
        Operator<?> plOp = (Operator<?>) it.next();
        if(match(ptNode, plOp)){
            if(this.size() != ptNodesVisited.size()){
                //BUG
                throw new RuntimeException("invalid size of pattern nodes visited");
            }

            return true;
        }

    }
    return false;
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
private <T extends OperatorPlan<? extends Operator<?>>> 
void showPlanOperators(T p) {
    System.out.println("Operators:");

    ArrayList<Operator<?>> ops = new ArrayList<Operator<?>>(p.getKeys()
            .values());
    Collections.sort(ops);
    for (Operator<?> op : ops) {
        System.out.println("    op: " + op.name());
    }
    System.out.println();
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
/***
 * Report plan1.OperatorSet - plan2.OperatorSet
 *
 * @param plan1
 * @param plan2
 * @param messages where the report messages go. null if no messages needed
 * @param plan2Name the name that is used to refer to plan2 in messages
 * @return
 */

private int diffKeys(OperatorPlan<Operator> plan1,
                     OperatorPlan<Operator> plan2,
                     StringBuilder messages,
                     String plan2Name) {
    int count = 0 ;

    // prepare
    Map<OperatorKey, Operator> keyList = plan1.getKeys() ;
    Iterator<OperatorKey> iter = keyList.keySet().iterator() ;

    // go through the list of vertices of the first plan
    while(iter.hasNext()) {

        OperatorKey key = iter.next() ;

        // if the same key doesn't exist in the second plan
        // we've got a problem
        if (plan2.getOperator(key) == null) {
            Operator op1 = plan1.getOperator(key) ;
            if (messages != null) {
                messages.append(op1.getClass().getSimpleName()) ;
                appendOpKey(op1.getOperatorKey(), messages) ;
                messages.append(" doesn't exist") ;
                if (plan2Name != null) {
                    messages.append(" in ") ;
                    messages.append(plan2Name) ;
                    messages.append("\n") ;
                }
            }
            // increment diff counter
            count++ ;
        }
    }

    return count ;
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
private List<OperatorKey> getSortedKeyList(OperatorPlan plan) {

        List<OperatorKey> keyList
                        = new ArrayList<OperatorKey>(plan.getKeys().keySet()) ;
        Collections.sort(keyList); 
        return keyList ;
    }
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
@Override
public void initialPlanNotification(String scriptId, OperatorPlan<?> plan) {
    synchronized (listeners) {
        for (PigProgressNotificationListener listener : listeners) {
            try {
                listener.initialPlanNotification(scriptId, plan);
            } catch (NoSuchMethodError e) {
                LOG.warn("PigProgressNotificationListener implementation doesn't "
                       + "implement initialPlanNotification(..) method: "
                       + listener.getClass().getName(), e);
            }
        }
    }
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
public void emitInitialPlanNotification(OperatorPlan<?> plan) {
    for (PigProgressNotificationListener listener: listeners) {
        try {
            listener.initialPlanNotification(id, plan);
        } catch (NoSuchMethodError e) {
            LOG.warn("PigProgressNotificationListener implementation doesn't "
                   + "implement initialPlanNotification(..) method: "
                   + listener.getClass().getName(), e);
        }
    }
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
private <T extends OperatorPlan<? extends Operator<?>>>
void showPlanOperators(T p) {
    System.out.println("Operators:");

    ArrayList<Operator<?>> ops = new ArrayList<Operator<?>>(p.getKeys()
            .values());
    Collections.sort(ops);
    for (Operator<?> op : ops) {
        System.out.println("    op: " + op.name());
    }
    System.out.println();
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
public void dagLaunchNotification(String dagName, OperatorPlan<?> dagPlan, int numVerticesToLaunch)  {
    for (PigTezProgressNotificationListener listener: tezListeners) {
        listener.dagLaunchNotification(id, dagName, dagPlan, numVerticesToLaunch);
    }
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
@Override
public void initialPlanNotification(String id, OperatorPlan<?> plan) {
    System.out.println("id: " + id + " planNodes: " + plan.getKeys().size());
    assertNotNull(plan);
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
/**
 * The merge of a list of map plans
 * @param <O>
 * @param <E>
 * @param finPlan - Final Plan into which the list of plans is merged
 * @param plans - list of map plans to be merged
 * @throws PlanException
 */
private <O extends Operator, E extends OperatorPlan<O>> void merge(
        E finPlan, List<E> plans) throws PlanException {
    for (E e : plans) {
        finPlan.merge(e);
    }
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
/**
 * The merge of a list of plans into a single plan
 * @param <O>
 * @param <E>
 * @param finPlan - Final Plan into which the list of plans is merged
 * @param plans - list of plans to be merged
 * @throws PlanException
 */
private <O extends Operator<?>, E extends OperatorPlan<O>> void merge(
        E finPlan, List<E> plans) throws PlanException {
    for (E e : plans) {
        finPlan.merge(e);
    }
}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
@Override
public void initialPlanNotification(String scriptId, OperatorPlan<?> plan) {

}
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
/**
 * Invoked before any Hadoop jobs (or a Tez DAG) are run with the plan that is to be executed.
 *
 * @param scriptId the unique id of the script
 * @param plan the OperatorPlan that is to be executed
 */
public void initialPlanNotification(String scriptId, OperatorPlan<?> plan);
 

import org.apache.pig.impl.plan.OperatorPlan; //导入依赖的package包/类
/**
 * Invoked just before launching a Tez DAG spawned by the script.
 *
 * @param scriptId the unique id of the script
 * @param dagId the unique name of the Tez DAG
 * @param dagPlan the OperatorPlan that is to be executed
 * @param numVerticesToLaunch the total number of vertices spawned by the Tez DAG
 */
public abstract void dagLaunchNotification(String scriptId, String dagId,
        OperatorPlan<?> dagPlan, int numVerticesToLaunch);