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.cardinality
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.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, Iterable<QueryPlanProperty> qpInfo)	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, Iterable<QueryPlanProperty> qpInfo)	Creates a LogicalPlan with a LogicalOpUnion as root operator and the given plans as its two subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(Iterable<QueryPlanProperty> qpInfo, LogicalPlan... subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayJoin as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(List<LogicalPlan> subPlans, Iterable<QueryPlanProperty> qpInfo)	Creates a LogicalPlan with a LogicalOpMultiwayJoin as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayUnion(Iterable<QueryPlanProperty> qpInfo, LogicalPlan... subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayUnion as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayUnion(List<LogicalPlan> subPlans, Iterable<QueryPlanProperty> qpInfo)	Creates a LogicalPlan with a LogicalOpMultiwayUnion as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithSubPlans(LogicalOperator rootOp, Iterable<QueryPlanProperty> qpInfo, 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, Iterable<QueryPlanProperty> qpInfo, LogicalPlan... subPlans)	Creates a LogicalPlan with the given operator as root operator and the given plans as subplans.
LogicalPlan	LogicalPlan.getSubPlan(int i)
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, Iterable<QueryPlanProperty> qpInfo)	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, Iterable<QueryPlanProperty> qpInfo)	Creates a LogicalPlan with a LogicalOpUnion as root operator and the given plans as its two subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(Iterable<QueryPlanProperty> qpInfo, LogicalPlan... subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayJoin as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayUnion(Iterable<QueryPlanProperty> qpInfo, LogicalPlan... subPlans)	Creates a LogicalPlan with a LogicalOpMultiwayUnion as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithSubPlans(LogicalOperator rootOp, Iterable<QueryPlanProperty> qpInfo, 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, Iterable<QueryPlanProperty> qpInfo)	Creates a LogicalPlan with a LogicalOpMultiwayJoin as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayUnion(List<LogicalPlan> subPlans, Iterable<QueryPlanProperty> qpInfo)	Creates a LogicalPlan with a LogicalOpMultiwayUnion as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithSubPlans(LogicalOperator rootOp, Iterable<QueryPlanProperty> qpInfo, 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, Iterable<QueryPlanProperty> qpInfo, LogicalPlan subPlan1, LogicalPlan subPlan2)	Constructor.
	LogicalPlanWithNaryRootImpl(NaryLogicalOp rootOp, Iterable<QueryPlanProperty> qpInfo, LogicalPlan... subPlans)	Constructor.
	LogicalPlanWithUnaryRootImpl(UnaryLogicalOp rootOp, Iterable<QueryPlanProperty> qpInfo, LogicalPlan subPlan)	Constructor.

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

Modifier	Constructor	Description
	LogicalPlanWithNaryRootImpl(NaryLogicalOp rootOp, Iterable<QueryPlanProperty> qpInfo, List<LogicalPlan> subPlans)	Constructor.

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, QueryProcContext ctxt)
PhysicalPlan	LogicalToPhysicalPlanConverterImpl.convert(LogicalPlan lp, boolean keepMultiwayJoins, QueryProcContext ctxt)
PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.convert(LogicalPlan lp, boolean keepMultiwayJoins)
protected 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.
BaseForTextBasedPlanPrinters.ExtPrintablePlan	TextBasedLogicalPlanPrinterImpl.createPrintablePlan(LogicalPlan lp)
List<PlanPrinter.PrintablePlan>	TextBasedLogicalPlanPrinterImpl.createPrintableSubPlans(LogicalPlan lp)
void	LogicalPlanPrinter.print(LogicalPlan plan, PrintStream out, LogicalPlanPrinter.LogicalPlanStage planType)	Prints the given plan to the given stream.
void	LogicalPlanPrinter.print(LogicalPlan plan, LogicalPlanPrinter.LogicalPlanStage planType)	Prints the given plan to the stream(s) that are stored in this printer.
void	TextBasedLogicalPlanPrinterImpl.print(LogicalPlan plan, PrintStream out, LogicalPlanPrinter.LogicalPlanStage planType)
void	TextBasedLogicalPlanPrinterImpl.print(LogicalPlan plan, LogicalPlanPrinter.LogicalPlanStage planType)

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, QueryProcContext ctxt)

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, QueryProcContext ctxt)	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
void	CardinalityEstimator.addCardinalities(LogicalPlan... plans)	Annotates each of the given plans (including, recursively, each of their subplans) with estimates regarding their result cardinalities.
LogicalPlan	LogicalOptimizer.optimize(LogicalPlan inputPlan, boolean keepNaryOperators, QueryProcContext ctxt)
Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizer.optimize(LogicalPlan initialPlan, QueryProcContext ctxt)

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

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

