|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of VisitorException in org.apache.pig |
---|
Methods in org.apache.pig that throw VisitorException | |
---|---|
protected void |
PigServer.SortInfoSetter.visit(LOStore store)
|
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.visitPenCogroup(POCogroup cogroup)
|
void |
PhyPlanVisitor.visitPenCross(POCross cross)
|
void |
PhyPlanVisitor.visitPenSplit(POSplit split)
|
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 LinkedList<POLoad> |
PlanHelper.getLoads(PhysicalPlan plan)
Get all the load operators in the plan in the right dependency order |
static LinkedList<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.experimental.logical |
---|
Methods in org.apache.pig.experimental.logical that throw VisitorException | |
---|---|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOAdd binOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOAnd binOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOBinCond op)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOCast cast)
|
void |
LogicalPlanMigrationVistor.visit(LOCogroup cg)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOConst con)
|
void |
LogicalPlanMigrationVistor.visit(LOCross cs)
|
void |
LogicalPlanMigrationVistor.visit(LODistinct dt)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LODivide binOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOEqual op)
|
void |
LogicalPlanMigrationVistor.visit(LOFilter filter)
|
void |
LogicalPlanMigrationVistor.visit(LOForEach forEach)
|
void |
LogicalPlanMigrationVistor.ForeachInnerPlanVisitor.visit(LOForEach foreach)
|
void |
LogicalPlanMigrationVistor.visit(LOGenerate g)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOGreaterThan op)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOGreaterThanEqual op)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOIsNull uniOp)
|
void |
LogicalPlanMigrationVistor.visit(LOJoin loj)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOLesserThan op)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOLesserThanEqual op)
|
void |
LogicalPlanMigrationVistor.visit(LOLimit limOp)
|
void |
LogicalPlanMigrationVistor.ForeachInnerPlanVisitor.visit(LOLimit limOp)
|
void |
LogicalPlanMigrationVistor.visit(LOLoad load)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOMapLookup colOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOMod binOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOMultiply binOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LONegative uniOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LONot uniOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LONotEqual op)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOOr binOp)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOProject project)
|
void |
LogicalPlanMigrationVistor.ForeachInnerPlanVisitor.visit(LOProject project)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LORegexp binOp)
|
void |
LogicalPlanMigrationVistor.visit(LOSort s)
|
void |
LogicalPlanMigrationVistor.ForeachInnerPlanVisitor.visit(LOSort s)
|
void |
LogicalPlanMigrationVistor.visit(LOSplit split)
|
void |
LogicalPlanMigrationVistor.visit(LOSplitOutput splitOutput)
|
void |
LogicalPlanMigrationVistor.visit(LOStore store)
|
void |
LogicalPlanMigrationVistor.visit(LOStream stream)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOSubtract binOp)
|
void |
LogicalPlanMigrationVistor.visit(LOUnion union)
|
void |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.visit(LOUserFunc op)
|
Uses of VisitorException in org.apache.pig.experimental.plan |
---|
Methods in org.apache.pig.experimental.plan that throw VisitorException | |
---|---|
protected void |
PlanVisitor.popWalker()
Pop the next to previous walker off of the stack and set it as the current walker. |
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 |
PColFilterExtractor.visit()
|
void |
LOPrinter.visit()
|
protected void |
PColFilterExtractor.visit(BinaryExpressionOperator binOp)
|
protected void |
LOVisitor.visit(BinaryExpressionOperator binOp)
|
protected void |
PColFilterExtractor.visit(ExpressionOperator op)
|
protected void |
LOVisitor.visit(ExpressionOperator eOp)
|
void |
PlanSetter.visit(LOAdd op)
|
void |
PColFilterExtractor.visit(LOAdd op)
|
void |
LogicalPlanCloneHelper.visit(LOAdd op)
|
void |
LOVisitor.visit(LOAdd op)
|
void |
PlanSetter.visit(LOAnd op)
|
void |
PColFilterExtractor.visit(LOAnd op)
|
void |
LogicalPlanCloneHelper.visit(LOAnd binOp)
|
void |
LOVisitor.visit(LOAnd binOp)
|
void |
PlanSetter.visit(LOBinCond op)
|
protected void |
PColFilterExtractor.visit(LOBinCond binCond)
|
protected void |
LogicalPlanCloneHelper.visit(LOBinCond binCond)
|
protected void |
LOVisitor.visit(LOBinCond binCond)
|
void |
PlanSetter.visit(LOCast op)
|
protected void |
PColFilterExtractor.visit(LOCast cast)
|
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 |
PColFilterExtractor.visit(LODivide op)
|
void |
LogicalPlanCloneHelper.visit(LODivide op)
|
void |
LOVisitor.visit(LODivide op)
|
void |
PlanSetter.visit(LOEqual op)
|
void |
PColFilterExtractor.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 |
PColFilterExtractor.visit(LOGreaterThan op)
|
void |
LogicalPlanCloneHelper.visit(LOGreaterThan op)
|
void |
LOVisitor.visit(LOGreaterThan op)
|
void |
PlanSetter.visit(LOGreaterThanEqual op)
|
void |
PColFilterExtractor.visit(LOGreaterThanEqual op)
|
void |
LogicalPlanCloneHelper.visit(LOGreaterThanEqual op)
|
void |
LOVisitor.visit(LOGreaterThanEqual op)
|
void |
PlanSetter.visit(LOIsNull op)
|
void |
PColFilterExtractor.visit(LOIsNull isNull)
|
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 |
PColFilterExtractor.visit(LOLesserThan op)
|
void |
LogicalPlanCloneHelper.visit(LOLesserThan op)
|
void |
LOVisitor.visit(LOLesserThan op)
|
void |
PlanSetter.visit(LOLesserThanEqual op)
|
void |
PColFilterExtractor.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 |
PColFilterExtractor.visit(LOMod op)
|
void |
LogicalPlanCloneHelper.visit(LOMod op)
|
void |
LOVisitor.visit(LOMod op)
|
void |
PlanSetter.visit(LOMultiply op)
|
void |
PColFilterExtractor.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 |
PColFilterExtractor.visit(LONot not)
|
void |
LogicalPlanCloneHelper.visit(LONot uniOp)
|
void |
LOVisitor.visit(LONot uniOp)
|
void |
PlanSetter.visit(LONotEqual op)
|
void |
PColFilterExtractor.visit(LONotEqual op)
|
void |
LogicalPlanCloneHelper.visit(LONotEqual op)
|
void |
LOVisitor.visit(LONotEqual op)
|
void |
PlanSetter.visit(LOOr op)
|
void |
PColFilterExtractor.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 |
PColFilterExtractor.visit(LOProject project)
|
protected void |
LogicalPlanCloneHelper.visit(LOProject project)
|
protected void |
LOVisitor.visit(LOProject project)
|
void |
PlanSetter.visit(LORegexp op)
|
protected void |
PColFilterExtractor.visit(LORegexp regexp)
|
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 |
PColFilterExtractor.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 |
PColFilterExtractor.visit(LOUserFunc udf)
|
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 | |
---|---|
void |
LocalLogToPhyTranslationVisitor.visit(LOCogroup cg)
|
protected void |
LineageTrimmingVisitor.visit(LOCogroup cg)
|
protected void |
DerivedDataVisitor.visit(LOCogroup cg)
|
protected void |
AugmentBaseDataVisitor.visit(LOCogroup cg)
|
void |
LocalLogToPhyTranslationVisitor.visit(LOCross cross)
|
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)
|
void |
LocalLogToPhyTranslationVisitor.visit(LOJoin join)
|
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)
|
void |
LocalLogToPhyTranslationVisitor.visit(LOSplit split)
|
protected void |
LineageTrimmingVisitor.visit(LOSplit split)
|
protected void |
DerivedDataVisitor.visit(LOSplit split)
|
protected void |
AugmentBaseDataVisitor.visit(LOSplit split)
|
void |
LocalLogToPhyTranslationVisitor.visit(LOSplitOutput split)
|
void |
LocalLogToPhyTranslationVisitor.visit(LOStore loStore)
|
protected void |
DerivedDataVisitor.visit(LOStore store)
|
protected void |
AugmentBaseDataVisitor.visit(LOStore store)
|
void |
LocalLogToPhyTranslationVisitor.visit(LOStream stream)
|
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.physicalOperators |
---|
Methods in org.apache.pig.pen.physicalOperators that throw VisitorException | |
---|---|
void |
POSplitOutput.visit(PhyPlanVisitor v)
|
void |
POSplit.visit(PhyPlanVisitor v)
|
void |
POCross.visit(PhyPlanVisitor v)
|
void |
POCounter.visit(PhyPlanVisitor v)
|
void |
POCogroup.visit(PhyPlanVisitor v)
|
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)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |