Uses of Class
org.apache.pig.backend.hadoop.executionengine.physicalLayer.Result

Packages that use Result
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.relationalOperators   
org.apache.pig.backend.local.executionengine.physicalLayer.counters   
org.apache.pig.backend.local.executionengine.physicalLayer.relationalOperators   
 

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

Fields in org.apache.pig.backend.hadoop.executionengine.physicalLayer declared as Result
protected  Result PhysicalOperator.res
           
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer that return Result
 Result PhysicalOperator.getNext(Boolean b)
           
 Result PhysicalOperator.getNext(DataBag db)
           
 Result PhysicalOperator.getNext(DataByteArray ba)
           
 Result PhysicalOperator.getNext(Double d)
           
 Result PhysicalOperator.getNext(Float f)
           
 Result PhysicalOperator.getNext(Integer i)
           
 Result PhysicalOperator.getNext(Long l)
           
 Result PhysicalOperator.getNext(Map m)
           
 Result PhysicalOperator.getNext(String s)
           
 Result PhysicalOperator.getNext(Tuple t)
           
 Result PhysicalOperator.processInput()
          A generic method for parsing input that either returns the attached input if it exists or fetches it from its predecessor.
 

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

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators that return Result
protected  Result POProject.consumeInputBag(Result input)
           
 Result POProject.getNext()
          Fetches the input tuple and returns the requested column
 Result ComparisonOperator.getNext(Boolean b)
           
 Result ConstantExpression.getNext(Boolean b)
           
 Result EqualToExpr.getNext(Boolean bool)
           
 Result GTOrEqualToExpr.getNext(Boolean bool)
           
 Result GreaterThanExpr.getNext(Boolean bool)
           
 Result LTOrEqualToExpr.getNext(Boolean bool)
           
 Result LessThanExpr.getNext(Boolean bool)
           
 Result NotEqualToExpr.getNext(Boolean bool)
           
 Result POAnd.getNext(Boolean b)
           
 Result POBinCond.getNext(Boolean b)
           
 Result POIsNull.getNext(Boolean b)
           
 Result POMapLookUp.getNext(Boolean b)
           
 Result PONot.getNext(Boolean b)
           
 Result POOr.getNext(Boolean b)
           
 Result POProject.getNext(Boolean b)
           
 Result PORegexp.getNext(Boolean bool)
           
 Result POUserComparisonFunc.getNext(Boolean b)
           
 Result POUserFunc.getNext(Boolean b)
           
 Result ComparisonOperator.getNext(DataBag db)
           
 Result ConstantExpression.getNext(DataBag db)
           
 Result ExpressionOperator.getNext(DataBag db)
           
 Result POBinCond.getNext(DataBag db)
           
 Result POCast.getNext(DataBag bag)
           
 Result POMapLookUp.getNext(DataBag db)
           
 Result POProject.getNext(DataBag db)
           
 Result PORelationToExprProject.getNext(DataBag db)
           
 Result POUserComparisonFunc.getNext(DataBag db)
           
 Result POUserFunc.getNext(DataBag db)
           
 Result ComparisonOperator.getNext(DataByteArray ba)
           
 Result ConstantExpression.getNext(DataByteArray ba)
           
 Result POBinCond.getNext(DataByteArray ba)
           
 Result POMapLookUp.getNext(DataByteArray ba)
           
 Result POProject.getNext(DataByteArray ba)
           
 Result POUserComparisonFunc.getNext(DataByteArray ba)
           
 Result POUserFunc.getNext(DataByteArray ba)
           
 Result Add.getNext(Double d)
           
 Result ComparisonOperator.getNext(Double d)
           
 Result ConstantExpression.getNext(Double d)
           
 Result Divide.getNext(Double d)
           
 Result Multiply.getNext(Double d)
           
 Result POBinCond.getNext(Double d)
           
 Result POCast.getNext(Double d)
           
 Result POMapLookUp.getNext(Double d)
           
 Result PONegative.getNext(Double d)
           
 Result POProject.getNext(Double d)
           
 Result POUserComparisonFunc.getNext(Double d)
           
 Result POUserFunc.getNext(Double d)
           
 Result Subtract.getNext(Double d)
           
 Result Add.getNext(Float f)
           
 Result ComparisonOperator.getNext(Float f)
           
 Result ConstantExpression.getNext(Float f)
           
 Result Divide.getNext(Float f)
           
 Result Multiply.getNext(Float f)
           
 Result POBinCond.getNext(Float f)
           
 Result POCast.getNext(Float f)
           
 Result POMapLookUp.getNext(Float f)
           
 Result PONegative.getNext(Float f)
           
 Result POProject.getNext(Float f)
           
 Result POUserComparisonFunc.getNext(Float f)
           
 Result POUserFunc.getNext(Float f)
           
 Result Subtract.getNext(Float f)
           
 Result Add.getNext(Integer i)
           
 Result ComparisonOperator.getNext(Integer i)
           
 Result ConstantExpression.getNext(Integer i)
           
 Result Divide.getNext(Integer i)
           
 Result Mod.getNext(Integer i)
           
 Result Multiply.getNext(Integer i)
           
 Result POBinCond.getNext(Integer i)
           
 Result POCast.getNext(Integer i)
           
 Result POMapLookUp.getNext(Integer i)
           
 Result PONegative.getNext(Integer i)
           
 Result POProject.getNext(Integer i)
           
 Result POUserComparisonFunc.getNext(Integer i)
           
 Result POUserFunc.getNext(Integer i)
           
 Result Subtract.getNext(Integer i)
           
 Result Add.getNext(Long l)
           
 Result ComparisonOperator.getNext(Long l)
           
 Result ConstantExpression.getNext(Long l)
           
 Result Divide.getNext(Long l)
           
 Result Mod.getNext(Long i)
           
 Result Multiply.getNext(Long l)
           
 Result POBinCond.getNext(Long l)
           
 Result POCast.getNext(Long l)
           
 Result POMapLookUp.getNext(Long l)
           
 Result PONegative.getNext(Long l)
           
 Result POProject.getNext(Long l)
           
 Result POUserComparisonFunc.getNext(Long l)
           
 Result POUserFunc.getNext(Long l)
           
 Result Subtract.getNext(Long l)
           
 Result ComparisonOperator.getNext(Map m)
           
 Result ConstantExpression.getNext(Map m)
           
 Result POBinCond.getNext(Map m)
           
 Result POCast.getNext(Map m)
           
 Result POMapLookUp.getNext(Map m)
           
 Result POProject.getNext(Map m)
           
 Result POUserComparisonFunc.getNext(Map m)
           
 Result POUserFunc.getNext(Map m)
           
 Result ComparisonOperator.getNext(String s)
           
 Result ConstantExpression.getNext(String s)
           
 Result POBinCond.getNext(String s)
           
 Result POCast.getNext(String str)
           
 Result POMapLookUp.getNext(String s)
           
 Result POProject.getNext(String s)
           
 Result POUserComparisonFunc.getNext(String s)
           
 Result POUserFunc.getNext(String s)
           
 Result ComparisonOperator.getNext(Tuple t)
           
 Result ConstantExpression.getNext(Tuple t)
           
 Result POBinCond.getNext(Tuple t)
           
 Result POCast.getNext(Tuple t)
           
 Result POMapLookUp.getNext(Tuple t)
           
 Result POProject.getNext(Tuple t)
          Asked for Tuples.
 Result POUserComparisonFunc.getNext(Tuple in)
           
 Result POUserFunc.getNext(Tuple tIn)
           
 Result POMapLookUp.processInput()
           
 Result POUserFunc.processInput()
           
