refactor query() to select() and add the clause as optional parameter

Author: Gerald Unterrainer

src/main/java/info/unterrainer/commons/httpserver/daos/BasicJpqlDao.java

@@ -262,7 +262,7 @@ else if (!orderBy.isBlank())
 		return q;
 	}
 
-	private boolean isAllowed(final info.unterrainer.commons.httpserver.daos.QueryBuilder query,
+	private boolean isAllowed(final info.unterrainer.commons.httpserver.daos.SelectQueryBuilder query,
 			final EntityManager em) {
 		String tenantReferenceField = "testId";
 		String tenantIdField = "tenantId";

src/main/java/info/unterrainer/commons/httpserver/daos/BasicQueryBuilder.java renamed to src/main/java/info/unterrainer/commons/httpserver/daos/BasicSelectQueryBuilder.java

@@ -11,7 +11,7 @@
 import lombok.RequiredArgsConstructor;
 
 @RequiredArgsConstructor(access = AccessLevel.PACKAGE)
-public class BasicQueryBuilder<P extends BasicJpa, T, R extends BasicQueryBuilder<P, T, R>> {
+public class BasicSelectQueryBuilder<P extends BasicJpa, T, R extends BasicSelectQueryBuilder<P, T, R>> {
 
 	protected final EntityManagerFactory emf;
 	protected final BasicJpqlDao<P> dao;
@@ -41,22 +41,10 @@ public R entityManager(final EntityManager em) {
 		return (R) this;
 	}
 
-	/**
-	 * Sets a custom select-clause.
-	 * <p>
-	 * Default is "o"<br>
-	 * To reset it to default, set it to null.<br>
-	 * To completely delete it, set it to an empty string.
-	 *
-	 * @param selectClause the new clause
-	 * @return an instance of this builder to provide a fluent interface
-	 */
-	@SuppressWarnings("unchecked")
-	public R select(final String selectClause) {
+	void setSelect(final String selectClause) {
 		this.selectClause = selectClause;
 		if (this.selectClause == null || this.selectClause.isBlank())
 			this.selectClause = "o";
-		return (R) this;
 	}
 
 	/**

src/main/java/info/unterrainer/commons/httpserver/daos/Query.java renamed to src/main/java/info/unterrainer/commons/httpserver/daos/Dml.java

@@ -17,7 +17,7 @@
 import lombok.RequiredArgsConstructor;
 
 @RequiredArgsConstructor(access = AccessLevel.PACKAGE)
-public class Query<P extends BasicJpa, T> {
+public class Dml<P extends BasicJpa, T> {
 
 	protected final EntityManagerFactory emf;
 	protected final QueryInterface<P, T> builder;

src/main/java/info/unterrainer/commons/httpserver/daos/JpqlAsyncDao.java

@@ -6,15 +6,67 @@
 
 public class JpqlAsyncDao<P extends BasicAsyncJpa> extends BasicJpqlDao<P> {
 
+	/**
+	 * Generates a DAO that lets you build and execute queries.
+	 *
+	 * @param emf  the {@link EntityManagerFactory} to use
+	 * @param type the return-type of the query (the underlying JPA)
+	 */
 	public JpqlAsyncDao(final EntityManagerFactory emf, final Class<P> type) {
 		super(emf, type);
 	}
 
-	public QueryAsyncBuilder<P, P> query() {
-		return new QueryAsyncBuilder<>(emf, this, type);
+	/**
+	 * Build a SELECT(*)-like query. The result will be of the underlying generic
+	 * type.
+	 *
+	 * @return a query-builder
+	 */
+	public SelectAsyncQueryBuilder<P, P> select() {
+		return new SelectAsyncQueryBuilder<>(emf, this, type);
 	}
 
-	public <T> QueryAsyncBuilder<P, T> query(final Class<T> resultType) {
-		return new QueryAsyncBuilder<>(emf, this, resultType);
+	/**
+	 * Build a SELECT(*)-like query. The result will be of the given type (use this
+	 * for a COUNT(*) query, for example).
+	 *
+	 * @param <T>        the type the result will be
+	 * @param resultType the type the result will be
+	 * @return a query-builder
+	 */
+	public <T> SelectAsyncQueryBuilder<P, T> select(final Class<T> resultType) {
+		return new SelectAsyncQueryBuilder<>(emf, this, resultType);
+	}
+
+	/**
+	 * Build a SELECT-query with a custom select-clause. The result will be of the
+	 * given type (use this for a COUNT(*) query, for example).
+	 *
+	 * @param <T>          the type the result will be
+	 * @param selectClause your custom select-clause (the base-object has the alias
+	 *                     'o'. So the default would be "o" internally resulting in
+	 *                     a "SELECT o")
+	 * @param resultType   the type the result will be
+	 * @return a query-builder
+	 */
+	public <T> SelectAsyncQueryBuilder<P, T> select(final String selectClause, final Class<T> resultType) {
+		SelectAsyncQueryBuilder<P, T> b = new SelectAsyncQueryBuilder<>(emf, this, resultType);
+		b.setSelect(selectClause);
+		return b;
+	}
+
+	/**
+	 * Build a SELECT-query with a custom select-clause. The result will be of the
+	 * underlying generic type.
+	 *
+	 * @param selectClause your custom select-clause (the base-object has the alias
+	 *                     'o'. So the default would be "o" internally resulting in
+	 *                     a "SELECT o")
+	 * @return a query-builder
+	 */
+	public <T> SelectAsyncQueryBuilder<P, P> select(final String selectClause) {
+		SelectAsyncQueryBuilder<P, P> b = new SelectAsyncQueryBuilder<>(emf, this, type);
+		b.setSelect(selectClause);
+		return b;
 	}
 }

src/main/java/info/unterrainer/commons/httpserver/daos/JpqlDao.java

@@ -7,15 +7,67 @@
 
 public class JpqlDao<P extends BasicJpa> extends BasicJpqlDao<P> implements BasicDao<P, EntityManager> {
 
+	/**
+	 * Generates a DAO that lets you build and execute queries.
+	 *
+	 * @param emf  the {@link EntityManagerFactory} to use
+	 * @param type the return-type of the query (the underlying JPA)
+	 */
 	public JpqlDao(final EntityManagerFactory emf, final Class<P> type) {
 		super(emf, type);
 	}
 
-	public QueryBuilder<P, P> query() {
-		return new QueryBuilder<>(emf, this, type);
+	/**
+	 * Build a SELECT(*)-like query. The result will be of the underlying generic
+	 * type.
+	 *
+	 * @return a query-builder
+	 */
+	public SelectQueryBuilder<P, P> select() {
+		return new SelectQueryBuilder<>(emf, this, type);
 	}
 
-	public <T> QueryBuilder<P, T> query(final Class<T> resultType) {
-		return new QueryBuilder<>(emf, this, resultType);
+	/**
+	 * Build a SELECT(*)-like query. The result will be of the given type (use this
+	 * for a COUNT(*) query, for example).
+	 *
+	 * @param <T>        the type the result will be
+	 * @param resultType the type the result will be
+	 * @return a query-builder
+	 */
+	public <T> SelectQueryBuilder<P, T> select(final Class<T> resultType) {
+		return new SelectQueryBuilder<>(emf, this, resultType);
+	}
+
+	/**
+	 * Build a SELECT-query with a custom select-clause. The result will be of the
+	 * given type (use this for a COUNT(*) query, for example).
+	 *
+	 * @param <T>          the type the result will be
+	 * @param selectClause your custom select-clause (the base-object has the alias
+	 *                     'o'. So the default would be "o" internally resulting in
+	 *                     a "SELECT o")
+	 * @param resultType   the type the result will be
+	 * @return a query-builder
+	 */
+	public <T> SelectQueryBuilder<P, T> select(final String selectClause, final Class<T> resultType) {
+		SelectQueryBuilder<P, T> b = new SelectQueryBuilder<>(emf, this, resultType);
+		b.setSelect(selectClause);
+		return b;
+	}
+
+	/**
+	 * Build a SELECT-query with a custom select-clause. The result will be of the
+	 * underlying generic type.
+	 *
+	 * @param selectClause your custom select-clause (the base-object has the alias
+	 *                     'o'. So the default would be "o" internally resulting in
+	 *                     a "SELECT o")
+	 * @return a query-builder
+	 */
+	public <T> SelectQueryBuilder<P, P> select(final String selectClause) {
+		SelectQueryBuilder<P, P> b = new SelectQueryBuilder<>(emf, this, type);
+		b.setSelect(selectClause);
+		return b;
 	}
 }

src/main/java/info/unterrainer/commons/httpserver/daos/QueryInterface.java

@@ -11,7 +11,7 @@ interface QueryInterface<P extends BasicJpa, T> {
 
 	BasicJpqlDao<P> getDao();
 
-	Query<P, T> build();
+	SelectQuery<P, T> build();
 
 	TypedQuery<T> getTypedQuery(final EntityManager em);
 

src/main/java/info/unterrainer/commons/httpserver/daos/QueryAsyncBuilder.java renamed to src/main/java/info/unterrainer/commons/httpserver/daos/SelectAsyncQueryBuilder.java

@@ -11,18 +11,18 @@
 import info.unterrainer.commons.rdbutils.entities.BasicAsyncJpa;
 import info.unterrainer.commons.rdbutils.enums.AsyncState;
 
-public class QueryAsyncBuilder<P extends BasicAsyncJpa, T> extends BasicQueryBuilder<P, T, QueryAsyncBuilder<P, T>>
+public class SelectAsyncQueryBuilder<P extends BasicAsyncJpa, T> extends BasicSelectQueryBuilder<P, T, SelectAsyncQueryBuilder<P, T>>
 		implements QueryInterface<P, T> {
 
 	private Set<AsyncState> asyncStates = new HashSet<>();
 
-	QueryAsyncBuilder(final EntityManagerFactory emf, final JpqlAsyncDao<P> dao, final Class<T> resultType) {
+	SelectAsyncQueryBuilder(final EntityManagerFactory emf, final JpqlAsyncDao<P> dao, final Class<T> resultType) {
 		super(emf, dao, resultType);
 	}
 
 	@Override
-	public Query<P, T> build() {
-		return new Query<>(emf, this);
+	public SelectQuery<P, T> build() {
+		return new SelectQuery<>(emf, this);
 	}
 
 	/**
@@ -40,7 +40,7 @@ public Query<P, T> build() {
 	 * @param asyncStates a single or number of AsyncState values
 	 * @return an instance of this builder to provide a fluent interface
 	 */
-	public QueryAsyncBuilder<P, T> asyncStateOf(final AsyncState... asyncStates) {
+	public SelectAsyncQueryBuilder<P, T> asyncStateOf(final AsyncState... asyncStates) {
 		this.asyncStates.addAll(Arrays.asList(asyncStates));
 		return this;
 	}

src/main/java/info/unterrainer/commons/httpserver/daos/CountQueryBuilder.java renamed to src/main/java/info/unterrainer/commons/httpserver/daos/SelectCountQueryBuilder.java

@@ -5,9 +5,9 @@
 import info.unterrainer.commons.rdbutils.Transactions;
 import info.unterrainer.commons.rdbutils.entities.BasicJpa;
 
-public class CountQueryBuilder<P extends BasicJpa> extends BasicQueryBuilder<P, Long, CountQueryBuilder<P>> {
+public class SelectCountQueryBuilder<P extends BasicJpa> extends BasicSelectQueryBuilder<P, Long, SelectCountQueryBuilder<P>> {
 
-	CountQueryBuilder(final EntityManagerFactory emf, final JpqlDao<P> dao) {
+	SelectCountQueryBuilder(final EntityManagerFactory emf, final JpqlDao<P> dao) {
 		super(emf, dao, Long.class);
 	}
 

src/main/java/info/unterrainer/commons/httpserver/daos/SelectQuery.java

@@ -0,0 +1,135 @@
+package info.unterrainer.commons.httpserver.daos;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.NoResultException;
+import javax.persistence.NonUniqueResultException;
+import javax.persistence.TypedQuery;
+
+import info.unterrainer.commons.httpserver.jsons.ListJson;
+import info.unterrainer.commons.rdbutils.Transactions;
+import info.unterrainer.commons.rdbutils.entities.BasicJpa;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(access = AccessLevel.PACKAGE)
+public class SelectQuery<P extends BasicJpa, T> {
+
+	protected final EntityManagerFactory emf;
+	protected final QueryInterface<P, T> builder;
+
+	private <V> V withEntityManager(final Function<EntityManager, V> func) {
+		if (builder.getEntityManager() == null)
+			return Transactions.withNewTransactionReturning(emf, em -> func.apply(em));
+		return func.apply(builder.getEntityManager());
+	}
+
+	/**
+	 * Gets all the rows as a {@link ListJson} as returned by a web-service.
+	 * <p>
+	 * The list contains additional information about the data.
+	 *
+	 * @return a {@link ListJson} containing the rows as specified
+	 */
+	public ListJson<T> getListJson() {
+		return getListJson(0, Long.MAX_VALUE);
+	}
+
+	/**
+	 * Gets all the rows specified by offset and size as a {@link ListJson} as
+	 * returned by a web-service.
+	 * <p>
+	 * The list contains additional information about the data.
+	 *
+	 * @param offset the row-number to start at
+	 * @param size   the number-of-rows to return
+	 * @return a {@link ListJson} containing the rows as specified
+	 */
+	public ListJson<T> getListJson(final long offset, final long size) {
+		return withEntityManager(em -> {
+			ListJson<T> r = new ListJson<>();
+			r.setEntries(builder.getDao().getList(em, builder.getTypedQuery(em), offset, size));
+			r.setCount((Long) builder.getCountQuery(em).getSingleResult());
+			return r;
+		});
+	}
+
+	/**
+	 * Gets the first row this query returns.
+	 *
+	 * @return the result-row as a JPA
+	 */
+	public T getFirst() {
+		List<T> r = getList(0, 1);
+		if (r.size() == 1) {
+			T jpa = r.get(0);
+			return jpa;
+		}
+		return null;
+	}
+
+	/**
+	 * Get the first N rows from this queries' results.
+	 *
+	 * @param count the number of rows to get
+	 * @return the list of the first N result-rows as JPAs
+	 */
+	public List<T> getN(final long count) {
+		return getList(0, count);
+	}
+
+	/**
+	 * Execute a SELECT query that returns a single result-row.
+	 *
+	 * @return the result-row as a JPA
+	 * @throws NoResultException        if there is no
+	 *                                  resultNonUniqueResultException
+	 * @throws NonUniqueResultException if more than one result
+	 */
+	public T getSingle() {
+		return withEntityManager(em -> {
+			TypedQuery<T> typedQuery = builder.getTypedQuery(em);
+			return typedQuery.getSingleResult();
+		});
+	}
+
+	/**
+	 * Execute a SELECT query that returns multiple result-rows.
+	 *
+	 * @return the list of result-rows as JPAs
+	 */
+	public List<T> getList() {
+		return withEntityManager(em -> builder.getDao().getList(em, builder.getTypedQuery(em), 0, Long.MAX_VALUE));
+	}
+
+	/**
+	 * Gets all the rows specified by offset and size as a list.
+	 *
+	 * @param offset the row-number to start at
+	 * @param size   the number-of-rows to return
+	 * @return a list containing the rows as specified
+	 */
+	public List<T> getList(final long offset, final long size) {
+		return withEntityManager(em -> builder.getDao().getList(em, builder.getTypedQuery(em), offset, size));
+	}
+
+	/**
+	 * Execute a SELECT query that returns multiple result-rows and reverse the
+	 * order of results.
+	 * <p>
+	 * The reversing-process happens after retrieval of the result, since the whole
+	 * list is going to be transferred anyway.<br>
+	 * The list is reversed using {@code Collections.reverse(list)};
+	 *
+	 * @return the reversed list of result-rows as JPAs
+	 */
+	public List<T> getListReversed() {
+		List<T> l = getList();
+		Collections.reverse(l);
+		return l;
+	}
+}