org.eigenbase.rel.rules
Class PushProjector

java.lang.Object
  org.eigenbase.rel.rules.PushProjector

public class PushProjector
extends Object

PushProjector is a utility class used to perform operations used in push projection rules.

Pushing is particularly interesting in the case of join, because there are multiple inputs. Generally an expression can be pushed down to a particular input if it depends upon no other inputs. If it can be pushed down to both sides, it is pushed down to the left.

Sometimes an expression needs to be split before it can be pushed down. To flag that an expression cannot be split, specify a rule that it must be preserved. Such an expression will be pushed down intact to one of the inputs, or not pushed down at all.

Version:

$Id: //open/dev/farrago/src/org/eigenbase/rel/rules/PushProjector.java#15 $

Author:

Zelaine Fong

Nested Class Summary

static interface	PushProjector.ExprCondition A functor that replies true or false for a given expression.
private class	PushProjector.InputSpecialOpFinder Visitor which builds a bitmap of the inputs used by an expressions, as well as locating expressions corresponding to special operators.
static class	PushProjector.OperatorExprCondition An expression condition that evaluates to true if the expression is a call to one of a set of operators.
private class	PushProjector.RefAndExprConverter Walks an expression tree, replacing input refs with new values to reflect projection and converting special expressions to field references.

Field Summary

(package private) BitSet	childBitmap Bitmap containing the fields in the RelNode that the projection is being pushed past, if the RelNode is not a join.
(package private) RelDataTypeField[]	childFields Fields from the RelNode that the projection is being pushed past
(package private) List<RexNode>	childPreserveExprs Expressions referenced in the projection/filter that should be preserved.
private RelNode	childRel
(package private) int	nChildFields Number of fields in the RelNode that the projection is being pushed past
(package private) int	nFields Number of fields in the RelNode that the projection is being pushed past, if the RelNode is not a join.
(package private) int	nFieldsRight Number of fields in the right hand side of a join, in the case where the projection is being pushed past a join.
(package private) int	nProject Number of fields being projected.
(package private) int	nRightProject Number of fields being projected from the right hand side of a join, in the case where the projection is being pushed past a join.
private int	nSysFields Number of system fields.
(package private) int	nSystemProject Number of system fields being projected.
private RexNode	origFilter
private ProjectRel	origProj
(package private) RexNode[]	origProjExprs Original projection expressions
private PushProjector.ExprCondition	preserveExprCondition
(package private) BitSet	projRefs Bitmap containing the references in the original projection
(package private) RexBuilder	rexBuilder Rex builder used to create new expressions.
(package private) BitSet	rightBitmap Bitmap containing the fields in the right hand side of a join, in the case where the projection is being pushed past a join.
(package private) List<RexNode>	rightPreserveExprs Expressions referenced in the projection/filter that should be preserved, corresponding to expressions on the right hand side of the join, if the projection is being pushed past a join.

Constructor Summary

PushProjector(ProjectRel origProj, RexNode origFilter, RelNode childRel, PushProjector.ExprCondition preserveExprCondition)
Creates a PushProjector object for pushing projects past a RelNode.

Method Summary

ProjectRel	convertProject(RexNode defaultExpr) Decomposes a projection to the input references referenced by a projection and a filter, either of which is optional.
RexNode	convertRefsAndExprs(RexNode rex, RelDataTypeField[] destFields, int[] adjustments) Clones an expression tree and walks through it, adjusting each RexInputRef index by some amount, and converting expressions that need to be preserved to field references.
ProjectRel	createNewProject(RelNode projChild, int[] adjustments) Creates a new projection based on the original projection, adjusting all input refs using an adjustment array passed in.
ProjectRel	createProjectRefsAndExprs(RelNode projChild, boolean adjust, boolean rightSide) Creates a projection based on the inputs specified in a bitmap and the expressions that need to be preserved.
int[]	getAdjustments() Determines how much each input reference needs to be adjusted as a result of projection
boolean	locateAllRefs() Locates all references found in either the projection expressions a filter, as well as references to expressions that should be preserved.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

origProj

private final ProjectRel origProj

origFilter

private final RexNode origFilter

childRel

private final RelNode childRel

preserveExprCondition

private final PushProjector.ExprCondition preserveExprCondition

origProjExprs

final RexNode[] origProjExprs

Original projection expressions

childFields

final RelDataTypeField[] childFields

Fields from the RelNode that the projection is being pushed past

nChildFields

final int nChildFields

Number of fields in the RelNode that the projection is being pushed past

projRefs

final BitSet projRefs

Bitmap containing the references in the original projection

childBitmap

final BitSet childBitmap

Bitmap containing the fields in the RelNode that the projection is being pushed past, if the RelNode is not a join. If the RelNode is a join, then the fields correspond to the left hand side of the join.

