com.bigdata.bop.solutions

Class GroupByRewriter

java.lang.Object

com.bigdata.bop.solutions.GroupByRewriter

All Implemented Interfaces:

IVariableFactory, IGroupByRewriteState, Serializable

public class GroupByRewriter
extends Object
implements IGroupByRewriteState, IVariableFactory, Serializable

Utility class simplifies an aggregation operator through a rewrite.

Version:

$Id$ TODO Modify to rewrite AVERAGE as SUM()/COUNT() in preparation for a more distributed / parallel evaluation when the aggregate does not use DISTINCT and when there are no dependencies among the aggregate expressions (e.g., SUM(x)+1 is fine, as is SUM(x)+SUM(y), but SUM(x+AVG(x)) introduces a dependency which prevents us from optimizing the aggregation using per-group incremental pipelined evaluation).

Author:

Bryan Thompson

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
GroupByRewriter(IGroupByRewriteState rewrittenState) Special construct creates a distinct instance of each IAggregate in order to avoid side-effects in the internal state of the IAggregate functions when evaluated in different contexts (e.g., a pipelined aggregation subquery).
GroupByRewriter(IGroupByState groupByState)

Method Summary

Methods

Modifier and Type	Method and Description
LinkedHashMap<IAggregate<?>,IVariable<?>>	getAggExpr() The set of all unique IAggregate expressions with Binds onto anonymous variables.
IConstraint[]	getHaving2() A modified version of the original HAVING expression which has the same semantics (and null iff the original was null or empty).
IValueExpression<?>[]	getSelect2() A modified version of the original SELECT expression which has the same semantics.
static IConstraint	rewrite(IConstraint e, IVariableFactory f, LinkedHashMap<IAggregate<?>,IVariable<?>> aggExpr) Rewrite an IConstraint.
static IValueExpression<?>	rewrite(IValueExpression<?> e, IVariableFactory f, LinkedHashMap<IAggregate<?>,IVariable<?>> aggExpr) Rewrite an IValueExpression from a SELECT or HAVING clause.
String	toString()
IVariable<?>	var() Return a new anonymous variable (this is overridden by some unit tests in order to have predictable variable names).

Methods inherited from class java.lang.Object

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

Constructor Detail

GroupByRewriter

public GroupByRewriter(IGroupByRewriteState rewrittenState)

Special construct creates a distinct instance of each IAggregate in order to avoid side-effects in the internal state of the IAggregate functions when evaluated in different contexts (e.g., a pipelined aggregation subquery).

Parameters:

rewrittenState -

GroupByRewriter

public GroupByRewriter(IGroupByState groupByState)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

getAggExpr

public LinkedHashMap<IAggregate<?>,IVariable<?>> getAggExpr()

The set of all unique IAggregate expressions with Binds onto anonymous variables. Any internal IAggregate have been lifted out and will appear before any IAggregates which use them.

Specified by:

getAggExpr in interface IGroupByRewriteState

getSelect2

public IValueExpression<?>[] getSelect2()

A modified version of the original SELECT expression which has the same semantics. However, the modified select expressions DO NOT contain any IAggregate functions. All IAggregate functions have been lifted out into aggExpr.

Specified by:

getSelect2 in interface IGroupByRewriteState

getHaving2

public IConstraint[] getHaving2()

A modified version of the original HAVING expression which has the same semantics (and null iff the original was null or empty). However, the modified select expressions DO NOT contain any IAggregate functions. All IAggregate functions have been lifted out into aggExpr.

Specified by:

getHaving2 in interface IGroupByRewriteState

rewrite

public static IConstraint rewrite(IConstraint e,
                  IVariableFactory f,
                  LinkedHashMap<IAggregate<?>,IVariable<?>> aggExpr)

Rewrite an IConstraint.

Note: Rewriting a constraint require us to effectively clone the original constraint. I've hacked this in two ways. First, I assume that the inner value expression is e.get(0). Second, I wrap the rewritten value expression with #newConstraint(IValueExpression). That factory is responsible for the type of the returned IConstraint.

rewrite

public static IValueExpression<?> rewrite(IValueExpression<?> e,
                          IVariableFactory f,
                          LinkedHashMap<IAggregate<?>,IVariable<?>> aggExpr)

Rewrite an IValueExpression from a SELECT or HAVING clause. If a rewrite is performed, then the modified expression is returned. Otherwise the original expression is returned. If an aggregation expression is lifted out by the rewrite, then it is added to aggExpr.

Parameters:

e - The IValueExpression.

f - A factory for anonymous variables.

aggExpr - A map associating each unique IAggregate expression lifted out of the an IValueExpression with an anonymous variable on which the value of the IAggregate lifted out the of IValueExpression will be bound when that IAggregate is evaluated.

Returns:

The (possibly rewritten) IValueExpression.

var

public IVariable<?> var()

Return a new anonymous variable (this is overridden by some unit tests in order to have predictable variable names).

Specified by:

var in interface IVariableFactory