io.crate.planner.operators

Interface LogicalPlan

All Superinterfaces:

Plan

All Known Implementing Classes:

Count, Get, GroupHashAggregate, HashAggregate, Insert, MultiPhase, RelationBoundary, RootRelationBoundary, Union

public interface LogicalPlan
extends Plan

LogicalPlan is a tree of "Operators" This is a representation of the logical order of operators that need to be executed to produce a correct result. #build(PlannerContext, ProjectionBuilder, int, int, OrderBy, Integer, Row, Map) is used to create the actual "physical" execution plan. A Operator is something like Limit, OrderBy, HashAggregate, Join, Union, Collect

     select x, y, z from t1 where x = 10 order by x limit 10:

     Limit 10
        |
     Order By x
         |
     Collect [x, y, z]
 

#build(PlannerContext, ProjectionBuilder, int, int, OrderBy, Integer, Row, Map) is called on the "root" and flows down. Each time each operator may provide "hints" to the children so that they can decide to eagerly apply parts of the operations This allows us to create execution plans as follows::

     select x, y, z from t1 where order by x limit 10;


          Merge
         /  limit10
       /         \
     Collect     Collect
     limit 10    limit 10

 

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	LogicalPlan.Builder

Method Summary

Modifier and Type	Method and Description
<C,R> R	accept(LogicalPlanVisitor<C,R> visitor, C context)
java.util.List<AbstractTableRelation>	baseTables()
ExecutionPlan	build(PlannerContext plannerContext, ProjectionBuilder projectionBuilder, int limit, int offset, OrderBy order, java.lang.Integer pageSizeHint, Row params, SubQueryResults subQueryResults) Uses the current shard allocation information to create a physical execution plan.
java.util.Map<LogicalPlan,SelectSymbol>	dependencies() SubQueries that this plan depends on to be able to execute it.
long	estimatedRowSize() Returns an estimation of the size (in bytes) of each row returned by the plan.
default void	execute(DependencyCarrier executor, PlannerContext plannerContext, RowConsumer consumer, Row params, SubQueryResults subQueryResults)
java.util.Map<Symbol,Symbol>	expressionMapping() A mapping from from symbol to symbol.
long	numExpectedRows()
java.util.List<Symbol>	outputs()
default boolean	preferShardProjections() Indicates if the operators which are added on top of this LogicalPlan should operate on a shard level.
LogicalPlan	tryOptimize(LogicalPlan pushDown, io.crate.planner.operators.SymbolMapper mapper) Tried to optimize the plan and its dependencies to execute more efficiently.

Methods inherited from interface io.crate.planner.Plan

executeBulk

Method Detail

tryOptimize

@Nullable
LogicalPlan tryOptimize(@Nullable
                                  LogicalPlan pushDown,
                                  io.crate.planner.operators.SymbolMapper mapper)

Tried to optimize the plan and its dependencies to execute more efficiently. This is done by creating optimized operators or "pushing down" parts of the plan. Optimized operators For example: Aggregate(count(*)) + Collect => Count Push Down Tries to "push-down" a LogicalPlan to this plan or the children of this plan. A push-down is an optimization which changes the plan by performing operations earlier in the plan tree. Ideally, it makes the plan execute more efficiently. For example, pushing down an *Order*:

       *Order*                   Union
          |                     /     \
          |                    /       \
        Union              *Order*  *Order*
       /     \                |        |
      /       \      =>       |        |
   Collect   Order          Collect  Order
               |                       |
               |                       |
            Collect                 Collect
 

Then combining two Order(s):

        Union                  Union
       /     \                /     \
      /       \              /       \
   Order   *Order*        Order   *Order*
     |        |             |        |
     |        |      =>     |        |
   Order   *Order*       Collect  Collect
              |
              |
           Collect
 

Parameters:

pushDown - The LogicalPlan which gets "pushed down". null if currently no plan gets pushed. If null, recurses to find other push down candidates.

mapper - a function used to map symbols from the previous source to the new source. For example in a Join: If the OrderBy that is above of a join is moved beneath the join on one side the orderBySymbols must be changed to be based on the new outputs (For example, from Field[t2.x] to Reference[x]. To accomplish that, the Join operator can pass on an appropriate SymbolMapper when calling tryOptimize on its sources.

Returns:

A new LogicalPlan or null if rewriting/optimizing is not possible.

build

ExecutionPlan build(PlannerContext plannerContext,
                    ProjectionBuilder projectionBuilder,
                    int limit,
                    int offset,
                    @Nullable
                    OrderBy order,
                    @Nullable
                    java.lang.Integer pageSizeHint,
                    Row params,
                    SubQueryResults subQueryResults)

Uses the current shard allocation information to create a physical execution plan.
limit, offset, order can be passed from one operator to another. Depending on the operators implementation. Operator may choose to make use of this information, but can also ignore it.

outputs

java.util.List<Symbol> outputs()

preferShardProjections

default boolean preferShardProjections()

Indicates if the operators which are added on top of this LogicalPlan should operate on a shard level. Operating on a shard level increases parallelism.

expressionMapping

java.util.Map<Symbol,Symbol> expressionMapping()

A mapping from from symbol to symbol. This is used across relation boundaries to map parent expression to source expression Example:

     select tt.bb from
          (select t.b + t.b as bb from t) tt

 expressionMapping
      tt.bb -> t.b + t.b
 

baseTables

java.util.List<AbstractTableRelation> baseTables()

dependencies

java.util.Map<LogicalPlan,SelectSymbol> dependencies()

SubQueries that this plan depends on to be able to execute it. valuesBySubQuery in execute(DependencyCarrier, PlannerContext, RowConsumer, Row, SubQueryResults) must receive 1 entry per selectSymbol contained in the dependencies here. Note that currently MultiPhase is injected into the operator-tree to declare the dependencies. It's not necessary for each operator to expose it's own SelectSymbols; propagation is usually sufficient.

numExpectedRows

long numExpectedRows()

estimatedRowSize

long estimatedRowSize()

Returns an estimation of the size (in bytes) of each row returned by the plan. The estimation is based on the average size of a row of the concrete table(s) of the plan.

execute

default void execute(DependencyCarrier executor,
                     PlannerContext plannerContext,
                     RowConsumer consumer,
                     Row params,
                     SubQueryResults subQueryResults)

Specified by:

execute in interface Plan

accept

<C,R> R accept(LogicalPlanVisitor<C,R> visitor,
               C context)