From 4034f5fceff0ec21052b6149ecfed831903bbf8d Mon Sep 17 00:00:00 2001 From: Samppa Saarela Date: Wed, 21 Sep 2011 10:47:08 +0300 Subject: [PATCH] Support for transforming results into something else. --- .../com/mysema/query/ResultTransformer.java | 1 + .../java/com/mysema/query/group/Group.java | 2 - .../java/com/mysema/query/group/GroupBy.java | 335 +++++++++--------- .../java/com/mysema/query/group/QPair.java | 7 +- .../query/group/TransformerGroupBy.java | 30 ++ .../mysema/query/group/TransformerMap.java | 98 +++++ .../com/mysema/query/group/GroupByTest.java | 132 +++++-- .../java/com/mysema/query/SelectBaseTest.java | 11 +- 8 files changed, 408 insertions(+), 208 deletions(-) create mode 100644 querydsl-core/src/main/java/com/mysema/query/group/TransformerGroupBy.java create mode 100644 querydsl-core/src/main/java/com/mysema/query/group/TransformerMap.java diff --git a/querydsl-core/src/main/java/com/mysema/query/ResultTransformer.java b/querydsl-core/src/main/java/com/mysema/query/ResultTransformer.java index 9d9bdc320..babfdeefc 100644 --- a/querydsl-core/src/main/java/com/mysema/query/ResultTransformer.java +++ b/querydsl-core/src/main/java/com/mysema/query/ResultTransformer.java @@ -5,6 +5,7 @@ */ package com.mysema.query; + /** * Executes query on a Projectable and transforms results into T. This can be used for example * to group projected columns or to filter out duplicate results. 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 58d77051c..7999f2780 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 @@ -29,6 +29,4 @@ public interface Group { Map getMap(Expression key, Expression value); - Map getMap(Expression key, Class valueType); - } \ 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 c328bf1ef..53a9f9cf4 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 @@ -14,6 +14,8 @@ import java.util.Map; import java.util.NoSuchElementException; import java.util.Set; +import org.apache.commons.collections15.Transformer; + import com.mysema.commons.lang.CloseableIterator; import com.mysema.commons.lang.Pair; import com.mysema.query.Projectable; @@ -33,6 +35,32 @@ import com.mysema.query.types.Expression; @SuppressWarnings("unchecked") public class GroupBy implements ResultTransformer> { + private static class GList extends AbstractGroupColumnDefinition>{ + + public GList(Expression expr) { + super(expr); + } + + @Override + public GroupColumn> createGroupColumn() { + return new GroupColumn>() { + + private final List list = new ArrayList(); + + @Override + public void add(Object o) { + list.add((T) o); + } + + @Override + public List get() { + return list; + } + + }; + } + } + private static class GMap extends AbstractGroupColumnDefinition, Map>{ public GMap(QPair qpair) { @@ -60,6 +88,35 @@ public class GroupBy implements ResultTransformer> { } } + private static class GOne extends AbstractGroupColumnDefinition{ + + public GOne(Expression expr) { + super(expr); + } + + @Override + public GroupColumn createGroupColumn() { + return new GroupColumn() { + private boolean first = true; + + private T val; + + @Override + public void add(Object o) { + if (first) { + val = (T) o; + first = false; + } + } + + @Override + public T get() { + return val; + } + }; + } + } + private static class GSet extends AbstractGroupColumnDefinition>{ public GSet(Expression expr) { @@ -85,71 +142,93 @@ public class GroupBy implements ResultTransformer> { }; } } - - private static class GList extends AbstractGroupColumnDefinition>{ - - public GList(Expression expr) { - super(expr); - } - - @Override - public GroupColumn> createGroupColumn() { - return new GroupColumn>() { - - private final List list = new ArrayList(); - - @Override - public void add(Object o) { - list.add((T) o); - } - - @Override - public List get() { - return list; - } - - }; - } - } - - - private static class GOne extends AbstractGroupColumnDefinition{ - - public GOne(Expression expr) { - super(expr); - } - - @Override - public GroupColumn createGroupColumn() { - return new GroupColumn() { - private T val; - - private boolean first = true; - - @Override - public void add(Object o) { - if (first) { - val = (T) o; - first = false; - } - } - - @Override - public T get() { - return val; - } - }; - } - } - - private final List> columnDefinitions = new ArrayList>(); - - private final List> pairs = new ArrayList>(); public static GroupBy create(Expression expr) { return new GroupBy(expr); + } + + public static GroupBy create(Expression expr, Expression first, Expression... rest) { + return new GroupBy(expr, first, rest); } + private class GroupImpl implements Group { + + private final Map, GroupColumn> groupColumns = new LinkedHashMap, GroupColumn>(); + + public GroupImpl() { + for (int i=0; i < columnDefinitions.size(); i++) { + GroupColumnDefinition coldef = columnDefinitions.get(i); + groupColumns.put(coldef.getExpression(), coldef.createGroupColumn()); + } + } + + void add(Object[] row) { + int i=0; + for (GroupColumn groupColumn : groupColumns.values()) { + groupColumn.add(row[i]); + i++; + } + } + + private R get(Expression expr) { + GroupColumn col = (GroupColumn) groupColumns.get(expr); + if (col != null) { + return col.get(); + } + throw new NoSuchElementException(expr.toString()); + } + + @Override + public R getGroup(GroupColumnDefinition definition) { + Iterator> iter = groupColumns.values().iterator(); + for (GroupColumnDefinition def : columnDefinitions) { + GroupColumn groupColumn = iter.next(); + if (def.equals(definition)) { + return (R) groupColumn.get(); + } + } + throw new NoSuchElementException(definition.toString()); + } + + @Override + public List getList(Expression expr) { + return this.>get(expr); + } + + public Map getMap(Expression key, Expression value) { + for (QPair pair : maps) { + if (pair.equals(key, value)) { + return (Map) groupColumns.get(pair).get(); + } + } + throw new NoSuchElementException("GMap(" + key + ", " + value + ")"); + } + + @Override + public T getOne(Expression expr) { + return this.get(expr); + } + + @Override + public Set getSet(Expression expr) { + return this.>get(expr); + } + + @Override + public Object[] toArray() { + List arr = new ArrayList(groupColumns.size()); + for (GroupColumn col : groupColumns.values()) { + arr.add(col.get()); + } + return arr.toArray(); + } + + } + + private final List> columnDefinitions = new ArrayList>(); + + private final List> maps = new ArrayList>(); + public GroupBy(Expression groupBy) { withGroup(new GOne(groupBy)); } @@ -170,29 +249,14 @@ public class GroupBy implements ResultTransformer> { } } - public GroupBy withGroup(GroupColumnDefinition g) { - columnDefinitions.add(g); - return this; + private Expression[] getExpressions() { + Expression[] unwrapped = new Expression[columnDefinitions.size()]; + for (int i=0; i < columnDefinitions.size(); i++) { + unwrapped[i] = columnDefinitions.get(i).getExpression(); + } + return unwrapped; } - public GroupBy withSet(Expression expr) { - return withGroup(new GSet(expr)); - } - - public GroupBy withList(Expression expr) { - return withGroup(new GList(expr)); - } - - public GroupBy withOne(Expression expr) { - return withGroup(new GOne(expr)); - } - - public GroupBy withMap(Expression key, Expression value) { - QPair qpair = new QPair(key, value); - pairs.add(qpair); - return withGroup(new GMap(qpair)); - } - @Override public Map transform(Projectable projectable) { final Map groups = new LinkedHashMap(); @@ -215,96 +279,31 @@ public class GroupBy implements ResultTransformer> { return groups; } - private Expression[] getExpressions() { - Expression[] unwrapped = new Expression[columnDefinitions.size()]; - for (int i=0; i < columnDefinitions.size(); i++) { - unwrapped[i] = columnDefinitions.get(i).getExpression(); - } - return unwrapped; + public GroupBy withGroup(GroupColumnDefinition g) { + columnDefinitions.add(g); + return this; + } + + public GroupBy withList(Expression expr) { + return withGroup(new GList(expr)); } - private class GroupImpl implements Group { - - private final Map, GroupColumn> groupColumns = new LinkedHashMap, GroupColumn>(); - - public GroupImpl() { - for (int i=0; i < columnDefinitions.size(); i++) { - GroupColumnDefinition coldef = columnDefinitions.get(i); - groupColumns.put(coldef.getExpression(), coldef.createGroupColumn()); - } - } - - @Override - public R getGroup(GroupColumnDefinition definition) { - Iterator> iter = groupColumns.values().iterator(); - for (GroupColumnDefinition def : columnDefinitions) { - GroupColumn groupColumn = iter.next(); - if (def.equals(definition)) { - return (R) groupColumn.get(); - } - } - throw new NoSuchElementException(definition.toString()); - } - - @Override - public T getOne(Expression expr) { - return this.get(expr); - } - - @Override - public Set getSet(Expression expr) { - return this.>get(expr); - } - - @Override - public List getList(Expression expr) { - return this.>get(expr); - } - - private R get(Expression expr) { - GroupColumn col = (GroupColumn) groupColumns.get(expr); - if (col != null) { - return col.get(); - } - throw new NoSuchElementException(expr.toString()); - } - - public Map getMap(Expression key, Expression value) { - for (QPair pair : pairs) { - if (pair.equals(key, value)) { - return (Map) groupColumns.get(pair).get(); - } - } - throw new NoSuchElementException("GMap(" + key + ", " + value + ")"); - } - - @Override - public Map getMap(Expression key, Class valueType) { - for (QPair pair : pairs) { - if (pair.equals(key, valueType)) { - return (Map) groupColumns.get(pair).get(); - } - } - throw new NoSuchElementException("GMap(" + key + ", " + valueType + ")"); - } - - void add(Object[] row) { - int i=0; - for (GroupColumn groupColumn : groupColumns.values()) { - groupColumn.add(row[i]); - i++; - } - } - - @Override - public Object[] toArray() { - List arr = new ArrayList(groupColumns.size()); - for (GroupColumn col : groupColumns.values()) { - arr.add(col.get()); - } - return arr.toArray(); - } + public GroupBy withMap(Expression key, Expression value) { + QPair qpair = new QPair(key, value); + maps.add(qpair); + return withGroup(new GMap(qpair)); + } + public GroupBy withOne(Expression expr) { + return withGroup(new GOne(expr)); + } + + public GroupBy withSet(Expression expr) { + return withGroup(new GSet(expr)); + } + + public TransformerGroupBy withTransformer(Transformer transformer) { + return TransformerGroupBy.create(this, transformer); } } diff --git a/querydsl-core/src/main/java/com/mysema/query/group/QPair.java b/querydsl-core/src/main/java/com/mysema/query/group/QPair.java index 3bc518977..f4b9be377 100644 --- a/querydsl-core/src/main/java/com/mysema/query/group/QPair.java +++ b/querydsl-core/src/main/java/com/mysema/query/group/QPair.java @@ -29,6 +29,10 @@ public final class QPair extends ExpressionBase> implements Fac private final Expression value; + public static QPair create(Expression key, Expression value) { + return new QPair(key, value); + } + @SuppressWarnings({ "rawtypes", "unchecked" }) public QPair(Expression key, Expression value) { super((Class) Pair.class); @@ -62,8 +66,7 @@ public final class QPair extends ExpressionBase> implements Fac @Override public int hashCode() { - int hashCode = key.hashCode(); - return 31*hashCode + value.hashCode(); + return 31*key.hashCode() + value.hashCode(); } @Override diff --git a/querydsl-core/src/main/java/com/mysema/query/group/TransformerGroupBy.java b/querydsl-core/src/main/java/com/mysema/query/group/TransformerGroupBy.java new file mode 100644 index 000000000..c85a737df --- /dev/null +++ b/querydsl-core/src/main/java/com/mysema/query/group/TransformerGroupBy.java @@ -0,0 +1,30 @@ +package com.mysema.query.group; + +import java.util.Map; + +import org.apache.commons.collections15.Transformer; + +import com.mysema.query.Projectable; +import com.mysema.query.ResultTransformer; + +public class TransformerGroupBy implements ResultTransformer> { + + private final GroupBy groupBy; + + private final Transformer transformer; + + public static TransformerGroupBy create(GroupBy groupBy, Transformer transformer) { + return new TransformerGroupBy(groupBy, transformer); + } + + public TransformerGroupBy(GroupBy groupBy, Transformer transformer) { + this.groupBy = groupBy; + this.transformer = transformer; + } + + @Override + public Map transform(Projectable projectable) { + return TransformerMap.create(groupBy.transform(projectable), transformer); + } + +} diff --git a/querydsl-core/src/main/java/com/mysema/query/group/TransformerMap.java b/querydsl-core/src/main/java/com/mysema/query/group/TransformerMap.java new file mode 100644 index 000000000..992dcbb9e --- /dev/null +++ b/querydsl-core/src/main/java/com/mysema/query/group/TransformerMap.java @@ -0,0 +1,98 @@ +package com.mysema.query.group; + +import java.util.AbstractMap; +import java.util.Collection; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.collections15.Transformer; +import org.apache.commons.collections15.collection.TransformedCollection; +import org.apache.commons.collections15.set.TransformedSet; + +public class TransformerMap extends AbstractMap { + + private final Map map; + + private final Transformer transformer; + + public static Map create(Map map, Transformer transformer) { + return new TransformerMap(map, transformer); + } + + public TransformerMap(Map map, Transformer transformer) { + this.map = map; + this.transformer = transformer; + } + + public int size() { + return map.size(); + } + + public boolean isEmpty() { + return map.isEmpty(); + } + + public boolean containsKey(Object key) { + return map.containsKey(key); + } + + @SuppressWarnings("unchecked") + public boolean containsValue(Object value) { + return map.containsValue(transformer.transform((V) value)); + } + + public T get(Object key) { + return transformer.transform(map.get(key)); + } + + public T put(K key, T value) { + throw new UnsupportedOperationException(); + } + + public T remove(Object key) { + throw new UnsupportedOperationException(); + } + + public void putAll(Map m) { + throw new UnsupportedOperationException(); + } + + public void clear() { + throw new UnsupportedOperationException(); + } + + public Set keySet() { + return map.keySet(); + } + + public Collection values() { + return TransformedCollection.decorate(map.values(), transformer); + } + + public Set> entrySet() { + return TransformedSet.decorate(map.entrySet(), new Transformer, Map.Entry>() { + @Override + public java.util.Map.Entry transform(final Map.Entry input) { + return new Map.Entry() { + + @Override + public K getKey() { + return input.getKey(); + } + + @Override + public T getValue() { + return transformer.transform(input.getValue()); + } + + @Override + public T setValue(T value) { + throw new UnsupportedOperationException(); + } + + }; + } + }); + } + +} diff --git a/querydsl-core/src/test/java/com/mysema/query/group/GroupByTest.java b/querydsl-core/src/test/java/com/mysema/query/group/GroupByTest.java index da2450f3c..d4660bd21 100644 --- a/querydsl-core/src/test/java/com/mysema/query/group/GroupByTest.java +++ b/querydsl-core/src/test/java/com/mysema/query/group/GroupByTest.java @@ -1,6 +1,7 @@ package com.mysema.query.group; +import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.*; import java.util.Arrays; @@ -8,14 +9,15 @@ import java.util.HashSet; import java.util.Map; import java.util.Set; +import org.apache.commons.collections15.Transformer; import org.junit.Test; import com.mysema.commons.lang.CloseableIterator; import com.mysema.commons.lang.IteratorAdapter; import com.mysema.commons.lang.Pair; import com.mysema.query.Projectable; -import com.mysema.query.group.GroupBy; import com.mysema.query.support.AbstractProjectable; +import com.mysema.query.types.ConstructorExpression; import com.mysema.query.types.Expression; import com.mysema.query.types.expr.NumberExpression; import com.mysema.query.types.expr.StringExpression; @@ -24,15 +26,15 @@ import com.mysema.query.types.path.StringPath; public class GroupByTest { - private final NumberExpression postId = new NumberPath(Integer.class, "postId"); + private static final NumberExpression postId = new NumberPath(Integer.class, "postId"); - private final StringExpression postName = new StringPath("postName"); + private static final StringExpression postName = new StringPath("postName"); - private final NumberExpression commentId = new NumberPath(Integer.class, "commentId"); + private static final NumberExpression commentId = new NumberPath(Integer.class, "commentId"); - private final StringExpression commentText = new StringPath("commentText"); + private static final StringExpression commentText = new StringPath("commentText"); - private final GroupColumnDefinition constant = new AbstractGroupColumnDefinition(commentId) { + private static final GroupColumnDefinition constant = new AbstractGroupColumnDefinition(commentId) { @Override public GroupColumn createGroupColumn() { @@ -49,18 +51,51 @@ public class GroupByTest { }; } }; + + private static final ConstructorExpression qComment = + new ConstructorExpression( + GroupByTest.Comment.class, + new Class[] { Integer.class, String.class }, + commentId, commentText + ); - static class PostWithComments { - public Integer id; - public String name; - public Set comments; - public PostWithComments(Integer id, String name, Set comments) { + public static class Post { + public final Integer id; + public final String name; + public final Set comments; + public Post(Integer id, String name, Set comments) { this.id = id; this.name = name; this.comments = comments; } } + public static class Comment { + public final Integer id; + public final String text; + public Comment(Integer id, String text) { + this.id = id; + this.text = text; + } + public int hashCode() { + return 31*id.hashCode() + text.hashCode(); + } + public boolean equals(Object o) { + if (o == this) { + return true; + } else if (o instanceof Comment) { + Comment other = (Comment) o; + return this.id.equals(other.id) && this.text.equals(other.text); + } else { + return false; + } + } + } + + private static Pair pair(K key, V value) { + return new Pair(key, value); + } + private static final Projectable BASIC_RESULTS = projectable( row(1, "post 1", 1, "comment 1"), row(2, "post 2", 4, "comment 4"), @@ -71,10 +106,6 @@ public class GroupByTest { row(null, "null post", 8, "comment 8"), row(1, "post 1", 3, "comment 3") ); - - private static Pair pair(K key, V value) { - return new Pair(key, value); - } private static final Projectable MAP_RESULTS = projectable( row(1, "post 1", pair(1, "comment 1")), @@ -86,10 +117,21 @@ public class GroupByTest { row(1, "post 1", pair(3, "comment 3")) ); + private static final Projectable POST_W_COMMENTS_RESULTS = projectable( + row(1, "post 1", comment(1)), + row(1, "post 1", comment(2)), + row(2, "post 2", comment(5)), + row(3, "post 3", comment(6)), + row(null, "null post", comment(7)), + row(null, "null post", comment(8)), + row(1, "post 1", comment(3)) + ); + @Test public void Group_Order() { Map results = - GroupBy.create(postId).withOne(postName).withSet(commentId).transform(BASIC_RESULTS); + GroupBy.create(postId).withOne(postName).withSet(commentId) + .transform(BASIC_RESULTS); assertEquals(4, results.size()); } @@ -97,31 +139,34 @@ public class GroupByTest { @Test public void First_Set_And_List() { Map results = - GroupBy.create(postId).withOne(postName).withSet(commentId).withList(commentText).transform(BASIC_RESULTS); + GroupBy.create(postId).withOne(postName).withSet(commentId).withList(commentText) + .transform(BASIC_RESULTS); Group group = results.get(1); - assertEquals(toInt(1), group.getOne(postId)); - assertEquals("post 1", group.getOne(postName)); - assertEquals(toSet(1, 2, 3), group.getSet(commentId)); + assertEquals(toInt(1), group.getOne(postId)); + assertEquals("post 1", group.getOne(postName)); + assertEquals(toSet(1, 2, 3), group.getSet(commentId)); assertEquals(Arrays.asList("comment 1", "comment 2", "comment 3"), group.getList(commentText)); } @Test public void Group_By_Null() { Map results = - GroupBy.create(postId).withOne(postName).withSet(commentId).withList(commentText).transform(BASIC_RESULTS); + GroupBy.create(postId).withOne(postName).withSet(commentId).withList(commentText) + .transform(BASIC_RESULTS); Group group = results.get(null); assertNull(group.getOne(postId)); - assertEquals("null post", group.getOne(postName)); - assertEquals(toSet(7, 8), group.getSet(commentId)); + assertEquals("null post", group.getOne(postName)); + assertEquals(toSet(7, 8), group.getSet(commentId)); assertEquals(Arrays.asList("comment 7", "comment 8"), group.getList(commentText)); } @Test public void With_Constant_Column() { Map results = - GroupBy.create(postId).withOne(postName).withGroup(constant).transform(BASIC_RESULTS); + GroupBy.create(postId).withOne(postName).withGroup(constant) + .transform(BASIC_RESULTS); Group group = results.get(1); assertEquals("constant", group.getGroup(constant)); @@ -130,31 +175,54 @@ public class GroupByTest { @Test public void Map() { Map results = - GroupBy.create(postId).withOne(postName).withMap(commentId, commentText).transform(MAP_RESULTS); + GroupBy.create(postId).withOne(postName).withMap(commentId, commentText) + .transform(MAP_RESULTS); Group group = results.get(1); Map comments = group.getMap(commentId, commentText); assertEquals(3, comments.size()); assertEquals("comment 2", comments.get(2)); - - assertEquals(comments, group.getMap(commentId, String.class)); - assertEquals(comments, group.getMap(commentId, Object.class)); } @Test public void Array_Access() { Map results = - GroupBy.create(postId).withOne(postName).withSet(commentId).withList(commentText).transform(BASIC_RESULTS); + GroupBy.create(postId).withOne(postName).withSet(commentId).withList(commentText) + .transform(BASIC_RESULTS); Group group = results.get(1); Object[] array = group.toArray(); - assertEquals(toInt(1), array[0]); - assertEquals("post 1", array[1]); - assertEquals(toSet(1, 2, 3), array[2]); + assertEquals(toInt(1), array[0]); + assertEquals("post 1", array[1]); + assertEquals(toSet(1, 2, 3), array[2]); assertEquals(Arrays.asList("comment 1", "comment 2", "comment 3"), array[3]); } + @Test + public void Transform_Results() { + Map results = + GroupBy.create(postId, postName).withSet(qComment) + + .withTransformer(new Transformer() { + public Post transform(Group group) { + return new Post(group.getOne(postId), group.getOne(postName), group.getSet(qComment)); + } + }) + + .transform(POST_W_COMMENTS_RESULTS); + + Post post = results.get(1); + assertNotNull(post); + assertEquals(toInt(1), post.id); + assertEquals("post 1", post.name); + assertEquals(toSet(comment(1), comment(2), comment(3)), post.comments); + } + + private static Comment comment(Integer id) { + return new Comment(id, "comment " + id); + } + private static Projectable projectable(final Object[]... rows) { return new AbstractProjectable(){ public CloseableIterator iterate(Expression[] args) { diff --git a/querydsl-sql/src/test/java/com/mysema/query/SelectBaseTest.java b/querydsl-sql/src/test/java/com/mysema/query/SelectBaseTest.java index d54679c21..b7dbd0eab 100644 --- a/querydsl-sql/src/test/java/com/mysema/query/SelectBaseTest.java +++ b/querydsl-sql/src/test/java/com/mysema/query/SelectBaseTest.java @@ -1032,8 +1032,11 @@ public abstract class SelectBaseTest extends AbstractBaseTest{ .from(employee) .innerJoin(employee._superiorIdKey, employee2); - Map results = new GroupBy(employee.id, employee.firstname, employee.lastname) - .withMap(employee2.id, new QTuple(employee2.id, employee2.firstname, employee2.lastname)) + QTuple subordinates = new QTuple(employee2.id, employee2.firstname, employee2.lastname); + + // {id:1, firstname:"Mike", lastname:"Smith", subordinates: [{id:, firstname:, lastname:}, {id:, firstname:, lastname:}...] + Map results = GroupBy.create(employee.id, employee.firstname, employee.lastname) + .withMap(employee2.id, subordinates) .transform(qry); assertEquals(2, results.size()); @@ -1043,7 +1046,7 @@ public abstract class SelectBaseTest extends AbstractBaseTest{ assertEquals("Mike", group.getOne(employee.firstname)); assertEquals("Smith", group.getOne(employee.lastname)); - Map emps = group.getMap(employee2.id, Tuple.class); + Map emps = group.getMap(employee2.id, subordinates); assertEquals(4, emps.size()); assertEquals("Steve", emps.get(12).get(employee2.firstname)); @@ -1052,7 +1055,7 @@ public abstract class SelectBaseTest extends AbstractBaseTest{ assertEquals("Mary", group.getOne(employee.firstname)); assertEquals("Smith", group.getOne(employee.lastname)); - emps = group.getMap(employee2.id, Tuple.class); + emps = group.getMap(employee2.id, subordinates); assertEquals(4, emps.size()); assertEquals("Mason", emps.get(21).get(employee2.lastname)); }