Uses of Interface
se.liu.ida.hefquin.engine.queryplan.physical.PhysicalPlan

Packages that use PhysicalPlan

Package	Description
se.liu.ida.hefquin.engine.queryplan.physical
se.liu.ida.hefquin.engine.queryplan.physical.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.compiler
se.liu.ida.hefquin.engine.queryproc.impl.planning
se.liu.ida.hefquin.engine.queryproc.impl.poptimizer
se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.cardinality
se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.costmodel
se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.simple
se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.utils

Uses of PhysicalPlan in se.liu.ida.hefquin.engine.queryplan.physical

Subinterfaces of PhysicalPlan in se.liu.ida.hefquin.engine.queryplan.physical

Modifier and Type	Interface	Description
interface	PhysicalPlanWithBinaryRoot
interface	PhysicalPlanWithNaryRoot
interface	PhysicalPlanWithNullaryRoot
interface	PhysicalPlanWithUnaryRoot

Methods in se.liu.ida.hefquin.engine.queryplan.physical that return PhysicalPlan

Modifier and Type	Method	Description
PhysicalPlan	PhysicalPlan.getSubPlan(int i)
PhysicalPlan	PhysicalPlanWithUnaryRoot.getSubPlan()	Convenience method that always should return the same as what is returned by calling getSubPlan(int) with a value of 0.
PhysicalPlan	PhysicalPlanWithBinaryRoot.getSubPlan1()	Convenience method that always should return the same as what is returned by calling getSubPlan(int) with a value of 0.
PhysicalPlan	PhysicalPlanWithBinaryRoot.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.physical that return types with arguments of type PhysicalPlan

Modifier and Type	Method	Description
Iterator<PhysicalPlan>	PhysicalPlanWithNaryRoot.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.physical with parameters of type PhysicalPlan

Modifier and Type	Method	Description
void	PhysicalPlanWalker.PhysicalWalkerVisitor.walk(PhysicalPlan plan)
static void	PhysicalPlanWalker.walk(PhysicalPlan plan, PhysicalPlanVisitor beforeVisitor, PhysicalPlanVisitor afterVisitor)

Uses of PhysicalPlan in se.liu.ida.hefquin.engine.queryplan.physical.impl

Classes in se.liu.ida.hefquin.engine.queryplan.physical.impl that implement PhysicalPlan

Modifier and Type	Class	Description
class	PhysicalPlanWithBinaryRootImpl
class	PhysicalPlanWithNaryRootImpl
class	PhysicalPlanWithNullaryRootImpl
class	PhysicalPlanWithUnaryRootImpl

Fields in se.liu.ida.hefquin.engine.queryplan.physical.impl with type parameters of type PhysicalPlan

Modifier and Type	Field	Description
protected final List<PhysicalPlan>	PhysicalPlanWithNaryRootImpl.subPlans

Methods in se.liu.ida.hefquin.engine.queryplan.physical.impl that return PhysicalPlan

Modifier and Type	Method	Description
PhysicalPlan	PhysicalPlanWithBinaryRootImpl.getSubPlan(int i)
PhysicalPlan	PhysicalPlanWithNaryRootImpl.getSubPlan(int i)
PhysicalPlan	PhysicalPlanWithNullaryRootImpl.getSubPlan(int i)
PhysicalPlan	PhysicalPlanWithUnaryRootImpl.getSubPlan()
PhysicalPlan	PhysicalPlanWithUnaryRootImpl.getSubPlan(int i)
PhysicalPlan	PhysicalPlanWithBinaryRootImpl.getSubPlan1()
PhysicalPlan	PhysicalPlanWithBinaryRootImpl.getSubPlan2()

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

Modifier and Type	Method	Description
Iterator<PhysicalPlan>	PhysicalPlanWithNaryRootImpl.getSubPlans()

Methods in se.liu.ida.hefquin.engine.queryplan.physical.impl with parameters of type PhysicalPlan

Modifier and Type	Method	Description
static List<LogicalOpRequest<?,?>>	PhysicalOpParallelMultiLeftJoin.checkApplicability(PhysicalPlan[] children)	Checks whether a invalid reference LogicalOpMultiwayLeftJoin with the given list of physical plans can be implemented by the parallel multi-left-join (as captured by this physical operator).

Constructors in se.liu.ida.hefquin.engine.queryplan.physical.impl with parameters of type PhysicalPlan

Modifier	Constructor	Description
protected	PhysicalPlanWithBinaryRootImpl(BinaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan subPlan1, PhysicalPlan subPlan2)	Instead of creating such a plan directly using this constructor, use PhysicalPlanFactory.
protected	PhysicalPlanWithBinaryRootImpl(BinaryPhysicalOp rootOp, PhysicalPlan subPlan1, PhysicalPlan subPlan2)	Instead of creating such a plan directly using this constructor, use PhysicalPlanFactory.
protected	PhysicalPlanWithNaryRootImpl(NaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan... subPlans)	Instead of creating such a plan directly using this constructor, use PhysicalPlanFactory.
protected	PhysicalPlanWithNaryRootImpl(NaryPhysicalOp rootOp, PhysicalPlan... subPlans)	Instead of creating such a plan directly using this constructor, use PhysicalPlanFactory.
protected	PhysicalPlanWithUnaryRootImpl(UnaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan subPlan)	Instead of creating such a plan directly using this constructor, use PhysicalPlanFactory.
protected	PhysicalPlanWithUnaryRootImpl(UnaryPhysicalOp rootOp, PhysicalPlan subPlan)	Instead of creating such a plan directly using this constructor, use PhysicalPlanFactory.