protected  Result POProject.processInputBag()
           
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.expressionOperators with parameters of type Result
protected  Result POProject.consumeInputBag(Result input)
           
 

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

Fields in org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators with type parameters of type Result
protected  BlockingQueue<Result> POStream.binaryInputQueue
           
protected  BlockingQueue<Result> POStream.binaryOutputQueue
           
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators that return Result
 Result POCombinerPackage.getNext(Tuple t)
           
 Result PODemux.getNext(Tuple t)
           
 Result PODistinct.getNext(Tuple t)
           
 Result POFRJoin.getNext(Tuple t)
           
 Result POFilter.getNext(Tuple t)
          Attaches the proccesed input tuple to the expression plan and checks if comparison operator returns a true.
 Result POForEach.getNext(Tuple t)
          Calls getNext on the generate operator inside the nested physical plan and returns it maintaining an additional state to denote the begin and end of the nested plan processing.
 Result POGlobalRearrange.getNext(Tuple t)
           
 Result POJoinPackage.getNext(Tuple t)
          Calls getNext to get next ForEach result.
 Result POLimit.getNext(Tuple t)
          Counts the number of tuples processed into static variable soFar, if the number of tuples processed reach the limit, return EOP; Otherwise, return the tuple
 Result POLoad.getNext(Tuple t)
          The main method used by this operator's successor to read tuples from the specified file using the specified load function.
 Result POLocalRearrange.getNext(Tuple t)
          Calls getNext on the generate operator inside the nested physical plan.
 Result POMergeJoin.getNext(Tuple t)
           
 Result POMultiQueryPackage.getNext(Tuple t)
          Constructs the output tuple from the inputs.
 Result POOptimizedForEach.getNext(Tuple t)
          Calls getNext on the generate operator inside the nested physical plan and returns it maintaining an additional state to denote the begin and end of the nested plan processing.
 Result POPackage.getNext(Tuple t)
          From the inputs, constructs the output tuple for this co-group in the required format which is (key, {bag of tuples from input 1}, {bag of tuples from input 2}, ...)
 Result POPackageLite.getNext(Tuple t)
          Similar to POPackage.getNext except that only one input is expected with index 0 and ReadOnceBag is used instead of DefaultDataBag.
 Result POPartitionRearrange.getNext(Tuple t)
          Calls getNext on the generate operator inside the nested physical plan.
 Result POPreCombinerLocalRearrange.getNext(Tuple t)
          Calls getNext on the generate operator inside the nested physical plan.
 Result PORead.getNext(Tuple t)
           
 Result POSort.getNext(Tuple t)
           
 Result POSplit.getNext(Tuple t)
           
 Result POStore.getNext(Tuple t)
           
 Result POStream.getNext(Tuple t)
           
 Result POUnion.getNext(Tuple t)
          The code below, tries to follow our single threaded shared execution model with execution being passed around each non-drained input
 Result POStream.getNextHelper(Tuple t)
           
