public String debugString() {
StringBuilder out = new StringBuilder();
out.append(
Objects.toStringHelper(this)
.add("grouping_exprs", Expr.debugString(groupingExprs_))
.add("aggregate_exprs", Expr.debugString(aggregateExprs_))
.add(
"intermediate_tuple",
(intermediateTupleDesc_ == null) ? "null" : intermediateTupleDesc_.debugString())
.add(
"output_tuple",
(outputTupleDesc_ == null) ? "null" : outputTupleDesc_.debugString())
.toString());
return out.toString();
}
/**
* Returns a tuple descriptor for the aggregation/analytic's intermediate or final result,
* depending on whether isOutputTuple is true or false. Also updates the appropriate substitution
* map, and creates and registers auxiliary equality predicates between the grouping slots and the
* grouping exprs.
*/
private TupleDescriptor createTupleDesc(Analyzer analyzer, boolean isOutputTuple) {
TupleDescriptor result =
analyzer
.getDescTbl()
.createTupleDescriptor(tupleDebugName() + (isOutputTuple ? "-out" : "-intermed"));
List<Expr> exprs =
Lists.newArrayListWithCapacity(groupingExprs_.size() + aggregateExprs_.size());
exprs.addAll(groupingExprs_);
exprs.addAll(aggregateExprs_);
int aggregateExprStartIndex = groupingExprs_.size();
for (int i = 0; i < exprs.size(); ++i) {
Expr expr = exprs.get(i);
SlotDescriptor slotDesc = analyzer.addSlotDescriptor(result);
slotDesc.setLabel(expr.toSql());
slotDesc.setStats(ColumnStats.fromExpr(expr));
Preconditions.checkState(expr.getType().isValid());
slotDesc.setType(expr.getType());
if (i < aggregateExprStartIndex) {
// register equivalence between grouping slot and grouping expr;
// do this only when the grouping expr isn't a constant, otherwise
// it'll simply show up as a gratuitous HAVING predicate
// (which would actually be incorrect if the constant happens to be NULL)
if (!expr.isConstant()) {
analyzer.createAuxEquivPredicate(new SlotRef(slotDesc), expr.clone());
}
} else {
Preconditions.checkArgument(expr instanceof FunctionCallExpr);
FunctionCallExpr aggExpr = (FunctionCallExpr) expr;
if (aggExpr.isMergeAggFn()) {
slotDesc.setLabel(aggExpr.getChild(0).toSql());
} else {
slotDesc.setLabel(aggExpr.toSql());
}
// count(*) is non-nullable.
if (aggExpr.getFnName().getFunction().equals("count")) {
// TODO: Consider making nullability a property of types or of builtin agg fns.
// row_number, rank, and dense_rank are non-nullable as well.
slotDesc.setIsNullable(false);
}
if (!isOutputTuple) {
Type intermediateType = ((AggregateFunction) aggExpr.fn_).getIntermediateType();
if (intermediateType != null) {
// Use the output type as intermediate if the function has a wildcard decimal.
if (!intermediateType.isWildcardDecimal()) {
slotDesc.setType(intermediateType);
} else {
Preconditions.checkState(expr.getType().isDecimal());
}
}
}
}
}
String prefix = (isOutputTuple ? "result " : "intermediate ");
LOG.trace(prefix + " tuple=" + result.debugString());
return result;
}