Constructor parameters in se.liu.ida.hefquin.engine.queryplan.physical.impl with type arguments of type PhysicalPlan

Modifier	Constructor	Description
protected	PhysicalPlanWithNaryRootImpl(NaryPhysicalOp rootOp, List<PhysicalPlan> subPlans)	Instead of creating such a plan directly using this constructor, use PhysicalPlanFactory.
protected	PhysicalPlanWithNaryRootImpl(NaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, List<PhysicalPlan> subPlans)	Instead of creating such a plan directly using this constructor, use PhysicalPlanFactory.

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

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

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

Methods in se.liu.ida.hefquin.engine.queryplan.utils that return PhysicalPlan

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.
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlan(LogicalOperator lop, QueryPlanningInfo qpInfo, PhysicalPlan[] children, boolean keepMultiwayJoins)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanForMultiwayJoin(LogicalOpMultiwayJoin lop, QueryPlanningInfo qpInfo, PhysicalPlan[] children, boolean keepMultiwayJoins)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanForMultiwayLeftJoin(LogicalOpMultiwayLeftJoin lop, QueryPlanningInfo qpInfo, PhysicalPlan[] children, boolean keepMultiwayJoins)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanWithBinaryRoot(BinaryLogicalOp lop, QueryPlanningInfo qpInfo, PhysicalPlan child1, PhysicalPlan child2)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanWithNaryRoot(NaryLogicalOp lop, QueryPlanningInfo qpInfo, PhysicalPlan[] children, boolean keepMultiwayJoins)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanWithNullaryRoot(NullaryLogicalOp lop, QueryPlanningInfo qpInfo)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanWithUnaryRoot(UnaryLogicalOp lop, QueryPlanningInfo qpInfo, PhysicalPlan child)
static PhysicalPlan	PhysicalPlanFactory.createPlan(BinaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan subplan1, PhysicalPlan subplan2)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(LogicalOperator lop, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(LogicalOperator lop, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, List<PhysicalPlan> subplans)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NullaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(UnaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan subplan)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(BinaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan subplan1, PhysicalPlan subplan2)	Creates a physical plan with the given root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, List<PhysicalPlan> subplans)	Creates a physical plan with the given root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan... subplans)	Creates a physical plan with the given root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NullaryPhysicalOp rootOp, QueryPlanningInfo qpInfo)	Creates a physical plan with the given root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(PhysicalOperator pop, QueryPlanningInfo qpInfo, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the default physical operator for the given logical operator, as per LogicalToPhysicalOpConverter.
static PhysicalPlan	PhysicalPlanFactory.createPlan(PhysicalOperator pop, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the default physical operator for the given logical operator, as per LogicalToPhysicalOpConverter.
static PhysicalPlan	PhysicalPlanFactory.createPlan(UnaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan subplan)	Creates a physical plan with the given root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlanWithDefaultUnaryOpIfPossible(PhysicalPlan inputPlan, PhysicalPlan nextPlan, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop)	If the second of the two given plans is either a request, a filter with request, or a union over requests, then this function turns the request(s) into gpAdd operators with the first given plan as subplan.
static PhysicalPlan	PhysicalPlanFactory.createPlanWithJoin(PhysicalPlan subplan1, PhysicalPlan subplan2, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop)	Creates a plan with a binary join as root operator, using the default physical operator for such a join (as per the given LogicalToPhysicalOpConverter).
static PhysicalPlan	PhysicalPlanFactory.createPlanWithJoin(PhysicalPlan subplan1, PhysicalPlan subplan2, LogicalToPhysicalOpConverter lop2pop)	Creates a plan with a binary join as root operator, using the default physical operator for such a join (as per the given LogicalToPhysicalOpConverter).
static PhysicalPlan	PhysicalPlanFactory.createPlanWithRequest(DataRetrievalRequest req, FederationMember fm)	Creates a plan with a request operator as root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlanWithUnaryOpForUnionPlan(PhysicalPlan inputPlan, PhysicalPlan unionPlan, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop)	This function takes two physical plans as input, with the assumptions that the second of these plans i) has a union as its root operator and ii) every sub plan under this union is either a request or a filter with a request.
static PhysicalPlan	PhysicalPlanFactory.extractRequestAsPlan(LogicalOpGPAdd gpAdd)
static PhysicalPlan	PhysicalPlanFactory.extractRequestAsPlan(UnaryLogicalOp lop)
static PhysicalPlan	PhysicalPlanFactory.extractRequestAsPlan(PhysicalOpBindJoinBRTPF pop)
static PhysicalPlan	PhysicalPlanFactory.extractRequestAsPlan(PhysicalOpBindJoinSPARQL pop)
static PhysicalPlan	PhysicalPlanFactory.extractRequestAsPlan(PhysicalOpIndexNestedLoopsJoin pop)

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

