Added max and min queries

Author: CollinAlpert

README.md

@@ -20,7 +20,7 @@ Include the Maven artifact:
 <dependency>
     <groupId>com.github.collinalpert</groupId>
     <artifactId>java2db</artifactId>
-    <version>5.0.1</version>
+    <version>5.1.0</version>
 </dependency>
 ```
 Or include the [JAR](https://github.com/CollinAlpert/Java2DB/releases/latest) in your project. 
@@ -110,14 +110,15 @@ The last thing you need to do is give Java2DB access to your database. Set the s
 ### CRUD operations 
 
 #### Create
-Every service class has support for creating a single as well as multiple entities at once on the database.
+Every service class has support for creating a single as well as multiple entities at once on the database. 
+When creating a single entity, the id created for it on the database will also be set in the entity.
 Check out the different `create` methods provided by your service class.
 To achieve asynchronous behavior, please read the [Asynchronous operations](#asynchronous-operations) section.
 
 #### Read
-The `BaseService` provides a `createQuery` method which allows you to manually build a query and then execute it with the `toList`, `toStream` or `toArray` methods. You should only need this approach seldomly.\
+The `BaseService` provides a `createQuery` method which allows you to manually build a query and then execute it with the `toList`, `toStream`, `toArray` or `toMap` methods. You should only need this approach seldomly.\
 Much rather, use the `getSingle` or `getMultiple` methods. `getMultiple` returns an `EntityQuery` object with a preconfigured WHERE condition and then allows you to chain some additional query options. As of the current `EntityQuery` version, WHERE, LIMIT and ORDER BY are supported. With the ORDER BY functionality, there is also the possibility to coalesce multiple columns when ordering. Effectively, the calls `createQuery().where(predicate)` and `getMultiple(predicate)` are the same. The latter is recommended.\
-As previously mentioned, to execute the query and retrieve a result, use the `toList`, `toStream` or `toArray` methods.
+As previously mentioned, to execute the query and retrieve a result, use the `toList`, `toStream`, `toArray` or `toMap` methods.
 
 #### Update
 Every service class has support for updating a single as well as multiple entities at once on the database.
@@ -139,6 +140,9 @@ It is also possible to achieve `LIKE` operations using the String `startsWith`,
 ### Counting
 For counting functionality, the `BaseService` provides a `count` method. You can use it to either count all rows in a table, or to count all rows which match a certain condition. E.g. `personService.count()` would return the total number of people while `personService.count(person -> person.getAge() >= 50)` would return the amount of people that are of age 50 and older in your table.
 
+### Max/Min
+To get the maximal or minimal value from a table, the ``BaseService`` provides the `max()` and `min()` methods.
+
 ### Projections
 If you would not like to fetch an entire entity from the database, when building a query, you can project to a single column by using the ```project()``` method. 
 You then have option to choose the form in which the data should be fetched, as you would normally specify when executing a built entity query. 

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.github.collinalpert</groupId>
     <artifactId>java2db</artifactId>
-    <version>5.0.1</version>
+    <version>5.1.0</version>
     <packaging>jar</packaging>
 
     <name>Java2DB</name>

src/main/java/com/github/collinalpert/java2db/mappers/BaseMapper.java

@@ -19,11 +19,13 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Calendar;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
 import static com.github.collinalpert.java2db.utilities.Utilities.tryAction;
@@ -109,6 +111,25 @@ public E[] mapToArray(ResultSet set, Map<String, String> aliases) throws SQLExce
 		return module.getArray();
 	}
 
+	/**
+	 * Maps a {@code ResultSet} to a {@link Map}.
+	 *
+	 * @param set          The {@code ResultSet} to get the data from.
+	 * @param keyMapping   The key function of the map.
+	 * @param valueMapping The value function of the map.
+	 * @param aliases      A map of column aliases needed to retrieve column data from the {@code ResultSet}.
+	 * @param <K>          The type of the keys in the map.
+	 * @param <V>          The type of the values in the map.
+	 * @return A {@code Map} containing the {@code ResultSet}s data.
+	 * @throws SQLException In case the {@code ResultSet} can't be read.
+	 */
+	@Override
+	public <K, V> Map<K, V> mapToMap(ResultSet set, Function<E, K> keyMapping, Function<E, V> valueMapping, Map<String, String> aliases) throws SQLException {
+		var map = new HashMap<K, V>();
+		mapInternal(set, x -> map.put(keyMapping.apply(x), valueMapping.apply(x)), aliases);
+		return map;
+	}
+
 	/**
 	 * Internal handling for executing a certain action for every entity that is generated when iterating through a {@code ResultSet}.
 	 *

src/main/java/com/github/collinalpert/java2db/mappers/Mappable.java

@@ -7,6 +7,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
 /**
@@ -29,7 +30,7 @@ public interface Mappable<T extends BaseEntity> {
 	 *
 	 * @param set     The {@code ResultSet} to get the data from.
 	 * @param aliases A map of column aliases needed to retrieve column data from the {@code ResultSet}.
-	 * @return An {@code Optional} containing the {@code ResultSet}s data.
+	 * @return A {@code List} containing the {@code ResultSet}s data.
 	 * @throws SQLException In case the {@code ResultSet} can't be read.
 	 */
 	List<T> mapToList(ResultSet set, Map<String, String> aliases) throws SQLException;
@@ -39,7 +40,7 @@ public interface Mappable<T extends BaseEntity> {
 	 *
 	 * @param set     The {@code ResultSet} to get the data from.
 	 * @param aliases A map of column aliases needed to retrieve column data from the {@code ResultSet}.
-	 * @return An {@code Optional} containing the {@code ResultSet}s data.
+	 * @return A {@code Stream} containing the {@code ResultSet}s data.
 	 * @throws SQLException In case the {@code ResultSet} can't be read.
 	 */
 	Stream<T> mapToStream(ResultSet set, Map<String, String> aliases) throws SQLException;
@@ -49,8 +50,22 @@ public interface Mappable<T extends BaseEntity> {
 	 *
 	 * @param set     The {@code ResultSet} to get the data from.
 	 * @param aliases A map of column aliases needed to retrieve column data from the {@code ResultSet}.
-	 * @return An {@code Optional} containing the {@code ResultSet}s data.
+	 * @return An array containing the {@code ResultSet}s data.
 	 * @throws SQLException In case the {@code ResultSet} can't be read.
 	 */
 	T[] mapToArray(ResultSet set, Map<String, String> aliases) throws SQLException;
+
+	/**
+	 * Maps a {@code ResultSet} to a {@link Map}.
+	 *
+	 * @param set          The {@code ResultSet} to get the data from.
+	 * @param keyMapping   The key function of the map.
+	 * @param valueMapping The value function of the map.
+	 * @param aliases      A map of column aliases needed to retrieve column data from the {@code ResultSet}.
+	 * @param <K>          The type of the keys in the map.
+	 * @param <V>          The type of the values in the map.
+	 * @return A {@code Map} containing the {@code ResultSet}s data.
+	 * @throws SQLException In case the {@code ResultSet} can't be read.
+	 */
+	<K, V> Map<K, V> mapToMap(ResultSet set, Function<T, K> keyMapping, Function<T, V> valueMapping, Map<String, String> aliases) throws SQLException;
 }

src/main/java/com/github/collinalpert/java2db/queries/EntityProjectionQuery.java

@@ -9,7 +9,9 @@
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
@@ -54,6 +56,41 @@ public R[] toArray() {
 		return resultHandling(arrayModule, ArrayModule::addElement, defaultValue, ArrayModule::getArray);
 	}
 
+	/**
+	 * Executes a new query and returns the result as a {@link Map}. This method is equivalent to the call {@code Queryable#toMap(keyMapping, x -> x)}.
+	 *
+	 * @param keyMapping The field representing the keys of the map.
+	 * @return A map containing the result of the query.
+	 */
+	@Override
+	public <K> Map<K, R> toMap(Function<R, K> keyMapping) {
+		return this.toMap(keyMapping, x -> x);
+	}
+
+	/**
+	 * Executes a new query and returns the result as a {@link Map}.
+	 *
+	 * @param keyMapping   The field representing the keys of the map.
+	 * @param valueMapping The field representing the values of the map.
+	 * @return A map containing the result of the query.
+	 */
+	@Override
+	public <K, V> Map<K, V> toMap(Function<R, K> keyMapping, Function<R, V> valueMapping) {
+		var map = new HashMap<K, V>();
+		try (var connection = new DBConnection();
+			 var result = connection.execute(getQuery())) {
+			while (result.next()) {
+				var currentValue = result.getObject(1, super.returnType);
+				map.put(keyMapping.apply(currentValue), valueMapping.apply(currentValue));
+			}
+
+			return map;
+		} catch (SQLException e) {
+			e.printStackTrace();
+			return Collections.emptyMap();
+		}
+	}
+
 	/**
 	 * Performs handling on a {@code ResultSet} for different data structures.
 	 *

src/main/java/com/github/collinalpert/java2db/queries/EntityQuery.java

@@ -12,8 +12,10 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.StringJoiner;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
 /**
@@ -68,7 +70,7 @@ public EntityQuery<E> orWhere(SqlPredicate<E> predicate) {
 	/**
 	 * Sets an ORDER BY clauses for the DQL statement.
 	 *
-	 * @param function The column to order by..
+	 * @param function The column to order by.
 	 * @return This {@link EntityQuery} object, now with a ORDER BY clause.
 	 */
 	public EntityQuery<E> orderBy(SqlFunction<E, ?> function) {
@@ -245,6 +247,34 @@ public E[] toArray() {
 		}
 	}
 
+	/**
+	 * Executes a new query and returns the result as a {@link Map}. This method is equivalent to the call {@code Queryable#toMap(keyMapping, x -> x)}.
+	 *
+	 * @param keyMapping The field representing the keys of the map.
+	 * @return A map containing the result of the query.
+	 */
+	@Override
+	public <K> Map<K, E> toMap(Function<E, K> keyMapping) {
+		return this.toMap(keyMapping, x -> x);
+	}
+
+	/**
+	 * Executes a new query and returns the result as a {@link Map}.
+	 *
+	 * @param keyMapping   The field representing the keys of the map.
+	 * @param valueMapping The field representing the values of the map.
+	 * @return A map containing the result of the query.
+	 */
+	@Override
+	public <K, V> Map<K, V> toMap(Function<E, K> keyMapping, Function<E, V> valueMapping) {
+		try (var connection = new DBConnection()) {
+			return super.mapper.mapToMap(connection.execute(getQuery()), keyMapping, valueMapping, super.aliases);
+		} catch (SQLException e) {
+			e.printStackTrace();
+			return Collections.emptyMap();
+		}
+	}
+
 	/**
 	 * Creates the query clauses for a DQL statement. This contains constraints like a WHERE, an ORDER BY and a LIMIT statement.
 	 *

src/main/java/com/github/collinalpert/java2db/queries/Queryable.java

@@ -1,6 +1,8 @@
 package com.github.collinalpert.java2db.queries;
 
 import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
 /**
@@ -9,14 +11,14 @@
 public interface Queryable<T> extends SingleQueryable<T> {
 
 	/**
-	 * Executes the query and returns the result as a {@link List}
+	 * Executes the query and returns the result as a {@link List}.
 	 *
 	 * @return A list of entities representing the result rows.
 	 */
 	List<T> toList();
 
 	/**
-	 * Executes the query and returns the result as a {@link Stream}
+	 * Executes the query and returns the result as a {@link Stream}.
 	 *
 	 * @return A list of entities representing the result rows.
 	 */
@@ -28,4 +30,24 @@ public interface Queryable<T> extends SingleQueryable<T> {
 	 * @return An array of entities representing the result rows.
 	 */
 	T[] toArray();
+
+	/**
+	 * Executes a new query and returns the result as a {@link Map}. This method is equivalent to the call {@code Queryable#toMap(keyMapping, x -> x)}.
+	 *
+	 * @param keyMapping The field representing the keys of the map.
+	 * @param <K>        The type of the field representing the keys.
+	 * @return A map containing the result of the query.
+	 */
+	<K> Map<K, T> toMap(Function<T, K> keyMapping);
+
+	/**
+	 * Executes a new query and returns the result as a {@link Map}.
+	 *
+	 * @param keyMapping   The field representing the keys of the map.
+	 * @param valueMapping The field representing the values of the map.
+	 * @param <K>          The type of the field representing the keys.
+	 * @param <V>The       type of the field representing the values.
+	 * @return A map containing the result of the query.
+	 */
+	<K, V> Map<K, V> toMap(Function<T, K> keyMapping, Function<T, V> valueMapping);
 }

src/main/java/com/github/collinalpert/java2db/queries/async/AsyncEntityQuery.java

@@ -50,7 +50,7 @@ public AsyncEntityQuery<E> orWhere(SqlPredicate<E> predicate) {
 	/**
 	 * Sets an ORDER BY clauses for the DQL statement.
 	 *
-	 * @param function The column to order by..
+	 * @param function The column to order by.
 	 * @return This {@link EntityQuery} object, now with a ORDER BY clause.
 	 */
 	@Override

src/main/java/com/github/collinalpert/java2db/queries/async/AsyncQueryable.java

@@ -3,8 +3,10 @@
 import com.github.collinalpert.java2db.queries.Queryable;
 
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
 /**
@@ -77,4 +79,59 @@ default CompletableFuture<T[]> toArrayAsync() {
 	default CompletableFuture<Void> toArrayAsync(Consumer<? super T[]> callback) {
 		return toArrayAsync().thenAcceptAsync(callback);
 	}
+
+	/**
+	 * The asynchronous version of the {@link #toMap(Function)} method.
+	 *
+	 * @param keyMapping The field representing the keys of the map.
+	 * @param <K>        The type of the keys in the map.
+	 * @return The asynchronous operation which will retrieve the data from the database.
+	 * Custom handling for the {@code CompletableFuture} can be done here.
+	 * @see #toMap(Function)
+	 */
+	default <K> CompletableFuture<Map<K, T>> toMapAsync(Function<T, K> keyMapping) {
+		return CompletableFuture.supplyAsync(() -> this.toMap(keyMapping));
+	}
+
+	/**
+	 * The asynchronous version of the {@link #toMap(Function)} method.
+	 *
+	 * @param keyMapping The field representing the keys of the map.
+	 * @param callback   The action to be applied to the result once it is fetched from the database.
+	 * @param <K>        The type of the keys in the map.
+	 * @return The asynchronous operation which will retrieve the data from the database and apply the given action to the result.
+	 * @see #toMap(Function)
+	 */
+	default <K> CompletableFuture<Void> toMapAsync(Function<T, K> keyMapping, Consumer<? super Map<K, T>> callback) {
+		return toMapAsync(keyMapping).thenAcceptAsync(callback);
+	}
+
+	/**
+	 * The asynchronous version of the {@link #toMap(Function, Function)} method.
+	 *
+	 * @param keyMapping   The field representing the keys of the map.
+	 * @param valueMapping The field representing the values of the map.
+	 * @param <K>          The type of the keys in the map.
+	 * @param <V>          The type of the values in the map.
+	 * @return The asynchronous operation which will retrieve the data from the database.
+	 * Custom handling for the {@code CompletableFuture} can be done here.
+	 * @see #toMap(Function, Function)
+	 */
+	default <K, V> CompletableFuture<Map<K, V>> toMapAsync(Function<T, K> keyMapping, Function<T, V> valueMapping) {
+		return CompletableFuture.supplyAsync(() -> this.toMap(keyMapping, valueMapping));
+	}
+
+	/**
+	 * The asynchronous version of the {@link #toMap(Function, Function)} method.
+	 *
+	 * @param keyMapping   The field representing the keys of the map.
+	 * @param valueMapping The field representing the values of the map.
+	 * @param callback     The action to be applied to the result once it is fetched from the database.
+	 * @param <K>          The type of the keys in the map.
+	 * @param <V>          The type of the values in the map.
+	 * @return The asynchronous operation which will retrieve the data from the database and apply the given action to the result.
+	 */
+	default <K, V> CompletableFuture<Void> toMapAsync(Function<T, K> keyMapping, Function<T, V> valueMapping, Consumer<? super Map<K, V>> callback) {
+		return toMapAsync(keyMapping, valueMapping).thenAcceptAsync(callback);
+	}
 }

src/main/java/com/github/collinalpert/java2db/queries/async/AsyncSingleQueryable.java

@@ -20,7 +20,6 @@ public interface AsyncSingleQueryable<T> extends SingleQueryable<T> {
 	 */
 	default CompletableFuture<Optional<T>> firstAsync() {
 		return CompletableFuture.supplyAsync(this::first);
-
 	}
 
 	/**