Uses of Class
org.apache.pig.impl.plan.VisitorException

Packages that use VisitorException
org.apache.pig.backend.hadoop.executionengine.mapReduceLayer   
org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.plans   
org.apache.pig.backend.hadoop.executionengine.physicalLayer Implementation of physical operators that use hadoop as the execution engine and data storage. 
org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators   
org.apache.pig.backend.hadoop.executionengine.physicalLayer.plans   
org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators   
org.apache.pig.backend.hadoop.executionengine.physicalLayer.util   
org.apache.pig.backend.local.executionengine   
org.apache.pig.backend.local.executionengine.physicalLayer   
org.apache.pig.backend.local.executionengine.physicalLayer.counters   
org.apache.pig.backend.local.executionengine.physicalLayer.relationalOperators   
org.apache.pig.impl.logicalLayer The logical operators that represent a pig script and tools for manipulating those operators. 
org.apache.pig.impl.logicalLayer.optimizer   
org.apache.pig.impl.logicalLayer.validators   
org.apache.pig.impl.plan   
org.apache.pig.impl.plan.optimizer   
org.apache.pig.pen   
org.apache.pig.pen.util   
 

Uses of VisitorException in org.apache.pig.backend.hadoop.executionengine.mapReduceLayer
 

Subclasses of VisitorException in org.apache.pig.backend.hadoop.executionengine.mapReduceLayer
 class MRCompilerException
           
 

Methods in org.apache.pig.backend.hadoop.executionengine.mapReduceLayer that throw VisitorException
 MROperPlan MRCompiler.compile()
          The front-end method that the user calls to compile the plan.
 void MRCompiler.connectMapToReduceLimitedSort(MapReduceOper mro, MapReduceOper sortMROp)
           
 void MapReduceLauncher.explain(PhysicalPlan php, PigContext pc, PrintStream ps, String format, boolean verbose)
           
abstract  void Launcher.explain(PhysicalPlan pp, PigContext pc, PrintStream ps, String format, boolean verbose)
          Explain how a pig job will be executed on the underlying infrastructure.
 Pair<MapReduceOper,Integer> MRCompiler.getQuantileJob(POSort inpSort, MapReduceOper prevJob, FileSpec lFile, FileSpec quantFile, int rp, Pair<Integer,Byte>[] fields)
           
protected  Pair<MapReduceOper,Integer> MRCompiler.getSamplingJob(POSort sort, MapReduceOper prevJob, List<PhysicalPlan> transformPlans, FileSpec lFile, FileSpec sampleFile, int rp, List<PhysicalPlan> sortKeyPlans, String udfClassName, String[] udfArgs, String sampleLdrClassName)
          Create a sampling job to collect statistics by sampling an input file.
 Pair<MapReduceOper,Integer> MRCompiler.getSkewedJoinSampleJob(POSkewedJoin op, MapReduceOper prevJob, FileSpec lFile, FileSpec sampleFile, int rp)
          Create Sampling job for skewed join.
 PigStats MapReduceLauncher.launchPig(PhysicalPlan php, String grpName, PigContext pc)
           
abstract  PigStats Launcher.launchPig(PhysicalPlan php, String grpName, PigContext pc)
          Method to launch pig for hadoop either for a cluster's job tracker or for a local job runner.
 void SampleOptimizer.visit()
           
 void MapReduceOper.visit(MROpPlanVisitor v)
           
 void PhyPlanSetter.visitAdd(Add add)
           
 void PhyPlanSetter.visitAnd(POAnd and)
           
 void PhyPlanSetter.visitCollectedGroup(POCollectedGroup mg)
           
 void MRCompiler.visitCollectedGroup(POCollectedGroup op)
           
 void PhyPlanSetter.visitCombinerPackage(POCombinerPackage pkg)
           
 void PhyPlanSetter.visitComparisonFunc(POUserComparisonFunc compFunc)
           
 void PhyPlanSetter.visitConstant(ConstantExpression cnst)
           
 void PhyPlanSetter.visitDemux(PODemux demux)
           
 void PhyPlanSetter.visitDistinct(PODistinct distinct)
           
 void MRCompiler.visitDistinct(PODistinct op)
           
 void PhyPlanSetter.visitDivide(Divide dv)
           
 void PhyPlanSetter.visitEqualTo(EqualToExpr eq)
           
 void PhyPlanSetter.visitFilter(POFilter fl)
           
 void MRCompiler.visitFilter(POFilter op)
           
 void PhyPlanSetter.visitFRJoin(POFRJoin join)
           
 void MRCompiler.visitFRJoin(POFRJoin op)
          This is an operator which will have multiple inputs(= to number of join inputs) But it prunes off all inputs but the fragment input and creates separate MR jobs for each of the replicated inputs and uses these as the replicated files that are configured in the POFRJoin operator.
 void PhyPlanSetter.visitGlobalRearrange(POGlobalRearrange gr)
           
 void MRCompiler.visitGlobalRearrange(POGlobalRearrange op)
           
 void PhyPlanSetter.visitGreaterThan(GreaterThanExpr grt)
           
 void PhyPlanSetter.visitGTOrEqual(GTOrEqualToExpr gte)
           
 void PhyPlanSetter.visitIsNull(POIsNull isNull)
           
 void PhyPlanSetter.visitJoinPackage(POJoinPackage joinPackage)
           
 void PhyPlanSetter.visitLessThan(LessThanExpr lt)
           
 void PhyPlanSetter.visitLimit(POLimit lim)
           
 void MRCompiler.visitLimit(POLimit op)
           
 void PhyPlanSetter.visitLoad(POLoad ld)
           
 void MRCompiler.visitLoad(POLoad op)
           
 void PhyPlanSetter.visitLocalRearrange(POLocalRearrange lr)
           
 void MRCompiler.visitLocalRearrange(POLocalRearrange op)
           
 void PhyPlanSetter.visitLocalRearrangeForIllustrate(POLocalRearrangeForIllustrate lrfi)
           
 void PhyPlanSetter.visitLTOrEqual(LTOrEqualToExpr lte)
           
 void PhyPlanSetter.visitMergeJoin(POMergeJoin join)
           
 void MRCompiler.visitMergeJoin(POMergeJoin joinOp)
          Since merge-join works on two inputs there are exactly two MROper predecessors identified as left and right.
 void PhyPlanSetter.visitMod(Mod mod)
           
 void SecondaryKeyOptimizer.visitMROp(MapReduceOper mr)
           
 void SampleOptimizer.visitMROp(MapReduceOper mr)
           
 void KeyTypeDiscoveryVisitor.visitMROp(MapReduceOper mr)
           
 void CombinerOptimizer.visitMROp(MapReduceOper mr)
           
 void AccumulatorOptimizer.visitMROp(MapReduceOper mr)
           
 void PhyPlanSetter.visitMultiply(Multiply mul)
           
 void PhyPlanSetter.visitNot(PONot not)
           
 void PhyPlanSetter.visitNotEqualTo(NotEqualToExpr eq)
           
 void PhyPlanSetter.visitOr(POOr or)
           
 void PhyPlanSetter.visitPackage(POPackage pkg)
           
 void MRCompiler.visitPackage(POPackage op)
           
 void PhyPlanSetter.visitPOForEach(POForEach nfe)
           
 void MRCompiler.visitPOForEach(POForEach op)
           
 void PhyPlanSetter.visitProject(POProject proj)
           
 void PhyPlanSetter.visitRead(PORead read)
           
 void PhyPlanSetter.visitRegexp(PORegexp re)
           
 void PhyPlanSetter.visitSkewedJoin(POSkewedJoin join)
           
 void MRCompiler.visitSkewedJoin(POSkewedJoin op)
           
 void PhyPlanSetter.visitSort(POSort sort)
           
 void MRCompiler.visitSort(POSort op)
           
 void PhyPlanSetter.visitSplit(POSplit spl)
           
 void MRCompiler.visitSplit(POSplit op)
          Compiles a split operator.
 void PhyPlanSetter.visitStore(POStore st)
           
 void MRCompiler.visitStore(POStore op)
           
 void PhyPlanSetter.visitStream(POStream stream)
           
 void MRCompiler.visitStream(POStream op)
           
 void PhyPlanSetter.visitSubtract(Subtract sub)
           
 void PhyPlanSetter.visitUnion(POUnion un)
           
 void MRCompiler.visitUnion(POUnion op)
           
 void UDFFinishVisitor.visitUserFunc(POUserFunc userFunc)
           
 void PhyPlanSetter.visitUserFunc(POUserFunc userFunc)
           
 

