Uses of Interface
se.liu.ida.hefquin.engine.queryplan.logical.LogicalPlan

Packages that use LogicalPlan

Package	Description
se.liu.ida.hefquin.engine.queryplan.logical
se.liu.ida.hefquin.engine.queryplan.logical.impl
se.liu.ida.hefquin.engine.queryplan.utils
se.liu.ida.hefquin.engine.queryproc
se.liu.ida.hefquin.engine.queryproc.impl.loptimizer
se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics
se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics.utils
se.liu.ida.hefquin.engine.queryproc.impl.planning
se.liu.ida.hefquin.engine.queryproc.impl.poptimizer
se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.evolutionaryAlgorithm
se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.randomized
se.liu.ida.hefquin.engine.queryproc.impl.srcsel

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryplan.logical

Subinterfaces of LogicalPlan in se.liu.ida.hefquin.engine.queryplan.logical

Modifier and Type	Interface	Description
interface	LogicalPlanWithBinaryRoot
interface	LogicalPlanWithNaryRoot
interface	LogicalPlanWithNullaryRoot
interface	LogicalPlanWithUnaryRoot

Methods in se.liu.ida.hefquin.engine.queryplan.logical that return LogicalPlan

Modifier and Type	Method	Description
static LogicalPlan	LogicalPlanUtils.createPlanWithBinaryJoin(LogicalPlan subPlan1, LogicalPlan subPlan2)	Creates a LogicalPlan with a LogicalOpJoin as root operator and the given plans as its two subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithBinaryUnion(LogicalPlan subPlan1, LogicalPlan subPlan2)	Creates a LogicalPlan with a LogicalOpUnion as root operator and the given plans as its two subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(List<LogicalPlan> subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayJoin as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(LogicalPlan... subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayJoin as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayUnion(List<LogicalPlan> subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayUnion as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayUnion(LogicalPlan... subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayUnion as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithSubPlans(LogicalOperator rootOp, List<LogicalPlan> subPlans)	Creates a LogicalPlan with the given operator as root operator and the plans given in the list as subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithSubPlans(LogicalOperator rootOp, LogicalPlan... subPlans)	Creates a LogicalPlan with the given operator as root operator and the given plans as subplans.
LogicalPlan	LogicalPlan.getSubPlan(int i)	Returns the i-th sub-plan of this plan, where i starts at index 0 (zero).
LogicalPlan	LogicalPlanWithUnaryRoot.getSubPlan()	Convenience method that always should return the same as what is returned by calling getSubPlan(int) with a value of 0.
LogicalPlan	LogicalPlanWithBinaryRoot.getSubPlan1()	Convenience method that always should return the same as what is returned by calling getSubPlan(int) with a value of 0.
LogicalPlan	LogicalPlanWithBinaryRoot.getSubPlan2()	Convenience method that always should return the same as what is returned by calling getSubPlan(int) with a value of 1.

Methods in se.liu.ida.hefquin.engine.queryplan.logical that return types with arguments of type LogicalPlan

Modifier and Type	Method	Description
Iterator<LogicalPlan>	LogicalPlanWithNaryRoot.getSubPlans()	Convenience method that always should return an iterator over the same sub-plans that can be accessed via getSubPlan(int).

Methods in se.liu.ida.hefquin.engine.queryplan.logical with parameters of type LogicalPlan

Modifier and Type	Method	Description
static int	LogicalPlanUtils.countSubplans(LogicalPlan plan)
static LogicalPlan	LogicalPlanUtils.createPlanWithBinaryJoin(LogicalPlan subPlan1, LogicalPlan subPlan2)	Creates a LogicalPlan with a LogicalOpJoin as root operator and the given plans as its two subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithBinaryUnion(LogicalPlan subPlan1, LogicalPlan subPlan2)	Creates a LogicalPlan with a LogicalOpUnion as root operator and the given plans as its two subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(LogicalPlan... subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayJoin as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayUnion(LogicalPlan... subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayUnion as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithSubPlans(LogicalOperator rootOp, LogicalPlan... subPlans)	Creates a LogicalPlan with the given operator as root operator and the given plans as subplans.
static boolean	LogicalPlanUtils.isSourceAssignment(LogicalPlan plan)	Returns true if the given logical plan is a source assignment.
void	LogicalPlanWalker.LogicalWalkerVisitor.walk(LogicalPlan plan)
static void	LogicalPlanWalker.walk(LogicalPlan plan, LogicalPlanVisitor beforeVisitor, LogicalPlanVisitor afterVisitor)

Method parameters in se.liu.ida.hefquin.engine.queryplan.logical with type arguments of type LogicalPlan

Modifier and Type	Method	Description
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(List<LogicalPlan> subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayJoin as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayUnion(List<LogicalPlan> subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayUnion as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithSubPlans(LogicalOperator rootOp, List<LogicalPlan> subPlans)	Creates a LogicalPlan with the given operator as root operator and the plans given in the list as subplans.

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryplan.logical.impl

Classes in se.liu.ida.hefquin.engine.queryplan.logical.impl that implement LogicalPlan

Modifier and Type	Class	Description
class	LogicalPlanWithBinaryRootImpl
class	LogicalPlanWithNaryRootImpl
class	LogicalPlanWithNullaryRootImpl
class	LogicalPlanWithUnaryRootImpl

Methods in se.liu.ida.hefquin.engine.queryplan.logical.impl that return LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	LogicalPlanWithBinaryRootImpl.getSubPlan(int i)
LogicalPlan	LogicalPlanWithNaryRootImpl.getSubPlan(int i)
LogicalPlan	LogicalPlanWithNullaryRootImpl.getSubPlan(int i)
LogicalPlan	LogicalPlanWithUnaryRootImpl.getSubPlan()
LogicalPlan	LogicalPlanWithUnaryRootImpl.getSubPlan(int i)
LogicalPlan	LogicalPlanWithBinaryRootImpl.getSubPlan1()
LogicalPlan	LogicalPlanWithBinaryRootImpl.getSubPlan2()

Methods in se.liu.ida.hefquin.engine.queryplan.logical.impl that return types with arguments of type LogicalPlan

Modifier and Type	Method	Description
Iterator<LogicalPlan>	LogicalPlanWithNaryRootImpl.getSubPlans()

Constructors in se.liu.ida.hefquin.engine.queryplan.logical.impl with parameters of type LogicalPlan

Modifier	Constructor	Description
	LogicalPlanWithBinaryRootImpl(BinaryLogicalOp rootOp, LogicalPlan subPlan1, LogicalPlan subPlan2)
	LogicalPlanWithNaryRootImpl(NaryLogicalOp rootOp, LogicalPlan... subPlans)
	LogicalPlanWithUnaryRootImpl(UnaryLogicalOp rootOp, LogicalPlan subPlan)

Constructor parameters in se.liu.ida.hefquin.engine.queryplan.logical.impl with type arguments of type LogicalPlan

Modifier	Constructor	Description
	LogicalPlanWithNaryRootImpl(NaryLogicalOp rootOp, List<LogicalPlan> subPlans)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryplan.utils

Fields in se.liu.ida.hefquin.engine.queryplan.utils with type parameters of type LogicalPlan

Modifier and Type	Field	Description
protected final Map<LogicalPlan,PhysicalPlan>	LogicalToPhysicalPlanConverterImpl.Worker.convertedSubPlans

Methods in se.liu.ida.hefquin.engine.queryplan.utils with parameters of type LogicalPlan

Modifier and Type	Method	Description
PhysicalPlan	LogicalToPhysicalPlanConverter.convert(LogicalPlan lp, boolean keepMultiwayJoins)
PhysicalPlan	LogicalToPhysicalPlanConverterImpl.convert(LogicalPlan lp, boolean keepMultiwayJoins)
PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.convert(LogicalPlan lp, boolean keepMultiwayJoins)
protected List<PhysicalPlan>	LogicalToPhysicalPlanConverterImpl.Worker.convertChildren(LogicalPlan lp, boolean keepMultiwayJoins)	Converts the sub-plans of the given logical plan (if any) and returns a list of the resulting physical plans.
void	TextBasedLogicalPlanPrinterImpl.planWalk(LogicalPlan plan, int planNumber, int planLevel, int numberOfSiblings, TextBasedLogicalPlanPrinterImpl.OpPrinter opPrinter, String rootOpIndentString)	This method recursively goes through a plan, and appends specific strings to a print stream.
void	LogicalPlanPrinter.print(LogicalPlan plan, PrintStream out)	Prints the given plan to the given stream.
void	TextBasedLogicalPlanPrinterImpl.print(LogicalPlan plan, PrintStream out)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc

Methods in se.liu.ida.hefquin.engine.queryproc that return LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	QueryPlanningStats.getResultingLogicalPlan()
LogicalPlan	QueryPlanningStats.getResultingSourceAssignment()
LogicalPlan	LogicalOptimizer.optimize(LogicalPlan inputPlan, boolean keepNaryOperators)

Methods in se.liu.ida.hefquin.engine.queryproc that return types with arguments of type LogicalPlan

Modifier and Type	Method	Description
Pair<LogicalPlan,SourcePlanningStats>	SourcePlanner.createSourceAssignment(Query query)	The logical plan returned by this method is a source assignment (see Definition 8 of our FedQPL paper); that is, the only types of operators that it contains are request operators ( invalid reference LogicalOpRequest ), multiway joins ( invalid reference LogicalOpMultiwayJoin ), and multiway unions ( invalid reference LogicalOpMultiwayUnion ).

Methods in se.liu.ida.hefquin.engine.queryproc with parameters of type LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	LogicalOptimizer.optimize(LogicalPlan inputPlan, boolean keepNaryOperators)
Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizer.optimize(LogicalPlan initialPlan)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer

Methods in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer that return LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	ApplyVocabularyMappings.apply(LogicalPlan inputPlan)	Rewrites an initial logical plan into a second plan which incorporates translations of local to global vocabulary and request-operator rewriting.
LogicalPlan	HeuristicForLogicalOptimization.apply(LogicalPlan inputPlan)	Applies this heuristics to the given plan and returns the resulting, potentially rewritten plan.
LogicalPlan	HeuristicsBasedLogicalOptimizerImpl.optimize(LogicalPlan inputPlan, boolean keepNaryOperators)
static LogicalPlan	ApplyVocabularyMappings.rewriteReqOf(SPARQLGraphPattern pattern, FederationMember fm)	Creates a logical plan where all requests are TriplePatternRequests for use when a federation member's interface is a TPF-server.
static LogicalPlan	ApplyVocabularyMappings.rewriteToUseLocalVocabulary(LogicalPlan inputPlan)	Rewrites the given logical plan with a request operator as root into a logical plan that uses the local vocabulary of the federation member of the request.

Methods in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer with parameters of type LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	ApplyVocabularyMappings.apply(LogicalPlan inputPlan)	Rewrites an initial logical plan into a second plan which incorporates translations of local to global vocabulary and request-operator rewriting.
LogicalPlan	HeuristicForLogicalOptimization.apply(LogicalPlan inputPlan)	Applies this heuristics to the given plan and returns the resulting, potentially rewritten plan.
LogicalPlan	HeuristicsBasedLogicalOptimizerImpl.optimize(LogicalPlan inputPlan, boolean keepNaryOperators)
static LogicalPlan	ApplyVocabularyMappings.rewriteToUseLocalVocabulary(LogicalPlan inputPlan)	Rewrites the given logical plan with a request operator as root into a logical plan that uses the local vocabulary of the federation member of the request.

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics

Fields in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics declared as LogicalPlan

Modifier and Type	Field	Description
final LogicalPlan	CardinalityBasedJoinOrderingBase.AnnotatedLogicalPlan.plan	The wrapped LogicalPlan.

Methods in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics that return LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	CardinalityBasedJoinOrderingBase.apply(LogicalPlan inputPlan)
LogicalPlan	FilterPushDown.apply(LogicalPlan inputPlan)
LogicalPlan	GreedyBasedReordering.apply(LogicalPlan inputPlan)
LogicalPlan	MergeRequests.apply(LogicalPlan inputPlan)
LogicalPlan	PullUpLtgOverJoin.apply(LogicalPlan inputPlan)
LogicalPlan	PullUpLtgOverUnion.apply(LogicalPlan inputPlan)
LogicalPlan	PushJoinUnderUnionWithRequests.apply(LogicalPlan inputPlan)
LogicalPlan	RemovePairsOfG2lAndL2g.apply(LogicalPlan inputPlan)
LogicalPlan	RemoveUnnecessaryL2gAndG2l.apply(LogicalPlan inputPlan)
LogicalPlan	UnionPullUp.apply(LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.applyToPlanWithFilterAsRootOperator(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
protected LogicalPlan	GreedyBasedReordering.constructBinaryPlan(List<QueryAnalyzer> selectedSubPlans)
protected LogicalPlan	FilterPushDown.createPlanAfterPushingInSubPlan(LogicalOpFilter parentFilterOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForAddOpUnderFilter(LogicalOpFilter parentFilterOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp, LogicalPlan inputPlan)	Assumes that the given child operator is either a LogicalOpTPAdd, a LogicalOpTPOptAdd, a LogicalOpBGPAdd, a LogicalOpBGPOptAdd, a LogicalOpGPAdd, or a LogicalOpGPOptAdd.
protected LogicalPlan	FilterPushDown.createPlanForBindUnderFilter(LogicalOpFilter filterOp, LogicalOpBind bindOp, LogicalPlan subPlanUnderBind, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForFilterUnderFilter(LogicalOpFilter parentFilterOp, LogicalOpFilter childFilterOp, LogicalPlan subPlanUnderChildFilterOp)
protected LogicalPlan	FilterPushDown.createPlanForJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForL2GOrG2LUnderFilter(LogicalOpFilter parentFilterOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp, LogicalPlan inputPlan)	Assumes that the given child operator is either a LogicalOpLocalToGlobal or a LogicalOpGlobalToLocal.
protected LogicalPlan	FilterPushDown.createPlanForMultiwayLeftJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForRequestUnderFilter(LogicalOpFilter filterOp, LogicalOpRequest<?,?> reqOp, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForRightJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan nonoptSubPlan, LogicalPlan optSubPlan, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForUnionUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter)
protected LogicalPlan	MergeRequests.createPlanWithSingleRequestOp(org.apache.jena.sparql.syntax.Element elmt, SPARQLEndpoint fm)
protected LogicalPlan	MergeRequests.createPlanWithSingleRequestOp(SPARQLGraphPattern p, SPARQLEndpoint fm)
protected static LogicalPlan	PullUpLtgOverUnion.extractLtgOverNaryOp(LogicalPlan inputPlan)
static LogicalPlan	MergeRequests.mergeBindIntoSPARQLEndpointRequest(LogicalOpBind bindOp, SPARQLEndpoint ep, SPARQLRequest req)
static LogicalPlan	MergeRequests.mergeFilterIntoSPARQLEndpointRequest(LogicalOpFilter filterOp, SPARQLEndpoint ep, SPARQLRequest req)
protected LogicalPlan	MergeRequests.mergeOptPatternsIntoRequest(List<SPARQLGraphPattern> optPatterns, SPARQLEndpoint fm, SPARQLRequest req)
protected LogicalPlan	MergeRequests.mergePatternIntoRequest(SPARQLGraphPattern p, FederationMember fm, SPARQLRequest req)
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaJoin(FederationMember fm, List<LogicalPlan> reqPlans)	Assumes that the given list contains at list two plans and that all plans in the list consist only of a request operator.
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaJoin(FederationMember fm, SPARQLRequest req1, SPARQLRequest req2)
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaUnion(SPARQLEndpoint fm, List<LogicalPlan> reqPlans)
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaUnion(SPARQLEndpoint fm, SPARQLRequest req1, SPARQLRequest req2)
protected LogicalPlan	FilterPushDown.pushToNonOptSubPlan(org.apache.jena.sparql.expr.ExprList filterExprsWithoutAND, LogicalPlan nonoptSubPlan, org.apache.jena.sparql.expr.ExprList toBeKept)
protected LogicalPlan	GreedyBasedReordering.reorderSubPlans(LogicalPlan inputPlan)
protected LogicalPlan	PushJoinUnderUnionWithRequests.rewrite(LogicalPlan unionPlan, List<LogicalPlan> subPlansAsInput)
LogicalPlan	UnionPullUp.rewritePlanWithJoinOverUnion(List<LogicalPlan> plansWithUnionRoot, List<LogicalPlan> plansWithNonUnionRoot)	Based on the assumptions that i) the plans in the given lists have all been subplans of a join and ii) the given list of union-rooted plans is nonempty, pulls the unions out of these union-rooted plans by joining all their subplans with one another, and also with all the plans given in the other list (plansWithNonUnionRoot).
LogicalPlan	UnionPullUp.rewritePlanWithUnaryRootAndUnionChild(UnaryLogicalOp rootOp, LogicalPlan subPlan)	Based on the assumption that the given subplan has a union operator as its root operator, this function pulls up that union by pushing the given unary operator to be the root of each of the children of the union.
LogicalPlan	UnionPullUp.rewritePlanWithUnionRootAndUnionChild(List<LogicalPlan> plansWithUnionRoot, List<LogicalPlan> plansWithNonUnionRoot)	Based on the assumptions that i) the plans in the given lists have all been subplans of a union and ii) the given list of union-rooted plans is nonempty, merges all these union-rooted plans (plansWithUnionRoot) into a single union-root plan that has all the subplans of the given union-rooted plans as its subplans, together with all the plans given in the other list (plansWithNonUnionRoot).

Methods in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics with parameters of type LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	CardinalityBasedJoinOrderingBase.apply(LogicalPlan inputPlan)
LogicalPlan	FilterPushDown.apply(LogicalPlan inputPlan)
LogicalPlan	GreedyBasedReordering.apply(LogicalPlan inputPlan)
LogicalPlan	MergeRequests.apply(LogicalPlan inputPlan)
LogicalPlan	PullUpLtgOverJoin.apply(LogicalPlan inputPlan)
LogicalPlan	PullUpLtgOverUnion.apply(LogicalPlan inputPlan)
LogicalPlan	PushJoinUnderUnionWithRequests.apply(LogicalPlan inputPlan)
LogicalPlan	RemovePairsOfG2lAndL2g.apply(LogicalPlan inputPlan)
LogicalPlan	RemoveUnnecessaryL2gAndG2l.apply(LogicalPlan inputPlan)
LogicalPlan	UnionPullUp.apply(LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.applyToPlanWithFilterAsRootOperator(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
static boolean	RemovePairsOfG2lAndL2g.checkIfG2lAndL2gPairsRemovable(LogicalPlan plan)	If a pair of g2l and l2g operators use the same vocabulary mapping, these two operators can be omitted
protected boolean	RemoveUnnecessaryL2gAndG2l.checkIfL2gOrG2lNeeded(LogicalPlan plan)	This function is used to check if a l2g or g2l operator is needed.
static boolean	PullUpLtgOverJoin.checkIfLtgCanBeExtractedOverJoin(LogicalPlan inputPlan)	Check if l2g operator can be pulled up over join by checking: i) the root operator is a join (binary or multiway), ii) every subplan under this join has an l2g operator as its root, iii) all these l2g operators have the same vocab.mapping, and iv) that vocab.mapping is an "equivalence-only" mapping.
static boolean	PullUpLtgOverUnion.checkIfLtgCanBeExtractedOverUnion(LogicalPlan unionPlan)	Check if l2g operator can be pulled up over union by checking: i) the root operator is a union (binary or multiway), ii) every subplan under this join has an l2g operator as its root, and iii) all these l2g operators have the same vocab.mapping
protected LogicalPlan	FilterPushDown.createPlanAfterPushingInSubPlan(LogicalOpFilter parentFilterOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForAddOpUnderFilter(LogicalOpFilter parentFilterOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp, LogicalPlan inputPlan)	Assumes that the given child operator is either a LogicalOpTPAdd, a LogicalOpTPOptAdd, a LogicalOpBGPAdd, a LogicalOpBGPOptAdd, a LogicalOpGPAdd, or a LogicalOpGPOptAdd.
protected LogicalPlan	FilterPushDown.createPlanForBindUnderFilter(LogicalOpFilter filterOp, LogicalOpBind bindOp, LogicalPlan subPlanUnderBind, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForFilterUnderFilter(LogicalOpFilter parentFilterOp, LogicalOpFilter childFilterOp, LogicalPlan subPlanUnderChildFilterOp)
protected LogicalPlan	FilterPushDown.createPlanForJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForL2GOrG2LUnderFilter(LogicalOpFilter parentFilterOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp, LogicalPlan inputPlan)	Assumes that the given child operator is either a LogicalOpLocalToGlobal or a LogicalOpGlobalToLocal.
protected LogicalPlan	FilterPushDown.createPlanForMultiwayLeftJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForRequestUnderFilter(LogicalOpFilter filterOp, LogicalOpRequest<?,?> reqOp, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForRightJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan nonoptSubPlan, LogicalPlan optSubPlan, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForUnionUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter)
protected abstract int[]	CardinalityBasedJoinOrderingBase.estimateCardinalities(LogicalPlan[] plans)	Implementations of this function determine or estimate the cardinality of each of the given plans.
protected int[]	CardinalityBasedJoinOrderingWithRequests.estimateCardinalities(LogicalPlan[] plans)
protected List<LogicalOpRequest<?,?>>	CardinalityBasedJoinOrderingWithRequests.extractAllRequestOps(LogicalPlan plan)	Extracts all request operators from the given plan such that the resulting list of these operators will be ordered in the order in which the operators can be found by a depth-first traversal of the given plan.
protected List<LogicalOpRequest<?,?>>[]	CardinalityBasedJoinOrderingWithRequests.extractAllRequestOps(LogicalPlan[] plans)	Extracts all request operators from the given list of plans such that, for each of the plans, the resulting list of these operators is ordered in the order in which the operators can be found by a depth-first traversal of the plan.
protected static LogicalPlan	PullUpLtgOverUnion.extractLtgOverNaryOp(LogicalPlan inputPlan)
protected static Set<TriplePattern>	RemoveUnnecessaryL2gAndG2l.extractTPs(LogicalPlan plan)
boolean	UnionPullUp.hasUnionRoot(LogicalPlan plan)
protected LogicalPlan	FilterPushDown.pushToNonOptSubPlan(org.apache.jena.sparql.expr.ExprList filterExprsWithoutAND, LogicalPlan nonoptSubPlan, org.apache.jena.sparql.expr.ExprList toBeKept)
protected void	CardinalityBasedJoinOrderingBase.reorder(LogicalPlan[] plans)	Changes the order of the subplans in the given array by using the greedy algorithm described above for this class.
protected LogicalPlan	GreedyBasedReordering.reorderSubPlans(LogicalPlan inputPlan)
protected LogicalPlan	PushJoinUnderUnionWithRequests.rewrite(LogicalPlan unionPlan, List<LogicalPlan> subPlansAsInput)
LogicalPlan	UnionPullUp.rewritePlanWithUnaryRootAndUnionChild(UnaryLogicalOp rootOp, LogicalPlan subPlan)	Based on the assumption that the given subplan has a union operator as its root operator, this function pulls up that union by pushing the given unary operator to be the root of each of the children of the union.

Method parameters in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics with type arguments of type LogicalPlan

Modifier and Type	Method	Description
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaJoin(FederationMember fm, List<LogicalPlan> reqPlans)	Assumes that the given list contains at list two plans and that all plans in the list consist only of a request operator.
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaUnion(SPARQLEndpoint fm, List<LogicalPlan> reqPlans)
protected LogicalPlan	PushJoinUnderUnionWithRequests.rewrite(LogicalPlan unionPlan, List<LogicalPlan> subPlansAsInput)
LogicalPlan	UnionPullUp.rewritePlanWithJoinOverUnion(List<LogicalPlan> plansWithUnionRoot, List<LogicalPlan> plansWithNonUnionRoot)	Based on the assumptions that i) the plans in the given lists have all been subplans of a join and ii) the given list of union-rooted plans is nonempty, pulls the unions out of these union-rooted plans by joining all their subplans with one another, and also with all the plans given in the other list (plansWithNonUnionRoot).
LogicalPlan	UnionPullUp.rewritePlanWithUnionRootAndUnionChild(List<LogicalPlan> plansWithUnionRoot, List<LogicalPlan> plansWithNonUnionRoot)	Based on the assumptions that i) the plans in the given lists have all been subplans of a union and ii) the given list of union-rooted plans is nonempty, merges all these union-rooted plans (plansWithUnionRoot) into a single union-root plan that has all the subplans of the given union-rooted plans as its subplans, together with all the plans given in the other list (plansWithNonUnionRoot).
protected void	MergeRequests.separateSubPlansOfMultiwayOps(List<LogicalPlan> subPlans, Map<FederationMember,List<LogicalPlan>> reqOnlyPlansPerFedMember, List<LogicalPlan> nonReqSubPlans)
protected void	MergeRequests.separateSubPlansOfMultiwayOps(List<LogicalPlan> subPlans, Map<FederationMember,List<LogicalPlan>> reqOnlyPlansPerFedMember, List<LogicalPlan> nonReqSubPlans)

Constructors in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics with parameters of type LogicalPlan

Modifier	Constructor	Description
	AnnotatedLogicalPlan(LogicalPlan plan, int card)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics.utils

Fields in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics.utils declared as LogicalPlan

Modifier and Type	Field	Description
protected final LogicalPlan	QueryAnalyzer.plan

Methods in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics.utils that return LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	QueryAnalyzer.getPlan()

Methods in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics.utils with parameters of type LogicalPlan

Modifier and Type	Method	Description
protected Set<TriplePattern>	QueryAnalyzer.extractTPsAndRecordFms(LogicalPlan plan)

Constructors in se.liu.ida.hefquin.engine.queryproc.impl.loptimizer.heuristics.utils with parameters of type LogicalPlan

Modifier	Constructor	Description
	QueryAnalyzer(LogicalPlan plan)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.planning

Methods in se.liu.ida.hefquin.engine.queryproc.impl.planning that return LogicalPlan

Modifier and Type	Method	Description
LogicalPlan	QueryPlanningStatsImpl.getResultingLogicalPlan()
LogicalPlan	QueryPlanningStatsImpl.getResultingSourceAssignment()

Constructors in se.liu.ida.hefquin.engine.queryproc.impl.planning with parameters of type LogicalPlan

Modifier	Constructor	Description
	QueryPlanningStatsImpl(long overallQueryPlanningTime, long sourcePlanningTime, long logicalOptimizationTime, long physicalOptimizationTime, SourcePlanningStats sourcePlanningStats, LogicalPlan resultingSourceAssignment, LogicalPlan resultingLogicalPlan, PhysicalPlan resultingPhysicalPlan, PhysicalOptimizationStats queryOptimizationStats)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer

Methods in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer with parameters of type LogicalPlan

Modifier and Type	Method	Description
final Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizerBase.optimize(LogicalPlan lp)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.evolutionaryAlgorithm

Methods in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.evolutionaryAlgorithm with parameters of type LogicalPlan

Modifier and Type	Method	Description
protected static int	TerminationCriterionBase.countNumOfOps(LogicalPlan plan)
TerminationCriterion	TerminationCriterionFactory.createInstance(LogicalPlan plan)	Creates a new instance of the corresponding termination criterion, which is initialized based on the given logical plan, and returns that new instance.
Pair<PhysicalPlan,PhysicalOptimizationStats>	EvolutionaryAlgorithmQueryOptimizer.optimize(LogicalPlan initialPlan)

Constructors in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.evolutionaryAlgorithm with parameters of type LogicalPlan

Modifier	Constructor	Description
	TerminateByDistancePercAvg(double percAvgThreshold, LogicalPlan plan)
	TerminateByDistancePercAvgDynamicG(double percAvgThreshold, LogicalPlan plan)
	TerminateByDistancePercBest(double percBestThreshold, LogicalPlan plan)
	TerminateByDiversityDistBest(double distBestThreshold, double topK, LogicalPlan plan)
	TerminateByDiversityDistMax(double distMaxThreshold, LogicalPlan plan)
	TerminateByDiversityRelStDev(double relStDevThreshold, LogicalPlan plan)
	TerminatedByCostValue(double costValueThreshold, LogicalPlan plan)
	TerminatedByNumberOfGenerations(int generationThreshold, LogicalPlan plan)
	TerminationCriterionBase(LogicalPlan plan)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.randomized

Methods in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.randomized with parameters of type LogicalPlan

Modifier and Type	Method	Description
Pair<PhysicalPlan,PhysicalOptimizationStats>	IterativeImprovementBasedQueryOptimizer.optimize(LogicalPlan initialPlan)
Pair<PhysicalPlan,PhysicalOptimizationStats>	SimulatedAnnealing.optimize(LogicalPlan initialPlan)
Pair<PhysicalPlan,PhysicalOptimizationStats>	TwoPhaseQueryOptimizer.optimize(LogicalPlan initialPlan)

Uses of LogicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.srcsel

Methods in se.liu.ida.hefquin.engine.queryproc.impl.srcsel that return LogicalPlan

Modifier and Type	Method	Description
protected LogicalPlan	ExhaustiveSourcePlannerImpl.createPlan(org.apache.jena.sparql.algebra.Op jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlan(org.apache.jena.sparql.algebra.Op jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlan(org.apache.jena.sparql.algebra.Op jenaOp, FederationMember fm)
protected LogicalPlan	ExhaustiveSourcePlannerImpl.createPlanForBGP(org.apache.jena.sparql.algebra.op.OpBGP bgpOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForBGP(org.apache.jena.sparql.algebra.op.OpBGP pattern, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForBGP(org.apache.jena.sparql.core.BasicPattern pattern, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForBGP(BGP bgp, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForBind(org.apache.jena.sparql.algebra.op.OpExtend jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForFilter(org.apache.jena.sparql.algebra.op.OpFilter jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForFilter(org.apache.jena.sparql.algebra.op.OpFilter jenaOp, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForJoin(org.apache.jena.sparql.algebra.op.OpJoin jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForJoin(org.apache.jena.sparql.algebra.op.OpJoin jenaOp, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpConditional jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpConditional jenaOp, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpLeftJoin jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpLeftJoin jenaOp, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForSequence(org.apache.jena.sparql.algebra.op.OpSequence jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForServicePattern(org.apache.jena.sparql.algebra.op.OpService jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForUnion(org.apache.jena.sparql.algebra.op.OpUnion jenaOp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForUnion(org.apache.jena.sparql.algebra.op.OpUnion jenaOp, FederationMember fm)
protected LogicalPlan	ExhaustiveSourcePlannerImpl.createRequestSubPlan(org.apache.jena.graph.Triple tp, FederationMember fm)
protected LogicalPlan	ExhaustiveSourcePlannerImpl.createSubPlanForTP(org.apache.jena.graph.Triple tp)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayJoin(List<LogicalPlan> subPlans)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayJoin(LogicalPlan... subPlans)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayLeftJoin(LogicalPlan leftSubPlan, LogicalPlan rightSubPlan)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayUnion(LogicalPlan... subPlans)

Methods in se.liu.ida.hefquin.engine.queryproc.impl.srcsel that return types with arguments of type LogicalPlan

Modifier and Type	Method	Description
protected Pair<LogicalPlan,SourcePlanningStats>	ServiceClauseBasedSourcePlannerImpl.createSourceAssignment(org.apache.jena.sparql.algebra.Op jenaOp)
protected abstract Pair<LogicalPlan,SourcePlanningStats>	SourcePlannerBase.createSourceAssignment(org.apache.jena.sparql.algebra.Op jenaOp)
final Pair<LogicalPlan,SourcePlanningStats>	SourcePlannerBase.createSourceAssignment(Query query)

Methods in se.liu.ida.hefquin.engine.queryproc.impl.srcsel with parameters of type LogicalPlan

Modifier and Type	Method	Description
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayJoin(LogicalPlan... subPlans)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayLeftJoin(LogicalPlan leftSubPlan, LogicalPlan rightSubPlan)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayUnion(LogicalPlan... subPlans)

Method parameters in se.liu.ida.hefquin.engine.queryproc.impl.srcsel with type arguments of type LogicalPlan

Modifier and Type	Method	Description
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayJoin(List<LogicalPlan> subPlans)