Refactor move into ebean-core directory (#2066)

ebean-core/src/test/java/org/Main.java

@@ -0,0 +1,29 @@
+package org;
+
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class Main {
+
+  public static void main(String[] args) throws SQLException {
+
+
+    EbeanServer ms = Ebean.getServer("ms");
+    DataSource dataSource = ms.getPluginApi().getDataSource();
+
+    Connection connection = dataSource.getConnection();
+    PreparedStatement statement = connection.prepareStatement("select next VALUE for j2_seq");
+    ResultSet resultSet = statement.executeQuery();
+    if (resultSet.next()) {
+      Object val = resultSet.getObject(1);
+      System.out.println(""+val);
+    }
+    connection.close();
+  }
+}

ebean-core/src/test/java/org/MainMemoryLeak.java

@@ -0,0 +1,75 @@
+package org;
+
+import io.ebean.EbeanServer;
+import io.ebean.EbeanServerFactory;
+import io.ebean.Transaction;
+import io.ebean.annotation.Cache;
+import io.ebean.config.PlatformNoGeneratedKeysTest;
+import io.ebean.config.ServerConfig;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Lob;
+import java.util.Arrays;
+
+/**
+ *
+ * Test preparation:
+ *
+ * - Enable file based H2 in ebean.properties (line `datasource.h2.databaseUrl=jdbc:h2:file:~/tests`)
+ * - disable logging of io.ebean.SUM/TXN/SQL in logback-test.xml
+ * - remove existing database in ~/tests (do that before each run)
+ * - run this class with `-Xmx1g` jvm argument
+ * - an OOM in iteration ~45000 will occur (45k * 10k chars = 45k * 20k bytes = 900MB)
+ *
+ * remove the line `@Cache(enableQueryCache=true)` - and it will run forever (until disk is full)
+ */
+public class MainMemoryLeak {
+
+  @Cache(enableQueryCache=true)
+  @Entity
+  public static class ECachedBean {
+    @Id
+    private Long id;
+
+    @Lob
+    private String description;
+  }
+
+  public static void main(String[] args) {
+
+    PlatformNoGeneratedKeysTest.OtherH2Platform platform = new PlatformNoGeneratedKeysTest.OtherH2Platform();
+
+    ServerConfig config = new ServerConfig();
+
+    config.setDatabasePlatform(platform);
+    config.addClass(ECachedBean.class);
+    config.loadFromProperties();
+
+    EbeanServer server = EbeanServerFactory.create(config);
+
+    // create a string with 10k chars
+    char[] c = new char[10_000];
+    Arrays.fill(c, 'x');
+
+    try (Transaction txn = server.beginTransaction()) {
+      for (int i = 0; i < 500000; i++) {
+
+        if (i % 1000 == 0) {
+          long mem = Runtime.getRuntime().freeMemory() / 1024 / 1024;
+          if (mem > 1024) {
+            throw new IllegalStateException("-Xmx1g JVM argument expected");
+          }
+          System.out.println("Iteration: " + i + " Free mem: " + mem + " MB");
+        }
+
+        ECachedBean a = new ECachedBean();
+        a.description = new String(c);
+        server.save(a);
+      }
+      System.out.println("Success, no mem limit detected");
+      txn.commit();
+    }
+
+  }
+}

ebean-core/src/test/java/org/ebeantest/LoggedSqlCollector.java

@@ -0,0 +1,36 @@
+package org.ebeantest;
+
+import io.ebeantest.LoggedSql;
+
+import java.util.List;
+
+/**
+ * Helper that can collect the SQL that is logged via SLF4J.
+ * <p>
+ * Used {@link #start()} and {@link #stop()} to collect the logged messages that contain the
+ * executed SQL statements.
+ * <p>
+ * Internally this uses a Logback Appender to collect messages for org.avaje.ebean.SQL.
+ */
+public class LoggedSqlCollector {
+
+  /**
+   * Start collection of the logged SQL statements.
+   */
+  public static List<String> start() {
+    return LoggedSql.start();
+  }
+
+  /**
+   * Stop collection of the logged SQL statements return the list of captured messages that contain
+   * the SQL.
+   */
+  public static List<String> stop() {
+    return LoggedSql.stop();
+  }
+
+  public static List<String> current() {
+    return LoggedSql.collect();
+  }
+
+}

ebean-core/src/test/java/org/multitenant/partition/CurrentTenant.java

@@ -0,0 +1,14 @@
+package org.multitenant.partition;
+
+import io.ebean.config.CurrentTenantProvider;
+
+class CurrentTenant implements CurrentTenantProvider {
+
+  /**
+   * Return the current tenantId from the user context.
+   */
+  @Override
+  public String currentId() {
+    return UserContext.get().getTenantId();
+  }
+}

ebean-core/src/test/java/org/multitenant/partition/MtBaseDomain.java

@@ -0,0 +1,57 @@
+package org.multitenant.partition;
+
+import io.ebean.annotation.WhenCreated;
+import io.ebean.annotation.WhenModified;
+
+import javax.persistence.Id;
+import javax.persistence.MappedSuperclass;
+import javax.persistence.Version;
+import java.time.Instant;
+
+@MappedSuperclass
+public abstract class MtBaseDomain {
+
+  @Id
+  long id;
+
+  @WhenModified
+  Instant whenModified;
+
+  @WhenCreated
+  Instant whenCreated;
+
+  @Version
+  long version;
+
+  public long getId() {
+    return id;
+  }
+
+  public void setId(long id) {
+    this.id = id;
+  }
+
+  public Instant getWhenModified() {
+    return whenModified;
+  }
+
+  public void setWhenModified(Instant whenModified) {
+    this.whenModified = whenModified;
+  }
+
+  public Instant getWhenCreated() {
+    return whenCreated;
+  }
+
+  public void setWhenCreated(Instant whenCreated) {
+    this.whenCreated = whenCreated;
+  }
+
+  public long getVersion() {
+    return version;
+  }
+
+  public void setVersion(long version) {
+    this.version = version;
+  }
+}

ebean-core/src/test/java/org/multitenant/partition/MtContent.java

@@ -0,0 +1,32 @@
+package org.multitenant.partition;
+
+import javax.persistence.Entity;
+
+@Entity
+public class MtContent extends MtTenantAware {
+
+  String title;
+
+  String body;
+
+  public MtContent(String title) {
+    this.title = title;
+  }
+
+  public String getTitle() {
+    return title;
+  }
+
+  public void setTitle(String title) {
+    this.title = title;
+  }
+
+  public String getBody() {
+    return body;
+  }
+
+  public void setBody(String body) {
+    this.body = body;
+  }
+
+}

ebean-core/src/test/java/org/multitenant/partition/MtTenant.java

@@ -0,0 +1,67 @@
+package org.multitenant.partition;
+
+import io.ebean.annotation.Length;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Version;
+
+@Entity
+public class MtTenant {
+
+  @Id
+  final String id;
+
+  @Length(50)
+  String name;
+
+  @Length(50)
+  String email;
+
+  String notes;
+
+  @Version
+  long version;
+
+  public MtTenant(String id, String name, String email) {
+    this.id = id;
+    this.name = name;
+    this.email = email;
+  }
+
+  public String getId() {
+    return id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getEmail() {
+    return email;
+  }
+
+  public void setEmail(String email) {
+    this.email = email;
+  }
+
+  public String getNotes() {
+    return notes;
+  }
+
+  public void setNotes(String notes) {
+    this.notes = notes;
+  }
+
+  public long getVersion() {
+    return version;
+  }
+
+  public void setVersion(long version) {
+    this.version = version;
+  }
+}

ebean-core/src/test/java/org/multitenant/partition/MtTenantAware.java

@@ -0,0 +1,22 @@
+package org.multitenant.partition;
+
+import io.ebean.annotation.TenantId;
+
+import javax.persistence.ManyToOne;
+import javax.persistence.MappedSuperclass;
+
+@MappedSuperclass
+public abstract class MtTenantAware extends MtBaseDomain {
+
+  @TenantId
+  @ManyToOne(optional = false)
+  MtTenant tenant;
+
+  public MtTenant getTenant() {
+    return tenant;
+  }
+
+  public void setTenant(MtTenant tenant) {
+    this.tenant = tenant;
+  }
+}

ebean-core/src/test/java/org/multitenant/partition/MultiTenantPartitionTest.java

@@ -0,0 +1,125 @@
+package org.multitenant.partition;
+
+import io.ebean.BaseTestCase;
+import io.ebean.EbeanServer;
+import io.ebean.EbeanServerFactory;
+import io.ebean.config.ServerConfig;
+import io.ebean.config.TenantMode;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class MultiTenantPartitionTest extends BaseTestCase {
+
+  private static String[] names = {"Ace", "Base", "Case", "Dae", "Eva"};
+
+  static List<MtTenant> tenants() {
+    List<MtTenant> tenants = new ArrayList<>();
+    for (int i = 0; i < 5; i++) {
+      tenants.add(new MtTenant("ten_"+i, names[i], names[i]+"@foo.com".toLowerCase()));
+    }
+    return tenants;
+  }
+
+  private static EbeanServer server = init();
+
+  static {
+    server.saveAll(tenants());
+  }
+
+  @Test
+  public void start() {
+
+    UserContext.set("rob", "ten_1");
+
+    LoggedSqlCollector.start();
+    MtContent content = new MtContent("first title");
+    server.save(content);
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertSql(sql.get(0)).contains("insert into mt_content (title, body, when_modified, when_created, version, tenant_id) values (?,?,?,?,?,?)");
+
+    content.setBody("some body");
+    server.save(content);
+
+    sql = LoggedSqlCollector.current();
+    assertSql(sql.get(0)).contains("update mt_content set body=?, when_modified=?, version=? where id=? and tenant_id=? and version=?");
+
+    server.delete(content);
+
+    sql = LoggedSqlCollector.current();
+    assertSql(sql.get(0)).contains("delete from mt_content where id=? and tenant_id=? and version=?");
+
+    LoggedSqlCollector.stop();
+  }
+
+  @Test
+  public void deleteById() {
+
+    UserContext.set("fred", "ten_2");
+
+    MtContent content = new MtContent("first title");
+    server.save(content);
+
+    LoggedSqlCollector.start();
+    int rows = server.delete(MtContent.class, content.getId());
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains("delete from mt_content where id=? and tenant_id=?");
+    assertThat(rows).isEqualTo(1);
+
+    rows = server.delete(MtContent.class, 99999);
+    assertThat(rows).isEqualTo(0);
+  }
+
+  @Test
+  public void deleteByIds() {
+
+    UserContext.set("fred", "ten_2");
+
+    MtContent a = newContent("title a");
+    MtContent b = newContent("title b");
+
+
+    List<Long> ids = Arrays.asList(a.getId(), b.getId(), 99998L);
+
+    LoggedSqlCollector.start();
+    int rows = server.deleteAll(MtContent.class, ids);
+    assertThat(rows).isEqualTo(2);
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains("delete from mt_content where id=? and tenant_id=?");
+  }
+
+  private MtContent newContent(String title) {
+    MtContent content = new MtContent(title);
+    server.save(content);
+    return content;
+  }
+
+
+  private static EbeanServer init() {
+
+    ServerConfig config = new ServerConfig();
+
+    config.setName("h2multitenant");
+    config.loadFromProperties();
+    config.setDdlGenerate(true);
+    config.setDdlRun(true);
+    config.setDdlExtra(false);
+    config.setRegister(false);
+    config.setDefaultServer(false);
+    config.setCurrentTenantProvider(new CurrentTenant());
+    config.setTenantMode(TenantMode.PARTITION);
+
+    config.getClasses().add(MtTenant.class);
+    config.getClasses().add(MtContent.class);
+
+    return EbeanServerFactory.create(config);
+  }
+}

ebean-core/src/test/java/org/multitenant/partition/UserContext.java

@@ -0,0 +1,46 @@
+package org.multitenant.partition;
+
+public final class UserContext {
+
+  private static final UserContextThreadLocal local = new UserContextThreadLocal();
+
+  private String userId;
+  private String tenantId;
+
+  private UserContext(String userId, String tenantId) {
+    this.userId = userId;
+    this.tenantId = tenantId;
+  }
+
+  private UserContext() {
+  }
+
+  public String getUserId() {
+    return userId;
+  }
+
+  public String getTenantId() {
+    return tenantId;
+  }
+
+  public static UserContext get() {
+    return local.get();
+  }
+
+  public static void reset() {
+    local.remove();
+  }
+
+  public static void set(String userId, String tenantId) {
+    local.set(new UserContext(userId, tenantId));
+  }
+
+
+  private static class UserContextThreadLocal extends ThreadLocal<UserContext> {
+
+    @Override
+    protected UserContext initialValue() {
+      return new UserContext();
+    }
+  }
+}

ebean-core/src/test/java/org/tests/aggregateformula/IAFBaseSegment.java

@@ -0,0 +1,18 @@
+package org.tests.aggregateformula;
+
+import javax.persistence.DiscriminatorColumn;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Inheritance;
+import javax.persistence.Table;
+
+@Entity
+@Inheritance
+@Table(name = "iaf_segment")
+@DiscriminatorColumn(name = "ptype")
+public class IAFBaseSegment {
+
+  @Id
+  private Long id;
+
+}

ebean-core/src/test/java/org/tests/aggregateformula/IAFPartialSegment.java

@@ -0,0 +1,30 @@
+package org.tests.aggregateformula;
+
+import javax.persistence.DiscriminatorValue;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.ManyToOne;
+
+@Entity
+@Inheritance
+@DiscriminatorValue("target")
+public class IAFPartialSegment extends IAFBaseSegment {
+
+  private final long segmentIdZat;
+
+  @ManyToOne(optional = false)
+  private final IAFSegmentStatus status;
+
+  public IAFPartialSegment(long segmentIdZat, IAFSegmentStatus status) {
+    this.segmentIdZat = segmentIdZat;
+    this.status = status;
+  }
+
+  public long getSegmentIdZat() {
+    return segmentIdZat;
+  }
+
+  public IAFSegmentStatus getStatus() {
+    return status;
+  }
+}

ebean-core/src/test/java/org/tests/aggregateformula/IAFSegmentStatus.java

@@ -0,0 +1,35 @@
+package org.tests.aggregateformula;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "iaf_segment_status")
+public class IAFSegmentStatus {
+
+  @Id
+  private long id;
+
+  private String name;
+
+  public IAFSegmentStatus(String name) {
+    this.name = name;
+  }
+
+  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;
+  }
+}

ebean-core/src/test/java/org/tests/aggregateformula/TestAggregateFormula.java

@@ -0,0 +1,212 @@
+package org.tests.aggregateformula;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.annotation.IgnorePlatform;
+import io.ebean.annotation.Platform;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNotNull;
+
+public class TestAggregateFormula extends BaseTestCase {
+
+  @IgnorePlatform({Platform.SQLSERVER, Platform.MYSQL, Platform.MARIADB, Platform.NUODB})
+  @Test
+  public void minDistinctOrderByNulls() {
+
+    ResetBasicData.reset();
+
+    LoggedSqlCollector.start();
+
+    List<Contact> contacts = Ebean.find(Contact.class)
+      .setDistinct(true)
+      .select("lastName, min(customer)")
+      .order("min(customer) asc nulls last")
+      .findList();
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains("select distinct t0.last_name, min(t0.customer_id) from contact t0 group by t0.last_name order by min(t0.customer_id) nulls last");
+
+    assertThat(contacts).isNotEmpty();
+
+    Contact contact = contacts.get(0);
+    assertThat(contact.getLastName()).isNotNull();
+    assertThat(contact.getCustomer()).isNotNull();
+    assertThat(contact.getCustomer().getId()).isNotNull();
+  }
+
+  @Test
+  public void minOnManyToOne() {
+
+    ResetBasicData.reset();
+
+    LoggedSqlCollector.start();
+
+    List<Contact> contacts = Ebean.find(Contact.class)
+      .select("lastName, min(customer)")
+      .findList();
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains("select t0.last_name, min(t0.customer_id) from contact t0 group by t0.last_name");
+
+    assertThat(contacts).isNotEmpty();
+
+    Contact contact = contacts.get(0);
+    assertThat(contact.getLastName()).isNotNull();
+    assertThat(contact.getCustomer()).isNotNull();
+    assertThat(contact.getCustomer().getId()).isNotNull();
+  }
+
+  @Test
+  public void minOnManyToOne_withFetchQuery() {
+
+    ResetBasicData.reset();
+
+    LoggedSqlCollector.start();
+
+    List<Contact> contacts = Ebean.find(Contact.class)
+      .select("lastName, min(customer)")
+      .fetchQuery("customer", "name, status")
+      .findList();
+
+    for (Contact contact : contacts) {
+      Customer customer = contact.getCustomer();
+      assertNotNull(customer.getName());
+      assertNotNull(customer.getStatus());
+    }
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertThat(sql).hasSize(2);
+    assertSql(sql.get(0)).contains("select t0.last_name, min(t0.customer_id) from contact t0 group by t0.last_name");
+    assertSql(sql.get(1)).contains("select t0.id, t0.name, t0.status from o_customer t0 where");
+
+    assertThat(contacts).isNotEmpty();
+
+    Contact contact = contacts.get(0);
+    assertThat(contact.getLastName()).isNotNull();
+    assertThat(contact.getCustomer()).isNotNull();
+    assertThat(contact.getCustomer().getId()).isNotNull();
+  }
+
+  @Test
+  public void minOnManyToOne_withFetchQueryWithJoin() {
+
+    ResetBasicData.reset();
+    LoggedSqlCollector.start();
+
+    List<Contact> contacts = Ebean.find(Contact.class)
+      .select("lastName, min(customer)")
+      .fetchQuery("customer", "name, status")
+      .fetch("customer.billingAddress", "city, country")
+      .findList();
+
+    for (Contact contact : contacts) {
+      Customer customer = contact.getCustomer();
+      assertNotNull(customer.getName());
+      assertNotNull(customer.getStatus());
+      final Address billingAddress = customer.getBillingAddress();
+      if (billingAddress != null) {
+        assertNotNull(billingAddress.getCountry());
+      }
+    }
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertThat(sql).hasSize(2);
+    assertSql(sql.get(0)).contains("select t0.last_name, min(t0.customer_id) from contact t0 group by t0.last_name");
+    assertSql(sql.get(1)).contains("select t0.id, t0.name, t0.status, t1.id, t1.city, t1.country_code from o_customer t0 left join o_address t1 on t1.id = t0.billing_address_id where");
+
+    assertThat(contacts).isNotEmpty();
+
+    Contact contact = contacts.get(0);
+    assertThat(contact.getLastName()).isNotNull();
+    assertThat(contact.getCustomer()).isNotNull();
+    assertThat(contact.getCustomer().getId()).isNotNull();
+  }
+
+  @Test
+  public void sum_withoutAlias() {
+
+    ResetBasicData.reset();
+
+    LoggedSqlCollector.start();
+
+    List<Order> orders = Ebean.find(Order.class)
+      .select("status, sum(id)")
+      .findList();
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains("select t0.status, sum(t0.id) from o_order t0 group by t0.status");
+
+    assertThat(orders).isNotEmpty();
+    for (Order order : orders) {
+      assertThat(order.getStatus()).isNotNull();
+      assertThat(order.getId()).isNotNull();
+    }
+  }
+
+  @Test
+  public void sum_withAlias() {
+
+    ResetBasicData.reset();
+
+    LoggedSqlCollector.start();
+
+    List<Order> orders = Ebean.find(Order.class)
+      .select("status, sum(id) as id")
+      .findList();
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains("select t0.status, sum(t0.id) id from o_order t0 group by t0.status");
+
+    assertThat(orders).isNotEmpty();
+    for (Order order : orders) {
+      assertThat(order.getStatus()).isNotNull();
+      assertThat(order.getId()).isNotNull();
+    }
+  }
+
+  @Test
+  public void sumWithManyToOne_min() {
+
+    ResetBasicData.reset();
+
+    LoggedSqlCollector.start();
+
+    List<Contact> contacts = Ebean.find(Contact.class)
+      .select("customer, min(cretime)")
+      .findList();
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains("select t0.customer_id, min(t0.cretime) from contact t0 group by t0.customer_id");
+
+    assertThat(contacts).isNotEmpty();
+  }
+
+  @Test
+  public void sumWithManyToOne_minMax() {
+
+    ResetBasicData.reset();
+
+    LoggedSqlCollector.start();
+
+    List<Contact> contacts = Ebean.find(Contact.class)
+      .select("customer, min(cretime), max(updtime)")
+      .findList();
+
+    List<String> sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains("select t0.customer_id, min(t0.cretime), max(t0.updtime) from contact t0 group by t0.customer_id");
+
+    assertThat(contacts).isNotEmpty();
+  }
+
+
+}