Uses of VisitorException in org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.plans
 

Methods in org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.plans that throw VisitorException
 void UDFFinder.visitComparisonFunc(POUserComparisonFunc compFunc)
           
 void POPackageAnnotator.visitMROp(MapReduceOper mr)
           
 void MRPrinter.visitMROp(MapReduceOper mr)
           
 void MROpPlanVisitor.visitMROp(MapReduceOper mr)
           
 void EndOfAllInputSetter.visitMROp(MapReduceOper mr)
           
 void UDFFinder.visitSort(POSort op)
           
 void UDFFinder.visitUserFunc(POUserFunc userFunc)
           
 

Uses of VisitorException in org.apache.pig.backend.hadoop.executionengine.physicalLayer
 

Subclasses of VisitorException in org.apache.pig.backend.hadoop.executionengine.physicalLayer
 class LogicalToPhysicalTranslatorException
           
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer that throw VisitorException
 void LogToPhyTranslationVisitor.visit(LOAdd op)
           
 void LogToPhyTranslationVisitor.visit(LOAnd op)
           
 void LogToPhyTranslationVisitor.visit(LOBinCond op)
           
 void LogToPhyTranslationVisitor.visit(LOCast op)
           
 void LogToPhyTranslationVisitor.visit(LOCogroup cg)
           
 void LogToPhyTranslationVisitor.visit(LOConst op)
           
protected  void LogToPhyTranslationVisitor.visit(LOCross cs)
           
 void LogToPhyTranslationVisitor.visit(LODistinct op)
           
 void LogToPhyTranslationVisitor.visit(LODivide op)
           
 void LogToPhyTranslationVisitor.visit(LOEqual op)
           
 void LogToPhyTranslationVisitor.visit(LOFilter filter)
           
 void LogToPhyTranslationVisitor.visit(LOForEach g)
           
 void LogToPhyTranslationVisitor.visit(LOGreaterThan op)
           
 void LogToPhyTranslationVisitor.visit(LOGreaterThanEqual op)
           
 void LogToPhyTranslationVisitor.visit(LOIsNull op)
           
protected  void LogToPhyTranslationVisitor.visit(LOJoin loj)
           
 void LogToPhyTranslationVisitor.visit(LOLesserThan op)
           
 void LogToPhyTranslationVisitor.visit(LOLesserThanEqual op)
           
 void LogToPhyTranslationVisitor.visit(LOLimit limit)
           
 void LogToPhyTranslationVisitor.visit(LOLoad loLoad)
           
 void LogToPhyTranslationVisitor.visit(LOMapLookup op)
           
 void LogToPhyTranslationVisitor.visit(LOMod op)
           
 void LogToPhyTranslationVisitor.visit(LOMultiply op)
           
 void LogToPhyTranslationVisitor.visit(LONegative op)
           
 void LogToPhyTranslationVisitor.visit(LONot op)
           
 void LogToPhyTranslationVisitor.visit(LONotEqual op)
           
 void LogToPhyTranslationVisitor.visit(LOOr op)
           
 void LogToPhyTranslationVisitor.visit(LOProject op)
           
 void LogToPhyTranslationVisitor.visit(LORegexp op)
           
 void LogToPhyTranslationVisitor.visit(LOSort s)
           
 void LogToPhyTranslationVisitor.visit(LOSplit split)
           
 void LogToPhyTranslationVisitor.visit(LOSplitOutput split)
           
 void LogToPhyTranslationVisitor.visit(LOStore loStore)
           
 void LogToPhyTranslationVisitor.visit(LOStream stream)
           
 void LogToPhyTranslationVisitor.visit(LOSubtract op)
           
 void LogToPhyTranslationVisitor.visit(LOUnion op)
           
 void LogToPhyTranslationVisitor.visit(LOUserFunc func)
           
abstract  void PhysicalOperator.visit(PhyPlanVisitor v)
           
 

Uses of VisitorException in org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators that throw VisitorException
 void Subtract.visit(PhyPlanVisitor v)
           
 void POUserFunc.visit(PhyPlanVisitor v)
           
 void POUserComparisonFunc.visit(PhyPlanVisitor v)
           
 void PORelationToExprProject.visit(PhyPlanVisitor v)
           
 void PORegexp.visit(PhyPlanVisitor v)
           
 void POProject.visit(PhyPlanVisitor v)
           
 void POOr.visit(PhyPlanVisitor v)
           
 void PONot.visit(PhyPlanVisitor v)
           
 void PONegative.visit(PhyPlanVisitor v)
           
 void POMapLookUp.visit(PhyPlanVisitor v)
           
 void POIsNull.visit(PhyPlanVisitor v)
           
 void POCast.visit(PhyPlanVisitor v)
           
 void POBinCond.visit(PhyPlanVisitor v)
           
 void POAnd.visit(PhyPlanVisitor v)
           
 void NotEqualToExpr.visit(PhyPlanVisitor v)
           
 void Multiply.visit(PhyPlanVisitor v)
           
 void Mod.visit(PhyPlanVisitor v)
           
 void LessThanExpr.visit(PhyPlanVisitor v)
           
 void LTOrEqualToExpr.visit(PhyPlanVisitor v)
           
 void GreaterThanExpr.visit(PhyPlanVisitor v)
           
 void GTOrEqualToExpr.visit(PhyPlanVisitor v)
           
