fix: improve data loader query memory usage (#252)

* fix: improve data loader query memory usage

* fix: optimize batch loader memory usage

Author: igdianov

graphql-jpa-query-schema/src/main/java/com/introproventures/graphql/jpa/query/schema/impl/GraphQLJpaQueryFactory.java

@@ -335,32 +335,23 @@ protected TypedQuery<Object> getKeysQuery(DataFetchingEnvironment environment, F
     }
 
     protected Map<Object, List<Object>> loadOneToMany(DataFetchingEnvironment environment,
-                                                 Set<Object> keys) {
+                                                      Set<Object> keys) {
         Field field = environment.getField();
 
         TypedQuery<Object[]> query = getBatchQuery(environment, field, isDefaultDistinct(), keys);
 
-        if (logger.isDebugEnabled()) {
-            logger.info("\nGraphQL JPQL Batch Query String:\n    {}", getJPQLQueryString(query));
-        }
-
-        List<Object[]> resultList = query.getResultList();
+        List<Object[]> resultList = getResultList(query);
 
         Map<Object, List<Object>> batch = resultList.stream()
+                                                    .peek(t -> entityManager.detach(t[1]))
                                                     .collect(groupingBy(t -> t[0],
                                                                         Collectors.mapping(t -> t[1],
                                                                                            GraphQLSupport.toResultList())));
-        Map<Object, List<Object>> resultMap = new LinkedHashMap<>();
+        Map<Object, List<Object>> resultMap = new LinkedHashMap<>(keys.size());
 
         keys.forEach(it -> {
             List<Object> list = batch.getOrDefault(it, Collections.emptyList());
 
-            if (!list.isEmpty()) {
-                list = list.stream()
-                           .filter(GraphQLSupport.distinctByKey(GraphQLSupport::identityToString))
-                           .collect(Collectors.toList());
-            }
-
             resultMap.put(it, list);
         });
 
@@ -369,30 +360,33 @@ protected Map<Object, List<Object>> loadOneToMany(DataFetchingEnvironment enviro
 
     protected Map<Object, Object> loadManyToOne(DataFetchingEnvironment environment,
                                                 Set<Object> keys) {
-             Field field = environment.getField();
-
-             TypedQuery<Object[]> query = getBatchQuery(environment, field, isDefaultDistinct(), keys);
+        Field field = environment.getField();
 
-             if (logger.isDebugEnabled()) {
-                 logger.info("\nGraphQL JPQL Batch Query String:\n    {}", getJPQLQueryString(query));
-             }
+        TypedQuery<Object[]> query = getBatchQuery(environment, field, isDefaultDistinct(), keys);
 
-             List<Object[]> resultList = query.getResultList();
+        List<Object[]> resultList = getResultList(query);
 
-             Map<Object, Object> batch = new LinkedHashMap<>();
+        Map<Object, Object> resultMap = new LinkedHashMap<>(resultList.size());
 
-             resultList.forEach(item -> batch.put(item[0], item[1]));
+        resultList.stream()
+                  .peek(t -> entityManager.detach(t[1]))
+                  .forEach(item -> resultMap.put(item[0], item[1]));
 
-             Map<Object, Object> resultMap = new LinkedHashMap<>();
+        return resultMap;
+    }
 
-             keys.forEach(it -> {
-                 Object list = batch.getOrDefault(it, null);
+    protected <T> List<T> getResultList(TypedQuery<T> query) {
+        if (logger.isDebugEnabled()) {
+            logger.info("\nGraphQL JPQL Batch Query String:\n    {}", getJPQLQueryString(query));
+        }
 
-                 resultMap.put(it, list);
-             });
+        // Let' try reduce overhead and disable all caching
+        query.setHint(ORG_HIBERNATE_READ_ONLY, true);
+        query.setHint(ORG_HIBERNATE_FETCH_SIZE, defaultFetchSize);
+        query.setHint(ORG_HIBERNATE_CACHEABLE, false);
 
-             return resultMap;
-         }
+        return query.getResultList();
+    }
 
     @SuppressWarnings( { "rawtypes", "unchecked" } )
     protected TypedQuery<Object[]> getBatchQuery(DataFetchingEnvironment environment, Field field, boolean isDistinct, Set<Object> keys) {
@@ -599,11 +593,8 @@ protected final List<Predicate> getFieldPredicates(Field field, CriteriaQuery<?>
                 // Let's join fetch element collections to avoid filtering their values used where search criteria
                 if(PersistentAttributeType.ELEMENT_COLLECTION == attribute.getPersistentAttributeType()) {
                     from.fetch(selection.getName(), JoinType.LEFT);
-                } else if(!whereArgument.isPresent()) {
-                    // Let's apply fetch join to retrieve associated plural attributes
-                    if (!hasAnySelectionOrderBy(selection)) {
-                        fetch = reuseFetch(from, selection.getName(), isOptional);
-                    }
+                } else if(!whereArgument.isPresent() && !hasAnySelectionOrderBy(selection)) {
+                    fetch = reuseFetch(from, selection.getName(), isOptional);
                 }
             }
             // Let's build join fetch graph to avoid Hibernate error:

graphql-jpa-query-schema/src/main/java/com/introproventures/graphql/jpa/query/support/GraphQLSupport.java

@@ -159,6 +159,11 @@ public static Collector<Object, List<Object>, List<Object>> toResultList() {
                                 left.addAll(right);
                                 return left;
                             },
+                            (list) -> {
+                                return list.stream()
+                                           .filter(GraphQLSupport.distinctByKey(GraphQLSupport::identityToString))
+                                           .collect(Collectors.toList());
+                            },
                             Collector.Characteristics.CONCURRENT);
     }