throw new AssertionError(e);
}
}
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
final JavaTypeFactory typeFactory = implementor.getTypeFactory();
final BlockBuilder builder = new BlockBuilder();
final EnumerableRel child = (EnumerableRel) getChild();
final Result result = implementor.visitChild(this, 0, child, pref);
Expression childExp =
builder.append(
"child",
result.block);
final RelDataType inputRowType = getChild().getRowType();
final PhysType physType =
PhysTypeImpl.of(
typeFactory, getRowType(), pref.preferCustom());
// final Enumerable<Employee> child = <<child impl>>;
// Function1<Employee, Integer> keySelector =
// new Function1<Employee, Integer>() {
// public Integer apply(Employee a0) {
// return a0.deptno;
// }
// };
// Function1<Employee, Object[]> accumulatorInitializer =
// new Function1<Employee, Object[]>() {
// public Object[] apply(Employee a0) {
// return new Object[] {0, 0};
// }
// };
// Function2<Object[], Employee, Object[]> accumulatorAdder =
// new Function2<Object[], Employee, Object[]>() {
// public Object[] apply(Object[] a1, Employee a0) {
// a1[0] = ((Integer) a1[0]) + 1;
// a1[1] = ((Integer) a1[1]) + a0.salary;
// return a1;
// }
// };
// Function2<Integer, Object[], Object[]> resultSelector =
// new Function2<Integer, Object[], Object[]>() {
// public Object[] apply(Integer a0, Object[] a1) {
// return new Object[] { a0, a1[0], a1[1] };
// }
// };
// return childEnumerable
// .groupBy(
// keySelector, accumulatorInitializer, accumulatorAdder,
// resultSelector);
//
// or, if key has 0 columns,
//
// return childEnumerable
// .aggregate(
// accumulatorInitializer.apply(),
// accumulatorAdder,
// resultSelector);
//
// with a slightly different resultSelector; or if there are no aggregate
// functions
//
// final Enumerable<Employee> child = <<child impl>>;
// Function1<Employee, Integer> keySelector =
// new Function1<Employee, Integer>() {
// public Integer apply(Employee a0) {
// return a0.deptno;
// }
// };
// EqualityComparer<Employee> equalityComparer =
// new EqualityComparer<Employee>() {
// boolean equal(Employee a0, Employee a1) {
// return a0.deptno;
// }
// };
// return child
// .distinct(equalityComparer);
final PhysType inputPhysType = result.physType;
ParameterExpression parameter =
Expressions.parameter(inputPhysType.getJavaRowType(), "a0");
final PhysType keyPhysType =
inputPhysType.project(
BitSets.toList(groupSet), JavaRowFormat.LIST);
final int keyArity = groupSet.cardinality();
final Expression keySelector =
builder.append(
"keySelector",
inputPhysType.generateSelector(
parameter,
BitSets.toList(groupSet),
keyPhysType.getFormat()));
final List<AggImpState> aggs =
new ArrayList<AggImpState>(aggCalls.size());
for (int i = 0; i < aggCalls.size(); i++) {
AggregateCall call = aggCalls.get(i);
aggs.add(new AggImpState(i, call, false));
}
// Function0<Object[]> accumulatorInitializer =
// new Function0<Object[]>() {
// public Object[] apply() {
// return new Object[] {0, 0};
// }
// };
final List<Expression> initExpressions =
new ArrayList<Expression>();
final BlockBuilder initBlock = new BlockBuilder();
final List<Type> aggStateTypes = new ArrayList<Type>();
for (final AggImpState agg : aggs) {
agg.context =
new AggContext() {
public Aggregation aggregation() {
return agg.call.getAggregation();
}
public RelDataType returnRelType() {
return agg.call.type;
}
public Type returnType() {
return EnumUtil.javaClass(typeFactory, returnRelType());
}
public List<? extends RelDataType> parameterRelTypes() {
return EnumUtil.fieldRowTypes(inputRowType, null,
agg.call.getArgList());
}
public List<? extends Type> parameterTypes() {
return EnumUtil.fieldTypes(typeFactory,
parameterRelTypes());
}
};
List<Type> state =
agg.implementor.getStateType(agg.context);
if (state.isEmpty()) {
continue;
}
aggStateTypes.addAll(state);
final List<Expression> decls =
new ArrayList<Expression>(state.size());
for (int i = 0; i < state.size(); i++) {
String aggName = "a" + agg.aggIdx;
if (OptiqPrepareImpl.DEBUG) {
aggName = Util.toJavaId(agg.call.getAggregation().getName(), 0)
.substring("ID$0$".length()) + aggName;
}
Type type = state.get(i);
ParameterExpression pe =
Expressions.parameter(type,
initBlock.newName(aggName + "s" + i));
initBlock.add(Expressions.declare(0, pe, null));
decls.add(pe);
}
agg.state = decls;
initExpressions.addAll(decls);
agg.implementor.implementReset(agg.context,
new AggResultContextImpl(initBlock, decls));
}
final PhysType accPhysType =
PhysTypeImpl.of(
typeFactory,
typeFactory.createSyntheticType(aggStateTypes));
initBlock.add(accPhysType.record(initExpressions));
final Expression accumulatorInitializer =
builder.append(