querydsl upgrade

pom.xml

@@ -17,7 +17,7 @@
 		<java.version>1.8</java.version>
 		<dropwizard.version>0.9.0-rc1</dropwizard.version>
 		<guice.version>4.0</guice.version>
-		<querydsl.version>3.6.4</querydsl.version>
+		<querydsl.version>4.0.2</querydsl.version>
 		<rome.version>1.5.0</rome.version>
 	</properties>
 
@@ -265,14 +265,14 @@
 		</dependency>
 
 		<dependency>
-			<groupId>com.mysema.querydsl</groupId>
+			<groupId>com.querydsl</groupId>
 			<artifactId>querydsl-apt</artifactId>
 			<version>${querydsl.version}</version>
 			<scope>provided</scope>
 			<classifier>hibernate</classifier>
 		</dependency>
 		<dependency>
-			<groupId>com.mysema.querydsl</groupId>
+			<groupId>com.querydsl</groupId>
 			<artifactId>querydsl-jpa</artifactId>
 			<version>${querydsl.version}</version>
 		</dependency>

src/main/java/com/commafeed/backend/dao/FeedCategoryDAO.java

@@ -13,7 +13,7 @@ import com.commafeed.backend.model.FeedCategory;
 import com.commafeed.backend.model.QFeedCategory;
 import com.commafeed.backend.model.QUser;
 import com.commafeed.backend.model.User;
