Revert "Stateless session should use batching"

This reverts commit 4d8de16.

Author: DavideD

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

@@ -37,11 +37,18 @@ public Uni<Void> createData() {
         });
     }
 
-    public Uni<List<World>> update(Mutiny.StatelessSession session, List<World> worlds) {
-        return session.updateMultiple(worlds).replaceWith(() -> worlds);
+    public Uni<List<World>> update(Mutiny.Session session, List<World> worlds) {
+        return session
+                .setBatchSize(worlds.size())
+                .flush()
+                .map(v -> worlds);
     }
 
-    public Uni<List<World>> findStateless(Mutiny.StatelessSession s, int count) {
+    public Uni<List<World>> findStateless(int count) {
+        return inStatelessSession(session -> findStateless(session, count));
+    }
+
+    private 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,14 +44,17 @@ public Uni<Void> createData() {
         return worldRepository.createData();
     }
 
-    private Uni<List<World>> randomWorldsForWrite(Mutiny.StatelessSession session, int count) {
-        return worldRepository.findStateless(session, count);
+    private Uni<List<World>> randomWorldsForWrite(Mutiny.Session session, int count) {
+        return worldRepository.findManaged(session, count);
     }
 
     @GET
     @Path("updates")
     public Uni<List<World>> updates(@QueryParam("queries") String queries) {
-        return worldRepository.inStatelessSession(session -> {
+        return worldRepository.inSession(session -> {
+
+            session.setFlushMode(FlushMode.MANUAL);
+
             Uni<List<World>> worlds = randomWorldsForWrite(session, parseQueryCount(queries));
             return worlds.flatMap(worldsCollection -> {
                 final LocalRandom localRandom = Randomizer.current();
@@ -63,6 +66,7 @@ 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,8 +1,5 @@
 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;
@@ -56,22 +53,21 @@ 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[] worlds = loadNWorlds(count);
-        final List<World> worldList = new ArrayList<>(worlds.length);
+        final World[] list = loadNWorlds(count);
         final LocalRandom random = Randomizer.current();
         try (StatelessSession s = sf.openStatelessSession()) {
-            for (World w : worlds) {
+            s.setJdbcBatchSize(count);
+            for (World w : list) {
                 //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));
-                worldList.add(w);
+                s.update(w);
             }
-            s.updateMultiple(worldList);
         }
-        return worlds;
+        return list;
     }
 
 }