Update insert methods

.github/workflows/check.yml

@@ -24,6 +24,23 @@ jobs:
   build:
     runs-on: ubuntu-latest
 
+    services:
+      postgres:
+        image: postgres
+
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_USER: postgres
+          POSTGRES_DB: postgres
+
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5433:5432
+
     steps:
     - uses: actions/checkout@v4
     - name: Set up JDK 17
@@ -34,7 +51,7 @@ jobs:
     - name: Build with Gradle
       uses: gradle/actions/setup-gradle@v3
       with:
-        arguments: build -x test
+        arguments: build
     - uses: actions/upload-artifact@v4
       with:
         name: Package

build.gradle

@@ -27,7 +27,11 @@ dependencies {
     testImplementation platform('org.junit:junit-bom:5.9.1')
     testImplementation 'org.junit.jupiter:junit-jupiter'
 
-    testImplementation 'ch.qos.logback:logback-classic:1.3.8'
+    testImplementation 'ch.qos.logback:logback-classic:1.4.12'
+
+    testCompileOnly 'org.projectlombok:lombok:1.18.30'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.30'
+
     testImplementation 'org.postgresql:postgresql:42.6.0'
     testImplementation 'org.jdbi:jdbi3-postgres:3.39.0'
 }

src/main/java/de/mineking/javautils/database/DataClass.java

@@ -1,5 +1,6 @@
 package de.mineking.javautils.database;
 