abstract  void ExpressionOperator.visit(PhyPlanVisitor v)
           
 void EqualToExpr.visit(PhyPlanVisitor v)
           
 void Divide.visit(PhyPlanVisitor v)
           
 void ConstantExpression.visit(PhyPlanVisitor v)
           
 void Add.visit(PhyPlanVisitor v)
           
 

Uses of VisitorException in org.apache.pig.backend.hadoop.executionengine.physicalLayer.plans
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.plans that throw VisitorException
protected  void PlanPrinter.breadthFirst()
           
protected  String PlanPrinter.depthFirstPP()
           
 void PlanPrinter.print(OutputStream printer)
           
 void PlanPrinter.visit()
           
 void PhyPlanVisitor.visitAdd(Add add)
           
 void PhyPlanVisitor.visitAnd(POAnd and)
           
 void PhyPlanVisitor.visitCollectedGroup(POCollectedGroup mg)
           
 void PhyPlanVisitor.visitCombinerPackage(POCombinerPackage pkg)
           
 void PhyPlanVisitor.visitComparisonFunc(POUserComparisonFunc compFunc)
           
 void PhyPlanVisitor.visitConstant(ConstantExpression cnst)
           
 void PhyPlanVisitor.visitDemux(PODemux demux)
           
 void PhyPlanVisitor.visitDistinct(PODistinct distinct)
           
 void PhyPlanVisitor.visitDivide(Divide dv)
           
 void PhyPlanVisitor.visitEqualTo(EqualToExpr eq)
           
 void PhyPlanVisitor.visitFilter(POFilter fl)
           
 void PhyPlanVisitor.visitFRJoin(POFRJoin join)
           
 void PhyPlanVisitor.visitGlobalRearrange(POGlobalRearrange gr)
           
 void PhyPlanVisitor.visitGreaterThan(GreaterThanExpr grt)
           
 void PhyPlanVisitor.visitGTOrEqual(GTOrEqualToExpr gte)
           
 void PhyPlanVisitor.visitIsNull(POIsNull isNull)
           
 void PhyPlanVisitor.visitJoinPackage(POJoinPackage joinPackage)
           
 void PhyPlanVisitor.visitLessThan(LessThanExpr lt)
           
 void PhyPlanVisitor.visitLimit(POLimit lim)
           
 void PhyPlanVisitor.visitLoad(POLoad ld)
           
 void PhyPlanVisitor.visitLocalRearrange(POLocalRearrange lr)
           
 void PhyPlanVisitor.visitLocalRearrangeForIllustrate(POLocalRearrangeForIllustrate lrfi)
           
 void PhyPlanVisitor.visitLTOrEqual(LTOrEqualToExpr lte)
           
 void PhyPlanVisitor.visitMergeJoin(POMergeJoin join)
           
 void PhyPlanVisitor.visitMod(Mod mod)
           
 void PhyPlanVisitor.visitMultiply(Multiply mul)
           
 void PhyPlanVisitor.visitMultiQueryPackage(POMultiQueryPackage pkg)
           
 void PhyPlanVisitor.visitNot(PONot not)
           
 void PhyPlanVisitor.visitNotEqualTo(NotEqualToExpr eq)
           
 void PhyPlanVisitor.visitOr(POOr or)
           
 void PhyPlanVisitor.visitPackage(POPackage pkg)
           
 void PhyPlanVisitor.visitPartitionRearrange(POPartitionRearrange pr)
           
 void PhyPlanVisitor.visitPOForEach(POForEach nfe)
           
 void PhyPlanVisitor.visitProject(POProject proj)
           
 void PhyPlanVisitor.visitRead(PORead read)
           
 void PhyPlanVisitor.visitRegexp(PORegexp re)
           
 void PhyPlanVisitor.visitSkewedJoin(POSkewedJoin sk)
           
 void PhyPlanVisitor.visitSort(POSort sort)
           
 void PhyPlanVisitor.visitSplit(POSplit spl)
           
 void PhyPlanVisitor.visitStore(POStore st)
           
 void PhyPlanVisitor.visitStream(POStream stream)
           
 void PhyPlanVisitor.visitSubtract(Subtract sub)
           
 void PhyPlanVisitor.visitUnion(POUnion un)
           
 void PhyPlanVisitor.visitUserFunc(POUserFunc userFunc)
           
 

Uses of VisitorException in org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators that throw VisitorException
 void POUnion.visit(PhyPlanVisitor v)
           
 void POStream.visit(PhyPlanVisitor v)
           
 void POStore.visit(PhyPlanVisitor v)
           
 void POSplit.visit(PhyPlanVisitor v)
           
 void POSort.visit(PhyPlanVisitor v)
           
 void POSkewedJoin.visit(PhyPlanVisitor v)
           
 void PORead.visit(PhyPlanVisitor v)
           
 void POPreCombinerLocalRearrange.visit(PhyPlanVisitor v)
           
 void POPackage.visit(PhyPlanVisitor v)
           
 void POOptimizedForEach.visit(PhyPlanVisitor v)
           
 void POMultiQueryPackage.visit(PhyPlanVisitor v)
           
 void POMergeJoin.visit(PhyPlanVisitor v)
           
 void POLocalRearrangeForIllustrate.visit(PhyPlanVisitor v)
           
 void POLocalRearrange.visit(PhyPlanVisitor v)
           
 void POLoad.visit(PhyPlanVisitor v)
           
 void POLimit.visit(PhyPlanVisitor v)
           
 void POJoinPackage.visit(PhyPlanVisitor v)
           
 void POGlobalRearrange.visit(PhyPlanVisitor v)
           
 void POForEach.visit(PhyPlanVisitor v)
           
 void POFilter.visit(PhyPlanVisitor v)
           
 void POFRJoin.visit(PhyPlanVisitor v)
           
 void PODistinct.visit(PhyPlanVisitor v)
           
 void PODemux.visit(PhyPlanVisitor v)
           
 void POCombinerPackage.visit(PhyPlanVisitor v)
           
 void POCollectedGroup.visit(PhyPlanVisitor v)
           
 