Modifier and Type	Method	Description
static List<PhysicalPlan>	PhysicalPlanFactory.enumeratePlansWithUnaryOpFromReq(PhysicalOpRequest<?,?> req, PhysicalPlan subplan, LogicalToPhysicalOpConverter lop2pop)

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

Modifier and Type	Method	Description
static boolean	PhysicalPlanFactory.checkUnaryOpApplicableToUnionPlan(PhysicalPlan unionPlan)	Returns true if the given plan has a union operator as its root operator and all subplans under this union are of one of the following forms: i) a request, ii) a filter over a request, iii) an l2g operator over either a request or a filter with a request.
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlan(LogicalOperator lop, QueryPlanningInfo qpInfo, PhysicalPlan[] children, boolean keepMultiwayJoins)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanForMultiwayJoin(LogicalOpMultiwayJoin lop, QueryPlanningInfo qpInfo, PhysicalPlan[] children, boolean keepMultiwayJoins)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanForMultiwayLeftJoin(LogicalOpMultiwayLeftJoin lop, QueryPlanningInfo qpInfo, PhysicalPlan[] children, boolean keepMultiwayJoins)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanWithBinaryRoot(BinaryLogicalOp lop, QueryPlanningInfo qpInfo, PhysicalPlan child1, PhysicalPlan child2)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanWithNaryRoot(NaryLogicalOp lop, QueryPlanningInfo qpInfo, PhysicalPlan[] children, boolean keepMultiwayJoins)
protected PhysicalPlan	LogicalToPhysicalPlanConverterImpl.Worker.createPhysicalPlanWithUnaryRoot(UnaryLogicalOp lop, QueryPlanningInfo qpInfo, PhysicalPlan child)
static PhysicalPlan	PhysicalPlanFactory.createPlan(BinaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan subplan1, PhysicalPlan subplan2)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(LogicalOperator lop, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(LogicalOperator lop, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(UnaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, PhysicalPlan subplan)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(BinaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan subplan1, PhysicalPlan subplan2)	Creates a physical plan with the given root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan... subplans)	Creates a physical plan with the given root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(PhysicalOperator pop, QueryPlanningInfo qpInfo, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the default physical operator for the given logical operator, as per LogicalToPhysicalOpConverter.
static PhysicalPlan	PhysicalPlanFactory.createPlan(PhysicalOperator pop, PhysicalPlan... subplans)	Creates a physical plan in which the root operator is the default physical operator for the given logical operator, as per LogicalToPhysicalOpConverter.
static PhysicalPlan	PhysicalPlanFactory.createPlan(UnaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, PhysicalPlan subplan)	Creates a physical plan with the given root operator.
static PhysicalPlan	PhysicalPlanFactory.createPlanWithDefaultUnaryOpIfPossible(PhysicalPlan inputPlan, PhysicalPlan nextPlan, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop)	If the second of the two given plans is either a request, a filter with request, or a union over requests, then this function turns the request(s) into gpAdd operators with the first given plan as subplan.
static PhysicalPlan	PhysicalPlanFactory.createPlanWithJoin(PhysicalPlan subplan1, PhysicalPlan subplan2, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop)	Creates a plan with a binary join as root operator, using the default physical operator for such a join (as per the given LogicalToPhysicalOpConverter).
static PhysicalPlan	PhysicalPlanFactory.createPlanWithJoin(PhysicalPlan subplan1, PhysicalPlan subplan2, LogicalToPhysicalOpConverter lop2pop)	Creates a plan with a binary join as root operator, using the default physical operator for such a join (as per the given LogicalToPhysicalOpConverter).
static PhysicalPlan	PhysicalPlanFactory.createPlanWithUnaryOpForUnionPlan(PhysicalPlan inputPlan, PhysicalPlan unionPlan, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop)	This function takes two physical plans as input, with the assumptions that the second of these plans i) has a union as its root operator and ii) every sub plan under this union is either a request or a filter with a request.
BaseForTextBasedPlanPrinters.ExtPrintablePlan	TextBasedPhysicalPlanPrinterImpl.createPrintablePlan(PhysicalPlan p)
List<PlanPrinter.PrintablePlan>	TextBasedPhysicalPlanPrinterImpl.createPrintableSubPlans(PhysicalPlan p)
static List<PhysicalPlan>	PhysicalPlanFactory.enumeratePlansWithUnaryOpFromReq(PhysicalOpRequest<?,?> req, PhysicalPlan subplan, LogicalToPhysicalOpConverter lop2pop)
static ExpectedVariables[]	PhysicalPlanUtils.getExpectedVariables(PhysicalPlan... plans)	Returns an array of the ExpectedVariables objects of all given physical plans, in the order in which the plans are given.
static Set<org.apache.jena.sparql.core.Var>	PhysicalPlanUtils.intersectionOfAllVariables(PhysicalPlan... plans)	Returns an intersection of the sets of all variables (certain and possible) in all the given plans.
static Set<org.apache.jena.sparql.core.Var>	PhysicalPlanUtils.intersectionOfCertainVariables(PhysicalPlan... plans)	Returns an intersection of the sets of certain variables in all the given plans.
static Set<org.apache.jena.sparql.core.Var>	PhysicalPlanUtils.intersectionOfPossibleVariables(PhysicalPlan... plans)	Returns an intersection of the sets of possible variables in all the given plans.
void	PhysicalPlanPrinter.print(PhysicalPlan plan)	Prints the given plan to the given stream(s) that are stored in this printer.
void	PhysicalPlanPrinter.print(PhysicalPlan plan, PrintStream out)	Prints the given plan to the given stream.
void	TextBasedPhysicalPlanPrinterImpl.print(PhysicalPlan plan)
void	TextBasedPhysicalPlanPrinterImpl.print(PhysicalPlan plan, PrintStream out)
static Set<org.apache.jena.sparql.core.Var>	PhysicalPlanUtils.unionOfAllVariables(PhysicalPlan... plans)	Returns a set of all the variables (certain and possible) in all the given plans.
static Set<org.apache.jena.sparql.core.Var>	PhysicalPlanUtils.unionOfCertainVariables(PhysicalPlan plans)	Returns a set of all the certain variables in all the given plans.
static Set<org.apache.jena.sparql.core.Var>	PhysicalPlanUtils.unionOfPossibleVariables(PhysicalPlan... plans)	Returns a set of all the possible variables in all the given plans.