ebean-core/src/test/java/org/tests/aggregateformula/TestAggregateInheritFormula.java

@@ -0,0 +1,40 @@
+package org.tests.aggregateformula;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestAggregateInheritFormula extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    IAFSegmentStatus st0 = new IAFSegmentStatus("st0");
+    IAFSegmentStatus st1 = new IAFSegmentStatus("st1");
+
+    IAFPartialSegment p0 = new IAFPartialSegment(108, st0);
+    IAFPartialSegment p1 = new IAFPartialSegment(108, st1);
+    IAFPartialSegment p2 = new IAFPartialSegment(109, st0);
+
+    DB.saveAll(Arrays.asList(st0, st1, p0, p1));
+
+    LoggedSqlCollector.start();
+
+    List<IAFPartialSegment> segments =
+      DB.find(IAFPartialSegment.class)
+        .select("segmentIdZat, min(status)")
+        .where().eq("segmentIdZat", 108L)
+        .findList();
+
+    final List<String> sql = LoggedSqlCollector.stop();
+
+    assertThat(segments).hasSize(1);
+    assertSql(sql.get(0)).contains("select t0.segment_id_zat, min(t0.status_id) from iaf_segment t0 where t0.ptype = 'target' and t0.segment_id_zat = ? group by t0.segment_id_zat");
+  }
+}

ebean-core/src/test/java/org/tests/autofetch/AutofetchEmbeddedTest.java

@@ -0,0 +1,67 @@
+package org.tests.autofetch;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.embedded.EMain;
+import org.tests.model.embedded.Eembeddable;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class AutofetchEmbeddedTest extends BaseTestCase {
+
+  private final Logger logger = LoggerFactory.getLogger(AutofetchEmbeddedTest.class);
+
+  @Test
+  public void testEmbeddedBeanLazyLoadAndUpdate() {
+
+    EMain testBean = new EMain();
+    testBean.setName("test");
+    testBean.getEmbeddable().setDescription("test description");
+    Ebean.save(testBean);
+
+    EMain partialBean = Ebean.find(EMain.class).select("version").setId(testBean.getId()).findOne();
+
+    logger.info(" -- invoke lazy loading of embedded bean");
+    Eembeddable embeddable = partialBean.getEmbeddable();
+    embeddable.setDescription("modified description");
+
+    logger.info(" -- update bean");
+    Ebean.save(partialBean);
+
+  }
+
+  @Test
+  public void testEmbeddedBeanQueryTuning() {
+//    Ebean.getServer(null).getAutoTune().setProfiling(true);
+//    Ebean.getServer(null).getAutoTune().setQueryTuning(true);
+//    Ebean.getServer(null).getAutoTune().setProfilingBase(1);
+//
+//    EMain testBean = new EMain();
+//    testBean.setName("test");
+//    testBean.getEmbeddable().setDescription("test description");
+//    Ebean.save(testBean);
+//
+//    //This should not throw an exception
+//    for (int i = 0; i < 5; i++) {
+//      Ebean.beginTransaction();
+//      try {
+//        List<EMain> result = Ebean.find(EMain.class).setAutoTune(true).findList();
+//        for (EMain e : result) {
+//          e.getEmbeddable().setDescription("Test" + i);
+//          Ebean.save(e);
+//        }
+//        Ebean.commitTransaction();
+//      } finally {
+//        Ebean.endTransaction();
+//        logger.debug(Ebean.getServer(null).getAutoTune().collectProfiling());
+//      }
+//    }
+  }
+
+  @Test
+  public void testEmbeddedFetch() {
+    Ebean.find(EMain.class).fetch("embeddable").findList();
+  }
+}

ebean-core/src/test/java/org/tests/autofetch/MainAutoFetchExcludeLazyLobs.java

@@ -0,0 +1,32 @@
+package org.tests.autofetch;
+
+import io.ebean.Ebean;
+import org.tests.model.basic.EBasicClob;
+
+import java.util.List;
+
+public class MainAutoFetchExcludeLazyLobs {
+
+  public static void main(String[] args) {
+
+    EBasicClob a = new EBasicClob();
+    a.setName("name 1");
+    a.setTitle("a title");
+    a.setDescription("not that meaningful");
+
+    Ebean.save(a);
+
+    List<EBasicClob> list = Ebean.find(EBasicClob.class)
+      .setAutoTune(true)
+      .findList();
+
+    for (EBasicClob bean : list) {
+      bean.getName();
+      // although we read the description
+      // autofetch will not include it later
+      bean.getDescription();
+    }
+
+
+  }
+}

ebean-core/src/test/java/org/tests/autofetch/MainAutoQueryTune1.java

@@ -0,0 +1,34 @@
+package org.tests.autofetch;
+
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+public class MainAutoQueryTune1 {
+
+  public static void main(String[] args) {
+
+    ResetBasicData.reset();
+
+    MainAutoQueryTune1 me = new MainAutoQueryTune1();
+    me.tuneJoin();
+  }
+
+  private void tuneJoin() {
+    List<Order> list = Ebean.find(Order.class)
+      .setAutoTune(true)
+      .fetch("customer")
+      .where()
+      .eq("status", Order.Status.NEW)
+      .eq("customer.name", "Rob")
+      .order().asc("id")
+      .findList();
+
+    for (Order order : list) {
+      order.getId();
+      order.getOrderDate();
+    }
+  }
+}

ebean-core/src/test/java/org/tests/autofetch/TunedQueryInfoTest.java

@@ -0,0 +1,174 @@
+package org.tests.autofetch;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.EntityBeanIntercept;
+import io.ebean.cache.ServerCacheManager;
+import io.ebeaninternal.api.SpiQuery;
+import io.ebeaninternal.server.autotune.model.Origin;
+import io.ebeaninternal.server.autotune.service.TunedQueryInfo;
+import io.ebeaninternal.server.querydefn.OrmQueryDetail;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Set;
+
+public class TunedQueryInfoTest extends BaseTestCase {
+
+  EbeanServer server = Ebean.getServer(null);
+
+  private void init() {
+
+    ResetBasicData.reset();
+
+    ServerCacheManager serverCacheManager = Ebean.getServer(null).getServerCacheManager();
+    serverCacheManager.clearAll();
+  }
+
+  @Test
+  public void withSelectEmpty() {
+
+    init();
+
+    OrmQueryDetail tunedDetail = new OrmQueryDetail();
+    tunedDetail.select("");
+
+    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
+
+    Query<Order> query = server.find(Order.class).setId(1);
+
+    tunedInfo.tuneQuery((SpiQuery<?>) query);
+
+    Order order = query.findOne();
+    EntityBean eb = (EntityBean) order;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertTrue(ebi.isFullyLoadedBean());
+
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNull(loadedPropertyNames);
+
+    // invoke lazy loading
+    order.getCustomer();
+  }
+
+  @Test
+  public void withSelectSomethingThatDoesNotExist() {
+
+    init();
+
+    OrmQueryDetail tunedDetail = new OrmQueryDetail();
+    tunedDetail.select("somethingThatDoesNotExist");
+
+    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
+
+    Query<Order> query = server.find(Order.class).setId(1);
+
+    tunedInfo.tuneQuery((SpiQuery<?>) query);
+
+    LoggedSqlCollector.start();
+
+    Order order = query.findOne();
+    EntityBean eb = (EntityBean) order;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertFalse(ebi.isFullyLoadedBean());
+
+    // id and any ToMany relationships
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNotNull(loadedPropertyNames);
+
+    // invoke lazy loading
+    order.getCustomer();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(2, loggedSql.size());
+
+    Assert.assertTrue(trimSql(loggedSql.get(0), 1).contains("select t0.id, t0.id from o_order t0 where t0.id = ?"));
+    Assert.assertTrue(trimSql(loggedSql.get(1), 1).contains("select t0.id, t0.status,"));
+  }
+
+  private TunedQueryInfo createTunedQueryInfo(OrmQueryDetail tunedDetail) {
+    Origin origin = new Origin();
+    origin.setDetail(tunedDetail.asString());
+    return new TunedQueryInfo(origin);
+  }
+
+  @Test
+  public void withSelectSomeIncludeLazyLoaded() {
+
+    init();
+
+    OrmQueryDetail tunedDetail = new OrmQueryDetail();
+    tunedDetail.select("status, customer");
+
+    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
+
+    Query<Order> query = server.find(Order.class).setId(1);
+
+    tunedInfo.tuneQuery((SpiQuery<?>) query);
+
+    LoggedSqlCollector.start();
+
+    Order order = query.findOne();
+    EntityBean eb = (EntityBean) order;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertFalse(ebi.isFullyLoadedBean());
+
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNotNull(loadedPropertyNames);
+
+    Assert.assertTrue(loadedPropertyNames.contains("status"));
+    Assert.assertTrue(loadedPropertyNames.contains("customer"));
+
+    // no lazy loading expected here
+    order.getCustomer();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+  }
+
+  @Test
+  public void withSelectSome() {
+
+    init();
+
+    OrmQueryDetail tunedDetail = new OrmQueryDetail();
+    tunedDetail.select("status");
+
+    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
+
+    Query<Order> query = server.find(Order.class).setId(1);
+
+    tunedInfo.tuneQuery((SpiQuery<?>) query);
+
+    LoggedSqlCollector.start();
+
+    Order order = query.findOne();
+    EntityBean eb = (EntityBean) order;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertFalse(ebi.isFullyLoadedBean());
+
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNotNull(loadedPropertyNames);
+
+    Assert.assertTrue(loadedPropertyNames.contains("status"));
+    Assert.assertFalse(loadedPropertyNames.contains("customer"));
+
+    // no lazy loading expected here
+    order.getCustomer();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(2, loggedSql.size());
+  }
+
+}

ebean-core/src/test/java/org/tests/autofetch/TunedQueryWithNullFetchedBeanTest.java

@@ -0,0 +1,69 @@
+package org.tests.autofetch;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.EntityBeanIntercept;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+import java.util.Set;
+
+public class TunedQueryWithNullFetchedBeanTest extends BaseTestCase {
+
+  EbeanServer server = Ebean.getServer(null);
+
+  @Test
+  public void withFetchOfNullBeanJoin() {
+
+    ResetBasicData.reset();
+
+    Customer newCustomer = new Customer();
+    newCustomer.setName("TestFetchBillingAddress");
+    server.save(newCustomer);
+
+    Query<Customer> query = server.find(Customer.class)
+      .setId(newCustomer.getId())
+      .fetch("billingAddress", "id");
+
+    LoggedSqlCollector.start();
+
+    Customer customer = query.findOne();
+    EntityBean eb = (EntityBean) customer;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertTrue(ebi.isFullyLoadedBean());
+
+    // find the internal property index for "billingAddress"
+    String[] propNames = eb._ebean_getPropertyNames();
+    int pos = 0;
+    for (int i = 0; i < propNames.length; i++) {
+      if (propNames[i].equals("billingAddress")) {
+        pos = i;
+      }
+    }
+
+    // The billing address is loaded (but value null)
+    Assert.assertTrue(ebi.isLoadedProperty(pos));
+
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNull(loadedPropertyNames);
+
+    // no lazy loading expected here, value is null
+    Address billingAddress = customer.getBillingAddress();
+    Assert.assertNull(billingAddress);
+
+    // assert only one query executed
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+
+    Ebean.delete(newCustomer);
+  }
+}

ebean-core/src/test/java/org/tests/basic/MainDbBoolean.java

@@ -0,0 +1,152 @@
+package org.tests.basic;
+
+import io.ebean.EbeanServer;
+import io.ebean.EbeanServerFactory;
+import io.ebean.Query;
+import io.ebean.SqlRow;
+import io.ebean.config.ServerConfig;
+import io.ebean.config.dbplatform.postgres.PostgresPlatform;
+import io.ebean.datasource.DataSourceConfig;
+import org.junit.Assert;
+import org.tests.model.basic.TOne;
+import org.tests.model.basic.TSDetail;
+import org.tests.model.basic.TSMaster;
+
+import java.util.List;
+
+/**
+ * Used to run some tests manually on a specific Database type.
+ */
+public class MainDbBoolean {
+
+  public static void main(String[] args) {
+
+    MainDbBoolean me = new MainDbBoolean();
+
+    EbeanServer server = me.createEbeanServer();
+    me.simpleCheck(server);
+
+    EbeanServer oraServer = me.createOracleEbeanServer();
+    me.simpleCheck(oraServer);
+  }
+
+  /**
+   * Create a server for running small oracle specific tests manually.
+   * DDL generation etc.
+   */
+  private EbeanServer createOracleEbeanServer() {
+
+    ServerConfig c = new ServerConfig();
+    c.setName("ora");
+    c.setDdlExtra(false);
+
+    // requires oracle driver in class path
+    DataSourceConfig oraDb = new DataSourceConfig();
+    oraDb.setDriver("oracle.jdbc.driver.OracleDriver");
+    oraDb.setUsername("junk");
+    oraDb.setPassword("junk");
+    oraDb.setUrl("jdbc:oracle:thin:junk/junk@localhost:1521:XE");
+    oraDb.setHeartbeatSql("select count(*) from dual");
+
+
+    c.loadFromProperties();
+    c.setDdlGenerate(true);
+    c.setDdlRun(true);
+    c.setDefaultServer(false);
+    c.setRegister(false);
+    c.setDataSourceConfig(oraDb);
+
+    //c.setDatabaseBooleanTrue("1");
+    //c.setDatabaseBooleanFalse("0");
+    c.setDatabaseBooleanTrue("T");
+    c.setDatabaseBooleanFalse("F");
+
+    c.addClass(TOne.class);
+    c.addClass(TSMaster.class);
+    c.addClass(TSDetail.class);
+
+    return EbeanServerFactory.create(c);
+
+  }
+
+  private EbeanServer createEbeanServer() {
+
+    ServerConfig c = new ServerConfig();
+    c.setName("pgtest");
+    c.setDdlExtra(false);
+
+    // requires postgres driver in class path
+    DataSourceConfig postgresDb = new DataSourceConfig();
+    postgresDb.setDriver("org.postgresql.Driver");
+    postgresDb.setUsername("test");
+    postgresDb.setPassword("test");
+    postgresDb.setUrl("jdbc:postgresql://127.0.0.1:5432/test");
+    postgresDb.setHeartbeatSql("select count(*) from t_one");
+
+    c.loadFromProperties();
+    c.setDdlGenerate(true);
+    c.setDdlRun(true);
+    c.setDefaultServer(false);
+    c.setRegister(false);
+    c.setDataSourceConfig(postgresDb);
+
+    //c.setDatabaseBooleanTrue("1");
+    //c.setDatabaseBooleanFalse("0");
+    c.setDatabaseBooleanTrue("T");
+    c.setDatabaseBooleanFalse("F");
+
+    c.setDatabasePlatform(new PostgresPlatform());
+
+    c.addClass(TOne.class);
+
+    return EbeanServerFactory.create(c);
+
+  }
+
+  private void simpleCheck(EbeanServer server) {
+
+    TOne o = new TOne();
+    o.setName("banan");
+    o.setDescription("this one is true");
+    o.setActive(true);
+
+    server.save(o);
+
+    TOne o2 = new TOne();
+    o2.setName("banan");
+    o2.setDescription("this one is false");
+    o2.setActive(false);
+
+    server.save(o2);
+
+
+    List<TOne> list = server.find(TOne.class)
+      .setAutoTune(false)
+      .order("id")
+      .findList();
+
+    Assert.assertTrue(list.size() == 2);
+    Assert.assertTrue(list.get(0).isActive());
+    Assert.assertFalse(!list.get(0).isActive());
+
+    String sql = "select id, name, active from t_oneb order by id";
+    List<SqlRow> sqlRows = server.sqlQuery(sql).findList();
+    Assert.assertTrue(sqlRows.size() == 2);
+    Object active0 = sqlRows.get(0).get("active");
+    Object active1 = sqlRows.get(1).get("active");
+
+    Assert.assertTrue("T".equals(active0));
+    Assert.assertTrue("F".equals(active1));
+
+
+    Query<TOne> query = server.find(TOne.class)
+      .setAutoTune(false)
+      .order("id");
+
+    int rc = query.findCount();
+    Assert.assertTrue(rc > 0);
+
+
+    System.out.println("done");
+  }
+}

