Stateless session should use batching

In Hibernate ORM and Reactive, the stateless session ignore the batch size property.
The reason is that the stateless session execute queries
immediately and does not store the entities to execute a batch update
later.

To enable batching, we need to use the `updateMultiple` method
instead. It will use the size of the list as batch value.

Author: DavideD

frameworks/Java/quarkus/resteasy-reactive-hibernate-reactive/src/main/java/io/quarkus/benchmark/repository/WorldRepository.java

@@ -37,18 +37,15 @@ public Uni<Void> createData() {
         });
     }
 
-    public Uni<List<World>> update(Mutiny.Session session, List<World> worlds) {
-        return session
-                .setBatchSize(worlds.size())
-                .flush()
-                .map(v -> worlds);
+    public Uni<List<World>> update(Mutiny.StatelessSession session, List<World> worlds) {
+        return session.updateMultiple(worlds).replaceWith(worlds);
     }
 
     public Uni<List<World>> findStateless(int count) {
         return inStatelessSession(session -> findStateless(session, count));
     }
 
-    private Uni<List<World>> findStateless(Mutiny.StatelessSession s, int count) {
+    public Uni<List<World>> findStateless(Mutiny.StatelessSession s, int count) {
         //The rules require individual load: we can't use the Hibernate feature which allows load by multiple IDs
         // as one single operation as Hibernate is too smart and will switch to use batched loads automatically.
         // Hence, use this awkward alternative:

frameworks/Java/quarkus/resteasy-reactive-hibernate-reactive/src/main/java/io/quarkus/benchmark/resource/DbResource.java

@@ -44,17 +44,14 @@ public Uni<Void> createData() {
         return worldRepository.createData();
     }
 
-    private Uni<List<World>> randomWorldsForWrite(Mutiny.Session session, int count) {
-        return worldRepository.findManaged(session, count);
+    private Uni<List<World>> randomWorldsForWrite(Mutiny.StatelessSession session, int count) {
+        return worldRepository.findStateless(session, count);
     }
 
     @GET
     @Path("updates")
     public Uni<List<World>> updates(@QueryParam("queries") String queries) {
-        return worldRepository.inSession(session -> {
-
-            session.setFlushMode(FlushMode.MANUAL);
-
+        return worldRepository.inStatelessSession(session -> {
             Uni<List<World>> worlds = randomWorldsForWrite(session, parseQueryCount(queries));
             return worlds.flatMap(worldsCollection -> {
                 final LocalRandom localRandom = Randomizer.current();
@@ -66,7 +63,6 @@ public Uni<List<World>> updates(@QueryParam("queries") String queries) {
                     //the verification:
                     w.setRandomNumber(localRandom.getNextRandomExcluding(previousRead));
                 } );
-
                 return worldRepository.update(session, worldsCollection);
             });
         });

frameworks/Java/quarkus/resteasy-reactive-hibernate/src/main/java/io/quarkus/benchmark/repository/WorldRepository.java

@@ -1,5 +1,8 @@
 package io.quarkus.benchmark.repository;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import io.quarkus.benchmark.model.World;
 import io.quarkus.benchmark.utils.LocalRandom;
 import io.quarkus.benchmark.utils.Randomizer;
@@ -53,21 +56,22 @@ public World[] loadNWorlds(final int count) {
 
     public World[] updateNWorlds(final int count) {
         //We're again forced to use the "individual load" pattern by the rules:
-        final World[] list = loadNWorlds(count);
+        final World[] worlds = loadNWorlds(count);
+        final List<World> worldList = new ArrayList<>(worlds.length);
         final LocalRandom random = Randomizer.current();
         try (StatelessSession s = sf.openStatelessSession()) {
-            s.setJdbcBatchSize(count);
-            for (World w : list) {
+            for (World w : worlds) {
                 //Read the one field, as required by the following rule:
                 // # vi. At least the randomNumber field must be read from the database result set.
                 final int previousRead = w.getRandomNumber();
                 //Update it, but make sure to exclude the current number as Hibernate optimisations would otherwise
                 // skip the write operation:
                 w.setRandomNumber(random.getNextRandomExcluding(previousRead));
-                s.update(w);
+                worldList.add(w);
             }
+            s.updateMultiple(worldList);
         }
-        return list;
+        return worlds;
     }
 
 }