rightBitmap

BitSet rightBitmap

Bitmap containing the fields in the right hand side of a join, in the case where the projection is being pushed past a join. Not used otherwise.

nFields

final int nFields

Number of fields in the RelNode that the projection is being pushed past, if the RelNode is not a join. If the RelNode is a join, then this is the number of fields in the left hand side of the join.

The identity nChildFields == nSysFields + nFields + nFieldsRight holds. nFields does not include nSysFields. The output of a join looks like this:

 | nSysFields | nFields | nFieldsRight |
 

The output of a single-input rel looks like this:

 | nSysFields | nFields |
 

nFieldsRight

final int nFieldsRight

Number of fields in the right hand side of a join, in the case where the projection is being pushed past a join. Always 0 otherwise.

nSysFields

private final int nSysFields

Number of system fields. System fields appear at the start of a join, before the first field from the left input.

childPreserveExprs

final List<RexNode> childPreserveExprs

Expressions referenced in the projection/filter that should be preserved. In the case where the projection is being pushed past a join, then the list only contains the expressions corresponding to the left hand side of the join.

rightPreserveExprs

final List<RexNode> rightPreserveExprs

Expressions referenced in the projection/filter that should be preserved, corresponding to expressions on the right hand side of the join, if the projection is being pushed past a join. Empty list otherwise.

nSystemProject

int nSystemProject

Number of system fields being projected.

nProject

int nProject

Number of fields being projected. In the case where the projection is being pushed past a join, the number of fields being projected from the left hand side of the join.

nRightProject

int nRightProject

Number of fields being projected from the right hand side of a join, in the case where the projection is being pushed past a join. 0 otherwise.

rexBuilder

final RexBuilder rexBuilder

Rex builder used to create new expressions.

Constructor Detail

PushProjector

public PushProjector(ProjectRel origProj,
                     RexNode origFilter,
                     RelNode childRel,
                     PushProjector.ExprCondition preserveExprCondition)

Creates a PushProjector object for pushing projects past a RelNode.

Parameters:

origProj - the original projection that is being pushed; may be null if the projection is implied as a result of a projection having been trivially removed

origFilter - the filter that the projection must also be pushed past, if applicable

childRel - the RelNode that the projection is being pushed past

preserveExprCondition - condition for whether an expression should be preserved in the projection

Method Detail

convertProject

public ProjectRel convertProject(RexNode defaultExpr)

Decomposes a projection to the input references referenced by a projection and a filter, either of which is optional. If both are provided, the filter is underneath the project.

Creates a projection containing all input references as well as preserving any special expressions. Converts the original projection and/or filter to reference the new projection. Then, finally puts on top, a final projection corresponding to the original projection.

Parameters:

defaultExpr - expression to be used in the projection if no fields or special columns are selected

Returns:

the converted projection if it makes sense to push elements of the projection; otherwise returns null

locateAllRefs

public boolean locateAllRefs()

Locates all references found in either the projection expressions a filter, as well as references to expressions that should be preserved. Based on that, determines whether pushing the projection makes sense.

Returns:

true if all inputs from the child that the projection is being pushed past are referenced in the projection/filter and no special preserve expressions are referenced; in that case, it does not make sense to push the projection

createProjectRefsAndExprs

public ProjectRel createProjectRefsAndExprs(RelNode projChild,
                                            boolean adjust,
                                            boolean rightSide)

Creates a projection based on the inputs specified in a bitmap and the expressions that need to be preserved. The expressions are appended after the input references.

Parameters:

projChild - child that the projection will be created on top of

adjust - if true, need to create new projection expressions; otherwise, the existing ones are reused

rightSide - if true, creating a projection for the right hand side of a join

Returns:

created projection

getAdjustments

public int[] getAdjustments()

Determines how much each input reference needs to be adjusted as a result of projection

Returns:

array indicating how much each input needs to be adjusted by

convertRefsAndExprs

public RexNode convertRefsAndExprs(RexNode rex,
                                   RelDataTypeField[] destFields,
                                   int[] adjustments)

Clones an expression tree and walks through it, adjusting each RexInputRef index by some amount, and converting expressions that need to be preserved to field references.

Parameters:

rex - the expression

destFields - fields that the new expressions will be referencing

adjustments - the amount each input reference index needs to be adjusted by

Returns:

modified expression tree

createNewProject

public ProjectRel createNewProject(RelNode projChild,
                                   int[] adjustments)

Creates a new projection based on the original projection, adjusting all input refs using an adjustment array passed in. If there was no original projection, create a new one that selects every field from the underlying rel

Parameters:

projChild - child of the new project

adjustments - array indicating how much each input reference should be adjusted by

Returns:

the created projection