#220 - Refactor Persist batch, add effectively add PersistBatch.INSERT (to ALL and NONE) and allow batching per request (save(), insert(), update(), delete())

src/test/java/com/avaje/tests/batchinsert/TestBatchInsertSimple.java

@@ -1,53 +1,115 @@
 package com.avaje.tests.batchinsert;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
-import org.junit.Test;
-
 import com.avaje.ebean.BaseTestCase;
 import com.avaje.ebean.Ebean;
 import com.avaje.ebean.Transaction;
+import com.avaje.ebean.config.PersistBatch;
 import com.avaje.tests.model.basic.UTDetail;
 import com.avaje.tests.model.basic.UTMaster;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
 
 public class TestBatchInsertSimple extends BaseTestCase {
 
   Random random = new Random();
 
   @Test
-  public void testSimpleJdbcBatching() {
+  public void testJdbcBatchPerRequestWithMasterAndDetails() {
 
-    int numOfMasters = 10;// 2 + random.nextInt(8);
+    int numOfMasters = 4;// 2 + random.nextInt(8);
+
+    Transaction transaction = Ebean.beginTransaction();
+    try {
+      transaction.setBatch(PersistBatch.NONE);
+      transaction.setBatchOnCascade(PersistBatch.INSERT);
+      transaction.setBatchSize(30);
+
+      for (int i = 0; i < numOfMasters; i++) {
+        UTMaster master = createMasterAndDetails(i, 20);
+        Ebean.save(master);
+      }
+
+      transaction.commit();
+
+    } finally {
+      transaction.end();
+    }
+  }
+
+
+  @Test
+  public void testJdbcBatchPerRequestWithMasterOnly() {
+
+    int numOfMasters = 4;
+
+    Transaction transaction = Ebean.beginTransaction();
+    try {
+      transaction.setBatch(PersistBatch.NONE);
+      transaction.setBatchOnCascade(PersistBatch.INSERT);
+      transaction.setBatchSize(30);
+
+      for (int i = 0; i < numOfMasters; i++) {
+        UTMaster master = createMaster(i);
+        Ebean.save(master);
+      }
+
+      transaction.commit();
+
+    } finally {
+      transaction.end();
+    }
+  }
+
+  @Test
+  public void testJdbcBatchOnCollection() {
+
+    int numOfMasters = 3;
 
     List<UTMaster> masters = new ArrayList<UTMaster>();
     for (int i = 0; i < numOfMasters; i++) {
-      masters.add(createMasterAndDetails(i));
+      masters.add(createMasterAndDetails(i, 7));
     }
 
     Transaction transaction = Ebean.beginTransaction();
     try {
-      transaction.setBatchMode(true);
-      transaction.setBatchSize(4);
-      // transaction.setLogLevel(LogLevel.SUMMARY);
-      // transaction.setBatchGetGeneratedKeys(false);
+      transaction.setBatch(PersistBatch.NONE);
+      transaction.setBatchOnCascade(PersistBatch.ALL);
+      transaction.setBatchSize(20);
 
+      // escalate based on batchOnCascade value
       Ebean.save(masters);
 
       transaction.commit();
 
     } finally {
-      Ebean.endTransaction();
+      transaction.end();
     }
   }
 
-  private UTMaster createMasterAndDetails(int masterPos) {
+  @Test
+  public void testJdbcBatchOnCollectionNoTransaction() {
+
+    int numOfMasters = 3;
+
+    List<UTMaster> masters = new ArrayList<UTMaster>();
+    for (int i = 0; i < numOfMasters; i++) {
+      masters.add(createMasterAndDetails(i, 5));
+    }
+
+    // escalate based on batchOnCascade value
+    Ebean.save(masters);
+
+  }
+
+  private UTMaster createMasterAndDetails(int masterPos, int size) {
 
     UTMaster master = createMaster(masterPos);
     List<UTDetail> details = new ArrayList<UTDetail>();
 
-    int count = 2 + random.nextInt(20);
+    int count = 2 + random.nextInt(size);
 
     for (int i = 0; i < count; i++) {
 

src/test/java/com/avaje/tests/model/basic/xtra/TestInsertBatchThenFlushThenUpdate.java

@@ -0,0 +1,66 @@
+package com.avaje.tests.model.basic.xtra;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.Transaction;
+import com.avaje.ebean.config.PersistBatch;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class TestInsertBatchThenFlushThenUpdate extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    LoggedSqlCollector.start();
+    Transaction txn = Ebean.beginTransaction();
+    try {
+      txn.setBatch(PersistBatch.ALL);
+
+      EdParent parent = new EdParent();
+      parent.setName("MyComputer");
+
+      EdChild child = new EdChild();
+      child.setName("Harddisk 123");
+      child.setParent(parent);
+      ArrayList<EdChild> children = new ArrayList<EdChild>();
+      children.add(child);
+      parent.setChildren(children);
+
+      Ebean.save(parent);
+
+      // nothing flushed yet
+      assertEquals(0, LoggedSqlCollector.start().size());
+
+      txn.flushBatch();
+
+      List<String> loggedSql1 = LoggedSqlCollector.start();
+      assertEquals(loggedSql1.toString(), 2, loggedSql1.size());
+
+      parent.setName("MyDesk");
+      Ebean.save(parent);
+
+      // nothing flushed yet
+      assertEquals(0, LoggedSqlCollector.start().size());
+
+      Ebean.commitTransaction();
+
+      // insert statements for EdExtendedParent
+      List<String> loggedSql2 = LoggedSqlCollector.start();
+      assertEquals(2, loggedSql2.size());
+      assertTrue(loggedSql2.get(0).contains(" update td_parent "));
+      assertTrue(loggedSql2.get(1).contains(" update td_child "));
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+
+}

src/test/java/com/avaje/tests/model/basic/xtra/TestInsertBatchThenUpdate.java

@@ -0,0 +1,59 @@
+package com.avaje.tests.model.basic.xtra;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.Transaction;
+import com.avaje.ebean.config.PersistBatch;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestInsertBatchThenUpdate extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    LoggedSqlCollector.start();
+    Transaction txn = Ebean.beginTransaction();
+    try {
+      txn.setBatch(PersistBatch.ALL);
+
+      EdParent parent = new EdParent();
+      parent.setName("MyComputer");
+
+      EdChild child = new EdChild();
+      child.setName("Harddisk 123");
+      child.setParent(parent);
+      ArrayList<EdChild> children = new ArrayList<EdChild>();
+      children.add(child);
+      parent.setChildren(children);
+
+      Ebean.save(parent);
+
+      // nothing flushed yet
+      List<String> loggedSql0 = LoggedSqlCollector.start();
+      assertEquals(0, loggedSql0.size());
+
+      parent.setName("MyDesk");
+      Ebean.save(parent);
+
+      // nothing flushed yet
+      assertEquals(0, LoggedSqlCollector.start().size());
+
+      Ebean.commitTransaction();
+
+      // insert statements for EdExtendedParent
+      List<String> loggedSql2 = LoggedSqlCollector.start();
+      assertEquals(2, loggedSql2.size());
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+
+}

src/test/java/com/avaje/tests/model/basic/xtra/TestInsertBatchWithDifferentRootTypes.java

@@ -0,0 +1,70 @@
+package com.avaje.tests.model.basic.xtra;
+
+import com.avaje.ebean.BaseTestCase;
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.Transaction;
+import com.avaje.ebean.config.PersistBatch;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestInsertBatchWithDifferentRootTypes extends BaseTestCase {
+
+  @Test
+  public void testDifferRootTypes() {
+
+    LoggedSqlCollector.start();
+    Transaction txn = Ebean.beginTransaction();
+    try {
+      txn.setBatch(PersistBatch.ALL);
+
+      EdParent parent = new EdParent();
+      parent.setName("MyComputer");
+
+      EdChild child = new EdChild();
+      child.setName("Harddisk 123");
+      child.setParent(parent);
+      ArrayList<EdChild> children = new ArrayList<EdChild>();
+      children.add(child);
+      parent.setChildren(children);
+
+      Ebean.save(parent);
+
+      EdExtendedParent extendedParent = new EdExtendedParent();
+      extendedParent.setName("My second computer");
+      extendedParent.setExtendedName("Multimedia");
+
+      child = new EdChild();
+      child.setName("DVBS Card");
+      children = new ArrayList<EdChild>();
+      children.add(child);
+      extendedParent.setChildren(children);
+
+      // nothing flushed yet
+      List<String> loggedSql0 = LoggedSqlCollector.start();
+      assertEquals(0, loggedSql0.size());
+
+      // causes a flush as EdExtendedParent is different from EdParent
+      Ebean.save(extendedParent);
+
+      // insert statements for EdParent
+      List<String> loggedSql1 = LoggedSqlCollector.start();
+      assertEquals(2, loggedSql1.size());
+
+      Ebean.commitTransaction();
+
+      // insert statements for EdExtendedParent
+      List<String> loggedSql2 = LoggedSqlCollector.start();
+      assertEquals(2, loggedSql2.size());
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+
+}

src/test/java/com/avaje/tests/query/joins/TestQueryJoinManyNonRoot.java

@@ -2,18 +2,39 @@ package com.avaje.tests.query.joins;
 
 import java.util.List;
 
+import com.avaje.ebean.*;
+import org.avaje.ebeantest.LoggedSqlCollector;
 import org.junit.Assert;
 import org.junit.Test;
 
-import com.avaje.ebean.BaseTestCase;
-import com.avaje.ebean.Ebean;
-import com.avaje.ebean.FetchConfig;
-import com.avaje.ebean.Query;
 import com.avaje.tests.model.basic.Order;
 import com.avaje.tests.model.basic.ResetBasicData;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
 public class TestQueryJoinManyNonRoot extends BaseTestCase {
 
+  @Test
+  public void test_manyPredicate() {
+
+    ResetBasicData.reset();
+
+    LoggedSqlCollector.start();
+
+    List<Order> orders = Ebean.find(Order.class)
+            .select("id, status, orderDate")
+            .where().gt("details.orderQty", 0)
+            .findList();
+
+    assertTrue(!orders.isEmpty());
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    assertEquals(1, loggedSql.size());
+    assertTrue(loggedSql.get(0).contains("select distinct "));
+    assertTrue(loggedSql.get(0).contains(" from o_order t0 join o_order_detail u1 on u1.order_id = t0.id "));
+  }
+
   @Test
   public void test_manyNonRoot() {
 
@@ -27,9 +48,9 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
     List<Order> list = q.findList();
     String sql = q.getGeneratedSql();
 
-    Assert.assertTrue(list.size() > 0);
-    Assert.assertTrue(sql.contains("join o_customer t1 on t1.id "));
-    Assert.assertTrue(sql.contains("left outer join contact t2 on"));
+    assertTrue(list.size() > 0);
+    assertTrue(sql.contains("join o_customer t1 on t1.id "));
+    assertTrue(sql.contains("left outer join contact t2 on"));
     
     // select t0.id c0, t0.status c1, t0.order_date c2, t0.ship_date c3, t1.name c4, t0.cretime c5, t0.updtime c6, 
     //        t1.id c7, t1.status c8, t1.name c9, t1.smallnote c10, t1.anniversary c11, t1.cretime c12, t1.updtime c13, t1.billing_address_id c14, t1.shipping_address_id c15, 
@@ -56,10 +77,10 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
     List<Order> list = q.findList();
     String sql = q.getGeneratedSql();
 
-    Assert.assertTrue(list.size() > 0);
-    Assert.assertTrue(sql.contains("join o_customer t1 on t1.id "));
-    Assert.assertTrue(sql.contains("left outer join o_order_detail "));
-    Assert.assertTrue(sql.contains("left outer join o_product "));
+    assertTrue(list.size() > 0);
+    assertTrue(sql.contains("join o_customer t1 on t1.id "));
+    assertTrue(sql.contains("left outer join o_order_detail "));
+    assertTrue(sql.contains("left outer join o_product "));
 
     Assert.assertFalse(sql.contains("left outer join contact"));
 
@@ -84,9 +105,9 @@ public class TestQueryJoinManyNonRoot extends BaseTestCase {
       order.getCustomer().getContacts().size();
     }
 
-    Assert.assertTrue(list.size() > 0);
-    Assert.assertTrue(sql.contains("join o_customer t1 on t1.id "));
-    Assert.assertTrue(sql.contains("left outer join contact "));
+    assertTrue(list.size() > 0);
+    assertTrue(sql.contains("join o_customer t1 on t1.id "));
+    assertTrue(sql.contains("left outer join contact "));
 
     Assert.assertFalse(sql.contains("left outer join o_order_detail "));
     Assert.assertFalse(sql.contains("left outer join o_product "));