@Override protected V transform(Group group) { return group.getOne(lookup); } };
@Override protected V transform(Group group) { return group.getOne(lookup); } };
@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; } };
@Test public void group_by_null() { List<Group> results = BASIC_RESULTS.transform( groupBy(postId).list(postName, set(commentId), list(commentText))); assertEquals(4, results.size()); Group group = results.get(0); assertNull(group.getOne(postId)); 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 group_by_null() { Map<Integer, Group> results = BASIC_RESULTS.transform( groupBy(postId).as(postName, set(commentId), list(commentText))); Group group = results.get(null); assertNull(group.getOne(postId)); 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 first_set_and_list() { List<Group> results = BASIC_RESULTS.transform( groupBy(postId).list(postName, set(commentId), list(commentText))); assertEquals(4, results.size()); 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(Arrays.asList("comment 1", "comment 2", "comment 3"), group.getList(commentText)); }
@Test public void group_by_null() { CloseableIterator<Group> resultsIt = BASIC_RESULTS.transform( groupBy(postId).iterate(postName, set(commentId), list(commentText))); List<Group> results = IteratorAdapter.asList(resultsIt); assertEquals(4, results.size()); Group group = results.get(0); assertNull(group.getOne(postId)); 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 first_set_and_list() { Map<Integer, Group> results = BASIC_RESULTS.transform( groupBy(postId).as(postName, set(commentId), list(commentText))); 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(Arrays.asList("comment 1", "comment 2", "comment 3"), group.getList(commentText)); }
@Test public void first_set_and_list() { CloseableIterator<Group> resultsIt = BASIC_RESULTS.transform( groupBy(postId).iterate(postName, set(commentId), list(commentText))); List<Group> results = IteratorAdapter.asList(resultsIt); assertEquals(4, results.size()); 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(Arrays.asList("comment 1", "comment 2", "comment 3"), group.getList(commentText)); }
@Override protected V transform(Group group) { return group.getOne(lookup); } };
@Override protected V transform(Group group) { return group.getOne(lookup); } };
@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; } };
protected List<Group> verifyVersionsAndParentsSince(List<Group> versionsAndParents, Revision since) { if (versionsAndParents.isEmpty()) { throw new VersionNotFoundException(since); } if (versionsAndParents.size() == 1 && versionsAndParents.get(0).getOne(options.version.revision) == null) { return ImmutableList.of(); } return versionsAndParents; }
protected FetchResults<Id, M> fetch(List<Group> versionsAndParents, boolean optimized, BooleanExpression predicate) { if (versionsAndParents.isEmpty()) { return noResults; } Map<Revision, List<Tuple>> properties = fetchProperties(optimized, predicate); ListMultimap<Id, ObjectVersion<M>> results = ArrayListMultimap.create(); Revision latestRevision = null; for (Group versionAndParents : versionsAndParents) { Id id = versionAndParents.getOne(options.version.docId); latestRevision = versionAndParents.getOne(options.version.revision); Map<PropertyPath, Object> changeset = toChangeSet(properties.get(latestRevision)); results.put(id, buildVersion(latestRevision, versionAndParents, changeset)); } return new FetchResults<>(results, latestRevision); }
protected ObjectVersion<M> buildVersion(Revision rev, Group versionAndParents, Map<PropertyPath, Object> changeset) { if (!options.versionTableProperties.isEmpty()) { if (changeset == null) { changeset = new HashMap<>(); } for (Map.Entry<PropertyPath, Path<?>> entry : options.versionTableProperties.entrySet()) { PropertyPath path = entry.getKey(); @SuppressWarnings("unchecked") Path<Object> column = (Path<Object>) entry.getValue(); changeset.put(path, versionAndParents.getOne(column)); } } return new ObjectVersion.Builder<M>(rev) .branch(versionAndParents.getOne(options.version.branch)) .type(versionAndParents.getOne(options.version.type)) .parents(versionAndParents.getSet(options.parent.parentRevision)) .changeset(changeset) .meta(getMeta(versionAndParents)) .build(); }
@Override protected List<ObjectVersion<M>> doFetchUpdates(Id docId, Revision since) { List<Group> versionsAndParents = versionsAndParentsSince(docId, since); if (versionsAndParents.isEmpty()) { return ImmutableList.of(); } Long sinceOrdinal = versionsAndParents.get(0).getOne(options.sinceVersion.ordinal); BooleanExpression predicate = versionsOf(docId) .and(predicate(GT, options.version.ordinal, constant(sinceOrdinal))); FetchResults<Id, M> results = fetch(versionsAndParents, false, predicate); return results.containsKey(docId) ? results.getVersions(docId) : ImmutableList.of(); }
@Override protected List<ObjectVersion<M>> doFetchUpdates(Id docId, Revision since) { List<Group> versionsAndParents = versionsAndParentsSince(docId, since); if (versionsAndParents.isEmpty()) { return ImmutableList.of(); } Long sinceOrdinal = versionsAndParents.get(0).getOne(options.sinceVersion.localOrdinal); BooleanExpression predicate = versionsOf(docId) .and(predicate(GT, options.version.localOrdinal, constant(sinceOrdinal))); FetchResults<Id, M> results = fetch(versionsAndParents, false, predicate); return results.containsKey(docId) ? results.getVersions(docId) : ImmutableList.of(); }
@Test public void groupBy_superior() { SQLQuery<?> qry = query() .from(employee) .innerJoin(employee._superiorIdKey, employee2); QTuple subordinates = Projections.tuple(employee2.id, employee2.firstname, employee2.lastname); Map<Integer, Group> results = qry.transform( GroupBy.groupBy(employee.id).as(employee.firstname, employee.lastname, GroupBy.map(employee2.id, subordinates))); assertEquals(2, results.size()); // Mike Smith Group group = results.get(1); assertEquals("Mike", group.getOne(employee.firstname)); assertEquals("Smith", group.getOne(employee.lastname)); Map<Integer, Tuple> emps = group.getMap(employee2.id, subordinates); assertEquals(4, emps.size()); assertEquals("Steve", emps.get(12).get(employee2.firstname)); // Mary Smith group = results.get(2); assertEquals("Mary", group.getOne(employee.firstname)); assertEquals("Smith", group.getOne(employee.lastname)); emps = group.getMap(employee2.id, subordinates); assertEquals(4, emps.size()); assertEquals("Mason", emps.get(21).get(employee2.lastname)); }
@Test @ExcludeIn(DERBY) public void transform_groupBy_alias() { QCat kitten = new QCat("kitten"); SimplePath<Cat> k = Expressions.path(Cat.class, "k"); Map<Integer, Group> result = query().from(cat).innerJoin(cat.kittens, kitten) .transform(GroupBy.groupBy(cat.id) .as(cat.name, cat.id, GroupBy.list(Projections.constructor(Cat.class, kitten.name, kitten.id).as(k)))); for (Group entry : result.values()) { assertNotNull(entry.getOne(cat.id)); assertNotNull(entry.getOne(cat.name)); assertFalse(entry.getList(k).isEmpty()); } }