Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.pig.newplan.logical.optimizer;
 
 import java.util.List;
 
A visitor mechanism printing out the logical plan.
 
 public class LogicalPlanPrinter extends PlanVisitor {
 
     private PrintStream mStream = null;
     private String TAB1 = "    ";
     private String TABMore = "|   ";
     private String LSep = "|\n|---";
     private String USep = "|   |\n|   ";
     static public String SEPERATE = "\t";

    

Parameters:
ps PrintStream to output plan information to
plan Logical plan to print
 
     public LogicalPlanPrinter(OperatorPlan planPrintStream psthrows FrontendException {
         super(plannull);
          = ps;
     }
 
     @Override
     public void visit() throws FrontendException {
         try {
             if ( instanceof LogicalPlan) {
                 .write(depthFirstLP().getBytes());
             }
             else {
                 .write(reverseDepthFirstLP().getBytes());
             }
         } catch (IOException e) {
             throw new FrontendException(e);
         }
     }
 
     protected String depthFirstLP() throws FrontendExceptionIOException {
         StringBuilder sb = new StringBuilder();
         List<Operatorleaves = .getSinks();
         for (Operator leaf : leaves) {
             sb.append(depthFirst(leaf));
             sb.append("\n");
         }
         return sb.toString();
     }
     
     private String depthFirst(Operator nodethrows FrontendExceptionIOException {
         String nodeString = printNode(node);
         
         List<OperatororiginalPredecessors =  .getPredecessors(node);
         if (originalPredecessors == null)
             return nodeString;
         
         StringBuffer sb = new StringBuffer(nodeString);
         List<Operatorpredecessors =  new ArrayList<Operator>(originalPredecessors);
         
         int i = 0;
        for (Operator pred : predecessors) {
            i++;
            String DFStr = depthFirst(pred);
            if (DFStr != null) {
                sb.append();
                if (i < predecessors.size())
                    sb.append(shiftStringByTabs(DFStr, 2));
                else
                    sb.append(shiftStringByTabs(DFStr, 1));
            }
        }
        return sb.toString();
    }
    
    protected String reverseDepthFirstLP() throws FrontendExceptionIOException {
        StringBuilder sb = new StringBuilder();
        List<Operatorroots = .getSources();
        for (Operator root : roots) {
            sb.append(reverseDepthFirst(root));
            sb.append("\n");
        }
        return sb.toString();
    }
    
    private String reverseDepthFirst(Operator nodethrows FrontendExceptionIOException {
        String nodeString = printNode(node);
        
        List<OperatororiginalSuccessors =  .getSuccessors(node);
        if (originalSuccessors == null)
            return nodeString;
        
        StringBuffer sb = new StringBuffer(nodeString);
        List<Operatorsuccessors =  new ArrayList<Operator>(originalSuccessors);
        
        int i = 0;
        for (Operator succ : successors) {
            i++;
            String DFStr = reverseDepthFirst(succ);
            if (DFStr != null) {
                sb.append();
                if (i < successors.size())
                    sb.append(shiftStringByTabs(DFStr, 2));
                else
                    sb.append(shiftStringByTabs(DFStr, 1));
            }
        }
        return sb.toString();
    }
    
    private String planString(OperatorPlan lpthrows VisitorExceptionIOException {
        StringBuilder sb = new StringBuilder();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);
        if(lp!=null) {
            LogicalPlanPrinter printer = new LogicalPlanPrinter(lpps);
            printer.visit();
        }
        else
            return "";
        sb.append();
        sb.append(shiftStringByTabs(baos.toString(), 2));
        return sb.toString();
    }
    
    private String printNode(Operator nodethrows FrontendExceptionIOException {
        StringBuilder sb = new StringBuilder(node.toString()+"\n");
        
        if(node instanceof LOFilter){
            sb.append(planString(((LOFilter)node).getFilterPlan()));
        }
        else if(node instanceof LOLimit){
            sb.append(planString(((LOLimit)node).getLimitPlan()));
        }
        else if(node instanceof LOForEach){
            sb.append(planString(((LOForEach)node).getInnerPlan()));        
        }
        else if(node instanceof LOCogroup){
            MultiMap<IntegerLogicalExpressionPlanplans = ((LOCogroup)node).getExpressionPlans();
            for (int i : plans.keySet()) {
                // Visit the associated plans
                for (OperatorPlan plan : plans.get(i)) {
                    sb.append(planString(plan));
                }
            }
        }
        else if(node instanceof LOJoin){
            MultiMap<IntegerLogicalExpressionPlanplans = ((LOJoin)node).getExpressionPlans();
            for (int iplans.keySet()) {
                // Visit the associated plans
                for (OperatorPlan plan : plans.get(i)) {
                    sb.append(planString(plan));
                }
            }
        }
        else if(node instanceof LORank){
            // Visit fields for rank
            for (OperatorPlan plan : ((LORank)node).getRankColPlans())
                sb.append(planString(plan));
        }
        else if(node instanceof LOSort){
            for (OperatorPlan plan : ((LOSort)node).getSortColPlans())
                sb.append(planString(plan));
        }
        else if(node instanceof LOSplitOutput){
            sb.append(planString(((LOSplitOutput)node).getFilterPlan()));
        }
        else if(node instanceof LOGenerate){
            for (OperatorPlan plan : ((LOGenerate)node).getOutputPlans()) {
                sb.append(planString(plan));
            }
        }
        return sb.toString();
    }
    private String shiftStringByTabs(String DFStrint TabType) {
        StringBuilder sb = new StringBuilder();
        String[] spl = DFStr.split("\n");
        String tab = (TabType == 1) ?  : ;
        sb.append(spl[0] + "\n");
        for (int i = 1; i < spl.lengthi++) {
            sb.append(tab);
            sb.append(spl[i]);
            sb.append("\n");
        }
        return sb.toString();
    }
}

        
New to GrepCode? Check out our FAQ X