@Test public void map_sorted() { Map<Integer, Group> results = MAP_RESULTS.transform( groupBy(postId).as(postName, sortedMap(commentId, commentText))); Group group = results.get(1); Iterator<Map.Entry<Integer, String>> 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 map2() { List<Map<Integer, String>> results = MAP2_RESULTS.transform( groupBy(postId).list(map(commentId, commentText))); assertEquals(4, results.size()); Map<Integer, String> comments = results.get(1); assertEquals(3, comments.size()); assertEquals("comment 2", comments.get(2)); }
/** * Create a new GroupByBuilder for the given key expression * * @param key key for aggregation * @return builder for further specification */ public static <K> GroupByBuilder<K> groupBy(Expression<K> key) { return new GroupByBuilder<K>(key); }
public AbstractVersionStoreJdbc(Options options) { this.options = options; versionAndParentColumns = without(concat(options.version.all(), GroupBy.set(options.parent.parentRevision)), options.version.revision); versionAndParents = groupBy(options.version.revision).list(versionAndParentColumns); Expression<?>[] propertyColumns = without(options.property.all(), options.property.revision); properties = groupBy(options.property.revision).as(GroupBy.list(tuple(propertyColumns))); this.cache = options.cacheBuilder.apply(this); this.cacheLoader = this.cache != null ? this.cache::load : this::getOptimizedGraph; }
@Test public void map2() { CloseableIterator<Map<Integer, String>> resultsIt = MAP2_RESULTS.transform( groupBy(postId).iterate(map(commentId, commentText))); List<Map<Integer, String>> results = IteratorAdapter.asList(resultsIt); assertEquals(4, results.size()); Map<Integer, String> comments = results.get(1); assertEquals(3, comments.size()); assertEquals("comment 2", comments.get(2)); }
/** * Get the results as a closeable iterator * * @param expression projection * @return new result transformer */ public <V> ResultTransformer<CloseableIterator<V>> iterate(Expression<V> expression) { final Expression<V> lookup = getLookup(expression); return new GroupByIterate<K, V>(key, expression) { @Override protected V transform(Group group) { return group.getOne(lookup); } }; }
@Test public void map1() { CloseableIterator<Group> resultsIt = MAP_RESULTS.transform( groupBy(postId).iterate(postName, map(commentId, commentText))); List<Group> results = IteratorAdapter.asList(resultsIt); assertEquals(4, results.size()); Group group = results.get(1); Map<Integer, String> comments = group.getMap(commentId, commentText); assertEquals(3, comments.size()); assertEquals("comment 2", comments.get(2)); }
/** * Get the results as a list * * @param expression projection * @return new result transformer */ public <V> ResultTransformer<List<V>> list(Expression<V> expression) { final Expression<V> lookup = getLookup(expression); return new GroupByList<K, V>(key, expression) { @Override protected V transform(Group group) { return group.getOne(lookup); } }; }
@Test public void map_sorted_reverse() { Map<Integer, Group> results = MAP_RESULTS.transform( groupBy(postId).as(postName, sortedMap(commentId, commentText, Ordering.natural().reverse()))); Group group = results.get(1); Iterator<Map.Entry<Integer, String>> 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 map1() { List<Group> results = MAP_RESULTS.transform( groupBy(postId).list(postName, map(commentId, commentText))); assertEquals(4, results.size()); Group group = results.get(1); Map<Integer, String> comments = group.getMap(commentId, commentText); assertEquals(3, comments.size()); assertEquals("comment 2", comments.get(2)); }
@Test public void map22() { CloseableIterator<Map<Integer, String>> results = MAP2_RESULTS.transform( groupBy(postId).iterate(map(commentId, commentText))); List<Map<Integer, String>> actual = IteratorAdapter.asList(results); Object commentId = null; Map<Integer, String> comments = null; List<Map<Integer, String>> expected = new LinkedList<Map<Integer, String>>(); for (Iterator<Tuple> iterator = MAP2_RESULTS.iterate(); iterator.hasNext();) { Tuple tuple = iterator.next(); Object[] array = tuple.toArray(); if (comments == null || !(commentId == array[0] || commentId != null && commentId.equals(array[0]))) { comments = new LinkedHashMap<Integer,String>(); expected.add(comments); } commentId = array[0]; @SuppressWarnings("unchecked") Pair<Integer, String> pair = (Pair<Integer, String>) array[1]; comments.put(pair.getFirst(), pair.getSecond()); } assertEquals(expected.toString(), actual.toString()); }
/** * Get the results as a map * * @param expression projection * @return new result transformer */ @SuppressWarnings("unchecked") public <V> ResultTransformer<Map<K, V>> as(Expression<V> expression) { final Expression<V> lookup = getLookup(expression); return new GroupByMap<K, V>(key, expression) { @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(), entry.getValue().getOne(lookup)); } return results; } }; }
/** * Create a new GroupByBuilder for the given key expressions * * @param keys keys for aggregation * @return builder for further specification */ public static GroupByBuilder<List<?>> groupBy(Expression<?>... keys) { return new GroupByBuilder<List<?>>(Projections.list(keys)); }
@Test public void set_by_sorted() { Map<Integer, Group> results = BASIC_RESULTS_UNORDERED .transform(groupBy(postId).as(postName, sortedSet(commentId))); Group group = results.get(1); Iterator<Integer> it = group.getSet(commentId).iterator(); assertEquals(1, it.next().intValue()); assertEquals(2, it.next().intValue()); assertEquals(3, it.next().intValue()); }
@Test public void group_order() { List<Group> results = BASIC_RESULTS .transform(groupBy(postId).list(postName, set(commentId))); assertEquals(4, results.size()); }
@Test public void map4() { CloseableIterator<Map<Map<Integer, String>, String>> results = MAP4_RESULTS.transform( groupBy(postId).iterate(map(map(postId, commentText), postName))); List<Map<Map<Integer, String>, String>> actual = IteratorAdapter.asList(results); Object commentId = null; Map<Map<Integer, String>, String> comments = null; List<Map<Map<Integer, String>, String>> expected = new LinkedList<Map<Map<Integer, String>, String>>(); for (Iterator<Tuple> iterator = MAP4_RESULTS.iterate(); iterator.hasNext();) { Tuple tuple = iterator.next(); Object[] array = tuple.toArray(); if (comments == null || !(commentId == array[0] || commentId != null && commentId.equals(array[0]))) { comments = new LinkedHashMap<Map<Integer, String>, String>(); expected.add(comments); } commentId = array[0]; @SuppressWarnings("unchecked") Pair<Pair<Integer, String>, String> pair = (Pair<Pair<Integer, String>, String>) array[1]; Pair<Integer, String> first = pair.getFirst(); Map<Integer, String> posts = Collections.singletonMap(first.getFirst(), first.getSecond()); comments.put(posts, pair.getSecond()); } assertEquals(expected.toString(), actual.toString()); }
/** * Get the results as a closeable iterator * * @param expression projection * @return new result transformer */ public <V> ResultTransformer<CloseableIterator<V>> iterate(Expression<V> expression) { final Expression<V> lookup = getLookup(expression); return new GroupByIterate<K, V>(key, expression) { @Override protected V transform(Group group) { return group.getOne(lookup); } }; }
/** * Create a new GroupByBuilder for the given key expression * * @param key key for aggregation * @return builder for further specification */ public static <K> GroupByBuilder<K> groupBy(Expression<K> key) { return new GroupByBuilder<K>(key); }
@Test public void set_by_sorted_reverse() { Map<Integer, Group> results = BASIC_RESULTS_UNORDERED .transform(groupBy(postId).as(postName, sortedSet(commentId, Ordering.natural().reverse()))); Group group = results.get(1); Iterator<Integer> it = group.getSet(commentId).iterator(); assertEquals(3, it.next().intValue()); assertEquals(2, it.next().intValue()); assertEquals(1, it.next().intValue()); }
@Test(expected = ClassCastException.class) public void classCastException() { List<Group> results = BASIC_RESULTS.transform( groupBy(postId).list(postName, set(commentId), list(commentText))); assertEquals(4, results.size()); Group group = results.get(1); group.getList(commentId); }