add .selectClause instead of .select(String)

Author: Gerald Unterrainer

pom.xml

@@ -15,7 +15,7 @@
 
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>http-server</artifactId>
-	<version>0.3.10</version>
+	<version>0.3.11</version>
 	<name>HttpServer</name>
 	<packaging>jar</packaging>
 
@@ -28,12 +28,12 @@
 		<dependency>
 			<groupId>info.unterrainer.commons</groupId>
 			<artifactId>jre-utils</artifactId>
-			<version>0.3.6</version>
+			<version>0.3.7</version>
 		</dependency>
 		<dependency>
 			<groupId>info.unterrainer.commons</groupId>
 			<artifactId>rdb-utils</artifactId>
-			<version>0.2.2</version>
+			<version>0.2.3</version>
 		</dependency>
 		<dependency>
 			<groupId>info.unterrainer.commons</groupId>

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

@@ -1,9 +1,8 @@
 package info.unterrainer.commons.httpserver.daos;
 
-import jakarta.persistence.EntityManagerFactory;
-
 import info.unterrainer.commons.httpserver.jpas.BasicPermissionJpa;
 import info.unterrainer.commons.rdbutils.entities.BasicAsyncJpa;
+import jakarta.persistence.EntityManagerFactory;
 
 public class AsyncJpqlDao<P extends BasicAsyncJpa> extends BasicJpqlDao<P> {
 
@@ -80,38 +79,6 @@ public <T> AsyncListQueryBuilder<P, T> select(final Class<T> resultType) {
 		return new AsyncListQueryBuilder<>(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> AsyncListQueryBuilder<P, T> select(final String selectClause, final Class<T> resultType) {
-		AsyncListQueryBuilder<P, T> b = new AsyncListQueryBuilder<>(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 AsyncJpaListQueryBuilder<P> select(final String selectClause) {
-		AsyncJpaListQueryBuilder<P> b = new AsyncJpaListQueryBuilder<>(emf, this, type);
-		b.setSelect(selectClause);
-		return b;
-	}
-
 	/**
 	 * Get an element by ID.
 	 *

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

@@ -2,11 +2,10 @@
 
 import java.util.HashMap;
 
+import info.unterrainer.commons.rdbutils.entities.BasicJpa;
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.EntityManagerFactory;
 import jakarta.persistence.TypedQuery;
-
-import info.unterrainer.commons.rdbutils.entities.BasicJpa;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
@@ -20,16 +19,9 @@ public class BasicListQueryBuilder<P extends BasicJpa, X, R extends BasicListQue
 	protected final BasicJpqlDao<P> dao;
 	protected final Class<X> resultType;
 
-	protected String selectClause = "o";
 	protected String orderByClause;
 	protected boolean lockPessimistic = false;
 
-	void setSelect(final String selectClause) {
-		this.selectClause = selectClause;
-		if (this.selectClause == null || this.selectClause.isBlank())
-			this.selectClause = "o";
-	}
-
 	public TypedQuery<X> getTypedQuery(final EntityManager em) {
 		return dao.coreDao.getQuery(em, selectClause, joinClause, whereClause, parameters, resultType, orderByClause,
 				lockPessimistic, null, readTenantIds);

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

@@ -11,11 +11,31 @@
 public class BasicQueryGeneralBuilder<P extends BasicJpa, T, R extends BasicQueryGeneralBuilder<P, T, R>>
 		extends BasicQueryEntityManagerBuilder<P, T, R> {
 
+	protected String selectClause = "o";
 	protected String joinClause;
 	protected String whereClause;
 
 	protected Map<String, Object> parameters = new HashMap<>();
 
+	/**
+	 * Sets a custom select-clause.
+	 * <p>
+	 * Default is "o"<br>
+	 * To reset it to default, set it to null or directly to "o".
+	 *
+	 * @param selectClause your custom select-clause (the base-object has the alias
+	 *                     'o'. So the default would be changed to "o" internally
+	 *                     resulting in a "SELECT o")
+	 * @return an instance of this builder to provide a fluent interface
+	 */
+	@SuppressWarnings("unchecked")
+	public R selectClause(final String selectClause) {
+		this.selectClause = selectClause;
+		if (this.selectClause == null || this.selectClause.isBlank())
+			this.selectClause = "o";
+		return (R) this;
+	}
+
 	/**
 	 * Sets a custom join-clause.
 	 * <p>

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

@@ -2,11 +2,10 @@
 
 import java.util.function.Function;
 
-import jakarta.persistence.EntityManagerFactory;
-
 import info.unterrainer.commons.httpserver.jpas.BasicPermissionJpa;
 import info.unterrainer.commons.rdbutils.entities.BasicJpa;
 import io.javalin.http.Context;
+import jakarta.persistence.EntityManagerFactory;
 
 public class JpqlDao<P extends BasicJpa> extends BasicJpqlDao<P> {
 
@@ -144,38 +143,6 @@ public <T> ListQueryBuilder<P, T> select(final Class<T> resultType) {
 		return new ListQueryBuilder<>(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> ListQueryBuilder<P, T> select(final String selectClause, final Class<T> resultType) {
-		ListQueryBuilder<P, T> b = new ListQueryBuilder<>(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 JpaListQueryBuilder<P> select(final String selectClause) {
-		JpaListQueryBuilder<P> b = new JpaListQueryBuilder<>(emf, this, type);
-		b.setSelect(selectClause);
-		return b;
-	}
-
 	/**
 	 * Get an element by ID.
 	 *

src/test/java/info/unterrainer/commons/httpserver/HttpServerTests.java

@@ -1,10 +1,52 @@
 package info.unterrainer.commons.httpserver;
 
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
 import org.junit.jupiter.api.Test;
 
+import info.unterrainer.commons.httpserver.accessmanager.RoleBuilder;
+import info.unterrainer.commons.httpserver.daos.JpqlDao;
+import info.unterrainer.commons.httpserver.enums.Endpoint;
+import info.unterrainer.commons.httpserver.scripts.LocalTestServer;
+import info.unterrainer.commons.httpserver.scripts.jpas.TestJpa;
+import info.unterrainer.commons.httpserver.scripts.jsons.TestJson;
+import info.unterrainer.commons.rdbutils.RdbUtils;
+import info.unterrainer.commons.rdbutils.exceptions.RdbUtilException;
+import info.unterrainer.commons.serialization.jsonmapper.JsonMapper;
+import info.unterrainer.commons.serialization.objectmapper.ObjectMapper;
+import jakarta.persistence.EntityManagerFactory;
+
 public class HttpServerTests {
 
 	@Test
-	public void test() {
+	public void test() throws RdbUtilException {
+		EntityManagerFactory emf;
+		emf = RdbUtils.createAutoclosingEntityManagerFactory(LocalTestServer.class, "test");
+		JsonMapper jsonMapper = JsonMapper.create();
+		ObjectMapper objectMapper = new ObjectMapper();
+		ThreadPoolExecutor executorService = new ThreadPoolExecutor(20, 20, 60L, TimeUnit.SECONDS,
+				new LinkedBlockingQueue<Runnable>());
+		executorService.allowCoreThreadTimeOut(true);
+		HttpServer server = HttpServer.builder()
+				.applicationName("elite-server")
+				.jsonMapper(jsonMapper)
+				.objectMapper(objectMapper)
+				.executorService(executorService)
+				.appVersionFqns(new String[] { "at.elitezettl.server.eliteserver.Information",
+						"info.unterrainer.commons.httpserver.Information",
+						"at.elitezettl.commons.opcuabrowser.Information",
+						"info.unterrainer.commons.crontabscheduler.Information",
+						"info.unterrainer.commons.jreutils.Information",
+						"info.unterrainer.commons.rdbutils.Information",
+						"info.unterrainer.commons.serialization.Information" })
+				.build();
+		JpqlDao<TestJpa> basicDao = new JpqlDao<>(emf, TestJpa.class);
+		server.handlerGroupFor(TestJpa.class, TestJson.class, basicDao)
+				.path("tests")
+				.endpoints(Endpoint.ALL)
+				.addRoleFor(Endpoint.ALL, RoleBuilder.open())
+				.add();
 	}
 }