|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
abstract void |
Launcher.explain(PhysicalPlan pp,
PigContext pc,
PrintStream ps)
Explain how a pig job will be executed on the underlying infrastructure. |
void |
LocalLauncher.explain(PhysicalPlan php,
PigContext pc,
PrintStream ps)
|
void |
MapReduceLauncher.explain(PhysicalPlan php,
PigContext pc,
PrintStream ps)
|
Pair<MapReduceOper,Integer> |
MRCompiler.getQuantileJob(POSort inpSort,
MapReduceOper prevJob,
FileSpec lFile,
FileSpec quantFile,
int rp,
Pair<Integer,Byte>[] fields)
|
abstract boolean |
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. |
boolean |
LocalLauncher.launchPig(PhysicalPlan php,
String grpName,
PigContext pc)
|
boolean |
MapReduceLauncher.launchPig(PhysicalPlan php,
String grpName,
PigContext pc)
|
boolean |
LocalLauncher.launchPigWithCombinePlan(PhysicalPlan php,
String grpName,
PigContext pc,
PhysicalPlan combinePlan)
|
void |
MapReduceOper.visit(MROpPlanVisitor v)
|
void |
MRCompiler.visitDistinct(PODistinct op)
|
void |
MRCompiler.visitFilter(POFilter op)
|
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 |
MRCompiler.visitGlobalRearrange(POGlobalRearrange op)
|
void |
MRCompiler.visitLimit(POLimit op)
|
void |
MRCompiler.visitLoad(POLoad op)
|
void |
MRCompiler.visitLocalRearrange(POLocalRearrange op)
|
void |
CombinerOptimizer.visitMROp(MapReduceOper mr)
|
void |
KeyTypeDiscoveryVisitor.visitMROp(MapReduceOper mr)
|
void |
MRCompiler.visitPackage(POPackage op)
|
void |
MRCompiler.visitPOForEach(POForEach op)
|
void |
MRCompiler.visitSort(POSort op)
|
void |
MRCompiler.visitSplit(POSplit op)
Compiles a split operator. |
void |
MRCompiler.visitStore(POStore op)
|
void |
MRCompiler.visitStream(POStream op)
|
void |
MRCompiler.visitUnion(POUnion op)
|
void |
UDFFinishVisitor.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 |
MROpPlanVisitor.visitMROp(MapReduceOper mr)
|
void |
MRPrinter.visitMROp(MapReduceOper mr)
|
void |
MRStreamHandler.visitMROp(MapReduceOper mr)
|
void |
POPackageAnnotator.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)
|
protected void |
LogToPhyTranslationVisitor.visit(LOFRJoin frj)
Create the inner plans used to configure the Local Rearrange operators(ppLists) Extract the keytypes and create the POFRJoin operator. |
void |
LogToPhyTranslationVisitor.visit(LOGreaterThan op)
|
void |
LogToPhyTranslationVisitor.visit(LOGreaterThanEqual op)
|
void |
LogToPhyTranslationVisitor.visit(LOIsNull op)
|
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 |
---|
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.visitCombinerPackage(POCombinerPackage pkg)
|
void |
PhyPlanVisitor.visitComparisonFunc(POUserComparisonFunc compFunc)
|
void |
PhyPlanVisitor.visitConstant(ConstantExpression cnst)
|
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.visitMod(Mod mod)
|
void |
PhyPlanVisitor.visitMultiply(Multiply mul)
|
void |
PhyPlanVisitor.visitNot(PONot not)
|
void |
PhyPlanVisitor.visitNotEqualTo(NotEqualToExpr eq)
|
void |
PhyPlanVisitor.visitOr(POOr or)
|
void |
PhyPlanVisitor.visitPackage(POPackage pkg)
|
void |
PhyPlanVisitor.visitPOForEach(POForEach nfe)
|
void |
PhyPlanVisitor.visitProject(POProject proj)
|
void |
PhyPlanVisitor.visitRead(PORead read)
|
void |
PhyPlanVisitor.visitRegexp(PORegexp re)
|
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 |
POCombinerPackage.visit(PhyPlanVisitor v)
|
void |
PODistinct.visit(PhyPlanVisitor v)
|
void |
POFRJoin.visit(PhyPlanVisitor v)
|
void |
POFilter.visit(PhyPlanVisitor v)
|
void |
POForEach.visit(PhyPlanVisitor v)
|
void |
POGlobalRearrange.visit(PhyPlanVisitor v)
|
void |
POJoinPackage.visit(PhyPlanVisitor v)
|
void |
POLimit.visit(PhyPlanVisitor v)
|
void |
POLoad.visit(PhyPlanVisitor v)
|
void |
POLocalRearrange.visit(PhyPlanVisitor v)
|
void |
POLocalRearrangeForIllustrate.visit(PhyPlanVisitor v)
|
void |
POOptimizedForEach.visit(PhyPlanVisitor v)
|
void |
POPackage.visit(PhyPlanVisitor v)
|
void |
POPreCombinerLocalRearrange.visit(PhyPlanVisitor v)
|
void |
PORead.visit(PhyPlanVisitor v)
|
void |
POSort.visit(PhyPlanVisitor v)
|
void |
POSplit.visit(PhyPlanVisitor v)
|
void |
POStore.visit(PhyPlanVisitor v)
|
void |
POStream.visit(PhyPlanVisitor v)
|
void |
POUnion.visit(PhyPlanVisitor v)
|
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)
|
boolean |
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(LOSplit split)
|
void |
LocalLogToPhyTranslationVisitor.visit(LOSplitOutput split)
|
void |
LocalLogToPhyTranslationVisitor.visit(LOStream stream)
|
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 |
POCogroup.visit(PhyPlanVisitor v)
|
void |
POCross.visit(PhyPlanVisitor v)
|
void |
POSplit.visit(PhyPlanVisitor v)
|
void |
POSplitOutput.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 |
LOPrinter.print(OutputStream printer)
|
Schema |
LogicalOperator.regenerateSchema()
|
void |
LOCogroup.unsetSchema()
|
void |
LOFRJoin.unsetSchema()
|
void |
LOFilter.unsetSchema()
|
void |
LOForEach.unsetSchema()
|
void |
LOSplitOutput.unsetSchema()
|
void |
LogicalOperator.unsetSchema()
Unset the schema as if it had not been calculated. |
void |
LOPrinter.visit()
|
protected void |
LOVisitor.visit(BinaryExpressionOperator binOp)
|
protected void |
LOVisitor.visit(ExpressionOperator eOp)
|
void |
LOVisitor.visit(LOAdd op)
|
void |
LogicalPlanCloneHelper.visit(LOAdd op)
|
void |
PlanSetter.visit(LOAdd op)
|
void |
LOVisitor.visit(LOAnd binOp)
|
void |
LogicalPlanCloneHelper.visit(LOAnd binOp)
|
void |
PlanSetter.visit(LOAnd op)
|
protected void |
LOVisitor.visit(LOBinCond binCond)
|
protected void |
LogicalPlanCloneHelper.visit(LOBinCond binCond)
|
void |
PlanSetter.visit(LOBinCond op)
|
protected void |
LOVisitor.visit(LOCast cast)
|
protected void |
LogicalPlanCloneHelper.visit(LOCast cast)
|
void |
PlanSetter.visit(LOCast op)
|
protected void |
LOVisitor.visit(LOCogroup cg)
|
protected void |
LogicalPlanCloneHelper.visit(LOCogroup cg)
|
void |
PlanSetter.visit(LOCogroup op)
|
protected void |
ProjectStarTranslator.visit(LOCogroup cg)
|
protected void |
LOVisitor.visit(LOConst store)
|
protected void |
LogicalPlanCloneHelper.visit(LOConst constant)
|
void |
PlanSetter.visit(LOConst op)
|
protected void |
LOVisitor.visit(LOCross cs)
|
protected void |
LogicalPlanCloneHelper.visit(LOCross cs)
|
void |
PlanSetter.visit(LOCross op)
|
protected void |
LOVisitor.visit(LODistinct dt)
|
protected void |
LogicalPlanCloneHelper.visit(LODistinct dt)
|
void |
PlanSetter.visit(LODistinct op)
|
void |
LOVisitor.visit(LODivide op)
|
void |
LogicalPlanCloneHelper.visit(LODivide op)
|
void |
PlanSetter.visit(LODivide op)
|
void |
LOVisitor.visit(LOEqual op)
|
void |
LogicalPlanCloneHelper.visit(LOEqual op)
|
void |
PlanSetter.visit(LOEqual op)
|
protected void |
LOVisitor.visit(LOFilter filter)
|
protected void |
LogicalPlanCloneHelper.visit(LOFilter filter)
|
void |
PlanSetter.visit(LOFilter op)
|
protected void |
LOVisitor.visit(LOForEach forEach)
|
protected void |
LogicalPlanCloneHelper.visit(LOForEach forEach)
|
void |
PlanSetter.visit(LOForEach op)
|
protected void |
ProjectStarTranslator.visit(LOForEach forEach)
|
protected void |
LOVisitor.visit(LOFRJoin frj)
|
void |
PlanSetter.visit(LOFRJoin op)
|
protected void |
ProjectStarTranslator.visit(LOFRJoin frj)
|
protected void |
LOVisitor.visit(LOGenerate g)
|
protected void |
LogicalPlanCloneHelper.visit(LOGenerate g)
|
protected void |
LOVisitor.visit(LogicalOperator lOp)
|
protected void |
LogicalPlanCloneHelper.visit(LogicalOperator op)
|
void |
LOVisitor.visit(LOGreaterThan op)
|
void |
LogicalPlanCloneHelper.visit(LOGreaterThan op)
|
void |
PlanSetter.visit(LOGreaterThan op)
|
void |
LOVisitor.visit(LOGreaterThanEqual op)
|
void |
LogicalPlanCloneHelper.visit(LOGreaterThanEqual op)
|
void |
PlanSetter.visit(LOGreaterThanEqual op)
|
void |
LOVisitor.visit(LOIsNull uniOp)
|
void |
LogicalPlanCloneHelper.visit(LOIsNull uniOp)
|
void |
PlanSetter.visit(LOIsNull op)
|
void |
LOVisitor.visit(LOLesserThan op)
|
void |
LogicalPlanCloneHelper.visit(LOLesserThan op)
|
void |
PlanSetter.visit(LOLesserThan op)
|
void |
LOVisitor.visit(LOLesserThanEqual op)
|
void |
LogicalPlanCloneHelper.visit(LOLesserThanEqual op)
|
void |
PlanSetter.visit(LOLesserThanEqual op)
|
protected void |
LOVisitor.visit(LOLimit limOp)
|
protected void |
LogicalPlanCloneHelper.visit(LOLimit limOp)
|
void |
PlanSetter.visit(LOLimit op)
|
protected void |
LOVisitor.visit(LOLoad load)
|
protected void |
LogicalPlanCloneHelper.visit(LOLoad load)
|
void |
PlanSetter.visit(LOLoad op)
|
void |
LOVisitor.visit(LOMapLookup op)
|
void |
LogicalPlanCloneHelper.visit(LOMapLookup op)
|
void |
PlanSetter.visit(LOMapLookup op)
|
void |
LOVisitor.visit(LOMod op)
|
void |
LogicalPlanCloneHelper.visit(LOMod op)
|
void |
PlanSetter.visit(LOMod op)
|
void |
LOVisitor.visit(LOMultiply op)
|
void |
LogicalPlanCloneHelper.visit(LOMultiply op)
|
void |
PlanSetter.visit(LOMultiply op)
|
void |
LOVisitor.visit(LONegative op)
|
void |
LogicalPlanCloneHelper.visit(LONegative op)
|
void |
PlanSetter.visit(LONegative op)
|
void |
LOVisitor.visit(LONot uniOp)
|
void |
LogicalPlanCloneHelper.visit(LONot uniOp)
|
void |
PlanSetter.visit(LONot op)
|
void |
LOVisitor.visit(LONotEqual op)
|
void |
LogicalPlanCloneHelper.visit(LONotEqual op)
|
void |
PlanSetter.visit(LONotEqual op)
|
void |
LOVisitor.visit(LOOr binOp)
|
void |
LogicalPlanCloneHelper.visit(LOOr binOp)
|
void |
PlanSetter.visit(LOOr op)
|
protected void |
LOVisitor.visit(LOProject project)
|
protected void |
LogicalPlanCloneHelper.visit(LOProject project)
|
void |
PlanSetter.visit(LOProject op)
|
protected void |
RemoveRedundantOperators.visit(LOProject project)
|
protected void |
LOVisitor.visit(LORegexp regexp)
|
protected void |
LogicalPlanCloneHelper.visit(LORegexp binOp)
|
void |
PlanSetter.visit(LORegexp op)
|
protected void |
LOVisitor.visit(LOSort s)
|
protected void |
LogicalPlanCloneHelper.visit(LOSort s)
|
void |
PlanSetter.visit(LOSort op)
|
protected void |
ProjectStarTranslator.visit(LOSort s)
|
protected void |
LOVisitor.visit(LOSplit split)
|
protected void |
LogicalPlanCloneHelper.visit(LOSplit split)
|
void |
PlanSetter.visit(LOSplit op)
|
protected void |
LOVisitor.visit(LOSplitOutput sop)
|
protected void |
LogicalPlanCloneHelper.visit(LOSplitOutput sop)
|
void |
PlanSetter.visit(LOSplitOutput op)
|
protected void |
LOVisitor.visit(LOStore store)
|
protected void |
LogicalPlanCloneHelper.visit(LOStore store)
|
void |
PlanSetter.visit(LOStore op)
|
protected void |
LOVisitor.visit(LOStream stream)
|
protected void |
LogicalPlanCloneHelper.visit(LOStream stream)
|
void |
PlanSetter.visit(LOStream op)
|
void |
LOVisitor.visit(LOSubtract op)
|
void |
LogicalPlanCloneHelper.visit(LOSubtract op)
|
void |
PlanSetter.visit(LOSubtract op)
|
protected void |
LOVisitor.visit(LOUnion u)
|
protected void |
LogicalPlanCloneHelper.visit(LOUnion u)
|
void |
PlanSetter.visit(LOUnion op)
|
protected void |
LOVisitor.visit(LOUserFunc func)
Iterate over each expression that is part of the function argument list |
protected void |
LogicalPlanCloneHelper.visit(LOUserFunc func)
|
void |
PlanSetter.visit(LOUserFunc op)
|
void |
BinaryExpressionOperator.visit(LOVisitor v)
|
void |
LOAdd.visit(LOVisitor v)
|
void |
LOAnd.visit(LOVisitor v)
|
void |
LOBinCond.visit(LOVisitor v)
|
void |
LOCast.visit(LOVisitor v)
|
void |
LOCogroup.visit(LOVisitor v)
|
void |
LOConst.visit(LOVisitor v)
|
void |
LOCross.visit(LOVisitor v)
|
void |
LODistinct.visit(LOVisitor v)
|
void |
LODivide.visit(LOVisitor v)
|
void |
LOEqual.visit(LOVisitor v)
|
void |
LOFRJoin.visit(LOVisitor v)
|
void |
LOFilter.visit(LOVisitor v)
|
void |
LOForEach.visit(LOVisitor v)
|
void |
LOGenerate.visit(LOVisitor v)
|
void |
LOGreaterThan.visit(LOVisitor v)
|
void |
LOGreaterThanEqual.visit(LOVisitor v)
|
void |
LOIsNull.visit(LOVisitor v)
|
void |
LOLesserThan.visit(LOVisitor v)
|
void |
LOLesserThanEqual.visit(LOVisitor v)
|
void |
LOLimit.visit(LOVisitor v)
|
void |
LOLoad.visit(LOVisitor v)
|
void |
LOMapLookup.visit(LOVisitor v)
|
void |
LOMod.visit(LOVisitor v)
|
void |
LOMultiply.visit(LOVisitor v)
|
void |
LONegative.visit(LOVisitor v)
|
void |
LONot.visit(LOVisitor v)
|
void |
LONotEqual.visit(LOVisitor v)
|
void |
LOOr.visit(LOVisitor v)
|
void |
LOProject.visit(LOVisitor v)
|
void |
LORegexp.visit(LOVisitor v)
|
void |
LOSort.visit(LOVisitor v)
|
void |
LOSplit.visit(LOVisitor v)
|
void |
LOSplitOutput.visit(LOVisitor v)
|
void |
LOStore.visit(LOVisitor v)
|
void |
LOStream.visit(LOVisitor v)
|
void |
LOSubtract.visit(LOVisitor v)
|
void |
LOUnion.visit(LOVisitor v)
|
void |
LOUserFunc.visit(LOVisitor v)
|
abstract void |
LogicalOperator.visit(LOVisitor v)
Visit this node with the provided visitor. |
void |
UnaryExpressionOperator.visit(LOVisitor v)
|
protected void |
LOVisitor.visit(UnaryExpressionOperator uniOp)
|
protected void |
LogicalPlanCloneHelper.visit(UnaryExpressionOperator uniOp)
|
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.rebuildSchemas()
Rebuild schemas after a rule has transformed the tree. |
protected void |
LogicalTransformer.removeFromChain(LogicalOperator nodeToRemove,
Map<Integer,Integer> projectionMapping)
Remove a node in the middle of a linear chain. |
protected void |
SchemaCalculator.visit(BinaryExpressionOperator binOp)
|
protected void |
SchemaRemover.visit(BinaryExpressionOperator binOp)
|
protected void |
SchemaCalculator.visit(LOBinCond binCond)
|
protected void |
SchemaRemover.visit(LOBinCond binCond)
|
protected void |
SchemaCalculator.visit(LOCast cast)
|
protected void |
SchemaRemover.visit(LOCast cast)
|
protected void |
SchemaCalculator.visit(LOCogroup cg)
|
protected void |
SchemaRemover.visit(LOCogroup cg)
|
protected void |
SchemaCalculator.visit(LOConst c)
|
protected void |
SchemaRemover.visit(LOConst c)
|
protected void |
SchemaCalculator.visit(LOCross cs)
|
protected void |
SchemaRemover.visit(LOCross cs)
|
protected void |
SchemaCalculator.visit(LODistinct dt)
|
protected void |
SchemaRemover.visit(LODistinct dt)
|
protected void |
SchemaCalculator.visit(LOFilter filter)
|
protected void |
SchemaRemover.visit(LOFilter filter)
|
protected void |
SchemaCalculator.visit(LOForEach forEach)
|
protected void |
SchemaRemover.visit(LOForEach forEach)
|
protected void |
SchemaRemover.visit(LOFRJoin frj)
|
protected void |
SchemaCalculator.visit(LOLimit limit)
|
protected void |
SchemaRemover.visit(LOLimit limit)
|
protected void |
SchemaCalculator.visit(LOLoad load)
|
protected void |
SchemaRemover.visit(LOLoad load)
|
protected void |
SchemaCalculator.visit(LOProject project)
|
protected void |
SchemaRemover.visit(LOProject project)
|
protected void |
SchemaCalculator.visit(LORegexp regexp)
|
protected void |
SchemaRemover.visit(LORegexp regexp)
|
protected void |
SchemaCalculator.visit(LOSort s)
|
protected void |
SchemaRemover.visit(LOSort s)
|
protected void |
SchemaCalculator.visit(LOSplit split)
|
protected void |
SchemaRemover.visit(LOSplit split)
|
protected void |
SchemaCalculator.visit(LOSplitOutput sop)
|
protected void |
SchemaRemover.visit(LOSplitOutput sop)
|
protected void |
SchemaCalculator.visit(LOStore store)
|
protected void |
SchemaRemover.visit(LOStore store)
|
protected void |
SchemaCalculator.visit(LOUnion u)
|
protected void |
SchemaRemover.visit(LOUnion u)
|
protected void |
SchemaCalculator.visit(LOUserFunc func)
Iterate over each expression that is part of the function argument list |
protected void |
SchemaRemover.visit(LOUserFunc func)
Iterate over each expression that is part of the function argument list |
protected void |
SchemaCalculator.visit(UnaryExpressionOperator uniOp)
|
protected void |
SchemaRemover.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(LOFRJoin frj)
Mimics the type checking of LOCogroup |
protected void |
TypeCheckingVisitor.visit(LogicalOperator lOp)
|
void |
TypeCheckingVisitor.visit(LOGreaterThan binOp)
|
void |
TypeCheckingVisitor.visit(LOGreaterThanEqual binOp)
|
void |
TypeCheckingVisitor.visit(LOIsNull uniOp)
|
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 void |
DependencyOrderWalker.doAllPredecessors(O node,
Set<O> seen,
Collection<O> fifo)
|
protected void |
PlanVisitor.popWalker()
Pop the next to previous walker off of the stack and set it as the current walker. |
void |
PlanVisitor.visit()
Entry point for visiting the plan. |
abstract void |
Operator.visit(V v)
Visit this node with the provided visitor. |
void |
DependencyOrderWalker.walk(PlanVisitor<O,P> visitor)
Begin traversing the graph. |
void |
DependencyOrderWalkerWOSeenChk.walk(PlanVisitor<O,P> visitor)
Begin traversing the graph. |
void |
DepthFirstWalker.walk(PlanVisitor<O,P> visitor)
Begin traversing the graph. |
abstract void |
PlanWalker.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
|
Uses of VisitorException in org.apache.pig.pen |
---|
Methods in org.apache.pig.pen that throw VisitorException | |
---|---|
protected void |
AugmentBaseDataVisitor.visit(LOCogroup cg)
|
protected void |
DerivedDataVisitor.visit(LOCogroup cg)
|
protected void |
LineageTrimmingVisitor.visit(LOCogroup cg)
|
protected void |
AugmentBaseDataVisitor.visit(LOCross cs)
|
protected void |
DerivedDataVisitor.visit(LOCross cs)
|
protected void |
LineageTrimmingVisitor.visit(LOCross cs)
|
protected void |
AugmentBaseDataVisitor.visit(LODistinct dt)
|
protected void |
DerivedDataVisitor.visit(LODistinct dt)
|
protected void |
LineageTrimmingVisitor.visit(LODistinct dt)
|
protected void |
AugmentBaseDataVisitor.visit(LOFilter filter)
|
protected void |
DerivedDataVisitor.visit(LOFilter filter)
|
protected void |
LineageTrimmingVisitor.visit(LOFilter filter)
|
protected void |
AugmentBaseDataVisitor.visit(LOForEach forEach)
|
protected void |
DerivedDataVisitor.visit(LOForEach forEach)
|
protected void |
LineageTrimmingVisitor.visit(LOForEach forEach)
|
protected void |
DerivedDataVisitor.visit(LOLimit l)
|
protected void |
LineageTrimmingVisitor.visit(LOLimit limOp)
|
protected void |
AugmentBaseDataVisitor.visit(LOLoad load)
|
protected void |
DerivedDataVisitor.visit(LOLoad load)
|
protected void |
LineageTrimmingVisitor.visit(LOLoad load)
|
protected void |
AugmentBaseDataVisitor.visit(LOSort s)
|
protected void |
DerivedDataVisitor.visit(LOSort sort)
|
protected void |
LineageTrimmingVisitor.visit(LOSort s)
|
protected void |
AugmentBaseDataVisitor.visit(LOSplit split)
|
protected void |
DerivedDataVisitor.visit(LOSplit split)
|
protected void |
LineageTrimmingVisitor.visit(LOSplit split)
|
protected void |
AugmentBaseDataVisitor.visit(LOStore store)
|
protected void |
DerivedDataVisitor.visit(LOStore store)
|
protected void |
AugmentBaseDataVisitor.visit(LOUnion u)
|
protected void |
DerivedDataVisitor.visit(LOUnion u)
|
protected void |
LineageTrimmingVisitor.visit(LOUnion u)
|
Uses of VisitorException in org.apache.pig.pen.util |
---|
Methods in org.apache.pig.pen.util that throw VisitorException | |
---|---|
void |
DependencyOrderLimitedWalker.walk(PlanVisitor<O,P> visitor)
|
void |
PreOrderDepthFirstWalker.walk(PlanVisitor<O,P> visitor)
Begin traversing the graph. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |