@SuppressWarnings("unchecked") private <T> Expression<T> normalize(Expression<T> expr) { if (expr instanceof FactoryExpression<?>) { return (Expression<T>) FactoryExpressionUtils.wrap((FactoryExpression<?>) expr); } else { return expr; } }
/** * @param projection * @return */ public static FactoryExpression<?> wrap(List<? extends Expression<?>> projection) { boolean usesFactoryExpressions = false; for (Expression<?> e : projection) { usesFactoryExpressions |= e instanceof FactoryExpression; } if (usesFactoryExpressions) { return wrap(new ArrayConstructorExpression( projection.toArray(new Expression[projection.size()]))); } else { return null; } }
@Override public Expression<?> visit(FactoryExpression<?> expr, @Nullable Void context) { List<Expression<?>> args = visit(expr.getArgs()); if (args.equals(expr.getArgs())) { return expr; } else { return FactoryExpressionUtils.wrap(expr, args); } }
/** * Get the results as a list * * @param expression * @return */ public <V> ResultTransformer<List<V>> list(FactoryExpression<V> expression) { final FactoryExpression<?> transformation = FactoryExpressionUtils.wrap(expression); List<Expression<?>> args = transformation.getArgs(); return new GroupByList<K, V>(key, args.toArray(new Expression<?>[args.size()])) { @Override protected V transform(Group group) { // XXX Isn't group.toArray() suitable here? List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1); for (int i = 1; i < groupExpressions.size(); i++) { args.add(group.getGroup(groupExpressions.get(i))); } return (V)transformation.newInstance(args.toArray()); } }; }
/** * Get the results as a closeable iterator * * @param expression * @return */ public <V> ResultTransformer<CloseableIterator<V>> iterate(FactoryExpression<V> expression) { final FactoryExpression<?> transformation = FactoryExpressionUtils.wrap(expression); List<Expression<?>> args = transformation.getArgs(); return new GroupByIterate<K, V>(key, args.toArray(new Expression<?>[args.size()])) { @Override protected V transform(Group group) { // XXX Isn't group.toArray() suitable here? List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1); for (int i = 1; i < groupExpressions.size(); i++) { args.add(group.getGroup(groupExpressions.get(i))); } return (V)transformation.newInstance(args.toArray()); } }; }
/** * Get the results as a map * * @param expression * @return */ public <V> ResultTransformer<Map<K, V>> as(FactoryExpression<V> expression) { final FactoryExpression<?> transformation = FactoryExpressionUtils.wrap(expression); List<Expression<?>> args = transformation.getArgs(); return new GroupByMap<K, V>(key, args.toArray(new Expression<?>[args.size()])) { @Override protected Map<K, V> transform(Map<K, Group> groups) { Map<K, V> results = new LinkedHashMap<K, V>((int) Math.ceil(groups.size()/0.75), 0.75f); for (Map.Entry<K, Group> entry : groups.entrySet()) { results.put(entry.getKey(), transform(entry.getValue())); } return results; } @SuppressWarnings("unchecked") protected V transform(Group group) { // XXX Isn't group.toArray() suitable here? List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1); for (int i = 1; i < groupExpressions.size(); i++) { args.add(group.getGroup(groupExpressions.get(i))); } return (V)transformation.newInstance(args.toArray()); } }; }
@SuppressWarnings("rawtypes") public <RT> Expression<RT> convert(Expression<RT> expr, boolean forOrder) { if (expandAnyPaths) { if (expr instanceof Path) { expr = (Expression)normalizePath((Path)expr); } else if (expr != null) { if (replaceVisitor == null) { replaceVisitor = new ReplaceVisitor() { public Expression<?> visit(Path<?> expr, @Nullable Void context) { return normalizePath(expr); } }; } expr = (Expression)expr.accept(replaceVisitor, null); } } if (expr instanceof ProjectionRole<?>) { return convert(((ProjectionRole) expr).getProjection(), forOrder); } else if (expr instanceof FactoryExpression<?> && !(expr instanceof FactoryExpressionAdapter<?>)) { return FactoryExpressionUtils.wrap((FactoryExpression<RT>)expr); } else { return expr; } }
@Override public Map<K, V> transform(Projectable projectable) { Map<K, Group> groups = new LinkedHashMap<K, Group>(); // create groups FactoryExpression<Tuple> expr = FactoryExpressionUtils.wrap(new QTuple(expressions)); boolean hasGroups = false; for (Expression<?> e : expr.getArgs()) { hasGroups |= e instanceof GroupExpression; } if (hasGroups) { expr = withoutGroupExpressions(expr); } CloseableIterator<Tuple> iter = projectable.iterate(expr); try { while (iter.hasNext()) { Object[] row = iter.next().toArray(); K groupId = (K) row[0]; GroupImpl group = (GroupImpl)groups.get(groupId); if (group == null) { group = new GroupImpl(groupExpressions, maps); groups.put(groupId, group); } group.add(row); } } finally { iter.close(); } // transform groups return transform(groups); }
@Override public CloseableIterator<V> transform(Projectable projectable) { FactoryExpression<Tuple> expr = FactoryExpressionUtils.wrap(new QTuple(expressions)); boolean hasGroups = false; for (Expression<?> e : expr.getArgs()) {
@Override public List<V> transform(Projectable projectable) { FactoryExpression<Tuple> expr = FactoryExpressionUtils.wrap(new QTuple(expressions)); boolean hasGroups = false; for (Expression<?> e : expr.getArgs()) {