From ec7c7982c4d89cd26e8b11ca48476fa2f313c346 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Timo=20Westk=C3=A4mper?= Date: Tue, 3 Mar 2015 22:37:59 +0200 Subject: [PATCH 1/2] Add GroupBy.sortedSet and sortedMap --- .../java/com/mysema/query/group/GAvg.java | 2 +- .../java/com/mysema/query/group/GMap.java | 45 ++++- .../java/com/mysema/query/group/GMax.java | 2 +- .../java/com/mysema/query/group/GMin.java | 2 +- .../java/com/mysema/query/group/GSet.java | 54 ++++-- .../java/com/mysema/query/group/GSum.java | 2 +- .../java/com/mysema/query/group/Group.java | 63 ++++-- .../java/com/mysema/query/group/GroupBy.java | 182 ++++++++++++++++-- .../com/mysema/query/group/GroupImpl.java | 22 ++- .../query/group/AbstractGroupByTest.java | 11 ++ .../mysema/query/group/GroupByMapTest.java | 120 ++++++++---- 11 files changed, 400 insertions(+), 105 deletions(-) diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GAvg.java b/querydsl-core/src/main/java/com/mysema/query/group/GAvg.java index e718beab7..ced017028 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GAvg.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GAvg.java @@ -24,7 +24,7 @@ import com.mysema.util.MathUtils; * @param */ @SuppressWarnings("unchecked") -public class GAvg> extends AbstractGroupExpression { +public class GAvg extends AbstractGroupExpression { private static final long serialVersionUID = 3518868612387641383L; diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GMap.java b/querydsl-core/src/main/java/com/mysema/query/group/GMap.java index 5fe69db0d..7fc2593cb 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GMap.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GMap.java @@ -13,9 +13,7 @@ */ package com.mysema.query.group; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.Map; +import java.util.*; import com.mysema.commons.lang.Pair; @@ -23,7 +21,7 @@ import com.mysema.commons.lang.Pair; * @param * @param */ -class GMap extends AbstractGroupExpression, Map> { +abstract class GMap> extends AbstractGroupExpression, M> { private static final long serialVersionUID = 7106389414200843920L; @@ -31,11 +29,40 @@ class GMap extends AbstractGroupExpression, Map> { super(Map.class, qpair); } - @Override - public GroupCollector, Map> createGroupCollector() { - return new GroupCollector, Map>() { + protected abstract M createMap(); - private final Map map = new LinkedHashMap(); + public static GMap> createLinked(QPair expr) { + return new GMap>(expr) { + @Override + protected Map createMap() { + return new LinkedHashMap(); + } + }; + } + + public static , U> GMap> createSorted(QPair expr) { + return new GMap>(expr) { + @Override + protected SortedMap createMap() { + return new TreeMap(); + } + }; + } + + public static GMap> createSorted(QPair expr, final Comparator comparator) { + return new GMap>(expr) { + @Override + protected SortedMap createMap() { + return new TreeMap(comparator); + } + }; + } + + @Override + public GroupCollector, M> createGroupCollector() { + return new GroupCollector, M>() { + + private final M map = createMap(); @Override public void add(Pair pair) { @@ -43,7 +70,7 @@ class GMap extends AbstractGroupExpression, Map> { } @Override - public Map get() { + public M get() { return map; } diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GMax.java b/querydsl-core/src/main/java/com/mysema/query/group/GMax.java index 00fdccbe4..863cc9bce 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GMax.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GMax.java @@ -20,7 +20,7 @@ import com.mysema.query.types.Expression; * * @param */ -class GMax> extends AbstractGroupExpression { +class GMax> extends AbstractGroupExpression { private static final long serialVersionUID = 3815394663181131511L; diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GMin.java b/querydsl-core/src/main/java/com/mysema/query/group/GMin.java index 988bd4746..3c4f8af00 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GMin.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GMin.java @@ -20,7 +20,7 @@ import com.mysema.query.types.Expression; * * @param */ -class GMin> extends AbstractGroupExpression { +class GMin> extends AbstractGroupExpression { private static final long serialVersionUID = 8312168556148122576L; diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GSet.java b/querydsl-core/src/main/java/com/mysema/query/group/GSet.java index 49dd27df0..eb552ffcf 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GSet.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GSet.java @@ -13,8 +13,7 @@ */ package com.mysema.query.group; -import java.util.LinkedHashSet; -import java.util.Set; +import java.util.*; import com.mysema.query.types.Expression; @@ -23,32 +22,61 @@ import com.mysema.query.types.Expression; * * @param */ -class GSet extends AbstractGroupExpression> { - +abstract class GSet> extends AbstractGroupExpression { + private static final long serialVersionUID = -1575808026237160843L; + public static GSet> createLinked(Expression expr) { + return new GSet>(expr) { + @Override + protected Set createSet() { + return new LinkedHashSet(); + } + }; + } + + public static > GSet> createSorted(Expression expr) { + return new GSet>(expr) { + @Override + protected SortedSet createSet() { + return new TreeSet(); + } + }; + } + + public static GSet> createSorted(Expression expr, final Comparator comparator) { + return new GSet>(expr) { + @Override + protected SortedSet createSet() { + return new TreeSet(comparator); + } + }; + } + public GSet(Expression expr) { super(Set.class, expr); } - @Override - public GroupCollector> createGroupCollector() { - return new GroupCollector>() { + protected abstract S createSet(); + + @Override + public GroupCollector createGroupCollector() { + return new GroupCollector() { + + private final S set = createSet(); - private final Set set = new LinkedHashSet(); - @Override public void add(T o) { if (o != null) { - set.add(o); - } + set.add(o); + } } @Override - public Set get() { + public S get() { return set; } - + }; } } \ No newline at end of file diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GSum.java b/querydsl-core/src/main/java/com/mysema/query/group/GSum.java index 336a33533..612906cd6 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GSum.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GSum.java @@ -24,7 +24,7 @@ import com.mysema.util.MathUtils; * @param */ @SuppressWarnings("unchecked") -public class GSum> extends AbstractGroupExpression { +public class GSum extends AbstractGroupExpression { private static final long serialVersionUID = 3518868612387641383L; diff --git a/querydsl-core/src/main/java/com/mysema/query/group/Group.java b/querydsl-core/src/main/java/com/mysema/query/group/Group.java index 01f135508..e33c31f90 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/Group.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/Group.java @@ -13,42 +13,39 @@ */ package com.mysema.query.group; -import java.util.List; -import java.util.Map; -import java.util.NoSuchElementException; -import java.util.Set; +import java.util.*; import com.mysema.query.types.Expression; /** * A group of rows. Group is build according to GroupDefinitions. - * + * * @author sasa * */ public interface Group { - + /** * @return Groups elements as an array */ Object[] toArray(); - + /** * Returns the value of the given group. - * + * * @param Type of element in a single ResultSet row, i.e. type of {@code Expression} * @param Target type of this group, e.g. {@code List} - * @param coldef + * @param coldef * @throws NoSuchElementException if group is undefined. * @throws ClassCastException if group is of different type * @return Value of given group definition in this group */ R getGroup(GroupExpression coldef); - + /** * Returns the value of the given single valued expression. This is the * first value of given column within this group of the ResultSet. - * + * * @param Value type * @param expr Grouped expression * @throws NoSuchElementException if group is undefined. @@ -56,10 +53,10 @@ public interface Group { * @return Value of given expression in this group */ T getOne(Expression expr); - + /** * Returns a Set of values in this group. - * + * * @param Value type of Set * @param expr Grouped expression * @throws NoSuchElementException if group is undefined. @@ -67,29 +64,53 @@ public interface Group { * @return Set of values in this group */ Set getSet(Expression expr); - + /** - * Returns a List of values in this group. - * + * Returns a SortedSet of values in this group. + * + * @param Value type of Set + * @param expr Grouped expression + * @throws NoSuchElementException if group is undefined. + * @throws ClassCastException if group is of different type (e.g. List) + * @return Set of values in this group + */ + SortedSet getSortedSet(Expression expr); + + /** + * Returns a List of values in this group. + * * @param Value type of List * @param expr Grouped expression - * @throws NoSuchElementException if group is undefined. + * @throws NoSuchElementException if group is undefined. * @throws ClassCastException if group is of different type (e.g. Set) * @return List of values in this group */ List getList(Expression expr); - + /** * Returns a Map of values in this group - * + * * @param Key type of result Map * @param Value type of result Map * @param key Key expression * @param value Value expression - * @throws NoSuchElementException if group is undefined. + * @throws NoSuchElementException if group is undefined. * @throws ClassCastException if group is of different type (e.g. List) * @return Map of values in this group */ Map getMap(Expression key, Expression value); - + + /** + * Returns a SortedMap of values in this group + * + * @param Key type of result Map + * @param Value type of result Map + * @param key Key expression + * @param value Value expression + * @throws NoSuchElementException if group is undefined. + * @throws ClassCastException if group is of different type (e.g. List) + * @return Map of values in this group + */ + SortedMap getSortedMap(Expression key, Expression value); + } \ No newline at end of file diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GroupBy.java b/querydsl-core/src/main/java/com/mysema/query/group/GroupBy.java index 1a86e1d06..917567bf8 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GroupBy.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GroupBy.java @@ -13,9 +13,7 @@ */ package com.mysema.query.group; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import com.infradna.tool.bridge_method_injector.WithBridgeMethods; import com.mysema.commons.lang.Pair; @@ -57,7 +55,7 @@ public final class GroupBy { * @param expression * @return */ - public static > AbstractGroupExpression min(Expression expression) { + public static > AbstractGroupExpression min(Expression expression) { return new GMin(expression); } @@ -67,7 +65,7 @@ public final class GroupBy { * @param expression * @return */ - public static > AbstractGroupExpression sum(Expression expression) { + public static AbstractGroupExpression sum(Expression expression) { return new GSum(expression); } @@ -77,7 +75,7 @@ public final class GroupBy { * @param expression * @return */ - public static > AbstractGroupExpression avg(Expression expression) { + public static AbstractGroupExpression avg(Expression expression) { return new GAvg(expression); } @@ -87,7 +85,7 @@ public final class GroupBy { * @param expression * @return */ - public static > AbstractGroupExpression max(Expression expression) { + public static > AbstractGroupExpression max(Expression expression) { return new GMax(expression); } @@ -106,21 +104,65 @@ public final class GroupBy { } /** - * Create a new aggregating set expression + * Create a new aggregating set expression using a backing LinkedHashSet * * @param expression * @return */ public static AbstractGroupExpression> set(Expression expression) { - return new GSet(expression); + return GSet.createLinked(expression); } public static GroupExpression> set(GroupExpression groupExpression) { - return new MixinGroupExpression>(groupExpression, new GSet(groupExpression)); + return new MixinGroupExpression>(groupExpression, GSet.createLinked(groupExpression)); } /** - * Create a new aggregating map expression + * Create a new aggregating set expression using a backing TreeSet + * + * @param expression + * @return + */ + public static > AbstractGroupExpression> sortedSet(Expression expression) { + return GSet.createSorted(expression); + } + + /** + * Create a new aggregating set expression using a backing TreeSet + * + * @param groupExpression + * @return + */ + public static > GroupExpression> sortedSet(GroupExpression groupExpression) { + return new MixinGroupExpression>(groupExpression, GSet.createSorted(groupExpression)); + } + + + /** + * Create a new aggregating set expression using a backing TreeSet using the given comparator + * + * @param expression + * @param comparator + * @return + */ + public static AbstractGroupExpression> sortedSet(Expression expression, Comparator comparator) { + return GSet.createSorted(expression, comparator); + } + + /** + * Create a new aggregating set expression using a backing TreeSet using the given comparator + * + * @param groupExpression + * @param comparator + * @return + */ + public static GroupExpression> sortedSet(GroupExpression groupExpression, Comparator comparator) { + return new MixinGroupExpression>(groupExpression, GSet.createSorted(groupExpression, comparator)); + } + + + /** + * Create a new aggregating map expression using a backing LinkedHashMap * * @param key * @param value @@ -128,21 +170,135 @@ public final class GroupBy { */ @WithBridgeMethods(value=Expression.class,castRequired=true) public static AbstractGroupExpression,Map> map(Expression key, Expression value) { - return new GMap(QPair.create(key, value)); + return GMap.createLinked(QPair.create(key, value)); } + /** + * Create a new aggregating map expression using a backing LinkedHashMap + * + * @param key + * @param value + * @return + */ public static AbstractGroupExpression, Map> map(GroupExpression key, Expression value) { return map(key, new GOne(value)); } + /** + * Create a new aggregating map expression using a backing LinkedHashMap + * + * @param key + * @param value + * @return + */ public static AbstractGroupExpression, Map> map(Expression key, GroupExpression value) { return map(new GOne(key), value); } + /** + * Create a new aggregating map expression using a backing LinkedHashMap + * + * @param key + * @param value + * @return + */ public static AbstractGroupExpression, Map> map(GroupExpression key, GroupExpression value) { - return new GMap.Mixin>(key, value, new GMap(QPair.create(key, value))); + return new GMap.Mixin>(key, value, GMap.createLinked(QPair.create(key, value))); } + /** + * Create a new aggregating map expression using a backing TreeMap + * + * @param key + * @param value + * @return + */ + public static , V> AbstractGroupExpression, SortedMap> sortedMap(Expression key, Expression value) { + return GMap.createSorted(QPair.create(key, value)); + } + + /** + * Create a new aggregating map expression using a backing TreeMap + * + * @param key + * @param value + * @return + */ + public static , V, T extends Comparable> AbstractGroupExpression, SortedMap> sortedMap(GroupExpression key, Expression value) { + return sortedMap(key, new GOne(value)); + } + + /** + * Create a new aggregating map expression using a backing TreeMap + * + * @param key + * @param value + * @return + */ + public static , V, U> AbstractGroupExpression, SortedMap> sortedMap(Expression key, GroupExpression value) { + return sortedMap(new GOne(key), value); + } + + /** + * Create a new aggregating map expression using a backing TreeMap + * + * @param key + * @param value + * @return + */ + public static , V, T extends Comparable, U> AbstractGroupExpression, SortedMap> sortedMap(GroupExpression key, GroupExpression value) { + return new GMap.Mixin>(key, value, GMap.createSorted(QPair.create(key, value))); + } + + /** + * Create a new aggregating map expression using a backing TreeMap using the given comparator + * + * @param key + * @param value + * @param comparator + * @return + */ + public static AbstractGroupExpression, SortedMap> sortedMap(Expression key, Expression value, Comparator comparator) { + return GMap.createSorted(QPair.create(key, value), comparator); + } + + /** + * Create a new aggregating map expression using a backing TreeMap using the given comparator + * + * @param key + * @param value + * @param comparator + * @return + */ + public static AbstractGroupExpression, SortedMap> sortedMap(GroupExpression key, Expression value, Comparator comparator) { + return sortedMap(key, new GOne(value), comparator); + } + + /** + * Create a new aggregating map expression using a backing TreeMap using the given comparator + * + * @param key + * @param value + * @param comparator + * @return + */ + public static AbstractGroupExpression, SortedMap> sortedMap(Expression key, GroupExpression value, Comparator comparator) { + return sortedMap(new GOne(key), value, comparator); + } + + /** + * Create a new aggregating map expression using a backing TreeMap using the given comparator + * + * @param key + * @param value + * @param comparator + * @return + */ + public static AbstractGroupExpression, SortedMap> sortedMap(GroupExpression key, GroupExpression value, Comparator comparator) { + return new GMap.Mixin>(key, value, GMap.createSorted(QPair.create(key, value), comparator)); + } + + private GroupBy() {} } diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GroupImpl.java b/querydsl-core/src/main/java/com/mysema/query/group/GroupImpl.java index 27c9d2032..f28b49547 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GroupImpl.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GroupImpl.java @@ -13,12 +13,7 @@ */ package com.mysema.query.group; -import java.util.ArrayList; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.NoSuchElementException; -import java.util.Set; +import java.util.*; import com.mysema.query.types.Expression; import com.mysema.query.types.Operation; @@ -104,6 +99,16 @@ class GroupImpl implements Group { throw new NoSuchElementException("GMap(" + key + ", " + value + ")"); } + @Override + public SortedMap getSortedMap(Expression key, Expression value) { + for (QPair pair : maps) { + if (pair.equals(key, value)) { + return (SortedMap) groupCollectorMap.get(pair).get(); + } + } + throw new NoSuchElementException("GMap(" + key + ", " + value + ")"); + } + @Override public T getOne(Expression expr) { return this.get(expr); @@ -114,6 +119,11 @@ class GroupImpl implements Group { return this.>get(expr); } + @Override + public SortedSet getSortedSet(Expression expr) { + return this.>get(expr); + } + @Override public Object[] toArray() { List arr = new ArrayList(groupCollectors.size()); diff --git a/querydsl-core/src/test/java/com/mysema/query/group/AbstractGroupByTest.java b/querydsl-core/src/test/java/com/mysema/query/group/AbstractGroupByTest.java index 69af30027..637b757f5 100644 --- a/querydsl-core/src/test/java/com/mysema/query/group/AbstractGroupByTest.java +++ b/querydsl-core/src/test/java/com/mysema/query/group/AbstractGroupByTest.java @@ -34,6 +34,17 @@ public abstract class AbstractGroupByTest { row(3, "post 3", 6, "comment 6") ); + protected static final Projectable BASIC_RESULTS_UNORDERED = projectable( + row(null, "null post", 8, "comment 8"), + row(null, "null post", 7, "comment 7"), + row(1, "post 1", 2, "comment 2"), + row(1, "post 1", 1, "comment 1"), + row(2, "post 2", 4, "comment 4"), + row(1, "post 1", 3, "comment 3"), + row(3, "post 3", 6, "comment 6"), + row(2, "post 2", 5, "comment 5") + ); + protected static final Projectable MAP_RESULTS = projectable( row(null, "null post", pair(7, "comment 7")), row(null, "null post", pair(8, "comment 8")), diff --git a/querydsl-core/src/test/java/com/mysema/query/group/GroupByMapTest.java b/querydsl-core/src/test/java/com/mysema/query/group/GroupByMapTest.java index 9adbf37a4..fe243f912 100644 --- a/querydsl-core/src/test/java/com/mysema/query/group/GroupByMapTest.java +++ b/querydsl-core/src/test/java/com/mysema/query/group/GroupByMapTest.java @@ -14,23 +14,14 @@ package com.mysema.query.group; -import static com.mysema.query.group.GroupBy.groupBy; -import static com.mysema.query.group.GroupBy.list; -import static com.mysema.query.group.GroupBy.map; -import static com.mysema.query.group.GroupBy.set; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; +import static com.mysema.query.group.GroupBy.*; +import static org.junit.Assert.*; -import java.util.Arrays; -import java.util.Collections; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.Map; -import java.util.NoSuchElementException; +import java.util.*; import org.junit.Test; +import com.google.common.collect.Ordering; import com.mysema.commons.lang.Pair; import com.mysema.query.Tuple; import com.mysema.query.types.Projections; @@ -40,14 +31,38 @@ public class GroupByMapTest extends AbstractGroupByTest { @Test public void Group_Order() { Map results = BASIC_RESULTS - .transform(groupBy(postId).as(postName, set(commentId))); + .transform(groupBy(postId).as(postName, set(commentId))); assertEquals(4, results.size()); } + @Test + public void Set_By_Sorted() { + Map results = BASIC_RESULTS_UNORDERED + .transform(groupBy(postId).as(postName, sortedSet(commentId))); + + Group group = results.get(1); + Iterator it = group.getSet(commentId).iterator(); + assertEquals(1, it.next().intValue()); + assertEquals(2, it.next().intValue()); + assertEquals(3, it.next().intValue()); + } + + @Test + public void Set_By_Sorted_Reverse() { + Map results = BASIC_RESULTS_UNORDERED + .transform(groupBy(postId).as(postName, sortedSet(commentId, Ordering.natural().reverse()))); + + Group group = results.get(1); + Iterator it = group.getSet(commentId).iterator(); + assertEquals(3, it.next().intValue()); + assertEquals(2, it.next().intValue()); + assertEquals(1, it.next().intValue()); + } + @Test public void First_Set_And_List() { Map results = BASIC_RESULTS.transform( - groupBy(postId).as(postName, set(commentId), list(commentText))); + groupBy(postId).as(postName, set(commentId), list(commentText))); Group group = results.get(1); assertEquals(toInt(1), group.getOne(postId)); @@ -59,7 +74,7 @@ public class GroupByMapTest extends AbstractGroupByTest { @Test public void Group_By_Null() { Map results = BASIC_RESULTS.transform( - groupBy(postId).as(postName, set(commentId), list(commentText))); + groupBy(postId).as(postName, set(commentId), list(commentText))); Group group = results.get(null); assertNull(group.getOne(postId)); @@ -72,7 +87,7 @@ public class GroupByMapTest extends AbstractGroupByTest { @Test(expected=NoSuchElementException.class) public void NoSuchElementException() { Map results = BASIC_RESULTS.transform( - groupBy(postId).as(postName, set(commentId), list(commentText))); + groupBy(postId).as(postName, set(commentId), list(commentText))); Group group = results.get(1); group.getSet(qComment); @@ -81,7 +96,7 @@ public class GroupByMapTest extends AbstractGroupByTest { @Test(expected=ClassCastException.class) public void ClassCastException() { Map results = BASIC_RESULTS.transform( - groupBy(postId).as(postName, set(commentId), list(commentText))); + groupBy(postId).as(postName, set(commentId), list(commentText))); Group group = results.get(1); group.getList(commentId); @@ -90,7 +105,7 @@ public class GroupByMapTest extends AbstractGroupByTest { @Test public void Map() { Map results = MAP_RESULTS.transform( - groupBy(postId).as(postName, map(commentId, commentText))); + groupBy(postId).as(postName, map(commentId, commentText))); Group group = results.get(1); @@ -99,26 +114,53 @@ public class GroupByMapTest extends AbstractGroupByTest { assertEquals("comment 2", comments.get(2)); } + @Test + public void Map_Sorted() { + Map results = MAP_RESULTS.transform( + groupBy(postId).as(postName, sortedMap(commentId, commentText))); + + Group group = results.get(1); + + Iterator> it = group.getMap(commentId, commentText).entrySet().iterator(); + assertEquals(1, it.next().getKey().intValue()); + assertEquals(2, it.next().getKey().intValue()); + assertEquals(3, it.next().getKey().intValue()); + } + + @Test + public void Map_Sorted_Reverse() { + Map results = MAP_RESULTS.transform( + groupBy(postId).as(postName, sortedMap(commentId, commentText, Ordering.natural().reverse()))); + + Group group = results.get(1); + + Iterator> it = group.getMap(commentId, commentText).entrySet().iterator(); + assertEquals(3, it.next().getKey().intValue()); + assertEquals(2, it.next().getKey().intValue()); + assertEquals(1, it.next().getKey().intValue()); + } + + @Test public void Map2() { Map> results = MAP2_RESULTS.transform( - groupBy(postId).as(map(commentId, commentText))); + groupBy(postId).as(map(commentId, commentText))); Map comments = results.get(1); assertEquals(3, comments.size()); assertEquals("comment 2", comments.get(2)); } - + @Test - public void Map3() { + public void Map3() { Map>> actual = MAP3_RESULTS.transform( - groupBy(postId).as(map(postId, map(commentId, commentText)))); - + groupBy(postId).as(map(postId, map(commentId, commentText)))); + Map>> expected = new LinkedHashMap>>(); for (Iterator iterator = MAP3_RESULTS.iterate(); iterator.hasNext();) { Tuple tuple = iterator.next(); Object[] array = tuple.toArray(); - + Map> posts = expected.get(array[0]); if (posts == null) { posts = new LinkedHashMap>(); @@ -134,20 +176,20 @@ public class GroupByMapTest extends AbstractGroupByTest { } Pair second = pair.getSecond(); comments.put(second.getFirst(), second.getSecond()); - } + } assertEquals(expected.toString(), actual.toString()); } @Test - public void Map4() { + public void Map4() { Map, String>> actual = MAP4_RESULTS.transform( - groupBy(postId).as(map(map(postId, commentText), postName))); - + groupBy(postId).as(map(map(postId, commentText), postName))); + Map, String>> expected = new LinkedHashMap, String>>(); for (Iterator iterator = MAP4_RESULTS.iterate(); iterator.hasNext();) { Tuple tuple = iterator.next(); Object[] array = tuple.toArray(); - + Map, String> comments = expected.get(array[0]); if (comments == null) { comments = new LinkedHashMap, String>(); @@ -155,17 +197,17 @@ public class GroupByMapTest extends AbstractGroupByTest { } @SuppressWarnings("unchecked") Pair, String> pair = (Pair, String>) array[1]; - Pair first = pair.getFirst(); + Pair first = pair.getFirst(); Map posts = Collections.singletonMap(first.getFirst(), first.getSecond()); comments.put(posts, pair.getSecond()); - } + } assertEquals(expected.toString(), actual.toString()); } @Test public void Array_Access() { Map results = BASIC_RESULTS.transform( - groupBy(postId).as(postName, set(commentId), list(commentText))); + groupBy(postId).as(postName, set(commentId), list(commentText))); Group group = results.get(1); Object[] array = group.toArray(); @@ -224,8 +266,8 @@ public class GroupByMapTest extends AbstractGroupByTest { @Test public void OneToOneToMany_Projection() { Map results = USERS_W_LATEST_POST_AND_COMMENTS.transform( - groupBy(userName).as(Projections.constructor(User.class, userName, - Projections.constructor(Post.class, postId, postName, set(qComment))))); + groupBy(userName).as(Projections.constructor(User.class, userName, + Projections.constructor(Post.class, postId, postName, set(qComment))))); assertEquals(2, results.size()); @@ -239,8 +281,8 @@ public class GroupByMapTest extends AbstractGroupByTest { @Test public void OneToOneToMany_Projection_As_Bean() { Map results = USERS_W_LATEST_POST_AND_COMMENTS.transform( - groupBy(userName).as(Projections.bean(User.class, userName, - Projections.bean(Post.class, postId, postName, set(qComment).as("comments")).as("latestPost")))); + groupBy(userName).as(Projections.bean(User.class, userName, + Projections.bean(Post.class, postId, postName, set(qComment).as("comments")).as("latestPost")))); assertEquals(2, results.size()); @@ -254,8 +296,8 @@ public class GroupByMapTest extends AbstractGroupByTest { @Test public void OneToOneToMany_Projection_As_Bean_And_Constructor() { Map results = USERS_W_LATEST_POST_AND_COMMENTS.transform( - groupBy(userName).as(Projections.bean(User.class, userName, - Projections.constructor(Post.class, postId, postName, set(qComment)).as("latestPost")))); + groupBy(userName).as(Projections.bean(User.class, userName, + Projections.constructor(Post.class, postId, postName, set(qComment)).as("latestPost")))); assertEquals(2, results.size()); From 82e6f399f51358faef1f2ad5451542f3ec24d959 Mon Sep 17 00:00:00 2001 From: Ruben Dijkstra Date: Sat, 7 Mar 2015 23:23:08 +0100 Subject: [PATCH 2/2] Reorder inner classes to preserve numbering --- .../java/com/mysema/query/group/GMap.java | 40 +++++++------- .../java/com/mysema/query/group/GSet.java | 55 ++++++++++--------- 2 files changed, 48 insertions(+), 47 deletions(-) diff --git a/querydsl-core/src/main/java/com/mysema/query/group/GMap.java b/querydsl-core/src/main/java/com/mysema/query/group/GMap.java index 7fc2593cb..6ab8fb1cf 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/GMap.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/GMap.java @@ -31,6 +31,25 @@ abstract class GMap> extends AbstractGroupExpression, M> createGroupCollector() { + return new GroupCollector, M>() { + + private final M map = createMap(); + + @Override + public void add(Pair pair) { + map.put(pair.getFirst(), pair.getSecond()); + } + + @Override + public M get() { + return map; + } + + }; + } + public static GMap> createLinked(QPair expr) { return new GMap>(expr) { @Override @@ -58,25 +77,6 @@ abstract class GMap> extends AbstractGroupExpression, M> createGroupCollector() { - return new GroupCollector, M>() { - - private final M map = createMap(); - - @Override - public void add(Pair pair) { - map.put(pair.getFirst(), pair.getSecond()); - } - - @Override - public M get() { - return map; - } - - }; - } - static class Mixin> extends AbstractGroupExpression, R> { private static final long serialVersionUID = 1939989270493531116L; @@ -145,4 +145,4 @@ abstract class GMap> extends AbstractGroupExpression> extends AbstractGroupExpression { private static final long serialVersionUID = -1575808026237160843L; + public GSet(Expression expr) { + super(Set.class, expr); + } + + protected abstract S createSet(); + + @Override + public GroupCollector createGroupCollector() { + return new GroupCollector() { + + private final S set = createSet(); + + @Override + public void add(T o) { + if (o != null) { + set.add(o); + } + } + + @Override + public S get() { + return set; + } + + }; + } + public static GSet> createLinked(Expression expr) { return new GSet>(expr) { @Override @@ -53,30 +80,4 @@ abstract class GSet> extends AbstractGroupExpression { }; } - public GSet(Expression expr) { - super(Set.class, expr); - } - - protected abstract S createSet(); - - @Override - public GroupCollector createGroupCollector() { - return new GroupCollector() { - - private final S set = createSet(); - - @Override - public void add(T o) { - if (o != null) { - set.add(o); - } - } - - @Override - public S get() { - return set; - } - - }; - } -} \ No newline at end of file +}