#115 - Mapping - Add support for @ElementCollection enhancement

Add embedded bean support

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

@@ -0,0 +1,52 @@
+package org.tests.model.elementcollection;
+
+import javax.persistence.Embeddable;
+import javax.validation.constraints.Size;
+
+@Embeddable
+public class EcPhone {
+
+  @Size(max = 2)
+  String countryCode;
+
+  @Size(max = 6)
+  String area;
+
+  @Size(max = 20)
+  String number;
+
+  public EcPhone(String countryCode, String area, String number) {
+    this.countryCode = countryCode;
+    this.area = area;
+    this.number = number;
+  }
+
+  @Override
+  public String toString() {
+    return countryCode + "-" + area + "-" + number;
+  }
+
+  public String getCountryCode() {
+    return countryCode;
+  }
+
+  public void setCountryCode(String countryCode) {
+    this.countryCode = countryCode;
+  }
+
+  public String getArea() {
+    return area;
+  }
+
+  public void setArea(String area) {
+    this.area = area;
+  }
+
+  public String getNumber() {
+    return number;
+  }
+
+  public void setNumber(String number) {
+    this.number = number;
+  }
+}

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

@@ -0,0 +1,67 @@
+package org.tests.model.elementcollection;
+
+import javax.persistence.CollectionTable;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.Version;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+public class EcblPerson {
+
+  @Id
+  long id;
+
+  String name;
+
+  @ElementCollection
+  @CollectionTable(joinColumns = @JoinColumn(name = "person_id"))
+  List<EcPhone> phoneNumbers = new ArrayList<>();
+
+  @Version
+  long version;
+
+  public EcblPerson(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public String toString() {
+    return "person id:" + id + " name:" + name + " phs:" + phoneNumbers;
+  }
+
+  public long getId() {
+    return id;
+  }
+
+  public void setId(long id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public List<EcPhone> getPhoneNumbers() {
+    return phoneNumbers;
+  }
+
+  public void setPhoneNumbers(List<EcPhone> phoneNumbers) {
+    this.phoneNumbers = phoneNumbers;
+  }
+
+  public long getVersion() {
+    return version;
+  }
+
+  public void setVersion(long version) {
+    this.version = version;
+  }
+}

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

@@ -0,0 +1,68 @@
+package org.tests.model.elementcollection;
+
+import javax.persistence.CollectionTable;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.Version;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+
+@Entity
+public class EcbmPerson {
+
+  @Id
+  long id;
+
+  String name;
+
+  @ElementCollection
+  @CollectionTable(joinColumns = @JoinColumn(name = "person_id"))
+  Map<String,EcPhone> phoneNumbers = new LinkedHashMap<>();
+
+  @Version
+  long version;
+
+  public EcbmPerson(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public String toString() {
+    return "person id:" + id + " name:" + name + " phs:" + phoneNumbers;
+  }
+
+  public long getId() {
+    return id;
+  }
+
+  public void setId(long id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public Map<String,EcPhone> getPhoneNumbers() {
+    return phoneNumbers;
+  }
+
+  public void setPhoneNumbers(Map<String,EcPhone> phoneNumbers) {
+    this.phoneNumbers = phoneNumbers;
+  }
+
+  public long getVersion() {
+    return version;
+  }
+
+  public void setVersion(long version) {
+    this.version = version;
+  }
+}

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

@@ -2,6 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.Ebean;
+import org.ebeantest.LoggedSqlCollector;
 import org.junit.Test;
 
 import java.util.List;
@@ -13,17 +14,25 @@ public class TestElementCollectionBasic extends BaseTestCase {
   @Test
   public void test() {
 
+    LoggedSqlCollector.start();
+
     EcPerson person = new EcPerson("Fiona021");
     person.getPhoneNumbers().add("021 1234");
     person.getPhoneNumbers().add("021 4321");
     Ebean.save(person);
 
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("insert into ec_person");
+    assertThat(sql.get(1)).contains("insert into ec_person_phone");
 
     EcPerson person1 = new EcPerson("Fiona09");
     person1.getPhoneNumbers().add("09 1234");
     person1.getPhoneNumbers().add("09 4321");
     Ebean.save(person1);
 
+    LoggedSqlCollector.current();
+
     List<EcPerson> found =
       Ebean.find(EcPerson.class).where()
         .startsWith("name", "Fiona0")
@@ -37,6 +46,10 @@ public class TestElementCollectionBasic extends BaseTestCase {
     assertThat(phoneNumbers0).containsExactly("021 1234", "021 4321");
     assertThat(phoneNumbers1).containsExactly("09 1234", "09 4321");
 
+    sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(trimSql(sql.get(0))).contains("select t0.id, t0.name, t0.version from ec_person t0 where");
+    assertThat(trimSql(sql.get(1))).contains("select t0.owner_id, t0.phone from ec_person_phone t0 where");
 
     List<EcPerson> found2 =
       Ebean.find(EcPerson.class)
@@ -47,11 +60,83 @@ public class TestElementCollectionBasic extends BaseTestCase {
         .findList();
 
     assertThat(found2).hasSize(2);
+
+    sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    assertThat(trimSql(sql.get(0))).contains("select t0.id, t0.name, t0.version, t1.phone from ec_person t0 left join ec_person_phone t1");
+
     EcPerson foundFirst = found2.get(0);
+
+    jsonToFrom(foundFirst);
+    updateBasic(foundFirst);
+
+    LoggedSqlCollector.stop();
+  }
+
+  private void updateBasic(EcPerson bean) {
+
+    bean.setName("Fiona021-mod-0");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    assertThat(sql.get(0)).contains("update ec_person");
+
+    updateBoth(bean);
+  }
+
+  private void updateBoth(EcPerson bean) {
+
+    bean.setName("Fiona021-mod-both");
+    bean.getPhoneNumbers().add("01-22123");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(3);
+    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 (?,?)");
+
+    updateNothing(bean);
+  }
+
+  private void updateNothing(EcPerson bean) {
+
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(0);
+
+    updateOnlyCollection(bean);
+  }
+
+  private void updateOnlyCollection(EcPerson bean) {
+
+    bean.getPhoneNumbers().add("01-4321");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    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 (?,?)");
+
+    delete(bean);
+  }
+
+  private void delete(EcPerson bean) {
+
+    Ebean.delete(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("delete from ec_person_phone where owner_id = ?");
+    assertThat(sql.get(1)).contains("delete from ec_person where id=? and version=?");
+  }
+
+  private void jsonToFrom(EcPerson foundFirst) {
+
     String asJson = Ebean.json().toJson(foundFirst);
-
     EcPerson fromJson = Ebean.json().toBean(EcPerson.class, asJson);
-
     assertThat(fromJson.getPhoneNumbers()).containsAll(foundFirst.getPhoneNumbers());
   }
 }

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

@@ -2,6 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.Ebean;
+import org.ebeantest.LoggedSqlCollector;
 import org.junit.Test;
 
 import java.util.List;
@@ -14,26 +15,34 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
   @Test
   public void test() {
 
+    LoggedSqlCollector.start();
+
     EcmPerson person = new EcmPerson("Fiona021");
-    person.getPhoneNumbers().put("home","021 1234");
-    person.getPhoneNumbers().put("work","021 4321");
+    person.getPhoneNumbers().put("home", "021 1234");
+    person.getPhoneNumbers().put("work", "021 4321");
     Ebean.save(person);
 
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("insert into ecm_person");
+    assertThat(sql.get(1)).contains("insert into ecm_person_phone");
 
     EcmPerson person1 = new EcmPerson("Fiona09");
-    person1.getPhoneNumbers().put("home","09 1234");
-    person1.getPhoneNumbers().put("work","09 4321");
-    person1.getPhoneNumbers().put("mob","09 9876");
+    person1.getPhoneNumbers().put("home", "09 1234");
+    person1.getPhoneNumbers().put("work", "09 4321");
+    person1.getPhoneNumbers().put("mob", "09 9876");
     Ebean.save(person1);
 
+    LoggedSqlCollector.current();
+
     List<EcmPerson> found =
       Ebean.find(EcmPerson.class).where()
         .startsWith("name", "Fiona0")
         .order().asc("id")
         .findList();
 
-    Map<String,String> phoneNumbers0 = found.get(0).getPhoneNumbers();
-    Map<String,String> phoneNumbers1 = found.get(1).getPhoneNumbers();
+    Map<String, String> phoneNumbers0 = found.get(0).getPhoneNumbers();
+    Map<String, String> phoneNumbers1 = found.get(1).getPhoneNumbers();
     phoneNumbers0.size();
 
     assertThat(phoneNumbers0).containsValues("021 1234", "021 4321");
@@ -41,6 +50,10 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
     assertThat(phoneNumbers1).containsValues("09 1234", "09 4321", "09 9876");
     assertThat(phoneNumbers1.get("mob")).isEqualTo("09 9876");
 
+    sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(trimSql(sql.get(0))).contains("select t0.id, t0.name, t0.version from ecm_person t0 where");
+    assertThat(trimSql(sql.get(1))).contains("select t0.ecm_person_id, t0.type, t0.number from ecm_person_phone_numbers t0 where");
 
     List<EcmPerson> found2 =
       Ebean.find(EcmPerson.class)
@@ -51,13 +64,83 @@ public class TestElementCollectionBasicMap extends BaseTestCase {
         .findList();
 
     assertThat(found2).hasSize(2);
-    EcmPerson foundFirst = found2.get(0);
-    String asJson = Ebean.json().toJson(foundFirst);
 
+    sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    assertThat(trimSql(sql.get(0))).contains("select t0.id, t0.name, t0.version, t1.type, t1.number from ecm_person t0 left join ecm_person_phone_numbers t1");
+
+    EcmPerson foundFirst = found2.get(0);
+    jsonToFrom(foundFirst);
+    updateBasic(foundFirst);
+
+    LoggedSqlCollector.stop();
+  }
+
+  private void updateBasic(EcmPerson bean) {
+
+    bean.setName("Fiona021-mod-0");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    assertThat(sql.get(0)).contains("update ecm_person");
+
+    updateBoth(bean);
+  }
+
+  private void updateBoth(EcmPerson bean) {
+
+    bean.setName("Fiona021-mod-both");
+    bean.getPhoneNumbers().put("one", "01-22123");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(3);
+    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 (?,?,?)");
+
+    updateNothing(bean);
+  }
+
+  private void updateNothing(EcmPerson bean) {
+
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(0);
+
+    updateOnlyCollection(bean);
+  }
+
+  private void updateOnlyCollection(EcmPerson bean) {
+
+    bean.getPhoneNumbers().put("two", "01-4321");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    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 (?,?,?)");
+
+    delete(bean);
+  }
+
+  private void delete(EcmPerson bean) {
+
+    Ebean.delete(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("delete from ecm_person_phone_numbers where ecm_person_id = ?");
+    assertThat(sql.get(1)).contains("delete from ecm_person where id=? and version=?");
+  }
+
+  private void jsonToFrom(EcmPerson foundFirst) {
+    String asJson = Ebean.json().toJson(foundFirst);
     EcmPerson fromJson = Ebean.json().toBean(EcmPerson.class, asJson);
 
     assertThat(fromJson.getPhoneNumbers()).containsValues("021 1234", "021 4321");
     assertThat(fromJson.getPhoneNumbers().get("home")).isEqualTo("021 1234");
-
   }
 }

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

@@ -2,6 +2,7 @@ package org.tests.model.elementcollection;
 
 import io.ebean.BaseTestCase;
 import io.ebean.Ebean;
+import org.ebeantest.LoggedSqlCollector;
 import org.junit.Test;
 
 import java.util.List;
@@ -14,11 +15,17 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
   @Test
   public void test() {
 
+    LoggedSqlCollector.start();
+
     EcsPerson person = new EcsPerson("Fiona021");
     person.getPhoneNumbers().add("021 1234");
     person.getPhoneNumbers().add("021 4321");
     Ebean.save(person);
 
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("insert into ecs_person");
+    assertThat(sql.get(1)).contains("insert into ecs_person_phone");
 
     EcsPerson person1 = new EcsPerson("Fiona09");
     person1.getPhoneNumbers().add("09 1234");
@@ -26,6 +33,8 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
     person1.getPhoneNumbers().add("09 9876");
     Ebean.save(person1);
 
+    LoggedSqlCollector.current();
+
     List<EcsPerson> found =
       Ebean.find(EcsPerson.class).where()
         .startsWith("name", "Fiona0")
@@ -39,6 +48,10 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
     assertThat(phoneNumbers0).containsExactly("021 1234", "021 4321");
     assertThat(phoneNumbers1).containsExactly("09 1234", "09 4321", "09 9876");
 
+    sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(trimSql(sql.get(0))).contains("select t0.id, t0.name, t0.version from ecs_person t0 where");
+    assertThat(trimSql(sql.get(1))).contains("select t0.ecs_person_id, t0.phone from ecs_person_phone t0 where");
 
     List<EcsPerson> found2 =
       Ebean.find(EcsPerson.class)
@@ -49,11 +62,82 @@ public class TestElementCollectionBasicSet extends BaseTestCase {
         .findList();
 
     assertThat(found2).hasSize(2);
+
+    sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    assertThat(trimSql(sql.get(0))).contains("select t0.id, t0.name, t0.version, t1.phone from ecs_person t0 left join ecs_person_phone t1");
+
     EcsPerson foundFirst = found2.get(0);
+    jsonToFrom(foundFirst);
+
+    updateBasic(foundFirst);
+
+    LoggedSqlCollector.stop();
+  }
+
+  private void updateBasic(EcsPerson bean) {
+
+    bean.setName("Fiona021-mod-0");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    assertThat(sql.get(0)).contains("update ecs_person");
+
+    updateBoth(bean);
+  }
+
+  private void updateBoth(EcsPerson bean) {
+
+    bean.setName("Fiona021-mod-both");
+    bean.getPhoneNumbers().add("01-22123");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(3);
+    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 (?,?)");
+
+    updateNothing(bean);
+  }
+
+  private void updateNothing(EcsPerson bean) {
+
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(0);
+
+    updateOnlyCollection(bean);
+  }
+
+  private void updateOnlyCollection(EcsPerson bean) {
+
+    bean.getPhoneNumbers().add("01-4321");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    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 (?,?)");
+
+    delete(bean);
+  }
+
+  private void delete(EcsPerson bean) {
+
+    Ebean.delete(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("delete from ecs_person_phone where ecs_person_id = ?");
+    assertThat(sql.get(1)).contains("delete from ecs_person where id=? and version=?");
+  }
+
+  private void jsonToFrom(EcsPerson foundFirst) {
     String asJson = Ebean.json().toJson(foundFirst);
-
     EcsPerson fromJson = Ebean.json().toBean(EcsPerson.class, asJson);
-
     assertThat(fromJson.getPhoneNumbers()).containsAll(foundFirst.getPhoneNumbers());
   }
 }

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

@@ -0,0 +1,148 @@
+package org.tests.model.elementcollection;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestElementCollectionEmbeddedList extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    LoggedSqlCollector.start();
+
+    EcblPerson person = new EcblPerson("Fiona64021");
+    person.getPhoneNumbers().add(new EcPhone("64", "021","1234"));
+    person.getPhoneNumbers().add(new EcPhone("64","021","4321"));
+    Ebean.save(person);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("insert into ecbl_person");
+    assertThat(sql.get(1)).contains("insert into ecbl_person_phone_numbers");
+
+    EcblPerson person1 = new EcblPerson("Fiona6409");
+    person1.getPhoneNumbers().add(new EcPhone("61","09","1234"));
+    person1.getPhoneNumbers().add(new EcPhone("64","09","4321"));
+    Ebean.save(person1);
+
+    LoggedSqlCollector.current();
+
+    List<EcblPerson> found =
+      Ebean.find(EcblPerson.class).where()
+        .startsWith("name", "Fiona640")
+        .order().asc("id")
+        .findList();
+
+    List<EcPhone> phoneNumbers0 = found.get(0).getPhoneNumbers();
+    List<EcPhone> phoneNumbers1 = found.get(1).getPhoneNumbers();
+    phoneNumbers0.size();
+
+    assertThat(phoneNumbers0.toString()).contains("64-021-1234", "64-021-4321");
+    assertThat(phoneNumbers1.toString()).contains("61-09-1234", "64-09-4321");
+
+    sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(trimSql(sql.get(0))).contains("select t0.id, t0.name, t0.version from ecbl_person");
+    assertThat(trimSql(sql.get(1))).contains("select t0.person_id, t0.country_code, t0.area, t0.number from ecbl_person_phone_numbers");
+
+    List<EcblPerson> found2 =
+      Ebean.find(EcblPerson.class)
+        .fetch("phoneNumbers")
+        .where()
+        .startsWith("name", "Fiona640")
+        .order().asc("id")
+        .findList();
+
+    assertThat(found2).hasSize(2);
+
+    sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    String trimmedSql = trimSql(sql.get(0));
+    assertThat(trimmedSql).contains("select t0.id, t0.name, t0.version, t1.country_code, t1.area, t1.number from ecbl_person t0 left join ecbl_person_phone_numbers t1");
+
+
+    EcblPerson foundFirst = found2.get(0);
+    jsonToFrom(foundFirst);
+
+    updateBasic(foundFirst);
+
+    LoggedSqlCollector.stop();
+  }
+
+  private void updateBasic(EcblPerson bean) {
+
+    bean.setName("Fiona64-mod-0");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    assertThat(sql.get(0)).contains("update ecbl_person");
+
+    updateBoth(bean);
+  }
+
+  private void updateBoth(EcblPerson bean) {
+
+    bean.setName("Fiona64-mod-both");
+    bean.getPhoneNumbers().add(new EcPhone("01", "234", "123"));
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(3);
+    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 (?,?,?,?)");
+
+    updateNothing(bean);
+  }
+
+  private void updateNothing(EcblPerson bean) {
+
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(0);
+
+    updateOnlyCollection(bean);
+  }
+
+  private void updateOnlyCollection(EcblPerson bean) {
+
+    bean.getPhoneNumbers().add(new EcPhone("01", "12", "4321"));
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    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 (?,?,?,?)");
+
+    delete(bean);
+  }
+
+  private void delete(EcblPerson bean) {
+
+    Ebean.delete(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("delete from ecbl_person_phone_numbers where person_id = ?");
+    assertThat(sql.get(1)).contains("delete from ecbl_person where id=? and version=?");
+  }
+
+  private void jsonToFrom(EcblPerson foundFirst) {
+
+    String asJson = Ebean.json().toJson(foundFirst);
+
+    EcblPerson fromJson = Ebean.json().toBean(EcblPerson.class, asJson);
+
+    String phoneString = fromJson.getPhoneNumbers().toString();
+    assertThat(phoneString).contains("64-021-1234");
+    assertThat(phoneString).contains("64-021-4321");
+  }
+}

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

@@ -0,0 +1,141 @@
+package org.tests.model.elementcollection;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestElementCollectionEmbeddedMap extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    LoggedSqlCollector.start();
+
+    EcbmPerson person = new EcbmPerson("Fiona64021");
+    person.getPhoneNumbers().put("home", new EcPhone("64", "021","1234"));
+    person.getPhoneNumbers().put("work", new EcPhone("64","021","4321"));
+    Ebean.save(person);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("insert into ecbm_person");
+    assertThat(sql.get(1)).contains("insert into ecbm_person_phone_numbers");
+
+    EcbmPerson person1 = new EcbmPerson("Fiona6409");
+    person1.getPhoneNumbers().put("home",new EcPhone("64","09","1234"));
+    person1.getPhoneNumbers().put("mob",new EcPhone("61","09","4321"));
+
+    Ebean.save(person1);
+
+    LoggedSqlCollector.current();
+
+    List<EcbmPerson> found =
+      Ebean.find(EcbmPerson.class).where()
+        .startsWith("name", "Fiona640")
+        .order().asc("id")
+        .findList();
+
+    Map<String,EcPhone> phoneNumbers0 = found.get(0).getPhoneNumbers();
+    Map<String,EcPhone> phoneNumbers1 = found.get(1).getPhoneNumbers();
+    phoneNumbers0.size();
+
+    assertThat(phoneNumbers0.toString()).contains("64-021-1234", "64-021-4321");
+    assertThat(phoneNumbers1.toString()).contains("64-09-1234", "61-09-4321");
+
+    List<EcbmPerson> found2 =
+      Ebean.find(EcbmPerson.class)
+        .fetch("phoneNumbers")
+        .where()
+        .startsWith("name", "Fiona640")
+        .order().asc("id")
+        .findList();
+
+    assertThat(found2).hasSize(2);
+    EcbmPerson foundFirst = found2.get(0);
+
+    LoggedSqlCollector.current();
+
+    jsonToFrom(foundFirst);
+
+    updateBasic(foundFirst);
+
+    LoggedSqlCollector.stop();
+  }
+
+  private void updateBasic(EcbmPerson bean) {
+
+    bean.setName("Fiona64-mod-0");
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(1);
+    assertThat(sql.get(0)).contains("update ecbm_person");
+
+    updateBoth(bean);
+  }
+
+  private void updateBoth(EcbmPerson bean) {
+
+    bean.setName("Fiona64-mod-both");
+    bean.getPhoneNumbers().put("more", new EcPhone("01", "234", "123"));
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(3);
+    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,key,country_code,area,number)");
+
+    updateNothing(bean);
+  }
+
+  private void updateNothing(EcbmPerson bean) {
+
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(0);
+
+    updateOnlyCollection(bean);
+  }
+
+  private void updateOnlyCollection(EcbmPerson bean) {
+
+    bean.getPhoneNumbers().put("other", new EcPhone("01", "12", "4321"));
+    Ebean.save(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    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,key,country_code,area,number) values (?,?,?,?,?)");
+
+    delete(bean);
+  }
+
+  private void delete(EcbmPerson bean) {
+
+    Ebean.delete(bean);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("delete from ecbm_person_phone_numbers where person_id = ?");
+    assertThat(sql.get(1)).contains("delete from ecbm_person where id=? and version=?");
+  }
+
+  private void jsonToFrom(EcbmPerson foundFirst) {
+    String asJson = Ebean.json().toJson(foundFirst);
+
+    EcbmPerson fromJson = Ebean.json().toBean(EcbmPerson.class, asJson);
+
+    String phoneString = fromJson.getPhoneNumbers().toString();
+    assertThat(phoneString).contains("64-021-1234");
+    assertThat(phoneString).contains("64-021-4321");
+  }
+
+}