/** * Create a new aggregating map expression using a backing LinkedHashMap * * @param key key for the map entries * @param value value for the map entries * @return wrapper expression */ public static <K, V, T> AbstractGroupExpression<Pair<K, V>, Map<T, V>> map(GroupExpression<K, T> key, Expression<V> value) { return map(key, new GOne<V>(value)); }
/** * Create a new aggregating map expression using a backing TreeMap * * @param key key for the map entries * @param value value for the map entries * @return wrapper expression */ public static <K extends Comparable<? super K>, V, U> AbstractGroupExpression<Pair<K, V>, SortedMap<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value) { return sortedMap(new GOne<K>(key), value); }
/** * Create a new aggregating map expression using a backing LinkedHashMap * * @param key key for the map entries * @param value value for the map entries * @return wrapper expression */ public static <K, V, U> AbstractGroupExpression<Pair<K, V>, Map<K, U>> map(Expression<K> key, GroupExpression<V, U> value) { return map(new GOne<K>(key), value); }
/** * Create a new aggregating map expression using a backing TreeMap using the given comparator * * @param key key for the map entries * @param value value for the map entries * @param comparator comparator for the created TreeMap instances * @return wrapper expression */ public static <K, V, U> AbstractGroupExpression<Pair<K, V>, SortedMap<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value, Comparator<? super K> comparator) { return sortedMap(new GOne<K>(key), value, comparator); }
/** * Create a new aggregating map expression using a backing TreeMap * * @param key key for the map entries * @param value value for the map entries * @return wrapper expression */ public static <K, V, T extends Comparable<? super T>> AbstractGroupExpression<Pair<K, V>, SortedMap<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value) { return sortedMap(key, new GOne<V>(value)); }
/** * Create a new aggregating map expression using a backing TreeMap using the given comparator * * @param key key for the map entries * @param value value for the map entries * @param comparator comparator for the created TreeMap instances * @return wrapper expression */ public static <K, V, T> AbstractGroupExpression<Pair<K, V>, SortedMap<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value, Comparator<? super T> comparator) { return sortedMap(key, new GOne<V>(value), comparator); }
@SuppressWarnings("unchecked") AbstractGroupByTransformer(Expression<K> key, Expression<?>... expressions) { List<Expression<?>> projection = new ArrayList<Expression<?>>(expressions.length); groupExpressions.add(new GOne<K>(key)); projection.add(key); for (Expression<?> expr : expressions) { if (expr instanceof GroupExpression<?,?>) { GroupExpression<?,?> groupExpr = (GroupExpression<?,?>) expr; groupExpressions.add(groupExpr); Expression<?> colExpression = groupExpr.getExpression(); if (colExpression instanceof Operation && ((Operation) colExpression).getOperator() == Ops.ALIAS) { projection.add(((Operation) colExpression).getArg(0)); } else { projection.add(colExpression); } if (groupExpr instanceof GMap) { maps.add((QPair<?, ?>) colExpression); } } else { groupExpressions.add(new GOne(expr)); projection.add(expr); } } this.expressions = projection.toArray(new Expression[projection.size()]); }
@Test public void compile() { StringExpression str = Expressions.stringPath("str"); GroupExpression<String, String> strGroup = new GOne<String>(str); GroupBy.sortedMap(strGroup, str, null); GroupBy.sortedMap(str, strGroup, null); }
/** * Create a new aggregating map expression using a backing LinkedHashMap * * @param key key for the map entries * @param value value for the map entries * @return wrapper expression */ public static <K, V, T> AbstractGroupExpression<Pair<K, V>, Map<T, V>> map(GroupExpression<K, T> key, Expression<V> value) { return map(key, new GOne<V>(value)); }
/** * Create a new aggregating map expression using a backing TreeMap * * @param key key for the map entries * @param value value for the map entries * @return wrapper expression */ public static <K, V, T extends Comparable<? super T>> AbstractGroupExpression<Pair<K, V>, SortedMap<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value) { return sortedMap(key, new GOne<V>(value)); }
/** * Create a new aggregating map expression using a backing LinkedHashMap * * @param key key for the map entries * @param value value for the map entries * @return wrapper expression */ public static <K, V, U> AbstractGroupExpression<Pair<K, V>, Map<K, U>> map(Expression<K> key, GroupExpression<V, U> value) { return map(new GOne<K>(key), value); }
/** * Create a new aggregating map expression using a backing TreeMap * * @param key key for the map entries * @param value value for the map entries * @return wrapper expression */ public static <K extends Comparable<? super K>, V, U> AbstractGroupExpression<Pair<K, V>, SortedMap<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value) { return sortedMap(new GOne<K>(key), value); }
/** * Create a new aggregating map expression using a backing TreeMap using the given comparator * * @param key key for the map entries * @param value value for the map entries * @param comparator comparator for the created TreeMap instances * @return wrapper expression */ public static <K, V, U> AbstractGroupExpression<Pair<K, V>, SortedMap<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value, Comparator<? super K> comparator) { return sortedMap(new GOne<K>(key), value, comparator); }
/** * Create a new aggregating map expression using a backing TreeMap using the given comparator * * @param key key for the map entries * @param value value for the map entries * @param comparator comparator for the created TreeMap instances * @return wrapper expression */ public static <K, V, T> AbstractGroupExpression<Pair<K, V>, SortedMap<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value, Comparator<? super T> comparator) { return sortedMap(key, new GOne<V>(value), comparator); }
@SuppressWarnings("unchecked") AbstractGroupByTransformer(Expression<K> key, Expression<?>... expressions) { List<Expression<?>> projection = new ArrayList<Expression<?>>(expressions.length); groupExpressions.add(new GOne<K>(key)); projection.add(key); for (Expression<?> expr : expressions) { if (expr instanceof GroupExpression<?,?>) { GroupExpression<?,?> groupExpr = (GroupExpression<?,?>) expr; groupExpressions.add(groupExpr); Expression<?> colExpression = groupExpr.getExpression(); if (colExpression instanceof Operation && ((Operation) colExpression).getOperator() == Ops.ALIAS) { projection.add(((Operation) colExpression).getArg(0)); } else { projection.add(colExpression); } if (groupExpr instanceof GMap) { maps.add((QPair<?, ?>) colExpression); } } else { groupExpressions.add(new GOne(expr)); projection.add(expr); } } this.expressions = projection.toArray(new Expression[projection.size()]); }