ebean-core/src/test/java/org/tests/basic/MyTestDataSourcePoolListener.java

@@ -0,0 +1,24 @@
+package org.tests.basic;
+
+import io.ebean.datasource.DataSourcePoolListener;
+
+import java.sql.Connection;
+
+public class MyTestDataSourcePoolListener implements DataSourcePoolListener {
+  public static int SLEEP_AFTER_BORROW = 0;
+
+  @Override
+  public void onAfterBorrowConnection(Connection c) {
+    if (SLEEP_AFTER_BORROW > 0) {
+      try {
+        Thread.sleep(SLEEP_AFTER_BORROW);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  @Override
+  public void onBeforeReturnConnection(Connection c) {
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestAnnotationBase.java

@@ -0,0 +1,215 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.annotation.Index;
+import io.ebean.annotation.Platform;
+import io.ebean.annotation.Where;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanProperty;
+import io.ebeaninternal.server.deploy.IndexDefinition;
+import io.ebeaninternal.server.deploy.meta.DeployBeanProperty;
+import org.junit.Test;
+import org.tests.model.basic.ValidationGroupSomething;
+
+import javax.persistence.Entity;
+import javax.persistence.MappedSuperclass;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Size;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+import java.util.HashSet;
+import java.util.Set;
+
+import static io.ebean.annotation.Platform.H2;
+import static io.ebean.annotation.Platform.POSTGRES;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+public class TestAnnotationBase extends BaseTestCase {
+
+  private final Set<Class<?>> metaAnnotationsFilter = new HashSet<>();
+
+  public TestAnnotationBase() {
+    metaAnnotationsFilter.add(Where.class);
+    metaAnnotationsFilter.add(Where.List.class);
+  }
+
+  @Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
+  @Retention(RetentionPolicy.RUNTIME)
+  @Where(clause = "SELECT 'mysql' from 1", platforms = Platform.MYSQL)
+  @Where(clause = "SELECT 'h2' from 1", platforms = H2)
+  @Where(clause = "SELECT 'other' from 1")
+  public @interface MetaTest {
+
+  }
+
+  @Index(name = "ano_1", columnNames = "direct", platforms = {H2, POSTGRES})
+  @Index(name = "ano_2", columnNames = "direct", platforms = {H2, POSTGRES})
+  @MappedSuperclass
+  public static class MappedBaseEntity {
+
+  }
+
+  @Index(name = "ano_3", columnNames = "direct")
+  @Entity
+  public static class TestAnnotationBaseEntity extends MappedBaseEntity {
+
+    @Where(clause = "SELECT 'mysql' from 1", platforms = Platform.MYSQL)
+    @Where(clause = "SELECT 'h2' from 1", platforms = H2)
+    @Where(clause = "SELECT 'other' from 1")
+    private String direct;
+
+    @MetaTest
+    private String meta;
+
+    @MetaTest
+    @Where(clause = "SELECT 'oracle' from 1", platforms = Platform.ORACLE)
+    private String mixed;
+
+    @Size.List({
+      @Size(max = 10, message = "max length for you is 10"),
+      @Size(min = 1),
+      @Size(max = 40, message = "max value for you is 40", groups = ValidationGroupSomething.class)
+    })
+    private String constraintAnnotation;
+
+    @NotNull
+    private String null1;
+
+
+    @NotNull(groups = ValidationGroupSomething.class)
+    private String null2;
+
+    private String null3;
+
+    public String getDirect() {
+      return direct;
+    }
+
+    public void setDirect(String direct) {
+      this.direct = direct;
+    }
+
+    public String getMeta() {
+      return meta;
+    }
+
+    public void setMeta(String meta) {
+      this.meta = meta;
+    }
+
+    public String getMixed() {
+      return mixed;
+    }
+
+    public void setMixed(String mixed) {
+      this.mixed = mixed;
+    }
+
+    public String getConstraintAnnotation() {
+      return constraintAnnotation;
+    }
+
+    public void setConstraintAnnotation(String constraintAnnotation) {
+      this.constraintAnnotation = constraintAnnotation;
+    }
+
+    public String getNull1() {
+      return null1;
+    }
+
+    public void setNull1(String null1) {
+      this.null1 = null1;
+    }
+
+    public String getNull2() {
+      return null2;
+    }
+
+    public void setNull2(String null2) {
+      this.null2 = null2;
+    }
+
+    public String getNull3() {
+      return null3;
+    }
+
+    public void setNull3(String null3) {
+      this.null3 = null3;
+    }
+  }
+
+
+  @Test
+  public void testFindMaxSize() throws SecurityException {
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+    BeanProperty bp = descriptor.findProperty("constraintAnnotation");
+    assertEquals(40, bp.getDbLength());
+  }
+
+  @Test
+  public void annotationClassIndexes() throws SecurityException {
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+    final IndexDefinition[] indexDefinitions = descriptor.getIndexDefinitions();
+    assertEquals(3, indexDefinitions.length);
+  }
+
+  @Test
+  public void testNotNullWithGroup() throws SecurityException {
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+
+    BeanProperty bp = descriptor.findProperty("null1");
+    assertFalse(bp.isNullable());
+
+    bp = descriptor.findProperty("null2");
+    assertTrue(bp.isNullable());
+
+    bp = descriptor.findProperty("null3");
+    assertTrue(bp.isNullable());
+  }
+
+  @Test
+  public void testFindAnnotation() throws NoSuchFieldException, SecurityException {
+
+    Field directFld = TestAnnotationBaseEntity.class.getDeclaredField("direct");
+    final DeployBeanProperty direct = createProperty(directFld);
+
+    assertEquals("SELECT 'mysql' from 1", where(direct, Platform.MYSQL));
+    assertEquals("SELECT 'h2' from 1", where(direct, H2));
+    assertEquals("SELECT 'other' from 1", where(direct, Platform.POSTGRES));
+
+    // meta
+    Field metaFld = TestAnnotationBaseEntity.class.getDeclaredField("meta");
+    final DeployBeanProperty meta = createProperty(metaFld);
+
+    assertEquals("SELECT 'mysql' from 1", where(meta, Platform.MYSQL));
+    assertEquals("SELECT 'h2' from 1", where(meta, H2));
+    assertEquals("SELECT 'other' from 1", where(meta, Platform.POSTGRES));
+
+    // mixed
+    Field mixedFld = TestAnnotationBaseEntity.class.getDeclaredField("mixed");
+    final DeployBeanProperty mixed = createProperty(mixedFld);
+
+    assertEquals("SELECT 'mysql' from 1", where(mixed, Platform.MYSQL));
+    assertEquals("SELECT 'h2' from 1", where(mixed, H2));
+    assertEquals("SELECT 'other' from 1", where(mixed, Platform.POSTGRES));
+    assertEquals("SELECT 'oracle' from 1", where(mixed, Platform.ORACLE));
+  }
+
+  private String where(DeployBeanProperty property, Platform platform) {
+    return property.getMetaAnnotationWhere(platform).clause();
+  }
+
+  private DeployBeanProperty createProperty(Field fld) {
+    DeployBeanProperty directProperty = new DeployBeanProperty(null, null, null);
+    directProperty.setField(fld);
+    directProperty.initMetaAnnotations(metaAnnotationsFilter);
+    return directProperty;
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestAssocOneEqExpression.java

@@ -0,0 +1,43 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestAssocOneEqExpression extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c = new Customer();
+    c.setId(1);
+
+    Query<Order> query = Ebean.find(Order.class)
+      .where().eq("customer", c)
+      .query();
+
+    query.findList();
+    String sql = query.getGeneratedSql();
+    Assert.assertTrue(sql.contains("where t0.kcustomer_id = ?"));
+
+    Address b = new Address();
+    b.setId(1);
+
+    Query<Order> q2 = Ebean.find(Order.class)
+      .where().eq("customer.billingAddress", b)
+      .query();
+
+    q2.findList();
+    sql = q2.getGeneratedSql();
+    Assert.assertTrue(sql.contains("where t1.billing_address_id = ?"));
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestBatchLazy.java

@@ -0,0 +1,41 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestBatchLazy extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class);
+    List<Order> list = query.findList();
+
+
+    for (Order order : list) {
+      Customer customer = order.getCustomer();
+      customer.getName();
+
+      List<OrderDetail> details = order.getDetails();
+      for (OrderDetail orderDetail : details) {
+        orderDetail.getProduct().getSku();
+      }
+    }
+
+    Ebean.getDefaultServer().getAutoTune().collectProfiling();
+    Ebean.getDefaultServer().getAutoTune().reportProfiling();
+
+  }
+
+
+}

ebean-core/src/test/java/org/tests/basic/TestBatchLazyMany.java

@@ -0,0 +1,35 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+public class TestBatchLazyMany extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    Order order2 = Ebean.getReference(Order.class, 1);
+    order2.getOrderDate();
+
+//		List<Order> list = Ebean.find(Order.class)
+//			//.join("details")
+//			//.join("details", "+fetchquery")
+//			.findList();
+//
+//		Order order = list.get(0);
+//		//List<OrderDetail> details = order.getDetails();
+//		//details.size();
+//
+//		Customer customer = order.getCustomer();
+//		customer.getName();
+//		System.out.println("done");
+
+  }
+
+
+}

ebean-core/src/test/java/org/tests/basic/TestBeanReferenceRefresh.java

@@ -0,0 +1,52 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.cache.ServerCache;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Date;
+
+public class TestBeanReferenceRefresh extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    ServerCache beanCache = Ebean.getServerCacheManager().getBeanCache(Order.class);
+    beanCache.clear();
+
+    Order order = Ebean.getReference(Order.class, 1);
+
+    Assert.assertTrue(Ebean.getBeanState(order).isReference());
+
+    // invoke lazy loading
+    Date orderDate = order.getOrderDate();
+    Assert.assertNotNull(orderDate);
+
+    Customer customer = order.getCustomer();
+    Assert.assertNotNull(customer);
+
+    Assert.assertFalse(Ebean.getBeanState(order).isReference());
+    Assert.assertNotNull(order.getStatus());
+    Assert.assertNotNull(order.getDetails());
+    Assert.assertNull(Ebean.getBeanState(order).getLoadedProps());
+
+    Status status = order.getStatus();
+    Assert.assertTrue(status != Order.Status.SHIPPED);
+    order.setStatus(Order.Status.SHIPPED);
+    Ebean.refresh(order);
+
+    Status statusRefresh = order.getStatus();
+    Assert.assertEquals(status, statusRefresh);
+
+  }
+
+
+}

ebean-core/src/test/java/org/tests/basic/TestCreateEntityBean.java

@@ -0,0 +1,42 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Ebean;
+import io.ebean.annotation.IgnorePlatform;
+import io.ebean.annotation.Platform;
+import org.junit.Test;
+import org.tests.model.basic.EDefaultProp;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class TestCreateEntityBean extends BaseTestCase {
+
+  @IgnorePlatform(Platform.SQLSERVER)
+  @Test
+  public void testDefaultRelation() {
+
+    // Use `new` to construct EntityBean
+    final EDefaultProp beanNew = new EDefaultProp();
+    Ebean.save(beanNew);
+
+    final EDefaultProp beanNewDb = Ebean.find(EDefaultProp.class, beanNew.getId());
+    assertNotNull(beanNewDb);
+    assertEquals("defaultName", beanNew.getName());
+    assertNotNull(beanNewDb.geteSimple());
+    assertEquals("Default prop eSimple", beanNewDb.geteSimple().getName());
+
+    // Use `createEntityBean` to construct EntityBean and check if it behaves the same as `new`
+    final EDefaultProp beanCreateEntityBean = DB.getDefault().createEntityBean(EDefaultProp.class);
+    Ebean.save(beanCreateEntityBean);
+
+    final EDefaultProp beanCreateEntityBeanDb = Ebean.find(EDefaultProp.class, beanCreateEntityBean.getId());
+    assertNotNull(beanCreateEntityBeanDb);
+    assertEquals("defaultName", beanCreateEntityBeanDb.getName());
+    assertNotNull(beanCreateEntityBeanDb.geteSimple());
+    assertEquals("Default prop eSimple", beanCreateEntityBeanDb.geteSimple().getName());
+
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestDeleteByIdCollection.java

@@ -0,0 +1,80 @@
+package org.tests.basic;
+
+import io.ebean.Ebean;
+import io.ebean.TransactionalTestCase;
+
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestDeleteByIdCollection extends TransactionalTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c0 = ResetBasicData.createCustomer("del1", "del1 ship", "del1 bill", 1);
+    Customer c1 = ResetBasicData.createCustomer("del2", "del2 ship", "del2 bill", 2);
+
+    Ebean.save(c0);
+    Ebean.save(c1);
+
+    Customer c0Back = Ebean.find(Customer.class, c0.getId());
+    Customer c1Back = Ebean.find(Customer.class, "" + c1.getId());
+
+    Assert.assertNotNull(c0Back);
+    Assert.assertNotNull(c1Back);
+
+    List<String> ids = new ArrayList<>();
+    // also test id type conversion
+    ids.add("" + c0.getId());
+    ids.add("" + c1.getId());
+
+
+    Ebean.deleteAll(Customer.class, ids);
+    awaitL2Cache();
+
+    c0Back = Ebean.find(Customer.class, c0.getId());
+    c1Back = Ebean.find(Customer.class, "" + c1.getId());
+
+    Assert.assertNull(c0Back);
+    Assert.assertNull(c1Back);
+  }
+
+  @Test
+  public void testDelByStatement() {
+
+    ResetBasicData.reset();
+
+    Order order0 = ResetBasicData.createOrderCustAndOrder("delBySql 0");
+    Order order1 = ResetBasicData.createOrderCustAndOrder("delBySql 1");
+
+    Order o0Back = Ebean.find(Order.class, order0.getId());
+    Order o1Back = Ebean.find(Order.class, order1.getId());
+
+    Assert.assertNotNull(o0Back);
+    Assert.assertNotNull(o1Back);
+
+
+    List<Object> ids = new ArrayList<>();
+    // also test id type conversion
+    ids.add(order0.getId());
+    ids.add(order1.getId());
+
+    Ebean.deleteAll(Order.class, ids);
+    awaitL2Cache();
+
+    o0Back = Ebean.find(Order.class, order0.getId());
+    o1Back = Ebean.find(Order.class, order1.getId());
+
+    Assert.assertNull(o0Back);
+    Assert.assertNull(o1Back);
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java

@@ -0,0 +1,63 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.Test;
+import org.tests.model.basic.Article;
+import org.tests.model.basic.Section;
+import org.tests.model.basic.SubSection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestDeleteCascadingOneToMany extends BaseTestCase {
+
+  @Test
+  public void testDeleteCascadingOneToMany() {
+    Section s0 = new Section("some content");
+    Article a0 = new Article("art1", "auth1");
+    a0.addSection(s0);
+
+    DB.save(a0);
+    DB.delete(a0);
+  }
+
+  @Test
+  public void l2cache_updateBeanOnly_expect_doesNotUpdateManyIds() {
+
+    // setup, create our graph - Bean -> OneToMany -> OneToMany
+    Section s0 = new Section("c0");
+    s0.getSubSections().add(new SubSection("sub0"));
+    Article a0 = new Article("a2", "a2");
+    a0.getSections().add(s0);
+    DB.save(a0);
+
+    // load into l2 bean cache
+    final Article bean0 = DB.find(Article.class, a0.getId());
+    for (Section section : bean0.getSections()) {
+      section.getSubSections().size(); // ensure the collections are loaded into l2 cache
+    }
+
+    // mutate the manyIds associated with the bean
+    final Article bean1 = DB.find(Article.class, a0.getId());
+    final Section section1 = bean1.getSections().get(0);
+    section1.getSubSections().clear(); // orphan remove will delete sub0 - this is cause of EntityNotFoundException: Bean not found during lazy load or refresh
+    section1.getSubSections().add(new SubSection("sub-replacement"));
+    DB.save(bean1);
+
+    bean0.setName("a2mod");
+    // save bean but we have not mutated the collections
+    // should NOT update the l2 manyIds (Bug will PUT the original manyIds into l2 COLL cache)
+    DB.save(bean0);
+
+    // fetch again hitting l2 cache
+    final Article beanLast = DB.find(Article.class, a0.getId());
+
+    // invoke lazy loading - hits l2 cache and get the expected result
+    for (Section section : beanLast.getSections()) {
+      for (SubSection subSection : section.getSubSections()) {
+        assertThat(subSection.getTitle()).isEqualTo("sub-replacement");
+      }
+    }
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestDeleteImportedPartial.java

@@ -0,0 +1,34 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteImportedPartial extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    PFile persistentFile = new PFile("test.txt", new PFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getFileContent().getId();
+
+    PFile partialPfile = Ebean.find(PFile.class).select("id").where().idEq(persistentFile.getId())
+      .findOne();
+
+    // should delete file and fileContent
+    Ebean.delete(partialPfile);
+
+    PFile file1 = Ebean.find(PFile.class, id);
+    PFileContent content1 = Ebean.find(PFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestDeleteOneToOne.java

@@ -0,0 +1,50 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PersistentFile;
+import org.tests.model.basic.PersistentFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteOneToOne extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+
+    PersistentFile persistentFile = new PersistentFile("test.txt", new PersistentFileContent(
+      "test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getPersistentFileContent().getId();
+
+    // should delete file and fileContent
+    Ebean.delete(PersistentFile.class, id);
+
+    PersistentFile file1 = Ebean.find(PersistentFile.class, id);
+    PersistentFileContent content1 = Ebean.find(PersistentFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+
+  // public void testDeleteMany() {
+  //
+  // Customer c = new Customer();
+  // c.setName("Fiona");
+  // c.setStatus(Customer.Status.ACTIVE);
+  // c.addContact(new Contact("Fiona", "Black"));
+  // c.addContact(new Contact("Tracy", "Red"));
+  //
+  // Ebean.save(c);
+  //
+  // Ebean.delete(Customer.class, c.getId());
+  //
+  // Customer deletedCustomer = Ebean.find(Customer.class, c.getId());
+  //
+  // Assert.assertNull(deletedCustomer);
+  //
+  // }
+}

ebean-core/src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteOneToOneMultiple extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+
+    PFile persistentFile = new PFile("test.txt", new PFileContent("test".getBytes()));
+//    PFile persistentFile = new PFile();
+//    persistentFile.setName("test.txt");
+//    PFileContent content = new PFileContent();
+//    content.setContent("test".getBytes());
+//    persistentFile.setFileContent(content);
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getFileContent().getId();
+
+    // should delete file and fileContent
+    Ebean.delete(PFile.class, id);
+
+    PFile file1 = Ebean.find(PFile.class, id);
+    PFileContent content1 = Ebean.find(PFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestDeletePartialNoVersion.java

@@ -0,0 +1,54 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TMapSuperEntity;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeletePartialNoVersion extends BaseTestCase {
+
+  @Test
+  public void testNoVersion() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babanaone");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name")
+      .findOne();
+
+    Assert.assertNotNull(e2);
+
+    e2.setName("banaban2");
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+
+
+  public void testWithVersion() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babanatwo");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name, version")
+      .findOne();
+
+    Assert.assertNotNull(e2);
+
+    e2.setName("banaban2two");
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestDynamicUpdate.java

@@ -0,0 +1,53 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import org.tests.model.embedded.EMain;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDynamicUpdate extends BaseTestCase {
+
+  @Test
+  public void testUpdate() {
+
+    // insert
+    EMain b = new EMain();
+    b.setName("aaa");
+    b.getEmbeddable().setDescription("123");
+
+    EbeanServer server = Ebean.getServer(null);
+
+    server.save(b);
+
+    Assert.assertNotNull(b.getId());
+
+    // reload object und update the name
+    EMain b2 = server.find(EMain.class, b.getId());
+
+    b2.getEmbeddable().setDescription("ABC");
+
+    BeanState beanState = server.getBeanState(b2);
+    boolean dirty = beanState.isDirty();
+    Assert.assertTrue(dirty);
+
+    server.save(b2);
+
+    server.beginTransaction();
+    try {
+      EMain b3 = server.find(EMain.class, b.getId());
+      Assert.assertEquals("ABC", b3.getEmbeddable().getDescription());
+    } finally {
+      server.endTransaction();
+    }
+    EMain b4 = server.find(EMain.class, b.getId());
+    b4.setName("bbb");
+    b4.getEmbeddable().setDescription("123");
+    server.save(b4);
+
+    EMain b5 = server.find(EMain.class, b.getId());
+    Assert.assertEquals("123", b5.getEmbeddable().getDescription());
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java

@@ -0,0 +1,28 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+
+public class TestEnhancementCollectionInitialisation extends BaseTestCase {
+
+  @Test
+  public void testListInitialisation() {
+
+    Customer customer = new Customer();
+    BeanState beanState = Ebean.getBeanState(customer);
+    if (beanState != null) {
+      List<Order> orders = customer.getOrders();
+      Assert.assertNotNull(orders);
+    }
+
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestErrorBindLog.java

@@ -0,0 +1,29 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.Order;
+
+import javax.persistence.PersistenceException;
+
+public class TestErrorBindLog extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    try {
+      Ebean.find(Order.class).where().gt("id", "JUNK").findList();
+
+    } catch (PersistenceException e) {
+      String msg = e.getMessage();
+      if (isHana()) {
+        Assert.assertTrue(msg.contains("Error with property[1] dt[12]data[JUNK]"));
+      }
+      else {
+        Assert.assertTrue(msg.contains("Bind values:"));
+      }
+    }
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestExplicitInsert.java

@@ -0,0 +1,90 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasic;
+import org.tests.model.basic.MyEBasicConfigStartup;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class TestExplicitInsert extends BaseTestCase {
+
+  @Test
+  public void setId_when_converted() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+
+    Customer cust = new Customer();
+    Object returnId = server.setBeanId(cust, "42");
+
+    assertThat(returnId).isEqualTo(42);
+    assertThat(cust.getId()).isEqualTo(42);
+  }
+
+  @Test
+  public void setId_when_correctType() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+
+    Customer customer = new Customer();
+    Object returnId = server.setBeanId(customer, 42);
+
+    assertThat(returnId).isEqualTo(42);
+    assertThat(customer.getId()).isEqualTo(42);
+  }
+
+  @Test
+  public void test() throws InterruptedException {
+
+    Thread.sleep(100);
+
+    MyEBasicConfigStartup.resetCounters();
+
+    EBasic b = new EBasic();
+    b.setName("exp insert");
+    b.setDescription("explicit insert");
+    b.setStatus(EBasic.Status.ACTIVE);
+
+    EbeanServer server = Ebean.getDefaultServer();
+    server.insert(b);
+
+    Assert.assertNotNull(b.getId());
+
+    Assert.assertEquals(b.getId(), server.getBeanId(b));
+
+
+    EBasic b2 = server.find(EBasic.class, b.getId());
+    b2.setId(null);
+
+    b2.setName("force insert");
+    server.insert(b2);
+
+    Assert.assertNotNull(b2.getId());
+    Assert.assertTrue(!b.getId().equals(b2.getId()));
+
+    List<EBasic> list = server.find(EBasic.class).where().in("id", b.getId(), b2.getId()).findList();
+
+    assertEquals(2, list.size());
+
+    b2.setName("do an update");
+    server.save(b2);
+
+    server.delete(b);
+    server.delete(b2);
+
+    // just sleep a little to allow the background thread to fire
+    Thread.sleep(100);
+
+    assertEquals(2, MyEBasicConfigStartup.insertCount.get());
+    assertEquals(1, MyEBasicConfigStartup.updateCount.get());
+    assertEquals(2, MyEBasicConfigStartup.deleteCount.get());
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestFetchId.java

@@ -0,0 +1,39 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.FutureIds;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestFetchId extends BaseTestCase {
+
+  @Test
+  public void testFetchId() throws InterruptedException, ExecutionException {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("id", 1)
+      .gt("details.id", 0)
+      .query();
+
+    List<Object> ids = query.findIds();
+    assertThat(ids).isNotEmpty();
+
+    FutureIds<Order> futureIds = query.findFutureIds();
+
+    // wait for all the id's to be fetched
+    List<Object> idList = futureIds.get();
+    assertThat(idList).isNotEmpty();
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestIUDVanilla.java

@@ -0,0 +1,82 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.EBasicVer;
+import org.tests.model.basic.UTMaster;
+
+import javax.persistence.OptimisticLockException;
+import java.sql.Timestamp;
+
+public class TestIUDVanilla extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicVer e0 = new EBasicVer("vanilla");
+
+    e0.save();
+
+    Assert.assertNotNull(e0.getId());
+    Assert.assertNotNull(e0.getLastUpdate());
+
+    Timestamp lastUpdate0 = e0.getLastUpdate();
+
+    e0.setName("modified");
+    e0.save();
+
+    Timestamp lastUpdate1 = e0.getLastUpdate();
+    Assert.assertNotNull(lastUpdate1);
+    Assert.assertNotSame(lastUpdate0, lastUpdate1);
+
+    EBasicVer e2 = DB.getDefault().createEntityBean(EBasicVer.class);
+
+    e2.setId(e0.getId());
+    e2.setLastUpdate(lastUpdate1);
+
+    e2.setName("forcedUpdate");
+    e2.update();
+
+    EBasicVer e3 = new EBasicVer("ModNoOCC");
+    e3.setId(e0.getId());
+
+    e3.update();
+
+    e3.setName("ModAgain");
+    e3.setDescription("Banana");
+
+    e3.update();
+
+  }
+
+  @Test
+  public void stateless_noOCC() {
+
+    EBasicVer e0 = new EBasicVer("vanilla");
+    e0.save();
+
+    EBasicVer e3 = new EBasicVer("ModNoOCC");
+    e3.setId(e0.getId());
+    e3.setLastUpdate(e0.getLastUpdate());
+
+    e3.update();
+
+    e3.setName("ModAgain");
+    //e3.setDescription("Banana");
+
+    e3.update();
+  }
+
+  @Test(expected = OptimisticLockException.class)
+  public void modifyVersion_expect_optimisticLock() {
+
+    UTMaster e0 = new UTMaster("save me");
+    e0.save();
+
+    // for this case we know 42 should throw OptimisticLockException
+    e0.setVersion(42);
+    e0.update();
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestInEmpty.java

@@ -0,0 +1,48 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class TestInEmpty extends BaseTestCase {
+
+  @Test
+  public void test_in_empty() {
+
+    Query<Order> query = Ebean.find(Order.class).where().in("id", new Object[0]).gt("id", 0)
+      .query();
+
+    List<Order> list = query.findList();
+    assertSql(query).contains("1=0");
+    assertEquals(0, list.size());
+  }
+
+  @Test
+  public void test_isIn_empty() {
+
+    Query<Order> query = Ebean.find(Order.class).where().isIn("id", new Object[0]).gt("id", 0)
+      .query();
+
+    List<Order> list = query.findList();
+    assertSql(query).contains("1=0");
+    assertEquals(0, list.size());
+  }
+
+  @Test
+  public void test_notIn_empty() {
+
+    Query<Order> query = Ebean.find(Order.class).where().notIn("id", new Object[0]).gt("id", 0)
+      .query();
+
+    query.findList();
+    assertSql(query).contains("1=1");
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestInheritRef.java

@@ -0,0 +1,58 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Car;
+import org.tests.model.basic.Truck;
+import org.tests.model.basic.Vehicle;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestInheritRef extends BaseTestCase {
+
+  @Test
+  public void testAssocOne() {
+
+    Ebean.beginTransaction();
+    try {
+      Ebean.createUpdate(Vehicle.class, "delete from vehicle");
+
+      Car c = new Car();
+      c.setLicenseNumber("C6788");
+      c.setDriver("CarDriver");
+      Ebean.save(c);
+
+      Truck t = new Truck();
+      t.setLicenseNumber("T1098BBX");
+      t.setCapacity(20D);
+      Ebean.save(t);
+
+      List<Vehicle> list = Ebean.find(Vehicle.class)
+        .setAutoTune(false)
+        .findList();
+
+      Assert.assertTrue(!list.isEmpty());
+
+      Truck foundTruck = null;
+      int found = 0;
+
+      for (Vehicle vehicle : list) {
+        if (vehicle instanceof Truck) {
+          Truck truck = (Truck) vehicle;
+          if ("T1098BBX".equals(truck.getLicenseNumber())) {
+            found++;
+            foundTruck = truck;
+          }
+        }
+      }
+
+      Assert.assertEquals(1, found);
+      Assert.assertTrue(foundTruck.getCapacity() == 20D);
+
+    } finally {
+      Ebean.rollbackTransaction();
+    }
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestJodaType.java

@@ -0,0 +1,43 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanProperty;
+import io.ebeaninternal.server.type.ScalarType;
+import org.tests.model.basic.TJodaEntity;
+import org.joda.time.LocalTime;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestJodaType extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    BeanDescriptor<TJodaEntity> beanDescriptor = server.getBeanDescriptor(TJodaEntity.class);
+    BeanProperty beanProperty = beanDescriptor.getBeanProperty("localTime");
+    ScalarType<?> scalarType = beanProperty.getScalarType();
+
+    Assert.assertNotNull(scalarType);
+  }
+
+  @Test
+  public void test_insert_find() {
+
+    LocalTime now = new LocalTime().withMillisOfSecond(0);
+
+    TJodaEntity bean = new TJodaEntity();
+    bean.setLocalTime(now);
+    Ebean.save(bean);
+
+    TJodaEntity foundBean = Ebean.find(TJodaEntity.class, bean.getId());
+
+    assertThat(foundBean.getLocalTime()).isEqualTo(bean.getLocalTime());
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestJoinInheritance.java

@@ -0,0 +1,80 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Car;
+import org.tests.model.basic.Trip;
+import org.tests.model.basic.Vehicle;
+import org.tests.model.basic.VehicleDriver;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.Date;
+
+public class TestJoinInheritance extends BaseTestCase {
+
+
+  /**
+   * Test join hierarchy assoc one.
+   * <p>
+   * This test catches the problem where the discriminator column is select
+   * but is not skipped if the parent bean is already in the presistence context.
+   * <p>
+   * Test case: We have several trips with different addresses but always the same
+   * driver and car (the cars could be different). So the driver will be loaded
+   * when the first trip is loaded but when the second trip is loaded the driver is
+   * found in the persistence context. So the bean is not read but the index in the
+   * result set is forwarded by the number of properties - however, the vehicle type
+   * column was not being skipped - but the query reads happily - only the data is
+   * then wrong in the address object.
+   */
+  @Test
+  public void testJoinHierarchyAssocOne() {
+
+    Ebean.createUpdate(Vehicle.class, "delete from vehicle");
+
+
+    Address address = new Address();
+    address.setLine1("Street");
+    address.setLine2("Street");
+    address.setCity("City");
+
+    address.setCretime(new Timestamp(new Date().getTime()));
+
+    Ebean.save(address);
+
+    Car c = new Car();
+    c.setLicenseNumber("C6788");
+    c.setDriver("CarDriver");
+    c.setRegistrationDate(new Date());
+    Ebean.save(c);
+
+    VehicleDriver driver = new VehicleDriver();
+
+    driver.setVehicle(c);
+    driver.setAddress(address);
+    driver.setLicenseIssuedOn(new Date());
+    Ebean.save(driver);
+
+    final String line1 = "Street1";
+    final String line2 = "Street2";
+    final String city = "City";
+
+    int nrDrivers = 2;
+    for (int i = 0; i < nrDrivers; i++) {
+      Address address1 = new Address();
+      address1.setLine1(line1);
+      address1.setLine2(line2);
+      address1.setCity(city);
+      Ebean.save(address1);
+
+      Trip trip = new Trip();
+      trip.setVehicleDriver(driver);
+      trip.setAddress(address1);
+      trip.setCretime(new Timestamp(new Date().getTime()));
+      Ebean.save(trip);
+    }
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java

@@ -0,0 +1,40 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+public class TestLazyLoadEmptyOneToMany extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c = new Customer();
+    c.setName("testll");
+
+    Ebean.save(c);
+
+    Customer c1 = Ebean.find(Customer.class)
+      .setAutoTune(false)
+      .select("id")
+      .fetch("contacts", "id")
+      .where().idEq(c.getId())
+      .findOne();
+
+    List<Contact> contacts = c1.getContacts();
+    int sz = contacts.size();
+
+    Assert.assertTrue(sz == 0);
+
+    // cleanup
+    Ebean.delete(c1);
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestLazyLoadInCache.java

@@ -0,0 +1,64 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.CacheMode;
+import io.ebean.Ebean;
+import org.junit.Test;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class TestLazyLoadInCache extends BaseTestCase {
+
+  @Test
+  public void testLoadInCache() {
+
+    ResetBasicData.reset();
+
+    Map<Integer, Customer> map = Ebean.find(Customer.class)
+      .select("id, name")
+      .setBeanCacheMode(CacheMode.PUT)
+      .setReadOnly(true)
+      .order().asc("id")
+      .findMap();
+
+    assertTrue(!map.isEmpty());
+
+    Object id = map.keySet().iterator().next();
+
+    Customer cust1 = map.get(id);
+
+    Customer cust1B = Ebean.find(Customer.class)
+      .setReadOnly(true)
+      .setId(id)
+      .findOne();
+
+    assertTrue(cust1 != cust1B);
+
+    Set<String> loadedProps = Ebean.getBeanState(cust1).getLoadedProps();
+
+    assertTrue(loadedProps.contains("name"));
+    assertFalse(loadedProps.contains("status"));
+
+    cust1.getStatus();
+
+    // a readOnly reference
+    Address billingAddress = cust1.getBillingAddress();
+    BeanState billAddrState = Ebean.getBeanState(billingAddress);
+    assertTrue(billAddrState.isReference());
+    assertTrue(billAddrState.isReadOnly());
+
+    // lazy load .. no longer a reference
+    billingAddress.getCity();
+    assertFalse(billAddrState.isReference());
+
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestLimitQuery.java

@@ -0,0 +1,139 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class TestLimitQuery extends BaseTestCase {
+
+  @Test
+  public void testLimitWithMany() {
+    rob();
+    rob();
+  }
+
+  @Test
+  public void testMaxRowsZeroWithFirstRow() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(0)
+      .setFirstRow(3)
+      .order().asc("orderDate");
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    if (isH2()) {
+      assertThat(sql).contains("offset 3");
+      assertThat(sql).contains("limit 0");
+    }
+  }
+
+  @Test
+  public void testMaxRowsWithFirstRowZero() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(3)
+      .setFirstRow(0).query();
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    boolean hasLimit = sql.contains("limit 3");
+    boolean hasOffset = sql.contains("offset");
+
+    if (isH2()) {
+      Assert.assertTrue(sql, hasLimit);
+      Assert.assertFalse(sql, hasOffset);
+    }
+  }
+
+  @Test
+  public void testDefaults() {
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .query();
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    boolean hasLimit = sql.contains("limit");
+    boolean hasOffset = sql.contains("offset");
+
+    if (isH2()) {
+      Assert.assertFalse(hasLimit);
+      Assert.assertFalse(hasOffset);
+    }
+  }
+
+  private void rob() {
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(10).query();
+    //.findList();
+
+    List<Order> list = query.findList();
+
+    Assert.assertTrue("sz > 0", !list.isEmpty());
+
+    String sql = query.getGeneratedSql();
+    boolean hasDetailsJoin = sql.contains("join o_order_detail");
+    boolean hasLimit = sql.contains("limit 10");
+    boolean hasSelectedDetails = sql.contains("od.id,");
+    boolean hasDistinct = sql.contains("select distinct");
+
+    Assert.assertTrue(hasDetailsJoin);
+    Assert.assertFalse(hasSelectedDetails);
+    Assert.assertTrue(hasDistinct);
+    if (isH2()) {
+      Assert.assertTrue(hasLimit);
+    }
+
+    query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .setMaxRows(10);
+
+    query.findList();
+
+    sql = query.getGeneratedSql();
+    hasDetailsJoin = sql.contains("left join o_order_detail");
+    hasLimit = sql.contains("limit 10");
+    hasSelectedDetails = sql.contains("od.id");
+    hasDistinct = sql.contains("select distinct");
+
+    Assert.assertFalse("no join with maxRows", hasDetailsJoin);
+    Assert.assertFalse(hasSelectedDetails);
+    Assert.assertFalse(hasDistinct);
+    if (isH2()) {
+      Assert.assertTrue(hasLimit);
+    }
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestLoadBeanCache.java

@@ -0,0 +1,33 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Map;
+
+public class TestLoadBeanCache extends BaseTestCase {
+
+  @Test
+  public void testLoad() {
+
+    ResetBasicData.reset();
+
+    Map<String, Country> map = Ebean.find(Country.class)
+      .setLoadBeanCache(true)
+      .setUseQueryCache(true)
+      .setReadOnly(true)
+      .order("name")
+      .findMap();
+
+    Country loadedNz = map.get("NZ");
+
+    // this will hit the cache
+    Country nz = Ebean.find(Country.class, "NZ");
+
+    Assert.assertTrue(loadedNz == nz);
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestLogTransLogOnError.java

@@ -0,0 +1,72 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Transaction;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasicVer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+public class TestLogTransLogOnError extends BaseTestCase {
+
+  @Test
+  public void testQueryError() {
+
+    ResetBasicData.reset();
+
+    try (Transaction txn = Ebean.beginTransaction()) {
+
+      Ebean.find(Customer.class).findList();
+      Ebean.find(Order.class).where().gt("id", 1).findList();
+
+      EBasicVer newBean = new EBasicVer("aName");
+      newBean.setDescription("something");
+
+      // Ebean.save(newBean);
+
+      // t.log("--- next query should error");
+      List<Customer> list = Ebean.find(Customer.class).where().eq("id", "NotAnInt!!").findList();
+
+      Assert.assertEquals(0, list.size());
+      // Get here with mysql?
+      // Assert.assertTrue(false);
+      txn.commit();
+
+    } catch (RuntimeException e) {
+      // e.printStackTrace();
+      Assert.assertTrue(true);
+    }
+  }
+
+  public void testPersistError() {
+
+    ResetBasicData.reset();
+
+    try (Transaction txn = Ebean.beginTransaction()) {
+      Ebean.find(Customer.class).findList();
+
+      EBasicVer newBean = new EBasicVer("aName");
+      newBean
+        .setDescription("something sdfjksdjflsjdflsjdflksjdfkjd fsjdfkjsdkfjsdkfjskdjfskjdf"
+          + " sjdf sdjflksjdfkjsdlfkjsdkfjs ksjdfksjdlfjsldf something sdfjksdjflsjdflsjdflksjdfkjd"
+          + "fsjdfkjsdkfjsdkfjskdjfskjdf sjdf sdjflksjdfkjsdlfkjsdkfjs ksjdfksjdlfjsldf something s"
+          + "dfjksdjflsjdflsjdflksjdfkjd fsjdfkjsdkfjsdkfjskdjfskjdf sjdf sdjflksjdfkjsdlfkjsdkfjs ");
+
+      // t.log("--- next insert should error");
+      Ebean.save(newBean);
+
+      // never get here
+      Assert.assertTrue(false);
+      txn.commit();
+
+    } catch (RuntimeException e) {
+      // e.printStackTrace();
+      Assert.assertTrue(true);
+    }
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestM2MCascadeOne.java

@@ -0,0 +1,48 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.MRole;
+import org.tests.model.basic.MUser;
+import org.junit.Test;
+
+public class TestM2MCascadeOne extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    MUser u = new MUser();
+    u.setUserName("testM2M");
+
+    u.getRoles();
+    Ebean.save(u);
+
+    MRole r0 = new MRole();
+    r0.setRoleName("rol_0");
+    Ebean.save(r0);
+
+    MRole r1 = new MRole();
+    r1.setRoleName("rol_1");
+
+    MUser u1 = Ebean.find(MUser.class, u.getUserid());
+
+    u1.addRole(r0);
+    u1.addRole(r1);
+
+    Ebean.save(u1);
+
+  }
+
+  @Test
+  public void testRawPredicate_with_ManyToManyPath() {
+
+    Query<MUser> query = Ebean.find(MUser.class)
+      .select("userid")
+      .where().raw("roles.roleid in (?)", 24)
+      .query();
+
+    query.findList();
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestM2MVanilla.java

@@ -0,0 +1,97 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Query;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.MRole;
+import org.tests.model.basic.MUser;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestM2MVanilla extends BaseTestCase {
+
+  @Test
+  public void testVanilla() {
+
+    DB.createSqlUpdate("delete from mrole_muser").execute();
+    DB.sqlUpdate("delete from mrole").execute();
+    DB.sqlUpdate("delete from muser").execute();
+
+    MRole r1 = new MRole();
+    r1.setRoleName("role1");
+    DB.save(r1);
+
+    MRole r2 = new MRole();
+    r2.setRoleName("role2");
+    DB.save(r2);
+
+    MRole r3 = new MRole();
+    r3.setRoleName("role3");
+    DB.save(r3);
+
+    MUser u0 = new MUser();
+    u0.setUserName("something");
+
+    DB.save(u0);
+
+    MUser user = DB.find(MUser.class, u0.getUserid());
+
+    List<MRole> roleList = new ArrayList<>();
+    roleList.add(r1);
+    roleList.add(r2);
+
+    user.setRoles(roleList);
+
+    DB.save(user);
+    // Ebean.saveManyToManyAssociations(user, "roles");
+
+    MUser checkUser = DB.find(MUser.class, u0.getUserid());
+    List<MRole> checkRoles = checkUser.getRoles();
+    Assert.assertNotNull(checkRoles);
+    Assert.assertEquals(2, checkRoles.size());
+
+    checkRoles.add(r3);
+
+    DB.save(checkUser);
+    // Ebean.saveManyToManyAssociations(checkUser, "roles");
+
+    MUser checkUser2 = DB.find(MUser.class, u0.getUserid());
+    List<MRole> checkRoles2 = checkUser2.getRoles();
+    Assert.assertNotNull(checkRoles2);
+    Assert.assertEquals("added a role", 3, checkRoles2.size());
+
+    Query<MUser> rolesQuery0 = DB.find(MUser.class).where().eq("roles", r1).query();
+
+    rolesQuery0.findList();
+
+    Query<MUser> rolesQuery = DB.find(MUser.class).where().in("roles", roleList).query();
+
+    List<MUser> userInRolesList = rolesQuery.findList();
+    Assert.assertTrue(!userInRolesList.isEmpty());
+
+    List<MUser> list = DB.find(MUser.class)
+      .where().in("roles", roleList)
+      .filterMany("roles").eq("roleName", "role1")
+      .findList();
+
+    MUser mUser = list.get(0);
+    List<MRole> roles = mUser.getRoles();
+    Assert.assertEquals(1, roles.size());
+
+    checkRoles2.remove(0);
+    checkRoles2.remove(0);
+    DB.save(checkUser2);
+
+    checkUser2 = DB.find(MUser.class, u0.getUserid());
+    checkRoles2 = checkUser2.getRoles();
+    Assert.assertNotNull(checkRoles2);
+    Assert.assertEquals("added a role", 1, checkRoles2.size());
+
+    DB.delete(checkUser2);
+
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestManyLazyLoad.java

@@ -0,0 +1,64 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.sql.Date;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class TestManyLazyLoad extends BaseTestCase {
+
+  @Test
+  public void testLazyLoadRef() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    awaitL2Cache();
+
+    List<Order> list = Ebean.find(Order.class).order().asc("id").findList();
+    assertTrue(list.size() + " > 0", !list.isEmpty());
+
+    // just use the first one
+    Order order = list.get(0);
+
+    // get it as a reference
+    Order order1 = Ebean.getReference(Order.class, order.getId());
+    assertNotNull(order1);
+
+    Date orderDate = order1.getOrderDate();
+    assertNotNull(orderDate);
+
+    List<OrderDetail> details = order1.getDetails();
+
+    // lazy load the details
+    int sz = details.size();
+    assertTrue(sz + " > 0", sz > 0);
+
+    OrderDetail orderDetail = details.get(0);
+    Order o = orderDetail.getOrder();
+    assertSame(o, order1);
+
+    // load detail into cache
+    Ebean.find(OrderDetail.class, orderDetail.getId());
+
+    // change order... list before a scalar property
+    Order order2 = Ebean.getReference(Order.class, order.getId());
+    assertNotNull(order2);
+
+    List<OrderDetail> details2 = order2.getDetails();
+
+    // lazy load the details
+    int sz2 = details2.size();
+    assertTrue(sz2 + " > 0", sz2 > 0);
+
+    Order o2 = details2.get(0).getOrder();
+    assertSame(o2, order2);
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestManyOneInterface.java

@@ -0,0 +1,31 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.ResetBasicData;
+import org.tests.model.interfaces.Address;
+import org.tests.model.interfaces.IAddress;
+import org.tests.model.interfaces.IPerson;
+import org.tests.model.interfaces.Person;
+import org.junit.Test;
+
+public class TestManyOneInterface extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    IAddress a = new Address();
+
+    IPerson p = new Person();
+
+    p.setDefaultAddress(a);
+
+    Ebean.save(a);
+    Ebean.save(p);
+
+    //Assert.assertTrue();
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestMappedSuper.java

@@ -0,0 +1,35 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TMapSuperEntity;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestMappedSuper extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babana");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name, myint, someObject, bananan")
+      .findOne();
+
+    Assert.assertNotNull(e2);
+
+    TMapSuperEntity eSaveDelete = new TMapSuperEntity();
+    eSaveDelete.setName("babana");
+
+    Ebean.save(eSaveDelete);
+
+    Ebean.delete(eSaveDelete);
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestMetaAnnotation.java

@@ -0,0 +1,82 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.annotation.Platform;
+import io.ebean.annotation.IgnorePlatform;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.metaannotation.SizeMedium;
+import org.junit.Test;
+
+import javax.persistence.PersistenceException;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Very simple test case to check if Ebean recognizes meta-annotation correctly.
+ *
+ * @author Roland Praml, FOCONIS AG
+ */
+public class TestMetaAnnotation extends BaseTestCase {
+
+  private static final String spaces100 = new String(new char[100]).replace('\0', ' ');
+  private static final String spaces101 = new String(new char[101]).replace('\0', ' ');
+
+  /**
+   * This test writes 100 spaces to "line1" which is annotated with @Size(max=100)
+   */
+  @Test
+  public void testWrite100SpacesToLine1() {
+
+    Address address = new Address();
+    address.setLine1(spaces100);
+    Ebean.save(address);
+  }
+
+  /**
+   * This test writes 100 spaces to "line1" which is meta-annotated with {@link SizeMedium}.
+   */
+  @Test
+  public void testWrite100SpacesToLine2() {
+
+    Address address = new Address();
+    address.setLine2(spaces100);
+    Ebean.save(address);
+  }
+
+  /**
+   * This test writes 101 spaces to "line1" which is annotated with @Size(max=100).
+   */
+  @Test
+  @IgnorePlatform({Platform.POSTGRES, Platform.SQLSERVER, Platform.MYSQL, Platform.MARIADB}) // pg & mssql does not fail if string is too long.
+  public void testWrite101SpacesToLine1() {
+
+    Address address = new Address();
+    address.setLine1(spaces101);
+    try {
+      Ebean.save(address);
+      fail("Test failed, Could insert a too long string");
+    } catch (PersistenceException e) {
+      assertTrue(true);
+    }
+  }
+
+  /**
+   * This test writes 101 spaces to "line1" which is meta-annotated with {@link SizeMedium}.
+   */
+  @Test
+  @IgnorePlatform({Platform.POSTGRES, Platform.SQLSERVER, Platform.MYSQL, Platform.MARIADB})
+  public void testWrite101SpacesToLine2() {
+
+    Address address = new Address();
+    address.setLine2(spaces101);
+    try {
+      Ebean.save(address);
+      fail("Test failed, Could insert a too long string");
+    } catch (PersistenceException e) {
+      assertTrue(true);
+    }
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java

@@ -0,0 +1,56 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Transaction;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.OCar;
+import org.tests.model.basic.OEngine;
+import org.tests.model.basic.OGearBox;
+
+public class TestMultipleOneToOneIUD extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    OEngine engine = new OEngine();
+    engine.setShortDesc("engine 1");
+
+    OGearBox gearBox = new OGearBox();
+    gearBox.setBoxDesc("6 speed manual");
+    gearBox.setSize(6);
+
+    OCar car = new OCar();
+    car.setVin("xx4534");
+    car.setName("test car");
+    car.setEngine(engine);
+
+    try (Transaction txn = Ebean.beginTransaction()) {
+      Ebean.save(gearBox);
+      Ebean.save(car);
+
+      Assert.assertNotNull(car.getId());
+      Assert.assertNotNull(engine.getEngineId());
+      Assert.assertNotNull(gearBox.getId());
+      txn.commit();
+    }
+
+    OCar c2 = Ebean.find(OCar.class, car.getId());
+    Assert.assertNotNull(c2);
+    Assert.assertNotNull(c2.getEngine());
+    // gearBox not assigned yet
+    Assert.assertNull(c2.getGearBox());
+
+    // ok, assign gearBox
+    c2.setGearBox(gearBox);
+    Ebean.save(c2);
+
+    // now all should be there...
+    OCar c3 = Ebean.find(OCar.class, car.getId());
+    Assert.assertNotNull(c3);
+    Assert.assertNotNull(c3.getEngine());
+    Assert.assertNotNull(c3.getGearBox());
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestNonUpdateProperty.java

@@ -0,0 +1,25 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.MNonUpdPropEntity;
+import org.junit.Test;
+
+public class TestNonUpdateProperty extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    MNonUpdPropEntity e = new MNonUpdPropEntity();
+    e.setName("name");
+    e.setNote("note");
+
+    Ebean.save(e);
+
+    MNonUpdPropEntity e2 = Ebean.find(MNonUpdPropEntity.class, e.getId());
+
+    e2.setName("mod");
+    Ebean.update(e2);
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestOrderByAnnotation.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.TransactionalTestCase;
+
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestOrderByAnnotation extends TransactionalTestCase {
+
+  @Test
+  public void testOrderBy() {
+
+    Customer custTest = ResetBasicData.createCustAndOrder("testOrderByAnn");
+
+    Customer customer = Ebean.find(Customer.class, custTest.getId());
+    List<Order> orders = customer.getOrders();
+
+    Assert.assertTrue(!orders.isEmpty());
+
+
+    Query<Order> q1 = Ebean.find(Order.class)
+      .fetch("details");
+
+    q1.findList();
+
+    String s1 = q1.getGeneratedSql();
+
+    Assert.assertTrue(s1.contains("order by t0.id, t1.id asc, t1.order_qty asc, t1.cretime desc"));
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java

@@ -0,0 +1,38 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestOrderTotalAmountFormula extends BaseTestCase {
+
+  @Test
+  public void testAsJoin() {
+
+    ResetBasicData.reset();
+
+    List<Customer> l0 = Ebean.find(Customer.class)
+      .select("id, name")
+      .fetch("orders", "status, totalAmount")
+      .where()
+      .eq("orders.details.product.name", "Desk")
+      .like("contacts.firstName", "Ji%")
+      .findList();
+
+    for (Customer c0 : l0) {
+      c0.getId();
+      List<Order> orders = c0.getOrders();
+      for (Order order : orders) {
+        order.getId();
+      }
+    }
+
+  }
+
+
+}

ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java

@@ -0,0 +1,153 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.RawSql;
+import io.ebean.RawSqlBuilder;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.OrderAggregate;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNotNull;
+
+public class TestOrderTotalAmountReportBean extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as totalItems, sum(order_qty*unit_price) as totalAmount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql).columnMapping("order_id", "order.id").create();
+
+    List<OrderAggregate> l0 =
+      Ebean.find(OrderAggregate.class)
+        .setRawSql(rawSql)
+        .findList();
+
+    for (OrderAggregate r0 : l0) {
+      r0.toString();
+    }
+
+    List<OrderAggregate> l2 = Ebean.createQuery(OrderAggregate.class)
+      .setRawSql(rawSql)
+      .where().gt("order.id", 0)
+      .having().lt("totalItems", 3).gt("totalAmount", 50).findList();
+
+    for (OrderAggregate r2 : l2) {
+      Assert.assertTrue(r2.getTotalItems() < 3);
+    }
+
+  }
+
+  @Test
+  public void test_when_aliasInUnderscore() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as total_items, sum(order_qty*unit_price) as total_amount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql)
+      .columnMapping("order_id", "order.id")
+      .create();
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class)
+      .setRawSql(rawSql);
+
+    query.findList();
+
+    assertSql(query).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount");
+  }
+
+  @Test
+  public void test_when_aliasInCamelCase() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as totalItems, sum(order_qty*unit_price) as totalAmount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql)
+      .columnMapping("order_id", "order.id")
+      .create();
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class)
+      .setRawSql(rawSql);
+
+    query.findList();
+
+    assertSql(query).contains("count(*) as totalItems, sum(order_qty*unit_price) as totalAmount");
+  }
+
+  @Test
+  public void testDefaultNamedRawSql() {
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class);
+    List<OrderAggregate> list = query.findList();
+
+    assertSql(query).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withMax");
+    List<OrderAggregate> list = query.findList();
+
+    assertSql(query).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql_with_extraPredicates() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withMax");
+    List<OrderAggregate> list = query
+      .where().gt("order.id", 1)
+      .having().gt("totalItems", 1)
+      .order().desc("totalAmount")
+      .findList();
+
+    assertSql(query).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertSql(query).contains("from o_order_detail  where order_id > ? group by order_id  having count(*) > ?  order by sum(order_qty*unit_price) desc");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql_with_param() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withParam");
+    List<OrderAggregate> list = query
+      .setParameter("minId", 2)
+      .where().isNotNull("order.id")
+      .having().lt("totalAmount", 100)
+      .order().desc("totalAmount")
+      .setMaxRows(10)
+      .findList();
+
+    assertSql(query).contains("count(*) as totalItems, sum(order_qty*unit_price) as totalAmount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertSql(query).contains("from o_order_detail where id > ?  and order_id is not null group by order_id  having sum(order_qty*unit_price) < ?  order by sum(order_qty*unit_price) desc");
+    assertNotNull(list);
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestOrderTotalAmountSql.java

@@ -0,0 +1,30 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.SqlRow;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+public class TestOrderTotalAmountSql extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    String sql = "select order_id, sum(order_qty*unit_price) as total_amount from o_order_detail  where order_qty > :minQty  group by order_id";
+    List<SqlRow> sqlRows = DB.sqlQuery(sql).setParameter("minQty", 1).findList();
+
+    for (SqlRow sqlRow : sqlRows) {
+      Integer id = sqlRow.getInteger("order_id");
+      Double amount = sqlRow.getDouble("total_amount");
+      Assert.assertNotNull("sqlRows: " + sqlRows, id);
+      Assert.assertNotNull("sqlRows: " + sqlRows, amount);
+    }
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestPersistenceContext.java

@@ -0,0 +1,80 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestPersistenceContext extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    // implicit transaction with its own
+    // persistence context
+    Order oBefore = Ebean.find(Order.class, 1);
+
+    Order order = null;
+
+    // start a persistence context
+    Ebean.beginTransaction();
+    try {
+
+      order = Ebean.find(Order.class, 1);
+
+      // not the same instance ...as a different
+      // persistence context
+      Assert.assertTrue(order != oBefore);
+
+
+      // finds an existing bean in the persistence context
+      // ... so doesn't even execute a query
+      Order o2 = Ebean.find(Order.class, 1);
+      Order o3 = Ebean.getReference(Order.class, 1);
+
+      // all the same instance
+      Assert.assertTrue(order == o2);
+      Assert.assertTrue(order == o3);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+
+    // implicit transaction with its own
+    // persistence context
+    Order oAfter = Ebean.find(Order.class, 1);
+
+    Assert.assertTrue(oAfter != oBefore);
+    Assert.assertTrue(oAfter != order);
+
+    // start a persistence context
+    Ebean.beginTransaction();
+    try {
+      Order testOrder = ResetBasicData.createOrderCustAndOrder("testPC");
+      Integer id = testOrder.getCustomer().getId();
+      Integer orderId = testOrder.getId();
+
+      Customer customer = Ebean.find(Customer.class)
+        .setUseCache(false)
+        .setId(id)
+        .findOne();
+
+      System.gc();
+      Order order2 = Ebean.find(Order.class, orderId);
+      Customer customer2 = order2.getCustomer();
+
+      Assert.assertEquals(customer.getId(), customer2.getId());
+
+      Assert.assertTrue(customer == customer2);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestQueryForUpdate.java

@@ -0,0 +1,139 @@
+package org.tests.basic;
+
+import io.ebean.AcquireLockException;
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Database;
+import io.ebean.Query;
+import io.ebean.Transaction;
+import io.ebean.annotation.ForPlatform;
+import io.ebean.annotation.Platform;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasic;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertTrue;
+
+public class TestQueryForUpdate extends BaseTestCase {
+
+
+  @Test
+  @ForPlatform({Platform.H2, Platform.ORACLE, Platform.POSTGRES, Platform.SQLSERVER, Platform.MYSQL, Platform.MARIADB})
+  public void testForUpdate() {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = DB.find(Customer.class)
+      .forUpdate()
+      .order().desc("id");
+
+    query.findList();
+    if (isSqlServer()) {
+      assertThat(sqlOf(query)).contains("with (updlock)");
+    } else {
+      assertThat(sqlOf(query)).contains("for update");
+    }
+  }
+
+  @Test
+  @ForPlatform({ Platform.H2, Platform.ORACLE, Platform.POSTGRES, Platform.SQLSERVER, Platform.MYSQL, Platform.MARIADB})
+  public void testForUpdate_when_alreadyInPC() {
+
+    EBasic basic = new EBasic("test PC cache");
+    DB.save(basic);
+
+    try (Transaction transaction = DB.beginTransaction()) {
+
+      LoggedSqlCollector.start();
+
+      EBasic basic0 = DB.find(EBasic.class, basic.getId());
+      assertThat(basic0).isNotNull();
+
+      EBasic basic1 = DB.find(EBasic.class)
+        .setId( basic.getId())
+        .forUpdate()
+        .findOne();
+
+      assertThat(basic1).isNotNull();
+      assertThat(basic1).isSameAs(basic0);
+
+      List<String> sql = LoggedSqlCollector.stop();
+      assertThat(sql).hasSize(2);
+      if (isH2() || isPostgres()) {
+        assertSql(sql.get(0)).contains("from e_basic t0 where t0.id =");
+        assertSql(sql.get(1)).contains("from e_basic t0 where t0.id =");
+        assertSql(sql.get(1)).contains("for update");
+      }
+
+      transaction.end();
+    }
+  }
+
+  @Test
+  @ForPlatform({Platform.H2, Platform.POSTGRES, Platform.SQLSERVER, Platform.ORACLE})
+  public void testForUpdate_noWait_noMaxRows() {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = DB.find(Customer.class)
+      .forUpdateNoWait()
+      .order().desc("id");
+
+    query.findList();
+    if (isOracle()) {
+      assertThat(sqlOf(query)).contains("for update nowait");
+    } else if (isH2()) {
+      assertThat(sqlOf(query)).contains("for update");
+    } else if (isSqlServer()) {
+      assertThat(sqlOf(query)).contains("with (updlock,nowait)");
+    } else {
+      assertThat(sqlOf(query)).contains("for update nowait");
+    }
+  }
+
+  @Test
+  @ForPlatform({Platform.H2, Platform.POSTGRES, Platform.SQLSERVER})
+  public void testForUpdate_noWait() {
+
+    ResetBasicData.reset();
+
+    Database server = DB.getDefault();
+
+    try (Transaction txn = DB.beginTransaction()) {
+      Query<Customer> query = DB.find(Customer.class)
+        .forUpdateNoWait()
+        .setMaxRows(1)
+        .order().desc("id");
+
+      List<Customer> list = query.findList();
+      Customer first = list.get(0);
+      if (isSqlServer()) {
+        assertThat(sqlOf(query)).contains("with (updlock,nowait)");
+      } else if (isH2()) {
+        assertThat(sqlOf(query)).contains("for update");
+      } else {
+        assertThat(sqlOf(query)).contains("for update nowait");
+      }
+      // create a 2nd transaction to test that the
+      // row is locked and we can't acquire it
+      try (Transaction txn2 = server.createTransaction()) {
+        logger.info("... attempt another acquire using 2nd transaction");
+        server.find(Customer.class)
+          .where().idEq(first.getId())
+          .forUpdateNoWait()
+          .usingTransaction(txn2)
+          .findOne();
+
+        assertTrue(false); // never get here
+      } catch (AcquireLockException e) {
+        logger.info("... got AcquireLockException " + e);
+      }
+      txn.commit();
+    }
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestQueryUsingConnection.java

@@ -0,0 +1,87 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Database;
+import io.ebean.Transaction;
+import io.ebean.annotation.IgnorePlatform;
+import io.ebean.annotation.Platform;
+import org.junit.Test;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.ResetBasicData;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class TestQueryUsingConnection extends BaseTestCase {
+
+  @Test
+  public void usingConnection() throws SQLException {
+
+    ResetBasicData.reset();
+
+    DataSource dataSource = DB.getDefault().getPluginApi().getDataSource();
+
+    try (Connection connection = dataSource.getConnection()) {
+
+      int count = DB.find(Country.class)
+        .usingConnection(connection)
+        .findCount();
+
+      assertThat(count).isGreaterThan(0);
+    }
+  }
+
+  @IgnorePlatform(Platform.SQLSERVER)
+  @Test
+  public void usingTransaction() {
+
+    ResetBasicData.reset();
+
+    try (Transaction transaction = DB.createTransaction()) {
+
+      Transaction current = Transaction.current();
+      assertThat(current).isNull();
+
+      Country x = new Country();
+      x.setCode("xx");
+      x.setName("WillRollThisBack");
+
+      DB.getDefault().insert(x, transaction);
+
+      final CountryDto dto = DB.findDto(CountryDto.class, "select code, name from o_country where code=?")
+        .usingTransaction(transaction)
+        .setParameter(1, "xx")
+        .findOne();
+
+      assertThat(dto).isNotNull();
+      assertEquals("xx", dto.code);
+      assertEquals("WillRollThisBack", dto.name);
+
+      final int count = DB.find(Country.class)
+        .usingTransaction(transaction)
+        .findCount();
+
+      final int otherCount = DB.find(Country.class).findCount();
+
+      transaction.rollback();
+
+      assertThat(count).isEqualTo(otherCount + 1);
+    }
+
+  }
+
+  public static class CountryDto {
+    final String code;
+    final String name;
+
+    public CountryDto(String code, String name) {
+      this.code = code;
+      this.name = name;
+    }
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestQueryUsingDatabase.java

@@ -0,0 +1,36 @@
+package org.tests.basic;
+
+import io.ebean.DB;
+import io.ebean.Database;
+import org.junit.Before;
+import org.junit.Test;
+import org.tests.model.basic.ESimple;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestQueryUsingDatabase {
+
+  private static final String SOME_OTHER_DB_NAME = "someotherdb";
+  public static final ESimple RECORD1 = new ESimple();
+  public static final ESimple RECORD2 = new ESimple();
+
+  @Before
+  public void setupNonDefaultDatabase() {
+    DB.byName(SOME_OTHER_DB_NAME).insert(RECORD1);
+    DB.byName(SOME_OTHER_DB_NAME).insert(RECORD2);
+  }
+
+  @Test
+  public void usingNonDefaultDatabase() {
+    final Database nonDefaultDb = DB.byName(SOME_OTHER_DB_NAME);
+
+    List<ESimple> orderList = DB.find(ESimple.class)
+      .usingDatabase(nonDefaultDb)
+      .findList();
+
+    assertThat(orderList).size().isEqualTo(2);
+    assertThat(orderList).containsExactlyInAnyOrder(RECORD1, RECORD2);
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestQueryWhereBetween.java

@@ -0,0 +1,99 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.sql.Timestamp;
+
+public class TestQueryWhereBetween extends BaseTestCase {
+
+  long statCount;
+  long statTotal;
+
+  @Test
+  public void testCountOrderBy() {
+
+    ResetBasicData.reset();
+
+    Timestamp t = new Timestamp(System.currentTimeMillis());
+
+    Query<Order> query = Ebean.find(Order.class).setAutoTune(false).where()
+      .betweenProperties("cretime", "updtime", t).order().asc("orderDate").order().desc("id");
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    Assert.assertTrue(sql.contains("between t0.cretime and t0.updtime"));
+  }
+
+  @Ignore
+  @Test
+  public void doStuff() {
+
+    someLoop(3, true);
+
+    int loop = 30000;
+    someLoop(loop, true);
+    someLoop(loop, true);
+    someLoop(loop, true);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+    someLoop(loop);
+
+    long avg = statTotal / statCount;
+    System.out.println("avg "+avg);
+  }
+
+  private void someLoop(int loop) {
+    someLoop(loop, false);
+  }
+  private void someLoop(int loop, boolean warm) {
+
+    long start = System.currentTimeMillis();
+    for (int i = 0; i < loop; i++) {
+      someQuery();
+    }
+
+    long exe = System.currentTimeMillis() - start;
+    System.out.println("exe: "+exe);
+
+    if (!warm) {
+      statTotal += exe;
+      statCount++;
+    }
+  }
+
+  private void someQuery() {
+
+    Timestamp t = new Timestamp(System.currentTimeMillis());
+
+    Query<Order> query = Ebean.find(Order.class).setAutoTune(false)
+      .where()
+      .le("cretime", t)
+      .order().asc("orderDate")
+      .order().desc("id");
+
+    query.findList();
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestQueryWhereInRange.java

@@ -0,0 +1,124 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.Query;
+import org.junit.Test;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestQueryWhereInRange extends BaseTestCase {
+
+  @Test
+  public void inRange() {
+
+    ResetBasicData.reset();
+
+    LocalDate today = LocalDate.now();
+
+    Query<Order> query = DB.find(Order.class)
+      .where().inRange("orderDate", today.minusDays(7), today)
+      .isNotNull("id")
+      .query();
+
+    query.findList();
+
+    assertThat(sqlOf(query)).contains("where (t0.order_date >= ? and t0.order_date < ?) and ");
+  }
+
+  @Test
+  public void eqOrNull() {
+
+    ResetBasicData.reset();
+
+    LocalDate today = LocalDate.now();
+
+    Query<Order> query = DB.find(Order.class)
+      .where().eqOrNull("orderDate", today)
+      .query();
+
+    query.findList();
+
+    assertSql(query).contains("where (t0.order_date = ? or t0.order_date is null)");
+  }
+
+  @Test
+  public void gtOrNull() {
+
+    ResetBasicData.reset();
+
+    LocalDate today = LocalDate.now();
+
+    Query<Order> query = DB.find(Order.class)
+      .where().gtOrNull("orderDate", today)
+      .query();
+
+    query.findList();
+
+    assertSql(query).contains("where (t0.order_date > ? or t0.order_date is null)");
+  }
+
+  @Test
+  public void geOrNull() {
+
+    ResetBasicData.reset();
+    LocalDate today = LocalDate.now();
+
+    Query<Order> query = DB.find(Order.class)
+      .where().geOrNull("orderDate", today)
+      .query();
+
+    query.findList();
+
+    assertSql(query).contains("where (t0.order_date >= ? or t0.order_date is null)");
+  }
+
+  @Test
+  public void ltOrNull() {
+
+    ResetBasicData.reset();
+
+    LocalDate today = LocalDate.now();
+
+    Query<Order> query = DB.find(Order.class)
+      .where().ltOrNull("orderDate", today)
+      .query();
+
+    query.findList();
+    assertSql(query).contains(" where (t0.order_date < ? or t0.order_date is null)");
+  }
+
+  @Test
+  public void leOrNull() {
+
+    ResetBasicData.reset();
+    LocalDate today = LocalDate.now();
+
+    Query<Order> query = DB.find(Order.class)
+      .where().leOrNull("orderDate", today)
+      .query();
+
+    query.findList();
+    assertSql(query).contains(" where (t0.order_date <= ? or t0.order_date is null)");
+  }
+
+  @Test
+  public void inRangeWith() {
+
+    ResetBasicData.reset();
+
+    LocalDate today = LocalDate.now();
+
+    Query<Order> query = DB.find(Order.class)
+      .where().inRangeWith("orderDate", "shipDate", today)
+      .query();
+
+    query.findList();
+
+    assertSql(query).contains("(t0.order_date <= ? and (t0.ship_date > ? or t0.ship_date is null))");
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestQueryWithCache.java

@@ -0,0 +1,73 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheManager;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.core.CacheOptions;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+public class TestQueryWithCache extends BaseTestCase {
+
+  @Test
+  public void testCountryDeploy() {
+
+    ResetBasicData.reset();
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    BeanDescriptor<Country> beanDescriptor = server.getBeanDescriptor(Country.class);
+    CacheOptions cacheOptions = beanDescriptor.getCacheOptions();
+
+    assertNotNull(cacheOptions);
+    assertTrue(cacheOptions.isReadOnly());
+    assertTrue(beanDescriptor.isCacheSharableBeans());
+
+    ServerCacheManager serverCacheManager = server.getServerCacheManager();
+    serverCacheManager.clear(Country.class);
+
+    ServerCache beanCache = serverCacheManager.getBeanCache(Country.class);
+    assertEquals(0, beanCache.size());
+
+    Country nz1 = Ebean.getReference(Country.class, "NZ");
+    assertEquals(0, beanCache.size());
+
+    // has the effect of loading the cache via lazy loading
+    nz1.getName();
+    assertEquals(1, beanCache.size());
+
+    Country nz2 = Ebean.getReference(Country.class, "NZ");
+    Country nz2b = Ebean.getReference(Country.class, "NZ");
+
+    Country nz3 = Ebean.find(Country.class, "NZ");
+
+    Country nz4 = Ebean.find(Country.class).setId("NZ").setAutoTune(false).setUseCache(false)
+      .findOne();
+
+    assertTrue(nz2 == nz2b);
+    assertTrue(nz2 == nz3);
+    assertTrue(nz3 != nz4);
+
+  }
+
+  @Test
+  public void testSkipCache() {
+
+    ResetBasicData.reset();
+
+    Ebean.find(Country.class, "NZ");
+
+    Query<Country> query = Ebean.find(Country.class).setId("NZ").setUseCache(false);
+    query.findOne();
+
+    assertSql(query).isNotNull();
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestReadOnlyPropagation.java

@@ -0,0 +1,92 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.CacheMode;
+import io.ebean.Ebean;
+import io.ebean.bean.BeanCollection;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class TestReadOnlyPropagation extends BaseTestCase {
+
+  @Test
+  public void testReadOnly() {
+
+    ResetBasicData.reset();
+
+    Order order = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .setBeanCacheMode(CacheMode.OFF)
+      .setReadOnly(true)
+      .setId(1)
+      .findOne();
+
+    Assert.assertTrue(Ebean.getBeanState(order).isReadOnly());
+
+
+    Customer customer = order.getCustomer();
+    Assert.assertTrue(Ebean.getBeanState(customer).isReadOnly());
+
+    Address billingAddress = customer.getBillingAddress();
+    Assert.assertTrue(Ebean.getBeanState(billingAddress).isReadOnly());
+
+
+    List<OrderDetail> details = order.getDetails();
+    BeanCollection<?> bc = (BeanCollection<?>) details;
+
+    Assert.assertTrue(bc.isReadOnly());
+    Assert.assertTrue(!bc.isPopulated());
+
+    bc.size();
+    Assert.assertTrue(!bc.isEmpty());
+    Assert.assertTrue(bc.isReadOnly());
+    Assert.assertTrue(bc.isPopulated());
+    try {
+      details.add(new OrderDetail());
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      details.remove(0);
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      Iterator<OrderDetail> it = details.iterator();
+      it.next();
+      it.remove();
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      ListIterator<OrderDetail> it = details.listIterator();
+      it.next();
+      it.remove();
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      List<OrderDetail> subList = details.subList(0, 1);
+      subList.remove(0);
+      Assert.assertTrue(false);
+    } catch (UnsupportedOperationException e) {
+      Assert.assertTrue(true);
+    }
+
+
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java

@@ -0,0 +1,38 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PersistentFile;
+import org.tests.model.basic.PersistentFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestSaveDeleteOneToOne extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+    PersistentFile persistentFile = new PersistentFile("test.txt",
+      new PersistentFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Ebean.delete(persistentFile);
+  }
+
+  @Test
+  public void testCreateLoadDeletePersistentFile() {
+    PersistentFile persistentFile = new PersistentFile("test.txt",
+      new PersistentFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+
+    persistentFile = Ebean.find(PersistentFile.class, persistentFile.getId());
+
+    PersistentFileContent persistentFileContent = persistentFile.getPersistentFileContent();
+
+    Assert.assertNotNull(persistentFileContent);
+
+    Assert.assertNotNull("load byte content", persistentFileContent.getContent());
+
+    Ebean.delete(persistentFile);
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestSaveDeleteOneToOneMultiple extends BaseTestCase {
+
+//	public void testCreateDeletePFile() {
+//		PFile persistentFile = new PFile("test.txt",
+//				new PFileContent("test".getBytes()));
+//
+//		Ebean.save(persistentFile);
+//		Ebean.delete(persistentFile);
+//	}
+
+  @Test
+  public void testCreateLoadDeletePFile() {
+    PFile persistentFile = new PFile("test.txt",
+      new PFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+
+    persistentFile = Ebean.find(PFile.class, persistentFile.getId());
+
+    PFileContent persistentFileContent = persistentFile.getFileContent();
+
+    Assert.assertNotNull(persistentFileContent);
+
+    Assert.assertNotNull("load byte content", persistentFileContent.getContent());
+
+    Ebean.delete(persistentFile);
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestSharedInstancePropagation.java

@@ -0,0 +1,63 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.bean.BeanCollection;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.Product;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class TestSharedInstancePropagation extends BaseTestCase {
+
+
+  /**
+   * Test that the sharedInstance status is propagated on lazy loading.
+   */
+  @Test
+  public void testSharedListNavigate() {
+
+    ResetBasicData.reset();
+
+    Ebean.getServerCacheManager().clearAll();
+
+    Order order = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .setReadOnly(true)
+      .setId(1)
+      .findOne();
+
+
+    assertNotNull(order);
+    assertTrue(Ebean.getBeanState(order).isReadOnly());
+
+    List<OrderDetail> details = order.getDetails();
+    BeanCollection<?> bc = (BeanCollection<?>) details;
+    assertTrue(bc.isReadOnly());
+    assertFalse(bc.isPopulated());
+
+    // lazy load
+    bc.size();
+
+    assertTrue(bc.isPopulated());
+    assertTrue(!bc.isEmpty());
+    OrderDetail detail = details.get(0);
+
+    assertTrue(Ebean.getBeanState(detail).isReadOnly());
+    assertFalse(Ebean.getBeanState(detail).isReference());
+
+    Product product = detail.getProduct();
+
+    assertTrue(Ebean.getBeanState(product).isReadOnly());
+
+    // lazy load
+    product.getName();
+    assertFalse(Ebean.getBeanState(product).isReference());
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestTransient.java

@@ -0,0 +1,99 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.DB;
+import org.junit.Test;
+import org.tests.model.basic.Customer;
+
+import java.sql.Types;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class TestTransient extends BaseTestCase {
+
+  @Test
+  public void testTransient() {
+
+    Customer cnew = new Customer();
+    cnew.setName("testTrans");
+
+    DB.save(cnew);
+    Integer custId = cnew.getId();
+
+    Customer c = DB.find(Customer.class).setId(custId).findOne();
+
+    assertNotNull(c);
+
+    BeanState beanState = DB.getBeanState(c);
+    assertFalse("not new or dirty as transient", beanState.isNewOrDirty());
+
+    c.getLock().tryLock();
+    try {
+      c.setSelected(Boolean.TRUE);
+    } finally {
+      c.getLock().unlock();
+    }
+
+    Boolean selected = c.getSelected();
+    assertNotNull(selected);
+
+    assertFalse("not new or dirty as transient", beanState.isNewOrDirty());
+
+    DB.save(c);
+
+    selected = c.getSelected();
+    assertNotNull(selected);
+
+    c.setName("Modified");
+    assertTrue("dirty now", beanState.isNewOrDirty());
+
+    selected = c.getSelected();
+    assertNotNull(selected);
+
+    DB.save(c);
+    assertFalse("Not dirty after save", beanState.isNewOrDirty());
+
+    selected = c.getSelected();
+    assertNotNull(selected);
+
+    String updateStmt = "update customer set smallnote = 'testTrans2' where id = :id";
+    int rows = DB.createUpdate(Customer.class, updateStmt)
+      .setParameter("id", custId).execute();
+    assertEquals(1, rows);
+    assertEquals("testTrans2", findNote(custId).get());
+
+    rows = DB.createUpdate(Customer.class, "update customer set smallnote = ? where id = ?")
+      .setNull(1, Types.VARCHAR)
+      .setParameter(2, custId).execute();
+    assertEquals(1, rows);
+    assertThat(findNote(custId)).isEmpty();
+
+    rows = DB.createUpdate(Customer.class, "update customer set smallnote = ? where id = ?")
+      .setParameter(1, "Foo")
+      .setParameter(2, custId).execute();
+    assertEquals(1, rows);
+    assertEquals("Foo", findNote(custId).get());
+
+    rows = DB.createUpdate(Customer.class, "update customer set smallnote = :name where id = :id")
+      .setNullParameter("name", Types.VARCHAR)
+      .setParameter("id", custId).execute();
+    assertEquals(1, rows);
+    assertThat(findNote(custId)).isEmpty();
+
+    // cleanup
+    DB.delete(Customer.class, custId);
+  }
+
+  private Optional<String> findNote(Integer custId) {
+    return DB.sqlQuery("select smallnote from o_customer where id = ?")
+        .setParameter(custId)
+        .mapToScalar(String.class).findOneOrEmpty();
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestUpdateManyToOne.java

@@ -0,0 +1,40 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestUpdateManyToOne extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    List<Customer> custs = Ebean.find(Customer.class).findList();
+
+    List<Order> orders = Ebean.find(Order.class).setMaxRows(1).findList();
+
+    Order order = orders.get(0);
+    Customer customer = order.getCustomer();
+
+    Customer changeCust = null;
+    for (Customer c : custs) {
+      if (!customer.getId().equals(c.getId())) {
+        changeCust = c;
+        break;
+      }
+    }
+    order.setCustomer(changeCust);
+    Ebean.save(order);
+
+    order.setCustomer(customer);
+    Ebean.save(order);
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestUuidInsert.java

@@ -0,0 +1,25 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TUuidEntity;
+import org.junit.Test;
+
+public class TestUuidInsert extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TUuidEntity e = new TUuidEntity();
+    e.setName("bana");
+
+    Ebean.save(e);
+
+    TUuidEntity e2 = Ebean.find(TUuidEntity.class, e.getId());
+    e2.setName("apple");
+
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+}

ebean-core/src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java

@@ -0,0 +1,44 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.UUOne;
+import org.tests.model.basic.UUTwo;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class TestUuidInsertMasterDetail extends BaseTestCase {
+
+  @Test
+  public void testInsert() {
+
+    UUTwo two = new UUTwo();
+    two.setName("something");
+
+    ArrayList<UUTwo> list = new ArrayList<>();
+    list.add(two);
+
+    UUOne one = new UUOne();
+    one.setName("some one");
+    one.setComments(list);
+
+    Ebean.save(one);
+
+    UUOne oneB = Ebean.find(UUOne.class, one.getId());
+
+    UUTwo twoB = new UUTwo();
+    twoB.setName("another something");
+    oneB.getComments().add(twoB);
+
+    Ebean.save(oneB);
+  }
+
+  public void testNullFK() {
+
+    UUTwo two = new UUTwo();
+    two.setName("something");
+    Ebean.save(two);
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/TestWhereAnnotation.java

@@ -0,0 +1,36 @@
+package org.tests.basic;
+
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.TransactionalTestCase;
+
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestWhereAnnotation extends TransactionalTestCase {
+
+  @Test
+  public void testWhere() {
+
+    Customer custTest = ResetBasicData.createCustAndOrder("testWhereAnn");
+
+    Customer customer = Ebean.find(Customer.class, custTest.getId());
+    List<Order> orders = customer.getOrders();
+
+    Assert.assertTrue(!orders.isEmpty());
+
+    Query<Customer> q1 = Ebean.find(Customer.class).setUseCache(false).fetch("orders").where()
+      .idEq(1).query();
+
+    q1.findOne();
+    String s1 = q1.getGeneratedSql();
+    assertThat(s1).contains("t1.order_date is not null");
+  }
+}

ebean-core/src/test/java/org/tests/basic/delete/TestDeleteByIdList.java

@@ -0,0 +1,40 @@
+package org.tests.basic.delete;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestDeleteByIdList extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    OrderDetail dummy = Ebean.getReference(OrderDetail.class, 1);
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    server.getBeanDescriptor(OrderDetail.class).cacheBeanPut(dummy);
+
+    Customer c0 = ResetBasicData.createCustAndOrder("DelIdList-0");
+    Assert.assertNotNull(c0);
+
+    Customer c1 = ResetBasicData.createCustAndOrder("DelIdList-1");
+
+    List<Object> orderIds = Ebean.find(Order.class).where().in("customer", c0, c1).findIds();
+
+    Assert.assertEquals(2, orderIds.size());
+
+    Ebean.deleteAll(Order.class, orderIds);
+    Ebean.delete(c0);
+    Ebean.delete(c1);
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java

@@ -0,0 +1,40 @@
+package org.tests.basic.delete;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestDeleteCascadeById extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    OrderDetail dummy = Ebean.getReference(OrderDetail.class, 1);
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    server.getBeanDescriptor(OrderDetail.class).cacheBeanPut(dummy);
+
+    Customer cust = ResetBasicData.createCustAndOrder("DelCas");
+    Assert.assertNotNull(cust);
+
+    List<Order> orders = Ebean.find(Order.class).where().eq("customer", cust).findList();
+
+    Assert.assertEquals(1, orders.size());
+    Order o = orders.get(0);
+    Assert.assertNotNull(o);
+
+    // cleanup
+    Ebean.delete(o);
+    Ebean.delete(cust);
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/delete/TestDeleteCascadeByQuery.java

@@ -0,0 +1,76 @@
+package org.tests.basic.delete;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import org.tests.model.onetoone.OtoUser;
+import org.tests.model.onetoone.OtoUserOptional;
+
+public class TestDeleteCascadeByQuery extends BaseTestCase {
+  
+  private OtoUser testUser;
+  private OtoUserOptional userOptional;
+  private Query<OtoUserOptional> userOptionalQuery = Ebean.find(OtoUserOptional.class);
+  private Query<OtoUser> userQuery = Ebean.find(OtoUser.class);
+  
+  /**
+   * Init each test. Delete all existing beans. Then create OtoUser, add OtoUserOptional and save.
+   */
+  @Before
+  public void init() {
+    Ebean.deleteAll(userQuery.findList());
+    Ebean.deleteAll(userOptionalQuery.findList());
+    
+    userOptional = new OtoUserOptional();
+    Ebean.save(userOptional);
+    testUser = new OtoUser();
+    testUser.setOptional(userOptional);
+    Ebean.save(testUser);
+  }
+  
+  /**
+   * Test that validates deleting a bean using Ebean.delete() respects the CascadeType.DELETE 
+   * setting.
+   */
+  @Test
+  public void testDeleteCascadeByEbeanDelete() {
+
+    assertThat(Ebean.delete(testUser)).isTrue();
+
+    assertThat(userOptionalQuery.findCount())
+      .overridingErrorMessage("Entity OtoUserOptional found. Ebean.delete() on the user "
+          + "did not delete the OneToOne mapped entity as set with CascadeType.ALL")
+      .isEqualTo(0);
+  }
+  
+  /**
+   * Test that validates deleting a bean with OneToOne mapping with a query respects the 
+   * CascadeType.DELETE setting.
+   */
+  @Test
+  public void testDeleteCascadeByQuery() {
+    
+    assertThat(userQuery.delete()).isEqualTo(1);
+
+    assertThat(userOptionalQuery.findCount())
+      .overridingErrorMessage("Entity OtoUserOptional found. Ebean query delete() on the user "
+          + "did not delete the OneToOne mapped entity as set with CascadeType.ALL")
+      .isEqualTo(0);
+  }
+  
+  /**
+   * Cleanup - Delete all existing beans for the next test.
+   */
+  @After
+  public void cleanup() {
+    Ebean.deleteAll(userQuery.findList());
+    Ebean.deleteAll(userOptionalQuery.findList());
+  }
+}

ebean-core/src/test/java/org/tests/basic/encrypt/BasicEncryptKey.java

@@ -0,0 +1,19 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.config.EncryptKey;
+
+public class BasicEncryptKey implements EncryptKey {
+
+  private final String key;
+
+  public BasicEncryptKey(String key) {
+    this.key = key;
+  }
+
+  @Override
+  public String getStringValue() {
+    return key;
+  }
+
+
+}

ebean-core/src/test/java/org/tests/basic/encrypt/BasicEncyptKeyManager.java

@@ -0,0 +1,22 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.config.EncryptKey;
+import io.ebean.config.EncryptKeyManager;
+
+public class BasicEncyptKeyManager implements EncryptKeyManager {
+
+  /**
+   * Initialise the key manager.
+   */
+  @Override
+  public void initialise() {
+
+  }
+
+  @Override
+  public EncryptKey getEncryptKey(String tableName, String columnName) {
+    // Must be 16 Chars for Oracle function
+    return new BasicEncryptKey("simple0123456789");
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/encrypt/TestEncrypt.java

@@ -0,0 +1,156 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.SqlRow;
+import io.ebean.annotation.ForPlatform;
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.DbEncrypt;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+import org.tests.model.basic.EBasicEncrypt;
+import org.tests.model.basic.EBasicEncryptRelate;
+
+import java.sql.Date;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class TestEncrypt extends BaseTestCase {
+
+
+  @Test
+  @ForPlatform(Platform.H2) // only run this on H2 - PGCrypto not happy on CI server
+  public void testQueryBind() {
+
+    LoggedSqlCollector.start();
+    DB.find(EBasicEncrypt.class)
+      .where().startsWith("description", "Rob")
+      .findList();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    assertThat(loggedSql).hasSize(1);
+    assertThat(loggedSql.get(0)).contains("; --bind(****,Rob%)");
+  }
+
+  @Test
+  @ForPlatform(Platform.H2) // only run this on H2 - PGCrypto not happy on CI server
+  public void testQueryJoin() {
+
+    LoggedSqlCollector.start();
+
+    DB.find(EBasicEncryptRelate.class)
+      .where().eq("other.description", "foo")
+      .findList();
+
+    DB.find(EBasicEncryptRelate.class)
+      .where().eq("other.description", "foo")
+      .findCount();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    assertThat(loggedSql).hasSize(2);
+    assertThat(loggedSql.get(0)).contains("left join e_basicenc t1 on t1.id = t0.other_id");
+    assertThat(loggedSql.get(1)).contains("left join e_basicenc t1 on t1.id = t0.other_id");
+  }
+
+  @Test
+  public void asDto() {
+    DB.find(EBasicEncrypt.class).delete();
+
+    EBasicEncrypt e = new EBasicEncrypt();
+    e.setName("name2");
+    e.setDescription("descEncrypted2");
+    e.setDob(new Date(System.currentTimeMillis() - 100000));
+
+    DB.save(e);
+
+    final EDto dto = DB.find(EBasicEncrypt.class)
+      .select("name, description")
+      .asDto(EDto.class)
+      .findOne();
+
+    assertThat(dto).isNotNull();
+    assertThat(dto.getName()).isEqualTo("name2");
+    assertThat(dto.getDescription()).isEqualTo("descEncrypted2");
+  }
+
+  public static class EDto {
+    String name;
+    String description;
+    public EDto(){
+    }
+    public String getName() {
+      return name;
+    }
+
+    public void setName(String name) {
+      this.name = name;
+    }
+
+    public String getDescription() {
+      return description;
+    }
+
+    public void setDescription(String description) {
+      this.description = description;
+    }
+  }
+
+  @Test
+  @ForPlatform(Platform.H2)
+  public void test() {
+
+    DB.find(EBasicEncrypt.class).delete();
+
+    EBasicEncrypt e = new EBasicEncrypt();
+    e.setName("testname");
+    e.setDescription("testdesc");
+    e.setDob(new Date(System.currentTimeMillis() - 100000));
+
+    DB.save(e);
+
+    SqlRow row = DB.sqlQuery("select * from e_basicenc where id = :id")
+      .setParameter("id", e.getId())
+      .findOne();
+
+    row.getString("name");
+    row.get("description");
+
+    EBasicEncrypt e1 = DB.find(EBasicEncrypt.class, e.getId());
+
+    e1.getDescription();
+
+    e1.setName("testmod");
+    e1.setDescription("moddesc");
+    e1.setStatus(EBasicEncrypt.Status.ONE);
+
+    DB.save(e1);
+
+    EBasicEncrypt e2 = DB.find(EBasicEncrypt.class, e.getId());
+
+    assertEquals("moddesc", e2.getDescription());
+    assertEquals(EBasicEncrypt.Status.ONE, e2.getStatus());
+
+    SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
+    DbEncrypt dbEncrypt = server.getDatabasePlatform().getDbEncrypt();
+
+    if (dbEncrypt == null) {
+      // can not test the where clause
+      System.out.println("TestEncrypt: Not testing where clause as no DbEncrypt");
+
+    } else {
+
+      List<EBasicEncrypt> list = DB.find(EBasicEncrypt.class).where()
+        .eq("description", "moddesc").findList();
+
+      assertEquals(1, list.size());
+
+      list = DB.find(EBasicEncrypt.class).where().startsWith("description", "modde").findList();
+
+      assertEquals(1, list.size());
+    }
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java

@@ -0,0 +1,52 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.SqlRow;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.EBasicEncryptBinary;
+
+import java.sql.Timestamp;
+
+public class TestEncryptBinary extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Timestamp t0 = new Timestamp(System.currentTimeMillis());
+    EBasicEncryptBinary e = new EBasicEncryptBinary();
+    e.setName("test1");
+    e.setDescription("testdesc1");
+    e.setSomeTime(t0);
+    e.setData("HelloWorld".getBytes());
+
+    DB.save(e);
+
+    SqlRow row = DB.createSqlQuery("select * from e_basicenc_bin where id = :id")
+      .setParameter("id", e.getId())
+      .findOne();
+
+    row.getString("name");
+    row.get("data");
+    row.get("some_time");
+
+    EBasicEncryptBinary e1 = DB.find(EBasicEncryptBinary.class, e.getId());
+
+    Timestamp t1 = e1.getSomeTime();
+    e1.getData();
+
+    e1.getDescription();
+
+    Assert.assertEquals(t0, t1);
+
+    e1.setName("testmod");
+    e1.setDescription("moddesc");
+
+    DB.save(e1);
+
+    EBasicEncryptBinary e2 = DB.find(EBasicEncryptBinary.class, e.getId());
+    e2.getDescription();
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/encrypt/TestEncryptClientSide.java

@@ -0,0 +1,55 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Test;
+import org.tests.model.basic.EBasicEncryptClient;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestEncryptClientSide extends BaseTestCase {
+
+  @Test
+  public void insertUpdate() {
+
+    LocalDate today = LocalDate.now();
+
+    EBasicEncryptClient bean = new EBasicEncryptClient();
+    bean.setDescription("hello");
+    bean.setStatus(EBasicEncryptClient.Status.ONE);
+    bean.setDob(today);
+
+    Ebean.save(bean);
+
+    EBasicEncryptClient found = Ebean.find(EBasicEncryptClient.class)
+      .where()
+      .eq("description", "hello")
+      .eq("status", EBasicEncryptClient.Status.ONE)
+      .eq("dob", today)
+      .findOne();
+
+    assertThat(found).isNotNull();
+    assertThat(found.getDescription()).isEqualTo("hello");
+    assertThat(found.getStatus()).isEqualTo(EBasicEncryptClient.Status.ONE);
+    assertThat(found.getDob()).isEqualTo(today);
+
+
+    found.setDescription("goodbye");
+    found.setStatus(EBasicEncryptClient.Status.TWO);
+    Ebean.save(found);
+
+    found = Ebean.find(EBasicEncryptClient.class)
+      .where()
+      .eq("description", "goodbye")
+      .eq("status", EBasicEncryptClient.Status.TWO)
+      .eq("dob", today)
+      .findOne();
+
+    assertThat(found).isNotNull();
+    assertThat(found.getDescription()).isEqualTo("goodbye");
+
+    Ebean.delete(found);
+  }
+}

ebean-core/src/test/java/org/tests/basic/event/TestPreInsertValidation.java

@@ -0,0 +1,49 @@
+package org.tests.basic.event;
+
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TWithPreInsert;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestPreInsertValidation extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TWithPreInsert e = new TWithPreInsert();
+    e.setTitle("Mister");
+    // the perInsert should populate the
+    // name with should not be null
+    Ebean.save(e);
+
+    // the save worked and name set in preInsert
+    Assert.assertNotNull(e.getId());
+    Assert.assertNotNull(e.getName());
+
+    TWithPreInsert e1 = Ebean.find(TWithPreInsert.class, e.getId());
+
+    e1.setTitle("Missus");
+    Ebean.save(e1);
+  }
+
+  @Test
+  public void testStatelessUpdate() {
+
+    TWithPreInsert e = new TWithPreInsert();
+    e.setName("BeanForUpdateTest");
+    Ebean.save(e);
+
+    TWithPreInsert bean2 = new TWithPreInsert();
+    bean2.setId(e.getId());
+    bean2.setName("stateless-update-name");
+    bean2.setTitle(null);
+
+    Ebean.update(bean2);
+
+    // title set on preUpdate
+    Assert.assertNotNull(bean2.getTitle());
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/event/TestQueryAdapter.java

@@ -0,0 +1,56 @@
+package org.tests.basic.event;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.QueryType;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+import org.tests.model.basic.ResetBasicData;
+import org.tests.model.basic.TOne;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestQueryAdapter extends BaseTestCase {
+
+  @Test
+  public void testSimple() {
+
+    ResetBasicData.reset();
+
+    TOne o = new TOne();
+    o.setName("something");
+
+    Ebean.save(o);
+
+    Query<TOne> queryFindId = Ebean.find(TOne.class).setId(o.getId());
+
+    TOne one = queryFindId.findOne();
+
+    assertThat(one.getId()).isEqualTo(o.getId());
+    assertThat(sqlOf(queryFindId)).contains(" 1=1");
+
+    Query<TOne> notUsedQuery = Ebean.find(TOne.class);
+    assertThat(notUsedQuery.getQueryType()).isEqualTo(QueryType.FIND);
+
+    LoggedSqlCollector.start();
+
+    Ebean.update(TOne.class)
+      .set("name", "mod")
+      .where().idEq(o.getId())
+      .update();
+
+    List<String> sql = LoggedSqlCollector.current();
+    assertSql(sql.get(0)).contains(" 2=2");
+
+    Ebean.find(TOne.class)
+      .where().idEq(o.getId())
+      .delete();
+
+    sql = LoggedSqlCollector.stop();
+    assertSql(sql.get(0)).contains(" 3=3");
+
+  }
+}

ebean-core/src/test/java/org/tests/basic/join/TestSecondaryJoin.java

@@ -0,0 +1,32 @@
+package org.tests.basic.join;
+
+import io.ebean.Ebean;
+import io.ebean.TransactionalTestCase;
+
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestSecondaryJoin extends TransactionalTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    List<Order> list = Ebean.find(Order.class)
+      // .select("*")
+      // .join("customer")
+      .findList();
+
+    Order o0 = list.get(0);
+    o0.setCustomerName("Banan");
+    o0.setStatus(Status.APPROVED);
+
+    Ebean.save(o0);
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java

@@ -0,0 +1,82 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import org.tests.model.basic.EBasicClobFetchEager;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestBasicClobFetchEager extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicClobFetchEager entity = new EBasicClobFetchEager();
+    entity.setName("test");
+    entity.setDescription("initialClobValue");
+    EbeanServer server = Ebean.getServer(null);
+    server.save(entity);
+
+
+    String expectedSql = "select t0.id, t0.name, t0.title, t0.description, t0.last_update from ebasic_clob_fetch_eager t0 where t0.id = ?";
+
+    // Clob included in fetch as FetchType.EAGER set by annotation
+    Query<EBasicClobFetchEager> defaultQuery = Ebean.find(EBasicClobFetchEager.class).setId(entity.getId());
+    defaultQuery.findOne();
+    String sql = trimSql(defaultQuery.getGeneratedSql(), 6);
+
+    assertThat(sql).contains(expectedSql);
+
+
+    LoggedSqlCollector.start();
+
+    // Same as previous query - clob included by default based on annotation
+    Ebean.find(EBasicClobFetchEager.class, entity.getId());
+
+    // Assert query same as previous ...
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+    assertThat(trimSql(loggedSql.get(0), 6)).contains(expectedSql);
+
+
+    // Explicitly select * including Clob
+    Query<EBasicClobFetchEager> explicitQuery = Ebean.find(EBasicClobFetchEager.class).setId(entity.getId()).select("*");
+
+    explicitQuery.findOne();
+    sql = sqlOf(explicitQuery, 6);
+
+    assertThat(sql).contains(expectedSql);
+
+    // Update description to test refresh
+
+    EBasicClobFetchEager updateBean = new EBasicClobFetchEager();
+    updateBean.setId(entity.getId());
+    updateBean.setDescription("modified");
+    Ebean.update(updateBean);
+
+
+    // Test refresh function
+
+    Assert.assertEquals("initialClobValue", entity.getDescription());
+
+    LoggedSqlCollector.start();
+
+    // Refresh query includes all properties
+    server.refresh(entity);
+
+    // Assert all properties fetched in refresh
+    loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+    assertThat(trimSql(loggedSql.get(0), 6)).contains(expectedSql);
+    Assert.assertEquals("modified", entity.getDescription());
+
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java

@@ -0,0 +1,73 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import org.tests.model.basic.EBasicClobNoVer;
+import org.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestBasicClobNoVer extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicClobNoVer entity = new EBasicClobNoVer();
+    entity.setName("test");
+    entity.setDescription("initialClobValue");
+    EbeanServer server = Ebean.getServer(null);
+    server.save(entity);
+
+
+    String sqlNoClob = "select t0.id, t0.name from ebasic_clob_no_ver t0 where t0.id = ?";
+    String sqlWithClob = "select t0.id, t0.name, t0.description from ebasic_clob_no_ver t0 where t0.id = ?";
+
+
+    // Clob by default is Fetch Lazy
+    Query<EBasicClobNoVer> defaultQuery = Ebean.find(EBasicClobNoVer.class).setId(entity.getId());
+    defaultQuery.findOne();
+    String sql = sqlOf(defaultQuery, 2);
+
+    Assert.assertTrue("Clob is fetch lazy by default", sql.contains(sqlNoClob));
+
+
+    // Explicitly select * including Clob
+    Query<EBasicClobNoVer> explicitQuery = Ebean.find(EBasicClobNoVer.class).setId(entity.getId()).select("*");
+
+    explicitQuery.findOne();
+    sql = sqlOf(explicitQuery, 2);
+
+    Assert.assertTrue("Explicitly include Clob", sql.contains(sqlWithClob));
+
+    // Update description to test refresh
+
+    EBasicClobNoVer updateBean = new EBasicClobNoVer();
+    updateBean.setId(entity.getId());
+    updateBean.setDescription("modified");
+    Ebean.update(updateBean);
+
+
+    // Test refresh function
+
+    Assert.assertEquals("initialClobValue", entity.getDescription());
+
+    LoggedSqlCollector.start();
+
+    // Refresh query includes all properties
+    server.refresh(entity);
+
+    // Assert all properties fetched in refresh
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+    assertThat(trimSql(loggedSql.get(0), 2)).contains(sqlWithClob);
+    Assert.assertEquals("modified", entity.getDescription());
+
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/lob/TestByteOnly.java

@@ -0,0 +1,27 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TBytesOnly;
+import org.junit.Test;
+
+public class TestByteOnly extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    byte[] content = new byte[]{1, 1};
+    TBytesOnly e = new TBytesOnly();
+    e.setContent(content);
+
+    Ebean.save(e);
+
+    byte[] content2 = new byte[]{1, 1};
+
+    TBytesOnly e2 = Ebean.find(TBytesOnly.class, e.getId());
+    e2.setContent(content2);
+
+    Ebean.save(e2);
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/one2one/Booking.java

@@ -0,0 +1,92 @@
+package org.tests.basic.one2one;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.OneToMany;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import javax.persistence.Version;
+import java.util.List;
+
+@Entity
+@Table(name = "drel_booking")
+public class Booking {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Column(unique = true)
+  Long bookingUid;
+
+  @Version
+  private int version;
+
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "agent_invoice")
+  private Invoice agentInvoice;
+
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "client_invoice")
+  private Invoice clientInvoice;
+
+  @OneToMany(mappedBy = "booking")
+  private List<Invoice> invoices;
+
+  public Booking(Long bookingUid) {
+    this.bookingUid = bookingUid;
+  }
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public Long getBookingUid() {
+    return bookingUid;
+  }
+
+  public void setBookingUid(Long bookingUid) {
+    this.bookingUid = bookingUid;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Invoice getAgentInvoice() {
+    return agentInvoice;
+  }
+
+  public void setAgentInvoice(Invoice agentInvoice) {
+    this.agentInvoice = agentInvoice;
+  }
+
+  public Invoice getClientInvoice() {
+    return clientInvoice;
+  }
+
+  public void setClientInvoice(Invoice clientInvoice) {
+    this.clientInvoice = clientInvoice;
+  }
+
+  public List<Invoice> getInvoices() {
+    return invoices;
+  }
+
+  public void setInvoices(List<Invoice> invoices) {
+    this.invoices = invoices;
+  }
+}

ebean-core/src/test/java/org/tests/basic/one2one/Invoice.java

@@ -0,0 +1,51 @@
+package org.tests.basic.one2one;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.Table;
+import javax.persistence.Version;
+
+@Entity
+@Table(name = "drel_invoice")
+public class Invoice {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Version
+  private int version;
+
+  @ManyToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "booking")//_xid", referencedColumnName = "booking_uid")
+  private Booking booking;
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Booking getBooking() {
+    return booking;
+  }
+
+  public void setBooking(Booking booking) {
+    this.booking = booking;
+  }
+}

ebean-core/src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java

@@ -0,0 +1,54 @@
+package org.tests.basic.one2one;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+
+public class TestOne2OneBookingInvoice extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Booking b = new Booking(3000L);
+    Invoice ai = new Invoice();
+    Invoice ci = new Invoice();
+
+    ai.setBooking(b);
+    ci.setBooking(b);
+
+    b.setAgentInvoice(ai);
+    b.setClientInvoice(ci);
+
+    Ebean.save(b);
+
+    Invoice invoice = Ebean.find(Invoice.class, ai.getId());
+    assertEquals(b.getId(), invoice.getBooking().getId());
+
+    Booking b1 = Ebean.find(Booking.class, b.getId());
+
+    Invoice ai1 = b1.getAgentInvoice();
+    assertNotNull(ai1);
+
+    Booking b2 = ai1.getBooking();
+    assertNotNull(b2);
+    assertEquals(b1.getId(), b2.getId());
+    assertSame(b1, b2);
+
+    Invoice ci1 = b1.getClientInvoice();
+    Booking b3 = ci1.getBooking();
+    assertNotNull(b3);
+    assertEquals(b1.getId(), b2.getId());
+    assertSame(b1, b2);
+
+    // cleanup
+    ai.setBooking(null);
+    ci.setBooking(null);
+    Ebean.save(ai);
+    Ebean.save(ci);
+    Ebean.delete(b);
+  }
+}

ebean-core/src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java

@@ -0,0 +1,22 @@
+package org.tests.basic.one2one;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Test;
+
+public class TestOneToOneWheelTire extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Wheel w = new Wheel();
+    Tire t = new Tire();
+    t.setWheel(w);
+    w.setTire(t);
+
+    Ebean.save(t);
+
+    Ebean.delete(t);
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/one2one/Tire.java

@@ -0,0 +1,52 @@
+package org.tests.basic.one2one;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import javax.persistence.Version;
+
+@Entity
+@Table(name = "tire")
+public class Tire {
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+  @Version
+  private int version;
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "wheel")
+  private Wheel wheel;
+
+  public Tire() {
+    super();
+  }
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Wheel getWheel() {
+    return wheel;
+  }
+
+  public void setWheel(Wheel wheel) {
+    this.wheel = wheel;
+  }
+}

ebean-core/src/test/java/org/tests/basic/one2one/Wheel.java

@@ -0,0 +1,52 @@
+package org.tests.basic.one2one;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import javax.persistence.Version;
+
+@Entity
+@Table(name = "wheel")
+public class Wheel {
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Version
+  private int version;
+
+  @OneToOne(mappedBy = "wheel", cascade = CascadeType.PERSIST)
+  private Tire tire;
+
+  public Long getId() {
+    return id;
+  }
+
+  public Wheel() {
+    super();
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Tire getTire() {
+    return tire;
+  }
+
+  public void setTire(Tire tire) {
+    this.tire = tire;
+  }
+}

ebean-core/src/test/java/org/tests/basic/type/BSimpleWithGen.java

@@ -0,0 +1,48 @@
+package org.tests.basic.type;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Transient;
+import java.util.List;
+import java.util.Map;
+
+@Entity
+public class BSimpleWithGen {
+
+  @Id
+  private Integer id;
+
+  private String name;
+
+  @Transient
+  private Map<String, List<String>> someMap;
+
+  public BSimpleWithGen(String name) {
+    this.name = name;
+  }
+
+  public Integer getId() {
+    return id;
+  }
+
+  public void setId(Integer id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public Map<String, List<String>> getSomeMap() {
+    return someMap;
+  }
+
+  public void setSomeMap(Map<String, List<String>> someMap) {
+    this.someMap = someMap;
+  }
+
+}

ebean-core/src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java

@@ -0,0 +1,100 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.DB;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import org.junit.Assert;
+import org.junit.Test;
+import org.tests.model.basic.EBasic;
+import org.tests.model.basic.EBasic.Status;
+import org.tests.model.basic.EBasicEnumId;
+import org.tests.model.basic.EBasicEnumInt;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class TestEnumValueAnnotation extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasic b = new EBasic();
+    b.setName("Banana");
+    b.setStatus(Status.NEW);
+
+    DB.save(b);
+
+    SqlRow sqlRow = DB.sqlQuery("select * from e_basic where id = :id")
+      .setParameter("id", b.getId())
+      .findOne();
+
+    String strStatus = sqlRow.getString("status");
+    assertEquals("N", strStatus);
+
+    EBasic b2 = new EBasic();
+    b2.setName("Apple");
+    b2.setStatus(Status.NEW);
+
+    DB.save(b2);
+
+    EBasic b3 = DB.find(EBasic.class, b2.getId());
+    b3.setName("Orange");
+
+    DB.save(b3);
+  }
+
+  @Test
+  public void testAsId() {
+    EBasicEnumId b = new EBasicEnumId();
+    b.setName("Banana");
+    b.setStatus(EBasicEnumId.Status.NEW);
+
+    DB.save(b);
+
+    SqlQuery q = DB.sqlQuery("select * from e_basic_enum_id where status = :status");
+    q.setParameter("status", b.getStatus());
+
+    SqlRow sqlRow = q.findOne();
+    String strStatus = sqlRow.getString("status");
+
+    assertEquals("N", strStatus);
+
+    try {
+      b = DB.find(EBasicEnumId.class, b.getStatus());
+    } catch (java.lang.IllegalArgumentException iae) {
+      Assert.fail("The use of an enum as id should work : " + iae.getLocalizedMessage());
+    }
+
+    assertEquals(EBasicEnumId.Status.NEW, b.getStatus());
+  }
+
+  @Test
+  public void testDbEnumValueInt() {
+
+    EBasicEnumInt b = new EBasicEnumInt();
+    b.setName("Banana");
+    b.setStatus(EBasicEnumInt.Status.NEW);
+
+    DB.save(b);
+
+    SqlQuery q = DB.sqlQuery("select * from e_basic_eni where id = :id");
+    q.setParameter("id", b.getId());
+
+    Optional<SqlRow> sqlRow = q.findOneOrEmpty();
+    sqlRow.ifPresent(sqlRow1 -> {
+      Integer intStatus = sqlRow1.getInteger("status");
+      assertEquals(Integer.valueOf(1), intStatus);
+    });
+
+
+    EBasicEnumInt b2 = DB.find(EBasicEnumInt.class)
+      .where().eq("id", b.getId())
+      .eq("status", EBasicEnumInt.Status.NEW)
+      .findOne();
+
+    assertNotNull(b2);
+  }
+}

ebean-core/src/test/java/org/tests/basic/type/TestExtraScalarTypes.java

@@ -0,0 +1,48 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.ESomeType;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Currency;
+import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import static org.junit.Assert.assertTrue;
+
+public class TestExtraScalarTypes extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Locale locale = Locale.getDefault();
+    Currency currency = Currency.getInstance(locale);
+    TimeZone tz = TimeZone.getDefault();
+
+    ESomeType e = new ESomeType();
+    e.setLocale(locale);
+    e.setTimeZone(tz);
+    e.setCurrency(currency);
+
+    Ebean.save(e);
+
+    ESomeType e2 = Ebean.find(ESomeType.class).setAutoTune(false).setId(e.getId()).findOne();
+
+    Assert.assertNotNull(e2.getCurrency());
+    Assert.assertNotNull(e2.getLocale());
+    Assert.assertNotNull(e2.getTimeZone());
+
+    List<ESomeType> list = Ebean.find(ESomeType.class)
+      .setAutoTune(false).where()
+      .eq("locale", locale)
+      .eq("timeZone", tz.getID())
+      .eq("currency", currency)
+      .findList();
+
+    assertTrue(!list.isEmpty());
+  }
+
+}