|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use LogicalOperator | |
---|---|
org.apache.pig | Public interfaces and classes for Pig. |
org.apache.pig.backend.hadoop.executionengine.physicalLayer | Implementation of physical operators that use hadoop as the execution engine and data storage. |
org.apache.pig.experimental.logical | |
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.schema | |
org.apache.pig.impl.logicalLayer.validators | |
org.apache.pig.pen | |
org.apache.pig.pen.util |
Uses of LogicalOperator in org.apache.pig |
---|
Methods in org.apache.pig that return types with arguments of type LogicalOperator | |
---|---|
Map<LogicalOperator,DataBag> |
PigServer.getExamples(String alias)
|
Uses of LogicalOperator in org.apache.pig.backend.hadoop.executionengine.physicalLayer |
---|
Fields in org.apache.pig.backend.hadoop.executionengine.physicalLayer with type parameters of type LogicalOperator | |
---|---|
protected Map<LogicalOperator,PhysicalOperator> |
LogToPhyTranslationVisitor.logToPhyMap
|
Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer with parameters of type LogicalOperator | |
---|---|
static void |
LogToPhyTranslationVisitor.updateWithEmptyBagCheck(PhysicalPlan fePlan,
LogicalOperator joinInput)
updates plan with check for empty bag and if bag is empty to flatten a bag with as many null's as dictated by the schema |
Uses of LogicalOperator in org.apache.pig.experimental.logical |
---|
Fields in org.apache.pig.experimental.logical with type parameters of type LogicalOperator | |
---|---|
protected HashMap<LogicalOperator,LogicalExpression> |
LogicalPlanMigrationVistor.LogicalExpPlanMigrationVistor.exprOpsMap
|
Uses of LogicalOperator in org.apache.pig.impl.logicalLayer |
---|
Subclasses of LogicalOperator in org.apache.pig.impl.logicalLayer | |
---|---|
class |
BinaryExpressionOperator
This abstract class represents the logical Binary Expression Operator The binary operator has two operands and an operator. |
class |
ExpressionOperator
|
class |
LOAdd
|
class |
LOAnd
|
class |
LOBinCond
|
class |
LOCast
|
class |
LOCogroup
|
class |
LOConst
|
class |
LOCross
|
class |
LODefine
|
class |
LODistinct
|
class |
LODivide
|
class |
LOEqual
|
class |
LOFilter
|
class |
LOForEach
|
class |
LOGenerate
|
class |
LOGreaterThan
|
class |
LOGreaterThanEqual
|
class |
LOIsNull
|
class |
LOJoin
|
class |
LOLesserThan
|
class |
LOLesserThanEqual
|
class |
LOLimit
|
class |
LOLoad
|
class |
LOMapLookup
|
class |
LOMod
|
class |
LOMultiply
|
class |
LONegative
|
class |
LONot
|
class |
LONotEqual
|
class |
LOOr
|
class |
LOProject
LOProject is designed like a singly linked list; A few examples will illustrate the point about the linked list nature of the design; a = load 'input1' as (name, age); b = group a by name; foreach b generate a, a.name; The project operator occurs in two places in the above script: generate a(here) and a.name(here) In the first occurrence, we are trying to project the elements of the bag a; In order to retrieve the bag, we need to project the the second column ($1) or column number 1 (using the zero based index) from the input (the relation or bag b) In the second occurence, we are trying to project the first column ($0) or column number 0 from the bag a which in turn is the column number 1 in the relation b; As you can see, the nested structure or the singly linked list nature is clearly visible; Given that it's a singly linked list, the null pointer or the sentinel is marked explictly using the boolean variable mSentinel; The sentinel is marked true only when the input is a relational operator; This occurs when we create the innermost operator |
class |
LORegexp
|
class |
LOSort
|
class |
LOSplit
|
class |
LOSplitOutput
|
class |
LOStore
|
class |
LOStream
LOStream represents the specification of an external
command to be executed in a Pig Query. |
class |
LOSubtract
|
class |
LOUnion
|
class |
LOUserFunc
|
class |
RelationalOperator
|
class |
UnaryExpressionOperator
This abstract class represents the logical Unary Expression Operator The unary operator has an operand and an operator. |
Fields in org.apache.pig.impl.logicalLayer with type parameters of type LogicalOperator | |
---|---|
static Map<LogicalOperator,LogicalOperator> |
LogicalPlanCloneHelper.mOpToCloneMap
|
static Map<LogicalOperator,LogicalOperator> |
LogicalPlanCloneHelper.mOpToCloneMap
|
Methods in org.apache.pig.impl.logicalLayer that return LogicalOperator | |
---|---|
LogicalOperator |
LOProject.getExpression()
|
LogicalOperator |
LOSort.getInput()
|
LogicalOperator |
LOLimit.getInput()
|
LogicalOperator |
LOFilter.getInput()
|
LogicalOperator |
LODistinct.getInput()
|
LogicalOperator |
LogicalPlan.getSingleLeafPlanOutputOp()
|
LogicalOperator |
RelationalOperator.insertPlainForEachAfter(List<Integer> columnsToProject)
|
Methods in org.apache.pig.impl.logicalLayer that return types with arguments of type LogicalOperator | |
---|---|
MultiMap<LogicalOperator,LogicalPlan> |
LOCogroup.getGroupByPlans()
|
List<LogicalOperator> |
LOUnion.getInputs()
|
List<LogicalOperator> |
LOJoin.getInputs()
|
List<LogicalOperator> |
LOCross.getInputs()
|
List<LogicalOperator> |
LOCogroup.getInputs()
|
MultiMap<LogicalOperator,LogicalPlan> |
LOJoin.getJoinPlans()
|
protected MultiMap<LogicalOperator,LogicalPlan> |
DotLOPrinter.getMultiInputNestedPlans(LogicalOperator op)
|
List<LogicalOperator> |
LOSplit.getOutputs()
|
Methods in org.apache.pig.impl.logicalLayer with parameters of type LogicalOperator | |
---|---|
void |
LOSplit.addOutput(LogicalOperator lOp)
|
void |
ColumnPruner.addPruneMap(LogicalOperator op,
List<Pair<Integer,Integer>> prunedColumns)
|
protected String[] |
DotLOPrinter.getAttributes(LogicalOperator op)
|
protected MultiMap<LogicalOperator,LogicalPlan> |
DotLOPrinter.getMultiInputNestedPlans(LogicalOperator op)
|
protected String |
DotLOPrinter.getName(LogicalOperator op)
|
protected Collection<LogicalPlan> |
DotLOPrinter.getNestedPlans(LogicalOperator op)
|
void |
LOProject.setExpression(LogicalOperator exp)
|
void |
LOCogroup.switchGroupByPlanOp(LogicalOperator oldOp,
LogicalOperator newOp)
This does switch the mapping oldOp -> List of inner plans to newOp -> List of inner plans which is useful when there is a structural change in LogicalPlan |
void |
LOJoin.switchJoinColPlanOp(LogicalOperator oldOp,
LogicalOperator newOp)
This does switch the mapping oldOp -> List of inner plans to newOp -> List of inner plans which is useful when there is a structural change in LogicalPlan |
protected void |
LogicalPlanCloneHelper.visit(LogicalOperator op)
|
protected void |
LOVisitor.visit(LogicalOperator lOp)
|
Constructors in org.apache.pig.impl.logicalLayer with parameters of type LogicalOperator | |
---|---|
LOProject(LogicalPlan plan,
OperatorKey key,
LogicalOperator exp,
Integer projection)
|
|
LOProject(LogicalPlan plan,
OperatorKey key,
LogicalOperator exp,
List<Integer> projection)
|
|
LOStream(LogicalPlan plan,
OperatorKey k,
LogicalOperator input,
ExecutableManager exeManager,
StreamingCommand cmd)
Create a new LOStream with the given command. |
|
ProjectFixerUpper(LogicalPlan plan,
LogicalOperator oldNode,
int oldNodeIndex,
LogicalOperator newNode,
boolean useOldNode,
LogicalOperator containingNode)
|
|
ProjectFixerUpper(LogicalPlan plan,
LogicalOperator oldNode,
LogicalOperator newNode,
Map<Integer,Integer> projectionMapping)
|
Constructor parameters in org.apache.pig.impl.logicalLayer with type arguments of type LogicalOperator | |
---|---|
LOCogroup(LogicalPlan plan,
OperatorKey k,
MultiMap<LogicalOperator,LogicalPlan> groupByPlans,
boolean[] isInner)
|
|
LOCogroup(LogicalPlan plan,
OperatorKey k,
MultiMap<LogicalOperator,LogicalPlan> groupByPlans,
LOCogroup.GROUPTYPE type,
boolean[] isInner)
|
|
LogicalPlanCloneHelper(LogicalPlan plan,
Map<LogicalOperator,LogicalOperator> origCloneMap)
|
|
LogicalPlanCloneHelper(LogicalPlan plan,
Map<LogicalOperator,LogicalOperator> origCloneMap)
|
|
LOJoin(LogicalPlan plan,
OperatorKey k,
MultiMap<LogicalOperator,LogicalPlan> joinPlans,
LOJoin.JOINTYPE jt,
boolean[] isInner)
|
|
LOSplit(LogicalPlan plan,
OperatorKey key,
ArrayList<LogicalOperator> outputs)
|
|
LOVisitor(LogicalPlan plan,
PlanWalker<LogicalOperator,LogicalPlan> walker)
|
Uses of LogicalOperator in org.apache.pig.impl.logicalLayer.optimizer |
---|
Methods in org.apache.pig.impl.logicalLayer.optimizer with parameters of type LogicalOperator | |
---|---|
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. |
void |
PruneColumns.processNode(LogicalOperator lo,
org.apache.pig.impl.logicalLayer.optimizer.RequiredInfo requiredOutputInfo)
|
Method parameters in org.apache.pig.impl.logicalLayer.optimizer with type arguments of type LogicalOperator | |
---|---|
boolean |
TypeCastInserter.check(List<LogicalOperator> nodes)
|
boolean |
PushUpFilter.check(List<LogicalOperator> nodes)
|
boolean |
PushDownForeachFlatten.check(List<LogicalOperator> nodes)
|
boolean |
PruneColumns.check(List<LogicalOperator> nodes)
|
boolean |
PartitionFilterOptimizer.check(List<LogicalOperator> nodes)
|
boolean |
OpLimitOptimizer.check(List<LogicalOperator> nodes)
|
boolean |
ImplicitSplitInserter.check(List<LogicalOperator> nodes)
|
void |
TypeCastInserter.transform(List<LogicalOperator> nodes)
|
void |
PushUpFilter.transform(List<LogicalOperator> nodes)
|
void |
PushDownForeachFlatten.transform(List<LogicalOperator> nodes)
|
void |
PruneColumns.transform(List<LogicalOperator> nodes)
|
void |
PartitionFilterOptimizer.transform(List<LogicalOperator> nodes)
|
void |
OpLimitOptimizer.transform(List<LogicalOperator> nodes)
|
void |
ImplicitSplitInserter.transform(List<LogicalOperator> nodes)
|
Uses of LogicalOperator in org.apache.pig.impl.logicalLayer.schema |
---|
Methods in org.apache.pig.impl.logicalLayer.schema that return types with arguments of type LogicalOperator | |
---|---|
Map<String,LogicalOperator> |
Schema.FieldSchema.getCanonicalMap()
|
MultiMap<LogicalOperator,String> |
Schema.FieldSchema.getReverseCanonicalMap()
|
Methods in org.apache.pig.impl.logicalLayer.schema with parameters of type LogicalOperator | |
---|---|
void |
Schema.FieldSchema.setParent(String parentCanonicalName,
LogicalOperator parent)
|
Uses of LogicalOperator in org.apache.pig.impl.logicalLayer.validators |
---|
Methods in org.apache.pig.impl.logicalLayer.validators with parameters of type LogicalOperator | |
---|---|
protected void |
SchemaAliasVisitor.validate(LogicalOperator lo)
The logic here is to check if we have duplicate alias in each schema |
protected void |
TypeCheckingVisitor.visit(LogicalOperator lOp)
|
Uses of LogicalOperator in org.apache.pig.pen |
---|
Methods in org.apache.pig.pen that return types with arguments of type LogicalOperator | |
---|---|
Map<LogicalOperator,DataBag> |
ExampleGenerator.getExamples()
|
Map<LogicalOperator,PhysicalOperator> |
LocalLogToPhyTranslationVisitor.getLogToPhyMap()
|
Methods in org.apache.pig.pen with parameters of type LogicalOperator | |
---|---|
static Collection<IdentityHashSet<Tuple>> |
EquivalenceClasses.getEquivalenceClasses(LogicalOperator op,
Map<LogicalOperator,DataBag> derivedData)
|
void |
DerivedDataVisitor.setOperatorToEvaluate(LogicalOperator op)
|
Method parameters in org.apache.pig.pen with type arguments of type LogicalOperator | |
---|---|
static Collection<IdentityHashSet<Tuple>> |
EquivalenceClasses.getEquivalenceClasses(LogicalOperator op,
Map<LogicalOperator,DataBag> derivedData)
|
Constructors in org.apache.pig.pen with parameters of type LogicalOperator | |
---|---|
DerivedDataVisitor(LogicalOperator op,
PigContext pc,
Map<LOLoad,DataBag> baseData,
Map<LogicalOperator,PhysicalOperator> logToPhyMap,
PhysicalPlan physPlan)
|
Constructor parameters in org.apache.pig.pen with type arguments of type LogicalOperator | |
---|---|
AugmentBaseDataVisitor(LogicalPlan plan,
Map<LOLoad,DataBag> baseData,
Map<LogicalOperator,DataBag> derivedData)
|
|
DerivedDataVisitor(LogicalOperator op,
PigContext pc,
Map<LOLoad,DataBag> baseData,
Map<LogicalOperator,PhysicalOperator> logToPhyMap,
PhysicalPlan physPlan)
|
|
DerivedDataVisitor(LogicalPlan plan,
PigContext pc,
Map<LOLoad,DataBag> baseData,
Map<LogicalOperator,PhysicalOperator> logToPhyMap,
PhysicalPlan physPlan)
|
|
LineageTrimmingVisitor(LogicalPlan plan,
Map<LOLoad,DataBag> baseData,
Map<LogicalOperator,PhysicalOperator> LogToPhyMap,
PhysicalPlan physPlan,
PigContext pc)
|
Uses of LogicalOperator in org.apache.pig.pen.util |
---|
Methods in org.apache.pig.pen.util with parameters of type LogicalOperator | |
---|---|
static float |
MetricEvaluation.getCompleteness(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData,
Map<LogicalOperator,Collection<IdentityHashSet<Tuple>>> OperatorToEqClasses,
boolean overallCompleteness)
|
static float |
MetricEvaluation.getConciseness(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData,
Map<LogicalOperator,Collection<IdentityHashSet<Tuple>>> OperatorToEqClasses,
boolean overallConciseness)
|
static float |
MetricEvaluation.getRealness(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData,
boolean overallRealness)
|
static void |
DisplayExamples.printSimple(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData)
|
Method parameters in org.apache.pig.pen.util with type arguments of type LogicalOperator | |
---|---|
static float |
MetricEvaluation.getCompleteness(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData,
Map<LogicalOperator,Collection<IdentityHashSet<Tuple>>> OperatorToEqClasses,
boolean overallCompleteness)
|
static float |
MetricEvaluation.getCompleteness(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData,
Map<LogicalOperator,Collection<IdentityHashSet<Tuple>>> OperatorToEqClasses,
boolean overallCompleteness)
|
static float |
MetricEvaluation.getConciseness(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData,
Map<LogicalOperator,Collection<IdentityHashSet<Tuple>>> OperatorToEqClasses,
boolean overallConciseness)
|
static float |
MetricEvaluation.getConciseness(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData,
Map<LogicalOperator,Collection<IdentityHashSet<Tuple>>> OperatorToEqClasses,
boolean overallConciseness)
|
static float |
MetricEvaluation.getRealness(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData,
boolean overallRealness)
|
static void |
DisplayExamples.printSimple(LogicalOperator op,
Map<LogicalOperator,DataBag> exampleData)
|
static String |
DisplayExamples.printTabular(LogicalPlan lp,
Map<LogicalOperator,DataBag> exampleData)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |