Uses of Class
org.apache.pig.impl.logicalLayer.FrontendException

Packages that use FrontendException

org.apache.hadoop.zebra.pig	Implementation of PIG Storer/Loader Interfaces
org.apache.pig	Public interfaces and classes for Pig.
org.apache.pig.backend.hadoop.executionengine
org.apache.pig.backend.hadoop.executionengine.mapReduceLayer
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.plans
org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators
org.apache.pig.backend.hadoop.hbase
org.apache.pig.builtin	This package contains builtin Pig UDFs.
org.apache.pig.data	This package contains implementations of Pig specific data types as well as support functions for reading, writing, and using all Pig data types.
org.apache.pig.impl.logicalLayer.schema
org.apache.pig.impl.logicalLayer.validators
org.apache.pig.impl.plan
org.apache.pig.impl.plan.optimizer
org.apache.pig.newplan
org.apache.pig.newplan.logical
org.apache.pig.newplan.logical.expression
org.apache.pig.newplan.logical.optimizer
org.apache.pig.newplan.logical.relational
org.apache.pig.newplan.logical.rules
org.apache.pig.newplan.logical.visitor
org.apache.pig.newplan.optimizer
org.apache.pig.parser
org.apache.pig.pen
org.apache.pig.pen.util
org.apache.pig.piggybank.evaluation.datetime
org.apache.pig.piggybank.evaluation.datetime.convert
org.apache.pig.piggybank.evaluation.datetime.diff
org.apache.pig.piggybank.evaluation.datetime.truncate
org.apache.pig.piggybank.evaluation.math
org.apache.pig.piggybank.evaluation.string
org.apache.pig.piggybank.evaluation.util
org.apache.pig.piggybank.evaluation.util.apachelogparser
org.apache.pig.piggybank.storage
org.apache.pig.tools
org.apache.pig.tools.pigstats

Uses of FrontendException in org.apache.hadoop.zebra.pig

Methods in org.apache.hadoop.zebra.pig that throw FrontendException

LoadPushDown.RequiredFieldResponse

TableLoader.pushProjection(LoadPushDown.RequiredFieldList requiredFieldList)

Uses of FrontendException in org.apache.pig

Methods in org.apache.pig that throw FrontendException

void	PigServer.discardBatch() Discards a batch of Pig commands.
static String	LoadFunc.getAbsolutePath(String location, org.apache.hadoop.fs.Path curDir) Construct the absolute path from the file location and the current directory.
List<FuncSpec>	EvalFunc.getArgToFuncMapping() Allow a UDF to specify type specific implementations of itself.
boolean	PigServer.isBatchEmpty() Returns whether there is anything to process in the current batch.
protected PigStats	PigServer.launchPlan(PhysicalPlan pp, String jobName) A common method for launching the jobs according to the physical plan
void	PigServer.printAliases() Intended to be used by unit tests only.
LoadPushDown.RequiredFieldResponse	LoadPushDown.pushProjection(LoadPushDown.RequiredFieldList requiredFieldList) Indicate to the loader fields that will be needed.
static void	ResourceSchema.ResourceFieldSchema.throwInvalidSchemaException()

Uses of FrontendException in org.apache.pig.backend.hadoop.executionengine

Methods in org.apache.pig.backend.hadoop.executionengine that throw FrontendException

PhysicalPlan

HExecutionEngine.compile(LogicalPlan plan, Properties properties)

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

Subclasses of FrontendException in org.apache.pig.backend.hadoop.executionengine.mapReduceLayer

class	JobCreationException
class	MRCompilerException

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

Subclasses of FrontendException in org.apache.pig.backend.hadoop.executionengine.physicalLayer

class

LogicalToPhysicalTranslatorException

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

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.plans that throw FrontendException

void	PatternNode.accept(PlanVisitor v)
boolean	PatternNode.isEqual(Operator operator)

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

Methods in org.apache.pig.backend.hadoop.executionengine.physicalLayer.relationalOperators that throw FrontendException

void	POMergeJoin.setupRightPipeline(PhysicalPlan rightPipeline)

Uses of FrontendException in org.apache.pig.backend.hadoop.hbase

Methods in org.apache.pig.backend.hadoop.hbase that throw FrontendException

LoadPushDown.RequiredFieldResponse

HBaseStorage.pushProjection(LoadPushDown.RequiredFieldList requiredFieldList)

Uses of FrontendException in org.apache.pig.builtin

Methods in org.apache.pig.builtin that throw FrontendException

List<FuncSpec>	UPPER.getArgToFuncMapping()
List<FuncSpec>	TRIM.getArgToFuncMapping()
List<FuncSpec>	TOP.getArgToFuncMapping()
List<FuncSpec>	TOKENIZE.getArgToFuncMapping()
List<FuncSpec>	SUM.getArgToFuncMapping()
List<FuncSpec>	SUBSTRING.getArgToFuncMapping()
List<FuncSpec>	SIZE.getArgToFuncMapping()
List<FuncSpec>	ROUND.getArgToFuncMapping()
List<FuncSpec>	REPLACE.getArgToFuncMapping()
List<FuncSpec>	REGEX_EXTRACT_ALL.getArgToFuncMapping()
List<FuncSpec>	REGEX_EXTRACT.getArgToFuncMapping()
List<FuncSpec>	MIN.getArgToFuncMapping()
List<FuncSpec>	MAX.getArgToFuncMapping()
List<FuncSpec>	LOWER.getArgToFuncMapping()
List<FuncSpec>	LAST_INDEX_OF.getArgToFuncMapping()
List<FuncSpec>	DoubleBase.getArgToFuncMapping()
List<FuncSpec>	COUNT.getArgToFuncMapping()
List<FuncSpec>	CONCAT.getArgToFuncMapping()
List<FuncSpec>	AVG.getArgToFuncMapping()
List<FuncSpec>	ABS.getArgToFuncMapping()
LoadPushDown.RequiredFieldResponse	PigStorage.pushProjection(LoadPushDown.RequiredFieldList requiredFieldList)

Constructors in org.apache.pig.builtin that throw FrontendException

GenericInvoker(String fullName)

GenericInvoker(String fullName, String paramSpecsStr)

GenericInvoker(String fullName, String paramSpecsStr, String isStatic)

InvokeForDouble(String fullName)

InvokeForDouble(String fullName, String paramSpecsStr)

InvokeForDouble(String fullName, String paramSpecsStr, String isStatic)

InvokeForFloat(String fullName)

InvokeForFloat(String fullName, String paramSpecsStr)

InvokeForFloat(String fullName, String paramSpecsStr, String isStatic)

InvokeForInt(String fullName)

InvokeForInt(String fullName, String paramSpecsStr)

InvokeForInt(String fullName, String paramSpecsStr, String isStatic)

InvokeForLong(String fullName)

InvokeForLong(String fullName, String paramSpecsStr)

InvokeForLong(String fullName, String paramSpecsStr, String isStatic)

InvokeForString(String fullName)

InvokeForString(String fullName, String paramSpecsStr)

InvokeForString(String fullName, String paramSpecsStr, String isStatic)

Invoker(String fullName, String paramSpecsStr)

Invoker(String fullName, String paramSpecsStr, String isStatic)

Uses of FrontendException in org.apache.pig.data

Methods in org.apache.pig.data that throw FrontendException

static Schema.FieldSchema	DataType.determineFieldSchema(Object o) Determine the field schema of an object
static Schema.FieldSchema	DataType.determineFieldSchema(ResourceSchema.ResourceFieldSchema rcFieldSchema) Determine the field schema of an ResourceFieldSchema

Uses of FrontendException in org.apache.pig.impl.logicalLayer.schema

Subclasses of FrontendException in org.apache.pig.impl.logicalLayer.schema

class

SchemaMergeException

Methods in org.apache.pig.impl.logicalLayer.schema that throw FrontendException