Uses of VisitorException in org.apache.pig.backend.hadoop.executionengine.physicalLayer.util
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.util that throw VisitorException
static List<POLoad> PlanHelper.getLoads(PhysicalPlan plan)
          Get all the load operators in the plan in the right dependency order
static List<POStore> PlanHelper.getStores(PhysicalPlan plan)
          Get all the store operators in the plan in the right dependency order
 

Uses of VisitorException in org.apache.pig.backend.local.executionengine
 

Methods in org.apache.pig.backend.local.executionengine that throw VisitorException
 void LocalPigLauncher.explain(PhysicalPlan pp, PigContext pc, PrintStream ps, String format, boolean isVerbose)
           
 PigStats LocalPigLauncher.launchPig(PhysicalPlan php, String grpName, PigContext pc)
           
 

Uses of VisitorException in org.apache.pig.backend.local.executionengine.physicalLayer
 

Methods in org.apache.pig.backend.local.executionengine.physicalLayer that throw VisitorException
 void LocalLogToPhyTranslationVisitor.visit(LOCogroup cg)
           
 void LocalLogToPhyTranslationVisitor.visit(LOCross cross)
           
 void LocalLogToPhyTranslationVisitor.visit(LOJoin join)
           
 void LocalLogToPhyTranslationVisitor.visit(LOSplit split)
           
 void LocalLogToPhyTranslationVisitor.visit(LOSplitOutput split)
           
 void LocalLogToPhyTranslationVisitor.visit(LOStore loStore)
           
 void LocalLogToPhyTranslationVisitor.visit(LOStream stream)
           
 

Uses of VisitorException in org.apache.pig.backend.local.executionengine.physicalLayer.counters
 

Methods in org.apache.pig.backend.local.executionengine.physicalLayer.counters that throw VisitorException
 void POCounter.visit(PhyPlanVisitor v)
           
 

Uses of VisitorException in org.apache.pig.backend.local.executionengine.physicalLayer.relationalOperators
 

Methods in org.apache.pig.backend.local.executionengine.physicalLayer.relationalOperators that throw VisitorException
 void POSplitOutput.visit(PhyPlanVisitor v)
           
 void POSplit.visit(PhyPlanVisitor v)
           
 void POCross.visit(PhyPlanVisitor v)
           
 void POCogroup.visit(PhyPlanVisitor v)
           
 

Uses of VisitorException in org.apache.pig.impl.logicalLayer
 

Methods in org.apache.pig.impl.logicalLayer that throw VisitorException
protected  String LOPrinter.depthFirstLP()
           
 void LogicalPlan.explain(OutputStream out, PrintStream ps)
           
 void LogicalPlan.explain(PrintStream ps, String format, boolean verbose)
           
 void LOPrinter.print(OutputStream printer)
           
protected  void ColumnPruner.prune(RelationalOperator lOp)
           
 Schema LogicalOperator.regenerateSchema()
          Regenerate the schema by unsetting and getting the schema
 void LogicalOperator.unsetSchema()
          Unset the schema as if it had not been calculated.
 void LOSplitOutput.unsetSchema()
           
 void LOJoin.unsetSchema()
           
 void LOForEach.unsetSchema()
           
 void LOFilter.unsetSchema()
           
 void LOCogroup.unsetSchema()
           
 void LOPrinter.visit()
           
protected  void LOVisitor.visit(BinaryExpressionOperator binOp)
           
protected  void LOVisitor.visit(ExpressionOperator eOp)
           
 void PlanSetter.visit(LOAdd op)
           
 void LogicalPlanCloneHelper.visit(LOAdd op)
           
 void LOVisitor.visit(LOAdd op)
           
 void PlanSetter.visit(LOAnd op)
           
 void LogicalPlanCloneHelper.visit(LOAnd binOp)
           
 void LOVisitor.visit(LOAnd binOp)
           
 void PlanSetter.visit(LOBinCond op)
           
protected  void LogicalPlanCloneHelper.visit(LOBinCond binCond)
           
protected  void LOVisitor.visit(LOBinCond binCond)
           
 void PlanSetter.visit(LOCast op)
           
protected  void LogicalPlanCloneHelper.visit(LOCast cast)
           
protected  void LOVisitor.visit(LOCast cast)
           
protected  void CastFinder.visit(LOCast cast)
           
protected  void ProjectionMapRemover.visit(LOCogroup cg)
           
protected  void ProjectionMapCalculator.visit(LOCogroup cg)
           
protected  void ProjectStarTranslator.visit(LOCogroup cg)
           
protected  void ProjectFixerUpper.visit(LOCogroup cg)
           
 void PlanSetter.visit(LOCogroup op)
           
protected  void LogicalPlanCloneHelper.visit(LOCogroup cg)
           
protected  void LOVisitor.visit(LOCogroup cg)
           
protected  void ColumnPruner.visit(LOCogroup cogroup)
           
 void PlanSetter.visit(LOConst op)
           
protected  void LogicalPlanCloneHelper.visit(LOConst constant)
           
protected  void LOVisitor.visit(LOConst store)
           
protected  void ProjectionMapRemover.visit(LOCross cs)
           
protected  void ProjectionMapCalculator.visit(LOCross cs)
           
 void PlanSetter.visit(LOCross op)
           
protected  void LogicalPlanCloneHelper.visit(LOCross cs)
           
protected  void LOVisitor.visit(LOCross cs)
           
protected  void ColumnPruner.visit(LOCross cross)
           
protected  void TopLevelProjectFinder.visit(LODistinct dt)
           
protected  void ProjectionMapRemover.visit(LODistinct dt)
           
protected  void ProjectionMapCalculator.visit(LODistinct dt)
           
 void PlanSetter.visit(LODistinct op)
           
protected  void LogicalPlanCloneHelper.visit(LODistinct dt)
           
protected  void LOVisitor.visit(LODistinct dt)
           
protected  void ColumnPruner.visit(LODistinct distinct)
           
 void PlanSetter.visit(LODivide op)
           
 void LogicalPlanCloneHelper.visit(LODivide op)
           
 void LOVisitor.visit(LODivide op)
           
 void PlanSetter.visit(LOEqual op)
           
 void LogicalPlanCloneHelper.visit(LOEqual op)
           
 void LOVisitor.visit(LOEqual op)
           
protected  void TopLevelProjectFinder.visit(LOFilter filter)
           
protected  void ProjectionMapRemover.visit(LOFilter filter)
           