+import de.mineking.javautils.database.exception.ConflictException;
 import org.jetbrains.annotations.NotNull;
 
 public interface DataClass<T extends DataClass<T>> {
@@ -8,9 +9,19 @@ public interface DataClass<T extends DataClass<T>> {
 
 	@NotNull
 	@SuppressWarnings("unchecked")
-	default DataClass<T> update() {
-		getTable().insert((T) this);
-		return this;
+	default T insert() throws ConflictException {
+		return getTable().insert((T) this);
+	}
+
+	@SuppressWarnings("unchecked")
+	default boolean update() {
+		return getTable().update((T) this);
+	}
+
+	@NotNull
+	@SuppressWarnings("unchecked")
+	default T upsert() {
+		return getTable().upsert((T) this);
 	}
 
 	@NotNull

src/main/java/de/mineking/javautils/database/Table.java

@@ -1,9 +1,9 @@
 package de.mineking.javautils.database;
 
+import de.mineking.javautils.database.exception.ConflictException;
 import org.jetbrains.annotations.NotNull;
 
 import java.lang.reflect.Field;
-import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -47,14 +47,12 @@ default List<T> selectAll() {
 	}
 
 	@NotNull
-	T insert(@NotNull T object);
+	T insert(@NotNull T object) throws ConflictException;
+
+	boolean update(@NotNull T object);
 
 	@NotNull
-	default List<T> insertMany(@NotNull Collection<T> objects) {
-		return objects.stream()
-				.map(this::insert)
-				.toList();
-	}
+	T upsert(@NotNull T object);
 
 	int delete(@NotNull Where where);
 

src/main/java/de/mineking/javautils/database/TableImpl.java

@@ -1,6 +1,9 @@
 package de.mineking.javautils.database;
 
+import de.mineking.javautils.database.exception.ConflictException;
+import org.jdbi.v3.core.result.ResultProducers;
 import org.jdbi.v3.core.statement.StatementContext;
+import org.jdbi.v3.core.statement.Update;
 import org.jetbrains.annotations.NotNull;
 
 import java.lang.reflect.*;
@@ -136,9 +139,89 @@ public int delete(@NotNull Where where) {
 		);
 	}
 
+	private boolean execute(@NotNull T object, Update query) {
+		columns.forEach((name, field) -> {
+			try {
+				query.bind(name, manager.getArgument(field.getGenericType(), field, field.get(object)));
+			} catch(IllegalAccessException e) {
+				throw new RuntimeException(e);
+			}
+		});
+
+		return query.execute(ResultProducers.returningResults())
+				.map((rs, ctx) -> {
+					columns.forEach((name, field) -> {
+						try {
+							field.set(object, manager.parse(field.getGenericType(), field, manager.extract(field.getGenericType(), field, name, rs)));
+						} catch(IllegalAccessException | SQLException e) {
+							throw new RuntimeException(e);
+						}
+					});
+					return true;
+				}).findFirst().orElse(false);
+	}
+
+	@NotNull
+	@Override
+	public T insert(@NotNull T object) throws ConflictException {
+		var sql = "insert into <name>(<columns>) values(<values>) on conflict do nothing returning *";
+
+		var updated = manager.db.withHandle(handle -> {
+			var query = handle.createUpdate(sql)
+					.define("name", name)
+					.define("columns", columns.entrySet().stream()
+							.filter(e -> {
+								try {
+									return !(e.getValue().getAnnotation(Column.class).autoincrement() && ((Number) e.getValue().get(object)).longValue() <= 0);
+								} catch(IllegalAccessException ex) {
+									throw new RuntimeException(ex);
+								}
+							})
+							.map(e -> '"' + e.getKey() + '"')
+							.collect(Collectors.joining(", "))
+					)
+					.define("values", columns.entrySet().stream()
+							.filter(e -> {
+								try {
+									return !(e.getValue().getAnnotation(Column.class).autoincrement() && ((Number) e.getValue().get(object)).longValue() <= 0);
+								} catch(IllegalAccessException ex) {
+									throw new RuntimeException(ex);
+								}
+							})
+							.map(e -> ":" + e.getKey())
+							.collect(Collectors.joining(", "))
+					);
+
+			return execute(object, query);
+		});
+
+		if(updated) return object;
+		else throw new ConflictException();
+	}
+
+	@Override
+	public boolean update(@NotNull T object) {
+		var sql = "update <name> set <update> <where> returning *";
+		var identifier = Where.of(this, object);
+
+		return manager.db.withHandle(handle -> {
+			var query = handle.createUpdate(sql)
+					.define("name", name)
+					.define("update", columns.keySet().stream()
+							.filter(k -> !this.keys.containsKey(k))
+							.map(k -> '"' + k + "\" = :" + k)
+							.collect(Collectors.joining(", "))
+					)
+					.define("where", identifier.format())
+					.bindMap(identifier.formatValues(this));
+
+			return execute(object, query);
+		});
+	}
+
 	@NotNull
 	@Override
-	public T insert(@NotNull T object) {
+	public T upsert(@NotNull T object) {
 		var sql = "insert into <name>(<columns>) values(<values>) ";
 
 		if(!keys.isEmpty()) sql += " on conflict(<keys>) do update set <update>";
@@ -180,26 +263,7 @@ public T insert(@NotNull T object) {
 							.collect(Collectors.joining(", "))
 					);
 
-			columns.forEach((name, field) -> {
-				try {
-					query.bind(name, manager.getArgument(field.getGenericType(), field, field.get(object)));
-				} catch(IllegalAccessException e) {
-					throw new RuntimeException(e);
-				}
-			});
-
-			query.executeAndReturnGeneratedKeys()
-					.map((rs, ctx) -> {
-						columns.forEach((name, field) -> {
-							try {
-								field.set(object, manager.parse(field.getGenericType(), field, manager.extract(field.getGenericType(), field, name, rs)));
-							} catch(IllegalAccessException | SQLException e) {
-								throw new RuntimeException(e);
-							}
-						});
-
-						return null;
-					}).one();
+			execute(object, query);
 		});
 
 		return object;

src/main/java/de/mineking/javautils/database/exception/ConflictException.java

@@ -0,0 +1,4 @@
+package de.mineking.javautils.database.exception;
+
+public class ConflictException extends SQLException {
+}

src/main/java/de/mineking/javautils/database/exception/SQLException.java

@@ -0,0 +1,4 @@
+package de.mineking.javautils.database.exception;
+
+public class SQLException extends RuntimeException {
+}