/** Build smap AVG -> SUM/COUNT; assumes that select list and having clause have been analyzed. */
private Expr.SubstitutionMap createAvgSMap(
ArrayList<FunctionCallExpr> aggExprs, Analyzer analyzer)
throws AnalysisException, AuthorizationException {
Expr.SubstitutionMap result = new Expr.SubstitutionMap();
for (FunctionCallExpr aggExpr : aggExprs) {
if (!aggExpr.getFnName().getFunction().equals("avg")) continue;
// Transform avg(TIMESTAMP) to cast(avg(cast(TIMESTAMP as DOUBLE)) as TIMESTAMP)
CastExpr inCastExpr = null;
if (aggExpr.getChild(0).type_.getPrimitiveType() == PrimitiveType.TIMESTAMP) {
inCastExpr = new CastExpr(ColumnType.DOUBLE, aggExpr.getChild(0).clone(null), false);
}
List<Expr> sumInputExprs =
Lists.newArrayList(
aggExpr.getChild(0).type_.getPrimitiveType() == PrimitiveType.TIMESTAMP
? inCastExpr
: aggExpr.getChild(0).clone(null));
List<Expr> countInputExpr = Lists.newArrayList(aggExpr.getChild(0).clone(null));
FunctionCallExpr sumExpr =
new FunctionCallExpr("sum", new FunctionParams(aggExpr.isDistinct(), sumInputExprs));
FunctionCallExpr countExpr =
new FunctionCallExpr("count", new FunctionParams(aggExpr.isDistinct(), countInputExpr));
ArithmeticExpr divExpr =
new ArithmeticExpr(ArithmeticExpr.Operator.DIVIDE, sumExpr, countExpr);
if (aggExpr.getChild(0).type_.getPrimitiveType() == PrimitiveType.TIMESTAMP) {
CastExpr outCastExpr = new CastExpr(ColumnType.TIMESTAMP, divExpr, false);
outCastExpr.analyze(analyzer);
result.addMapping(aggExpr, outCastExpr);
} else {
divExpr.analyze(analyzer);
result.addMapping(aggExpr, divExpr);
}
}
LOG.debug("avg smap: " + result.debugString());
return result;
}
/*
* Create a map from COUNT([ALL]) -> zeroifnull(COUNT([ALL])) if
* i) There is no GROUP-BY, and
* ii) There are other distinct aggregates to be evaluated.
* This transformation is necessary for COUNT to correctly return 0 for empty
* input relations.
*/
private Expr.SubstitutionMap createCountAllMap(List<FunctionCallExpr> aggExprs, Analyzer analyzer)
throws AuthorizationException, AnalysisException {
Expr.SubstitutionMap scalarCountAllMap = new Expr.SubstitutionMap();
if (groupingExprs_ != null && !groupingExprs_.isEmpty()) {
// There are grouping expressions, so no substitution needs to be done.
return scalarCountAllMap;
}
com.google.common.base.Predicate<FunctionCallExpr> isNotDistinctPred =
new com.google.common.base.Predicate<FunctionCallExpr>() {
public boolean apply(FunctionCallExpr expr) {
return !expr.isDistinct();
}
};
if (Iterables.all(aggExprs, isNotDistinctPred)) {
// Only [ALL] aggs, so no substitution needs to be done.
return scalarCountAllMap;
}
com.google.common.base.Predicate<FunctionCallExpr> isCountPred =
new com.google.common.base.Predicate<FunctionCallExpr>() {
public boolean apply(FunctionCallExpr expr) {
return expr.getFnName().getFunction().equals("count");
}
};
Iterable<FunctionCallExpr> countAllAggs =
Iterables.filter(aggExprs, Predicates.and(isCountPred, isNotDistinctPred));
for (FunctionCallExpr countAllAgg : countAllAggs) {
// Replace COUNT(ALL) with zeroifnull(COUNT(ALL))
ArrayList<Expr> zeroIfNullParam = Lists.newArrayList(countAllAgg.clone(null));
FunctionCallExpr zeroIfNull = new FunctionCallExpr("zeroifnull", zeroIfNullParam);
zeroIfNull.analyze(analyzer);
scalarCountAllMap.addMapping(countAllAgg, zeroIfNull);
}
return scalarCountAllMap;
}