Modifier and Type	Method	Description
protected Set<LogicalPlan>	RequestBasedCardinalityEstimator.extractNullarySubPlans(LogicalPlan... plans)	Returns all relevant nullary subplans that are somewhere within any of the given plans, where such a subplan is considered relevant if it does not yet have a cardinality estimate.

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

Modifier and Type	Method	Description
void	CardinalityEstimationWorker.addCardinalities(LogicalPlan... plans)	Determine a cardinality estimate for each of the given plans recursively, assuming that every nullary subplan within each of the given plans is already annotated with a cardinality estimate.
void	CardinalityEstimationWorkerImpl.addCardinalities(LogicalPlan... plans)
void	RequestBasedCardinalityEstimator.addCardinalities(LogicalPlan... plans)
void	RequestBasedCardinalityEstimator.addCardinalitiesForRequests(LogicalPlan... plans)	Makes sure that every nullary subplan within each of the given plans is annotated with cardinality estimates (which are determined by issuing cardinality requests).
protected void	CardinalityEstimationWorkerImpl.addCardinality(LogicalPlan plan)	Assumes that all nullary subplans within the given plan are already annotated with a cardinality estimate.
protected Set<LogicalPlan>	RequestBasedCardinalityEstimator.extractNullarySubPlans(LogicalPlan... plans)	Returns all relevant nullary subplans that are somewhere within any of the given plans, where such a subplan is considered relevant if it does not yet have a cardinality estimate.
protected void	RequestBasedCardinalityEstimator.extractNullarySubPlans(LogicalPlan plan, Set<LogicalPlan> extractedSubPlans)	Extracts all relevant nullary subplans that are somewhere within the given plan and adds these subplans to the given set, where such a subplan is considered relevant if it does not yet have a cardinality estimate.

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

Modifier and Type	Method	Description
protected void	RequestBasedCardinalityEstimator.extractNullarySubPlans(LogicalPlan plan, Set<LogicalPlan> extractedSubPlans)	Extracts all relevant nullary subplans that are somewhere within the given plan and adds these subplans to the given set, where such a subplan is considered relevant if it does not yet have a cardinality estimate.

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, QueryProcContext ctxt)
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, QueryProcContext ctxt)
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

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

Modifier and Type	Method	Description
protected LogicalPlan	CardinalityBasedJoinOrderingBase._apply(LogicalPlan inputPlan)
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 invalid reference LogicalOpTPAdd , a invalid reference LogicalOpTPOptAdd , a invalid reference LogicalOpBGPAdd , a invalid reference 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.createPlanForUnfoldUnderFilter(LogicalOpFilter filterOp, LogicalOpUnfold unfoldOp, LogicalPlan subPlanUnderUnfold, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForUnionUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter)
protected LogicalPlan	MergeRequests.createPlanWithSingleRequestOp(SPARQLGraphPattern p, FederationMember fm)
protected static LogicalPlan	PullUpLtgOverUnion.extractLtgOverNaryOp(LogicalPlan inputPlan)
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaJoin(FederationMember fm, List<LogicalPlan> reqPlans)	Assumes that the given list contains at least two plans and that all plans in the list consist only of a request operator.
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 that return types with arguments of type LogicalPlan

Modifier and Type	Method	Description
protected Pair<LogicalPlan,Integer>	CardinalityBasedJoinOrderingBase.determineNextPlan(List<LogicalPlan> selectedPlans, int joinCardOfSelectedPlans, List<LogicalPlan> nextCandidates)	Returns the plan from the given list of next candidates that has the lowest join cardinality with a plan consisting of the given selected plans, and that join cardinality will be returned as well.

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

