#1631 - Change logging for SqlUpdate ... such that it is more consistent with other SQL logging wrt JDBC batch

src/main/java/io/ebeaninternal/server/core/PersistRequestUpdateSql.java

@@ -3,8 +3,10 @@ package io.ebeaninternal.server.core;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.SpiSqlUpdate;
 import io.ebeaninternal.api.SpiTransaction;
+import io.ebeaninternal.server.lib.util.Str;
 import io.ebeaninternal.server.persist.BatchControl;
 import io.ebeaninternal.server.persist.PersistExecute;
+import io.ebeaninternal.server.persist.TrimLogSql;
 
 /**
  * Persist request specifically for CallableSql.
@@ -25,12 +27,12 @@ public final class PersistRequestUpdateSql extends PersistRequest {
 
   private String tableName;
 
-  private String description;
-
   private boolean addBatch;
 
   private boolean forceNoBatch;
 
+  private boolean batchThisRequest;
+
   public PersistRequestUpdateSql(SpiEbeanServer server, SpiSqlUpdate sqlUpdate,
                                  SpiTransaction t, PersistExecute persistExecute, boolean forceNoBatch) {
 
@@ -124,10 +126,9 @@ public final class PersistRequestUpdateSql extends PersistRequest {
    * Specify the type of statement executed. Used to automatically register
    * with the transaction event.
    */
-  public void setType(SqlType sqlType, String tableName, String description) {
+  public void setType(SqlType sqlType, String tableName) {
     this.sqlType = sqlType;
     this.tableName = tableName;
-    this.description = description;
   }
 
   /**
@@ -137,6 +138,20 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     this.bindLog = bindLog;
   }
 
+  public void startBind(boolean batchThisRequest) {
+    this.batchThisRequest = batchThisRequest;
+    super.startBind(batchThisRequest);
+  }
+
+  /**
+   * Log the sql bind used with jdbc batch.
+   */
+  public void logSqlBatchBind() {
+    if (transaction.isLogSql()) {
+      transaction.logSql(Str.add(" -- bind(", bindLog, ")"));
+    }
+  }
+
   /**
    * Perform post execute processing.
    */
@@ -145,9 +160,8 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     if (startNanos > 0) {
       persistExecute.collectSqlUpdate(label, startNanos, rowCount);
     }
-    if (transaction.isLogSummary()) {
-      String m = description + " table[" + tableName + "] rows[" + rowCount + "] bind[" + bindLog + "]";
-      transaction.logSummary(m);
+    if (transaction.isLogSql() && !batchThisRequest) {
+      transaction.logSql(Str.add(TrimLogSql.trim(updateSql.getGeneratedSql()), "; -- bind(", bindLog, ") rows(", String.valueOf(rowCount), ")"));
     }
 
     if (updateSql.isAutoTableMod()) {

src/main/java/io/ebeaninternal/server/lib/util/Str.java

@@ -15,14 +15,16 @@ public class Str {
     // determine a decent buffer size
     int len = 16 + s0.length() + s1.length();
     for (String arg1 : args) {
-      len += arg1.length();
+      len += (arg1 == null) ? 0 : arg1.length();
     }
 
     // append all the strings into the buffer
     StringBuilder sb = new StringBuilder(len);
     sb.append(s0).append(s1);
     for (String arg : args) {
-      sb.append(arg);
+      if (arg != null) {
+        sb.append(arg);
+      }
     }
     return sb.toString();
   }

src/main/java/io/ebeaninternal/server/persist/ExeUpdateSql.java

@@ -95,15 +95,10 @@ class ExeUpdateSql {
     sql = BindParamsParser.parse(bindParams, sql);
     updateSql.setGeneratedSql(sql);
 
-    boolean logSql = request.isLogSql();
-
     PreparedStatement pstmt;
     if (batchThisRequest) {
-      pstmt = pstmtFactory.getPstmt(t, logSql, sql, request);
+      pstmt = pstmtFactory.getPstmt(t, request.isLogSql(), sql, request);
     } else {
-      if (logSql) {
-        t.logSql(TrimLogSql.trim(sql));
-      }
       pstmt = pstmtFactory.getPstmt(t, sql, request.isGetGeneratedKeys());
     }
 
@@ -120,6 +115,9 @@ class ExeUpdateSql {
 
     // derive the statement type (for TransactionEvent)
     parseUpdate(sql, request);
+    if (batchThisRequest) {
+      request.logSqlBatchBind();
+    }
     return pstmt;
   }
 
@@ -127,16 +125,16 @@ class ExeUpdateSql {
   private void determineType(String word1, String word2, String word3, PersistRequestUpdateSql request) {
 
     if (word1.equalsIgnoreCase("UPDATE")) {
-      request.setType(SqlType.SQL_UPDATE, word2, "UpdateSql");
+      request.setType(SqlType.SQL_UPDATE, word2);
 
     } else if (word1.equalsIgnoreCase("DELETE")) {
-      request.setType(SqlType.SQL_DELETE, word3, "DeleteSql");
+      request.setType(SqlType.SQL_DELETE, word3);
 
     } else if (word1.equalsIgnoreCase("INSERT")) {
-      request.setType(SqlType.SQL_INSERT, word3, "InsertSql");
+      request.setType(SqlType.SQL_INSERT, word3);
 
     } else {
-      request.setType(SqlType.SQL_UNKNOWN, null, "UnknownSql");
+      request.setType(SqlType.SQL_UNKNOWN, null);
     }
   }
 
@@ -160,7 +158,7 @@ class ExeUpdateSql {
     if (spaceCount < 2) {
       // unknown so no automatic L2 cache invalidation performed (so it should instead)
       // be done explicitly via the server.externalModification() method
-      request.setType(SqlType.SQL_UNKNOWN, null, "UnknownSql");
+      request.setType(SqlType.SQL_UNKNOWN, null);
 
     } else {
       // try to determine if it is insert, update or delete and the table involved

src/test/java/io/ebean/BaseTestCase.java

@@ -94,6 +94,16 @@ public abstract class BaseTestCase {
     return trimSql(query.getGeneratedSql(), columns);
   }
 
+  protected void assertSqlBind(List<String> sql, int i) {
+    assertThat(sql.get(i)).contains("-- bind");
+  }
+
+  protected void assertSqlBind(List<String> sql, int from, int to) {
+    for (int i = from; i <= to; i++) {
+      assertThat(sql.get(i)).contains("-- bind");
+    }
+  }
+
   protected String trimSql(String sql) {
 
     if (sql.contains(" c1,")) {

src/test/java/org/tests/merge/TestMergeM2M.java

@@ -41,12 +41,12 @@ public class TestMergeM2M extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(3);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("select");
       assertThat(sql.get(1)).contains("insert into mmachine");
       assertThat(sql.get(2)).contains("insert into mmachine_mgroup");
-    }
-    else {
+      assertSqlBind(sql, 3, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("select");
       assertThat(sql.get(1)).contains("insert into mmachine");
@@ -66,11 +66,13 @@ public class TestMergeM2M extends BaseTestCase {
     Ebean.merge(m1, options);
 
     sql = LoggedSqlCollector.current();
-    assertThat(sql).hasSize(4);
+    assertThat(sql).hasSize(9);
     assertThat(sql.get(0)).contains("select");
     assertThat(sql.get(1)).contains("delete from mmachine_mgroup");
-    assertThat(sql.get(2)).contains("insert into mmachine_mgroup");
-    assertThat(sql.get(3)).contains("update mmachine");
+    assertSqlBind(sql, 2, 4);
 
+    assertThat(sql.get(5)).contains("insert into mmachine_mgroup");
+    assertSqlBind(sql, 6, 7);
+    assertThat(sql.get(8)).contains("update mmachine");
   }
 }

src/test/java/org/tests/model/elementcollection/TestElementCollectionBasic.java

@@ -30,11 +30,11 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(4);
       assertThat(sql.get(0)).contains("insert into ec_person");
       assertThat(sql.get(1)).contains("insert into ec_person_phone");
-    }
-    else {
+      assertSqlBind(sql, 2, 3);
+    } else {
       assertThat(sql).hasSize(3);
       assertThat(sql.get(0)).contains("insert into ec_person");
       assertThat(sql.get(1)).contains("insert into ec_person_phone");
@@ -130,12 +130,13 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(3);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("update ec_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ec_person_phone where owner_id=?");
       assertThat(sql.get(2)).contains("insert into ec_person_phone (owner_id,phone) values (?,?)");
-    }
-    else {
+      assertSqlBind(sql, 3, 5);
+
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("update ec_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ec_person_phone where owner_id=?");
@@ -160,10 +161,12 @@ public class TestElementCollectionBasic extends BaseTestCase {
     }
 
     List<String> sql = LoggedSqlCollector.current();
-    assertThat(sql).hasSize(4);
+    assertThat(sql).hasSize(9);
     assertThat(sql.get(0)).contains("update ec_person set name=?, version=? where id=? and version=?");
     assertThat(sql.get(2)).contains("delete from ec_person_phone where owner_id=?");
-    assertThat(sql.get(3)).contains("insert into ec_person_phone (owner_id,phone) values (?,?)");
+    assertSqlBind(sql, 3);
+    assertThat(sql.get(4)).contains("insert into ec_person_phone (owner_id,phone) values (?,?)");
+    assertSqlBind(sql, 5, 8);
 
     assertThat(eventLog()).containsExactly("preUpdate", "postUpdate");
 
@@ -192,9 +195,11 @@ public class TestElementCollectionBasic extends BaseTestCase {
     }
 
     List<String> sql = LoggedSqlCollector.current();
-    assertThat(sql).hasSize(2);
+    assertThat(sql).hasSize(8);
     assertThat(sql.get(0)).contains("delete from ec_person_phone where owner_id=?");
-    assertThat(sql.get(1)).contains("insert into ec_person_phone (owner_id,phone) values (?,?)");
+    assertSqlBind(sql, 1);
+    assertThat(sql.get(2)).contains("insert into ec_person_phone (owner_id,phone) values (?,?)");
+    assertSqlBind(sql, 3, 7);
 
     assertThat(eventLog()).containsExactly("preUpdate", "postUpdate");
 
@@ -208,11 +213,12 @@ public class TestElementCollectionBasic extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(8);
       assertThat(sql.get(0)).contains("delete from ec_person_phone where owner_id=?");
       assertThat(sql.get(1)).contains("insert into ec_person_phone (owner_id,phone) values (?,?)");
-    }
-    else {
+      assertSqlBind(sql, 2, 7);
+
+    } else {
       assertThat(sql).hasSize(7);
       assertThat(sql.get(0)).contains("delete from ec_person_phone where owner_id=?");
       assertThat(sql.get(1)).contains("insert into ec_person_phone (owner_id,phone) values (?,?)");

src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicCache.java

@@ -1,5 +1,6 @@
 package org.tests.model.elementcollection;
 
+import io.ebean.BaseTestCase;
 import io.ebean.Ebean;
 import io.ebean.annotation.PersistBatch;
 import io.ebeaninternal.api.SpiEbeanServer;
@@ -10,7 +11,7 @@ import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class TestElementCollectionBasicCache {
+public class TestElementCollectionBasicCache extends BaseTestCase {
 
   @Test
   public void test() {
@@ -42,9 +43,9 @@ public class TestElementCollectionBasicCache {
 
     sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(3);
-    }
-    else {
+      assertThat(sql).hasSize(6);
+      assertSqlBind(sql, 3, 5);
+    } else {
       assertThat(sql).hasSize(5);
     }
 
@@ -68,9 +69,8 @@ public class TestElementCollectionBasicCache {
 
     sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2); // cache hit
-    }
-    else {
+      assertThat(sql).hasSize(6); // cache hit
+    } else {
       assertThat(sql).hasSize(5); // cache hit
     }
 

src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMap.java

@@ -25,11 +25,11 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(4);
       assertThat(sql.get(0)).contains("insert into ecm_person");
       assertThat(sql.get(1)).contains("insert into ecm_person_phone");
-    }
-    else {
+      assertSqlBind(sql, 2, 3);
+    } else {
       assertThat(sql).hasSize(3);
       assertThat(sql.get(0)).contains("insert into ecm_person");
       assertThat(sql.get(1)).contains("insert into ecm_person_phone");
@@ -105,12 +105,12 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(3);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("update ecm_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ecm_person_phone_numbers where ecm_person_id=?");
       assertThat(sql.get(2)).contains("insert into ecm_person_phone_numbers (ecm_person_id,type,number) values (?,?,?)");
-    }
-    else {
+      assertSqlBind(sql, 3, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("update ecm_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ecm_person_phone_numbers where ecm_person_id=?");
@@ -139,11 +139,11 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("delete from ecm_person_phone_numbers where ecm_person_id=?");
       assertThat(sql.get(1)).contains("insert into ecm_person_phone_numbers (ecm_person_id,type,number) values (?,?,?)");
-    }
-    else {
+      assertSqlBind(sql, 2, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("delete from ecm_person_phone_numbers where ecm_person_id=?");
       assertThat(sql.get(1)).contains("insert into ecm_person_phone_numbers (ecm_person_id,type,number) values (?,?,?)");

src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapAsLob.java

@@ -23,9 +23,10 @@ public class TestElementCollectionBasicMapAsLob extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(4);
       assertThat(sql.get(0)).contains("insert into ecmc_person");
       assertThat(sql.get(1)).contains("insert into ecmc_person_phone");
+      assertSqlBind(sql, 2, 3);
     } else {
       assertThat(sql).hasSize(3);
       assertThat(sql.get(0)).contains("insert into ecmc_person");

src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicMapCache.java

@@ -1,5 +1,6 @@
 package org.tests.model.elementcollection;
 
+import io.ebean.BaseTestCase;
 import io.ebean.Ebean;
 import io.ebean.annotation.PersistBatch;
 import io.ebeaninternal.api.SpiEbeanServer;
@@ -10,7 +11,7 @@ import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class TestElementCollectionBasicMapCache {
+public class TestElementCollectionBasicMapCache extends BaseTestCase {
 
   @Test
   public void test() {
@@ -44,9 +45,9 @@ public class TestElementCollectionBasicMapCache {
 
     sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(3);
-    }
-    else {
+      assertThat(sql).hasSize(6);
+      assertSqlBind(sql, 3, 5);
+    } else {
       assertThat(sql).hasSize(5);
     }
 
@@ -72,9 +73,9 @@ public class TestElementCollectionBasicMapCache {
 
     sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2); // cache hit
-    }
-    else {
+      assertThat(sql).hasSize(4); // cache hit
+      assertSqlBind(sql, 2, 3);
+    } else {
       assertThat(sql).hasSize(3); // cache hit
     }
 

src/test/java/org/tests/model/elementcollection/TestElementCollectionBasicSet.java

@@ -24,11 +24,11 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(4);
       assertThat(sql.get(0)).contains("insert into ecs_person");
       assertThat(sql.get(1)).contains("insert into ecs_person_phone");
-    }
-    else {
+      assertSqlBind(sql, 2, 3);
+    } else {
       assertThat(sql).hasSize(3);
       assertThat(sql.get(0)).contains("insert into ecs_person");
       assertThat(sql.get(1)).contains("insert into ecs_person_phone");
@@ -103,12 +103,12 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(3);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("update ecs_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ecs_person_phone where ecs_person_id=?");
       assertThat(sql.get(2)).contains("insert into ecs_person_phone (ecs_person_id,phone) values (?,?)");
-    }
-    else {
+      assertSqlBind(sql, 3, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("update ecs_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ecs_person_phone where ecs_person_id=?");
@@ -137,11 +137,11 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("delete from ecs_person_phone where ecs_person_id=?");
       assertThat(sql.get(1)).contains("insert into ecs_person_phone (ecs_person_id,phone) values (?,?)");
-    }
-    else {
+      assertSqlBind(sql, 2, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("delete from ecs_person_phone where ecs_person_id=?");
       assertThat(sql.get(1)).contains("insert into ecs_person_phone (ecs_person_id,phone) values (?,?)");

src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedList.java

@@ -23,11 +23,11 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(4);
       assertThat(sql.get(0)).contains("insert into ecbl_person");
       assertThat(sql.get(1)).contains("insert into ecbl_person_phone_numbers");
-    }
-    else {
+      assertSqlBind(sql, 2, 3);
+    } else {
       assertThat(sql).hasSize(3);
       assertThat(sql.get(0)).contains("insert into ecbl_person");
       assertThat(sql.get(1)).contains("insert into ecbl_person_phone_numbers");
@@ -103,12 +103,12 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(3);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("update ecbl_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ecbl_person_phone_numbers where person_id=?");
       assertThat(sql.get(2)).contains("insert into ecbl_person_phone_numbers (person_id,country_code,area,number) values (?,?,?,?)");
-    }
-    else {
+      assertSqlBind(sql, 3, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("update ecbl_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ecbl_person_phone_numbers where person_id=?");
@@ -137,11 +137,11 @@ public class TestElementCollectionEmbeddedList extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("delete from ecbl_person_phone_numbers where person_id=?");
       assertThat(sql.get(1)).contains("insert into ecbl_person_phone_numbers (person_id,country_code,area,number) values (?,?,?,?)");
-    }
-    else {
+      assertSqlBind(sql, 2, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("delete from ecbl_person_phone_numbers where person_id=?");
       assertThat(sql.get(1)).contains("insert into ecbl_person_phone_numbers (person_id,country_code,area,number) values (?,?,?,?)");

src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedListCache.java

@@ -48,11 +48,11 @@ public class TestElementCollectionEmbeddedListCache extends BaseTestCase {
 
     sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2); // update of collection only
+      assertThat(sql).hasSize(4); // update of collection only
       assertThat(sql.get(0)).contains("delete from ecbl_person_phone_numbers where person_id=?");
       assertThat(sql.get(1)).contains("insert into ecbl_person_phone_numbers (person_id,country_code,area,number) values (?,?,?,?)");
-    }
-    else {
+      assertSqlBind(sql, 2, 3);
+    } else {
       assertThat(sql).hasSize(3); // update of collection only
       assertThat(sql.get(0)).contains("delete from ecbl_person_phone_numbers where person_id=?");
       assertThat(sql.get(1)).contains("insert into ecbl_person_phone_numbers (person_id,country_code,area,number) values (?,?,?,?)");
@@ -76,7 +76,7 @@ public class TestElementCollectionEmbeddedListCache extends BaseTestCase {
     Ebean.save(three);
 
     sql = LoggedSqlCollector.current();
-    assertThat(sql).hasSize(3);
+    assertThat(sql).hasSize(4);
 
     EcblPerson four = Ebean.find(EcblPerson.class)
       .setId(person.getId())

src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMap.java

@@ -24,11 +24,11 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(4);
       assertThat(sql.get(0)).contains("insert into ecbm_person");
       assertThat(sql.get(1)).contains("insert into ecbm_person_phone_numbers");
-    }
-    else {
+      assertSqlBind(sql, 2, 3);
+    } else {
       assertThat(sql).hasSize(3);
       assertThat(sql.get(0)).contains("insert into ecbm_person");
       assertThat(sql.get(1)).contains("insert into ecbm_person_phone_numbers");
@@ -96,12 +96,12 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(3);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("update ecbm_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ecbm_person_phone_numbers where person_id=?");
       assertThat(sql.get(2)).contains("insert into ecbm_person_phone_numbers (person_id,mkey,country_code,area,number)");
-    }
-    else {
+      assertSqlBind(sql, 3, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("update ecbm_person set name=?, version=? where id=? and version=?");
       assertThat(sql.get(1)).contains("delete from ecbm_person_phone_numbers where person_id=?");
@@ -130,11 +130,11 @@ public class TestElementCollectionEmbeddedMap extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2);
+      assertThat(sql).hasSize(6);
       assertThat(sql.get(0)).contains("delete from ecbm_person_phone_numbers where person_id=?");
       assertThat(sql.get(1)).contains("insert into ecbm_person_phone_numbers (person_id,mkey,country_code,area,number) values (?,?,?,?,?)");
-    }
-    else {
+      assertSqlBind(sql, 2, 5);
+    } else {
       assertThat(sql).hasSize(5);
       assertThat(sql.get(0)).contains("delete from ecbm_person_phone_numbers where person_id=?");
       assertThat(sql.get(1)).contains("insert into ecbm_person_phone_numbers (person_id,mkey,country_code,area,number) values (?,?,?,?,?)");

src/test/java/org/tests/model/elementcollection/TestElementCollectionEmbeddedMapCache.java

@@ -49,11 +49,11 @@ public class TestElementCollectionEmbeddedMapCache extends BaseTestCase {
 
     sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(2); // update of collection only
+      assertThat(sql).hasSize(4); // update of collection only
       assertThat(sql.get(0)).contains("delete from ecbm_person_phone_numbers where person_id=?");
       assertThat(sql.get(1)).contains("insert into ecbm_person_phone_numbers (person_id,mkey,country_code,area,number) values (?,?,?,?,?)");
-    }
-    else {
+      assertSqlBind(sql, 2, 3);
+    } else {
       assertThat(sql).hasSize(3); // update of collection only
       assertThat(sql.get(0)).contains("delete from ecbm_person_phone_numbers where person_id=?");
       assertThat(sql.get(1)).contains("insert into ecbm_person_phone_numbers (person_id,mkey,country_code,area,number) values (?,?,?,?,?)");
@@ -77,7 +77,7 @@ public class TestElementCollectionEmbeddedMapCache extends BaseTestCase {
     Ebean.save(three);
 
     sql = LoggedSqlCollector.current();
-    assertThat(sql).hasSize(3);
+    assertThat(sql).hasSize(4);
 
     EcbmPerson four = Ebean.find(EcbmPerson.class)
       .setId(person.getId())

src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTable.java

@@ -38,10 +38,11 @@ public class TestOneToManyJoinTable extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(1);
+      assertThat(sql).hasSize(3);
       assertThat(sql.get(0)).contains("insert into troop_monkey (troop_pid, monkey_mid) values (?, ?)");
-    }
-    else {
+      assertSqlBind(sql, 1, 2);
+
+    } else {
       assertThat(sql).hasSize(2);
       assertThat(sql.get(0)).contains("insert into troop_monkey (troop_pid, monkey_mid) values (?, ?)");
       assertThat(sql.get(1)).contains("insert into troop_monkey (troop_pid, monkey_mid) values (?, ?)");
@@ -96,12 +97,14 @@ public class TestOneToManyJoinTable extends BaseTestCase {
     //Collections.sort(sql);
 
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(8);
+      assertThat(sql).hasSize(13);
       assertThat(sql.get(0)).contains("insert into trainer ");
       assertThat(sql.get(1)).contains("insert into monkey ");
+      assertSqlBind(sql, 2, 4);
       assertThat(sql.get(5)).contains("update monkey set name=?, food_preference=?, version=? where mid=? and version=?");
       assertThat(sql.get(6)).contains("-- bind(");
       assertThat(sql.get(7)).contains("insert into trainer_monkey ");
+      assertSqlBind(sql, 8, 12);
 
     } else {
       assertThat(sql).hasSize(10);

src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableInheritance.java

@@ -34,7 +34,7 @@ public class TestOneToManyJoinTableInheritance extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
 
-    assertThat(sql).hasSize(8);
+    assertThat(sql).hasSize(11);
     assertThat(sql.get(0)).contains("insert into class_super ");
     assertThat(sql.get(1)).contains("-- bind(ClassA)");
     assertThat(sql.get(2)).contains("-- bind(ClassB)");
@@ -43,6 +43,7 @@ public class TestOneToManyJoinTableInheritance extends BaseTestCase {
     assertThat(sql.get(5)).contains("-- bind(Tim");
     assertThat(sql.get(6)).contains("-- bind(Uim");
     assertThat(sql.get(7)).contains("insert into class_super_monkey (class_super_sid, monkey_mid) values (?, ?)");
+    assertSqlBind(sql, 8, 10);
 
     ClassA dbA = Ebean.find(ClassA.class, 1);
     ClassB dbB = Ebean.find(ClassB.class, 2);

src/test/java/org/tests/o2m/jointable/TestOneToManyJoinTableNoTableName.java

@@ -38,10 +38,10 @@ public class TestOneToManyJoinTableNoTableName extends BaseTestCase {
 
     List<String> sql = LoggedSqlCollector.current();
     if (isPersistBatchOnCascade()) {
-      assertThat(sql).hasSize(1);
+      assertThat(sql).hasSize(3);
       assertThat(sql.get(0)).contains("insert into mkeygroup_monkey (mkeygroup_pid, monkey_mid) values (?, ?)");
-    }
-    else {
+      assertSqlBind(sql, 1, 2);
+    } else {
       assertThat(sql).hasSize(2);
       assertThat(sql.get(0)).contains("insert into mkeygroup_monkey (mkeygroup_pid, monkey_mid) values (?, ?)");
       assertThat(sql.get(1)).contains("insert into mkeygroup_monkey (mkeygroup_pid, monkey_mid) values (?, ?)");

src/test/java/org/tests/update/TestSqlUpdateBindMultipleLists.java

@@ -3,9 +3,13 @@ package org.tests.update;
 import io.ebean.BaseTestCase;
 import io.ebean.Ebean;
 import io.ebean.SqlUpdate;
+import org.ebeantest.LoggedSqlCollector;
 import org.junit.Test;
 
+import java.util.List;
+
 import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
 
 public class TestSqlUpdateBindMultipleLists extends BaseTestCase {
@@ -13,6 +17,8 @@ public class TestSqlUpdateBindMultipleLists extends BaseTestCase {
   @Test
   public void test() {
 
+    LoggedSqlCollector.start();
+
     SqlUpdate sqlUpdate = Ebean.createSqlUpdate("delete from o_customer where id in (:ids)");
 
     sqlUpdate.setParameter("ids", asList(9991, 9992, 9993));
@@ -24,6 +30,8 @@ public class TestSqlUpdateBindMultipleLists extends BaseTestCase {
     sqlUpdate.execute();
     assertEquals("delete from o_customer where id in (?,?)", sqlUpdate.getGeneratedSql());
 
+    List<String> sql = LoggedSqlCollector.stop();
+    assertThat(sql).hasSize(2);
   }
 
 

src/test/java/org/tests/update/TestSqlUpdateInTxn.java

@@ -5,6 +5,7 @@ import io.ebean.Ebean;
 import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
 import io.ebean.meta.MetaTimedMetric;
+import org.ebeantest.LoggedSqlCollector;
 import org.junit.Assert;
 import org.junit.Test;
 import org.tests.idkeys.db.AuditLog;
@@ -42,19 +43,55 @@ public class TestSqlUpdateInTxn extends BaseTestCase {
   @Test
   public void testExecute_inTransaction_withBatch() {
 
+    LoggedSqlCollector.start();
+
     try (Transaction transaction = Ebean.beginTransaction()) {
       transaction.setBatchMode(true);
 
-      int row = Ebean.createSqlUpdate("update audit_log set description = description where id = ?")
-        .setParameter(1, 999999)
-        .execute();
+      SqlUpdate sqlUpdate = Ebean.createSqlUpdate("update audit_log set description = description where id = ?")
+        .setParameter(1, 999999);
 
+      int row = sqlUpdate.execute();
       // update statement using JDBC batch so not executed yet
       assertThat(row).isEqualTo(-1);
 
+      sqlUpdate.setParameter(1, 999998);
+      sqlUpdate.execute();
+
       transaction.commit();
     }
 
+    List<String> sql = LoggedSqlCollector.stop();
+    assertThat(sql).hasSize(3);
+    assertThat(sql.get(0)).contains("update audit_log set description = description where id = ?");
+    assertSqlBind(sql, 1, 2);
+  }
+
+  @Test
+  public void testExecute_inTransaction_withoutBatch() {
+
+    LoggedSqlCollector.start();
+
+    try (Transaction transaction = Ebean.beginTransaction()) {
+      transaction.setBatchMode(false);
+
+      SqlUpdate sqlUpdate = Ebean.createSqlUpdate("update audit_log set description = description where id = ?")
+        .setParameter(1, 999999);
+
+      int row0 = sqlUpdate.execute();
+      assertThat(row0).isEqualTo(0);
+
+      sqlUpdate.setParameter(1, 999998);
+      int row1 = sqlUpdate.execute();
+      assertThat(row1).isEqualTo(0);
+
+      transaction.commit();
+    }
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("update audit_log set description = description where id = ?; -- bind(999999)");
+    assertThat(sql.get(1)).contains("update audit_log set description = description where id = ?; -- bind(999998)");
   }
 
   @Test