Method parameters in se.liu.ida.hefquin.engine.queryplan.utils with type arguments of type PhysicalPlan

Modifier and Type	Method	Description
static PhysicalPlan	PhysicalPlanFactory.createPlan(NaryLogicalOp rootOp, QueryPlanningInfo qpInfo, LogicalToPhysicalOpConverter lop2pop, List<PhysicalPlan> subplans)	Creates a physical plan in which the root operator is the physical operator that the given LogicalToPhysicalOpConverter returns for the given logical operator.
static PhysicalPlan	PhysicalPlanFactory.createPlan(NaryPhysicalOp rootOp, QueryPlanningInfo qpInfo, List<PhysicalPlan> subplans)	Creates a physical plan with the given root operator.

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

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

Modifier and Type	Method	Description
PhysicalPlan	QueryPlanningStats.getResultingPhysicalPlan()

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

Modifier and Type	Method	Description
Pair<PhysicalPlan,QueryPlanningStats>	QueryPlanner.createPlan(Query query, QueryProcContext ctxt)
Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizer.optimize(LogicalPlan initialPlan, QueryProcContext ctxt)

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

Modifier and Type	Method	Description
void	CardinalityEstimator.addCardinalities(PhysicalPlan... plans)	Annotates each of the given plans (including, recursively, each of their subplans) with estimates regarding their result cardinalities.
ExecutablePlan	QueryPlanCompiler.compile(PhysicalPlan qep)

Uses of PhysicalPlan 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 PhysicalPlan

