/*
* 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.test;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import org.apache.pig.newplan.logical.expression.AddExpression;
import org.apache.pig.newplan.logical.expression.AndExpression;
import org.apache.pig.newplan.logical.expression.BinCondExpression;
import org.apache.pig.newplan.logical.expression.CastExpression;
import org.apache.pig.newplan.logical.expression.ConstantExpression;
import org.apache.pig.newplan.logical.expression.DereferenceExpression;
import org.apache.pig.newplan.logical.expression.DivideExpression;
import org.apache.pig.newplan.logical.expression.EqualExpression;
import org.apache.pig.newplan.logical.expression.GreaterThanEqualExpression;
import org.apache.pig.newplan.logical.expression.GreaterThanExpression;
import org.apache.pig.newplan.logical.expression.IsNullExpression;
import org.apache.pig.newplan.logical.expression.LessThanEqualExpression;
import org.apache.pig.newplan.logical.expression.LessThanExpression;
import org.apache.pig.newplan.logical.expression.LogicalExpressionPlan;
import org.apache.pig.newplan.logical.expression.LogicalExpressionVisitor;
import org.apache.pig.newplan.logical.expression.MapLookupExpression;
import org.apache.pig.newplan.logical.expression.ModExpression;
import org.apache.pig.newplan.logical.expression.MultiplyExpression;
import org.apache.pig.newplan.logical.expression.NegativeExpression;
import org.apache.pig.newplan.logical.expression.NotEqualExpression;
import org.apache.pig.newplan.logical.expression.NotExpression;
import org.apache.pig.newplan.logical.expression.OrExpression;
import org.apache.pig.newplan.logical.expression.ProjectExpression;
import org.apache.pig.newplan.logical.expression.RegexExpression;
import org.apache.pig.newplan.logical.expression.SubtractExpression;
import org.apache.pig.newplan.logical.expression.UserFuncExpression;
import org.apache.pig.newplan.logical.relational.LOCogroup;
import org.apache.pig.newplan.logical.relational.LOCross;
import org.apache.pig.newplan.logical.relational.LODistinct;
import org.apache.pig.newplan.logical.relational.LOFilter;
import org.apache.pig.newplan.logical.relational.LOForEach;
import org.apache.pig.newplan.logical.relational.LOGenerate;
import org.apache.pig.newplan.logical.relational.LOInnerLoad;
import org.apache.pig.newplan.logical.relational.LOJoin;
import org.apache.pig.newplan.logical.relational.LOLimit;
import org.apache.pig.newplan.logical.relational.LOLoad;
import org.apache.pig.newplan.logical.relational.LORank;
import org.apache.pig.newplan.logical.relational.LOSort;
import org.apache.pig.newplan.logical.relational.LOSplit;
import org.apache.pig.newplan.logical.relational.LOSplitOutput;
import org.apache.pig.newplan.logical.relational.LOStore;
import org.apache.pig.newplan.logical.relational.LOStream;
import org.apache.pig.newplan.logical.relational.LOUnion;
import org.apache.pig.newplan.logical.relational.LogicalPlan;
import org.apache.pig.newplan.logical.relational.LogicalRelationalNodesVisitor;
import org.apache.pig.newplan.DependencyOrderWalker;
import org.apache.pig.newplan.Operator;
import org.apache.pig.impl.logicalLayer.FrontendException;
import org.apache.pig.impl.plan.VisitorException;
/**
* This class transforms LogicalPlan to its textual representation
*
*/
public class OptimizeLimitPlanPrinter extends LogicalRelationalNodesVisitor {
private StringBuilder sb = null ;
public OptimizeLimitPlanPrinter(LogicalPlan plan) throws FrontendException {
super( plan, new DependencyOrderWalker( plan ) );
sb = new StringBuilder() ;
}
@Override
public void visit(LOLoad load) throws FrontendException {
appendEdges( load );
}
@Override
public void visit(LOJoin join) throws FrontendException {
appendEdges( join );
}
@Override
public void visit(LOGenerate gen) throws FrontendException {
appendEdges( gen );
}
@Override
public void visit(LOInnerLoad load) throws FrontendException {
appendEdges( load );
}
@Override
public void visit(LOUnion loUnion) throws FrontendException {
appendEdges( loUnion );
}
@Override
public void visit(LOStream loStream) throws FrontendException {
appendEdges( loStream );
}
@Override
public void visit(LOFilter filter) throws FrontendException {
LogicalExpressionPlan expPlan = filter.getFilterPlan();
MyLogicalExpressionVisitor visitor = new MyLogicalExpressionVisitor( expPlan );
sb.append("[" + visitor.printToString() + "]" );
appendEdges( filter );
}
@Override
public void visit(LOStore store) throws FrontendException {
appendEdges( store );
}
@Override
public void visit(LOForEach foreach) throws FrontendException {
appendOp( foreach ) ;
boolean hasFlatten = false;
LogicalPlan inner1 = foreach.getInnerPlan();
Iterator<Operator> it = inner1.getOperators();
while( it.hasNext() ) {
Operator op = it.next();
if( op instanceof LOGenerate ) {
LOGenerate gen = (LOGenerate)op;
boolean[] flattenFlags = gen.getFlattenFlags();
if( flattenFlags != null ) {
for( boolean flatten : flattenFlags ) {
if( flatten ) {
hasFlatten = true;
break;
}
}
}
}
}
if (hasFlatten)
sb.append(" [hasflat=\"true\"]");
else
sb.append(" [hasflat=\"false\"]");
sb.append(";\n");
appendEdges(foreach);
}
@Override
public void visit(LOCogroup loCogroup) throws FrontendException {
appendEdges(loCogroup);
}
@Override
public void visit(LOSplit loSplit) throws FrontendException {
appendEdges(loSplit);
}
@Override
public void visit(LOSplitOutput loSplitOutput) throws FrontendException {
}
@Override
public void visit(LOSort loSort) throws FrontendException {
appendOp(loSort) ;
sb.append(" [limit=\"" + loSort.getLimit() + "\"]");
sb.append(";\n");
appendEdges(loSort);
}
@Override
public void visit(LORank loRank) throws FrontendException {
appendOp(loRank) ;
appendEdges(loRank);
}
@Override
public void visit(LODistinct loDistinct) throws FrontendException {
appendEdges(loDistinct);
}
@Override
public void visit(LOLimit loLimit) throws FrontendException {
appendOp(loLimit) ;
sb.append(" [limit=\""+loLimit.getLimit()+"\"]");
sb.append(";\n");
appendEdges(loLimit);
}
@Override
public void visit(LOCross loCross) throws FrontendException {
appendEdges(loCross);
}
private void appendOp(Operator op) {
sb.append(" "+op.getClass().getSimpleName()) ;
}
private void appendEdges(Operator op) throws FrontendException {
List<Operator> list = currentWalker.getPlan().getSuccessors(op) ;
if (list!=null) {
for(Operator tmp: list) {
sb.append(" "+op.getClass().getSimpleName()+" -> ");
sb.append(tmp.getClass().getSimpleName()+";\n");
}
}
}
/***
* This method has to be called after the visit is totally finished only
* @throws IOException
*/
public String printToString() throws IOException {
try {
visit() ;
} catch(VisitorException vse) {
throw new AssertionError("Error while transforming type graph to text") ;
}
return sb.toString() ;
}
}
class MyLogicalExpressionVisitor extends LogicalExpressionVisitor {
private StringBuilder sb = null ;
public MyLogicalExpressionVisitor(LogicalExpressionPlan plan) throws FrontendException {
super( plan, new DependencyOrderWalker( plan ) );
sb = new StringBuilder() ;
}
@Override
public void visit(AndExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(OrExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(EqualExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(ProjectExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(ConstantExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(CastExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(GreaterThanExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(GreaterThanEqualExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(LessThanExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(LessThanEqualExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(NotEqualExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(NotExpression op ) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(IsNullExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(NegativeExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(AddExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(SubtractExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(MultiplyExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(ModExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(DivideExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(MapLookupExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(BinCondExpression op) throws FrontendException {
appendEdges(op);
}
@Override
public void visit(UserFuncExpression op) throws FrontendException {
appendEdges( op );
}
@Override
public void visit(DereferenceExpression bagDerefenceExpression) throws FrontendException {
appendEdges( bagDerefenceExpression );
}
public void visit(RegexExpression op) throws FrontendException {
appendEdges( op );
}
private void appendEdges(Operator op) throws FrontendException {
List<Operator> list = currentWalker.getPlan().getSuccessors(op) ;
if (list!=null) {
for(Operator tmp: list) {
sb.append(" "+op.getClass().getSimpleName()+" -> ");
sb.append(tmp.getClass().getSimpleName()+";\n");
}
}
}
public String printToString() throws FrontendException {
try {
visit() ;
} catch(VisitorException vse) {
throw new AssertionError("Error while transforming type graph to text") ;
}
return sb.toString() ;
}
}