@Override
public Object process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
throws SemanticException {
GroupByOperator op = (GroupByOperator) nd;
ColumnPrunerProcCtx cppCtx = (ColumnPrunerProcCtx) ctx;
List<String> colLists = new ArrayList<String>();
GroupByDesc conf = op.getConf();
ArrayList<ExprNodeDesc> keys = conf.getKeys();
for (ExprNodeDesc key : keys) {
colLists = Utilities.mergeUniqElems(colLists, key.getCols());
}
ArrayList<AggregationDesc> aggrs = conf.getAggregators();
for (AggregationDesc aggr : aggrs) {
ArrayList<ExprNodeDesc> params = aggr.getParameters();
for (ExprNodeDesc param : params) {
colLists = Utilities.mergeUniqElems(colLists, param.getCols());
}
}
int groupingSetPosition = conf.getGroupingSetPosition();
if (groupingSetPosition >= 0) {
List<String> cols = cppCtx.genColLists(op);
String groupingColumn = conf.getOutputColumnNames().get(groupingSetPosition);
if (!cols.contains(groupingColumn)) {
conf.getOutputColumnNames().remove(groupingSetPosition);
if (op.getSchema() != null) {
op.getSchema().getSignature().remove(groupingSetPosition);
}
}
}
cppCtx.getPrunedColLists().put(op, colLists);
return null;
}
public Object process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
throws SemanticException {
RewriteCanApplyCtx canApplyCtx = (RewriteCanApplyCtx) ctx;
for (Node node : stack) {
// For table scan operator,
// check ReferencedColumns to make sure that only the index column is
// selected for the following operators.
if (node instanceof TableScanOperator) {
TableScanOperator ts = (TableScanOperator) node;
canApplyCtx.setTableScanOperator(ts);
List<String> selectColumns = ts.getConf().getReferencedColumns();
if (selectColumns == null || selectColumns.size() != 1) {
canApplyCtx.setSelClauseColsFetchException(true);
return null;
} else {
canApplyCtx.setIndexKey(selectColumns.get(0));
}
} else if (node instanceof SelectOperator) {
// For select operators in the stack, we just add them
if (canApplyCtx.getSelectOperators() == null) {
canApplyCtx.setSelectOperators(new ArrayList<SelectOperator>());
}
canApplyCtx.getSelectOperators().add((SelectOperator) node);
} else if (node instanceof GroupByOperator) {
if (canApplyCtx.getGroupByOperators() == null) {
canApplyCtx.setGroupByOperators(new ArrayList<GroupByOperator>());
}
// According to the pre-order,
// the first GroupbyOperator is the one before RS
// and the second one is the one after RS
GroupByOperator operator = (GroupByOperator) node;
canApplyCtx.getGroupByOperators().add(operator);
if (!canApplyCtx.isQueryHasGroupBy()) {
canApplyCtx.setQueryHasGroupBy(true);
GroupByDesc conf = operator.getConf();
List<AggregationDesc> aggrList = conf.getAggregators();
if (aggrList == null
|| aggrList.size() != 1
|| !("count".equals(aggrList.get(0).getGenericUDAFName()))) {
// In the current implementation, we make sure that only count is
// in the function
canApplyCtx.setAggFuncIsNotCount(true);
return null;
} else {
List<ExprNodeDesc> para = aggrList.get(0).getParameters();
if (para == null || para.size() == 0 || para.size() > 1) {
canApplyCtx.setAggParameterException(true);
return null;
} else {
ExprNodeDesc expr =
ExprNodeDescUtils.backtrack(
para.get(0), operator, (Operator<OperatorDesc>) stack.get(0));
if (!(expr instanceof ExprNodeColumnDesc)) {
canApplyCtx.setAggParameterException(true);
return null;
}
}
}
}
}
}
return null;
}