static Schema	Schema.generateNestedSchema(byte topLevelType, byte... innerTypes)
Schema.FieldSchema	Schema.getField(int fieldNum) Given a field number, find the associated FieldSchema.
Schema.FieldSchema	Schema.getField(String alias) Given an alias name, find the associated FieldSchema.
Schema.FieldSchema	Schema.getFieldSubNameMatch(String alias) Given an alias name, find the associated FieldSchema.
static Schema	Schema.getPigSchema(ResourceSchema rSchema)
int	Schema.getPosition(String alias) Given an alias, find the associated position of the field schema.
int	Schema.getPositionSubName(String alias) Given an alias, find the associated position of the field schema.
static Schema	SchemaUtil.newBagSchema(Byte[] dataTypes) Create a new tuple schema according one array: the type of fields, the tuple name is t, and the bag name is b.
static Schema	SchemaUtil.newBagSchema(List<Byte> dataTypes) Create a new tuple schema according one list: types of fields, the default names of fields are f0,f1,f2..., and the tuple is t, the bag name is b.
static Schema	SchemaUtil.newBagSchema(List<String> names, List<Byte> dataTypes) Create a bag schema according two list: name of fields, type of fields, and the default bag name is b, the default tuple name is t.
static Schema	SchemaUtil.newBagSchema(String[] names, Byte[] dataTypes) Create a new tuple schema according two arrays: names of field,types of fields.
static Schema	SchemaUtil.newBagSchema(String bagName, String tupleName, List<String> fieldNames, List<Byte> dataTypes) Create a bag schema according the bag name,tuple name and two list: name of fields, type of fields
static Schema	SchemaUtil.newBagSchema(String bagName, String tupleName, String[] fieldNames, Byte[] dataTypes)
static Schema	SchemaUtil.newTupleSchema(Byte[] dataTypes) Create a new tuple schema according one array: types of fields, the default names of fields are f0,f1,f2..., and the tuple name is t.
static Schema	SchemaUtil.newTupleSchema(List<Byte> dataTypes) Create a new tuple schema according one list: types of fields, the default names of fields are f0,f1,f2..., and the tuple name is t.
static Schema	SchemaUtil.newTupleSchema(List<String> fieldNames, List<Byte> dataTypes) Create a new tuple schema according the two list: names of fields, types of fields, the default tuple name is t.
static Schema	SchemaUtil.newTupleSchema(String[] names, Byte[] dataTypes) Create a new tuple schema according the two arrays: names of fields, types of fields, the default tuple name is t.
static Schema	SchemaUtil.newTupleSchema(String tupleName, List<String> fieldNames, List<Byte> dataTypes) Create a new tuple schema according the tuple name and two list: names of fields, types of fields
static Schema	SchemaUtil.newTupleSchema(String tupleName, String[] fieldNames, Byte[] dataTypes) Create a new tuple schema according the tuple name and two arrays: names of fields, types of fields
void	Schema.reconcile(Schema other) Reconcile this schema with another schema.
static void	Schema.stringifySchema(StringBuilder sb, Schema schema, byte type)

Constructors in org.apache.pig.impl.logicalLayer.schema that throw FrontendException

Schema.FieldSchema(String a, Schema s, byte t)
Constructor for tuple fields.

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

Subclasses of FrontendException in org.apache.pig.impl.logicalLayer.validators

class

TypeCheckerException

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

Subclasses of FrontendException in org.apache.pig.impl.plan

class	PlanException
class	PlanValidationException
class	VisitorException

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

Subclasses of FrontendException in org.apache.pig.impl.plan.optimizer

class

OptimizerException

Uses of FrontendException in org.apache.pig.newplan

Methods in org.apache.pig.newplan that throw FrontendException

abstract void	Operator.accept(PlanVisitor v) Accept a visitor at this node in the graph.
Pair<Integer,Integer>	OperatorSubPlan.disconnect(Operator from, Operator to)
Pair<Integer,Integer>	OperatorPlan.disconnect(Operator from, Operator to) Disconnect two operators in the plan.
Pair<Integer,Integer>	BaseOperatorPlan.disconnect(Operator from, Operator to) Disconnect two operators in the plan.
protected void	DependencyOrderWalker.doAllPredecessors(Operator node, Set<Operator> seen, Collection<Operator> fifo)
protected void	ReverseDependencyOrderWalkerWOSeenChk.doAllSuccessors(Operator node, Collection<Operator> fifo)
protected void	ReverseDependencyOrderWalker.doAllSuccessors(Operator node, Set<Operator> seen, Collection<Operator> fifo)
void	BaseOperatorPlan.explain(PrintStream ps, String format, boolean verbose)
Expression	PColFilterExtractor.getExpression(LogicalExpression op)
void	OperatorSubPlan.insertBetween(Operator pred, Operator operatorToInsert, Operator succ)
void	OperatorPlan.insertBetween(Operator pred, Operator operatorToInsert, Operator succ) This method insert node operatorToInsert between pred and succ.
void	BaseOperatorPlan.insertBetween(Operator pred, Operator operatorToInsert, Operator succ)
abstract boolean	Operator.isEqual(Operator operator) This is like a shallow equals comparison.
boolean	OperatorSubPlan.isEqual(OperatorPlan other)
boolean	OperatorPlan.isEqual(OperatorPlan other) This is like a shallow comparison.
boolean	BaseOperatorPlan.isEqual(OperatorPlan other)
protected static boolean	BaseOperatorPlan.isEqual(OperatorPlan p1, OperatorPlan p2)
protected void	PlanVisitor.popWalker() Pop the next to previous walker off of the stack and set it as the current walker.
void	OperatorSubPlan.remove(Operator op)
void	OperatorPlan.remove(Operator op) Remove an operator from the plan.
void	BaseOperatorPlan.remove(Operator op) Remove an operator from the plan.
void	OperatorSubPlan.removeAndReconnect(Operator operatorToRemove)
void	OperatorPlan.removeAndReconnect(Operator operatorToRemove) This method remove a node operatorToRemove.
void	BaseOperatorPlan.removeAndReconnect(Operator operatorToRemove)
void	OperatorSubPlan.replace(Operator oldOperator, Operator newOperator)
void	OperatorPlan.replace(Operator oldOperator, Operator newOperator) This method replace the oldOperator with the newOperator, make all connection to the new operator in the place of old operator
void	BaseOperatorPlan.replace(Operator oldOperator, Operator newOperator)
void	PlanVisitor.visit() Entry point for visiting the plan.
void	PColFilterExtractor.visit()
protected void	PColFilterExtractor.visit(ProjectExpression project)
void	SubtreeDependencyOrderWalker.walk(PlanVisitor visitor)
void	ReverseDependencyOrderWalkerWOSeenChk.walk(PlanVisitor visitor) Begin traversing the graph.
void	ReverseDependencyOrderWalker.walk(PlanVisitor visitor) Begin traversing the graph.
abstract void	PlanWalker.walk(PlanVisitor visitor) Begin traversing the graph.
void	DepthFirstWalker.walk(PlanVisitor visitor) Begin traversing the graph.
void	DependencyOrderWalker.walk(PlanVisitor visitor) Begin traversing the graph.

Uses of FrontendException in org.apache.pig.newplan.logical

Methods in org.apache.pig.newplan.logical that throw FrontendException

static LOForEach	Util.addForEachAfter(LogicalPlan plan, LogicalRelationalOperator op, int branch, Set<Integer> columnsToDrop)
static Schema	Util.fixSchemaAddTupleInBag(Schema sch) If schema argument has fields where a bag does not contain a tuple schema, it inserts a tuple schema.

Uses of FrontendException in org.apache.pig.newplan.logical.expression

Methods in org.apache.pig.newplan.logical.expression that throw FrontendException