-import com.mysema.query.types.Predicate;
+import com.querydsl.core.types.Predicate;
 
 @Singleton
 public class FeedCategoryDAO extends GenericDAO<FeedCategory> {
@@ -26,11 +26,11 @@ public class FeedCategoryDAO extends GenericDAO<FeedCategory> {
 	}
 
 	public List<FeedCategory> findAll(User user) {
-		return newQuery().from(category).where(category.user.eq(user)).join(category.user, QUser.user).fetch().list(category);
+		return query().selectFrom(category).where(category.user.eq(user)).join(category.user, QUser.user).fetchJoin().fetch();
 	}
 
 	public FeedCategory findById(User user, Long id) {
-		return newQuery().from(category).where(category.user.eq(user), category.id.eq(id)).uniqueResult(category);
+		return query().selectFrom(category).where(category.user.eq(user), category.id.eq(id)).fetchOne();
 	}
 
 	public FeedCategory findByName(User user, String name, FeedCategory parent) {
@@ -40,7 +40,7 @@ public class FeedCategoryDAO extends GenericDAO<FeedCategory> {
 		} else {
 			parentPredicate = category.parent.eq(parent);
 		}
-		return newQuery().from(category).where(category.user.eq(user), category.name.eq(name), parentPredicate).uniqueResult(category);
+		return query().selectFrom(category).where(category.user.eq(user), category.name.eq(name), parentPredicate).fetchOne();
 	}
 
 	public List<FeedCategory> findByParent(User user, FeedCategory parent) {
@@ -50,7 +50,7 @@ public class FeedCategoryDAO extends GenericDAO<FeedCategory> {
 		} else {
 			parentPredicate = category.parent.eq(parent);
 		}
-		return newQuery().from(category).where(category.user.eq(user), parentPredicate).list(category);
+		return query().selectFrom(category).where(category.user.eq(user), parentPredicate).fetch();
 	}
 
 	public List<FeedCategory> findAllChildrenCategories(User user, FeedCategory parent) {

src/main/java/com/commafeed/backend/dao/FeedDAO.java

@@ -15,8 +15,9 @@ import com.commafeed.backend.model.QFeed;
 import com.commafeed.backend.model.QFeedSubscription;
 import com.commafeed.backend.model.QUser;
 import com.google.common.collect.Iterables;
-import com.mysema.query.jpa.hibernate.HibernateQuery;
+import com.querydsl.jpa.JPAExpressions;
-import com.mysema.query.jpa.hibernate.HibernateSubQuery;
+import com.querydsl.jpa.JPQLQuery;
+import com.querydsl.jpa.hibernate.HibernateQuery;
 
 @Singleton
 public class FeedDAO extends GenericDAO<Feed> {
@@ -29,23 +30,23 @@ public class FeedDAO extends GenericDAO<Feed> {
 	}
 
 	public List<Feed> findNextUpdatable(int count, Date lastLoginThreshold) {
-		HibernateQuery query = newQuery().from(feed);
+		HibernateQuery<Feed> query = query().selectFrom(feed);
 		query.where(feed.disabledUntil.isNull().or(feed.disabledUntil.lt(new Date())));
 
 		if (lastLoginThreshold != null) {
 			QFeedSubscription subs = QFeedSubscription.feedSubscription;
 			QUser user = QUser.user;
 
-			HibernateSubQuery subQuery = new HibernateSubQuery().from(subs);
+			JPQLQuery<Integer> subQuery = JPAExpressions.selectOne().from(subs);
 			subQuery.join(subs.user, user).where(user.lastLogin.gt(lastLoginThreshold));
 			query.where(subQuery.exists());
 		}
 
-		return query.orderBy(feed.disabledUntil.asc()).limit(count).distinct().list(feed);
+		return query.orderBy(feed.disabledUntil.asc()).limit(count).distinct().fetch();
 	}
 
 	public Feed findByUrl(String normalizedUrl) {
-		List<Feed> feeds = newQuery().from(feed).where(feed.normalizedUrlHash.eq(DigestUtils.sha1Hex(normalizedUrl))).list(feed);
+		List<Feed> feeds = query().selectFrom(feed).where(feed.normalizedUrlHash.eq(DigestUtils.sha1Hex(normalizedUrl))).fetch();
 		Feed feed = Iterables.getFirst(feeds, null);
 		if (feed != null && StringUtils.equals(normalizedUrl, feed.getNormalizedUrl())) {
 			return feed;
@@ -54,12 +55,12 @@ public class FeedDAO extends GenericDAO<Feed> {
 	}
 
 	public List<Feed> findByTopic(String topic) {
-		return newQuery().from(feed).where(feed.pushTopicHash.eq(DigestUtils.sha1Hex(topic))).list(feed);
+		return query().selectFrom(feed).where(feed.pushTopicHash.eq(DigestUtils.sha1Hex(topic))).fetch();
 	}
 
 	public List<Feed> findWithoutSubscriptions(int max) {
 		QFeedSubscription sub = QFeedSubscription.feedSubscription;
-		return newQuery().from(feed).where(new HibernateSubQuery().from(sub).where(sub.feed.eq(feed)).notExists()).limit(max).list(feed);
+		return query().selectFrom(feed).where(JPAExpressions.selectOne().from(sub).where(sub.feed.eq(feed)).notExists()).limit(max)
-		// return newQuery().from(feed).leftJoin(feed.subscriptions, sub).where(sub.id.isNull()).limit(max).list(feed);
+				.fetch();
 	}
 }

src/main/java/com/commafeed/backend/dao/FeedEntryContentDAO.java

@@ -10,13 +10,14 @@ import org.hibernate.SessionFactory;
 import com.commafeed.backend.model.FeedEntryContent;
 import com.commafeed.backend.model.QFeedEntry;
 import com.commafeed.backend.model.QFeedEntryContent;
-import com.google.common.collect.Iterables;
+import com.querydsl.jpa.JPAExpressions;
-import com.mysema.query.jpa.hibernate.HibernateSubQuery;
+import com.querydsl.jpa.JPQLQuery;
 
 @Singleton
 public class FeedEntryContentDAO extends GenericDAO<FeedEntryContent> {
 
 	private QFeedEntryContent content = QFeedEntryContent.feedEntryContent;
+	private QFeedEntry entry = QFeedEntry.feedEntry;
 
 	@Inject
 	public FeedEntryContentDAO(SessionFactory sessionFactory) {
@@ -24,16 +25,14 @@ public class FeedEntryContentDAO extends GenericDAO<FeedEntryContent> {
 	}
 
 	public Long findExisting(String contentHash, String titleHash) {
-		List<Long> list = newQuery().from(content).where(content.contentHash.eq(contentHash), content.titleHash.eq(titleHash)).limit(1)
+		return query().select(content.id).from(content).where(content.contentHash.eq(contentHash), content.titleHash.eq(titleHash))
-				.list(content.id);
+				.fetchFirst();
-		return Iterables.getFirst(list, null);
 	}
 
 	public int deleteWithoutEntries(int max) {
-		QFeedEntry entry = QFeedEntry.feedEntry;
 
-		HibernateSubQuery subQuery = new HibernateSubQuery().from(entry).where(entry.content.id.eq(content.id));
+		JPQLQuery<Integer> subQuery = JPAExpressions.selectOne().from(entry).where(entry.content.id.eq(content.id));
-		List<FeedEntryContent> list = newQuery().from(content).where(subQuery.notExists()).limit(max).list(content);
+		List<FeedEntryContent> list = query().selectFrom(content).where(subQuery.notExists()).limit(max).fetch();
 
 		int deleted = list.size();
 		delete(list);

src/main/java/com/commafeed/backend/dao/FeedEntryDAO.java

@@ -6,18 +6,17 @@ import java.util.stream.Collectors;
 import javax.inject.Inject;
 import javax.inject.Singleton;
 
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
 import org.apache.commons.codec.digest.DigestUtils;
 import org.hibernate.SessionFactory;
 
 import com.commafeed.backend.model.Feed;
 import com.commafeed.backend.model.FeedEntry;
 import com.commafeed.backend.model.QFeedEntry;
-import com.google.common.collect.Iterables;
+import com.querydsl.core.Tuple;
-import com.mysema.query.Tuple;
+import com.querydsl.core.types.dsl.NumberExpression;
-import com.mysema.query.types.expr.NumberExpression;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
 
 @Singleton
 public class FeedEntryDAO extends GenericDAO<FeedEntry> {
@@ -30,24 +29,25 @@ public class FeedEntryDAO extends GenericDAO<FeedEntry> {
 	}
 
 	public Long findExisting(String guid, Feed feed) {
-		List<Long> list = newQuery().from(entry).where(entry.guidHash.eq(DigestUtils.sha1Hex(guid)), entry.feed.eq(feed)).limit(1)
+		return query().select(entry.id).from(entry).where(entry.guidHash.eq(DigestUtils.sha1Hex(guid)), entry.feed.eq(feed)).limit(1)
-				.list(entry.id);
+				.fetchOne();
-		return Iterables.getFirst(list, null);
 	}
 
 	public List<FeedCapacity> findFeedsExceedingCapacity(long maxCapacity, long max) {
 		NumberExpression<Long> count = entry.id.count();
-		List<Tuple> tuples = newQuery().from(entry).groupBy(entry.feed).having(count.gt(maxCapacity)).limit(max).list(entry.feed.id, count);
+		List<Tuple> tuples = query().select(entry.feed.id, count).from(entry).groupBy(entry.feed).having(count.gt(maxCapacity)).limit(max)
+				.fetch();
 		return tuples.stream().map(t -> new FeedCapacity(t.get(entry.feed.id), t.get(count))).collect(Collectors.toList());
 	}
 
 	public int delete(Long feedId, long max) {
-		List<FeedEntry> list = newQuery().from(entry).where(entry.feed.id.eq(feedId)).limit(max).list(entry);
+
+		List<FeedEntry> list = query().selectFrom(entry).where(entry.feed.id.eq(feedId)).limit(max).fetch();
 		return delete(list);
 	}
 
 	public int deleteOldEntries(Long feedId, long max) {
-		List<FeedEntry> list = newQuery().from(entry).where(entry.feed.id.eq(feedId)).orderBy(entry.updated.asc()).limit(max).list(entry);
+		List<FeedEntry> list = query().selectFrom(entry).where(entry.feed.id.eq(feedId)).orderBy(entry.updated.asc()).limit(max).fetch();
 		return delete(list);
 	}
 

src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java

@@ -30,9 +30,9 @@ import com.commafeed.backend.model.UserSettings.ReadingOrder;
 import com.commafeed.frontend.model.UnreadCount;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Ordering;
-import com.mysema.query.BooleanBuilder;
+import com.querydsl.core.BooleanBuilder;
-import com.mysema.query.Tuple;
+import com.querydsl.core.Tuple;
-import com.mysema.query.jpa.hibernate.HibernateQuery;
+import com.querydsl.jpa.hibernate.HibernateQuery;
 
 @Singleton
 public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
@@ -68,7 +68,7 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 	private static final Comparator<FeedEntryStatus> STATUS_COMPARATOR_ASC = Ordering.from(STATUS_COMPARATOR_DESC).reverse();
 
 	public FeedEntryStatus getStatus(User user, FeedSubscription sub, FeedEntry entry) {
-		List<FeedEntryStatus> statuses = newQuery().from(status).where(status.entry.eq(entry), status.subscription.eq(sub)).list(status);
+		List<FeedEntryStatus> statuses = query().selectFrom(status).where(status.entry.eq(entry), status.subscription.eq(sub)).fetch();
 		FeedEntryStatus status = Iterables.getFirst(statuses, null);
 		return handleStatus(user, status, sub, entry);
 	}
@@ -93,7 +93,7 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 	}
 
 	public List<FeedEntryStatus> findStarred(User user, Date newerThan, int offset, int limit, ReadingOrder order, boolean includeContent) {
-		HibernateQuery query = newQuery().from(status).where(status.user.eq(user), status.starred.isTrue());
+		HibernateQuery<FeedEntryStatus> query = query().selectFrom(status).where(status.user.eq(user), status.starred.isTrue());
 		if (newerThan != null) {
 			query.where(status.entryInserted.gt(newerThan));
 		}
@@ -110,7 +110,7 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 			query.setTimeout(timeout / 1000);
 		}
 
-		List<FeedEntryStatus> statuses = query.list(status);
+		List<FeedEntryStatus> statuses = query.fetch();
 		for (FeedEntryStatus status : statuses) {
 			status = handleStatus(user, status, status.getSubscription(), status.getEntry());
 			fetchTags(user, status);
@@ -118,10 +118,10 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 		return lazyLoadContent(includeContent, statuses);
 	}
 
-	private HibernateQuery buildQuery(User user, FeedSubscription sub, boolean unreadOnly, List<FeedEntryKeyword> keywords, Date newerThan,
+	private HibernateQuery<FeedEntry> buildQuery(User user, FeedSubscription sub, boolean unreadOnly, List<FeedEntryKeyword> keywords,
-			int offset, int limit, ReadingOrder order, Date last, String tag) {
+			Date newerThan, int offset, int limit, ReadingOrder order, Date last, String tag) {
 
-		HibernateQuery query = newQuery().from(entry).where(entry.feed.eq(sub.getFeed()));
+		HibernateQuery<FeedEntry> query = query().selectFrom(entry).where(entry.feed.eq(sub.getFeed()));
 
 		if (CollectionUtils.isNotEmpty(keywords)) {
 			query.join(entry.content, content);
@@ -197,8 +197,8 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 		FixedSizeSortedSet<FeedEntryStatus> set = new FixedSizeSortedSet<FeedEntryStatus>(capacity, comparator);
 		for (FeedSubscription sub : subs) {
 			Date last = (order != null && set.isFull()) ? set.last().getEntryUpdated() : null;
-			HibernateQuery query = buildQuery(user, sub, unreadOnly, keywords, newerThan, -1, capacity, order, last, tag);
+			HibernateQuery<FeedEntry> query = buildQuery(user, sub, unreadOnly, keywords, newerThan, -1, capacity, order, last, tag);
-			List<Tuple> tuples = query.list(entry.id, entry.updated, status.id);
+			List<Tuple> tuples = query.select(entry.id, entry.updated, status.id).fetch();
 			for (Tuple tuple : tuples) {
 				Long id = tuple.get(entry.id);
 				Date updated = tuple.get(entry.updated);
@@ -245,8 +245,8 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 
 	public UnreadCount getUnreadCount(User user, FeedSubscription subscription) {
 		UnreadCount uc = null;
-		HibernateQuery query = buildQuery(user, subscription, true, null, null, -1, -1, null, null, null);
+		HibernateQuery<FeedEntry> query = buildQuery(user, subscription, true, null, null, -1, -1, null, null, null);
-		List<Tuple> tuples = query.list(entry.count(), entry.updated.max());
+		List<Tuple> tuples = query.select(entry.count(), entry.updated.max()).fetch();
 		for (Tuple tuple : tuples) {
 			Long count = tuple.get(entry.count());
 			Date updated = tuple.get(entry.updated.max());
@@ -266,7 +266,7 @@ public class FeedEntryStatusDAO extends GenericDAO<FeedEntryStatus> {
 	}
 
 	public List<FeedEntryStatus> getOldStatuses(Date olderThan, int limit) {
-		return newQuery().from(status).where(status.entryInserted.lt(olderThan), status.starred.isFalse()).limit(limit).list(status);
+		return query().selectFrom(status).where(status.entryInserted.lt(olderThan), status.starred.isFalse()).limit(limit).fetch();
 	}
 
 }

src/main/java/com/commafeed/backend/dao/FeedEntryTagDAO.java

@@ -23,10 +23,10 @@ public class FeedEntryTagDAO extends GenericDAO<FeedEntryTag> {
 	}
 
 	public List<String> findByUser(User user) {
-		return newQuery().from(tag).where(tag.user.eq(user)).distinct().list(tag.name);
+		return query().selectDistinct(tag.name).from(tag).where(tag.user.eq(user)).fetch();
 	}
 
 	public List<FeedEntryTag> findByEntry(User user, FeedEntry entry) {
-		return newQuery().from(tag).where(tag.user.eq(user), tag.entry.eq(entry)).list(tag);
+		return query().selectFrom(tag).where(tag.user.eq(user), tag.entry.eq(entry)).fetch();
 	}
 }

src/main/java/com/commafeed/backend/dao/FeedSubscriptionDAO.java

@@ -16,7 +16,7 @@ import com.commafeed.backend.model.Models;
 import com.commafeed.backend.model.QFeedSubscription;
 import com.commafeed.backend.model.User;
 import com.google.common.collect.Iterables;
-import com.mysema.query.jpa.hibernate.HibernateQuery;
+import com.querydsl.jpa.hibernate.HibernateQuery;
 
 @Singleton
 public class FeedSubscriptionDAO extends GenericDAO<FeedSubscription> {
@@ -29,34 +29,34 @@ public class FeedSubscriptionDAO extends GenericDAO<FeedSubscription> {
 	}
 
 	public FeedSubscription findById(User user, Long id) {
-		List<FeedSubscription> subs = newQuery().from(sub).where(sub.user.eq(user), sub.id.eq(id)).leftJoin(sub.feed).fetch()
+		List<FeedSubscription> subs = query().selectFrom(sub).where(sub.user.eq(user), sub.id.eq(id)).leftJoin(sub.feed).fetchJoin()
-				.leftJoin(sub.category).fetch().list(sub);
+				.leftJoin(sub.category).fetchJoin().fetch();
 		return initRelations(Iterables.getFirst(subs, null));
 	}
 
 	public List<FeedSubscription> findByFeed(Feed feed) {
-		return newQuery().from(sub).where(sub.feed.eq(feed)).list(sub);
+		return query().selectFrom(sub).where(sub.feed.eq(feed)).fetch();
 	}
 
 	public FeedSubscription findByFeed(User user, Feed feed) {
-		List<FeedSubscription> subs = newQuery().from(sub).where(sub.user.eq(user), sub.feed.eq(feed)).list(sub);
+		List<FeedSubscription> subs = query().selectFrom(sub).where(sub.user.eq(user), sub.feed.eq(feed)).fetch();
 		return initRelations(Iterables.getFirst(subs, null));
 	}
 
 	public List<FeedSubscription> findAll(User user) {
-		List<FeedSubscription> subs = newQuery().from(sub).where(sub.user.eq(user)).leftJoin(sub.feed).fetch().leftJoin(sub.category)
+		List<FeedSubscription> subs = query().selectFrom(sub).where(sub.user.eq(user)).leftJoin(sub.feed).fetchJoin()
-				.fetch().list(sub);
+				.leftJoin(sub.category).fetchJoin().fetch();
 		return initRelations(subs);
 	}
 
 	public List<FeedSubscription> findByCategory(User user, FeedCategory category) {
-		HibernateQuery query = newQuery().from(sub).where(sub.user.eq(user));
+		HibernateQuery<FeedSubscription> query = query().selectFrom(sub).where(sub.user.eq(user));
 		if (category == null) {
 			query.where(sub.category.isNull());
 		} else {
 			query.where(sub.category.eq(category));
 		}
-		return initRelations(query.list(sub));
+		return initRelations(query.fetch());
 	}
 
 	public List<FeedSubscription> findByCategories(User user, List<FeedCategory> categories) {

src/main/java/com/commafeed/backend/dao/GenericDAO.java

@@ -1,22 +1,25 @@
 package com.commafeed.backend.dao;
 
-import io.dropwizard.hibernate.AbstractDAO;
-
 import java.util.Collection;
 
 import org.hibernate.SessionFactory;
 
 import com.commafeed.backend.model.AbstractModel;
-import com.mysema.query.jpa.hibernate.HibernateQuery;
+import com.querydsl.jpa.hibernate.HibernateQueryFactory;
+
+import io.dropwizard.hibernate.AbstractDAO;
 
 public abstract class GenericDAO<T extends AbstractModel> extends AbstractDAO<T> {
 
+	private HibernateQueryFactory factory;
+
 	protected GenericDAO(SessionFactory sessionFactory) {
 		super(sessionFactory);
+		this.factory = new HibernateQueryFactory(() -> currentSession());
 	}
 
-	protected HibernateQuery newQuery() {
+	protected HibernateQueryFactory query() {
-		return new HibernateQuery(currentSession());
+		return factory;
 	}
 
 	public void saveOrUpdate(T model) {

src/main/java/com/commafeed/backend/dao/UserDAO.java

@@ -19,18 +19,18 @@ public class UserDAO extends GenericDAO<User> {
 	}
 
 	public User findByName(String name) {
-		return newQuery().from(user).where(user.name.equalsIgnoreCase(name)).uniqueResult(user);
+		return query().selectFrom(user).where(user.name.equalsIgnoreCase(name)).fetchOne();
 	}
 
 	public User findByApiKey(String key) {
-		return newQuery().from(user).where(user.apiKey.equalsIgnoreCase(key)).uniqueResult(user);
+		return query().selectFrom(user).where(user.apiKey.equalsIgnoreCase(key)).fetchOne();
 	}
 
 	public User findByEmail(String email) {
-		return newQuery().from(user).where(user.email.equalsIgnoreCase(email)).uniqueResult(user);
+		return query().selectFrom(user).where(user.email.equalsIgnoreCase(email)).fetchOne();
 	}
 
 	public long count() {
-		return newQuery().from(user).count();
+		return query().selectFrom(user).fetchCount();
 	}
 }

src/main/java/com/commafeed/backend/dao/UserRoleDAO.java

@@ -25,11 +25,11 @@ public class UserRoleDAO extends GenericDAO<UserRole> {
 	}
 
 	public List<UserRole> findAll() {
-		return newQuery().from(role).leftJoin(role.user).fetch().distinct().list(role);
+		return query().selectFrom(role).leftJoin(role.user).fetchJoin().distinct().fetch();
 	}
 
 	public List<UserRole> findAll(User user) {
-		return newQuery().from(role).where(role.user.eq(user)).distinct().list(role);
+		return query().selectFrom(role).where(role.user.eq(user)).distinct().fetch();
 	}
 
 	public Set<Role> findRoles(User user) {

src/main/java/com/commafeed/backend/dao/UserSettingsDAO.java

@@ -20,6 +20,6 @@ public class UserSettingsDAO extends GenericDAO<UserSettings> {
 	}
 
 	public UserSettings findByUser(User user) {
-		return newQuery().from(settings).where(settings.user.eq(user)).uniqueResult(settings);
+		return query().selectFrom(settings).where(settings.user.eq(user)).fetchFirst();
 	}
 }