Modifier and Type	Method	Description
protected Set<PhysicalPlan>	RequestBasedCardinalityEstimator.extractNullarySubPlans(PhysicalPlan... 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 PhysicalPlan

Modifier and Type	Method	Description
void	CardinalityEstimationWorker.addCardinalities(PhysicalPlan... 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(PhysicalPlan... plans)
void	RequestBasedCardinalityEstimator.addCardinalities(PhysicalPlan... plans)
void	RequestBasedCardinalityEstimator.addCardinalitiesForRequests(PhysicalPlan... 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(PhysicalPlan plan)	Assumes that all nullary subplans within the given plan are already annotated with a cardinality estimate.
protected Set<PhysicalPlan>	RequestBasedCardinalityEstimator.extractNullarySubPlans(PhysicalPlan... 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(PhysicalPlan plan, Set<PhysicalPlan> 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 PhysicalPlan

Modifier and Type	Method	Description
protected void	RequestBasedCardinalityEstimator.extractNullarySubPlans(PhysicalPlan plan, Set<PhysicalPlan> 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 PhysicalPlan in se.liu.ida.hefquin.engine.queryproc.impl.compiler

Fields in se.liu.ida.hefquin.engine.queryproc.impl.compiler with type parameters of type PhysicalPlan

Modifier and Type	Field	Description
protected final Map<PhysicalPlan,PushBasedPlanThread>	QueryPlanCompilerForPushBasedExecution.Worker.convertedSubPlans

Methods in se.liu.ida.hefquin.engine.queryproc.impl.compiler with parameters of type PhysicalPlan

Modifier and Type	Method	Description
protected PushBasedPlanThread	QueryPlanCompilerForPushBasedExecution.Worker._createThreads(PhysicalPlan qep, LinkedList<PushBasedPlanThread> tasks, ExecutionContext execCxt)
ExecutablePlan	QueryPlanCompilerForIteratorBasedExecution.compile(PhysicalPlan qep)
protected ResultElementIterator	QueryPlanCompilerForIteratorBasedExecution.compile(PhysicalPlan qep, ExecutionContext execCxt)
ExecutablePlan	QueryPlanCompilerForPushBasedExecution.compile(PhysicalPlan qep)
protected LinkedList<PushBasedPlanThread>	QueryPlanCompilerForPushBasedExecution.createThreads(PhysicalPlan qep, ExecutionContext execCxt)
void	QueryPlanCompilerForPushBasedExecution.Worker.createThreads(PhysicalPlan qep, LinkedList<PushBasedPlanThread> threads, ExecutionContext execCxt)

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

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

Modifier and Type	Method	Description
PhysicalPlan	QueryPlanningStatsImpl.getResultingPhysicalPlan()

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

Modifier and Type	Method	Description
Pair<PhysicalPlan,QueryPlanningStats>	QueryPlannerImpl.createPlan(Query query, QueryProcContext ctxt)

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

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

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

Fields in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer declared as PhysicalPlan

Modifier and Type	Field	Description
protected final PhysicalPlan	CardinalityEstimationException.plan
protected final PhysicalPlan	CostEstimationException.plan

Methods in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer that return PhysicalPlan

Modifier and Type	Method	Description
PhysicalPlan	CardinalityEstimationException.getPlan()	Returns the plan for which estimating the result cardinality failed with this exception.
PhysicalPlan	CostEstimationException.getPlan()	Returns the plan for which the cost estimation failed with this exception.

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

Modifier and Type	Method	Description
final Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizerBase.optimize(LogicalPlan lp, QueryProcContext ctxt)
protected abstract Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizerBase.optimize(PhysicalPlan initialPhysicalPlan, QueryProcContext ctxt)
Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizerWithoutOptimization.optimize(PhysicalPlan initialPlan, QueryProcContext ctxt)

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

Modifier and Type	Method	Description
CompletableFuture<Integer>	CardinalityEstimation.initiateCardinalityEstimation(PhysicalPlan plan)	Asynchronous method that initiates a process to estimate the cardinality of the result that will be produced by the given plan.
CompletableFuture<Double>	CostModel.initiateCostEstimation(PhysicalPlan p)
protected abstract Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizerBase.optimize(PhysicalPlan initialPhysicalPlan, QueryProcContext ctxt)
Pair<PhysicalPlan,PhysicalOptimizationStats>	PhysicalOptimizerWithoutOptimization.optimize(PhysicalPlan initialPlan, QueryProcContext ctxt)

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

Modifier	Constructor	Description
	CardinalityEstimationException(String message, Throwable cause, PhysicalPlan plan)
	CardinalityEstimationException(String message, PhysicalPlan plan)
	CardinalityEstimationException(Throwable cause, PhysicalPlan plan)
	CardinalityEstimationException(PhysicalPlan plan)
	CostEstimationException(String message, Throwable cause, PhysicalPlan plan)
	CostEstimationException(String message, PhysicalPlan plan)
	CostEstimationException(Throwable cause, PhysicalPlan plan)
	CostEstimationException(PhysicalPlan plan)

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

Fields in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.cardinality declared as PhysicalPlan

Modifier and Type	Field	Description
protected final PhysicalPlan	CardinalityEstimationImpl.WorkerForSubquery.plan
protected final PhysicalPlan	MinBasedCardinalityEstimationImpl.WorkerForUnion.plan
protected final PhysicalPlan	MinBasedCardinalityEstimationImpl.WorkerForJoin.plan1
protected final PhysicalPlan	MinBasedCardinalityEstimationImpl.WorkerForJoin.plan2

Fields in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.cardinality with type parameters of type PhysicalPlan

Modifier and Type	Field	Description
protected final Map<PhysicalPlan,CompletableFuture<Integer>>	CardinalityEstimationImpl.cache
protected final Map<PhysicalPlan,Map<org.apache.jena.sparql.core.Var,CompletableFuture<Integer>>>	VarSpecificCardinalityEstimationImpl.MyCache.map

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

Modifier and Type	Method	Description
CompletableFuture<Integer>	CardinalityEstimationImpl._initiateCardinalityEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	MinBasedCardinalityEstimationImpl._initiateCardinalityEstimation(PhysicalPlan plan)
protected CompletableFuture<Integer>	VarSpecificCardinalityEstimationImpl._initiateCardinalityEstimation(PhysicalPlan plan, org.apache.jena.sparql.core.Var v)
protected CompletableFuture<Integer>	VarSpecificCardinalityEstimationImpl._initiateJoinCardinalityEstimation(PhysicalPlan plan1, PhysicalPlan plan2, org.apache.jena.sparql.core.Var v)
protected CompletableFuture<Integer>	VarSpecificCardinalityEstimationImpl._initiateMultiwayUnionCardinalityEstimation(PhysicalPlan plan, org.apache.jena.sparql.core.Var v)
CompletableFuture<Integer>	VarSpecificCardinalityEstimationImpl.MyCache.get(PhysicalPlan plan, org.apache.jena.sparql.core.Var v)
final CompletableFuture<Integer>	CardinalityEstimationImpl.initiateCardinalityEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	VarSpecificCardinalityEstimation.initiateCardinalityEstimation(PhysicalPlan plan, org.apache.jena.sparql.core.Var v)	Asynchronous method that initiates a process to estimate the the variable-specific cardinality of the result that will be produced by the given plan.
CompletableFuture<Integer>	VarSpecificCardinalityEstimationImpl.initiateCardinalityEstimation(PhysicalPlan plan, org.apache.jena.sparql.core.Var v)
void	VarSpecificCardinalityEstimationImpl.MyCache.put(PhysicalPlan plan, org.apache.jena.sparql.core.Var v, CompletableFuture<Integer> future)

Constructors in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.cardinality with parameters of type PhysicalPlan

Modifier	Constructor	Description
	WorkerForJoin(CardinalityEstimation cardEstimate, PhysicalPlan plan1, PhysicalPlan plan2)
	WorkerForRequestOps(PhysicalPlan plan)
	WorkerForSubquery(PhysicalPlan plan)
	WorkerForUnion(CardinalityEstimation cardEstimate, PhysicalPlan plan)

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

Fields in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.costmodel with type parameters of type PhysicalPlan

Modifier and Type	Field	Description
protected final Map<PhysicalPlan,CompletableFuture<Double>>	CostModelImpl.cache

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

Modifier and Type	Method	Description
protected CompletableFuture<Double>	CostModelImpl._initiateCostEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	CFRBasedCostFunctionForPlan.aggregateValueForAllSubPlans(Set<PhysicalPlan> visitedPlan, CompletableFuture<Integer> futureForRoot, PhysicalPlan plan)
CompletableFuture<Integer>	CFRBasedParallelismCostFunctionForPlan.aggregateValueForAllSubPlans(Set<PhysicalPlan> visitedPlans, CompletableFuture<Integer> futureForRoot, PhysicalPlan plan)
protected CompletableFuture<Integer>	CFRBase.initiateCardinalityEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	CFRBasedCostFunctionForPlan.initiateCostEstimation(Set<PhysicalPlan> visitedPlans, PhysicalPlan plan)
CompletableFuture<Integer>	CFRNumberOfProcessedSolMaps.initiateCostEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	CFRNumberOfRequests.initiateCostEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	CFRNumberOfTermsShippedInRequests.initiateCostEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	CFRNumberOfTermsShippedInResponses.initiateCostEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	CFRNumberOfVarsShippedInRequests.initiateCostEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	CFRNumberOfVarsShippedInResponses.initiateCostEstimation(PhysicalPlan plan)
CompletableFuture<Integer>	CostFunctionForPlan.initiateCostEstimation(Set<PhysicalPlan> visitedPlans, PhysicalPlan plan)	A function for estimating the cost of a plan.
CompletableFuture<Integer>	CostFunctionForRootOp.initiateCostEstimation(PhysicalPlan plan)
CompletableFuture<Double>	CostModelImpl.initiateCostEstimation(PhysicalPlan plan)

Method parameters in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.costmodel with type arguments of type PhysicalPlan

Modifier and Type	Method	Description
CompletableFuture<Integer>	CFRBasedCostFunctionForPlan.aggregateValueForAllSubPlans(Set<PhysicalPlan> visitedPlan, CompletableFuture<Integer> futureForRoot, PhysicalPlan plan)
CompletableFuture<Integer>	CFRBasedParallelismCostFunctionForPlan.aggregateValueForAllSubPlans(Set<PhysicalPlan> visitedPlans, CompletableFuture<Integer> futureForRoot, PhysicalPlan plan)
CompletableFuture<Integer>	CFRBasedCostFunctionForPlan.initiateCostEstimation(Set<PhysicalPlan> visitedPlans, PhysicalPlan plan)
CompletableFuture<Integer>	CostFunctionForPlan.initiateCostEstimation(Set<PhysicalPlan> visitedPlans, PhysicalPlan plan)	A function for estimating the cost of a plan.

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

Fields in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.simple with type parameters of type PhysicalPlan

Modifier and Type	Field	Description
protected Map<Integer,Map<List<PhysicalPlan>,PhysicalPlan>>	DPBasedJoinPlanOptimizer.OptimalPlansPerStage.map
protected Map<Integer,Map<List<PhysicalPlan>,PhysicalPlan>>	DPBasedJoinPlanOptimizer.OptimalPlansPerStage.map
protected final List<PhysicalPlan>	CardinalityBasedGreedyJoinPlanOptimizerImpl.GreedyConstructionAlgorithm.subplans
protected final List<PhysicalPlan>	CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.subplans
protected final List<PhysicalPlan>	DPBasedJoinPlanOptimizer.DynamicProgrammingOptimizerImpl.subplans

Methods in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.simple that return PhysicalPlan

Modifier and Type	Method	Description
protected PhysicalPlan	CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.addNextBestJoin(PhysicalPlan currentPlan)	Creates a binary join plan with the given plan as left child and one of the remaining subplans (see CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.subplans) as the right child.
protected PhysicalPlan	CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.chooseFirstSubplan()	Compares all available subplans (see CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.subplans) in terms of their respective costs (as estimated by using the CostModelBasedGreedyJoinPlanOptimizerImpl.costModel) and returns the one with the lowest estimated cost.
PhysicalPlan	JoinPlanOptimizer.determineJoinPlan(List<PhysicalPlan> subplans, QueryProcContext ctxt)	Returns a plan that combines the given subplans using binary joins.
default PhysicalPlan	JoinPlanOptimizer.determineJoinPlan(PhysicalPlan[] subplans, QueryProcContext ctxt)	Returns a plan that combines the given subplans using binary joins.
final PhysicalPlan	JoinPlanOptimizerBase.determineJoinPlan(List<PhysicalPlan> subplans, QueryProcContext ctxt)
PhysicalPlan	RandomizedJoinPlanOptimizerImpl.determineJoinPlan(List<PhysicalPlan> subplans, QueryProcContext ctxt)
PhysicalPlan	DPBasedJoinPlanOptimizer.OptimalPlansPerStage.get(List<PhysicalPlan> subsets)
protected PhysicalPlan[]	SimpleJoinOrderingQueryOptimizer.getOptimizedSubPlans(PhysicalPlan plan, QueryProcContext ctxt)
PhysicalPlan	CardinalityBasedGreedyJoinPlanOptimizerImpl.GreedyConstructionAlgorithm.getResultingPlan()
PhysicalPlan	CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.getResultingPlan()
PhysicalPlan	DPBasedJoinPlanOptimizer.DynamicProgrammingOptimizerImpl.getResultingPlan()
PhysicalPlan	JoinPlanOptimizerBase.EnumerationAlgorithm.getResultingPlan()
PhysicalPlan	SimpleJoinOrderingQueryOptimizer.optimizePlan(PhysicalPlan plan, QueryProcContext ctxt)

Methods in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.simple that return types with arguments of type PhysicalPlan

Modifier and Type	Method	Description
protected List<PhysicalPlan>	CostModelBasedGreedyJoinPlanOptimizerImpl.createAllJoinPlans(PhysicalPlan leftOrChild, PhysicalPlan rightOrTop, LogicalToPhysicalOpConverter lop2pop)	Creates a list of join plans, including a (default) binary join of the given two plans as well as possible plans with unary (gpAdd-based) joins in which the first given plan is the child.
protected Map<Integer,List<PhysicalPlan>>	CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.createNextPossiblePlans(PhysicalPlan currentPlan)	Creates all possible binary join plans with the given plan as left child and one of the remaining subplans (see CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.subplans) as the right child, as well as plans with unary (gpAdd-based) joins with the given plan as the child.
Pair<PhysicalPlan,PhysicalOptimizationStats>	SimpleJoinOrderingQueryOptimizer.optimize(PhysicalPlan initialPlan, QueryProcContext ctxt)

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

Modifier and Type	Method	Description
void	DPBasedJoinPlanOptimizer.OptimalPlansPerStage.add(List<PhysicalPlan> subsets, PhysicalPlan plan)
protected PhysicalPlan	CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.addNextBestJoin(PhysicalPlan currentPlan)	Creates a binary join plan with the given plan as left child and one of the remaining subplans (see CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.subplans) as the right child.
protected List<PhysicalPlan>	CostModelBasedGreedyJoinPlanOptimizerImpl.createAllJoinPlans(PhysicalPlan leftOrChild, PhysicalPlan rightOrTop, LogicalToPhysicalOpConverter lop2pop)	Creates a list of join plans, including a (default) binary join of the given two plans as well as possible plans with unary (gpAdd-based) joins in which the first given plan is the child.
protected Map<Integer,List<PhysicalPlan>>	CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.createNextPossiblePlans(PhysicalPlan currentPlan)	Creates all possible binary join plans with the given plan as left child and one of the remaining subplans (see CostModelBasedGreedyJoinPlanOptimizerImpl.GreedyEnumerationAlgorithm.subplans) as the right child, as well as plans with unary (gpAdd-based) joins with the given plan as the child.
default PhysicalPlan	JoinPlanOptimizer.determineJoinPlan(PhysicalPlan[] subplans, QueryProcContext ctxt)	Returns a plan that combines the given subplans using binary joins.
protected List<LogicalOpRequest<?,?>>	CardinalityBasedGreedyJoinPlanOptimizerImpl.GreedyConstructionAlgorithm.extractAllRequestOpsFromSourceAssignment(PhysicalPlan plan)	Extracts all request operators from the given plan, assuming that this plan is a sub-plan of a source assignment (hence, assuming that this plan can only be either a single request, a filter over a request, or a union with requests).
protected PhysicalPlan[]	SimpleJoinOrderingQueryOptimizer.getOptimizedSubPlans(PhysicalPlan plan, QueryProcContext ctxt)
protected boolean	SimpleJoinOrderingQueryOptimizer.hasMultiwayJoinAsRoot(PhysicalPlan plan)
Pair<PhysicalPlan,PhysicalOptimizationStats>	SimpleJoinOrderingQueryOptimizer.optimize(PhysicalPlan initialPlan, QueryProcContext ctxt)
PhysicalPlan	SimpleJoinOrderingQueryOptimizer.optimizePlan(PhysicalPlan plan, QueryProcContext ctxt)

Method parameters in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.simple with type arguments of type PhysicalPlan

Modifier and Type	Method	Description
void	DPBasedJoinPlanOptimizer.OptimalPlansPerStage.add(List<PhysicalPlan> subsets, PhysicalPlan plan)
PhysicalPlan	JoinPlanOptimizer.determineJoinPlan(List<PhysicalPlan> subplans, QueryProcContext ctxt)	Returns a plan that combines the given subplans using binary joins.
final PhysicalPlan	JoinPlanOptimizerBase.determineJoinPlan(List<PhysicalPlan> subplans, QueryProcContext ctxt)
PhysicalPlan	RandomizedJoinPlanOptimizerImpl.determineJoinPlan(List<PhysicalPlan> subplans, QueryProcContext ctxt)
protected boolean	DPBasedJoinPlanOptimizer.determineOptimalCandidatesAtStageN(List<List<PhysicalPlan>> subsets, DPBasedJoinPlanOptimizer.OptimalPlansPerStage optPlansPerStage, boolean ignoreCartesianProductJoins, LogicalToPhysicalOpConverter lop2pop)	For each of the sets of plans in 'subsets', determines the best possible join plan and adds this best plan to 'optPlansPerStage'.
PhysicalPlan	DPBasedJoinPlanOptimizer.OptimalPlansPerStage.get(List<PhysicalPlan> subsets)
JoinPlanOptimizerBase.EnumerationAlgorithm	CardinalityBasedGreedyJoinPlanOptimizerImpl.initializeEnumerationAlgorithm(List<PhysicalPlan> subplans, QueryProcContext ctxt)
JoinPlanOptimizerBase.EnumerationAlgorithm	CostModelBasedGreedyJoinPlanOptimizerImpl.initializeEnumerationAlgorithm(List<PhysicalPlan> subplans, QueryProcContext ctxt)
protected JoinPlanOptimizerBase.EnumerationAlgorithm	DPBasedJoinPlanOptimizer.initializeEnumerationAlgorithm(List<PhysicalPlan> subplans, QueryProcContext ctxt)
protected abstract JoinPlanOptimizerBase.EnumerationAlgorithm	JoinPlanOptimizerBase.initializeEnumerationAlgorithm(List<PhysicalPlan> subplans, QueryProcContext ctxt)

Constructor parameters in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.simple with type arguments of type PhysicalPlan

Modifier	Constructor	Description
	DynamicProgrammingOptimizerImpl(List<PhysicalPlan> subplans, QueryProcContext ctxt)
	GreedyConstructionAlgorithm(List<PhysicalPlan> subplans, QueryProcContext ctxt)
	GreedyEnumerationAlgorithm(List<PhysicalPlan> subplans, QueryProcContext ctxt)

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

Fields in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.utils declared as PhysicalPlan

Modifier and Type	Field	Description
protected final PhysicalPlan	PhysicalPlanWithCost.plan

Methods in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.utils that return PhysicalPlan

Modifier and Type	Method	Description
PhysicalPlan	PhysicalPlanWithCost.getPlan()

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

Modifier and Type	Method	Description
static PhysicalPlanWithCost	PhysicalPlanWithCostUtils.annotatePlanWithCost(CostModel cm, PhysicalPlan plan)
static Integer[]	CardinalityEstimationUtils.getEstimates(CardinalityEstimation cardEstimate, PhysicalPlan... plans)	Initiates the cardinality estimation processes for all the given plans and, afterwards, waits for the resulting estimates and returns them.
static Double[]	CostEstimationUtils.getEstimates(CostModel costModel, PhysicalPlan... plans)	Initiates the cost estimation processes for all the given plans and, afterwards, waits for the resulting estimates and returns them.

Method parameters in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.utils with type arguments of type PhysicalPlan

Modifier and Type	Method	Description
static List<PhysicalPlanWithCost>	PhysicalPlanWithCostUtils.annotatePlansWithCost(CostModel cost, List<PhysicalPlan> plans)
static Integer[]	CardinalityEstimationUtils.getEstimates(CardinalityEstimation cardEstimate, List<PhysicalPlan> plans)	Initiates the cardinality estimation processes for all the plans in the given list and, afterwards, waits for the resulting estimates and returns them.
static Double[]	CostEstimationUtils.getEstimates(CostModel costModel, List<PhysicalPlan> plans)	Initiates the cost estimation processes for all the plans in the given list and, afterwards, waits for the resulting estimates and returns them.

Constructors in se.liu.ida.hefquin.engine.queryproc.impl.poptimizer.utils with parameters of type PhysicalPlan

Modifier	Constructor	Description
	PhysicalPlanWithCost(PhysicalPlan plan, double cost)