void	UserFuncExpression.accept(PlanVisitor v)
void	SubtractExpression.accept(PlanVisitor v)
void	ScalarExpression.accept(PlanVisitor v)
void	RegexExpression.accept(PlanVisitor v)
void	ProjectExpression.accept(PlanVisitor v)
void	OrExpression.accept(PlanVisitor v)
void	NotExpression.accept(PlanVisitor v)
void	NotEqualExpression.accept(PlanVisitor v)
void	NegativeExpression.accept(PlanVisitor v)
void	MultiplyExpression.accept(PlanVisitor v)
void	ModExpression.accept(PlanVisitor v)
void	MapLookupExpression.accept(PlanVisitor v)
void	LessThanExpression.accept(PlanVisitor v)
void	LessThanEqualExpression.accept(PlanVisitor v)
void	IsNullExpression.accept(PlanVisitor v)
void	GreaterThanExpression.accept(PlanVisitor v)
void	GreaterThanEqualExpression.accept(PlanVisitor v)
void	EqualExpression.accept(PlanVisitor v)
void	DivideExpression.accept(PlanVisitor v)
void	DereferenceExpression.accept(PlanVisitor v)
void	ConstantExpression.accept(PlanVisitor v)
void	CastExpression.accept(PlanVisitor v)
void	BinCondExpression.accept(PlanVisitor v)
void	AndExpression.accept(PlanVisitor v)
void	AddExpression.accept(PlanVisitor v)
LogicalExpressionPlan	LogicalExpressionPlan.deepCopy()
LogicalExpression	UserFuncExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	SubtractExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	ScalarExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	RegexExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	ProjectExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	OrExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	NotExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	NotEqualExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	NegativeExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	MultiplyExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	ModExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	MapLookupExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
abstract LogicalExpression	LogicalExpression.deepCopy(LogicalExpressionPlan lgExpPlan) Create the deep copy of this expression and add that into the passed LogicalExpressionPlan Return the copy of this expression with updated logical expression plan.
LogicalExpression	LessThanExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	LessThanEqualExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	IsNullExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	GreaterThanExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	GreaterThanEqualExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	EqualExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	DivideExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	DereferenceExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	ConstantExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	CastExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	BinCondExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	AndExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
LogicalExpression	AddExpression.deepCopy(LogicalExpressionPlan lgExpPlan)
protected abstract void	AllSameExpressionVisitor.execute(LogicalExpression op) Method to call on every node in the logical expression plan.
void	LogicalExpressionPlan.explain(PrintStream ps, String format, boolean verbose)
LogicalRelationalOperator	ProjectExpression.findReferent() Find the LogicalRelationalOperator that this projection refers to.
List<LogicalExpression>	UserFuncExpression.getArguments()
LogicalExpression	BinCondExpression.getCondition() Returns the operator which handles this condition
LogicalExpression	UnaryExpression.getExpression() Get the expression that this unary expression operators on.
LogicalSchema.LogicalFieldSchema	UserFuncExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	SubtractExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	ScalarExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	RegexExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	ProjectExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	OrExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	NotExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	NotEqualExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	NegativeExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	MultiplyExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	ModExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	MapLookupExpression.getFieldSchema()
abstract LogicalSchema.LogicalFieldSchema	LogicalExpression.getFieldSchema() Get the field schema for the output of this expression operator.
LogicalSchema.LogicalFieldSchema	LessThanExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	LessThanEqualExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	IsNullExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	GreaterThanExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	GreaterThanEqualExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	EqualExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	DivideExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	DereferenceExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	ConstantExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	CastExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	BinCondExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	AndExpression.getFieldSchema()
LogicalSchema.LogicalFieldSchema	AddExpression.getFieldSchema()
LogicalExpression	BinCondExpression.getLhs() Get the left hand side of this expression.
LogicalExpression	BinaryExpression.getLhs() Get the left hand side of this binary expression.
LogicalExpression	MapLookupExpression.getMap()
LogicalExpression	DereferenceExpression.getReferredExpression()
LogicalExpression	BinCondExpression.getRhs() Get the right hand side of this expression.
LogicalExpression	BinaryExpression.getRhs() Get the right hand side of this binary expression.
byte	ProjectExpression.getType()
byte	LogicalExpression.getType() Get the data type for this expression.
boolean	UserFuncExpression.isDeterministic()
boolean	UserFuncExpression.isEqual(Operator other)
boolean	SubtractExpression.isEqual(Operator other)
boolean	RegexExpression.isEqual(Operator other)
boolean	ProjectExpression.isEqual(Operator other)
boolean	OrExpression.isEqual(Operator other)
boolean	NotExpression.isEqual(Operator other)
boolean	NotEqualExpression.isEqual(Operator other)
boolean	NegativeExpression.isEqual(Operator other)
boolean	MultiplyExpression.isEqual(Operator other)
boolean	ModExpression.isEqual(Operator other)
boolean	MapLookupExpression.isEqual(Operator other)
boolean	LessThanExpression.isEqual(Operator other)
boolean	LessThanEqualExpression.isEqual(Operator other)
boolean	IsNullExpression.isEqual(Operator other)
boolean	GreaterThanExpression.isEqual(Operator other)
boolean	GreaterThanEqualExpression.isEqual(Operator other)
boolean	EqualExpression.isEqual(Operator other)
boolean	DivideExpression.isEqual(Operator other)
boolean	DereferenceExpression.isEqual(Operator other)
boolean	ConstantExpression.isEqual(Operator other)
boolean	CastExpression.isEqual(Operator other)
boolean	BinCondExpression.isEqual(Operator other)
boolean	AndExpression.isEqual(Operator other)
boolean	AddExpression.isEqual(Operator other)
boolean	LogicalExpressionPlan.isEqual(OperatorPlan other)
void	LogicalExpression.neverUseForRealSetFieldSchema(LogicalSchema.LogicalFieldSchema fs)
void	ProjectExpression.setColumnNumberFromAlias() If there is an alias, finds the column number from it.
void	ProjectExpression.setEndAlias(String endAlias)
void	ProjectExpression.setStartAlias(String startAlias)
void	LogicalExpressionVisitor.visit(AddExpression op)
void	ExpToPhyTranslationVisitor.visit(AddExpression op)
void	AllSameExpressionVisitor.visit(AddExpression op)
void	LogicalExpressionVisitor.visit(AndExpression op)
void	ExpToPhyTranslationVisitor.visit(AndExpression op)
void	AllSameExpressionVisitor.visit(AndExpression andExpr)
void	LogicalExpressionVisitor.visit(BinCondExpression op)
void	ExpToPhyTranslationVisitor.visit(BinCondExpression op)
void	AllSameExpressionVisitor.visit(BinCondExpression op)
void	LogicalExpressionVisitor.visit(CastExpression op)
void	ExpToPhyTranslationVisitor.visit(CastExpression op)
void	AllSameExpressionVisitor.visit(CastExpression cast)
void	LogicalExpressionVisitor.visit(ConstantExpression op)
void	ExpToPhyTranslationVisitor.visit(ConstantExpression op)
void	AllSameExpressionVisitor.visit(ConstantExpression constant)
void	LogicalExpressionVisitor.visit(DereferenceExpression op)
void	ExpToPhyTranslationVisitor.visit(DereferenceExpression op)
void	AllSameExpressionVisitor.visit(DereferenceExpression derefenceExpression)
void	LogicalExpressionVisitor.visit(DivideExpression op)
void	ExpToPhyTranslationVisitor.visit(DivideExpression op)
void	AllSameExpressionVisitor.visit(DivideExpression op)
void	LogicalExpressionVisitor.visit(EqualExpression op)
void	ExpToPhyTranslationVisitor.visit(EqualExpression op)
void	AllSameExpressionVisitor.visit(EqualExpression equal)
void	LogicalExpressionVisitor.visit(GreaterThanEqualExpression op)
void	ExpToPhyTranslationVisitor.visit(GreaterThanEqualExpression op)
void	AllSameExpressionVisitor.visit(GreaterThanEqualExpression op)
void	LogicalExpressionVisitor.visit(GreaterThanExpression op)
void	ExpToPhyTranslationVisitor.visit(GreaterThanExpression op)
void	AllSameExpressionVisitor.visit(GreaterThanExpression greaterThanExpression)
void	LogicalExpressionVisitor.visit(IsNullExpression op)
void	ExpToPhyTranslationVisitor.visit(IsNullExpression op)
void	AllSameExpressionVisitor.visit(IsNullExpression op)
void	LogicalExpressionVisitor.visit(LessThanEqualExpression op)
void	ExpToPhyTranslationVisitor.visit(LessThanEqualExpression op)
void	AllSameExpressionVisitor.visit(LessThanEqualExpression op)
void	LogicalExpressionVisitor.visit(LessThanExpression op)
void	ExpToPhyTranslationVisitor.visit(LessThanExpression op)
void	AllSameExpressionVisitor.visit(LessThanExpression lessThanExpression)
void	LogicalExpressionVisitor.visit(MapLookupExpression op)
void	ExpToPhyTranslationVisitor.visit(MapLookupExpression op)
void	AllSameExpressionVisitor.visit(MapLookupExpression op)
void	LogicalExpressionVisitor.visit(ModExpression op)
void	ExpToPhyTranslationVisitor.visit(ModExpression op)
void	AllSameExpressionVisitor.visit(ModExpression op)
void	LogicalExpressionVisitor.visit(MultiplyExpression op)
void	ExpToPhyTranslationVisitor.visit(MultiplyExpression op)
void	AllSameExpressionVisitor.visit(MultiplyExpression op)
void	LogicalExpressionVisitor.visit(NegativeExpression op)
void	ExpToPhyTranslationVisitor.visit(NegativeExpression op)
void	AllSameExpressionVisitor.visit(NegativeExpression op)
void	LogicalExpressionVisitor.visit(NotEqualExpression op)
void	ExpToPhyTranslationVisitor.visit(NotEqualExpression op)
void	AllSameExpressionVisitor.visit(NotEqualExpression op)
void	LogicalExpressionVisitor.visit(NotExpression op)
void	ExpToPhyTranslationVisitor.visit(NotExpression op)
void	AllSameExpressionVisitor.visit(NotExpression op)
void	LogicalExpressionVisitor.visit(OrExpression op)
void	ExpToPhyTranslationVisitor.visit(OrExpression op)
void	AllSameExpressionVisitor.visit(OrExpression exp)
void	LogicalExpressionVisitor.visit(ProjectExpression op)
void	ExpToPhyTranslationVisitor.visit(ProjectExpression op)
void	AllSameExpressionVisitor.visit(ProjectExpression project)
void	LogicalExpressionVisitor.visit(RegexExpression op)
void	ExpToPhyTranslationVisitor.visit(RegexExpression op)
void	AllSameExpressionVisitor.visit(RegexExpression op)
void	LogicalExpressionVisitor.visit(ScalarExpression op)
void	LogicalExpressionVisitor.visit(SubtractExpression op)
void	ExpToPhyTranslationVisitor.visit(SubtractExpression op)
void	AllSameExpressionVisitor.visit(SubtractExpression op)
void	LogicalExpressionVisitor.visit(UserFuncExpression op)
void	ExpToPhyTranslationVisitor.visit(UserFuncExpression op)
void	AllSameExpressionVisitor.visit(UserFuncExpression op)

