add wrapped values and primitive support to tuple transformer

Author: Piiit

src/main/java/it/aboutbits/springboot/toolbox/.gitkeep

@@ -4,6 +4,7 @@
 import jakarta.persistence.EntityNotFoundException;
 import jakarta.persistence.Query;
 import jakarta.persistence.TypedQuery;
+import lombok.SneakyThrows;
 import org.hibernate.query.NativeQuery;
 import org.hibernate.transform.ResultTransformer;
 import org.springframework.data.domain.Page;
@@ -13,36 +14,39 @@
 import java.util.List;
 import java.util.Optional;
 
-@SuppressWarnings({"rawtypes"})
+@SuppressWarnings("rawtypes")
 public final class QueryTransformer<T> {
 
     private final EntityManager entityManager;
     private final TupleTransformer<T> tupleTransformer;
     private org.hibernate.query.Query unwrappedQuery;
+    private Query query;
     private boolean isNative = false;
 
-    private QueryTransformer(final EntityManager entityManager, final Class<T> outputClass) {
+    private QueryTransformer(EntityManager entityManager, Class<T> outputClass) {
         this.entityManager = entityManager;
         this.tupleTransformer = new TupleTransformer<>(outputClass);
+
     }
 
-    public static <T> QueryTransformer<T> of(final EntityManager entityManager, final Class<T> outputClass) {
+    public static <T> QueryTransformer<T> of(EntityManager entityManager, Class<T> outputClass) {
         return new QueryTransformer<>(entityManager, outputClass);
     }
 
-    public QueryTransformer<T> withQuery(final Query query) {
+    public QueryTransformer<T> withQuery(Query query) {
         if (query instanceof NativeQuery<?>) {
             this.isNative = true;
         }
         this.unwrappedQuery = query.unwrap(org.hibernate.query.Query.class);
+        this.query = query;
         return this;
     }
 
     public Page<T> asPage(Pageable pageable) {
         return asPage(pageable.getPageNumber(), pageable.getPageSize());
     }
 
-    public Page<T> asPage(final int pageNumber, final int pageSize) {
+    public Page<T> asPage(int pageNumber, int pageSize) {
         return isNative ? asPageNativeQuery(pageNumber, pageSize) : asPageQuery(pageNumber, pageSize);
     }
 
@@ -58,7 +62,7 @@ public Optional<T> asSingleResult() {
         if (result.size() > 1) {
             throw new IllegalStateException("Single result query returned multiple results!");
         }
-        return Optional.of(result.get(0));
+        return Optional.of(result.getFirst());
     }
 
     public T asSingleResultOrFail() {
@@ -67,7 +71,7 @@ public T asSingleResultOrFail() {
     }
 
     @SuppressWarnings({"deprecation", "unchecked"})
-    private List<T> asList(final Integer pageNumber, final Integer pageSize) {
+    private List<T> asList(Integer pageNumber, Integer pageSize) {
         unwrappedQuery.setResultTransformer(
                 (ResultTransformer) (objects, aliases) -> tupleTransformer.transform(objects)
         );
@@ -81,14 +85,16 @@ private List<T> asList(final Integer pageNumber, final Integer pageSize) {
         return unwrappedQuery.getResultList();
     }
 
-    private Page<T> asPageQuery(final int pageNumber, final int pageSize) {
+    @SneakyThrows
+    private Page<T> asPageQuery(int pageNumber, int pageSize) {
         var selectPattern = "(?i)select.*?[ \\t]*from ";
         var queryString = unwrappedQuery.getQueryString().trim().replaceAll("\\R", " ");
         var countQueryString = queryString.replaceFirst(selectPattern, "select count(*) from ");
         countQueryString = countQueryString.replaceAll("(?i)\\s+order\\s+by\\s+.*$", "");
 
         if (queryString.toLowerCase().contains("select distinct")) {
-            throw new IllegalStateException("Pagination is not possible, if SELECT DISTINCT is present");
+            throw new IllegalStateException(
+                    "Pagination is not possible, if SELECT DISTINCT is present. Remove DISTINCT and use GROUP BY instead!");
         }
 
         if (countQueryString.equals(queryString)) {
@@ -109,11 +115,13 @@ private Page<T> asPageQuery(final int pageNumber, final int pageSize) {
         return new PageImpl<>(content, Pageable.ofSize(pageSize).withPage(pageNumber), count);
     }
 
-    private Page<T> asPageNativeQuery(final int pageNumber, final int pageSize) {
+    private Page<T> asPageNativeQuery(int pageNumber, int pageSize) {
         var queryString = unwrappedQuery.getQueryString().trim().replaceAll("\\R", " ");
         var countQueryString = "select count(*) from (" + queryString + ") as count";
         var parameters = unwrappedQuery.getParameters();
-        var countQuery = isNative ? entityManager.createNativeQuery(countQueryString, Long.class) : entityManager.createQuery(countQueryString, Long.class);
+        var countQuery = isNative
+                ? entityManager.createNativeQuery(countQueryString, Long.class)
+                : entityManager.createQuery(countQueryString, Long.class);
         for (var parameter : parameters) {
             var value = unwrappedQuery.getParameterValue(parameter.getPosition());
             countQuery.setParameter(parameter.getPosition(), value);
@@ -129,7 +137,7 @@ private Page<T> asPageNativeQuery(final int pageNumber, final int pageSize) {
      * So, if we find a "group by" inside the query string we just count the groups and do not sum the count within
      * them.
      */
-    private static long getCount(final TypedQuery<Long> countQuery, final String queryString) {
+    private static long getCount(TypedQuery<Long> countQuery, String queryString) {
         var countQueryResults = countQuery.getResultList();
         if (countQueryResults == null || countQueryResults.isEmpty()) {
             return 0L;
@@ -141,15 +149,15 @@ private static long getCount(final TypedQuery<Long> countQuery, final String que
         }
 
         // Non-grouping query: return the first element, which is the result of count(*)
-        return countQueryResults.get(0);
+        return countQueryResults.getFirst();
     }
 
-    private static long getCount(final Query countQuery) {
+    private static long getCount(Query countQuery) {
         var countQueryResults = countQuery.getResultList();
         if (countQueryResults == null || countQueryResults.isEmpty()) {
             return 0L;
         }
         // Non-grouping query: return the first element, which is the result of count(*)
-        return (long) countQueryResults.get(0);
+        return (long) countQueryResults.getFirst();
     }
 }

src/main/java/it/aboutbits/springboot/toolbox/persistence/transformer/QueryTransformer.java

@@ -1,55 +1,91 @@
 package it.aboutbits.springboot.toolbox.persistence.transformer;
 
+import it.aboutbits.springboot.toolbox.reflection.util.RecordReflectionUtil;
 import it.aboutbits.springboot.toolbox.type.CustomType;
-import it.aboutbits.springboot.toolbox.type.ScaledBigDecimal;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
-import java.math.BigDecimal;
-import java.math.BigInteger;
 import java.time.Instant;
 import java.time.OffsetDateTime;
 import java.time.ZoneId;
 import java.util.Arrays;
 
 @SuppressWarnings("rawtypes")
 public class TupleTransformer<T> {
-
     private final Class<T> outputClass;
-    private final Constructor<T> outputClassConstructor;
-    private final Class[] outputClassFieldClasses;
+    private Constructor<T> outputClassConstructor = null;
+    private Class[] outputClassFieldClasses = null;
+
+    private final Mode mode;
 
-    public TupleTransformer(final Class<T> outputClass) {
+    private enum Mode {
+        PRIMITIVE,  // Real Java primitives or their wrapped counterpart (ex., long and Long)
+        WRAPPED,  // Record with a single wrapped value (CustomType as for example Iban)
+        TUPLE  // Complex tuples with more than one value
+    }
+
+    public TupleTransformer(Class<T> outputClass) {
         this.outputClass = outputClass;
 
         // Find all fields and their types inside the result class
         // Ignore constants, because they will not be used as constructor parameters
-        outputClassFieldClasses = Arrays
-                .stream(outputClass.getDeclaredFields())
-                .filter(field -> !Modifier.isStatic(field.getModifiers()))
-                .map(Field::getType)
-                .toArray(Class[]::new);
-
-        // Find the all-args-constructor inside the result class
-        try {
-            outputClassConstructor = outputClass.getDeclaredConstructor(outputClassFieldClasses);
-            outputClassConstructor.setAccessible(true);
-        } catch (NoSuchMethodException exception) {
-            throw new TransformerRuntimeException(
-                    String.format(
-                            "Query transformation: Could not find a valid constructor in target class %s",
-                            outputClass.getName()
-                    ),
-                    exception
-            );
+        if (outputClass.isPrimitive() || isSimpleType(outputClass)) {
+            mode = Mode.PRIMITIVE;
+        } else if (CustomType.class.isAssignableFrom(outputClass)) {
+            mode = Mode.WRAPPED;
+        } else {
+            mode = Mode.TUPLE;
+
+            outputClassFieldClasses = Arrays
+                    .stream(outputClass.getDeclaredFields())
+                    .filter(field -> !Modifier.isStatic(field.getModifiers()))
+                    .map(Field::getType)
+                    .toArray(Class[]::new);
+
+            // Find the all-args-constructor inside the result class
+            try {
+                outputClassConstructor = outputClass.getDeclaredConstructor(outputClassFieldClasses);
+                outputClassConstructor.setAccessible(true);
+            } catch (NoSuchMethodException exception) {
+                throw new TransformerRuntimeException(
+                        String.format(
+                                "Query transformation: Could not find a valid constructor in target class %s",
+                                outputClass.getName()
+                        ),
+                        exception
+                );
+            }
         }
     }
 
+    private static <T> boolean isSimpleType(Class<T> outputClass) {
+        return String.class.isAssignableFrom(outputClass)
+                || Float.class.isAssignableFrom(outputClass)
+                || Double.class.isAssignableFrom(outputClass)
+                || Short.class.isAssignableFrom(outputClass)
+                || Integer.class.isAssignableFrom(outputClass)
+                || Long.class.isAssignableFrom(outputClass)
+                || Boolean.class.isAssignableFrom(outputClass);
+    }
+
     @SuppressWarnings("unchecked")
-    public T transform(final Object[] objects) {
+    public T transform(Object[] objects) {
         try {
+            if (Mode.PRIMITIVE.equals(mode)) {
+                if (objects.length != 1) {
+                    throw new TransformerRuntimeException("PRIMITIVE mode does not support multiple values!");
+                }
+                return (T) objects[0];
+            }
+
+            if (Mode.WRAPPED.equals(mode)) {
+                if (objects.length != 1) {
+                    throw new TransformerRuntimeException("WRAPPED mode does not support multiple values!");
+                }
+                return (T) toCustomType(objects[0], (Class<CustomType<?>>) outputClass);
+            }
 
             // If we have a single entry in the result, and that entry matches the desired result class
             // we can just give it back, no casting, nor type-checking needed. We can just unbox it and
@@ -95,12 +131,6 @@ public T transform(final Object[] objects) {
                     continue;
                 }
 
-                // Converter: to WrappedValue
-                if (CustomType.class.isAssignableFrom(outputClassFieldClasses[i])) {
-                    objects[i] = toWrappedValue(objects[i], outputClassFieldClasses[i]);
-                    continue;
-                }
-
                 // Converter: Instant to OffsetDateTime
                 if (objects[i] instanceof Instant && outputClassFieldClasses[i].isAssignableFrom(OffsetDateTime.class)) {
                     objects[i] = OffsetDateTime.ofInstant(
@@ -110,6 +140,12 @@ public T transform(final Object[] objects) {
                     continue;
                 }
 
+                // Converter: to Records that wrap exactly one value (CustomType)
+                if (CustomType.class.isAssignableFrom(outputClassFieldClasses[i])) {
+                    objects[i] = toCustomType(objects[i], outputClassFieldClasses[i]);
+                    continue;
+                }
+
                 // Non-matching classes in fields. No converter found...
                 throw new UnsupportedOperationException(
                         String.format(
@@ -122,8 +158,13 @@ public T transform(final Object[] objects) {
 
             return outputClassConstructor.newInstance(objects);
 
-        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException
-                 | UnsupportedOperationException exception) {
+        } catch (
+                InstantiationException
+                | IllegalAccessException
+                | NoSuchMethodException
+                | InvocationTargetException
+                | UnsupportedOperationException exception
+        ) {
             throw new TransformerRuntimeException(
                     String.format(
                             "Query transformation: Given database record cannot be converted into target class %s",
@@ -134,55 +175,12 @@ public T transform(final Object[] objects) {
         }
     }
 
-    @SuppressWarnings("unchecked")
-    private <X extends CustomType<?>> X toWrappedValue(
+    private <X extends CustomType<?>> X toCustomType(
             Object actualValue,
             Class<X> targetType
-    ) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
-        // types with a preferred constructor
-        if (targetType.isAssignableFrom(ScaledBigDecimal.class)) {
-            var constructor = targetType.getDeclaredConstructor(Double.class);
-            var value = (Double) actualValue;
-            return constructor.newInstance(value);
-        }
+    ) throws InvocationTargetException, InstantiationException, IllegalAccessException {
+        var constructor = RecordReflectionUtil.getConstructorForType(targetType, actualValue.getClass());
 
-        // types using first suitable constructor
-        Constructor<?>[] constructors = targetType.getDeclaredConstructors();
-
-        for (Constructor<?> constructor : constructors) {
-            Class<?>[] parameterTypes = constructor.getParameterTypes();
-            if (parameterTypes.length == 1) {
-                if (Number.class.isAssignableFrom(parameterTypes[0])) {
-                    if (Long.class.equals(parameterTypes[0])) {
-                        var val = (Long) actualValue;
-                        return (X) constructor.newInstance(val);
-                    } else if (Integer.class.equals(parameterTypes[0])) {
-                        var val = (Integer) actualValue;
-                        return (X) constructor.newInstance(val);
-                    } else if (Double.class.equals(parameterTypes[0])) {
-                        var val = (Double) actualValue;
-                        return (X) constructor.newInstance(val);
-                    } else if (Float.class.equals(parameterTypes[0])) {
-                        var val = (Float) actualValue;
-                        return (X) constructor.newInstance(val);
-                    } else if (BigInteger.class.equals(parameterTypes[0])) {
-                        var val = BigInteger.valueOf((Long) actualValue);
-                        return (X) constructor.newInstance(val);
-                    } else if (BigDecimal.class.equals(parameterTypes[0])) {
-                        var val = BigDecimal.valueOf((Double) actualValue);
-                        return (X) constructor.newInstance(val);
-                    } else {
-                        throw new IllegalArgumentException("Unsupported number type");
-                    }
-                } else if (String.class.equals(parameterTypes[0])) {
-                    var val = (String) actualValue;
-                    return (X) constructor.newInstance(val);
-                } else if (Boolean.class.equals(parameterTypes[0])) {
-                    var val = (Boolean) actualValue;
-                    return (X) constructor.newInstance(val);
-                } // Add more types as needed
-            }
-        }
-        throw new IllegalArgumentException(targetType.getSimpleName() + " does not have a suitable single-value constructor");
+        return constructor.newInstance(actualValue);
     }
 }