protected  Result POForEach.processPlan()
           
 

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators that return types with arguments of type Result
 BlockingQueue<Result> POStream.getBinaryInputQueue()
           
 BlockingQueue<Result> POStream.getBinaryOutputQueue()
           
 

Method parameters in org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators with type arguments of type Result
protected  Tuple POLocalRearrange.constructLROutput(List<Result> resLst, Tuple value)
           
protected  Tuple POLocalRearrangeForIllustrate.constructLROutput(List<Result> resLst, Tuple value)
           
protected  Tuple POPreCombinerLocalRearrange.constructLROutput(List<Result> resLst, Tuple value)
           
protected  DataBag POPartitionRearrange.constructPROutput(List<Result> resLst, Tuple value)
           
 

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

Methods in org.apache.pig.backend.local.executionengine.physicalLayer.counters that return Result
 Result POCounter.getNext(Tuple t)
           
 

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

Methods in org.apache.pig.backend.local.executionengine.physicalLayer.relationalOperators that return Result
 Result POCogroup.getNext(Tuple t)
           
 Result POCross.getNext(Tuple t)
           
 Result POSplit.getNext(Tuple t)
           
 Result POSplitOutput.getNext(Tuple t)
           
 Result POStreamLocal.getNext(Tuple t)
          This is different from the Map-Reduce implementation of the POStream since there is no push model here.
 



Copyright © ${year} The Apache Software Foundation