Constructors in org.apache.pig.newplan.logical.expression that throw FrontendException

AllSameExpressionVisitor(OperatorPlan plan, PlanWalker walker)

ExpToPhyTranslationVisitor(OperatorPlan plan, LogicalRelationalOperator op, PhysicalPlan phyPlan, Map<Operator,PhysicalOperator> map)

ExpToPhyTranslationVisitor(OperatorPlan plan, PlanWalker walker, LogicalRelationalOperator op, PhysicalPlan phyPlan, Map<Operator,PhysicalOperator> map)

LogicalExpressionVisitor(OperatorPlan p, PlanWalker walker)

Uses of FrontendException in org.apache.pig.newplan.logical.optimizer

Methods in org.apache.pig.newplan.logical.optimizer that throw FrontendException

protected String	LogicalPlanPrinter.depthFirstLP()
protected abstract void	AllSameRalationalNodesVisitor.execute(LogicalRelationalOperator op) Method to call on every node in the logical plan.
protected LogicalExpressionVisitor	ProjectionPatcher.ProjectionFinder.getVisitor(LogicalExpressionPlan expr)
protected abstract LogicalExpressionVisitor	AllExpressionVisitor.getVisitor(LogicalExpressionPlan expr) Get a new instance of the expression visitor to apply to a given expression.
protected String	LogicalPlanPrinter.reverseDepthFirstLP()
void	SchemaPatcher.transformed(OperatorPlan fp, OperatorPlan tp)
void	ProjectionPatcher.transformed(OperatorPlan fp, OperatorPlan tp)
void	LogicalPlanPrinter.visit()
void	UidResetter.visit(LOCogroup loCogroup)
void	SchemaResetter.visit(LOCogroup loCogroup)
void	AllSameRalationalNodesVisitor.visit(LOCogroup cg)
void	AllExpressionVisitor.visit(LOCogroup cg)
void	UidResetter.visit(LOCross loCross)
void	SchemaResetter.visit(LOCross loCross)
void	AllSameRalationalNodesVisitor.visit(LOCross cross)
void	UidResetter.visit(LODistinct loDistinct)
void	SchemaResetter.visit(LODistinct loDistinct)
void	AllSameRalationalNodesVisitor.visit(LODistinct distinct)
void	UidResetter.visit(LOFilter filter)
void	SchemaResetter.visit(LOFilter filter)
void	AllSameRalationalNodesVisitor.visit(LOFilter filter)
void	AllExpressionVisitor.visit(LOFilter filter)
void	UidResetter.visit(LOForEach foreach)
void	SchemaResetter.visit(LOForEach foreach)
void	DanglingNestedNodeRemover.visit(LOForEach foreach)
void	AllSameRalationalNodesVisitor.visit(LOForEach foreach)
void	AllExpressionVisitor.visit(LOForEach foreach)
void	UidResetter.visit(LOGenerate gen)
void	SchemaResetter.visit(LOGenerate gen)
void	AllExpressionVisitor.visit(LOGenerate gen)
void	UidResetter.visit(LOInnerLoad load)
void	SchemaResetter.visit(LOInnerLoad load)
void	AllExpressionVisitor.visit(LOInnerLoad load)
void	UidResetter.visit(LOJoin join)
void	SchemaResetter.visit(LOJoin join)
void	AllSameRalationalNodesVisitor.visit(LOJoin join)
void	AllExpressionVisitor.visit(LOJoin join)
void	UidResetter.visit(LOLimit loLimit)
void	SchemaResetter.visit(LOLimit loLimit)
void	UidResetter.visit(LOLoad load)
void	SchemaResetter.visit(LOLoad load)
void	AllSameRalationalNodesVisitor.visit(LOLoad load)
void	UidResetter.visit(LOSort loSort)
void	SchemaResetter.visit(LOSort loSort)
void	AllSameRalationalNodesVisitor.visit(LOSort sort)
void	AllExpressionVisitor.visit(LOSort sort)
void	UidResetter.visit(LOSplit loSplit)
void	SchemaResetter.visit(LOSplit loSplit)
void	AllSameRalationalNodesVisitor.visit(LOSplit split)
void	UidResetter.visit(LOSplitOutput loSplitOutput)
void	SchemaResetter.visit(LOSplitOutput loSplitOutput)
void	AllSameRalationalNodesVisitor.visit(LOSplitOutput splitOutput)
void	AllExpressionVisitor.visit(LOSplitOutput splitOutput)
void	UidResetter.visit(LOStore store)
void	SchemaResetter.visit(LOStore store)
void	AllSameRalationalNodesVisitor.visit(LOStore store)
void	UidResetter.visit(LOStream loStream)
void	SchemaResetter.visit(LOStream loStream)
void	AllSameRalationalNodesVisitor.visit(LOStream stream)
void	UidResetter.visit(LOUnion loUnion)
void	SchemaResetter.visit(LOUnion loUnion)
void	AllSameRalationalNodesVisitor.visit(LOUnion union)

