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(boolean mayReduce, 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(boolean mayReduce, 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.createPlanWithMinus(boolean mayReduce, LogicalPlan subPlan1, LogicalPlan subPlan2, Iterable<QueryPlanProperty> qpInfo)	Creates a LogicalPlan with a LogicalOpMinus as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(boolean mayReduce, 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(boolean mayReduce, 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(boolean mayReduce, 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(boolean mayReduce, 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(boolean mayReduce, 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(boolean mayReduce, 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.createPlanWithMinus(boolean mayReduce, LogicalPlan subPlan1, LogicalPlan subPlan2, Iterable<QueryPlanProperty> qpInfo)	Creates a LogicalPlan with a LogicalOpMinus as root operator and the given plans as its subplans.
static LogicalPlan	LogicalPlanUtils.createPlanWithMultiwayJoin(boolean mayReduce, 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(boolean mayReduce, 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(boolean mayReduce, 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(boolean mayReduce, 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	LogicalPlanWithoutResult	This class represents a logical plan that produces the empty result.
class	LogicalPlanWithUnaryRootImpl

Fields in se.liu.ida.hefquin.engine.queryplan.logical.impl declared as LogicalPlan

Modifier and Type	Field	Description
protected static final LogicalPlan	LogicalPlanWithoutResult.instance

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

Modifier and Type	Method	Description
static LogicalPlan	LogicalPlanWithoutResult.getInstance()
LogicalPlan	LogicalPlanWithBinaryRootImpl.getSubPlan(int i)
LogicalPlan	LogicalPlanWithNaryRootImpl.getSubPlan(int i)
LogicalPlan	LogicalPlanWithNullaryRootImpl.getSubPlan(int i)
LogicalPlan	LogicalPlanWithoutResult.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

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

Modifier and Type	Field	Description
protected final LogicalPlan	ApplyVocabularyMappings.Worker.inputPlan
protected LogicalPlan	ApplyVocabularyMappings.Worker.rewrittenPlan

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	ApplyVocabularyMappings.Worker.getRewrittenPlan()
LogicalPlan	HeuristicsBasedLogicalOptimizerImpl.optimize(LogicalPlan inputPlan, boolean keepNaryOperators, QueryProcContext ctxt)
static LogicalPlan	ApplyVocabularyMappings.rewriteReqOf(SPARQLGraphPattern pattern, FederationMember fm, boolean mayReduce)	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.

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

Modifier	Constructor	Description
	Worker(LogicalPlan inputPlan)

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
protected LogicalPlan	FilterPushDown.Worker.createdPlan
protected LogicalPlan	ProjectPushDown.Worker.createdPlan
protected final LogicalPlan	FilterPushDown.Worker.inputPlan
protected final LogicalPlan	ProjectPushDown.Worker.inputPlan
protected LogicalPlan	MergeRequests.Worker.returnPlan
protected final LogicalPlan	FilterPushDown.Worker.subPlanUnderFilter
protected final LogicalPlan	ProjectPushDown.Worker.subPlanUnderProject

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

Modifier and Type	Field	Description
protected final List<LogicalPlan>	MergeRequests.Worker.rewrittenSubPlans

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)
protected LogicalPlan	RemoveSubPlansWithEmptyResults._apply(LogicalPlan inputPlan)
LogicalPlan	CardinalityBasedJoinOrderingBase.apply(LogicalPlan inputPlan)
LogicalPlan	FilterPushDown.apply(LogicalPlan inputPlan)
LogicalPlan	GreedyBasedReordering.apply(LogicalPlan inputPlan)
LogicalPlan	MergeRequests.apply(LogicalPlan inputPlan)
LogicalPlan	ProjectPushDown.apply(LogicalPlan inputPlan)
LogicalPlan	PullUpLtgOverJoin.apply(LogicalPlan inputPlan)
LogicalPlan	PullUpLtgOverUnion.apply(LogicalPlan inputPlan)
LogicalPlan	PushJoinUnderUnionWithRequests.apply(LogicalPlan inputPlan)
LogicalPlan	RemovePairsOfG2lAndL2g.apply(LogicalPlan inputPlan)
LogicalPlan	RemoveSubPlansWithEmptyResults.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	ProjectPushDown.applyToPlanWithProjectAsRootOperator(LogicalOpProject projectOp, LogicalPlan subPlanUnderProject, LogicalPlan inputPlan)
protected LogicalPlan	GreedyBasedReordering.constructBinaryPlan(boolean mayReduce, 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 LogicalOpGPAdd, or a LogicalOpGPOptAdd.
protected LogicalPlan	ProjectPushDown.createPlanForAddOpUnderProject(LogicalOpProject parentProjectOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp, LogicalPlan inputPlan)	Pushes a project operator below a gpAdd or gpOptAdd operator.
protected LogicalPlan	FilterPushDown.createPlanForBindUnderFilter(LogicalOpFilter filterOp, LogicalOpBind bindOp, LogicalPlan subPlanUnderBind, LogicalPlan inputPlan)
protected LogicalPlan	ProjectPushDown.createPlanForBindUnderProject(LogicalOpProject projectOp, LogicalOpBind bindOp, LogicalPlan subPlanUnderBind, LogicalPlan inputPlan)	Attempts to push a project operator below a bind operator.
protected LogicalPlan	FilterPushDown.createPlanForFilterUnderFilter(LogicalOpFilter parentFilterOp, LogicalOpFilter childFilterOp, LogicalPlan subPlanUnderChildFilterOp)
protected LogicalPlan	ProjectPushDown.createPlanForFixedSolMapUnderProject(LogicalOpProject projectOp, LogicalOpFixedSolMap fixedSolMapOp, LogicalPlan inputPlan)	Applies a project operator to a fixed solution mapping operator.
protected LogicalPlan	ProjectPushDown.createPlanForJoinLikeOpUnderProject(LogicalOpProject projectOp, LogicalPlan subPlanUnderProject, LogicalPlan inputPlan)	Pushes a projection below a n-ary operator by splitting required variables per branch.
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	ProjectPushDown.createPlanForL2GOrG2LUnderProject(LogicalOpProject projectOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp)	Assumes that the given child operator is either a LogicalOpLocalToGlobal or a LogicalOpGlobalToLocal.
protected LogicalPlan	FilterPushDown.createPlanForLeftJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan nonoptSubPlan, LogicalPlan optSubPlan, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForMinusUnderFilter(LogicalOpFilter filterOp, LogicalOpMinus op, LogicalPlan subPlanUnderFilter)
protected LogicalPlan	FilterPushDown.createPlanForMultiwayLeftJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
protected LogicalPlan	ProjectPushDown.createPlanForProjectUnderProject(LogicalOpProject parentProjectOp, LogicalOpProject childProjectOp, LogicalPlan subPlanUnderChildProjectOp)	Merges a parent and child project operator into a single project operator.
protected LogicalPlan	FilterPushDown.createPlanForRequestUnderFilter(LogicalOpFilter filterOp, LogicalOpRequest<?,?> reqOp, LogicalPlan inputPlan)
protected LogicalPlan	ProjectPushDown.createPlanForRequestUnderProject(LogicalOpProject projectOp, LogicalOpRequest<?,?> reqOp, LogicalPlan inputPlan)	Pushing a project operator into request operator is not possible yet TODO #570
protected LogicalPlan	FilterPushDown.createPlanForUnaryOpUnderFilter(LogicalOpFilter filterOp, UnaryLogicalOp op, LogicalPlan subPlanUnderOp)
protected LogicalPlan	ProjectPushDown.createPlanForUnaryOpUnderProject(LogicalOpProject projectOp, UnaryLogicalOp op, LogicalPlan subPlanUnderOp)	Returns a plan in which the given project operator is pushed under the given unary operator, with the subplan underneath being a version of the given subplan in which the project push down heuristic has been applied recursively.
protected LogicalPlan	FilterPushDown.createPlanForUnfoldUnderFilter(LogicalOpFilter filterOp, LogicalOpUnfold unfoldOp, LogicalPlan subPlanUnderUnfold, LogicalPlan inputPlan)
protected LogicalPlan	ProjectPushDown.createPlanForUnfoldUnderProject(LogicalOpProject projectOp, LogicalOpUnfold unfoldOp, LogicalPlan subPlanUnderUnfold, LogicalPlan inputPlan)	Attempts to push a project operator below an unfold operator.
protected LogicalPlan	FilterPushDown.createPlanForUnionUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter)
protected LogicalPlan	ProjectPushDown.createPlanForUnionUnderProject(LogicalOpProject projectOp, LogicalPlan subPlanUnderProject)	Pushes the project operator into each subplan under the union operator.
protected LogicalPlan	MergeRequests.createPlanWithSingleRequestOp(SPARQLGraphPattern p, boolean mayReduce, FederationMember fm)
protected static LogicalPlan	PullUpLtgOverUnion.extractLtgOverNaryOp(LogicalPlan inputPlan)
LogicalPlan	FilterPushDown.Worker.getCreatedPlan()
LogicalPlan	ProjectPushDown.Worker.getCreatedPlan()
LogicalPlan	MergeRequests.Worker.getRewrittenPlan()
protected LogicalPlan	MergeRequests.mergeSPARQLRequestsViaJoin(FederationMember fm, boolean mayReduce, 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, boolean mayReduce)
protected LogicalPlan	GreedyBasedReordering.reorderSubPlans(boolean mayReduce, LogicalPlan inputPlan)
protected LogicalPlan	PushJoinUnderUnionWithRequests.rewrite(boolean mayReduce, LogicalPlan unionPlan, List<LogicalPlan> subPlansAsInput)
LogicalPlan	UnionPullUp.rewritePlanWithJoinOverUnion(boolean mayReduce, 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(boolean mayReduce, 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(boolean mayReduce, 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)
protected LogicalPlan	RemoveSubPlansWithEmptyResults._apply(LogicalPlan inputPlan)
LogicalPlan	CardinalityBasedJoinOrderingBase.apply(LogicalPlan inputPlan)
LogicalPlan	FilterPushDown.apply(LogicalPlan inputPlan)
LogicalPlan	GreedyBasedReordering.apply(LogicalPlan inputPlan)
LogicalPlan	MergeRequests.apply(LogicalPlan inputPlan)
LogicalPlan	ProjectPushDown.apply(LogicalPlan inputPlan)
LogicalPlan	PullUpLtgOverJoin.apply(LogicalPlan inputPlan)
LogicalPlan	PullUpLtgOverUnion.apply(LogicalPlan inputPlan)
LogicalPlan	PushJoinUnderUnionWithRequests.apply(LogicalPlan inputPlan)
LogicalPlan	RemovePairsOfG2lAndL2g.apply(LogicalPlan inputPlan)
LogicalPlan	RemoveSubPlansWithEmptyResults.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	ProjectPushDown.applyToPlanWithProjectAsRootOperator(LogicalOpProject projectOp, LogicalPlan subPlanUnderProject, 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 Set<org.apache.jena.sparql.core.Var>	ProjectPushDown.computeJoinVars(LogicalPlan joinPlan)	Determines the set of all join variables between the subplans of the given plan, where a join variable is a variable (certain or possible) that occurs in at least two subplan.
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 LogicalOpGPAdd, or a LogicalOpGPOptAdd.
protected LogicalPlan	ProjectPushDown.createPlanForAddOpUnderProject(LogicalOpProject parentProjectOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp, LogicalPlan inputPlan)	Pushes a project operator below a gpAdd or gpOptAdd operator.
protected LogicalPlan	FilterPushDown.createPlanForBindUnderFilter(LogicalOpFilter filterOp, LogicalOpBind bindOp, LogicalPlan subPlanUnderBind, LogicalPlan inputPlan)
protected LogicalPlan	ProjectPushDown.createPlanForBindUnderProject(LogicalOpProject projectOp, LogicalOpBind bindOp, LogicalPlan subPlanUnderBind, LogicalPlan inputPlan)	Attempts to push a project operator below a bind operator.
protected LogicalPlan	FilterPushDown.createPlanForFilterUnderFilter(LogicalOpFilter parentFilterOp, LogicalOpFilter childFilterOp, LogicalPlan subPlanUnderChildFilterOp)
protected LogicalPlan	ProjectPushDown.createPlanForFixedSolMapUnderProject(LogicalOpProject projectOp, LogicalOpFixedSolMap fixedSolMapOp, LogicalPlan inputPlan)	Applies a project operator to a fixed solution mapping operator.
protected LogicalPlan	ProjectPushDown.createPlanForJoinLikeOpUnderProject(LogicalOpProject projectOp, LogicalPlan subPlanUnderProject, LogicalPlan inputPlan)	Pushes a projection below a n-ary operator by splitting required variables per branch.
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	ProjectPushDown.createPlanForL2GOrG2LUnderProject(LogicalOpProject projectOp, UnaryLogicalOp childOp, LogicalPlan subPlanUnderChildOp)	Assumes that the given child operator is either a LogicalOpLocalToGlobal or a LogicalOpGlobalToLocal.
protected LogicalPlan	FilterPushDown.createPlanForLeftJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan nonoptSubPlan, LogicalPlan optSubPlan, LogicalPlan inputPlan)
protected LogicalPlan	FilterPushDown.createPlanForMinusUnderFilter(LogicalOpFilter filterOp, LogicalOpMinus op, LogicalPlan subPlanUnderFilter)
protected LogicalPlan	FilterPushDown.createPlanForMultiwayLeftJoinUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
protected LogicalPlan	ProjectPushDown.createPlanForProjectUnderProject(LogicalOpProject parentProjectOp, LogicalOpProject childProjectOp, LogicalPlan subPlanUnderChildProjectOp)	Merges a parent and child project operator into a single project operator.
protected LogicalPlan	FilterPushDown.createPlanForRequestUnderFilter(LogicalOpFilter filterOp, LogicalOpRequest<?,?> reqOp, LogicalPlan inputPlan)
protected LogicalPlan	ProjectPushDown.createPlanForRequestUnderProject(LogicalOpProject projectOp, LogicalOpRequest<?,?> reqOp, LogicalPlan inputPlan)	Pushing a project operator into request operator is not possible yet TODO #570
protected LogicalPlan	FilterPushDown.createPlanForUnaryOpUnderFilter(LogicalOpFilter filterOp, UnaryLogicalOp op, LogicalPlan subPlanUnderOp)
protected LogicalPlan	ProjectPushDown.createPlanForUnaryOpUnderProject(LogicalOpProject projectOp, UnaryLogicalOp op, LogicalPlan subPlanUnderOp)	Returns a plan in which the given project operator is pushed under the given unary operator, with the subplan underneath being a version of the given subplan in which the project push down heuristic has been applied recursively.
protected LogicalPlan	FilterPushDown.createPlanForUnfoldUnderFilter(LogicalOpFilter filterOp, LogicalOpUnfold unfoldOp, LogicalPlan subPlanUnderUnfold, LogicalPlan inputPlan)
protected LogicalPlan	ProjectPushDown.createPlanForUnfoldUnderProject(LogicalOpProject projectOp, LogicalOpUnfold unfoldOp, LogicalPlan subPlanUnderUnfold, LogicalPlan inputPlan)	Attempts to push a project operator below an unfold operator.
protected LogicalPlan	FilterPushDown.createPlanForUnionUnderFilter(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter)
protected LogicalPlan	ProjectPushDown.createPlanForUnionUnderProject(LogicalOpProject projectOp, LogicalPlan subPlanUnderProject)	Pushes the project operator into each subplan under the union operator.
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 boolean	RemoveSubPlansWithEmptyResults.isProvablyEmpty(LogicalPlan plan)	Returns true if, according to the cardinality estimate that has been determined for the given plan, the plan is guaranteed to produce an empty result.
protected LogicalPlan	FilterPushDown.pushToNonOptSubPlan(org.apache.jena.sparql.expr.ExprList filterExprsWithoutAND, LogicalPlan nonoptSubPlan, org.apache.jena.sparql.expr.ExprList toBeKept, boolean mayReduce)
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(boolean mayReduce, LogicalPlan inputPlan)
protected LogicalPlan	PushJoinUnderUnionWithRequests.rewrite(boolean mayReduce, LogicalPlan unionPlan, List<LogicalPlan> subPlansAsInput)
LogicalPlan	UnionPullUp.rewritePlanWithUnaryRootAndUnionChild(boolean mayReduce, 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, boolean mayReduce, 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(boolean mayReduce, LogicalPlan unionPlan, List<LogicalPlan> subPlansAsInput)
LogicalPlan	UnionPullUp.rewritePlanWithJoinOverUnion(boolean mayReduce, 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(boolean mayReduce, 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
	Worker(LogicalOpFilter filterOp, LogicalPlan subPlanUnderFilter, LogicalPlan inputPlan)
	Worker(LogicalOpProject projectOp, LogicalPlan subPlanUnderProject, LogicalPlan inputPlan)

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

Modifier	Constructor	Description
	Worker(List<LogicalPlan> rewrittenSubPlans, boolean mayReduce)

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, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlan(org.apache.jena.sparql.algebra.Op jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlan(org.apache.jena.sparql.algebra.Op jenaOp, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ExhaustiveSourcePlannerImpl.createPlanForBGP(org.apache.jena.sparql.algebra.op.OpBGP bgpOp, QueryProcContext ctxt, boolean mayReduce)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForBGP(org.apache.jena.sparql.algebra.op.OpBGP pattern, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForBGP(org.apache.jena.sparql.core.BasicPattern pattern, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForBGP(BGP bgp, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForBind(org.apache.jena.sparql.algebra.op.OpExtend jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForDistinct(org.apache.jena.sparql.algebra.op.OpDistinct jenaOp, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForFilter(org.apache.jena.sparql.algebra.op.OpFilter jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForFilter(org.apache.jena.sparql.algebra.op.OpFilter jenaOp, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForJoin(List<org.apache.jena.sparql.algebra.Op> ops, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForJoin(org.apache.jena.sparql.algebra.op.OpJoin jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForJoin(org.apache.jena.sparql.algebra.op.OpJoin jenaOp, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpConditional jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpConditional jenaOp, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpLeftJoin jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForLeftJoin(org.apache.jena.sparql.algebra.op.OpLeftJoin jenaOp, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForMinus(org.apache.jena.sparql.algebra.op.OpMinus jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForOpTable(org.apache.jena.sparql.algebra.op.OpTable opTable)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForProject(org.apache.jena.sparql.algebra.op.OpProject jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForSequence(org.apache.jena.sparql.algebra.op.OpSequence jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForServicePattern(org.apache.jena.sparql.algebra.op.OpService jenaOp, boolean mayReduce, 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, boolean mayReduce, 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, boolean mayReduce, FederationMember fm)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForUnfold(org.apache.jena.sparql.algebra.op.OpUnfold jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForUnion(org.apache.jena.sparql.algebra.op.OpUnion jenaOp, boolean mayReduce, QueryProcContext ctxt)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.createPlanForUnion(org.apache.jena.sparql.algebra.op.OpUnion jenaOp, boolean mayReduce, 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, boolean mayReduce)
protected LogicalPlan	ExhaustiveSourcePlannerImpl.createSubPlanForTP(org.apache.jena.graph.Triple tp, QueryProcContext ctxt, boolean mayReduce)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayJoin(boolean mayReduce, LogicalPlan... subPlans)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayJoin(List<LogicalPlan> subPlans, boolean mayReduce)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayLeftJoin(LogicalPlan leftSubPlan, LogicalPlan rightSubPlan, boolean mayReduce)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayUnion(boolean mayReduce, 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, boolean mayReduce, 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(boolean mayReduce, LogicalPlan... subPlans)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayLeftJoin(LogicalPlan leftSubPlan, LogicalPlan rightSubPlan, boolean mayReduce)
protected LogicalPlan	ServiceClauseBasedSourcePlannerImpl.mergeIntoMultiwayUnion(boolean mayReduce, 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, boolean mayReduce)