Modifier and Type	Method	Description
protected LogicalPlan	CardinalityBasedJoinOrderingBase._apply(LogicalPlan inputPlan)
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 static boolean	CardinalityBasedJoinOrderingBase.containsJoinOp(LogicalPlan logicalPlan)	Recursively checks whether the given logical plan contains any join operators (LogicalOpJoin or LogicalOpMultiwayJoin).
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 invalid reference LogicalOpTPAdd , a invalid reference LogicalOpTPOptAdd , a invalid reference LogicalOpBGPAdd , a invalid reference 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.createPlanForUnfoldUnderFilter(LogicalOpFilter filterOp, LogicalOpUnfold unfoldOp, LogicalPlan subPlanUnderUnfold, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForUnionUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter)
protected int	CardinalityBasedJoinOrderingBase.determineIdxOfSmallestCardinality(LogicalPlan[] plans)	Compares the given plans in terms of their estimated cardinalities and, for the plan that has the smallest estimated cardinality, returns the index of this plan within the given list.
protected abstract int	CardinalityBasedJoinOrderingBase.estimateJoinCardinality(List<LogicalPlan> selectedPlans, int joinCardOfSelectedPlans, LogicalPlan nextCandidate)	Implementations of this function estimate the cardinality of the join between the result of joining the given selected plans and the result of the given next candidate.
protected int	CardinalityBasedJoinOrderingWithRequests.estimateJoinCardinality(List<LogicalPlan> selectedPlans, int joinCardOfSelectedPlans, LogicalPlan nextCandidate)
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 boolean	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 Pair<LogicalPlan,Integer>	CardinalityBasedJoinOrderingBase.determineNextPlan(List<LogicalPlan> selectedPlans, int joinCardOfSelectedPlans, List<LogicalPlan> nextCandidates)	Returns the plan from the given list of next candidates that has the lowest join cardinality with a plan consisting of the given selected plans, and that join cardinality will be returned as well.
protected abstract int	CardinalityBasedJoinOrderingBase.estimateJoinCardinality(List<LogicalPlan> selectedPlans, int joinCardOfSelectedPlans, LogicalPlan nextCandidate)	Implementations of this function estimate the cardinality of the join between the result of joining the given selected plans and the result of the given next candidate.
protected int	CardinalityBasedJoinOrderingWithRequests.estimateJoinCardinality(List<LogicalPlan> selectedPlans, int joinCardOfSelectedPlans, LogicalPlan nextCandidate)
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaJoin(FederationMember fm, List<LogicalPlan> reqPlans)	Assumes that the given list contains at least two plans and that all plans in the list consist only of a request operator.
protected SPARQLGraphPattern	MergeRequests.mergeSPARQLRequestsViaUnion(List<LogicalPlan> reqPlans)	Assumes that the given list contains at least two plans and that all plans in the list consist only of a request operator.
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)

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, QueryProcContext ctxt)

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, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlan(org.apache.jena.sparql.algebra.Op jenaOp, QueryProcContext ctxt)
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, QueryProcContext ctxt)
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, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForFilter(org.apache.jena.sparql.algebra.op.OpFilter jenaOp, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForFilter(org.apache.jena.sparql.algebra.op.OpFilter jenaOp, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForJoin(List<org.apache.jena.sparql.algebra.Op> ops, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForJoin(org.apache.jena.sparql.algebra.op.OpJoin jenaOp, QueryProcContext ctxt)
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, QueryProcContext ctxt)
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, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpLeftJoin jenaOp, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForOpTable(org.apache.jena.sparql.algebra.op.OpTable opTable)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForSequence(org.apache.jena.sparql.algebra.op.OpSequence jenaOp, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForServicePattern(org.apache.jena.sparql.algebra.op.OpService jenaOp, QueryProcContext ctxt)	This function assumes that the given operator comes from a SERVICE clause that did not have a PARAMS part (or an empty one), and it produces a plan with a request operator as root.
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForServiceWithParams(OpServiceWithParams jenaOp, LogicalPlan subplan, QueryProcContext ctxt)	This function assumes that the given operator comes from a SERVICE clause that had a nonempty PARAMS part, and it produces a plan with a gpAdd operator as root and the given subplan as input to this root operator.
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForTriplePattern(org.apache.jena.sparql.algebra.op.OpTriple pattern, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForUnfold(org.apache.jena.sparql.algebra.op.OpUnfold jenaOp, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForUnion(org.apache.jena.sparql.algebra.op.OpUnion jenaOp, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForUnion(org.apache.jena.sparql.algebra.op.OpUnion jenaOp, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForValues(org.apache.jena.sparql.algebra.op.OpTable jenaOp, QueryProcContext ctxt)
protected LogicalPlan	ExhaustiveSourcePlannerImpl.createRequestSubPlan(org.apache.jena.graph.Triple tp, FederationMember fm)
protected LogicalPlan	ExhaustiveSourcePlannerImpl.createSubPlanForTP(org.apache.jena.graph.Triple tp, QueryProcContext ctxt)
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, QueryProcContext ctxt)
protected abstract Pair<LogicalPlan,SourcePlanningStats>	SourcePlannerBase.createSourceAssignment(org.apache.jena.sparql.algebra.Op jenaOp, QueryProcContext ctxt)
final Pair<LogicalPlan,SourcePlanningStats>	SourcePlannerBase.createSourceAssignment(Query query, QueryProcContext ctxt)

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

Modifier and Type	Method	Description
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForServiceWithParams(OpServiceWithParams jenaOp, LogicalPlan subplan, QueryProcContext ctxt)	This function assumes that the given operator comes from a SERVICE clause that had a nonempty PARAMS part, and it produces a plan with a gpAdd operator as root and the given subplan as input to this root operator.
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)