Constructors in org.apache.pig.newplan.logical.optimizer that throw FrontendException

AllExpressionVisitor(OperatorPlan plan, PlanWalker walker)

AllSameRalationalNodesVisitor(OperatorPlan plan, PlanWalker walker)

DanglingNestedNodeRemover(OperatorPlan plan)

LogicalPlanPrinter(OperatorPlan plan, PrintStream ps)

ProjectionPatcher.ProjectionFinder(OperatorPlan plan)

SchemaResetter(OperatorPlan plan)

UidResetter(OperatorPlan plan)

Uses of FrontendException in org.apache.pig.newplan.logical.relational

Methods in org.apache.pig.newplan.logical.relational that throw FrontendException

void	LOUnion.accept(PlanVisitor v)
void	LOStream.accept(PlanVisitor v)
void	LOStore.accept(PlanVisitor v)
void	LOSplitOutput.accept(PlanVisitor v)
void	LOSplit.accept(PlanVisitor v)
void	LOSort.accept(PlanVisitor v)
void	LONative.accept(PlanVisitor v)
void	LOLoad.accept(PlanVisitor v)
void	LOLimit.accept(PlanVisitor v)
void	LOJoin.accept(PlanVisitor v)
void	LOInnerLoad.accept(PlanVisitor v)
void	LOGenerate.accept(PlanVisitor v)
void	LOForEach.accept(PlanVisitor v)
void	LOFilter.accept(PlanVisitor v)
void	LODistinct.accept(PlanVisitor v)
void	LOCross.accept(PlanVisitor v)
void	LOCogroup.accept(PlanVisitor v)
protected boolean	LogicalRelationalOperator.checkEquality(LogicalRelationalOperator other) Do some basic equality checks on two relational operators.
LogicalSchema	LOForEach.dumpNestedSchema(String alias, String nestedAlias)
void	LogicalPlan.explain(PrintStream ps, String format, boolean verbose)
static List<LOInnerLoad>	LOForEach.findReacheableInnerLoadFromBoundaryProject(ProjectExpression project)
LogicalSchema.LogicalFieldSchema	LogicalSchema.getField(String alias) Fetch a field by alias
LogicalSchema.LogicalFieldSchema	LogicalSchema.getFieldSubNameMatch(String alias) Given an alias name, find the associated LogicalFieldSchema.
LoadFunc	LOLoad.getLoadFunc()
LogicalSchema	LOUnion.getSchema()
LogicalSchema	LOStream.getSchema()
LogicalSchema	LOStore.getSchema()
LogicalSchema	LOSplitOutput.getSchema()
LogicalSchema	LOSplit.getSchema()
LogicalSchema	LOSort.getSchema()
LogicalSchema	LONative.getSchema()
LogicalSchema	LOLoad.getSchema() Get the schema for this load.
LogicalSchema	LOLimit.getSchema()
LogicalSchema	LOJoin.getSchema()
LogicalSchema	LOInnerLoad.getSchema()
abstract LogicalSchema	LogicalRelationalOperator.getSchema() Get the schema for the output of this relational operator.
LogicalSchema	LOGenerate.getSchema()
LogicalSchema	LOForEach.getSchema()
LogicalSchema	LOFilter.getSchema()
LogicalSchema	LODistinct.getSchema()
LogicalSchema	LOCross.getSchema()
LogicalSchema	LOCogroup.getSchema()
SortInfo	LOSort.getSortInfo()
boolean	LOUnion.isEqual(Operator other)
boolean	LOStream.isEqual(Operator other)
boolean	LOStore.isEqual(Operator other)
boolean	LOSplitOutput.isEqual(Operator other)
boolean	LOSplit.isEqual(Operator other)
boolean	LOSort.isEqual(Operator other)
boolean	LONative.isEqual(Operator obj)
boolean	LOLoad.isEqual(Operator other)
boolean	LOLimit.isEqual(Operator other)
boolean	LOJoin.isEqual(Operator other)
boolean	LOInnerLoad.isEqual(Operator other)
boolean	LOGenerate.isEqual(Operator other)
boolean	LOForEach.isEqual(Operator other)
boolean	LOFilter.isEqual(Operator other)
boolean	LODistinct.isEqual(Operator other)
boolean	LOCross.isEqual(Operator other)
boolean	LOCogroup.isEqual(Operator other)
boolean	LogicalPlan.isEqual(OperatorPlan other) Equality is checked by calling equals on every leaf in the plan.
static LogicalSchema.LogicalFieldSchema	LogicalSchema.LogicalFieldSchema.merge(LogicalSchema.LogicalFieldSchema fs1, LogicalSchema.LogicalFieldSchema fs2, LogicalSchema.MergeMode mode) Merge two LogicalFieldSchema, the behavior of merge depends on mode.
static LogicalSchema	LogicalSchema.merge(LogicalSchema s1, LogicalSchema s2, LogicalSchema.MergeMode mode) Merge two schemas.
static LogicalSchema	LogicalSchema.mergeSchemaByAlias(LogicalSchema schema1, LogicalSchema schema2) Merges two schemas using their column aliases (unlike mergeSchema(..) functions which merge using positions) Schema will not be merged if types are incompatible, as per DataType.mergeType(..) For Tuples and Bags, SubSchemas have to be equal be considered compatible
static LogicalSchema	LogicalSchema.mergeSchemasByAlias(List<LogicalSchema> schemas) Merges collection of schemas using their column aliases (unlike mergeSchema(..) functions which merge using positions) Schema will not be merged if types are incompatible, as per DataType.mergeType(..) For Tuples and Bags, SubSchemas have to be equal be considered compatible
LogicalSchema.LogicalFieldSchema	LogicalSchema.LogicalFieldSchema.mergeUid(LogicalSchema.LogicalFieldSchema uidOnlyFieldSchema) Adds the uid from FieldSchema argument to this FieldSchema If the argument is null, it stamps this FieldSchema with uid
LogicalSchema	LogicalSchema.mergeUid(LogicalSchema uidOnlySchema)
static void	LogToPhyTranslationVisitor.updateWithEmptyBagCheck(PhysicalPlan fePlan, Operator 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
void	LogToPhyTranslationVisitor.visit(LOCogroup cg)
void	LogicalRelationalNodesVisitor.visit(LOCogroup loCogroup)
void	LogToPhyTranslationVisitor.visit(LOCross cross)
void	LogicalRelationalNodesVisitor.visit(LOCross loCross)
void	LogToPhyTranslationVisitor.visit(LODistinct loDistinct)
void	LogicalRelationalNodesVisitor.visit(LODistinct loDistinct)
void	LogToPhyTranslationVisitor.visit(LOFilter filter)
void	LogicalRelationalNodesVisitor.visit(LOFilter filter)
void	LogToPhyTranslationVisitor.visit(LOForEach foreach)
void	LogicalRelationalNodesVisitor.visit(LOForEach foreach)
void	LogicalRelationalNodesVisitor.visit(LOGenerate gen)
void	LogToPhyTranslationVisitor.visit(LOInnerLoad load)
void	LogicalRelationalNodesVisitor.visit(LOInnerLoad load)
void	LogToPhyTranslationVisitor.visit(LOJoin loj)
void	LogicalRelationalNodesVisitor.visit(LOJoin join)
void	LogToPhyTranslationVisitor.visit(LOLimit loLimit)
void	LogicalRelationalNodesVisitor.visit(LOLimit loLimit)
void	LogToPhyTranslationVisitor.visit(LOLoad loLoad)
void	LogicalRelationalNodesVisitor.visit(LOLoad load)
void	LogToPhyTranslationVisitor.visit(LONative loNative)
void	LogicalRelationalNodesVisitor.visit(LONative nativeMR)
void	LogToPhyTranslationVisitor.visit(LOSort sort)
void	LogicalRelationalNodesVisitor.visit(LOSort loSort)
void	LogToPhyTranslationVisitor.visit(LOSplit loSplit)
void	LogicalRelationalNodesVisitor.visit(LOSplit loSplit)
void	LogToPhyTranslationVisitor.visit(LOSplitOutput loSplitOutput)
void	LogicalRelationalNodesVisitor.visit(LOSplitOutput loSplitOutput)
void	LogToPhyTranslationVisitor.visit(LOStore loStore)
void	LogicalRelationalNodesVisitor.visit(LOStore store)
void	LogToPhyTranslationVisitor.visit(LOStream stream)
void	LogicalRelationalNodesVisitor.visit(LOStream loStream)
void	LogToPhyTranslationVisitor.visit(LOUnion loUnion)
void	LogicalRelationalNodesVisitor.visit(LOUnion loUnion)

Constructors in org.apache.pig.newplan.logical.relational that throw FrontendException

LogicalRelationalNodesVisitor(OperatorPlan plan, PlanWalker walker)

LogToPhyTranslationVisitor(OperatorPlan plan)

LOInnerLoad(OperatorPlan plan, LOForEach foreach, String colAlias)

Uses of FrontendException in org.apache.pig.newplan.logical.rules

Methods in org.apache.pig.newplan.logical.rules that throw FrontendException

boolean	MapKeysPruneHelper.check()
boolean	ColumnPruneHelper.check()
boolean	TypeCastInserter.TypeCastInserterTransformer.check(OperatorPlan matched)
boolean	SplitFilter.SplitFilterTransformer.check(OperatorPlan matched)
boolean	PushUpFilter.PushUpFilterTransformer.check(OperatorPlan matched)
boolean	PartitionFilterOptimizer.PartitionFilterPushDownTransformer.check(OperatorPlan matched)
boolean	MergeForEach.MergeForEachTransformer.check(OperatorPlan matched)
boolean	MergeFilter.MergeFilterTransformer.check(OperatorPlan matched)
boolean	LogicalExpressionSimplifier.LogicalExpressionSimplifierTransformer.check(OperatorPlan matched)
boolean	ImplicitSplitInserter.ImplicitSplitInserterTransformer.check(OperatorPlan matched)
boolean	GroupByConstParallelSetter.GroupAllParallelSetterTransformer.check(OperatorPlan matched)
boolean	FilterAboveForeach.FilterAboveForEachTransformer.check(OperatorPlan matched)
boolean	ColumnMapKeyPrune.ColumnMapKeyPruneTransformer.check(OperatorPlan matched)
boolean	AddForEach.AddForEachTransformer.check(OperatorPlan matched)
protected Set<Integer>	ColumnPruneHelper.getColumns(LogicalSchema schema, Set<Long> uids)
protected LogicalExpressionVisitor	MapKeysPruneHelper.MapMarker.getVisitor(LogicalExpressionPlan expr)
protected LogicalExpressionVisitor	MapKeysPruneHelper.FullMapCollector.getVisitor(LogicalExpressionPlan expr)
List<OperatorPlan>	ImplicitSplitInserter.match(OperatorPlan plan)
static boolean	OptimizerUtils.planHasNonDeterministicUdf(LogicalExpressionPlan filterPlan) Helper method to determine if the logical expression plan for a Filter contains non-deterministic operations and should therefore be treated extra carefully during optimization.
void	TypeCastInserter.TypeCastInserterTransformer.transform(OperatorPlan matched)
void	SplitFilter.SplitFilterTransformer.transform(OperatorPlan matched)
void	PushUpFilter.PushUpFilterTransformer.transform(OperatorPlan matched)
void	PartitionFilterOptimizer.PartitionFilterPushDownTransformer.transform(OperatorPlan matched)
void	MergeForEach.MergeForEachTransformer.transform(OperatorPlan matched)
void	MergeFilter.MergeFilterTransformer.transform(OperatorPlan matched)
void	LogicalExpressionSimplifier.LogicalExpressionSimplifierTransformer.transform(OperatorPlan plan)
void	LimitOptimizer.OptimizeLimitTransformer.transform(OperatorPlan matched)
void	ImplicitSplitInserter.ImplicitSplitInserterTransformer.transform(OperatorPlan matched)
void	GroupByConstParallelSetter.GroupAllParallelSetterTransformer.transform(OperatorPlan plan)
void	FilterAboveForeach.FilterAboveForEachTransformer.transform(OperatorPlan matched)
void	ColumnMapKeyPrune.ColumnMapKeyPruneTransformer.transform(OperatorPlan matched)
void	AddForEach.AddForEachTransformer.transform(OperatorPlan matched)
void	LoadStoreFuncDupSignatureValidator.validate()
void	InputOutputFileValidator.validate()
void	MapKeysPruneHelper.FullMapCollector.visit(LOCogroup cogroup)
void	ColumnPruneVisitor.visit(LOCogroup cg)
void	ColumnPruneVisitor.visit(LOCross cross)
void	MapKeysPruneHelper.MapMarker.visit(LOFilter filter)
void	ColumnPruneVisitor.visit(LOFilter filter)
void	ColumnPruneVisitor.visit(LOForEach foreach)
void	MapKeysPruneHelper.MapMarker.visit(LOGenerate gen)
void	MapKeysPruneHelper.MapMarker.visit(LOJoin join)
void	ColumnPruneVisitor.visit(LOJoin join)
void	MapKeysPruneHelper.MapMarker.visit(LOLoad load)
void	ColumnPruneVisitor.visit(LOLoad load)
void	MapKeysPruneHelper.MapMarker.visit(LOSort sort)
void	ColumnPruneVisitor.visit(LOSort sort)
void	ColumnPruneVisitor.visit(LOSplit split)
void	MapKeysPruneHelper.MapMarker.visit(LOSplitOutput splitOutput)
void	MapKeysPruneHelper.FullMapCollector.visit(LOSplitOutput splitOutput)
void	ColumnPruneVisitor.visit(LOSplitOutput splitOutput)
void	MapKeysPruneHelper.FullMapCollector.visit(LOStore store)
void	ColumnPruneVisitor.visit(LOStore store)
void	MapKeysPruneHelper.FullMapCollector.visit(LOUnion union)
void	ColumnPruneVisitor.visit(LOUnion union)

Constructors in org.apache.pig.newplan.logical.rules that throw FrontendException

ColumnPruneVisitor(OperatorPlan plan, Map<LOLoad,Pair<Map<Integer,Set<String>>,Set<Integer>>> requiredItems, boolean columnPrune)

MapKeysPruneHelper.FullMapCollector(OperatorPlan plan, Set<Long> fullMapUids)

MapKeysPruneHelper.MapMarker(OperatorPlan plan)

Uses of FrontendException in org.apache.pig.newplan.logical.visitor

Methods in org.apache.pig.newplan.logical.visitor that throw FrontendException

protected LogicalExpressionVisitor	ScalarVisitor.getVisitor(LogicalExpressionPlan exprPlan)
protected LogicalExpressionVisitor	ProjStarInUdfExpander.getVisitor(LogicalExpressionPlan exprPlan)
protected LogicalExpressionVisitor	ColumnAliasConversionVisitor.getVisitor(LogicalExpressionPlan exprPlan)
protected LogicalExpressionVisitor	CastLineageSetter.getVisitor(LogicalExpressionPlan exprPlan)
static boolean	TypeCheckingExpVisitor.schemaEqualsForMatching(Schema inputSchema, Schema udfSchema, boolean ignoreByteArrays) Compare two schemas for equality for argument matching purposes.
protected void	SchemaAliasVisitor.validate(LogicalRelationalOperator op) The logic here is to check if we have duplicate alias in each schema
void	TypeCheckingExpVisitor.visit(AddExpression binOp)
void	TypeCheckingExpVisitor.visit(AndExpression andExp)
void	TypeCheckingExpVisitor.visit(BinCondExpression binCond)
void	TypeCheckingExpVisitor.visit(CastExpression 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 to chararray is ok For Composite Types: Recursively traverse the schemas till you get a basic type
void	TypeCheckingExpVisitor.visit(DereferenceExpression deref)
void	TypeCheckingExpVisitor.visit(DivideExpression binOp)
void	TypeCheckingExpVisitor.visit(EqualExpression binOp)
void	TypeCheckingExpVisitor.visit(GreaterThanEqualExpression binOp)
void	TypeCheckingExpVisitor.visit(GreaterThanExpression binOp)
void	TypeCheckingExpVisitor.visit(LessThanEqualExpression binOp)
void	TypeCheckingExpVisitor.visit(LessThanExpression binOp)
void	TypeCheckingRelVisitor.visit(LOCogroup cg) COGroup All group by cols from all inputs have to be of the same type
void	SchemaAliasVisitor.visit(LOCogroup group)
void	ProjectStarExpander.visit(LOCogroup cg)
void	LineageFindRelVisitor.visit(LOCogroup group)
void	SchemaAliasVisitor.visit(LOCross cross)
void	LineageFindRelVisitor.visit(LOCross relOp)
void	SchemaAliasVisitor.visit(LODistinct distinct)
void	LineageFindRelVisitor.visit(LODistinct relOp)
void	TypeCheckingRelVisitor.visit(LOFilter filter) The schema of filter output will be the same as filter input
void	SchemaAliasVisitor.visit(LOFilter filter)
void	LineageFindRelVisitor.visit(LOFilter filter)
void	UDFFinder.visit(LOForEach foreach)
void	TypeCheckingRelVisitor.visit(LOForEach forEach)
void	SchemaAliasVisitor.visit(LOForEach foreach)
void	ProjStarInUdfExpander.visit(LOForEach foreach)
void	ProjectStarExpander.visit(LOForEach foreach)
void	LineageFindRelVisitor.visit(LOForEach fe)
void	UDFFinder.visit(LOGenerate generate)
void	TypeCheckingRelVisitor.visit(LOGenerate gen)
void	SchemaAliasVisitor.visit(LOGenerate gen)
void	ProjStarInUdfExpander.visit(LOGenerate gen)
void	LineageFindRelVisitor.visit(LOGenerate gen)
void	TypeCheckingRelVisitor.visit(LOInnerLoad innerLoad)
void	SchemaAliasVisitor.visit(LOInnerLoad load)
void	LineageFindRelVisitor.visit(LOInnerLoad innerLoad)
void	TypeCheckingRelVisitor.visit(LOJoin join) LOJoin visitor
void	SchemaAliasVisitor.visit(LOJoin join)
void	ProjectStarExpander.visit(LOJoin join)
void	LineageFindRelVisitor.visit(LOJoin join)
void	SchemaAliasVisitor.visit(LOLimit limit)
void	LineageFindRelVisitor.visit(LOLimit relOp)
void	LineageFindRelVisitor.visit(LOLoad load)
void	SchemaAliasVisitor.visit(LONative nativeMR)
void	TypeCheckingRelVisitor.visit(LOSort sort) The schema of sort output will be the same as sort input.
void	SchemaAliasVisitor.visit(LOSort sort)
void	ProjectStarExpander.visit(LOSort sort)
void	LineageFindRelVisitor.visit(LOSort sort)
void	SchemaAliasVisitor.visit(LOSplit split)
void	LineageFindRelVisitor.visit(LOSplit relOp)
void	TypeCheckingRelVisitor.visit(LOSplitOutput op)
void	SchemaAliasVisitor.visit(LOSplitOutput splitOutput)
void	LineageFindRelVisitor.visit(LOSplitOutput split)
void	TypeCheckingRelVisitor.visit(LOStore store)
void	StoreAliasSetter.visit(LOStore store)
void	SortInfoSetter.visit(LOStore store)
void	SchemaAliasVisitor.visit(LOStore store)
void	LineageFindRelVisitor.visit(LOStore relOp)
void	SchemaAliasVisitor.visit(LOStream stream)
void	LineageFindRelVisitor.visit(LOStream stream)
void	UnionOnSchemaSetter.visit(LOUnion union)
void	TypeCheckingRelVisitor.visit(LOUnion u)
void	SchemaAliasVisitor.visit(LOUnion union)
void	LineageFindRelVisitor.visit(LOUnion relOp)
void	TypeCheckingExpVisitor.visit(MapLookupExpression map)
void	TypeCheckingExpVisitor.visit(ModExpression binOp)
void	TypeCheckingExpVisitor.visit(MultiplyExpression binOp)
void	TypeCheckingExpVisitor.visit(NegativeExpression negExp)
void	TypeCheckingExpVisitor.visit(NotEqualExpression binOp)
void	TypeCheckingExpVisitor.visit(NotExpression notExp)
void	TypeCheckingExpVisitor.visit(OrExpression orExp)
void	TypeCheckingExpVisitor.visit(RegexExpression rg) RegexExpression expects CharArray as input Itself always returns Boolean
void	TypeCheckingExpVisitor.visit(SubtractExpression binOp)
void	TypeCheckingExpVisitor.visit(UserFuncExpression func)

Constructors in org.apache.pig.newplan.logical.visitor that throw FrontendException

CastLineageSetter(LogicalPlan plan, CompilationMessageCollector msgCollector)

ColumnAliasConversionVisitor(OperatorPlan plan)

LineageFindRelVisitor(OperatorPlan plan)

ProjectStarExpander(OperatorPlan plan)

ProjStarInUdfExpander(OperatorPlan plan)

ScalarVisitor(OperatorPlan plan, PigContext pigContext)

SchemaAliasVisitor(OperatorPlan plan)

SortInfoSetter(OperatorPlan plan)

StoreAliasSetter(OperatorPlan plan)

TypeCheckingExpVisitor(OperatorPlan expPlan, CompilationMessageCollector msgCollector, LogicalRelationalOperator relOp)

TypeCheckingRelVisitor(OperatorPlan plan, CompilationMessageCollector msgCollector)

UDFFinder(OperatorPlan plan)

UnionOnSchemaSetter(OperatorPlan plan)

Uses of FrontendException in org.apache.pig.newplan.optimizer

Methods in org.apache.pig.newplan.optimizer that throw FrontendException

abstract boolean	Transformer.check(OperatorPlan matched) check if the transform should be done.
List<OperatorPlan>	Rule.match(OperatorPlan plan) Search for all the sub-plans that matches the pattern defined by this rule.
void	PlanOptimizer.optimize() Run the optimizer.
abstract void	Transformer.transform(OperatorPlan matched) Transform the tree
void	PlanTransformListener.transformed(OperatorPlan fp, OperatorPlan tp) Notification that a plan has been transformed.

Uses of FrontendException in org.apache.pig.parser

Subclasses of FrontendException in org.apache.pig.parser

class

ParserException

Methods in org.apache.pig.parser that throw FrontendException

static void

QueryParserUtils.attachStorePlan(LogicalPlan lp, String fileName, String func, Operator input, String alias, PigContext pigContext)

Uses of FrontendException in org.apache.pig.pen

Methods in org.apache.pig.pen that throw FrontendException

void	POOptimizeDisabler.visit(LOCogroup cg)
void	LineageTrimmingVisitor.visit(LOCogroup cg)
void	AugmentBaseDataVisitor.visit(LOCogroup cg)
void	LineageTrimmingVisitor.visit(LOCross cs)
void	AugmentBaseDataVisitor.visit(LOCross cs)
void	LineageTrimmingVisitor.visit(LODistinct dt)
void	AugmentBaseDataVisitor.visit(LODistinct dt)
void	LineageTrimmingVisitor.visit(LOFilter filter)
void	AugmentBaseDataVisitor.visit(LOFilter filter)
void	LineageTrimmingVisitor.visit(LOForEach forEach)
void	AugmentBaseDataVisitor.visit(LOForEach forEach)
void	POOptimizeDisabler.visit(LOJoin join)
void	LineageTrimmingVisitor.visit(LOJoin join)
void	AugmentBaseDataVisitor.visit(LOJoin join)
void	LineageTrimmingVisitor.visit(LOLimit limOp)
void	AugmentBaseDataVisitor.visit(LOLimit lm)
void	LineageTrimmingVisitor.visit(LOLoad load)
void	AugmentBaseDataVisitor.visit(LOLoad load)
void	LineageTrimmingVisitor.visit(LOSort s)
void	AugmentBaseDataVisitor.visit(LOSort s)
void	LineageTrimmingVisitor.visit(LOSplit split)
void	AugmentBaseDataVisitor.visit(LOSplit split)
void	LineageTrimmingVisitor.visit(LOStore store)
void	AugmentBaseDataVisitor.visit(LOStore store)
void	LineageTrimmingVisitor.visit(LOUnion u)
void	AugmentBaseDataVisitor.visit(LOUnion u)

Constructors in org.apache.pig.pen that throw FrontendException

AugmentBaseDataVisitor(OperatorPlan plan, Map<Operator,PhysicalOperator> logToPhysMap, Map<LOLoad,DataBag> baseData, Map<Operator,DataBag> derivedData)

POOptimizeDisabler(OperatorPlan plan)

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

Methods in org.apache.pig.pen.util that throw FrontendException

static String	DisplayExamples.printTabular(LogicalPlan lp, Map<Operator,DataBag> exampleData, Map<LOForEach,Map<LogicalRelationalOperator,DataBag>> forEachInnerLogToDataMap)
void	PreOrderDepthFirstWalker.walk(PlanVisitor visitor) Begin traversing the graph.

Uses of FrontendException in org.apache.pig.piggybank.evaluation.datetime

Methods in org.apache.pig.piggybank.evaluation.datetime that throw FrontendException

List<FuncSpec>

DiffDate.getArgToFuncMapping()

Uses of FrontendException in org.apache.pig.piggybank.evaluation.datetime.convert

Methods in org.apache.pig.piggybank.evaluation.datetime.convert that throw FrontendException

List<FuncSpec>	UnixToISO.getArgToFuncMapping()
List<FuncSpec>	ISOToUnix.getArgToFuncMapping()
List<FuncSpec>	CustomFormatToISO.getArgToFuncMapping()

Uses of FrontendException in org.apache.pig.piggybank.evaluation.datetime.diff

Methods in org.apache.pig.piggybank.evaluation.datetime.diff that throw FrontendException

List<FuncSpec>	ISOYearsBetween.getArgToFuncMapping()
List<FuncSpec>	ISOSecondsBetween.getArgToFuncMapping()
List<FuncSpec>	ISOMonthsBetween.getArgToFuncMapping()
List<FuncSpec>	ISOMinutesBetween.getArgToFuncMapping()
List<FuncSpec>	ISOHoursBetween.getArgToFuncMapping()
List<FuncSpec>	ISODaysBetween.getArgToFuncMapping()

Uses of FrontendException in org.apache.pig.piggybank.evaluation.datetime.truncate

Methods in org.apache.pig.piggybank.evaluation.datetime.truncate that throw FrontendException

List<FuncSpec>	ISOToYear.getArgToFuncMapping()
List<FuncSpec>	ISOToWeek.getArgToFuncMapping()
List<FuncSpec>	ISOToSecond.getArgToFuncMapping()
List<FuncSpec>	ISOToMonth.getArgToFuncMapping()
List<FuncSpec>	ISOToMinute.getArgToFuncMapping()
List<FuncSpec>	ISOToHour.getArgToFuncMapping()
List<FuncSpec>	ISOToDay.getArgToFuncMapping()

Uses of FrontendException in org.apache.pig.piggybank.evaluation.math

Methods in org.apache.pig.piggybank.evaluation.math that throw FrontendException

List<FuncSpec>	ULP.getArgToFuncMapping()
List<FuncSpec>	SIGNUM.getArgToFuncMapping()
List<FuncSpec>	SCALB.getArgToFuncMapping()
List<FuncSpec>	ROUND.getArgToFuncMapping() Deprecated.
List<FuncSpec>	NEXTUP.getArgToFuncMapping()
List<FuncSpec>	nextAfter.getArgToFuncMapping()
List<FuncSpec>	MIN.getArgToFuncMapping()
List<FuncSpec>	MAX.getArgToFuncMapping()
List<FuncSpec>	getExponent.getArgToFuncMapping()
List<FuncSpec>	DoubleDoubleBase.getArgToFuncMapping()
List<FuncSpec>	DoubleBase.getArgToFuncMapping() Deprecated.
List<FuncSpec>	copySign.getArgToFuncMapping()
List<FuncSpec>	ABS.getArgToFuncMapping() Deprecated.

Uses of FrontendException in org.apache.pig.piggybank.evaluation.string

Methods in org.apache.pig.piggybank.evaluation.string that throw FrontendException

List<FuncSpec>	UPPER.getArgToFuncMapping() Deprecated.
List<FuncSpec>	RegexMatch.getArgToFuncMapping()
List<FuncSpec>	RegexExtractAll.getArgToFuncMapping() Deprecated.
List<FuncSpec>	RegexExtract.getArgToFuncMapping() Deprecated.
List<FuncSpec>	LOWER.getArgToFuncMapping() Deprecated.
List<FuncSpec>	HashFNV.getArgToFuncMapping()

Uses of FrontendException in org.apache.pig.piggybank.evaluation.util

Methods in org.apache.pig.piggybank.evaluation.util that throw FrontendException

List<FuncSpec>	Top.getArgToFuncMapping() Deprecated.
List<FuncSpec>	SearchQuery.getArgToFuncMapping()

Uses of FrontendException in org.apache.pig.piggybank.evaluation.util.apachelogparser

Methods in org.apache.pig.piggybank.evaluation.util.apachelogparser that throw FrontendException

List<FuncSpec>	SearchTermExtractor.getArgToFuncMapping()
List<FuncSpec>	SearchEngineExtractor.getArgToFuncMapping()
List<FuncSpec>	HostExtractor.getArgToFuncMapping()
List<FuncSpec>	DateExtractor.getArgToFuncMapping()

Uses of FrontendException in org.apache.pig.piggybank.storage

Methods in org.apache.pig.piggybank.storage that throw FrontendException

LoadPushDown.RequiredFieldResponse	HiveColumnarLoader.pushProjection(LoadPushDown.RequiredFieldList requiredFieldList)
LoadPushDown.RequiredFieldResponse	CSVLoader.pushProjection(LoadPushDown.RequiredFieldList requiredFieldList)
LoadPushDown.RequiredFieldResponse	CSVExcelStorage.pushProjection(LoadPushDown.RequiredFieldList requiredFieldList)
LoadPushDown.RequiredFieldResponse	AllLoader.pushProjection(LoadPushDown.RequiredFieldList requiredFieldList)

Uses of FrontendException in org.apache.pig.tools

Methods in org.apache.pig.tools that throw FrontendException

void	ToolsPigServer.registerNoRun(String fileName, Map<String,String> params, List<String> paramFiles) Register a script without running it.
List<ExecJob>	ToolsPigServer.runPlan(LogicalPlan newPlan, String jobName) Given a (modified) new logical plan, run the script.

Uses of FrontendException in org.apache.pig.tools.pigstats

Methods in org.apache.pig.tools.pigstats that throw FrontendException

void	JobStats.accept(PlanVisitor v)