protected  void ProjectionMapCalculator.visit(LOFilter filter)
           
protected  void ProjectFixerUpper.visit(LOFilter f)
           
 void PlanSetter.visit(LOFilter op)
           
protected  void LogicalPlanCloneHelper.visit(LOFilter filter)
           
protected  void LOVisitor.visit(LOFilter filter)
           
protected  void ColumnPruner.visit(LOFilter filter)
           
protected  void TopLevelProjectFinder.visit(LOForEach forEach)
           
protected  void ProjectionMapRemover.visit(LOForEach forEach)
           
protected  void ProjectionMapCalculator.visit(LOForEach forEach)
           
protected  void ProjectStarTranslator.visit(LOForEach forEach)
           
protected  void ProjectFixerUpper.visit(LOForEach f)
           
 void PlanSetter.visit(LOForEach op)
           
protected  void LogicalPlanCloneHelper.visit(LOForEach forEach)
           
protected  void LOVisitor.visit(LOForEach forEach)
           
protected  void ColumnPruner.visit(LOForEach foreach)
           
protected  void LogicalPlanCloneHelper.visit(LOGenerate g)
           
protected  void LOVisitor.visit(LOGenerate g)
           
protected  void LogicalPlanCloneHelper.visit(LogicalOperator op)
           
protected  void LOVisitor.visit(LogicalOperator lOp)
           
 void PlanSetter.visit(LOGreaterThan op)
           
 void LogicalPlanCloneHelper.visit(LOGreaterThan op)
           
 void LOVisitor.visit(LOGreaterThan op)
           
 void PlanSetter.visit(LOGreaterThanEqual op)
           
 void LogicalPlanCloneHelper.visit(LOGreaterThanEqual op)
           
 void LOVisitor.visit(LOGreaterThanEqual op)
           
 void PlanSetter.visit(LOIsNull op)
           
 void LogicalPlanCloneHelper.visit(LOIsNull uniOp)
           
 void LOVisitor.visit(LOIsNull uniOp)
           
protected  void ProjectionMapRemover.visit(LOJoin join)
           
protected  void ProjectionMapCalculator.visit(LOJoin join)
           
protected  void ProjectStarTranslator.visit(LOJoin join)
           
 void PlanSetter.visit(LOJoin op)
           
protected  void LOVisitor.visit(LOJoin loj)
           
protected  void ColumnPruner.visit(LOJoin join)
           
 void PlanSetter.visit(LOLesserThan op)
           
 void LogicalPlanCloneHelper.visit(LOLesserThan op)
           
 void LOVisitor.visit(LOLesserThan op)
           
 void PlanSetter.visit(LOLesserThanEqual op)
           
 void LogicalPlanCloneHelper.visit(LOLesserThanEqual op)
           
 void LOVisitor.visit(LOLesserThanEqual op)
           
protected  void ProjectionMapRemover.visit(LOLimit limit)
           
protected  void ProjectionMapCalculator.visit(LOLimit limit)
           
 void PlanSetter.visit(LOLimit op)
           
protected  void LogicalPlanCloneHelper.visit(LOLimit limOp)
           
protected  void LOVisitor.visit(LOLimit limOp)
           
protected  void ColumnPruner.visit(LOLimit limit)
           
protected  void ProjectionMapRemover.visit(LOLoad load)
           
protected  void ProjectionMapCalculator.visit(LOLoad load)
           
 void PlanSetter.visit(LOLoad op)
           
protected  void LogicalPlanCloneHelper.visit(LOLoad load)
           
protected  void LOVisitor.visit(LOLoad load)
           
protected  void ColumnPruner.visit(LOLoad lOp)
           
 void PlanSetter.visit(LOMapLookup op)
           
 void LogicalPlanCloneHelper.visit(LOMapLookup op)
           
 void LOVisitor.visit(LOMapLookup op)
           
 void PlanSetter.visit(LOMod op)
           
 void LogicalPlanCloneHelper.visit(LOMod op)
           
 void LOVisitor.visit(LOMod op)
           
 void PlanSetter.visit(LOMultiply op)
           
 void LogicalPlanCloneHelper.visit(LOMultiply op)
           
 void LOVisitor.visit(LOMultiply op)
           
 void PlanSetter.visit(LONegative op)
           
 void LogicalPlanCloneHelper.visit(LONegative op)
           
 void LOVisitor.visit(LONegative op)
           
 void PlanSetter.visit(LONot op)
           
 void LogicalPlanCloneHelper.visit(LONot uniOp)
           
 void LOVisitor.visit(LONot uniOp)
           
 void PlanSetter.visit(LONotEqual op)
           
 void LogicalPlanCloneHelper.visit(LONotEqual op)
           
 void LOVisitor.visit(LONotEqual op)
           
 void PlanSetter.visit(LOOr op)
           
 void LogicalPlanCloneHelper.visit(LOOr binOp)
           
 void LOVisitor.visit(LOOr binOp)
           
protected  void TopLevelProjectFinder.visit(LOProject project)
           
protected  void RemoveRedundantOperators.visit(LOProject project)
           
protected  void ProjectFixerUpper.visit(LOProject p)
           
 void PlanSetter.visit(LOProject op)
           
protected  void LogicalPlanCloneHelper.visit(LOProject project)
           
protected  void LOVisitor.visit(LOProject project)
           
 void PlanSetter.visit(LORegexp op)
           
protected  void LogicalPlanCloneHelper.visit(LORegexp binOp)
           
protected  void LOVisitor.visit(LORegexp regexp)
           
protected  void TopLevelProjectFinder.visit(LOSort s)
           
protected  void ProjectionMapRemover.visit(LOSort s)
           
protected  void ProjectionMapCalculator.visit(LOSort s)
           
protected  void ProjectStarTranslator.visit(LOSort s)
           
protected  void ProjectFixerUpper.visit(LOSort s)
           
 void PlanSetter.visit(LOSort op)
           
protected  void LogicalPlanCloneHelper.visit(LOSort s)
           
protected  void LOVisitor.visit(LOSort s)
           
protected  void ColumnPruner.visit(LOSort sort)
           
protected  void ProjectionMapRemover.visit(LOSplit split)
           
protected  void ProjectionMapCalculator.visit(LOSplit split)
           
protected  void ProjectFixerUpper.visit(LOSplit s)
           
 void PlanSetter.visit(LOSplit op)
           
protected  void LogicalPlanCloneHelper.visit(LOSplit split)
           
protected  void LOVisitor.visit(LOSplit split)
           
protected  void ColumnPruner.visit(LOSplit split)
           
protected  void ProjectionMapRemover.visit(LOSplitOutput sop)
           
protected  void ProjectionMapCalculator.visit(LOSplitOutput sop)
           
protected  void ProjectFixerUpper.visit(LOSplitOutput s)
           
 void PlanSetter.visit(LOSplitOutput op)
           
protected  void LogicalPlanCloneHelper.visit(LOSplitOutput sop)
           
protected  void LOVisitor.visit(LOSplitOutput sop)
           
protected  void ColumnPruner.visit(LOSplitOutput splitoutput)
           
protected  void ProjectionMapRemover.visit(LOStore store)
           
protected  void ProjectionMapCalculator.visit(LOStore store)
           
 void PlanSetter.visit(LOStore op)
           
protected  void LogicalPlanCloneHelper.visit(LOStore store)
           
protected  void LOVisitor.visit(LOStore store)
           
protected  void ColumnPruner.visit(LOStore store)
           
protected  void ProjectionMapRemover.visit(LOStream stream)
           
protected  void ProjectionMapCalculator.visit(LOStream stream)
           
 void PlanSetter.visit(LOStream op)
           
protected  void LogicalPlanCloneHelper.visit(LOStream stream)
           
protected  void LOVisitor.visit(LOStream stream)
           
protected  void ColumnPruner.visit(LOStream stream)
           
 void PlanSetter.visit(LOSubtract op)
           
 void LogicalPlanCloneHelper.visit(LOSubtract op)
           
 void LOVisitor.visit(LOSubtract op)
           
protected  void ProjectionMapRemover.visit(LOUnion u)
           
protected  void ProjectionMapCalculator.visit(LOUnion u)
           
 void PlanSetter.visit(LOUnion op)
           
protected  void LogicalPlanCloneHelper.visit(LOUnion u)
           
protected  void LOVisitor.visit(LOUnion u)
           
protected  void ColumnPruner.visit(LOUnion union)
           
protected  void UDFFinder.visit(LOUserFunc udf)
           
 void PlanSetter.visit(LOUserFunc op)
           
protected  void LogicalPlanCloneHelper.visit(LOUserFunc func)
           
protected  void LOVisitor.visit(LOUserFunc func)
          Iterate over each expression that is part of the function argument list
 void UnaryExpressionOperator.visit(LOVisitor v)
           
abstract  void LogicalOperator.visit(LOVisitor v)
          Visit this node with the provided visitor.
 void LOUserFunc.visit(LOVisitor v)
           
 void LOUnion.visit(LOVisitor v)
           
 void LOSubtract.visit(LOVisitor v)
           
 void LOStream.visit(LOVisitor v)
           
 void LOStore.visit(LOVisitor v)
           
 void LOSplitOutput.visit(LOVisitor v)
           
 void LOSplit.visit(LOVisitor v)
           
 void LOSort.visit(LOVisitor v)
           
 void LORegexp.visit(LOVisitor v)
           
 void LOProject.visit(LOVisitor v)
           
 void LOOr.visit(LOVisitor v)
           
 void LONotEqual.visit(LOVisitor v)
           
 void LONot.visit(LOVisitor v)
           
 void LONegative.visit(LOVisitor v)
           
 void LOMultiply.visit(LOVisitor v)
           
 void LOMod.visit(LOVisitor v)
           
 void LOMapLookup.visit(LOVisitor v)
           
 void LOLoad.visit(LOVisitor v)
           
 void LOLimit.visit(LOVisitor v)
           
 void LOLesserThanEqual.visit(LOVisitor v)
           
 void LOLesserThan.visit(LOVisitor v)
           
 void LOJoin.visit(LOVisitor v)
           
 void LOIsNull.visit(LOVisitor v)
           
 void LOGreaterThanEqual.visit(LOVisitor v)
           
 void LOGreaterThan.visit(LOVisitor v)
           
 void LOGenerate.visit(LOVisitor v)
           
 void LOForEach.visit(LOVisitor v)
           
 void LOFilter.visit(LOVisitor v)
           
 void LOEqual.visit(LOVisitor v)
           
 void LODivide.visit(LOVisitor v)
           
 void LODistinct.visit(LOVisitor v)
           
 void LOCross.visit(LOVisitor v)
           
 void LOConst.visit(LOVisitor v)
           
 void LOCogroup.visit(LOVisitor v)
           
 void LOCast.visit(LOVisitor v)
           
 void LOBinCond.visit(LOVisitor v)
           
 void LOAnd.visit(LOVisitor v)
           
 void LOAdd.visit(LOVisitor v)
           
 void BinaryExpressionOperator.visit(LOVisitor v)
           
protected  void LogicalPlanCloneHelper.visit(UnaryExpressionOperator uniOp)
           
protected  void LOVisitor.visit(UnaryExpressionOperator uniOp)
           
 

Constructors in org.apache.pig.impl.logicalLayer that throw VisitorException
ProjectFixerUpper(LogicalPlan plan, LogicalOperator oldNode, int oldNodeIndex, LogicalOperator newNode, boolean useOldNode, LogicalOperator containingNode)
           
ProjectFixerUpper(LogicalPlan plan, LogicalOperator oldNode, LogicalOperator newNode, Map<Integer,Integer> projectionMapping)
           
 

Uses of VisitorException in org.apache.pig.impl.logicalLayer.optimizer
 

Methods in org.apache.pig.impl.logicalLayer.optimizer that throw VisitorException
protected  void LogicalTransformer.fixUpContainedPlans(LogicalOperator after, LogicalOperator newNode, LogicalOperator before, Map<Integer,Integer> projectionMapping)
          Once a node has been inserted, inner plans associated with other nodes may have references to the node that has been replaced or moved.
protected  void LogicalTransformer.insertAfter(LogicalOperator after, LogicalOperator newNode, Map<Integer,Integer> projectionMapping)
          Insert a node in after an existing nodes.
protected  void LogicalTransformer.insertBetween(LogicalOperator after, LogicalOperator newNode, LogicalOperator before, Map<Integer,Integer> projectionMapping)
          Insert a node in between two existing nodes.
protected  void LogicalTransformer.rebuildProjectionMaps()
          Rebuild projection maps after a rule has transformed the tree.
protected  void LogicalTransformer.rebuildSchemas()
          Rebuild schemas after a rule has transformed the tree.
protected  void SchemaRemover.visit(BinaryExpressionOperator binOp)
           
protected  void SchemaCalculator.visit(BinaryExpressionOperator binOp)
           
protected  void SchemaRemover.visit(ExpressionOperator op)
           
 void SchemaRemover.visit(LOAdd op)
           
 void SchemaRemover.visit(LOAnd binOp)
           
protected  void SchemaRemover.visit(LOBinCond binCond)
           
protected  void SchemaCalculator.visit(LOBinCond binCond)
           
protected  void SchemaRemover.visit(LOCast cast)
           
protected  void SchemaCalculator.visit(LOCast cast)
           
protected  void SchemaRemover.visit(LOCogroup cg)
           
protected  void SchemaCalculator.visit(LOCogroup cg)
           
protected  void SchemaRemover.visit(LOConst c)
           
protected  void SchemaCalculator.visit(LOConst c)
           
protected  void SchemaRemover.visit(LOCross cs)
           
protected  void SchemaCalculator.visit(LOCross cs)
           
protected  void SchemaRemover.visit(LODistinct dt)
           
protected  void SchemaCalculator.visit(LODistinct dt)
           
 void SchemaRemover.visit(LODivide op)
           
 void SchemaRemover.visit(LOEqual op)
           
protected  void SchemaRemover.visit(LOFilter filter)
           
protected  void SchemaCalculator.visit(LOFilter filter)
           
protected  void SchemaRemover.visit(LOForEach forEach)
           
protected  void SchemaCalculator.visit(LOForEach forEach)
           
 void SchemaRemover.visit(LOGreaterThan op)
           
 void SchemaRemover.visit(LOGreaterThanEqual op)
           
 void SchemaRemover.visit(LOIsNull uniOp)
           
protected  void SchemaRemover.visit(LOJoin join)
           
protected  void SchemaCalculator.visit(LOJoin join)
           
 void SchemaRemover.visit(LOLesserThan op)
           
 void SchemaRemover.visit(LOLesserThanEqual op)
           
protected  void SchemaRemover.visit(LOLimit limit)
           
protected  void SchemaCalculator.visit(LOLimit limit)
           
protected  void SchemaRemover.visit(LOLoad load)
           
protected  void SchemaCalculator.visit(LOLoad load)
           
 void SchemaRemover.visit(LOMapLookup op)
           
 void SchemaRemover.visit(LOMod op)
           
 void SchemaRemover.visit(LOMultiply op)
           
 void SchemaRemover.visit(LONegative op)
           
 void SchemaRemover.visit(LONot uniOp)
           
 void SchemaRemover.visit(LONotEqual op)
           
 void SchemaRemover.visit(LOOr binOp)
           
protected  void SchemaRemover.visit(LOProject project)
           
protected  void SchemaCalculator.visit(LOProject project)
           
protected  void SchemaRemover.visit(LORegexp regexp)
           
protected  void SchemaCalculator.visit(LORegexp regexp)
           
protected  void SchemaRemover.visit(LOSort s)
           
protected  void SchemaCalculator.visit(LOSort s)
           
protected  void SchemaRemover.visit(LOSplit split)
           
protected  void SchemaCalculator.visit(LOSplit split)
           
protected  void SchemaRemover.visit(LOSplitOutput sop)
           
protected  void SchemaCalculator.visit(LOSplitOutput sop)
           
protected  void SchemaRemover.visit(LOStore store)
           
protected  void SchemaCalculator.visit(LOStore store)
           
 void SchemaRemover.visit(LOSubtract op)
           
protected  void SchemaRemover.visit(LOUnion u)
           
protected  void SchemaCalculator.visit(LOUnion u)
           
protected  void SchemaRemover.visit(LOUserFunc func)
          Iterate over each expression that is part of the function argument list
protected  void SchemaCalculator.visit(LOUserFunc func)
          Iterate over each expression that is part of the function argument list
protected  void SchemaRemover.visit(UnaryExpressionOperator uniOp)
           
protected  void SchemaCalculator.visit(UnaryExpressionOperator uniOp)
           
 

Uses of VisitorException in org.apache.pig.impl.logicalLayer.validators
 

Subclasses of VisitorException in org.apache.pig.impl.logicalLayer.validators
 class TypeCheckerException
           
 

Methods in org.apache.pig.impl.logicalLayer.validators that throw VisitorException
 byte TypeCheckingVisitor.getAtomicGroupByType(LOCogroup cg)
          This can be used to get the merged type of output group col only when the group col is of atomic type TODO: This doesn't work with group by complex type
 Schema TypeCheckingVisitor.getTupleGroupBySchema(LOCogroup cg)
           
protected  void TypeCheckingVisitor.visit(ExpressionOperator eOp)
           
 void TypeCheckingVisitor.visit(LOAdd binOp)
           
 void TypeCheckingVisitor.visit(LOAnd binOp)
           
protected  void TypeCheckingVisitor.visit(LOBinCond binCond)
          For Bincond, lhsOp and rhsOp must have the same output type or both sides have to be number
protected  void TypeCheckingVisitor.visit(LOCast cast)
          For Basic Types: 0) Casting to itself is always ok 1) Casting from number to number is always ok 2) ByteArray to anything is ok 3) (number or chararray) to (bytearray or chararray) is ok For Composite Types: Recursively traverse the schemas till you get a basic type
protected  void TypeCheckingVisitor.visit(LOCogroup cg)
          COGroup All group by cols from all inputs have to be of the same type
protected  void TypeCheckingVisitor.visit(LOConst cs)
          LOConst.
protected  void TypeCheckingVisitor.visit(LOCross cs)
          Return concatenated of all fields from all input operators If one of the inputs have no schema then we cannot construct the output schema.
protected  void TypeCheckingVisitor.visit(LODistinct op)
          LODistinct, output schema should be the same as input
 void TypeCheckingVisitor.visit(LODivide binOp)
           
 void TypeCheckingVisitor.visit(LOEqual binOp)
           
protected  void TypeCheckingVisitor.visit(LOFilter filter)
          The schema of filter output will be the same as filter input
protected  void TypeCheckingVisitor.visit(LOForEach f)
          Output schema of LOForEach is a tuple schma which is the output of all inner plans Flatten also has to be taken care on in here
protected  void TypeCheckingVisitor.visit(LogicalOperator lOp)
           
 void TypeCheckingVisitor.visit(LOGreaterThan binOp)
           
 void TypeCheckingVisitor.visit(LOGreaterThanEqual binOp)
           
 void TypeCheckingVisitor.visit(LOIsNull uniOp)
           
protected  void TypeCheckingVisitor.visit(LOJoin join)
          LOJoin visitor
 void TypeCheckingVisitor.visit(LOLesserThan binOp)
           
 void TypeCheckingVisitor.visit(LOLesserThanEqual binOp)
           
protected  void TypeCheckingVisitor.visit(LOLimit op)
           
protected  void TypeCheckingVisitor.visit(LOLoad load)
           
 void TypeCheckingVisitor.visit(LOMapLookup map)
           
 void TypeCheckingVisitor.visit(LOMod binOp)
           
 void TypeCheckingVisitor.visit(LOMultiply binOp)
           
 void TypeCheckingVisitor.visit(LONegative uniOp)
           
 void TypeCheckingVisitor.visit(LONot uniOp)
           
 void TypeCheckingVisitor.visit(LONotEqual binOp)
           
 void TypeCheckingVisitor.visit(LOOr binOp)
           
protected  void TypeCheckingVisitor.visit(LOProject pj)
           
protected  void TypeCheckingVisitor.visit(LORegexp rg)
          LORegexp expects CharArray as input Itself always returns Boolean
protected  void TypeCheckingVisitor.visit(LOSort s)
          The schema of sort output will be the same as sort input.
protected  void TypeCheckingVisitor.visit(LOSplit split)
          The schema of split output will be the same as split input
protected  void TypeCheckingVisitor.visit(LOSplitOutput op)
           
 void TypeCheckingVisitor.visit(LOSubtract binOp)
           
protected  void TypeCheckingVisitor.visit(LOUnion u)
           
protected  void TypeCheckingVisitor.visit(LOUserFunc func)
           
protected  void TypeCheckingVisitor.visit(UnaryExpressionOperator uniOp)
          Currently, there are two unaryOps: Neg and Not.
 

Uses of VisitorException in org.apache.pig.impl.plan
 

Subclasses of VisitorException in org.apache.pig.impl.plan
 class PlanValidationException
           
 

Methods in org.apache.pig.impl.plan that throw VisitorException
protected  String PlanPrinter.depthFirst()
           
protected  void DependencyOrderWalker.doAllPredecessors(O node, Set<O> seen, Collection<O> fifo)
           
protected  void ReverseDependencyOrderWalker.doAllSuccessors(O node, Set<O> seen, Collection<O> fifo)
           
 void OperatorPlan.explain(OutputStream out, PrintStream ps)
           
protected  void PlanVisitor.popWalker()
          Pop the next to previous walker off of the stack and set it as the current walker.
 void PlanPrinter.print(OutputStream printer)
           
 void PlanVisitor.visit()
          Entry point for visiting the plan.
 void PlanPrinter.visit()
           
abstract  void Operator.visit(V v)
          Visit this node with the provided visitor.
 void ReverseDependencyOrderWalker.walk(PlanVisitor<O,P> visitor)
          Begin traversing the graph.
abstract  void PlanWalker.walk(PlanVisitor<O,P> visitor)
          Begin traversing the graph.
 void DepthFirstWalker.walk(PlanVisitor<O,P> visitor)
          Begin traversing the graph.
 void DependencyOrderWalkerWOSeenChk.walk(PlanVisitor<O,P> visitor)
          Begin traversing the graph.
 void DependencyOrderWalker.walk(PlanVisitor<O,P> visitor)
          Begin traversing the graph.
 

Uses of VisitorException in org.apache.pig.impl.plan.optimizer
 

Subclasses of VisitorException in org.apache.pig.impl.plan.optimizer
 class OptimizerException
           
 

Methods in org.apache.pig.impl.plan.optimizer that throw VisitorException
protected  String RulePlanPrinter.depthFirst()
           
 void RulePlan.explain(OutputStream out, PrintStream ps)
           
 void RulePlanPrinter.print(OutputStream printer)
           
 void RulePlanPrinter.visit()
           
 void CommonNodeFinder.visit()
           
protected  void RulePlanVisitor.visit(RuleOperator ruleOp)
           
protected  void CommonNodeFinder.visit(RuleOperator ruleOp)
           
 void RuleOperator.visit(RulePlanVisitor v)
          Visit this node with the provided visitor.
 

Uses of VisitorException in org.apache.pig.pen
 

Methods in org.apache.pig.pen that throw VisitorException
protected  void LineageTrimmingVisitor.visit(LOCogroup cg)
           
protected  void DerivedDataVisitor.visit(LOCogroup cg)
           
protected  void AugmentBaseDataVisitor.visit(LOCogroup cg)
           
protected  void LineageTrimmingVisitor.visit(LOCross cs)
           
protected  void DerivedDataVisitor.visit(LOCross cs)
           
protected  void AugmentBaseDataVisitor.visit(LOCross cs)
           
protected  void LineageTrimmingVisitor.visit(LODistinct dt)
           
protected  void DerivedDataVisitor.visit(LODistinct dt)
           
protected  void AugmentBaseDataVisitor.visit(LODistinct dt)
           
protected  void LineageTrimmingVisitor.visit(LOFilter filter)
           
protected  void DerivedDataVisitor.visit(LOFilter filter)
           
protected  void AugmentBaseDataVisitor.visit(LOFilter filter)
           
protected  void LineageTrimmingVisitor.visit(LOForEach forEach)
           
protected  void DerivedDataVisitor.visit(LOForEach forEach)
           
protected  void AugmentBaseDataVisitor.visit(LOForEach forEach)
           
protected  void LineageTrimmingVisitor.visit(LOLimit limOp)
           
protected  void DerivedDataVisitor.visit(LOLimit l)
           
protected  void LineageTrimmingVisitor.visit(LOLoad load)
           
protected  void DerivedDataVisitor.visit(LOLoad load)
           
protected  void AugmentBaseDataVisitor.visit(LOLoad load)
           
protected  void LineageTrimmingVisitor.visit(LOSort s)
           
protected  void DerivedDataVisitor.visit(LOSort sort)
           
protected  void AugmentBaseDataVisitor.visit(LOSort s)
           
protected  void LineageTrimmingVisitor.visit(LOSplit split)
           
protected  void DerivedDataVisitor.visit(LOSplit split)
           
protected  void AugmentBaseDataVisitor.visit(LOSplit split)
           
protected  void DerivedDataVisitor.visit(LOStore store)
           
protected  void AugmentBaseDataVisitor.visit(LOStore store)
           
protected  void LineageTrimmingVisitor.visit(LOUnion u)
           
protected  void DerivedDataVisitor.visit(LOUnion u)
           
protected  void AugmentBaseDataVisitor.visit(LOUnion u)
           
 

Uses of VisitorException in org.apache.pig.pen.util
 

Methods in org.apache.pig.pen.util that throw VisitorException
 void PreOrderDepthFirstWalker.walk(PlanVisitor<O,P> visitor)
          Begin traversing the graph.
 void DependencyOrderLimitedWalker.walk(PlanVisitor<O,P> visitor)
           
 



Copyright © ${year} The Apache Software Foundation