#919 - io.ebean package initial

src/test/java/io/ebeaninternal/api/BindParamsTest.java

@@ -0,0 +1,40 @@
+package io.ebeaninternal.api;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class BindParamsTest {
+
+  @Test
+  public void test_hash() {
+
+    BindParams bindParams = new BindParams();
+
+    List<String> ids = Arrays.asList("1", "2", "3");
+    bindParams.setParameter("ids", ids);
+    BindParams.Param param = bindParams.getParameter("ids");
+    assertEquals(3, param.queryBindCount());
+    assertFalse(bindParams.isSameBindHash());
+
+    List<String> ids2 = Arrays.asList("1", "2", "3", "4");
+    bindParams.setParameter("ids", ids2);
+    assertEquals(4, param.queryBindCount());
+    assertFalse(bindParams.isSameBindHash());
+
+    List<String> ids3 = Arrays.asList("2", "99", "44");
+    bindParams.setParameter("ids", ids3);
+    assertEquals(3, param.queryBindCount());
+    assertFalse(bindParams.isSameBindHash());
+
+
+    List<String> ids4 = Arrays.asList("4545", "3499", "3444");
+    bindParams.setParameter("ids", ids4);
+    assertEquals(3, param.queryBindCount());
+    assertTrue(bindParams.isSameBindHash());
+  }
+
+}

src/test/java/io/ebeaninternal/api/HashQueryPlanBuilderTest.java

@@ -0,0 +1,39 @@
+package io.ebeaninternal.api;
+
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class HashQueryPlanBuilderTest {
+
+  int combine(int v0, int v1) {
+    return new HashQueryPlanBuilder().add(v0).add(v1).build().hashCode();
+  }
+
+  @Test
+  public void test_pair_0_1() {
+    assertThat(combine(0, 31)).isNotEqualTo(combine(1, 0));
+  }
+
+  @Test
+  public void test_pair_0_10_adjust_0() {
+    assertThat(combine(0, 310)).isNotEqualTo(combine(10, 0));
+  }
+
+  @Test
+  public void test_pair_0_10_adjust_10() {
+    assertThat(combine(0, 320)).isNotEqualTo(combine(10, 10));
+  }
+
+  @Test
+  public void test_pair_0_10_adjust_40() {
+    assertThat(combine(0, 350)).isNotEqualTo(combine(10, 40));
+  }
+
+  @Test
+  public void test_pair_0_10_adjust_90() {
+    assertThat(combine(0, 400)).isNotEqualTo(combine(10, 90));
+  }
+
+}

src/test/java/io/ebeaninternal/api/HashQueryPlanTest.java

@@ -0,0 +1,45 @@
+package io.ebeaninternal.api;
+
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class HashQueryPlanTest {
+
+  private HashQueryPlan hqp(String raw, int plan, int bind) {
+    return new HashQueryPlan(raw, plan, bind);
+  }
+
+  private int hc(String raw, int plan, int bind) {
+    return hqp(raw, plan, bind).hashCode();
+  }
+
+  @Test
+  public void testEquals() throws Exception {
+
+    assertThat(hqp("foo", 10, 7)).isEqualTo(hqp("foo", 10, 7));
+    assertThat(hqp("foo", 10, 7)).isNotEqualTo(hqp("foo", 11, 7));
+    assertThat(hqp("foo", 10, 7)).isNotEqualTo(hqp("foo", 9, 7));
+    assertThat(hqp("foo", 10, 7)).isNotEqualTo(hqp("foo", 10, 8));
+    assertThat(hqp("foo", 10, 7)).isNotEqualTo(hqp("foo", 10, 6));
+    assertThat(hqp("foo", 10, 7)).isNotEqualTo(hqp("bar", 10, 6));
+    assertThat(hqp("foo", 10, 7)).isNotEqualTo(hqp(null, 10, 7));
+    assertThat(hqp(null, 10, 7)).isNotEqualTo(hqp("foo", 10, 7));
+    assertThat(hqp(null, 10, 7)).isEqualTo(hqp(null, 10, 7));
+  }
+
+  @Test
+  public void testHashCode() throws Exception {
+
+    assertThat(hc("foo", 10, 7)).isEqualTo(hc("foo", 10, 7));
+    assertThat(hc("foo", 10, 7)).isNotEqualTo(hc("foo", 11, 7));
+    assertThat(hc("foo", 10, 7)).isNotEqualTo(hc("foo", 9, 7));
+    assertThat(hc("foo", 10, 7)).isNotEqualTo(hc("foo", 10, 8));
+    assertThat(hc("foo", 10, 7)).isNotEqualTo(hc("foo", 10, 6));
+    assertThat(hc("foo", 10, 7)).isNotEqualTo(hc("bar", 10, 6));
+    assertThat(hc("foo", 10, 7)).isNotEqualTo(hc(null, 10, 7));
+    assertThat(hc(null, 10, 7)).isNotEqualTo(hc("foo", 10, 7));
+    assertThat(hc(null, 10, 7)).isEqualTo(hc(null, 10, 7));
+  }
+}

src/test/java/io/ebeaninternal/api/TDSpiEbeanServer.java

@@ -0,0 +1,810 @@
+package io.ebeaninternal.api;
+
+import io.ebean.AutoTune;
+import io.ebean.BackgroundExecutor;
+import io.ebean.BeanState;
+import io.ebean.CallableSql;
+import io.ebean.DocumentStore;
+import io.ebean.ExpressionFactory;
+import io.ebean.Filter;
+import io.ebean.FutureIds;
+import io.ebean.FutureList;
+import io.ebean.FutureRowCount;
+import io.ebean.PagedList;
+import io.ebean.PersistenceContextScope;
+import io.ebean.Query;
+import io.ebean.QueryIterator;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import io.ebean.SqlUpdate;
+import io.ebean.Transaction;
+import io.ebean.TransactionCallback;
+import io.ebean.TxCallable;
+import io.ebean.TxRunnable;
+import io.ebean.TxScope;
+import io.ebean.Update;
+import io.ebean.UpdateQuery;
+import io.ebean.ValuePair;
+import io.ebean.Version;
+import io.ebean.bean.BeanCollection;
+import io.ebean.bean.CallStack;
+import io.ebean.bean.EntityBeanIntercept;
+import io.ebean.bean.ObjectGraphNode;
+import io.ebean.cache.ServerCacheManager;
+import io.ebean.config.ServerConfig;
+import io.ebean.config.dbplatform.DatabasePlatform;
+import io.ebean.event.readaudit.ReadAuditLogger;
+import io.ebean.event.readaudit.ReadAuditPrepare;
+import io.ebean.meta.MetaInfoManager;
+import io.ebean.plugin.SpiServer;
+import io.ebean.text.csv.CsvReader;
+import io.ebean.text.json.JsonContext;
+import io.ebeaninternal.server.core.timezone.DataTimeZone;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.query.CQuery;
+import io.ebeaninternal.server.transaction.RemoteTransactionEvent;
+import io.ebean.TxIsolation;
+
+import javax.persistence.OptimisticLockException;
+import javax.persistence.PersistenceException;
+import java.lang.reflect.Type;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+
+/**
+ * Test double for SpiEbeanServer.
+ */
+public class TDSpiEbeanServer implements SpiEbeanServer {
+
+  String name;
+
+  public TDSpiEbeanServer() {
+  }
+
+  public TDSpiEbeanServer(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public void shutdownManaged() {
+
+  }
+
+  @Override
+  public Object currentTenantId() {
+    return null;
+  }
+
+  @Override
+  public DataTimeZone getDataTimeZone() {
+    return null;
+  }
+
+  @Override
+  public SpiServer getPluginApi() {
+    return null;
+  }
+
+  @Override
+  public boolean isCollectQueryOrigins() {
+    return false;
+  }
+
+  @Override
+  public boolean isUpdateAllPropertiesInBatch() {
+    return false;
+  }
+
+  @Override
+  public ServerConfig getServerConfig() {
+    return null;
+  }
+
+  @Override
+  public DatabasePlatform getDatabasePlatform() {
+    return null;
+  }
+
+  @Override
+  public CallStack createCallStack() {
+    return null;
+  }
+
+  @Override
+  public PersistenceContextScope getPersistenceContextScope(SpiQuery<?> query) {
+    return null;
+  }
+
+  @Override
+  public DocumentStore docStore() {
+    return null;
+  }
+
+  @Override
+  public ReadAuditLogger getReadAuditLogger() {
+    return null;
+  }
+
+  @Override
+  public ReadAuditPrepare getReadAuditPrepare() {
+    return null;
+  }
+
+  @Override
+  public void clearQueryStatistics() {
+
+  }
+
+  @Override
+  public BeanDescriptor<?> getBeanDescriptorByQueueId(String queueId) {
+    return null;
+  }
+
+  @Override
+  public List<BeanDescriptor<?>> getBeanDescriptors() {
+    return null;
+  }
+
+  @Override
+  public <T> BeanDescriptor<T> getBeanDescriptor(Class<T> type) {
+    return null;
+  }
+
+  @Override
+  public BeanDescriptor<?> getBeanDescriptorById(String descriptorId) {
+    return null;
+  }
+
+  @Override
+  public List<BeanDescriptor<?>> getBeanDescriptors(String tableName) {
+    return null;
+  }
+
+  @Override
+  public void externalModification(TransactionEventTable event) {
+
+  }
+
+  @Override
+  public SpiTransaction createServerTransaction(boolean isExplicit, int isolationLevel) {
+    return null;
+  }
+
+  @Override
+  public SpiTransaction getCurrentServerTransaction() {
+    return null;
+  }
+
+  @Override
+  public ScopeTrans createScopeTrans(TxScope txScope) {
+    return null;
+  }
+
+  @Override
+  public SpiTransaction createQueryTransaction(Object tenantId) {
+    return null;
+  }
+
+  @Override
+  public void remoteTransactionEvent(RemoteTransactionEvent event) {
+
+  }
+
+  @Override
+  public <T> CQuery<T> compileQuery(Query<T> query, Transaction t) {
+    return null;
+  }
+
+  @Override
+  public <T> int delete(Query<T> query, Transaction t) {
+    return 0;
+  }
+
+  @Override
+  public <T> UpdateQuery<T> update(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> int update(Query<T> query, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public <T> List<Version<T>> findVersions(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <A, T> List<A> findIdsWithCopy(Query<T> query, Transaction t) {
+    return null;
+  }
+
+  @Override
+  public <T> int findRowCountWithCopy(Query<T> query, Transaction t) {
+    return 0;
+  }
+
+  @Override
+  public void loadBean(LoadBeanRequest loadRequest) {
+
+  }
+
+  @Override
+  public void loadMany(LoadManyRequest loadRequest) {
+
+  }
+
+  @Override
+  public int getLazyLoadBatchSize() {
+    return 0;
+  }
+
+  @Override
+  public boolean isSupportedType(Type genericType) {
+    return false;
+  }
+
+  @Override
+  public void collectQueryStats(ObjectGraphNode objectGraphNode, long loadedBeanCount, long timeMicros) {
+
+  }
+
+  @Override
+  public void loadMany(BeanCollection<?> collection, boolean onlyIds) {
+
+  }
+
+  @Override
+  public void loadBean(EntityBeanIntercept ebi) {
+
+  }
+
+  @Override
+  public void shutdown(boolean shutdownDataSource, boolean deregisterDriver) {
+
+  }
+
+  @Override
+  public AutoTune getAutoTune() {
+    return null;
+  }
+
+  @Override
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public ExpressionFactory getExpressionFactory() {
+    return null;
+  }
+
+  @Override
+  public MetaInfoManager getMetaInfoManager() {
+    return null;
+  }
+
+  @Override
+  public BeanState getBeanState(Object bean) {
+    return null;
+  }
+
+  @Override
+  public Object setBeanId(Object bean, Object id) {
+    return id;
+  }
+
+  @Override
+  public Object getBeanId(Object bean) {
+    return null;
+  }
+
+  @Override
+  public Map<String, ValuePair> diff(Object a, Object b) {
+    return null;
+  }
+
+  @Override
+  public <T> T createEntityBean(Class<T> type) {
+    return null;
+  }
+
+  @Override
+  public <T> CsvReader<T> createCsvReader(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> createQuery(Class<T> beanType, String eql) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> createQuery(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> find(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> Query<T> findNative(Class<T> beanType, String nativeSql) {
+    return null;
+  }
+
+  @Override
+  public <T> Set<String> validateQuery(Query<T> query) {
+    return null;
+  }
+
+  @Override
+  public Object nextId(Class<?> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> Filter<T> filter(Class<T> beanType) {
+    return null;
+  }
+
+  @Override
+  public <T> void sort(List<T> list, String sortByClause) {
+
+  }
+
+  @Override
+  public <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) {
+    return null;
+  }
+
+  @Override
+  public SqlQuery createSqlQuery(String sql) {
+    return null;
+  }
+
+  @Override
+  public SqlUpdate createSqlUpdate(String sql) {
+    return null;
+  }
+
+  @Override
+  public CallableSql createCallableSql(String callableSql) {
+    return null;
+  }
+
+  @Override
+  public void register(TransactionCallback transactionCallback) throws PersistenceException {
+
+  }
+
+  @Override
+  public <T> T publish(Class<T> beanType, Object id) {
+    return null;
+  }
+
+  @Override
+  public <T> List<T> publish(Query<T> query) {
+    return null;
+  }
+
+  @Override
+  public <T> T publish(Class<T> beanType, Object id, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> List<T> publish(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> T draftRestore(Class<T> beanType, Object id, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> List<T> draftRestore(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> T draftRestore(Class<T> beanType, Object id) {
+    return null;
+  }
+
+  @Override
+  public <T> List<T> draftRestore(Query<T> query) {
+    return null;
+  }
+
+  @Override
+  public Transaction createTransaction() {
+    return null;
+  }
+
+  @Override
+  public Transaction createTransaction(TxIsolation isolation) {
+    return null;
+  }
+
+  @Override
+  public Transaction beginTransaction() {
+    return null;
+  }
+
+  @Override
+  public Transaction beginTransaction(TxScope scope) {
+    return null;
+  }
+
+  @Override
+  public Transaction beginTransaction(TxIsolation isolation) {
+    return null;
+  }
+
+  @Override
+  public Transaction currentTransaction() {
+    return null;
+  }
+
+  @Override
+  public void commitTransaction() {
+
+  }
+
+  @Override
+  public void rollbackTransaction() {
+
+  }
+
+  @Override
+  public void endTransaction() {
+
+  }
+
+  @Override
+  public void refresh(Object bean) {
+
+  }
+
+  @Override
+  public void refreshMany(Object bean, String propertyName) {
+
+  }
+
+  @Override
+  public <T> T find(Class<T> beanType, Object uid) {
+    return null;
+  }
+
+  @Override
+  public <T> T getReference(Class<T> beanType, Object id) {
+    return null;
+  }
+
+  @Override
+  public <T> int findCount(Query<T> query, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public <A, T> List<A> findIds(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> QueryIterator<T> findIterate(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> void findEach(Query<T> query, Consumer<T> consumer, Transaction transaction) {
+
+  }
+
+  @Override
+  public <T> void findEachWhile(Query<T> query, Predicate<T> consumer, Transaction transaction) {
+
+  }
+
+  @Override
+  public <T> List<T> findList(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> FutureRowCount<T> findFutureCount(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> Set<T> findSet(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <K, T> Map<K, T> findMap(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <A, T> List<A> findSingleAttributeList(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public <T> T findUnique(Query<T> query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public List<SqlRow> findList(SqlQuery query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public void findEach(SqlQuery query, Consumer<SqlRow> consumer, Transaction transaction) {
+  }
+
+  @Override
+  public void findEachWhile(SqlQuery query, Predicate<SqlRow> consumer, Transaction transaction) {
+  }
+
+  @Override
+  public SqlRow findUnique(SqlQuery query, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public void save(Object bean) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public boolean delete(Object bean) throws OptimisticLockException {
+    return false;
+  }
+
+  @Override
+  public int delete(Class<?> beanType, Object id) {
+    return 0;
+  }
+
+  @Override
+  public int delete(Class<?> beanType, Object id, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int deletePermanent(Class<?> beanType, Object id) {
+    return 0;
+  }
+
+  @Override
+  public int deletePermanent(Class<?> beanType, Object id, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int execute(SqlUpdate updSql) {
+    return 0;
+  }
+
+  @Override
+  public int execute(Update<?> update) {
+    return 0;
+  }
+
+  @Override
+  public int execute(Update<?> update, Transaction t) {
+    return 0;
+  }
+
+  @Override
+  public int execute(CallableSql callableSql) {
+    return 0;
+  }
+
+  @Override
+  public void externalModification(String tableName, boolean inserted, boolean updated, boolean deleted) {
+
+  }
+
+  @Override
+  public <T> T find(Class<T> beanType, Object uid, Transaction transaction) {
+    return null;
+  }
+
+  @Override
+  public void save(Object bean, Transaction transaction) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void markAsDirty(Object bean) {
+
+  }
+
+  @Override
+  public void update(Object bean) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void update(Object bean, Transaction t) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void update(Object bean, Transaction transaction, boolean deleteMissingChildren) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void insert(Object bean) {
+
+  }
+
+  @Override
+  public void insert(Object bean, Transaction t) {
+
+  }
+
+  @Override
+  public boolean delete(Object bean, Transaction t) throws OptimisticLockException {
+    return false;
+  }
+
+  @Override
+  public boolean deletePermanent(Object bean) throws OptimisticLockException {
+    return false;
+  }
+
+  @Override
+  public boolean deletePermanent(Object bean, Transaction transaction) throws OptimisticLockException {
+    return false;
+  }
+
+  @Override
+  public int deleteAllPermanent(Collection<?> beans) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int deleteAllPermanent(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int execute(SqlUpdate updSql, Transaction t) {
+    return 0;
+  }
+
+  @Override
+  public int execute(CallableSql callableSql, Transaction t) {
+    return 0;
+  }
+
+  @Override
+  public void execute(TxScope scope, TxRunnable r) {
+
+  }
+
+  @Override
+  public void execute(TxRunnable r) {
+
+  }
+
+  @Override
+  public <T> T execute(TxScope scope, TxCallable<T> c) {
+    return null;
+  }
+
+  @Override
+  public <T> T execute(TxCallable<T> c) {
+    return null;
+  }
+
+  @Override
+  public ServerCacheManager getServerCacheManager() {
+    return null;
+  }
+
+  @Override
+  public BackgroundExecutor getBackgroundExecutor() {
+    return null;
+  }
+
+  @Override
+  public JsonContext json() {
+    return null;
+  }
+
+  @Override
+  public int saveAll(Collection<?> beans) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int deleteAll(Collection<?> beans) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int deleteAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public int deleteAll(Class<?> beanType, Collection<?> ids) {
+    return 0;
+  }
+
+  @Override
+  public int deleteAll(Class<?> beanType, Collection<?> ids, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int deleteAllPermanent(Class<?> beanType, Collection<?> ids) {
+    return 0;
+  }
+
+  @Override
+  public int deleteAllPermanent(Class<?> beanType, Collection<?> ids, Transaction transaction) {
+    return 0;
+  }
+
+  @Override
+  public int saveAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
+    return 0;
+  }
+
+  @Override
+  public void updateAll(Collection<?> beans) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void updateAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
+
+  }
+
+  @Override
+  public void insertAll(Collection<?> beans) {
+
+  }
+
+  @Override
+  public void insertAll(Collection<?> beans, Transaction transaction) {
+
+  }
+}

src/test/java/io/ebeaninternal/extraddl/model/ExtraDdlXmlReaderTest.java

@@ -0,0 +1,47 @@
+package io.ebeaninternal.extraddl.model;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNotNull;
+
+public class ExtraDdlXmlReaderTest {
+
+  @Test
+  public void read() throws Exception {
+
+    ExtraDdl read = ExtraDdlXmlReader.read("/extra-ddl.xml");
+    assertNotNull(read);
+  }
+
+  @Test
+  public void buildExtra_when_h2() {
+
+    String ddl = ExtraDdlXmlReader.buildExtra("h2");
+
+    assertThat(ddl).contains("create or replace view order_agg_vw");
+    assertThat(ddl).contains("-- h2 and postgres script");
+    assertThat(ddl).doesNotContain(" -- oracle only script");
+  }
+
+  @Test
+  public void buildExtra_when_oracle() {
+
+    String ddl = ExtraDdlXmlReader.buildExtra("oracle");
+
+    assertThat(ddl).contains("create or replace view order_agg_vw");
+    assertThat(ddl).doesNotContain("-- h2 and postgres script");
+    assertThat(ddl).contains(" -- oracle only script");
+  }
+
+  @Test
+  public void buildExtra_when_mysql() {
+
+    String ddl = ExtraDdlXmlReader.buildExtra("mysql");
+
+    assertThat(ddl).contains("create or replace view order_agg_vw");
+    assertThat(ddl).doesNotContain("-- h2 and postgres script");
+    assertThat(ddl).doesNotContain(" -- oracle only script");
+  }
+
+}

src/test/java/io/ebeaninternal/server/autotune/service/AutoTuneXmlReaderTest.java

@@ -0,0 +1,31 @@
+package io.ebeaninternal.server.autotune.service;
+
+import io.ebeaninternal.server.autotune.model.Autotune;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.InputStream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AutoTuneXmlReaderTest {
+
+  @Test
+  public void read_file() throws Exception {
+
+    File testFile = new File("src/test/resources/autotune/test-autotune.xml");
+
+    Autotune tuneInfo = AutoTuneXmlReader.read(testFile);
+    assertThat(tuneInfo.getOrigin()).isNotEmpty();
+  }
+
+  @Test
+  public void read_inputStream() throws Exception {
+
+    InputStream is = getClass().getResourceAsStream("/autotune/test-autotune.xml");
+
+    Autotune tuneInfo = AutoTuneXmlReader.read(is);
+    assertThat(tuneInfo.getOrigin()).isNotEmpty();
+  }
+
+}

src/test/java/io/ebeaninternal/server/cache/CacheBeanDataTest.java

@@ -0,0 +1,123 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.BaseTestCase;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.PersistenceContext;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanPropertyAssocOne;
+import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Customer.Status;
+import org.tests.model.embedded.EAddress;
+import org.tests.model.embedded.EPerson;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class CacheBeanDataTest extends BaseTestCase {
+
+  @Test
+  public void extract_load_on_customer() {
+
+    SpiEbeanServer server = spiEbeanServer();
+    BeanDescriptor<Customer> desc = server.getBeanDescriptor(Customer.class);
+
+    Customer c = new Customer();
+    c.setId(98989);
+    c.setName("Rob");
+    c.setCretime(new Timestamp(System.currentTimeMillis()));
+    c.setUpdtime(new Timestamp(System.currentTimeMillis()));
+    c.setStatus(Status.ACTIVE);
+    c.setSmallnote("somenote");
+
+    Address billingAddress = new Address();
+    billingAddress.setId((short) 12);
+    billingAddress.setCity("Auckland");
+    billingAddress.setCountry(server.getReference(Country.class, "NZ"));
+    billingAddress.setLine1("92 Someplace Else");
+    c.setBillingAddress(billingAddress);
+
+    ((EntityBean) c)._ebean_getIntercept().setNewBeanForUpdate();
+
+    CachedBeanData cacheData = CachedBeanDataFromBean.extract(desc, (EntityBean) c);
+
+
+    assertNotNull(cacheData);
+
+    Customer newCustomer = new Customer();
+    newCustomer.setId(c.getId());
+    CachedBeanDataToBean.load(desc, (EntityBean) newCustomer, cacheData, new DefaultPersistenceContext());
+
+    assertEquals(c.getId(), newCustomer.getId());
+    assertEquals(c.getName(), newCustomer.getName());
+    assertEquals(c.getStatus(), newCustomer.getStatus());
+    assertEquals(c.getSmallnote(), newCustomer.getSmallnote());
+    assertEquals(c.getCretime(), newCustomer.getCretime());
+    assertEquals(c.getUpdtime(), newCustomer.getUpdtime());
+    assertEquals(c.getBillingAddress().getId(), newCustomer.getBillingAddress().getId());
+
+    assertNotNull(newCustomer.getId());
+    assertNotNull(newCustomer.getName());
+    assertNotNull(newCustomer.getStatus());
+    assertNotNull(newCustomer.getSmallnote());
+    assertNotNull(newCustomer.getCretime());
+    assertNotNull(newCustomer.getUpdtime());
+    assertNotNull(newCustomer.getBillingAddress());
+    assertNotNull(newCustomer.getBillingAddress().getId());
+
+  }
+
+
+  @Test
+  public void extract_load_withEmbeddedBean() {
+
+    SpiEbeanServer server = spiEbeanServer();
+    BeanDescriptor<EPerson> desc = server.getBeanDescriptor(EPerson.class);
+    BeanPropertyAssocOne<?> addressBeanProperty = (BeanPropertyAssocOne<?>) desc.getBeanProperty("address");
+
+    EAddress address = new EAddress();
+    address.setStreet("92 Someplace Else");
+    address.setSuburb("Sandringham");
+    address.setCity("Auckland");
+
+    EPerson person = new EPerson();
+    person.setId(98989L);
+    person.setName("Rob");
+    person.setAddress(address);
+
+    CachedBeanData addressCacheData = (CachedBeanData) addressBeanProperty.getCacheDataValue((EntityBean) person);
+
+    PersistenceContext context = new DefaultPersistenceContext();
+
+    EPerson newPersonCheck = new EPerson();
+    newPersonCheck.setId(98989L);
+    addressBeanProperty.setCacheDataValue((EntityBean) newPersonCheck, addressCacheData, context);
+
+    EAddress newAddress = newPersonCheck.getAddress();
+    assertEquals(address.getStreet(), newAddress.getStreet());
+    assertEquals(address.getCity(), newAddress.getCity());
+    assertEquals(address.getSuburb(), newAddress.getSuburb());
+
+
+    CachedBeanData cacheData = desc.cacheEmbeddedBeanExtract((EntityBean) person);
+
+    assertNotNull(cacheData);
+
+    EPerson newPerson = (EPerson) desc.cacheEmbeddedBeanLoad(cacheData, context);
+
+    assertNotNull(newPerson.getId());
+    assertNotNull(newPerson.getName());
+    assertNotNull(newPerson.getAddress());
+
+    assertEquals(person.getId(), newPerson.getId());
+    assertEquals(person.getName(), newPerson.getName());
+    assertEquals(person.getAddress().getStreet(), newPerson.getAddress().getStreet());
+    assertEquals(person.getAddress().getCity(), newPerson.getAddress().getCity());
+  }
+}

src/test/java/io/ebeaninternal/server/cache/CachedBeanDataFromBeanTest.java

@@ -0,0 +1,67 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.BaseTestCase;
+import io.ebean.bean.EntityBean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Car;
+import org.tests.model.basic.Customer;
+import org.junit.Test;
+
+import java.sql.Date;
+
+import static org.junit.Assert.assertEquals;
+
+public class CachedBeanDataFromBeanTest extends BaseTestCase {
+
+  SpiEbeanServer server = spiEbeanServer();
+
+  @Test
+  public void extract() throws Exception {
+
+    BeanDescriptor<Customer> desc = server.getBeanDescriptor(Customer.class);
+
+    Date largeDate = new Date(9223372036825200000L);
+
+    Customer customer = new Customer();
+    customer.setId(42);
+    customer.setName("Rob");
+    customer.setAnniversary(largeDate);
+
+    Address billingAddress = new Address();
+    billingAddress.setId(Short.valueOf("12"));
+    billingAddress.setCity("SomePlace");
+
+    customer.setBillingAddress(billingAddress);
+
+    CachedBeanData cacheData = CachedBeanDataFromBean.extract(desc, (EntityBean) customer);
+
+    assertEquals(cacheData.getData("id"), "42");
+    assertEquals(cacheData.getData("name"), "Rob");
+    assertEquals(cacheData.getData("billingAddress"), "12");
+    assertEquals(cacheData.getData("anniversary"), "9223372036825200000");
+  }
+
+
+  @Test
+  public void inheritance() {
+
+    Car car = new Car();
+    car.setId(42);
+    car.setDriver("Jimmy");
+    car.setNotes("some notes");
+
+    BeanDescriptor<Car> carDesc = server.getBeanDescriptor(Car.class);
+    CachedBeanData cacheData = CachedBeanDataFromBean.extract(carDesc, (EntityBean) car);
+
+    Car newCar = new Car();
+    EntityBean entityBean = (EntityBean) newCar;
+    CachedBeanDataToBean.load(carDesc, entityBean, cacheData, new DefaultPersistenceContext());
+
+    assertEquals(newCar.getId(), car.getId());
+    assertEquals(newCar.getDriver(), car.getDriver());
+    assertEquals(newCar.getNotes(), car.getNotes());
+  }
+}

src/test/java/io/ebeaninternal/server/cache/CachedBeanDataSerializeTest.java

@@ -0,0 +1,138 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.bean.EntityBean;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.tests.model.basic.TBytesOnly;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+
+public class CachedBeanDataSerializeTest extends BaseTestCase {
+
+  @Test
+  public void write() throws IOException, ClassNotFoundException {
+
+    Map<String, Object> map = new LinkedHashMap<>();
+    map.put("name", "rob");
+    map.put("some", "thing");
+    map.put("whenCreated", "" + System.currentTimeMillis());
+
+    long version = System.currentTimeMillis();
+    CachedBeanData write = new CachedBeanData(null, "C", map, version);
+
+    ByteArrayOutputStream os = new ByteArrayOutputStream();
+    ObjectOutputStream oos = new ObjectOutputStream(os);
+
+    write.writeExternal(oos);
+    oos.flush();
+    oos.close();
+
+    byte[] bytes = os.toByteArray();
+
+    ByteArrayInputStream is = new ByteArrayInputStream(bytes);
+    ObjectInputStream ois = new ObjectInputStream(is);
+
+    CachedBeanData read = new CachedBeanData();
+    read.readExternal(ois);
+
+    assertEquals(read.getVersion(), write.getVersion());
+    assertEquals(read.getWhenCreated(), write.getWhenCreated());
+    assertEquals(read.getDiscValue(), write.getDiscValue());
+    assertEquals(read.getData(), write.getData());
+  }
+
+
+  @Test
+  public void fullBean() throws IOException, ClassNotFoundException {
+
+    ResetBasicData.reset();
+
+    List<Customer> customers = Ebean.find(Customer.class)
+      .orderBy().asc("id")
+      .setMaxRows(1).findList();
+
+    Customer customer = customers.get(0);
+
+    BeanDescriptor<Customer> desc = getBeanDescriptor(Customer.class);
+    CachedBeanData extract = CachedBeanDataFromBean.extract(desc, (EntityBean) customer);
+
+    ByteArrayOutputStream os = new ByteArrayOutputStream();
+    writeToStream(extract, os);
+
+    byte[] bytes = os.toByteArray();
+
+    CachedBeanData read = readFromStream(bytes);
+
+    assertEquals(read.getData(), extract.getData());
+
+    Customer loadCustomer = new Customer();
+    CachedBeanDataToBean.load(desc, (EntityBean) loadCustomer, read, new DefaultPersistenceContext());
+
+    assertEquals(loadCustomer.getVersion(), customer.getVersion());
+    assertEquals(loadCustomer.getId(), customer.getId());
+    assertEquals(loadCustomer.getName(), customer.getName());
+    assertEquals(loadCustomer.getStatus(), customer.getStatus());
+  }
+
+  @Test
+  public void beanWithByteArray() throws IOException, ClassNotFoundException {
+
+    String stringContent = "ThisIsSome";
+
+    TBytesOnly bean = new TBytesOnly();
+    bean.setId(42);
+    bean.setContent(stringContent.getBytes("UTF-8"));
+
+    BeanDescriptor<TBytesOnly> desc = getBeanDescriptor(TBytesOnly.class);
+    CachedBeanData extract = CachedBeanDataFromBean.extract(desc, (EntityBean) bean);
+
+    ByteArrayOutputStream os = new ByteArrayOutputStream();
+    writeToStream(extract, os);
+    byte[] bytes = os.toByteArray();
+
+    CachedBeanData read = readFromStream(bytes);
+    byte[] extraContent = (byte[]) extract.getData("content");
+
+    assertEquals(stringContent, new String(extraContent));
+    assertTrue(Arrays.equals(bean.getContent(), extraContent));
+
+    TBytesOnly loadBean = new TBytesOnly();
+    CachedBeanDataToBean.load(desc, (EntityBean) loadBean, read, new DefaultPersistenceContext());
+
+    assertEquals(loadBean.getId(), bean.getId());
+    assertTrue(Arrays.equals(loadBean.getContent(), bean.getContent()));
+  }
+
+  private CachedBeanData readFromStream(byte[] bytes) throws IOException, ClassNotFoundException {
+
+    ByteArrayInputStream is = new ByteArrayInputStream(bytes);
+    ObjectInputStream ois = new ObjectInputStream(is);
+    return (CachedBeanData) ois.readObject();
+  }
+
+  private void writeToStream(CachedBeanData extract, ByteArrayOutputStream os) throws IOException {
+
+    ObjectOutputStream oos = new ObjectOutputStream(os);
+    oos.writeObject(extract);
+    oos.flush();
+    oos.close();
+  }
+
+}

src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolderTest.java

@@ -0,0 +1,93 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheFactory;
+import io.ebean.cache.ServerCacheOptions;
+import io.ebean.cache.ServerCacheType;
+import io.ebean.config.CurrentTenantProvider;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.junit.Test;
+
+import java.util.function.Supplier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class DefaultCacheHolderTest {
+
+  private String tenantId;
+
+  private final ServerCacheFactory cacheFactory = new DefaultServerCacheFactory();
+  private final ServerCacheOptions defaultOptions = new ServerCacheOptions();
+
+  @Test
+  public void getCache_normal() throws Exception {
+
+    DefaultCacheHolder holder = new DefaultCacheHolder(cacheFactory, defaultOptions, defaultOptions, null);
+
+    DefaultServerCache cache = cache(holder, Customer.class, "customer");
+    assertThat(cache.getName()).isEqualTo("customer_B");
+
+    DefaultServerCache cache1 = cache(holder, Customer.class, "customer");
+    assertThat(cache1).isSameAs(cache);
+
+    DefaultServerCache cache2 = cache(holder, Contact.class, "contact");
+    assertThat(cache1).isNotSameAs(cache2);
+    assertThat(cache2.getName()).isEqualTo("contact_B");
+  }
+
+  private DefaultServerCache cache(DefaultCacheHolder holder, Class<?> type, String name) {
+    Supplier<ServerCache> cache = holder.getCache(type, name, ServerCacheType.BEAN);
+    return (DefaultServerCache) cache.get();
+  }
+
+  @Test
+  public void getCache_multiTenant() throws Exception {
+
+    DefaultCacheHolder holder = new DefaultCacheHolder(cacheFactory, defaultOptions, defaultOptions, new MyTenantProv());
+
+    tenantId = "ten_1";
+    DefaultServerCache cache = cache(holder, Customer.class, "customer");
+    assertThat(cache.getName()).isEqualTo("customer_ten_1_B");
+
+    tenantId = "ten_2";
+    DefaultServerCache cache2 = cache(holder, Customer.class, "customer");
+    assertThat(cache2).isNotSameAs(cache);
+    assertThat(cache2.getName()).isEqualTo("customer_ten_2_B");
+
+    tenantId = "ten_1";
+    DefaultServerCache cache3 = cache(holder, Customer.class, "customer");
+    assertThat(cache3).isSameAs(cache);
+  }
+
+  @Test
+  public void clearAll() throws Exception {
+    DefaultCacheHolder holder = new DefaultCacheHolder(cacheFactory, defaultOptions, defaultOptions, null);
+    DefaultServerCache cache = cache(holder, Customer.class, "customer");
+    cache.put("foo", "foo");
+    assertThat(cache.size()).isEqualTo(1);
+    holder.clearAll();
+
+    assertThat(cache.size()).isEqualTo(0);
+  }
+
+  @Test
+  public void clearAll_multiTenant() throws Exception {
+    DefaultCacheHolder holder = new DefaultCacheHolder(cacheFactory, defaultOptions, defaultOptions, new MyTenantProv());
+    DefaultServerCache cache = cache(holder, Customer.class, "customer");
+    cache.put("foo", "foo");
+    assertThat(cache.size()).isEqualTo(1);
+
+    holder.clearAll();
+    assertThat(cache.size()).isEqualTo(0);
+  }
+
+  private class MyTenantProv implements CurrentTenantProvider {
+
+    @Override
+    public String currentId() {
+      return tenantId;
+    }
+  }
+}

src/test/java/io/ebeaninternal/server/cache/DefaultCacheHolder_getCacheOptions_Test.java

@@ -0,0 +1,52 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.cache.ServerCacheOptions;
+import io.ebean.cache.ServerCacheType;
+import org.tests.model.basic.Article;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Product;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class DefaultCacheHolder_getCacheOptions_Test {
+
+  private DefaultCacheHolder cacheHolder;
+
+  public DefaultCacheHolder_getCacheOptions_Test() {
+
+    ServerCacheOptions defaultOptions = new ServerCacheOptions();
+    defaultOptions.setMaxSize(10000);
+    defaultOptions.setMaxSecsToLive(120);
+
+    this.cacheHolder = new DefaultCacheHolder(null, defaultOptions, defaultOptions, null);
+  }
+
+  @Test
+  public void beanOptions_when_set() {
+
+    ServerCacheOptions options = cacheHolder.getCacheOptions(Article.class, ServerCacheType.BEAN);
+    assertEquals(options.getMaxSecsToLive(), 45);
+  }
+
+  @Test
+  public void beanOptions_when_notSet_expect_default() {
+
+    ServerCacheOptions options = cacheHolder.getCacheOptions(Order.class, ServerCacheType.BEAN);
+    assertEquals(options.getMaxSecsToLive(), 120);
+  }
+
+  @Test
+  public void queryOptions_when_set() {
+
+    ServerCacheOptions options = cacheHolder.getCacheOptions(Product.class, ServerCacheType.QUERY);
+    assertEquals(options.getMaxSecsToLive(), 15);
+  }
+
+  @Test
+  public void queryOptions_when_notSet_expect_default() {
+
+    ServerCacheOptions options = cacheHolder.getCacheOptions(Order.class, ServerCacheType.QUERY);
+    assertEquals(options.getMaxSecsToLive(), 120);
+  }
+}

src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheManagerTest.java

@@ -0,0 +1,81 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.cache.ServerCacheFactory;
+import io.ebean.cache.ServerCacheOptions;
+import io.ebean.config.CurrentTenantProvider;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+import static org.junit.Assert.assertTrue;
+
+public class DefaultServerCacheManagerTest {
+
+  private String tenantId;
+
+  private final ServerCacheFactory cacheFactory = new DefaultServerCacheFactory();
+
+  private DefaultServerCacheManager manager = new DefaultServerCacheManager(true, null, cacheFactory, new ServerCacheOptions(), new ServerCacheOptions());
+
+  private DefaultServerCacheManager multiTenantManager = new DefaultServerCacheManager(true, new MyTenantProv(), cacheFactory, new ServerCacheOptions(), new ServerCacheOptions());
+
+  @Test
+  public void getCache_normal() throws Exception {
+
+
+    DefaultServerCache cache = cache(manager, Customer.class);
+    assertThat(cache.getName()).isEqualTo("org.tests.model.basic.Customer_B");
+
+    DefaultServerCache cache1 = cache(manager, Customer.class);
+    assertThat(cache1).isSameAs(cache);
+
+    DefaultServerCache cache2 = cache(manager, Contact.class);
+    assertThat(cache1).isNotSameAs(cache2);
+    assertThat(cache2.getName()).isEqualTo("org.tests.model.basic.Contact_B");
+
+
+    DefaultServerCache natKeyCache = (DefaultServerCache) manager.getNaturalKeyCache(Customer.class).get();
+    assertThat(natKeyCache.getName()).isEqualTo("org.tests.model.basic.Customer_N");
+
+    DefaultServerCache queryCache = (DefaultServerCache) manager.getQueryCache(Customer.class).get();
+    assertThat(queryCache.getName()).isEqualTo("org.tests.model.basic.Customer_Q");
+
+    DefaultServerCache collCache = (DefaultServerCache) manager.getCollectionIdsCache(Customer.class, "contacts").get();
+    assertThat(collCache.getName()).isEqualTo("org.tests.model.basic.Customer.contacts_C");
+  }
+
+  private DefaultServerCache cache(DefaultServerCacheManager manager, Class<?> beanType) {
+    return (DefaultServerCache) manager.getBeanCache(beanType).get();
+  }
+
+  @Test
+  public void getCache_multiTenant() throws Exception {
+
+    tenantId = "ten1";
+    DefaultServerCache cache = cache(multiTenantManager, Customer.class);
+    assertThat(cache.getName()).isEqualTo("org.tests.model.basic.Customer_ten1_B");
+
+    tenantId = "ten2";
+    DefaultServerCache cache1 = cache(multiTenantManager, Customer.class);
+    assertThat(cache1).isNotSameAs(cache);
+    assertThat(cache1.getName()).isEqualTo("org.tests.model.basic.Customer_ten2_B");
+  }
+
+  @Test
+  public void isLocalL2Caching() throws Exception {
+
+    assertTrue(manager.isLocalL2Caching());
+    assertTrue(multiTenantManager.isLocalL2Caching());
+  }
+
+
+  private class MyTenantProv implements CurrentTenantProvider {
+
+    @Override
+    public String currentId() {
+      return tenantId;
+    }
+  }
+
+}

src/test/java/io/ebeaninternal/server/cache/DefaultServerCacheTest.java

@@ -0,0 +1,88 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.cache.ServerCacheOptions;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class DefaultServerCacheTest {
+
+  private DefaultServerCache createCache() {
+
+    ServerCacheOptions cacheOptions = new ServerCacheOptions();
+    cacheOptions.setMaxSize(100);
+    cacheOptions.setMaxIdleSecs(60);
+    cacheOptions.setMaxSecsToLive(600);
+    cacheOptions.setTrimFrequency(60);
+
+    return new DefaultServerCache("foo", cacheOptions);
+  }
+
+  @Test
+  public void testGetHitRatio() throws Exception {
+
+    DefaultServerCache cache = createCache();
+    assertEquals(0, cache.getHitRatio());
+    cache.put("A", "A");
+    cache.get("A");
+    assertEquals(100, cache.getHitRatio());
+    cache.get("B");
+    assertEquals(50, cache.getHitRatio());
+    cache.get("B");
+    cache.get("B");
+    assertEquals(25, cache.getHitRatio());
+  }
+
+  @Test
+  public void testSize() throws Exception {
+
+    DefaultServerCache cache = createCache();
+    assertEquals(0, cache.size());
+    cache.put("A", "A");
+    assertEquals(1, cache.size());
+    cache.put("A", "B");
+    assertEquals(1, cache.size());
+    cache.put("B", "B");
+    assertEquals(2, cache.size());
+
+    cache.remove("B");
+    cache.remove("A");
+    assertEquals(0, cache.size());
+  }
+
+  @Test
+  public void trimFreq_halfIdle() throws Exception {
+
+    DefaultServerCache cache = new DefaultServerCache("", null, 10000, 10, 20, 0);
+    assertEquals(cache.trimFrequency, 4);
+  }
+
+  @Test
+  public void trimFreq_halfIdle_withRounding() throws Exception {
+
+    DefaultServerCache cache = new DefaultServerCache("", null, 10000, 11, 20, 0);
+    assertEquals(cache.trimFrequency, 4);
+  }
+
+  @Test
+  public void trimFreq_halfTTL() throws Exception {
+
+    DefaultServerCache cache = new DefaultServerCache("", null, 10000, 0, 20, 0);
+    assertEquals(cache.trimFrequency, 9);
+  }
+
+  @Test
+  public void trimFreq_halfTTL_withRounding() throws Exception {
+
+    DefaultServerCache cache = new DefaultServerCache("", null, 10000, 0, 21, 0);
+    assertEquals(cache.trimFrequency, 9);
+  }
+
+  @Test
+  public void trimFreq_explicit() throws Exception {
+
+    DefaultServerCache cache = new DefaultServerCache("", null, 10000, 10, 20, 42);
+    assertEquals(cache.trimFrequency, 42);
+  }
+
+}

src/test/java/io/ebeaninternal/server/cache/DefaultServerCache_RunEvictionTest.java

@@ -0,0 +1,59 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.cache.ServerCacheOptions;
+import io.ebean.cache.ServerCacheStatistics;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.Random;
+
+
+public class DefaultServerCache_RunEvictionTest {
+
+
+  private DefaultServerCache createCache() {
+
+    ServerCacheOptions cacheOptions = new ServerCacheOptions();
+    cacheOptions.setMaxSize(10000);
+    cacheOptions.setMaxIdleSecs(1);
+    cacheOptions.setMaxSecsToLive(2);
+    cacheOptions.setTrimFrequency(1);
+
+    return new DefaultServerCache("foo", cacheOptions);
+  }
+
+  private final DefaultServerCache cache;
+
+  private final Random random = new Random();
+
+  public DefaultServerCache_RunEvictionTest() {
+    this.cache = createCache();
+  }
+
+  @Ignore
+  @Test
+  public void runEvict() throws InterruptedException {
+
+    for (int i = 0; i < 15; i++) {
+      doStuff();
+      cache.runEviction();
+      ServerCacheStatistics statistics = cache.getStatistics(true);
+      System.out.println(statistics);
+      Thread.sleep(500);
+    }
+  }
+
+  private void doStuff() {
+
+    for (int i = 0; i < 500; i++) {
+      String key = "" + random.nextInt(20000);
+
+      int mode = random.nextInt(10);
+      if (mode < 8) {
+        cache.get(key);
+      } else {
+        cache.put(key, key + "-" + System.currentTimeMillis());
+      }
+    }
+  }
+}

src/test/java/io/ebeaninternal/server/changelog/ChangeJsonBuilderTest.java

@@ -0,0 +1,41 @@
+package io.ebeaninternal.server.changelog;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.event.changelog.BeanChange;
+import io.ebean.event.changelog.ChangeSet;
+import io.ebean.text.json.JsonContext;
+import org.junit.Test;
+
+import java.io.StringWriter;
+import java.util.List;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+
+public class ChangeJsonBuilderTest extends BaseTestCase {
+
+  Helper helper = new Helper();
+
+  @Test
+  public void testToJson() throws Exception {
+
+    JsonContext jsonContext = Ebean.getDefaultServer().json();
+    ChangeJsonBuilder builder = new ChangeJsonBuilder(jsonContext);
+
+    ChangeSet changeSet = helper.createChangeSet("ABCD", 10);
+    changeSet.getUserContext().put("altUser", "role user");
+
+    List<BeanChange> changes = changeSet.getChanges();
+    for (int i = 0; i < changes.size(); i++) {
+      StringWriter buffer = new StringWriter();
+      builder.writeBeanJson(buffer, changes.get(i), changeSet, i);
+
+      assertThat(buffer.toString()).contains("\"source\"");
+      assertThat(buffer.toString()).contains("\"userId\"");
+      assertThat(buffer.toString()).contains("\"userIpAddress\"");
+      assertThat(buffer.toString()).contains("\"userContext\"");
+    }
+
+  }
+}

src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogListenerTest.java

@@ -0,0 +1,26 @@
+package io.ebeaninternal.server.changelog;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.event.changelog.ChangeSet;
+import org.junit.Test;
+
+public class DefaultChangeLogListenerTest extends BaseTestCase {
+
+  Helper helper = new Helper();
+
+  @Test
+  public void test() {
+
+    DefaultChangeLogListener changeLogListener = new DefaultChangeLogListener();
+
+    EbeanServer defaultServer = Ebean.getDefaultServer();
+    changeLogListener.configure(defaultServer.getPluginApi());
+
+    ChangeSet changeSet = helper.createChangeSet("INT-001", 13);
+
+    changeLogListener.log(changeSet);
+  }
+
+}

src/test/java/io/ebeaninternal/server/changelog/DefaultChangeLogRegisterTest.java

@@ -0,0 +1,74 @@
+package io.ebeaninternal.server.changelog;
+
+import io.ebean.BaseTestCase;
+import io.ebean.event.changelog.ChangeLogFilter;
+import org.tests.inheritance.model.ProductConfiguration;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.Customer;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+public class DefaultChangeLogRegisterTest extends BaseTestCase {
+
+
+  @Test
+  public void test_defaultInsertTrue() {
+
+    DefaultChangeLogRegister register = new DefaultChangeLogRegister(true);
+
+    assertNull(register.getChangeFilter(Address.class));
+
+    ChangeLogFilter changeFilter = register.getChangeFilter(Customer.class);
+    DefaultChangeLogRegister.UpdateFilter updateFilter = (DefaultChangeLogRegister.UpdateFilter) changeFilter;
+    assertFalse(updateFilter.includeInserts);
+    assertThat(updateFilter.updateProperties).containsExactly("name", "status");
+
+    changeFilter = register.getChangeFilter(Country.class);
+    DefaultChangeLogRegister.BasicFilter countryFilter = (DefaultChangeLogRegister.BasicFilter) changeFilter;
+    assertTrue(countryFilter.includeInserts);
+
+    // use default setting
+    changeFilter = register.getChangeFilter(Contact.class);
+    DefaultChangeLogRegister.BasicFilter contactFilter = (DefaultChangeLogRegister.BasicFilter) changeFilter;
+    assertTrue(contactFilter.includeInserts);
+
+  }
+
+  @Test
+  public void test_defaultInsertFalse() {
+
+    DefaultChangeLogRegister register = new DefaultChangeLogRegister(false);
+
+    assertNull(register.getChangeFilter(Address.class));
+
+    ChangeLogFilter changeFilter = register.getChangeFilter(Customer.class);
+    DefaultChangeLogRegister.UpdateFilter updateFilter = (DefaultChangeLogRegister.UpdateFilter) changeFilter;
+    assertFalse(updateFilter.includeInserts);
+    assertThat(updateFilter.updateProperties).containsExactly("name", "status");
+
+    changeFilter = register.getChangeFilter(Country.class);
+    DefaultChangeLogRegister.BasicFilter countryFilter = (DefaultChangeLogRegister.BasicFilter) changeFilter;
+    assertTrue(countryFilter.includeInserts);
+
+    // use default setting
+    changeFilter = register.getChangeFilter(Contact.class);
+    DefaultChangeLogRegister.BasicFilter contactFilter = (DefaultChangeLogRegister.BasicFilter) changeFilter;
+    assertFalse(contactFilter.includeInserts);
+
+  }
+
+  @Test
+  public void test_inheritance() {
+
+    DefaultChangeLogRegister register = new DefaultChangeLogRegister(true);
+    ChangeLogFilter changeFilter = register.getChangeFilter(ProductConfiguration.class);
+    assertNotNull(changeFilter);
+    DefaultChangeLogRegister.BasicFilter basicFilter = (DefaultChangeLogRegister.BasicFilter) changeFilter;
+    assertTrue(basicFilter.includeInserts);
+  }
+
+}

src/test/java/io/ebeaninternal/server/changelog/Helper.java

@@ -0,0 +1,68 @@
+package io.ebeaninternal.server.changelog;
+
+import io.ebean.ValuePair;
+import io.ebean.event.changelog.BeanChange;
+import io.ebean.event.changelog.ChangeSet;
+import io.ebean.event.changelog.ChangeType;
+import io.ebean.event.changelog.TxnState;
+import org.jetbrains.annotations.NotNull;
+
+import java.sql.Timestamp;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Helper {
+
+  public ChangeSet createChangeSet(String txnId, long startId) {
+
+    ChangeSet cs = new ChangeSet();
+    cs.setTxnId(txnId);
+    cs.setTxnState(TxnState.COMMITTED);
+    cs.setTxnBatch(0);
+    cs.setSource("myApp");
+    cs.setUserId("user234");
+    cs.setUserIpAddress("123.4.5.6");
+    cs.getUserContext().put("someKey", "user defined input");
+
+    List<BeanChange> changes = cs.getChanges();
+
+    changes.add(createInsert(startId));
+    changes.add(createUpdate(startId));
+    changes.add(createDelete(startId));
+
+    return cs;
+  }
+
+  @NotNull
+  private BeanChange createInsert(long startId) {
+    Map<String, ValuePair> values = new LinkedHashMap<>();
+    values.put("name", new ValuePair("rob", null));
+    values.put("modified", new ValuePair(new Timestamp(System.currentTimeMillis()), null));
+
+    BeanChange bean = new BeanChange("mytable", startId + 1, ChangeType.INSERT, null);
+    bean.setValues(values);
+    return bean;
+  }
+
+  @NotNull
+  private BeanChange createUpdate(long startId) {
+    Map<String, ValuePair> values = new LinkedHashMap<>();
+    values.put("name", new ValuePair("jim", "steve"));
+    values.put("nowHasVal", new ValuePair("wasNull", null));
+    values.put("nowNull", new ValuePair(null, "hadVal"));
+
+    values.put("modified", new ValuePair(new Timestamp(System.currentTimeMillis()), null));
+
+    BeanChange bean = new BeanChange("mytable", startId + 2, ChangeType.UPDATE, null);
+    bean.setValues(values);
+    return bean;
+  }
+
+  @NotNull
+  private BeanChange createDelete(long startId) {
+    return new BeanChange("mytable", startId + 3, ChangeType.DELETE, new HashMap<>());
+  }
+
+}

src/test/java/io/ebeaninternal/server/core/BasicTypeConverterTest.java

@@ -0,0 +1,35 @@
+package io.ebeaninternal.server.core;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class BasicTypeConverterTest {
+
+  @Test
+  public void toBoolean_when_1_long() throws Exception {
+    assertTrue(BasicTypeConverter.toBoolean(1L, "T"));
+  }
+
+  @Test
+  public void toBoolean_when_1_int() throws Exception {
+    assertTrue(BasicTypeConverter.toBoolean(1, "T"));
+  }
+
+  @Test
+  public void toBoolean_when_0() throws Exception {
+    assertFalse(BasicTypeConverter.toBoolean(0L, "T"));
+  }
+
+  @Test
+  public void toBoolean_when_TrueValue() throws Exception {
+    assertTrue(BasicTypeConverter.toBoolean("T", "T"));
+  }
+
+  @Test
+  public void toBoolean_when_notTrueValue() throws Exception {
+    assertFalse(BasicTypeConverter.toBoolean("F", "T"));
+  }
+
+}

src/test/java/io/ebeaninternal/server/core/DefaultBackgroundExecutorTest.java

@@ -0,0 +1,56 @@
+package io.ebeaninternal.server.core;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class DefaultBackgroundExecutorTest {
+
+  @Test
+  @Ignore
+  public void shutdown_when_running_expect_waitAndNiceShutdown() throws Exception {
+
+    DefaultBackgroundExecutor es = new DefaultBackgroundExecutor(1, 20, "test");
+
+    es.execute(new RunFor(3000, "a"));
+    es.execute(new RunFor(3000, "b"));
+    es.execute(new RunFor(3000, "c"));
+
+    es.shutdown();
+  }
+
+  @Test
+  @Ignore
+  public void shutdown_when_rougeRunnable_expect_InterruptedException() throws Exception {
+
+    DefaultBackgroundExecutor es = new DefaultBackgroundExecutor(1, 10, "test");
+
+    es.execute(new RunFor(300000, "a"));
+    es.execute(new RunFor(3000, "b"));
+    es.execute(new RunFor(3000, "c"));
+
+    es.shutdown();
+  }
+
+
+  class RunFor implements Runnable {
+
+    final long wait;
+    final String id;
+
+    RunFor(long wait, String id) {
+      this.wait = wait;
+      this.id = id;
+    }
+
+    @Override
+    public void run() {
+      try {
+        System.out.println("start " + id);
+        Thread.sleep(wait);
+        System.out.println("done " + id);
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+    }
+  }
+}

src/test/java/io/ebeaninternal/server/core/DefaultServer_createOrmQueryRequestTest.java

@@ -0,0 +1,316 @@
+package io.ebeaninternal.server.core;
+
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.FetchConfig;
+import io.ebean.Query;
+import io.ebeaninternal.server.querydefn.DefaultOrmQuery;
+import io.ebeaninternal.server.querydefn.OrmQueryDetail;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
+
+  Query<Order> query() {
+    return server().find(Order.class);
+  }
+
+  OrmQueryRequest<Order> queryRequest(Query<Order> query) {
+    return OrmQueryRequestTestHelper.queryRequest(query);
+  }
+
+  OrmQueryDetail detail(Query<Order> query) {
+    return queryRequest(query).getQuery().getDetail();
+  }
+
+  @Test
+  public void when_empty_then_same() {
+
+    assertSame(detail(query()), detail(query()));
+  }
+
+  @Test
+  public void select_all_then_same() {
+
+    assertSame(detail(query().select("*")), detail(query().select("*")));
+  }
+
+  @Test
+  public void when_propertiesInOrder_then_same() {
+
+    assertSame(detail(query().select("id,name")), detail(query().select("id,name")));
+  }
+
+  @Test
+  public void when_propertiesInDifferentOrder_then_different() {
+
+    assertDifferent(detail(query().select("id,name")), detail(query().select("name, id")));
+
+    // but same from autotune perspective
+    assertThat(detail(query().select("id,name")).isAutoTuneEqual(detail(query().select("name, id")))).isTrue();
+  }
+
+  @Test
+  public void when_additional_fetch_then_different() {
+
+    assertDifferent(detail(query().select("id,name")), detail(query().select("id,name").fetch("details")));
+  }
+
+  @Test
+  public void when_same_fetch_then_same() {
+
+    assertSame(detail(query().select("id,name").fetch("details")), detail(query().select("id,name").fetch("details")));
+  }
+
+  @Test
+  public void when_fetch_order_different_then_different() {
+
+    assertDifferent(detail(query().select("id,name").fetch("details").fetch("customer")),
+      detail(query().select("id,name").fetch("customer").fetch("details")));
+  }
+
+  @Test
+  public void when_extra_queryFetchToMany_then_same() {
+
+    assertDifferent(detail(query().select("id,name").fetch("customer")),
+      detail(query().select("id,name").fetch("customer").fetch("details", new FetchConfig().query())));
+  }
+
+  @Test
+  public void when_extra_queryToOne_fetch_then_different() {
+
+    // with the fetch of customer the foreign key must be added to the root query
+    assertDifferent(detail(query().select("id,name")),
+      detail(query().select("id,name").fetch("customer", new FetchConfig().query())));
+  }
+
+  @Test
+  public void when_additional_fetch_V2_then_different() {
+
+    assertDifferent(detail(query().select("id,name")), detail(query().select("id,name").fetch("customer", "id")));
+  }
+
+
+  @Test
+  public void when_fetchConfig_then_differentPlan() throws Exception {
+
+    DefaultOrmQuery<Order> query1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class)
+      .select("status, shipDate")
+      .fetch("details", "orderQty, unitPrice", new FetchConfig().query())
+      .fetch("details.product", "sku, name");
+
+
+    DefaultOrmQuery<Order> query2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class)
+      .select("status, shipDate")
+      .fetch("details", "orderQty, unitPrice")
+      .fetch("details.product", "sku, name");
+
+    assertDifferent(detail(query1), detail(query2));
+  }
+
+  @Test
+  public void testJoinOrder_when_fetchJoins_expect_detailJoinsPreserveOrder() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("customer", "name")
+      .fetch("details");
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer", "details");
+  }
+
+  @Test
+  public void testJoinOrder_when_fetchJoinsAndWhere_expect_fetchJoinsOnlyInFetchPaths() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("details")
+      .where().eq("customer.name", "rob").query();
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("details");
+  }
+
+  @Test
+  public void testJoinOrder_when_queryFetch_expect_getFetchPaths_doesNotIncludeQueryJoin() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("customer", "name")
+      .fetch("details", new FetchConfig().query());
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void testJoinOrder_when_queryFetch_expect_getFetchPaths_doesNotIncludeQueryJoin_via_fetchQuery() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("customer", "name")
+      .fetchQuery("details");
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void testJoinOrder_when_lazyFetch_expect_getFetchPaths_doesNotIncludeQueryJoin() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("customer", "name")
+      .fetch("details", new FetchConfig().lazy());
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void testJoinOrder_when_lazyFetch_expect_getFetchPaths_doesNotIncludeQueryJoin_via_fetchLazy() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("customer", "name")
+      .fetchLazy("details");
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void testJoinOrder_when_lazyFetchAndHasChildren_expect_getFetchPaths_doesNotIncludeJoinOrChild() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("customer", "name")
+      .fetch("details", new FetchConfig().lazy())
+      .fetch("details.product");
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void testJoinOrder_when_fetchMany_expect_getFetchPaths_containsAllInOrder() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("details")
+      .fetch("details.product")
+      .fetch("customer", "name");
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("details", "details.product", "customer");
+  }
+
+  @Test
+  public void testJoinOrder_when_queryJoin_expect_getFetchPaths_excludesQueryJoinAndChildren() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status, orderDate")
+      .fetch("details", new FetchConfig().query())
+      .fetch("details.product")
+      .fetch("customer", "name");
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void test_removeJoinToMany_when_multipleManyPaths() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .fetch("details")
+      .fetch("details.product")
+      .fetch("customer")
+      .fetch("customer.contacts"); // second many path
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("details", "details.product", "customer");
+  }
+
+  @Test
+  public void test_removeAllJoinToMany_when_firstRow() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setFirstRow(1)
+      .fetch("details") // many path
+      .fetch("details.product")
+      .fetch("customer")
+      .fetch("customer.contacts"); // many path
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void test_removeAllJoinToMany_when_maxRows() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setMaxRows(1)
+      .fetch("details") // many path
+      .fetch("details.product")
+      .fetch("customer")
+      .fetch("customer.contacts"); // many path
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void test_removeJoinToMany_when_filterMany() {
+
+    Query<Order> query = Ebean.find(Order.class)
+      .fetch("details")
+      .fetch("details.product")
+      .fetch("customer")
+      .fetch("customer.contacts")
+      .filterMany("details").eq("orderQuantity", 10)
+      .query();
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query);
+    OrmQueryDetail detail = queryRequest.getQuery().getDetail();
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
+  }
+
+  private void assertSame(OrmQueryDetail detail1, OrmQueryDetail detail2) {
+    assertThat(detail1.isSameByPlan(detail2)).isTrue();
+    assertThat(detail1.queryPlanHash()).isEqualTo(detail2.queryPlanHash());
+  }
+
+  private void assertDifferent(OrmQueryDetail detail1, OrmQueryDetail detail2) {
+    assertThat(detail1.isSameByPlan(detail2)).isFalse();
+    assertThat(detail1.queryPlanHash()).isNotEqualTo(detail2.queryPlanHash());
+  }
+}

src/test/java/io/ebeaninternal/server/core/DefaultServer_getReferenceTest.java

@@ -0,0 +1,73 @@
+package io.ebeaninternal.server.core;
+
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Car;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.tests.model.basic.Vehicle;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultServer_getReferenceTest extends BaseTestCase {
+
+  @Test
+  public void getReference_noPC() {
+    Ebean.getReference(Customer.class, 42);
+  }
+
+  @Test
+  public void getReference_when_inPC_expect_getFromPC() {
+
+    ResetBasicData.reset();
+
+    Ebean.beginTransaction();
+    try {
+      Customer loaded = Ebean.find(Customer.class, 1);
+      Customer reference = Ebean.getReference(Customer.class, 1);
+      assertThat(loaded).isSameAs(reference);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+
+  @Test
+  public void inherit_getReference_when_noPC() {
+
+    Car car = new Car();
+    car.setDriver("TestForRef");
+    Ebean.save(car);
+
+    Vehicle reference = Ebean.getReference(Vehicle.class, car.getId());
+
+    assertThat(reference).isInstanceOf(Car.class);
+    assertThat(reference.getId()).isSameAs(car.getId());
+
+    Ebean.delete(car);
+  }
+
+
+  @Test
+  public void inherit_getReference_when_inPC() {
+
+    Car car = new Car();
+    car.setDriver("TestForRef");
+    Ebean.save(car);
+
+    Ebean.beginTransaction();
+    try {
+      Vehicle loaded = Ebean.find(Vehicle.class, car.getId());
+      Vehicle reference = Ebean.getReference(Vehicle.class, car.getId());
+      assertThat(reference).isSameAs(loaded);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+
+    Ebean.delete(car);
+  }
+}

src/test/java/io/ebeaninternal/server/core/OrmQueryRequestTestHelper.java

@@ -0,0 +1,18 @@
+package io.ebeaninternal.server.core;
+
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebeaninternal.api.SpiQuery;
+
+public class OrmQueryRequestTestHelper {
+
+  static DefaultServer defaultServer = (DefaultServer) Ebean.getDefaultServer();
+
+  /**
+   * Create and return a OrmQueryRequest for the given query.
+   */
+  public static <T> OrmQueryRequest<T> queryRequest(Query<T> query) {
+    return (OrmQueryRequest<T>) defaultServer.createQueryRequest(SpiQuery.Type.LIST, query, null);
+  }
+
+}

src/test/java/io/ebeaninternal/server/core/PostgresCastTest.java

@@ -0,0 +1,28 @@
+package io.ebeaninternal.server.core;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class PostgresCastTest {
+
+  @Test
+  public void cast() throws Exception {
+
+    assertThat(PostgresCast.cast(1)).isEqualTo("::integer");
+    assertThat(PostgresCast.cast(1L)).isEqualTo("::bigint");
+    assertThat(PostgresCast.cast(1.0D)).isEqualTo("::decimal");
+    assertThat(PostgresCast.cast("")).isEqualTo("");
+  }
+
+  @Test
+  public void cast1() throws Exception {
+
+    assertThat(PostgresCast.cast(1, true)).isEqualTo("::integer[]");
+    assertThat(PostgresCast.cast(1L, true)).isEqualTo("::bigint[]");
+    assertThat(PostgresCast.cast(1.0D, true)).isEqualTo("::decimal[]");
+    assertThat(PostgresCast.cast("", true)).isEqualTo("");
+  }
+
+}

src/test/java/io/ebeaninternal/server/core/TestDiffHelpInsertSimple.java

@@ -0,0 +1,64 @@
+package io.ebeaninternal.server.core;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.ValuePair;
+import io.ebean.bean.EntityBean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.junit.Test;
+
+import java.sql.Date;
+import java.sql.Timestamp;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
+public class TestDiffHelpInsertSimple extends BaseTestCase {
+
+  long firstTime = System.currentTimeMillis() - 10000;
+
+  EbeanServer server;
+
+  BeanDescriptor<Order> orderDesc;
+
+  public TestDiffHelpInsertSimple() {
+    server = Ebean.getServer(null);
+    SpiEbeanServer spiServer = (SpiEbeanServer) server;
+    orderDesc = spiServer.getBeanDescriptor(Order.class);
+  }
+
+  private Order createBaseOrder(EbeanServer server) {
+    Order order1 = new Order();
+    order1.setId(12);
+    order1.setCretime(new Timestamp(firstTime));
+    order1.setCustomer(server.getReference(Customer.class, 1234));
+    order1.setStatus(Status.NEW);
+    //order1.setShipDate(new Date(firstTime));
+    order1.setOrderDate(new Date(firstTime));
+    return order1;
+  }
+
+  @Test
+  public void basic() {
+
+    Order order1 = createBaseOrder(server);
+
+    Map<String, ValuePair> diff = orderDesc.diffForInsert((EntityBean) order1);
+
+    assertEquals(4, diff.size());
+
+    Set<String> keySet = diff.keySet();
+    assertTrue(keySet.contains("cretime"));
+    assertTrue(keySet.contains("status"));
+    assertTrue(keySet.contains("orderDate"));
+    assertTrue(keySet.contains("customer.id"));
+    assertFalse(keySet.contains("shipDate"));
+  }
+
+}

src/test/java/io/ebeaninternal/server/core/TestDiffHelpInsertWithEmbedded.java

@@ -0,0 +1,105 @@
+package io.ebeaninternal.server.core;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.ValuePair;
+import io.ebean.bean.EntityBean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.embedded.EMain;
+import org.tests.model.embedded.Eembeddable;
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class TestDiffHelpInsertWithEmbedded extends BaseTestCase {
+
+  EbeanServer server;
+
+  BeanDescriptor<EMain> emainDesc;
+
+  public TestDiffHelpInsertWithEmbedded() {
+    server = Ebean.getServer(null);
+    SpiEbeanServer spiServer = (SpiEbeanServer) server;
+    emainDesc = spiServer.getBeanDescriptor(EMain.class);
+  }
+
+  @Test
+  public void simple() {
+
+    EMain emain1 = createEMain();
+
+    Map<String, ValuePair> diff = emainDesc.diffForInsert((EntityBean) emain1);
+    assertEquals(3, diff.size());
+    assertEquals("foo", diff.get("name").getNewValue());
+    assertEquals(13L, diff.get("version").getNewValue());
+
+    ValuePair valuePair = diff.get("embeddable.description");
+    assertNotNull(valuePair);
+    assertEquals("bar", valuePair.getNewValue());
+    assertNull(valuePair.getOldValue());
+  }
+
+  @Test
+  public void scalarPropertyAsNull() {
+
+    EMain emain1 = createEMain();
+    emain1.setName(null);
+
+    Map<String, ValuePair> diff = emainDesc.diffForInsert((EntityBean) emain1);
+    assertEquals(2, diff.size());
+    assertNull(diff.get("name"));
+    assertEquals(13L, diff.get("version").getNewValue());
+
+    ValuePair valuePair = diff.get("embeddable.description");
+    assertNotNull(valuePair);
+    assertEquals("bar", valuePair.getNewValue());
+    assertNull(valuePair.getOldValue());
+  }
+
+  @Test
+  public void embeddedAsNull() {
+
+    EMain emain1 = createEMain();
+    emain1.setEmbeddable(null);
+
+    Map<String, ValuePair> diff = emainDesc.diffForInsert((EntityBean) emain1);
+    assertEquals(2, diff.size());
+    assertEquals("foo", diff.get("name").getNewValue());
+    assertEquals(13L, diff.get("version").getNewValue());
+
+    assertNull(diff.get("embeddable.description"));
+  }
+
+
+  @Test
+  public void embeddedPropertiesAsNull() {
+
+    EMain emain1 = createEMain();
+    emain1.getEmbeddable().setDescription(null);
+
+    Map<String, ValuePair> diff = emainDesc.diffForInsert((EntityBean) emain1);
+    assertEquals(2, diff.size());
+    assertEquals("foo", diff.get("name").getNewValue());
+    assertEquals(13L, diff.get("version").getNewValue());
+
+    assertNull(diff.get("embeddable.description"));
+  }
+
+  private EMain createEMain() {
+
+    EMain emain = new EMain();
+    emain.setName("foo");
+    emain.setVersion(13l);
+
+    Eembeddable embeddable = new Eembeddable();
+    embeddable.setDescription("bar");
+    emain.setEmbeddable(embeddable);
+
+    return emain;
+  }
+
+}

src/test/java/io/ebeaninternal/server/core/TestDiffHelpSimple.java

@@ -0,0 +1,171 @@
+package io.ebeaninternal.server.core;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.ValuePair;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Date;
+import java.sql.Timestamp;
+import java.util.Map;
+import java.util.Set;
+
+public class TestDiffHelpSimple extends BaseTestCase {
+
+  long firstTime = System.currentTimeMillis() - 10000;
+  long secondTime = System.currentTimeMillis();
+
+  EbeanServer server;
+  BeanDescriptor<Order> orderDesc;
+
+  public TestDiffHelpSimple() {
+    server = Ebean.getServer(null);
+    SpiEbeanServer spiServer = (SpiEbeanServer) server;
+    orderDesc = spiServer.getBeanDescriptor(Order.class);
+  }
+
+  private Order createBaseOrder(EbeanServer server) {
+    Order order1 = new Order();
+    order1.setId(12);
+    order1.setCretime(new Timestamp(firstTime));
+    order1.setCustomer(server.getReference(Customer.class, 1234));
+    order1.setStatus(Status.NEW);
+    order1.setShipDate(new Date(firstTime));
+    order1.setOrderDate(new Date(firstTime));
+    return order1;
+  }
+
+  @Test
+  public void testBasicChanges() {
+
+
+    Order order1 = createBaseOrder(server);
+
+    Order order2 = new Order();
+    order2.setId(14);
+    order2.setCretime(new Timestamp(secondTime));
+    order2.setCustomer(server.getReference(Customer.class, 2133));
+    order2.setStatus(Status.COMPLETE);
+    order2.setShipDate(new Date(secondTime));
+    order2.setOrderDate(new Date(secondTime));
+
+    Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
+
+    Assert.assertEquals(5, diff.size());
+
+    Set<String> keySet = diff.keySet();
+    Assert.assertTrue(keySet.contains("cretime"));
+    Assert.assertTrue(keySet.contains("status"));
+    Assert.assertTrue(keySet.contains("shipDate"));
+    Assert.assertTrue(keySet.contains("orderDate"));
+    Assert.assertTrue(keySet.contains("customer.id"));
+  }
+
+  @Test
+  public void testBasicChanges_given_flatMode() {
+
+
+    Order order1 = createBaseOrder(server);
+
+    Order order2 = new Order();
+    order2.setId(14);
+    order2.setCretime(new Timestamp(secondTime));
+    order2.setCustomer(server.getReference(Customer.class, 2133));
+    order2.setStatus(Status.COMPLETE);
+    order2.setShipDate(new Date(secondTime));
+    order2.setOrderDate(new Date(secondTime));
+
+    Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
+
+    Assert.assertEquals(5, diff.size());
+
+    Set<String> keySet = diff.keySet();
+    Assert.assertTrue(keySet.contains("cretime"));
+    Assert.assertTrue(keySet.contains("status"));
+    Assert.assertTrue(keySet.contains("shipDate"));
+    Assert.assertTrue(keySet.contains("orderDate"));
+    Assert.assertTrue(keySet.contains("customer.id"));
+    Assert.assertEquals(2133, diff.get("customer.id").getOldValue());
+    Assert.assertEquals(1234, diff.get("customer.id").getNewValue());
+  }
+
+  @Test
+  public void testIdIgnored() {
+
+    Order order1 = createBaseOrder(server);
+    Order order2 = createBaseOrder(server);
+    order2.setId(14);
+
+    Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
+
+    Assert.assertEquals(0, diff.size());
+  }
+
+  @Test
+  public void testSecondValueNull() {
+
+    Order order1 = createBaseOrder(server);
+
+    Order order2 = createBaseOrder(server);
+    order2.setCustomer(server.getReference(Customer.class, 2133));
+    order2.setStatus(Status.COMPLETE);
+    order2.setShipDate(null);
+
+    Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
+
+    Assert.assertEquals(3, diff.size());
+
+    Set<String> keySet = diff.keySet();
+    Assert.assertTrue(keySet.contains("status"));
+    Assert.assertTrue(keySet.contains("customer.id"));
+    Assert.assertTrue(keySet.contains("shipDate"));
+
+    ValuePair shipDatePair = diff.get("shipDate");
+    Assert.assertEquals(order1.getShipDate(), shipDatePair.getNewValue());
+    Assert.assertEquals(order2.getShipDate(), shipDatePair.getOldValue());
+    Assert.assertNull(shipDatePair.getOldValue());
+  }
+
+
+  @Test
+  public void testFirstValueNull() {
+
+    Order order1 = createBaseOrder(server);
+    order1.setShipDate(null);
+
+    Order order2 = createBaseOrder(server);
+    order2.setShipDate(new Date(secondTime));
+
+    Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
+
+    Assert.assertEquals(1, diff.size());
+    Set<String> keySet = diff.keySet();
+    Assert.assertTrue(keySet.contains("shipDate"));
+
+    ValuePair shipDatePair = diff.get("shipDate");
+    Assert.assertEquals(order1.getShipDate(), shipDatePair.getNewValue());
+    Assert.assertEquals(order2.getShipDate(), shipDatePair.getOldValue());
+    Assert.assertNull(shipDatePair.getNewValue());
+  }
+
+  @Test
+  public void testBothNull() {
+
+    Order order1 = createBaseOrder(server);
+    order1.setShipDate(null);
+
+    Order order2 = createBaseOrder(server);
+    order2.setShipDate(null);
+
+    Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
+
+    Assert.assertEquals(0, diff.size());
+  }
+}

src/test/java/io/ebeaninternal/server/core/TestDiffHelpWithEmbedded.java

@@ -0,0 +1,157 @@
+package io.ebeaninternal.server.core;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.ValuePair;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.embedded.EMain;
+import org.tests.model.embedded.Eembeddable;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Map;
+
+public class TestDiffHelpWithEmbedded extends BaseTestCase {
+
+  EbeanServer server;
+
+  BeanDescriptor<EMain> emainDesc;
+
+  public TestDiffHelpWithEmbedded() {
+    server = Ebean.getServer(null);
+    SpiEbeanServer spiServer = (SpiEbeanServer) server;
+    emainDesc = spiServer.getBeanDescriptor(EMain.class);
+  }
+
+  @Test
+  public void testChangeExistingEmbedded() {
+
+    EMain emain1 = createEMain();
+    EMain emain2 = createEMain();
+
+    emain2.getEmbeddable().setDescription("baz");
+
+    Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
+    Assert.assertEquals(1, diff.size());
+    ValuePair valuePair = diff.get("embeddable.description");
+
+    Assert.assertNotNull(valuePair);
+    Assert.assertEquals("bar", valuePair.getNewValue());
+    Assert.assertEquals("baz", valuePair.getOldValue());
+  }
+
+  /**
+   * Same result as testChangeExistingEmbedded.
+   */
+  @Test
+  public void testSetViaNewEmbedded() {
+
+    EMain emain1 = createEMain();
+    EMain emain2 = createEMain();
+
+    Eembeddable embeddable = new Eembeddable();
+    embeddable.setDescription("baz");
+    emain2.setEmbeddable(embeddable);
+
+
+    Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
+    Assert.assertEquals(1, diff.size());
+    ValuePair valuePair = diff.get("embeddable.description");
+
+    Assert.assertNotNull(valuePair);
+    Assert.assertEquals("bar", valuePair.getNewValue());
+    Assert.assertEquals("baz", valuePair.getOldValue());
+  }
+
+  @Test
+  public void testDiffEmbedded_flatMode() {
+
+    EMain emain1 = createEMain();
+    EMain emain2 = createEMain();
+    emain2.getEmbeddable().setDescription("baz");
+
+    Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
+    Assert.assertEquals(1, diff.size());
+    ValuePair valuePair = diff.get("embeddable.description");
+
+    Assert.assertNotNull(valuePair);
+    Assert.assertEquals("bar", valuePair.getNewValue());
+    Assert.assertEquals("baz", valuePair.getOldValue());
+  }
+
+  @Test
+  public void testFirstEmbeddedIsNull() {
+
+    EMain emain1 = createEMain();
+    emain1.setEmbeddable(null);
+    EMain emain2 = createEMain();
+
+    Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
+    Assert.assertEquals(1, diff.size());
+    ValuePair valuePair = diff.get("embeddable.description");
+
+    Assert.assertNotNull(valuePair);
+    Assert.assertNull(valuePair.getNewValue());
+    Assert.assertEquals("bar", valuePair.getOldValue());
+  }
+
+  @Test
+  public void testSecondEmbeddedIsNull() {
+
+    EMain emain1 = createEMain();
+    EMain emain2 = createEMain();
+    emain2.setEmbeddable(null);
+
+    Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
+    Assert.assertEquals(1, diff.size());
+    ValuePair valuePair = diff.get("embeddable.description");
+
+    Assert.assertNotNull(valuePair);
+    Assert.assertNull(valuePair.getOldValue());
+    Assert.assertEquals("bar", valuePair.getNewValue());
+  }
+
+  @Test
+  public void testSecondEmbeddedIsNull_given_flatMode() {
+
+    EMain emain1 = createEMain();
+    EMain emain2 = createEMain();
+    emain2.setEmbeddable(null);
+
+    Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
+    Assert.assertEquals(1, diff.size());
+    ValuePair valuePair = diff.get("embeddable.description");
+
+    Assert.assertNotNull(valuePair);
+    Assert.assertNull(valuePair.getOldValue());
+    Assert.assertEquals("bar", valuePair.getNewValue());
+  }
+
+  @Test
+  public void testBothEmbeddedIsNull() {
+
+    EMain emain1 = createEMain();
+    emain1.setEmbeddable(null);
+    EMain emain2 = createEMain();
+    emain2.setEmbeddable(null);
+
+    Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
+    Assert.assertEquals(0, diff.size());
+  }
+
+  private EMain createEMain() {
+
+    EMain emain = new EMain();
+    emain.setName("foo");
+    emain.setVersion(13l);
+
+    Eembeddable embeddable = new Eembeddable();
+    embeddable.setDescription("bar");
+    emain.setEmbeddable(embeddable);
+
+    return emain;
+  }
+
+}

src/test/java/io/ebeaninternal/server/core/bootup/DistillPackagesTest.java

@@ -0,0 +1,52 @@
+package io.ebeaninternal.server.core.bootup;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DistillPackagesTest {
+
+  @Test
+  public void when_unique_expect_all() throws Exception {
+
+    List<String> distill = DistillPackages.distill(group("one", "two"), group("three"));
+    assertThat(distill).containsExactly("one", "three", "two");
+  }
+
+  @Test
+  public void when_sub_expect_distilled() throws Exception {
+
+    List<String> distill = DistillPackages.distill(group("one", "one.sub"), group("three"));
+    assertThat(distill).containsExactly("one", "three");
+  }
+
+
+  @Test
+  public void when_sub_expect_distilled2() throws Exception {
+
+    List<String> distill = DistillPackages.distill(group("one", "one.sub"), group("one.foo"));
+    assertThat(distill).containsExactly("one");
+  }
+
+  @Test
+  public void when_subDotSub_expect_distilled2() throws Exception {
+
+    List<String> distill = DistillPackages.distill(group("one", "one.sub.me"), group("two"));
+    assertThat(distill).containsExactly("one", "two");
+  }
+
+  @Test
+  public void when_unordered_expect_naturalOrder() throws Exception {
+
+    List<String> distill = DistillPackages.distill(group("z.x.y", "two"), group("one", "one.sub.me"));
+    assertThat(distill).containsExactly("one", "two", "z.x.y");
+  }
+
+  List<String> group(String... packages) {
+    return Arrays.asList(packages);
+  }
+
+}

src/test/java/io/ebeaninternal/server/core/bootup/ManifestReaderTest.java

@@ -0,0 +1,30 @@
+package io.ebeaninternal.server.core.bootup;
+
+import org.junit.Test;
+
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ManifestReaderTest {
+
+  @Test
+  public void readOne() throws Exception {
+
+    Set<String> packageSet = readMf("META-INF/test/test-one.mf");
+    assertThat(packageSet).contains("foo");
+  }
+
+  @Test
+  public void readSome() throws Exception {
+
+    Set<String> packageSet = readMf("META-INF/test/test-some.mf");
+    assertThat(packageSet).contains("com.foo.domain", "com.bar.domain");
+  }
+
+  private Set<String> readMf(String path) {
+    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+    return ManifestReader.readManifests(classLoader, path);
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/BeanCascadeInfoTest.java

@@ -0,0 +1,82 @@
+package io.ebeaninternal.server.deploy;
+
+import org.junit.Test;
+
+import javax.persistence.CascadeType;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class BeanCascadeInfoTest {
+
+  @Test
+  public void setTypes_ALL() throws Exception {
+
+    BeanCascadeInfo info = new BeanCascadeInfo();
+    info.setTypes(new CascadeType[]{CascadeType.ALL});
+    assertTrue(info.isSave());
+    assertTrue(info.isDelete());
+    assertTrue(info.isRefresh());
+  }
+
+  @Test
+  public void setTypes_PERSIST() throws Exception {
+
+    BeanCascadeInfo info = new BeanCascadeInfo();
+    info.setTypes(new CascadeType[]{CascadeType.PERSIST});
+    assertTrue(info.isSave());
+    assertFalse(info.isDelete());
+    assertFalse(info.isRefresh());
+  }
+
+  @Test
+  public void setTypes_MERGE() throws Exception {
+
+    BeanCascadeInfo info = new BeanCascadeInfo();
+    info.setTypes(new CascadeType[]{CascadeType.MERGE});
+    assertTrue(info.isSave());
+    assertFalse(info.isDelete());
+    assertFalse(info.isRefresh());
+  }
+
+  @Test
+  public void setTypes_REMOVE() throws Exception {
+
+    BeanCascadeInfo info = new BeanCascadeInfo();
+    info.setTypes(new CascadeType[]{CascadeType.REMOVE});
+    assertFalse(info.isSave());
+    assertTrue(info.isDelete());
+    assertFalse(info.isRefresh());
+  }
+
+  @Test
+  public void setTypes_REFRESH() throws Exception {
+
+    BeanCascadeInfo info = new BeanCascadeInfo();
+    info.setTypes(new CascadeType[]{CascadeType.REFRESH});
+    assertFalse(info.isSave());
+    assertFalse(info.isDelete());
+    assertTrue(info.isRefresh());
+  }
+
+  @Test
+  public void setDelete() throws Exception {
+
+    BeanCascadeInfo info = new BeanCascadeInfo();
+    info.setDelete(true);
+    assertFalse(info.isSave());
+    assertTrue(info.isDelete());
+    assertFalse(info.isRefresh());
+  }
+
+  @Test
+  public void setSaveDelete() throws Exception {
+
+    BeanCascadeInfo info = new BeanCascadeInfo();
+    info.setSaveDelete(true, true);
+    assertTrue(info.isSave());
+    assertTrue(info.isDelete());
+    assertFalse(info.isRefresh());
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/BeanDescriptorTest.java

@@ -0,0 +1,70 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.BaseTestCase;
+import io.ebean.bean.EntityBean;
+import io.ebean.plugin.Property;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import java.util.Collection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BeanDescriptorTest extends BaseTestCase {
+
+  BeanDescriptor<Customer> customerDesc = spiEbeanServer().getBeanDescriptor(Customer.class);
+
+  @Test
+  public void createReference() {
+
+    Customer bean = customerDesc.createReference(null, false, 42, null);
+    assertThat(bean.getId()).isEqualTo(42);
+    assertThat(server().getBeanState(bean).isReadOnly()).isFalse();
+  }
+
+  @Test
+  public void createReference_whenReadOnly() {
+
+    Customer bean = customerDesc.createReference(Boolean.TRUE, false, 42, null);
+    assertThat(server().getBeanState(bean).isReadOnly()).isTrue();
+  }
+
+  @Test
+  public void createReference_whenNotReadOnly() {
+
+    Customer bean = customerDesc.createReference(Boolean.FALSE, false, 42, null);
+    assertThat(server().getBeanState(bean).isReadOnly()).isFalse();
+  }
+
+  @Test
+  public void createReference_when_disabledLazyLoad() {
+
+    Customer bean = customerDesc.createReference(Boolean.FALSE, true, 42, null);
+    assertThat(server().getBeanState(bean).isDisableLazyLoad()).isTrue();
+  }
+
+  @Test
+  public void allProperties() {
+
+    BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
+    Collection<? extends Property> props = desc.allProperties();
+
+    assertThat(props).extracting("name").contains("id", "status", "orderDate", "shipDate");
+  }
+
+  @Test
+  public void merge_when_empty() {
+
+    Customer from = new Customer();
+    from.setId(42);
+    from.setName("rob");
+
+    Customer to = new Customer();
+    customerDesc.merge((EntityBean) from, (EntityBean) to);
+
+    assertThat(to.getId()).isEqualTo(42);
+    assertThat(to.getName()).isEqualTo("rob");
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_documentMappingTest.java

@@ -0,0 +1,85 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.BaseTestCase;
+import io.ebeanservice.docstore.api.mapping.DocPropertyAdapter;
+import io.ebeanservice.docstore.api.mapping.DocPropertyMapping;
+import io.ebeanservice.docstore.api.mapping.DocumentMapping;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BeanDescriptor_documentMappingTest extends BaseTestCase {
+
+
+  @Test
+  public void docMapping() {
+
+    BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
+
+    DocumentMapping documentMapping = desc.getDocMapping();
+
+    DocPropertyMapping properties = documentMapping.getProperties();
+
+    assertThat(properties).isNotNull();
+  }
+
+  @Test
+  public void docMapping_visitor() {
+
+    BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
+
+    DocumentMapping documentMapping = desc.getDocMapping();
+
+    DocPropertyMapping properties = documentMapping.getProperties();
+
+    assertThat(properties).isNotNull();
+
+    TDVisitor tdVisitor = new TDVisitor();
+    documentMapping.visit(tdVisitor);
+
+    assertThat(tdVisitor.sb.toString()).isEqualTo("{status,orderDate,shipDate, object{customer:id,name,}customerName, nested{details: [id,orderQty,shipQty,unitPrice,cretime,updtime,]}cretime,updtime,}");
+  }
+
+  class TDVisitor extends DocPropertyAdapter {
+
+    StringBuilder sb = new StringBuilder();
+
+    @Override
+    public void visitProperty(DocPropertyMapping property) {
+      sb.append(property.getName() + ",");
+    }
+
+    @Override
+    public void visitBegin() {
+
+      sb.append("{");
+    }
+
+    @Override
+    public void visitEnd() {
+      sb.append("}");
+    }
+
+    @Override
+    public void visitBeginObject(DocPropertyMapping property) {
+      sb.append(" object{" + property.getName() + ":");
+    }
+
+    @Override
+    public void visitEndObject(DocPropertyMapping property) {
+      sb.append("}");
+    }
+
+    @Override
+    public void visitBeginList(DocPropertyMapping property) {
+      sb.append(" nested{" + property.getName() + ": [");
+    }
+
+    @Override
+    public void visitEndList(DocPropertyMapping property) {
+      sb.append("]}");
+    }
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_registerTest.java

@@ -0,0 +1,111 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.EbeanServerFactory;
+import io.ebean.config.ServerConfig;
+import io.ebean.event.AbstractBeanPersistListener;
+import io.ebean.event.BeanPersistAdapter;
+import io.ebean.event.BeanPersistListener;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.EBasic;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class BeanDescriptor_registerTest {
+
+  @Test
+  public void testRegisterDeregister() throws Exception {
+
+    System.setProperty("ebean.ignoreExtraDdl", "true");
+
+    ServerConfig config = new ServerConfig();
+
+    config.setName("h2other");
+    config.loadFromProperties();
+    config.setRegister(false);
+    config.setDefaultServer(false);
+    config.getClasses().add(EBasic.class);
+
+    SpiEbeanServer ebeanServer = (SpiEbeanServer) EbeanServerFactory.create(config);
+    BeanDescriptor<EBasic> desc = ebeanServer.getBeanDescriptor(EBasic.class);
+
+    persistListenerRegistrationTests(desc);
+    persistControllerRegistrationTests(desc);
+  }
+
+  private void persistControllerRegistrationTests(BeanDescriptor<EBasic> desc) {
+
+    Controller1 controller1 = new Controller1();
+
+    assertNull(desc.getPersistController());
+    desc.register(controller1);
+    assertSame(controller1, desc.getPersistController());
+
+    Controller2 controller2 = new Controller2();
+    desc.register(controller2);
+
+    assertEquals(2, ((ChainedBeanPersistController) desc.getPersistController()).size());
+
+    desc.deregister(controller1);
+    assertEquals(1, ((ChainedBeanPersistController) desc.getPersistController()).size());
+
+    desc.deregister(controller2);
+    assertEquals(0, ((ChainedBeanPersistController) desc.getPersistController()).size());
+  }
+
+  private void persistListenerRegistrationTests(BeanDescriptor<EBasic> desc) {
+
+    Listener1 listener1 = new Listener1();
+
+    assertNull(desc.getPersistListener());
+    desc.register(listener1);
+    assertSame(listener1, desc.getPersistListener());
+
+    Listener2 listener2 = new Listener2();
+    desc.register(listener2);
+
+    BeanPersistListener persistListener = desc.getPersistListener();
+    assertTrue(persistListener instanceof ChainedBeanPersistListener);
+    assertEquals(2, ((ChainedBeanPersistListener) persistListener).size());
+
+    desc.deregister(listener1);
+    assertEquals(1, ((ChainedBeanPersistListener) desc.getPersistListener()).size());
+
+    desc.deregister(listener2);
+    assertEquals(0, ((ChainedBeanPersistListener) desc.getPersistListener()).size());
+  }
+
+  public static class Listener1 extends AbstractBeanPersistListener {
+
+    @Override
+    public boolean isRegisterFor(Class<?> cls) {
+      return EBasic.class.isAssignableFrom(cls);
+    }
+
+  }
+
+  public static class Listener2 extends AbstractBeanPersistListener {
+
+    @Override
+    public boolean isRegisterFor(Class<?> cls) {
+      return EBasic.class.isAssignableFrom(cls);
+    }
+
+  }
+
+  public static class Controller1 extends BeanPersistAdapter {
+
+    @Override
+    public boolean isRegisterFor(Class<?> cls) {
+      return EBasic.class.isAssignableFrom(cls);
+    }
+  }
+
+  public static class Controller2 extends BeanPersistAdapter {
+
+    @Override
+    public boolean isRegisterFor(Class<?> cls) {
+      return EBasic.class.isAssignableFrom(cls);
+    }
+  }
+}

src/test/java/io/ebeaninternal/server/deploy/BeanDescriptor_whenCreatedPropertyTest.java

@@ -0,0 +1,35 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasic;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+
+public class BeanDescriptor_whenCreatedPropertyTest extends BaseTestCase {
+
+
+  @Test
+  public void test() {
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getDefaultServer();
+
+    BeanDescriptor<Customer> desc = server.getBeanDescriptor(Customer.class);
+
+    BeanProperty whenCreatedProperty = desc.getWhenCreatedProperty();
+    assertEquals("cretime", whenCreatedProperty.getDbColumn());
+
+    BeanProperty whenModifiedProperty = desc.getWhenModifiedProperty();
+    assertEquals("updtime", whenModifiedProperty.getDbColumn());
+
+
+    BeanDescriptor<EBasic> eBasicDesc = server.getBeanDescriptor(EBasic.class);
+    assertNull(eBasicDesc.getWhenCreatedProperty());
+    assertNull(eBasicDesc.getWhenModifiedProperty());
+  }
+}

src/test/java/io/ebeaninternal/server/deploy/BeanPropertyAssocManyTest.java

@@ -0,0 +1,63 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.BaseTestCase;
+import io.ebean.bean.BeanCollection;
+import io.ebean.bean.EntityBean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+
+public class BeanPropertyAssocManyTest extends BaseTestCase {
+
+  BeanDescriptor<Customer> customerDesc = spiEbeanServer().getBeanDescriptor(Customer.class);
+
+  BeanPropertyAssocMany<Customer> contacts() {
+    return (BeanPropertyAssocMany<Customer>) customerDesc.getBeanProperty("contacts");
+  }
+
+  @Test
+  public void createReferenceIfNull_when_notBeanCollection_expect_null() {
+
+    Customer customer = new Customer();
+    customer.setContacts(new ArrayList<>());
+
+    BeanCollection<?> ref = contacts().createReferenceIfNull((EntityBean) customer);
+    assertNull(ref);
+  }
+
+  @Test
+  public void createReferenceIfNull_when_null_expect_ref() {
+
+    Customer customer = new Customer();
+    customer.setContacts(null);
+
+    BeanCollection<?> ref = contacts().createReferenceIfNull((EntityBean) customer);
+    assertNotNull(ref);
+    assertTrue(ref.isReference());
+  }
+
+
+  @Test
+  public void findIdsByParentId() {
+
+    ResetBasicData.reset();
+
+    List<Object> customerIds = new ArrayList<>();
+    customerIds.add(1L);
+    customerIds.add(2L);
+
+    List<Object> contactIdsForOne = contacts().findIdsByParentId(1L, null, null, null);
+
+    List<Object> contactIdsForMultiple = contacts().findIdsByParentId(null, customerIds, null, null);
+
+    assertThat(contactIdsForOne).isNotEmpty();
+    assertThat(contactIdsForMultiple).isNotEmpty();
+  }
+}

src/test/java/io/ebeaninternal/server/deploy/DeployPropertyParserMapTests.java

@@ -0,0 +1,25 @@
+package io.ebeaninternal.server.deploy;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class DeployPropertyParserMapTests {
+
+  @Test
+  public void test_like_escape() {
+
+
+    Map<String, String> map = new HashMap<>();
+    map.put("customer.name", "t1.name");
+    map.put("id", "t0.id");
+
+    DeployPropertyParserMap parser = new DeployPropertyParserMap(map);
+
+    String output = parser.parse("(lower(customer.name) like ? escape'' or id > ?)");
+    Assert.assertEquals("(lower(t1.name) like ? escape'' or t0.id > ?)", output);
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/DetermineAggPathTest.java

@@ -0,0 +1,34 @@
+package io.ebeaninternal.server.deploy;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class DetermineAggPathTest {
+
+  @Test
+  public void path() throws Exception {
+
+    assertThat(DetermineAggPath.path("count(details)")).isEqualTo("details");
+    assertThat(DetermineAggPath.path("count(details )")).isEqualTo("details");
+
+    assertThat(DetermineAggPath.path("count(person.contacts)")).isEqualTo("person.contacts");
+    assertThat(DetermineAggPath.path("sum(details.quantity*details.unitPrice)")).isEqualTo("details.quantity");
+  }
+
+  @Test
+  public void paths_simple() throws Exception {
+
+    DetermineAggPath.Path paths = DetermineAggPath.paths("count(details)");
+    assertThat(paths.paths).isEqualTo(new String[]{"details"});
+  }
+
+  @Test
+  public void paths_nested() throws Exception {
+
+    DetermineAggPath.Path paths = DetermineAggPath.paths("count(person.contacts)");
+    assertThat(paths.paths).isEqualTo(new String[]{"person", "contacts"});
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/TableJoinColumnTest.java

@@ -0,0 +1,49 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TableJoinColumnTest {
+
+  TableJoinColumn col(String localDbColumn, String foreignDbColumn, boolean insertable, boolean updateable) {
+    DeployTableJoinColumn column = new DeployTableJoinColumn(localDbColumn, foreignDbColumn, insertable, updateable);
+    return new TableJoinColumn(column);
+  }
+
+  @Test
+  public void equals_when_same() {
+    assertSame(col("a", "b", true, true), col("a", "b", true, true));
+  }
+
+  @Test
+  public void equals_when_diffFirstCol() {
+    assertDifferent(col("a", "b", true, true), col("c", "b", true, true));
+  }
+
+  @Test
+  public void equals_when_diffSecondCol() {
+    assertDifferent(col("a", "b", true, true), col("a", "c", true, true));
+  }
+
+  @Test
+  public void equals_when_diffInsertable() {
+    assertDifferent(col("a", "b", true, true), col("a", "b", false, true));
+  }
+
+  @Test
+  public void equals_when_diffUpdateable() {
+    assertDifferent(col("a", "b", true, true), col("a", "b", true, false));
+  }
+
+  private void assertDifferent(TableJoinColumn col, TableJoinColumn col2) {
+    assertThat(col).isNotEqualTo(col2);
+    assertThat(col.hashCode()).isNotEqualTo(col2.hashCode());
+  }
+
+  private void assertSame(TableJoinColumn col, TableJoinColumn col2) {
+    assertThat(col).isEqualTo(col2);
+    assertThat(col.hashCode()).isEqualTo(col2.hashCode());
+  }
+}

src/test/java/io/ebeaninternal/server/deploy/TableJoinTest.java

@@ -0,0 +1,67 @@
+package io.ebeaninternal.server.deploy;
+
+
+import io.ebeaninternal.server.deploy.meta.DeployTableJoin;
+import io.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TableJoinTest {
+
+  DeployTableJoinColumn col(String localDbColumn, String foreignDbColumn, boolean insertable, boolean updateable) {
+    return new DeployTableJoinColumn(localDbColumn, foreignDbColumn, insertable, updateable);
+  }
+
+  TableJoin table(String tableName, String col1, String col2) {
+    DeployTableJoin deploy = new DeployTableJoin();
+    deploy.setTable(tableName);
+    deploy.addJoinColumn(col(col1, col2, true, true));
+    return new TableJoin(deploy);
+  }
+
+  TableJoin table(String tableName, String col1, String col2, String col3, String col4) {
+    DeployTableJoin deploy = new DeployTableJoin();
+    deploy.setTable(tableName);
+    deploy.addJoinColumn(col(col1, col2, true, true));
+    deploy.addJoinColumn(col(col3, col4, true, true));
+    return new TableJoin(deploy);
+  }
+
+  @Test
+  public void equals_when_same() {
+    assertSame(table("myTable", "a", "b"), table("myTable", "a", "b"));
+  }
+
+  @Test
+  public void equals_when_diffTable() {
+    assertDifferent(table("myTable", "a", "b"), table("diffTable", "a", "b"));
+  }
+
+  @Test
+  public void equals_when_diffColumn() {
+    assertDifferent(table("myTable", "a", "b"), table("myTable", "c", "b"));
+  }
+
+  @Test
+  public void equals_when_moreColumns() {
+    assertDifferent(table("myTable", "a", "b"), table("myTable", "a", "b", "c", "d"));
+  }
+
+  @Test
+  public void equals_when_lessColumns() {
+    assertDifferent(table("myTable", "a", "b", "c", "d"), table("myTable", "a", "b"));
+  }
+
+  void assertSame(TableJoin join1, TableJoin join2) {
+    assertThat(join1).isEqualTo(join1);
+    assertThat(join1.hashCode()).isEqualTo(join1.hashCode());
+  }
+
+
+  void assertDifferent(TableJoin join1, TableJoin join2) {
+    assertThat(join1).isNotEqualTo(join2);
+    assertThat(join1.hashCode()).isNotEqualTo(join2.hashCode());
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/TestBeanDescriptorHasIdProperty.java

@@ -0,0 +1,110 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.EntityBeanIntercept;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.composite.RCustomer;
+import org.tests.model.composite.RCustomerKey;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
+
+  SpiEbeanServer spiServer;
+
+  public TestBeanDescriptorHasIdProperty() {
+    EbeanServer server = Ebean.getServer(null);
+    spiServer = (SpiEbeanServer) server;
+  }
+
+  @Test
+  public void testHasId() {
+
+    BeanDescriptor<Order> beanDescriptor = spiServer.getBeanDescriptor(Order.class);
+    assertNotNull(beanDescriptor.getIdProperty());
+    assertEquals("id", beanDescriptor.getIdProperty().getName());
+
+    assertNotNull(beanDescriptor.getVersionProperty());
+    assertEquals("updtime", beanDescriptor.getVersionProperty().getName());
+
+    Order order = new Order();
+
+    assertFalse(beanDescriptor.hasIdValue(entityBean(order)));
+    assertFalse(beanDescriptor.hasVersionProperty(getIntercept(order)));
+
+    order.setId(23);
+    order.setUpdtime(new Timestamp(System.currentTimeMillis()));
+
+    assertTrue(beanDescriptor.hasIdValue(entityBean(order)));
+    assertTrue(beanDescriptor.hasVersionProperty(getIntercept(order)));
+
+  }
+
+  @Test
+  public void testIsReference() {
+
+    BeanDescriptor<Customer> beanDescriptor = spiServer.getBeanDescriptor(Customer.class);
+
+    Customer order = new Customer();
+    EntityBeanIntercept ebi = getIntercept(order);
+    assertFalse(beanDescriptor.hasIdPropertyOnly(ebi));
+
+    order.setId(23);
+    assertTrue(beanDescriptor.hasIdPropertyOnly(ebi));
+
+    order.setName("custName");
+    assertFalse(beanDescriptor.hasIdPropertyOnly(ebi));
+  }
+
+  @Test
+  public void test_getIdForJson() {
+
+    BeanDescriptor<Order> orderDesc = spiServer.getBeanDescriptor(Order.class);
+
+    Order order = new Order();
+    order.setId(42);
+    assertEquals(42, orderDesc.getIdForJson(order));
+
+    assertEquals(42, orderDesc.convertIdFromJson(42));
+    assertEquals(42, orderDesc.convertIdFromJson("42"));
+    assertEquals(42, orderDesc.convertIdFromJson(42L));
+
+
+    RCustomerKey key = new RCustomerKey();
+    key.setCompany("comp");
+    key.setName("fred");
+
+    RCustomer rCustomer = new RCustomer();
+    rCustomer.setKey(key);
+
+    BeanDescriptor<RCustomer> rcustDesc = spiServer.getBeanDescriptor(RCustomer.class);
+
+    Map<String, Object> idForJson = (Map<String, Object>) rcustDesc.getIdForJson(rCustomer);
+    assertEquals("comp", idForJson.get("company"));
+    assertEquals("fred", idForJson.get("name"));
+    assertEquals(2, idForJson.size());
+
+    RCustomerKey keyVal = (RCustomerKey) rcustDesc.convertIdFromJson(idForJson);
+    assertEquals("comp", keyVal.getCompany());
+    assertEquals("fred", keyVal.getName());
+
+  }
+
+  private EntityBean entityBean(Object bean) {
+    return (EntityBean) bean;
+  }
+
+  private EntityBeanIntercept getIntercept(Object bean) {
+    return ((EntityBean) bean)._ebean_getIntercept();
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/TestCollectionLoadedStatus.java

@@ -0,0 +1,41 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.bean.BeanCollection;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.EntityBeanIntercept;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestCollectionLoadedStatus extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    BeanDescriptor<Customer> custDesc = server.getBeanDescriptor(Customer.class);
+
+    Customer customer = new Customer();
+    EntityBean eb = (EntityBean) customer;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    BeanProperty contactsProperty = custDesc.getBeanProperty("contacts");
+    Assert.assertFalse(ebi.isLoadedProperty(contactsProperty.getPropertyIndex()));
+
+    Object contactsViaInternal = contactsProperty.getValue(eb);
+    Assert.assertNull(contactsViaInternal);
+    Assert.assertFalse(ebi.isLoadedProperty(contactsProperty.getPropertyIndex()));
+
+    List<Contact> contacts = customer.getContacts();
+    Assert.assertNotNull(contacts);
+    Assert.assertTrue(contacts instanceof BeanCollection);
+    Assert.assertTrue(ebi.isLoadedProperty(contactsProperty.getPropertyIndex()));
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/TestNotEnhancedMappedSuper.java

@@ -0,0 +1,40 @@
+package io.ebeaninternal.server.deploy;
+
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.bean.EntityBean;
+import org.tests.model.mappedsuper.ASimpleBean;
+import org.tests.model.mappedsuper.NotEnhancedMappedSuper;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestNotEnhancedMappedSuper extends BaseTestCase {
+
+  @Test
+  public void simpleBean_mappedSuperNotEnhanced_ok() {
+
+    ASimpleBean bean = new ASimpleBean();
+    bean.setName("junk");
+
+    Ebean.save(bean);
+    Assert.assertNotNull(bean.getId());
+
+    bean.setName("junk mod");
+    Ebean.save(bean);
+
+    ASimpleBean fetched = Ebean.find(ASimpleBean.class, bean.getId());
+    Assert.assertEquals("junk mod", fetched.getName());
+    Assert.assertEquals(bean.getName(), fetched.getName());
+
+    Ebean.delete(bean);
+    ASimpleBean fetched2 = Ebean.find(ASimpleBean.class, bean.getId());
+    Assert.assertNull(fetched2);
+
+    NotEnhancedMappedSuper mappedSuper = new NotEnhancedMappedSuper();
+    boolean enhanced = (mappedSuper instanceof EntityBean);
+    Assert.assertFalse(enhanced);
+
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/TestReferenceWithConstructorProperties.java

@@ -0,0 +1,37 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Set;
+
+public class TestReferenceWithConstructorProperties extends BaseTestCase {
+
+  /**
+   * Test when constructor sets some properties.
+   */
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+    Order order = Ebean.getReference(Order.class, 1);
+
+    BeanState beanState = Ebean.getBeanState(order);
+    Set<String> loadedProps = beanState.getLoadedProps();
+
+    Assert.assertEquals(1, loadedProps.size());
+    Assert.assertTrue(beanState.isReference());
+
+    // read the status invokes lazy loading
+    order.getStatus();
+
+    Assert.assertFalse(beanState.isReference());
+
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/generatedproperty/InsertTimestampFactoryTest.java

@@ -0,0 +1,68 @@
+package io.ebeaninternal.server.deploy.generatedproperty;
+
+import io.ebean.config.ClassLoadConfig;
+import io.ebeaninternal.server.deploy.meta.DeployBeanProperty;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+
+import static org.junit.Assert.assertTrue;
+
+public class InsertTimestampFactoryTest {
+
+  InsertTimestampFactory factory = new InsertTimestampFactory(new ClassLoadConfig());
+
+  @Test
+  public void test_createdTimestamp_Instant() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, Instant.class, null, null);
+
+    GeneratedProperty insertTimestamp = factory.createInsertTimestamp(prop);
+    Object value = insertTimestamp.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof Instant);
+  }
+
+  @Test
+  public void test_createdTimestamp_LocalDateTime() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, LocalDateTime.class, null, null);
+
+    GeneratedProperty insertTimestamp = factory.createInsertTimestamp(prop);
+    Object value = insertTimestamp.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof LocalDateTime);
+  }
+
+  @Test
+  public void test_createdTimestamp_OffsetDateTime() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, OffsetDateTime.class, null, null);
+
+    GeneratedProperty insertTimestamp = factory.createInsertTimestamp(prop);
+    Object value = insertTimestamp.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof OffsetDateTime);
+  }
+
+  @Test
+  public void test_createdTimestamp_Timestamp() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, Timestamp.class, null, null);
+
+    GeneratedProperty insertTimestamp = factory.createInsertTimestamp(prop);
+    Object value = insertTimestamp.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof Timestamp);
+  }
+
+  @Test
+  public void test_createdTimestamp_utilDate() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, java.util.Date.class, null, null);
+
+    GeneratedProperty insertTimestamp = factory.createInsertTimestamp(prop);
+    Object value = insertTimestamp.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof java.util.Date);
+  }
+
+}

src/test/java/io/ebeaninternal/server/deploy/generatedproperty/UpdateTimestampFactoryTest.java

@@ -0,0 +1,68 @@
+package io.ebeaninternal.server.deploy.generatedproperty;
+
+import io.ebean.config.ClassLoadConfig;
+import io.ebeaninternal.server.deploy.meta.DeployBeanProperty;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+
+import static org.junit.Assert.assertTrue;
+
+public class UpdateTimestampFactoryTest {
+
+
+  UpdateTimestampFactory factory = new UpdateTimestampFactory(new ClassLoadConfig());
+
+  @Test
+  public void test_createdTimestamp_Instant() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, Instant.class, null, null);
+
+    GeneratedProperty generatedProperty = factory.createUpdateTimestamp(prop);
+    Object value = generatedProperty.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof Instant);
+  }
+
+  @Test
+  public void test_createdTimestamp_LocalDateTime() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, LocalDateTime.class, null, null);
+
+    GeneratedProperty generatedProperty = factory.createUpdateTimestamp(prop);
+    Object value = generatedProperty.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof LocalDateTime);
+  }
+
+  @Test
+  public void test_createdTimestamp_OffsetDateTime() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, OffsetDateTime.class, null, null);
+
+    GeneratedProperty generatedProperty = factory.createUpdateTimestamp(prop);
+    Object value = generatedProperty.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof OffsetDateTime);
+  }
+
+  @Test
+  public void test_createdTimestamp_Timestamp() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, Timestamp.class, null, null);
+
+    GeneratedProperty generatedProperty = factory.createUpdateTimestamp(prop);
+    Object value = generatedProperty.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof Timestamp);
+  }
+
+  @Test
+  public void test_createdTimestamp_utilDate() {
+
+    DeployBeanProperty prop = new DeployBeanProperty(null, java.util.Date.class, null, null);
+
+    GeneratedProperty generatedProperty = factory.createUpdateTimestamp(prop);
+    Object value = generatedProperty.getInsertValue(null, null, System.currentTimeMillis());
+    assertTrue(value instanceof java.util.Date);
+  }
+}

src/test/java/io/ebeaninternal/server/expression/AllEqualsExpressionTest.java

@@ -0,0 +1,118 @@
+package io.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class AllEqualsExpressionTest {
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", 10).isSameByPlan(exp("a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameMultiple() {
+
+    assertThat(exp("a", 10, "b", "23").isSameByBind(exp("a", 10, "b", "23"))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindValue() {
+
+    assertThat(exp("a", 10).isSameByPlan(exp("a", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_multiple() {
+
+    assertThat(exp("a", 10, "b", 20, "c", 30).isSameByPlan(exp("a", 10, "b", 20, "c", 30))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_less() {
+
+    assertThat(exp("a", 10, "b", 20, "c", 30).isSameByPlan(exp("a", 10, "b", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_more() {
+
+    assertThat(exp("a", 10, "b", 20).isSameByPlan(exp("a", 10, "b", 20, "c", 30))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty_diff() {
+
+    assertThat(exp("a", 10).isSameByPlan(exp("b", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_diff() {
+
+    assertThat(exp("a", 10).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindByNull_last() {
+
+    assertThat(exp("a", 10).isSameByPlan(exp("a", null))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindByNull_first() {
+
+    assertThat(exp("a", null).isSameByPlan(exp("a", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_differentExpressionType() {
+
+    assertThat(exp("a", null).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindByNull_last() {
+
+    assertThat(exp("a", 10).isSameByBind(exp("a", null))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindByNull_first() {
+
+    assertThat(exp("a", null).isSameByBind(exp("a", 10))).isFalse();
+  }
+
+
+  @NotNull
+  private AllEqualsExpression exp(Map<String, Object> propMap) {
+    return new AllEqualsExpression(propMap);
+  }
+
+  AllEqualsExpression exp(String key0, Object val1) {
+    LinkedHashMap<String, Object> map = new LinkedHashMap<>();
+    map.put(key0, val1);
+    return exp(map);
+  }
+
+
+  AllEqualsExpression exp(String key0, Object val1, String key2, Object val2) {
+    LinkedHashMap<String, Object> map = new LinkedHashMap<>();
+    map.put(key0, val1);
+    map.put(key2, val2);
+    return exp(map);
+  }
+
+  AllEqualsExpression exp(String key0, Object val1, String key2, Object val2, String key3, Object val3) {
+    LinkedHashMap<String, Object> map = new LinkedHashMap<>();
+    map.put(key0, val1);
+    map.put(key2, val2);
+    map.put(key3, val3);
+    return exp(map);
+  }
+}

src/test/java/io/ebeaninternal/server/expression/BaseExpressionTest.java

@@ -0,0 +1,13 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.BaseTestCase;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Order;
+
+public abstract class BaseExpressionTest extends BaseTestCase {
+
+  protected DefaultExpressionRequest newExpressionRequest() {
+    BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
+    return new DefaultExpressionRequest(desc);
+  }
+}

src/test/java/io/ebeaninternal/server/expression/BetweenExpressionTest.java

@@ -0,0 +1,69 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebeaninternal.api.SpiExpression;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class BetweenExpressionTest extends BaseExpressionTest {
+
+  @Test
+  public void addSql() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    BetweenExpression exp = new BetweenExpression("startDate", 1, 2);
+    exp.addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("startDate between  ? and ? ");
+  }
+
+  @Test
+  public void copyForPlanKey_isSameInstance() throws Exception {
+
+    BetweenExpression exp = new BetweenExpression("startDate", 1, 2);
+    SpiExpression other = exp.copyForPlanKey();
+
+    assertThat(exp).isSameAs(other);
+  }
+
+  @Test
+  public void isSameByPlan_when_properties_match() throws Exception {
+
+    BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
+    BetweenExpression exp1 = new BetweenExpression("startDate", 3, 4);
+
+    assertThat(exp0.isSameByPlan(exp1)).isTrue();
+    assertThat(exp1.isSameByPlan(exp0)).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_properties_do_not_match() throws Exception {
+
+    BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
+    BetweenExpression exp1 = new BetweenExpression("endDate", 1, 2);
+
+    assertThat(exp0.isSameByPlan(exp1)).isFalse();
+    assertThat(exp1.isSameByPlan(exp0)).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_values_do_not_match() throws Exception {
+
+    BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
+    BetweenExpression exp1 = new BetweenExpression("startDate", 1, 3);
+
+    assertThat(exp0.isSameByBind(exp1)).isFalse();
+    assertThat(exp1.isSameByBind(exp0)).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_values_match() throws Exception {
+
+    BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
+    BetweenExpression exp1 = new BetweenExpression("startDate", 1, 2);
+
+    assertThat(exp0.isSameByBind(exp1)).isTrue();
+    assertThat(exp1.isSameByBind(exp0)).isTrue();
+  }
+}

src/test/java/io/ebeaninternal/server/expression/BetweenPropertyExpressionTest.java

@@ -0,0 +1,45 @@
+package io.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class BetweenPropertyExpressionTest {
+
+  @NotNull
+  private BetweenPropertyExpression exp(String lowProperty, String highProperty, Object value) {
+    return new BetweenPropertyExpression(lowProperty, highProperty, value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+    assertThat(exp("a", "b", 10).isSameByPlan(exp("a", "b", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffValue() {
+    assertThat(exp("a", "b", 10).isSameByPlan(exp("a", "b", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty() {
+    assertThat(exp("a", "b", 10).isSameByPlan(exp("a", "c", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExpressionType() {
+    assertThat(exp("a", "b", 10).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_same() {
+    assertThat(exp("a", "b", 10).isSameByBind(exp("a", "b", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diff() {
+    assertThat(exp("a", "b", 10).isSameByBind(exp("a", "b", 20))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/CaseInsensitiveEqualExpressionTest.java

@@ -0,0 +1,50 @@
+package io.ebeaninternal.server.expression;
+
+
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class CaseInsensitiveEqualExpressionTest {
+
+  CaseInsensitiveEqualExpression exp(String propName, String value) {
+    return new CaseInsensitiveEqualExpression(propName, value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", "10").isSameByPlan(exp("a", "10"))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("a", "10").isSameByPlan(exp("a", "20"))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty_diff() {
+
+    assertThat(exp("a", "10").isSameByPlan(exp("b", "10"))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_diff() {
+
+    assertThat(exp("a", "10").isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", "10").isSameByBind(exp("b", "10"))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", "10").isSameByBind(exp("b", "20"))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/DefaultExampleExpressionTest.java

@@ -0,0 +1,124 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.BaseTestCase;
+import io.ebean.LikeType;
+import io.ebean.Query;
+import io.ebean.bean.EntityBean;
+import io.ebean.event.BeanQueryRequest;
+import io.ebeaninternal.api.HashQueryPlanBuilder;
+import io.ebeaninternal.api.ManyWhereJoins;
+import io.ebeaninternal.api.SpiQuery;
+import io.ebeaninternal.server.core.OrmQueryRequest;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class DefaultExampleExpressionTest extends BaseTestCase {
+
+
+  Customer customer() {
+    Address address = new Address();
+    address.setCity("billingAddress.city");
+
+    Customer customer = new Customer();
+    customer.setName("name");
+    customer.setBillingAddress(address);
+    return customer;
+  }
+
+  DefaultExampleExpression exp() {
+    Customer customer = customer();
+    return new DefaultExampleExpression((EntityBean) customer, false, LikeType.EQUAL_TO);
+  }
+
+  DefaultExampleExpression expExtra() {
+    Customer customer = customer();
+    customer.setSmallnote("smallNote");
+    return new DefaultExampleExpression((EntityBean) customer, false, LikeType.EQUAL_TO);
+  }
+
+  DefaultExampleExpression expDiffName() {
+    Customer customer = customer();
+    customer.setName("otherName");
+    return new DefaultExampleExpression((EntityBean) customer, false, LikeType.EQUAL_TO);
+  }
+
+  BeanDescriptor<Customer> customerBeanDescriptor() {
+    return getBeanDescriptor(Customer.class);
+  }
+
+  DefaultExampleExpression prepare(DefaultExampleExpression expr) {
+
+    SpiQuery<Customer> query = (SpiQuery<Customer>) spiEbeanServer().find(Customer.class);
+    BeanQueryRequest<?> request = create(query);
+    expr.containsMany(customerBeanDescriptor(), new ManyWhereJoins());
+    expr.prepareExpression(request);
+    return expr;
+  }
+
+  @Test
+  public void test() {
+
+    DefaultExampleExpression expr = exp();
+
+    prepare(expr);
+
+    HashQueryPlanBuilder builder = new HashQueryPlanBuilder();
+    expr.queryPlanHash(builder);
+
+    TDSpiExpressionRequest req = new TDSpiExpressionRequest(customerBeanDescriptor());
+    expr.addBindValues(req);
+
+    assertThat(req.bindValues).contains("name", "billingAddress.city");
+
+    Customer customer = customer();
+    customer.setName("Rob");
+    customer.getBillingAddress().setCity("Auckland");
+
+    ResetBasicData.reset();
+
+    Query<Customer> query1 = server().find(Customer.class)
+      .where().exampleLike(customer)
+      .query();
+
+    query1.findList();
+
+    assertThat(query1.getGeneratedSql()).contains("(t0.name like ? ");
+    assertThat(query1.getGeneratedSql()).contains(" and t1.city like ? ");
+
+  }
+
+  private <T> OrmQueryRequest<T> create(SpiQuery<T> query) {
+    return new OrmQueryRequest<>(null, null, query, null);
+  }
+
+  @Test
+  public void isSameByPlan_whenSame() {
+
+    assertThat(prepare(exp()).isSameByPlan(prepare(exp()))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindValue_stillSame() {
+
+    assertThat(prepare(exp()).isSameByPlan(prepare(expDiffName()))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_extraExpression_then_different() {
+
+    assertThat(prepare(exp()).isSameByPlan(prepare(expExtra()))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_lessExpression_then_different() {
+
+    assertThat(prepare(expExtra()).isSameByPlan(prepare(exp()))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/DefaultExpressionFactoryTest.java

@@ -0,0 +1,74 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.Expression;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+
+public class DefaultExpressionFactoryTest {
+
+  @Test
+  public void testLowerILike() throws Exception {
+
+    DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
+    Expression expression = factory.ilike("name", "foo");
+    assertThat(expression).isInstanceOf(LikeExpression.class);
+  }
+
+  @Test
+  public void testNativeILike() throws Exception {
+
+    DefaultExpressionFactory factory = new DefaultExpressionFactory(false, true);
+    Expression expression = factory.ilike("name", "foo");
+    assertThat(expression).isInstanceOf(NativeILikeExpression.class);
+  }
+
+  @Test
+  public void testEq() throws Exception {
+
+    DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
+    Expression expression = factory.eq("name", null);
+    assertThat(expression).isInstanceOf(NullExpression.class);
+  }
+
+  @Test
+  public void testNe() throws Exception {
+
+    DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
+    Expression expression = factory.ne("name", null);
+    assertThat(expression).isInstanceOf(NullExpression.class);
+  }
+
+  @Test
+  public void testIeq() throws Exception {
+
+    DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
+    Expression expression = factory.ieq("name", null);
+    assertThat(expression).isInstanceOf(NullExpression.class);
+  }
+
+  @Test
+  public void testEq_with_equalsWithNullAsNoop() throws Exception {
+
+    DefaultExpressionFactory factory = new DefaultExpressionFactory(true, false);
+    Expression expression = factory.eq("name", null);
+    assertThat(expression).isInstanceOf(NoopExpression.class);
+  }
+
+  @Test
+  public void testNe_with_equalsWithNullAsNoop() throws Exception {
+
+    DefaultExpressionFactory factory = new DefaultExpressionFactory(true, false);
+    Expression expression = factory.ne("name", null);
+    assertThat(expression).isInstanceOf(NoopExpression.class);
+  }
+
+  @Test
+  public void testIeq_with_equalsWithNullAsNoop() throws Exception {
+
+    DefaultExpressionFactory factory = new DefaultExpressionFactory(true, false);
+    Expression expression = factory.ieq("name", null);
+    assertThat(expression).isInstanceOf(NoopExpression.class);
+  }
+}

src/test/java/io/ebeaninternal/server/expression/DefaultExpressionListTest.java

@@ -0,0 +1,98 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.ExpressionList;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class DefaultExpressionListTest {
+
+
+  DefaultExpressionList exp() {
+
+    return new DefaultExpressionList<>(null, new DefaultExpressionFactory(true, true), null);
+  }
+
+  DefaultExpressionList spi(ExpressionList list) {
+    return (DefaultExpressionList) list;
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+      .isSameByPlan(spi(exp().eq("a", 10).eq("b", 20)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExpressionType() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+      .isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_less() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+      .isSameByPlan(spi(exp().eq("a", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_lessEmptyLast() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+      .isSameByPlan(spi(exp()))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_lessEmptyFirst() {
+
+    assertThat(spi(exp())
+      .isSameByPlan(spi(exp().eq("a", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_more() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+      .isSameByPlan(spi(exp().eq("a", 10).eq("b", 20).eq("c", 30)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperties() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+      .isSameByPlan(spi(exp().eq("c", 10).eq("b", 20)))).isFalse();
+  }
+
+
+  @Test
+  public void isSameByBind_when_same() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+      .isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffValues() {
+
+    assertThat(spi(exp().eq("a", 10).eq("b", 20))
+      .isSameByBind(spi(exp().eq("a", 10).eq("b", 30)))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_less() {
+
+    assertThat(spi(exp().eq("a", 10))
+      .isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_more() {
+
+    assertThat(spi(exp().eq("a", 10))
+      .isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/ExistsQueryExpressionTest.java

@@ -0,0 +1,85 @@
+package io.ebeaninternal.server.expression;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class ExistsQueryExpressionTest {
+
+
+  @NotNull
+  private ExistsQueryExpression exp(boolean not, String sql, Object... bindValues) {
+    return new ExistsQueryExpression(not, sql, Arrays.asList(bindValues));
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp(true, "a", 10).isSameByPlan(exp(true, "a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp(true, "a", 10).isSameByPlan(exp(true, "a", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffNot() {
+
+    assertThat(exp(true, "a", 10).isSameByPlan(exp(false, "a", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffSql() {
+
+    assertThat(exp(true, "a", 10).isSameByPlan(exp(true, "b", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp(true, "a", 10).isSameByBind(exp(true, "a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameMultipleBindValues() {
+
+    assertThat(exp(true, "a", 10, "ABC", 20).isSameByBind(exp(true, "a", 10, "ABC", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffMultipleBindValues() {
+
+    assertThat(exp(true, "a", 10, "ABC", 20).isSameByBind(exp(true, "a", 10, "ABC", 21))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffMultipleBindValuesByOrder() {
+
+    assertThat(exp(true, "a", 10, "ABC", 20).isSameByBind(exp(true, "a", 10, 20, "ABC"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp(true, "a", 10).isSameByBind(exp(true, "a", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+
+    assertThat(exp(true, "a", 10, 20).isSameByBind(exp(true, "a", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+
+    assertThat(exp(true, "a", 10).isSameByBind(exp(true, "a", 10, 20))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/IdExpressionTest.java

@@ -0,0 +1,41 @@
+package io.ebeaninternal.server.expression;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class IdExpressionTest {
+
+
+  @NotNull
+  private IdExpression exp(Object value) {
+    return new IdExpression(value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp(10).isSameByPlan(exp(10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp(10).isSameByPlan(exp(20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp(10).isSameByBind(exp(10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp(10).isSameByBind(exp(20))).isFalse();
+    assertThat(exp(10).isSameByBind(exp("junk"))).isFalse();
+  }
+}

src/test/java/io/ebeaninternal/server/expression/IdInExpressionTest.java

@@ -0,0 +1,67 @@
+package io.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class IdInExpressionTest {
+
+
+  @NotNull
+  private IdInExpression exp(Object... values) {
+    return new IdInExpression(Arrays.asList(values));
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp(10).isSameByPlan(exp(10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp(10).isSameByPlan(exp(20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindCount() {
+
+    assertThat(exp(10).isSameByPlan(exp(10, 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp(10).isSameByBind(exp(10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_mulitpleSameBindValues() {
+
+    assertThat(exp(10, "ABC", 20).isSameByBind(exp(10, "ABC", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp(10).isSameByBind(exp("junk"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+
+    assertThat(exp(10, "ABC", 20).isSameByBind(exp(10, "ABC"))).isFalse();
+  }
+
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+
+    assertThat(exp(10, "ABC").isSameByBind(exp(10, "ABC", 30))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/InExpressionTest.java

@@ -0,0 +1,174 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebeaninternal.api.HashQueryPlanBuilder;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+public class InExpressionTest {
+
+
+  @Test
+  public void queryPlanHash_given_diffPropertyName_should_differentPlanHash() throws Exception {
+
+    List<Integer> values = values(42, 92);
+
+    InExpression ex1 = new InExpression("foo", values, false);
+    InExpression ex2 = new InExpression("bar", values, false);
+
+    ex1.prepareExpression(null);
+    ex2.prepareExpression(null);
+
+    HashQueryPlanBuilder b1 = new HashQueryPlanBuilder();
+    ex1.queryPlanHash(b1);
+
+    HashQueryPlanBuilder b2 = new HashQueryPlanBuilder();
+    ex2.queryPlanHash(b2);
+
+    assertNotEquals(b1.build(), b2.build());
+  }
+
+  @Test
+  public void queryPlanHash_given_diffBindCount_should_differentPlanHash() throws Exception {
+
+    List<Integer> values1 = values(42, 92);
+    List<Integer> values2 = values(42, 92, 82);
+
+    InExpression ex1 = new InExpression("foo", values1, false);
+    InExpression ex2 = new InExpression("foo", values2, false);
+
+    ex1.prepareExpression(null);
+    ex2.prepareExpression(null);
+
+    HashQueryPlanBuilder b1 = new HashQueryPlanBuilder();
+    ex1.queryPlanHash(b1);
+
+    HashQueryPlanBuilder b2 = new HashQueryPlanBuilder();
+    ex2.queryPlanHash(b2);
+
+    assertNotEquals(b1.build(), b2.build());
+  }
+
+  @Test
+  public void queryPlanHash_given_diffNotFlag_should_differentPlanHash() throws Exception {
+
+    List<Integer> values = values(42, 92);
+
+    InExpression ex1 = new InExpression("foo", values, true);
+    InExpression ex2 = new InExpression("foo", values, false);
+
+    ex1.prepareExpression(null);
+    ex2.prepareExpression(null);
+
+    HashQueryPlanBuilder b1 = new HashQueryPlanBuilder();
+    ex1.queryPlanHash(b1);
+
+    HashQueryPlanBuilder b2 = new HashQueryPlanBuilder();
+    ex2.queryPlanHash(b2);
+
+    assertNotEquals(b1.build(), b2.build());
+  }
+
+  @Test
+  public void queryPlanHash_given_sameNotFlag_should_samePlanHash() throws Exception {
+
+    List<Integer> values = values(42, 92);
+
+    InExpression ex1 = new InExpression("foo", values, true);
+    InExpression ex2 = new InExpression("foo", values, true);
+
+    ex1.prepareExpression(null);
+    ex2.prepareExpression(null);
+
+    HashQueryPlanBuilder b1 = new HashQueryPlanBuilder();
+    ex1.queryPlanHash(b1);
+
+    HashQueryPlanBuilder b2 = new HashQueryPlanBuilder();
+    ex2.queryPlanHash(b2);
+
+    assertEquals(b1.build(), b2.build());
+  }
+
+  List<Integer> values(int... vals) {
+    ArrayList list = new ArrayList<Integer>();
+    for (int val : vals) {
+      list.add(val);
+    }
+    return list;
+  }
+
+  @NotNull
+  private InExpression exp(String propName, boolean not, Object... values) {
+    InExpression ex = new InExpression(propName, Arrays.asList(values), not);
+    ex.prepareExpression(null);
+    return ex;
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("a", false, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffPropertyName() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("b", false, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffNot() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("a", true, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("a", false, 10, 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindCount() {
+
+    assertThat(exp("a", false, 10).isSameByPlan(exp("a", false, 10, 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", false, 10).isSameByBind(exp("a", false, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameMultipleBindValues() {
+
+    assertThat(exp("a", false, 10, "ABC", 20).isSameByBind(exp("a", false, 10, "ABC", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", false, 10).isSameByBind(exp("a", false, "foo"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+
+    assertThat(exp("a", false, 10, "ABC", 20).isSameByBind(exp("a", false, 10, "ABC"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+
+    assertThat(exp("a", false, 10, "ABC").isSameByBind(exp("a", false, 10, "ABC", 30))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/InQueryExpressionTest.java

@@ -0,0 +1,89 @@
+package io.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class InQueryExpressionTest {
+
+
+  @NotNull
+  private InQueryExpression exp(String propertyName, boolean not, String sql, Object... bindValues) {
+    return new InQueryExpression(propertyName, not, sql, Arrays.asList(bindValues));
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("name", true, "sql", 10).isSameByPlan(exp("name", true, "sql", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("name", true, "sql", 10).isSameByPlan(exp("name", true, "sql", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffNPropertyName() {
+
+    assertThat(exp("name", true, "sql", 10).isSameByPlan(exp("nameDiff", true, "sql", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffNot() {
+
+    assertThat(exp("name", true, "sql", 10).isSameByPlan(exp("name", false, "sql", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffSql() {
+
+    assertThat(exp("name", true, "sql", 10).isSameByPlan(exp("name", true, "sqlDiff", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("name", true, "sql", 10).isSameByBind(exp("name", true, "sql", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameMultipleBindValues() {
+
+    assertThat(exp("name", true, "sql", 10, "ABC", 20).isSameByBind(exp("name", true, "sql", 10, "ABC", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffMultipleBindValues() {
+
+    assertThat(exp("name", true, "sql", 10, "ABC", 20).isSameByBind(exp("name", true, "sql", 10, "ABC", 21))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffMultipleBindValuesByOrder() {
+
+    assertThat(exp("name", true, "sql", 10, "ABC", 20).isSameByBind(exp("name", true, "sql", 10, 20, "ABC"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("name", true, "sql", 10).isSameByBind(exp("name", true, "sql", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+
+    assertThat(exp("name", true, "sql", 10, 20).isSameByBind(exp("name", true, "sql", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+
+    assertThat(exp("name", true, "sql", 10).isSameByBind(exp("name", true, "sql", 10, 20))).isFalse();
+  }
+}

src/test/java/io/ebeaninternal/server/expression/IsEmptyExpressionQueryTest.java

@@ -0,0 +1,114 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class IsEmptyExpressionQueryTest extends BaseTestCase {
+
+  @Test
+  public void isEmpty() {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = Ebean.find(Customer.class)
+      .select("id")
+      .where().isEmpty("contacts")
+      .query();
+
+    query.findList();
+    assertThat(sqlOf(query)).contains("select t0.id from o_customer t0 where not exists (select 1 from contact where customer_id = t0.id");
+  }
+
+  @Test
+  public void isNotEmpty() {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = Ebean.find(Customer.class)
+      .select("id")
+      .where().isNotEmpty("contacts")
+      .query();
+
+    query.findList();
+    assertThat(sqlOf(query)).contains("select t0.id from o_customer t0 where exists (select 1 from contact where customer_id = t0.id");
+  }
+
+  @Test
+  public void isEmpty_contacts() {
+
+    ResetBasicData.reset();
+
+    Query<Contact> query = Ebean.find(Contact.class)
+      .select("id")
+      .where().isEmpty("notes")
+      .query();
+
+    query.findList();
+    assertThat(sqlOf(query)).contains("select t0.id from contact t0 where not exists (select 1 from contact_note where contact_id = t0.id");
+  }
+
+  @Test
+  public void isNotEmpty_contacts() {
+
+    ResetBasicData.reset();
+
+    Query<Contact> query = Ebean.find(Contact.class)
+      .select("id")
+      .where().isNotEmpty("notes")
+      .query();
+
+    query.findList();
+    assertThat(sqlOf(query)).contains("select t0.id from contact t0 where exists (select 1 from contact_note where contact_id = t0.id");
+  }
+
+
+  @Test
+  public void isEmpty_manyToMany() {
+
+    ResetBasicData.reset();
+
+    Query<Contact> query = Ebean.find(Contact.class)
+      .select("id")
+      .where().isEmpty("notes")
+      .query();
+
+    query.findList();
+  }
+
+
+  @Test
+  public void isEmpty_nested() {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = Ebean.find(Customer.class)
+      .select("id")
+      .where().isEmpty("contacts.notes")
+      .query();
+
+    query.findList();
+    assertThat(sqlOf(query)).contains("select distinct t0.id from o_customer t0 join contact u1 on u1.customer_id = t0.id  where not exists (select 1 from contact_note where contact_id = u1.id)");
+  }
+
+  @Test
+  public void isNotEmpty_nested() {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = Ebean.find(Customer.class)
+      .select("id")
+      .where().isNotEmpty("contacts.notes")
+      .query();
+
+    query.findList();
+    assertThat(sqlOf(query)).contains("select distinct t0.id from o_customer t0 join contact u1 on u1.customer_id = t0.id  where exists (select 1 from contact_note where contact_id = u1.id)");
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/JsonPathExpressionTest.java

@@ -0,0 +1,81 @@
+package io.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class JsonPathExpressionTest {
+
+  @NotNull
+  private JsonPathExpression exp(String propertyName, String path, Op operator, Object value) {
+    return new JsonPathExpression(propertyName, path, operator, value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("a", "path", Op.EQ, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("a", "path", Op.EQ, 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffPath() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("a", "pathDiff", Op.EQ, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty_diff() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("b", "path", Op.EQ, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffOperator_diff() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(exp("a", "path", Op.LT, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_diff() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.LT, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_sameNullBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, null).isSameByBind(exp("a", "path", Op.LT, null))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.EQ, "junk"))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffFirstNullBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, null).isSameByBind(exp("a", "path", Op.LT, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_diffLastNullBindValues() {
+
+    assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.LT, null))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/JunctionExpressionTest.java

@@ -0,0 +1,61 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.Expr;
+import io.ebean.Expression;
+import io.ebean.Junction;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class JunctionExpressionTest {
+
+  Expression eq(String propName, int value) {
+    return Expr.eq(propName, value);
+  }
+
+
+  DefaultExpressionList<?> exp(Expression... expressions) {
+
+    DefaultExpressionList<Object> list = new DefaultExpressionList<>(null, new DefaultExpressionFactory(true, false), null);
+    for (Expression ex : expressions) {
+      list.add(ex);
+    }
+    return list;
+  }
+
+  <T> JunctionExpression and(DefaultExpressionList<T> list) {
+    return new JunctionExpression<>(Junction.Type.AND, list);
+  }
+
+  <T> JunctionExpression or(DefaultExpressionList<T> list) {
+    return new JunctionExpression<>(Junction.Type.OR, list);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(and(exp(eq("a", 10), eq("b", 10)))
+      .isSameByPlan(and(exp(eq("a", 10), eq("b", 10))))).isTrue();
+  }
+
+  @Test
+  public void copyForPlanKey_isSameByPlan_when_same() {
+
+    assertThat(and(exp(eq("a", 10), eq("b", 10)).copyForPlanKey())
+      .isSameByPlan(and(exp(eq("a", 10), eq("b", 10))))).isTrue();
+  }
+
+  @Test
+  public void copyForPlanKey_isSameByPlan_when_diff() {
+
+    assertThat(and(exp(eq("a", 10), eq("b", 10)).copyForPlanKey())
+      .isSameByPlan(and(exp(eq("a", 10), eq("c", 10))))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType() {
+
+    assertThat(and(exp(eq("a", 10), eq("b", 10)))
+      .isSameByPlan(or(exp(eq("a", 10), eq("b", 10))))).isFalse();
+  }
+}

src/test/java/io/ebeaninternal/server/expression/LikeExpressionTest.java

@@ -0,0 +1,66 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.LikeType;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class LikeExpressionTest extends BaseExpressionTest {
+
+
+  @NotNull
+  private LikeExpression exp(String propertyName, String value, boolean caseInsensitive, LikeType type) {
+    return new LikeExpression(propertyName, value, caseInsensitive, type);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+      .isSameByPlan(exp("a", "rob", true, LikeType.STARTS_WITH))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_then_stillSame() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+      .isSameByPlan(exp("a", "bor", true, LikeType.STARTS_WITH))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffCaseInsensitive() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+      .isSameByPlan(exp("a", "rob", false, LikeType.STARTS_WITH))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffLikeType() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+      .isSameByPlan(exp("a", "rob", true, LikeType.ENDS_WITH))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+      .isSameByPlan(exp("b", "rob", true, LikeType.STARTS_WITH))).isFalse();
+  }
+
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+      .isSameByBind(exp("a", "rob", true, LikeType.STARTS_WITH))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
+      .isSameByBind(exp("a", "bor", true, LikeType.STARTS_WITH))).isFalse();
+  }
+}

src/test/java/io/ebeaninternal/server/expression/LogicExpressionTest.java

@@ -0,0 +1,129 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.Expr;
+import io.ebean.Expression;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LogicExpressionTest extends BaseExpressionTest {
+
+  Expression eq(String propName, int value) {
+    return Expr.eq(propName, value);
+  }
+
+  LogicExpression and(Expression a, Expression b) {
+    return new LogicExpression.And(a, b);
+  }
+
+  LogicExpression or(Expression a, Expression b) {
+    return new LogicExpression.Or(a, b);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+      .isSameByPlan(and(eq("a", 10), eq("b", 10)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_then_stillSame() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+      .isSameByPlan(and(eq("a", 20), eq("b", 20)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExp1_then_diff() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+      .isSameByPlan(and(eq("c", 10), eq("b", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExp2_then_diff() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+      .isSameByPlan(and(eq("a", 10), eq("c", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_then_diff() {
+
+    assertThat(or(eq("a", 10), eq("b", 10))
+      .isSameByPlan(and(eq("a", 10), eq("c", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExpressionType() {
+
+    assertThat(or(eq("a", 10), eq("b", 10))
+      .isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+      .isSameByBind(and(eq("a", 10), eq("c", 10)))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(and(eq("a", 10), eq("b", 10))
+      .isSameByBind(and(eq("a", 10), eq("c", 20)))).isFalse();
+  }
+
+  @Test
+  public void nestedPath_when_notNested() {
+
+    LogicExpression and = and(eq("orderDate", 10), eq("shipDate", 10));
+
+    and.nestedPath(getBeanDescriptor(Order.class));
+
+    assertThat(and.expOne).isInstanceOf(SimpleExpression.class);
+    assertThat(and.expTwo).isInstanceOf(SimpleExpression.class);
+  }
+
+  @Test
+  public void nestedPath_when_nestedSame() {
+
+    LogicExpression and = and(eq("details.orderQty", 10), eq("details.unitPrice", 10));
+
+    String path = and.nestedPath(getBeanDescriptor(Order.class));
+
+    assertThat(path).isEqualTo("details");
+    assertThat(and.expOne).isInstanceOf(SimpleExpression.class);
+    assertThat(and.expTwo).isInstanceOf(SimpleExpression.class);
+  }
+
+  @Test
+  public void nestedPath_when_nestedDifferent() {
+
+    LogicExpression and = and(eq("details.orderQty", 10), eq("shipments.shipTime", 10));
+
+    String path = and.nestedPath(getBeanDescriptor(Order.class));
+
+    assertThat(path).isNull();
+    assertThat(and.expOne).isInstanceOf(NestedPathWrapperExpression.class);
+    assertThat(((NestedPathWrapperExpression) and.expOne).nestedPath).isEqualTo("details");
+    assertThat(and.expTwo).isInstanceOf(NestedPathWrapperExpression.class);
+    assertThat(((NestedPathWrapperExpression) and.expTwo).nestedPath).isEqualTo("shipments");
+  }
+
+  @Test
+  public void nestedPath_when_oneNested() {
+
+    LogicExpression and = and(eq("details.orderQty", 10), eq("orderDate", 10));
+
+    String path = and.nestedPath(getBeanDescriptor(Order.class));
+
+    assertThat(path).isNull();
+    assertThat(and.expOne).isInstanceOf(NestedPathWrapperExpression.class);
+    assertThat(((NestedPathWrapperExpression) and.expOne).nestedPath).isEqualTo("details");
+    assertThat(and.expTwo).isInstanceOf(SimpleExpression.class);
+  }
+}

src/test/java/io/ebeaninternal/server/expression/NoopExpressionTest.java

@@ -0,0 +1,68 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Customer;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class NoopExpressionTest extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Query<Customer> query = Ebean.find(Customer.class)
+      .select("id")
+      .where().add(NoopExpression.INSTANCE)
+      .query();
+
+    query.findList();
+    String generatedSql = sqlOf(query);
+
+    assertThat(generatedSql).contains("select t0.id from o_customer t0 where 1=1");
+  }
+
+  @Test
+  public void test_withPreAndPost() {
+
+    Query<Customer> query = Ebean.find(Customer.class)
+      .select("id")
+      .where().eq("name", null)
+      .add(NoopExpression.INSTANCE)
+      .ne("status", null)
+      .query();
+
+    query.findList();
+    String generatedSql = sqlOf(query);
+
+    assertThat(generatedSql).contains("select t0.id from o_customer t0 where t0.name is null  and 1=1 and t0.status is not null");
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(new NoopExpression().isSameByPlan(new NoopExpression())).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffExpressionType() {
+
+    assertThat(new NoopExpression().isSameByPlan(null)).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_same() {
+
+    assertThat(new NoopExpression().isSameByBind(new NoopExpression())).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffExpressionType() {
+
+    assertThat(new NoopExpression().isSameByBind(null)).isTrue();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/NotExpressionTest.java

@@ -0,0 +1,58 @@
+package io.ebeaninternal.server.expression;
+
+
+import io.ebean.Expression;
+import org.junit.Test;
+
+import static io.ebean.Expr.eq;
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class NotExpressionTest {
+
+
+  NotExpression not(Expression expression) {
+    return new NotExpression(expression);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(not(eq("a", 10))
+      .isSameByPlan(not(eq("a", 10)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_sameByPlan() {
+
+    assertThat(not(eq("a", 10))
+      .isSameByPlan(not(eq("a", 20)))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_different() {
+
+    assertThat(not(eq("a", 10))
+      .isSameByPlan(not(eq("b", 10)))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_differentExpressionType() {
+
+    assertThat(not(eq("a", 10))
+      .isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_same() {
+
+    assertThat(not(eq("a", 10))
+      .isSameByBind(not(eq("b", 10)))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_different() {
+
+    assertThat(not(eq("a", 10))
+      .isSameByBind(not(eq("a", 20)))).isFalse();
+  }
+}

src/test/java/io/ebeaninternal/server/expression/NullExpressionTest.java

@@ -0,0 +1,95 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebeaninternal.api.ManyWhereJoins;
+import io.ebeaninternal.api.SpiExpression;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class NullExpressionTest extends BaseExpressionTest {
+
+  NullExpression nullExp(String propertyName, boolean notNull) {
+    NullExpression expr = new NullExpression(propertyName, notNull);
+    expr.containsMany(getBeanDescriptor(Order.class), new ManyWhereJoins());
+    return expr;
+  }
+
+  @Test
+  public void addSql_when_notNull() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    nullExp("id", true).addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("id is not null ");
+  }
+
+  @Test
+  public void addSql_when_null() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    nullExp("id", false).addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("id is null ");
+  }
+
+  @Test
+  public void addSql_when_notNull_and_assocOne() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    nullExp("customer", true).addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("customer.id is not null ");
+  }
+
+  @Test
+  public void addSql_when_null_and_assocOne() throws Exception {
+
+    DefaultExpressionRequest expReq = newExpressionRequest();
+
+    nullExp("customer", false).addSql(expReq);
+
+    assertThat(expReq.getSql()).isEqualTo("customer.id is null ");
+  }
+
+  @Test
+  public void copyForPlanKey_isSameInstance() throws Exception {
+
+    NullExpression exp = nullExp("customer.name", false);
+    SpiExpression other = exp.copyForPlanKey();
+
+    assertThat(exp).isSameAs(other);
+  }
+
+  @Test
+  public void isSameByBind_true() throws Exception {
+
+    assertThat(nullExp("customer.name", false)
+      .isSameByBind(nullExp("customer.name", false))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_true() throws Exception {
+
+    assertThat(nullExp("customer.name", false)
+      .isSameByPlan(nullExp("customer.name", false))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_false_when_notNullDiff() throws Exception {
+
+    assertThat(new NullExpression("customer.name", false)
+      .isSameByPlan(new NullExpression("customer.name", true))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_false_when_propertyNameDiff() throws Exception {
+
+    assertThat(new NullExpression("customer.startDate", true)
+      .isSameByPlan(new NullExpression("customer.name", true))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/PrepareDocNestedTest.java

@@ -0,0 +1,148 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.ExpressionList;
+import io.ebeaninternal.api.SpiExpression;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+public class PrepareDocNestedTest extends BaseTestCase {
+  @Test
+  public void prepare() throws Exception {
+
+    ExpressionList<Order> where = Ebean.find(Order.class)
+      .where()
+      .gt("details.orderQty", 1)
+      .query().where();
+
+
+    DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
+    PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
+
+    List<SpiExpression> underlyingList = exp.getUnderlyingList();
+    assertEquals(underlyingList.size(), 1);
+    assertEquals(exp.allDocNestedPath, "details");
+  }
+
+  @Test
+  public void prepare_when_multipleOfSamePath() throws Exception {
+
+    ExpressionList<Order> where = Ebean.find(Order.class)
+      .where()
+      .gt("details.orderQty", 1)
+      .gt("details.unitPrice", 1)
+      .query().where();
+
+
+    DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
+    PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
+
+    List<SpiExpression> underlyingList = exp.getUnderlyingList();
+    assertEquals(underlyingList.size(), 2);
+    assertEquals(exp.allDocNestedPath, "details");
+  }
+
+  @Test
+  public void prepare_when_mixed() throws Exception {
+
+    ExpressionList<Order> where = Ebean.find(Order.class)
+      .where()
+      .gt("customer.id", 1)
+      .gt("details.orderQty", 1)
+      .gt("details.unitPrice", 1)
+      .query().where();
+
+
+    DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
+    PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
+
+    List<SpiExpression> underlyingList = exp.getUnderlyingList();
+    assertEquals(underlyingList.size(), 2);
+    assertNull(exp.allDocNestedPath);
+
+    DefaultExpressionList<?> second = (DefaultExpressionList<?>) underlyingList.get(1);
+    assertEquals(second.allDocNestedPath, "details");
+  }
+
+  @Test
+  public void prepare_when_nestedJunction() throws Exception {
+
+    ExpressionList<Order> where = Ebean.find(Order.class)
+      .where()
+      .not()
+      .gt("customer.id", 1)
+      .gt("details.orderQty", 1)
+      .gt("details.unitPrice", 1)
+      .query().where();
+
+    DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
+    PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
+
+    List<SpiExpression> underlyingList = exp.getUnderlyingList();
+    assertEquals(underlyingList.size(), 1);
+    assertNull(exp.allDocNestedPath);
+
+    JunctionExpression<?> junction = (JunctionExpression<?>) underlyingList.get(0);
+    List<SpiExpression> junctionUnderlying = junction.exprList.getUnderlyingList();
+    JunctionExpression<?> nestedNestedPath = (JunctionExpression) junctionUnderlying.get(1);
+    assertEquals(nestedNestedPath.exprList.allDocNestedPath, "details");
+  }
+
+  @Test
+  public void prepare_when_nestedMultiple() throws Exception {
+
+    ExpressionList<Order> where = Ebean.find(Order.class)
+      .where()
+      .isNotNull("shipments.shipTime")
+      .gt("details.orderQty", 1)
+      .gt("details.unitPrice", 1)
+      .query().where();
+
+    DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
+    PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
+
+    List<SpiExpression> underlyingList = exp.getUnderlyingList();
+    assertEquals(underlyingList.size(), 2);
+    assertNull(exp.allDocNestedPath);
+
+    DefaultExpressionList<?> shipExpr = (DefaultExpressionList<?>) underlyingList.get(0);
+    assertEquals(shipExpr.allDocNestedPath, "shipments");
+
+    DefaultExpressionList<?> detailsExpr = (DefaultExpressionList<?>) underlyingList.get(1);
+    assertEquals(detailsExpr.allDocNestedPath, "details");
+  }
+
+
+  @Test
+  public void prepare_when_manyMixed() throws Exception {
+
+    ExpressionList<Order> where = Ebean.find(Order.class)
+      .where()
+      .gt("customer.id", 1)             // 0
+      .isNotNull("shipments.shipTime")  // shipments 0
+      .isNotNull("status")              // 1
+      .gt("details.orderQty", 1)        // details 0
+      .isNotNull("orderDate")           // 2
+      .gt("details.unitPrice", 1)       // details 1
+      .query().where();
+
+    DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
+    PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
+
+    List<SpiExpression> underlyingList = exp.getUnderlyingList();
+    assertEquals(underlyingList.size(), 5);
+    assertNull(exp.allDocNestedPath);
+
+    DefaultExpressionList<?> shipExpr = (DefaultExpressionList<?>) underlyingList.get(3);
+    assertEquals(shipExpr.allDocNestedPath, "shipments");
+
+    DefaultExpressionList<?> detailsExpr = (DefaultExpressionList<?>) underlyingList.get(4);
+    assertEquals(detailsExpr.allDocNestedPath, "details");
+  }
+}

src/test/java/io/ebeaninternal/server/expression/RawExpressionTest.java

@@ -0,0 +1,50 @@
+package io.ebeaninternal.server.expression;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class RawExpressionTest {
+
+  @NotNull
+  private RawExpression exp(String sql, Object... values) {
+    return new RawExpression(sql, values);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+    assertThat(exp("a", 10).isSameByPlan(exp("a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBindValues() {
+    assertThat(exp("a", 10).isSameByPlan(exp("a", 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffSql() {
+    assertThat(exp("a", 10).isSameByPlan(exp("b", 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_same() {
+    assertThat(exp("a", 10).isSameByBind(exp("a", 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+    assertThat(exp("a", 10).isSameByBind(exp("a", 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_moreBindValues() {
+    assertThat(exp("a", 10).isSameByBind(exp("a", 10, 20))).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_lessBindValues() {
+    assertThat(exp("a", 10, 20).isSameByBind(exp("a", 10))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/SameTest.java

@@ -0,0 +1,29 @@
+package io.ebeaninternal.server.expression;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class SameTest {
+
+  @Test
+  public void sameByNull() throws Exception {
+
+    assertThat(Same.sameByNull("a", "a")).isTrue();
+    assertThat(Same.sameByNull("a", "b")).isTrue();
+    assertThat(Same.sameByNull(null, null)).isTrue();
+    assertThat(Same.sameByNull("a", null)).isFalse();
+    assertThat(Same.sameByNull(null, "a")).isFalse();
+  }
+
+  @Test
+  public void sameByValue() throws Exception {
+
+    assertThat(Same.sameByValue("a", "a")).isTrue();
+    assertThat(Same.sameByValue("a", "b")).isFalse();
+    assertThat(Same.sameByValue(null, null)).isTrue();
+    assertThat(Same.sameByValue("a", null)).isFalse();
+    assertThat(Same.sameByValue(null, "a")).isFalse();
+  }
+}

src/test/java/io/ebeaninternal/server/expression/SimpleExpressionTest.java

@@ -0,0 +1,58 @@
+package io.ebeaninternal.server.expression;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SimpleExpressionTest extends BaseExpressionTest {
+
+  @NotNull
+  private SimpleExpression exp(String propertyName, Op operator, Object value) {
+    return new SimpleExpression(propertyName, operator, value);
+  }
+
+  @Test
+  public void isSameByPlan_when_same() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(exp("a", Op.EQ, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffBind_same() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(exp("a", Op.EQ, 20))).isTrue();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffProperty_diff() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(exp("b", Op.EQ, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffOperator_diff() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(exp("a", Op.LT, 10))).isFalse();
+  }
+
+  @Test
+  public void isSameByPlan_when_diffType_diff() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByPlan(new NoopExpression())).isFalse();
+  }
+
+  @Test
+  public void isSameByBind_when_sameBindValues() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByBind(exp("a", Op.LT, 10))).isTrue();
+  }
+
+  @Test
+  public void isSameByBind_when_diffBindValues() {
+
+    assertThat(exp("a", Op.EQ, 10).isSameByBind(exp("a", Op.EQ, "junk"))).isFalse();
+  }
+
+}

src/test/java/io/ebeaninternal/server/expression/TDSpiExpressionRequest.java

@@ -0,0 +1,78 @@
+package io.ebeaninternal.server.expression;
+
+import io.ebeaninternal.api.SpiExpressionRequest;
+import io.ebeaninternal.server.core.DbExpressionHandler;
+import io.ebeaninternal.server.core.SpiOrmQueryRequest;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Test double for testing with SpiExpressionRequest.
+ */
+public class TDSpiExpressionRequest implements SpiExpressionRequest {
+
+  List<Object> bindValues = new ArrayList<>();
+
+  final BeanDescriptor<?> descriptor;
+
+  public TDSpiExpressionRequest(BeanDescriptor<?> descriptor) {
+    this.descriptor = descriptor;
+  }
+
+  @Override
+  public DbExpressionHandler getDbPlatformHandler() {
+    return null;
+  }
+
+  @Override
+  public String parseDeploy(String logicalProp) {
+    return null;
+  }
+
+  @Override
+  public BeanDescriptor<?> getBeanDescriptor() {
+    return descriptor;
+  }
+
+  @Override
+  public SpiOrmQueryRequest<?> getQueryRequest() {
+    return null;
+  }
+
+  @Override
+  public SpiExpressionRequest append(String sql) {
+    return null;
+  }
+
+  @Override
+  public void addBindEncryptKey(Object encryptKey) {
+
+  }
+
+  @Override
+  public void addBindValue(Object bindValue) {
+    bindValues.add(bindValue);
+  }
+
+  @Override
+  public String getSql() {
+    return null;
+  }
+
+  @Override
+  public ArrayList<Object> getBindValues() {
+    return null;
+  }
+
+  @Override
+  public int nextParameter() {
+    return 0;
+  }
+
+  @Override
+  public void appendLike() {
+
+  }
+}

src/test/java/io/ebeaninternal/server/grammer/EqlParserTest.java

@@ -0,0 +1,474 @@
+package io.ebeaninternal.server.grammer;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebeaninternal.api.SpiQuery;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class EqlParserTest extends BaseTestCase {
+
+
+  @Test(expected = IllegalArgumentException.class)
+  public void illegal_syntax() throws Exception {
+    parse("find Article where name = :p0");
+  }
+
+  @Test
+  public void where_eq() throws Exception {
+
+    Query<Customer> query = parse("where name eq 'Rob'");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name = ?");
+  }
+
+  @Test
+  public void where_eq_reverse() throws Exception {
+
+    Query<Customer> query = parse("where 'Rob' eq name");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name = ?");
+  }
+
+  @Test
+  public void where_gt_reverse() throws Exception {
+
+    Query<Customer> query = parse("where 'Rob' > name");
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("where t0.name < ?");
+  }
+
+  @Test
+  public void where_gte_reverse() throws Exception {
+
+    Query<Customer> query = parse("where 'Rob' >= name");
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("where t0.name <= ?");
+  }
+
+  @Test
+  public void where_lt_reverse() throws Exception {
+
+    Query<Customer> query = parse("where 'Rob' < name");
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("where t0.name > ?");
+  }
+
+  @Test
+  public void where_lte_reverse() throws Exception {
+
+    Query<Customer> query = parse("where 'Rob' <= name");
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("where t0.name >= ?");
+  }
+
+  @Test
+  public void where_ieq() throws Exception {
+
+    Query<Customer> query = parse("where name ieq 'Rob'");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where lower(t0.name) =?");
+  }
+
+  @Test
+  public void where_ieq_reverse() throws Exception {
+
+    Query<Customer> query = parse("where 'Rob' ieq name");
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("where lower(t0.name) =?");
+  }
+
+  @Test
+  public void where_eq2() throws Exception {
+
+    Query<Customer> query = parse("where name = 'Rob'");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name = ?");
+  }
+
+  @Test
+  public void where_namedParam() throws Exception {
+
+    Query<Customer> query = parse("where name eq :name");
+    query.setParameter("name", "Rob");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name = ?");
+  }
+
+  @Test
+  public void where_namedParam_otherOrder() {
+    Query<Customer> query = parse("where :nm < name");
+    query.setParameter("nm", "Rob");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name > ?");
+  }
+
+  @Test
+  public void where_namedParam_startsWith() throws Exception {
+
+    Query<Customer> query = parse("where name startsWith :name");
+    query.setParameter("name", "Rob");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name like ?");
+  }
+
+  @Test
+  public void where_or1() throws Exception {
+
+    Query<Customer> query = parse("where name = 'Rob' or (status = 'NEW' and smallnote is null)");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where (t0.name = ?  or (t0.status = ?  and t0.smallnote is null ) )");
+  }
+
+  @Test
+  public void where_or2() throws Exception {
+
+    Query<Customer> query = parse("where (name = 'Rob' or status = 'NEW') and smallnote is null");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where ((t0.name = ?  or t0.status = ? )  and t0.smallnote is null )");
+  }
+
+  @Test
+  public void test_simplifyExpressions() throws Exception {
+
+    Query<Customer> query = parse("where not (name = 'Rob' and status = 'NEW')");
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("where not (t0.name = ?  and t0.status = ? )");
+
+    query = parse("where not ((name = 'Rob' and status = 'NEW'))");
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("where not (t0.name = ?  and t0.status = ? )");
+
+    query = parse("where not (((name = 'Rob') and (status = 'NEW')))");
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("where not (t0.name = ?  and t0.status = ? )");
+  }
+
+
+  @Test
+  public void where_in() throws Exception {
+
+    Query<Customer> query = parse("where name in ('Rob','Jim')");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name in (?, ? )");
+  }
+
+  @Test
+  public void where_in_when_namedParams() throws Exception {
+
+    Query<Customer> query = parse("where name in (:one, :two)");
+    query.setParameter("one", "Foo");
+    query.setParameter("two", "Bar");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name in (?, ? )");
+  }
+
+  @Test
+  public void where_in_when_namedParams_withWhitespace() throws Exception {
+
+    Query<Customer> query = parse("where name in (:one,  :two)");
+    query.setParameter("one", "Foo");
+    query.setParameter("two", "Bar");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name in (?, ? )");
+  }
+
+  @Test
+  public void where_in_when_namedParams_withNoWhitespace() throws Exception {
+
+    Query<Customer> query = parse("where name in (:one,:two)");
+    query.setParameter("one", "Foo");
+    query.setParameter("two", "Bar");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name in (?, ? )");
+  }
+
+  @Test
+  public void where_in_when_namedParamAsList() throws Exception {
+
+    Query<Customer> query = parse("where name in (:names)");
+    query.setParameter("names", Arrays.asList("Baz", "Maz", "Jim"));
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name in (?, ?, ? )");
+  }
+
+  @Test
+  public void where_between() throws Exception {
+
+    Query<Customer> query = parse("where name between 'As' and 'B'");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name between  ? and ? ");
+  }
+
+  @Test
+  public void where_between_withNamedParams() throws Exception {
+
+    Query<Customer> query = parse("where name between :one and :two");
+    query.setParameter("one", "a");
+    query.setParameter("two", "b");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where t0.name between  ? and ? ");
+  }
+
+  @Test
+  public void where_betweenProperty() throws Exception {
+
+    Query<Customer> query = parse("where 'x' between name and smallnote");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where  ?  between t0.name and t0.smallnote");
+  }
+
+  @Test
+  public void where_betweenProperty_withNamed() throws Exception {
+
+    Query<Customer> query = parse("where :some between name and smallnote");
+    query.setParameter("some", "A");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("where  ?  between t0.name and t0.smallnote");
+  }
+
+  @Test
+  public void fetch_basic() throws Exception {
+
+    Query<Customer> query = parse("fetch billingAddress");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains(", t1.id");
+  }
+
+  @Test
+  public void fetch_withProperty() throws Exception {
+
+    Query<Customer> query = parse("fetch billingAddress (city)");
+    query.findList();
+
+    assertThat(sqlOf(query, 10)).contains(", t1.id, t1.city");
+  }
+
+  @Test
+  public void fetch_withProperty_noWhitespace() throws Exception {
+
+    Query<Customer> query = parse("fetch billingAddress(city)");
+    query.findList();
+
+    assertThat(sqlOf(query, 10)).contains(", t1.id, t1.city");
+  }
+
+  @Test
+  public void fetch_basic_multiple() throws Exception {
+
+    Query<Customer> query = parse("fetch billingAddress fetch shippingAddress");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains(", t1.city");
+    assertThat(query.getGeneratedSql()).contains(", t2.city");
+  }
+
+  @Test
+  public void fetch_basic_multiple_withProperties() throws Exception {
+
+    Query<Customer> query = parse("fetch billingAddress (city) fetch shippingAddress (city)");
+    query.findList();
+
+    assertThat(sqlOf(query, 12)).contains(", t1.id, t1.city, t2.id, t2.city");
+  }
+
+  @Test
+  public void fetch_lazy() throws Exception {
+
+    Query<Customer> query = parse("fetch lazy billingAddress");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).doesNotContain(", t1.city");
+  }
+
+  @Test
+  public void fetch_lazy50() throws Exception {
+
+    Query<Customer> query = parse("fetch lazy(50) billingAddress");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).doesNotContain(", t1.city");
+  }
+
+  @Test
+  public void fetch_query50() throws Exception {
+
+    ResetBasicData.reset();
+    Query<Customer> query = parse("fetch query(50) billingAddress");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).doesNotContain(", t1.city");
+  }
+
+  @Test
+  public void fetch_query50_asHint() throws Exception {
+
+    ResetBasicData.reset();
+    Query<Customer> query = parse("fetch billingAddress (+query(50),city)");
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).doesNotContain(", t1.city");
+  }
+
+  @Test
+  public void fetch_lazy50_asHint() throws Exception {
+
+    ResetBasicData.reset();
+    Query<Customer> query = parse("fetch billingAddress (+lazy(50),city)");
+    List<Customer> list = query.findList();
+
+    assertThat(query.getGeneratedSql()).doesNotContain(", t1.city");
+
+    Customer customer = list.get(0);
+    customer.getBillingAddress().getCity();
+  }
+
+  @Test
+  public void select() throws Exception {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("select (name)");
+    query.findList();
+    assertThat(sqlOf(query, 1)).contains("select t0.id, t0.name from o_customer t0");
+  }
+
+  @Test
+  public void selectDistinct() throws Exception {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("select distinct (name)");
+    query.findList();
+    assertThat(sqlOf(query, 1)).contains("select distinct t0.name from o_customer t0");
+  }
+
+
+  @Test
+  public void limit() throws Exception {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("limit 10");
+    query.findList();
+    if (isH2()) {
+      assertThat(query.getGeneratedSql()).contains(" limit 10");
+    }
+  }
+
+  @Test
+  public void limitOffset() throws Exception {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("limit 10 offset 5");
+    query.findList();
+    if (isH2()) {
+      assertThat(query.getGeneratedSql()).contains(" limit 10 offset 5");
+    }
+  }
+
+  @Test
+  public void orderBy() throws Exception {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("order by id");
+    query.findList();
+    if (isH2()) {
+      assertThat(query.getGeneratedSql()).contains("from o_customer t0 order by t0.id");
+    }
+  }
+
+  @Test
+  public void orderBy_desc() throws Exception {
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("order by id desc");
+    query.findList();
+    if (isH2()) {
+      assertThat(query.getGeneratedSql()).contains("from o_customer t0 order by t0.id desc");
+    }
+  }
+
+  @Test
+  public void orderBy_nullsLast() throws Exception {
+
+    if (!isPlatformOrderNullsSupport()) {
+      return;
+    }
+
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("order by id desc nulls last");
+    query.findList();
+    if (isH2()) {
+      assertThat(query.getGeneratedSql()).contains(" from o_customer t0 order by t0.id desc nulls last");
+    }
+  }
+
+  @Test
+  public void orderBy_nullsFirst() throws Exception {
+
+    if (!isPlatformOrderNullsSupport()) {
+      return;
+    }
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("order by id nulls first");
+    query.findList();
+    if (isH2()) {
+      assertThat(query.getGeneratedSql()).contains(" from o_customer t0 order by t0.id nulls first");
+    }
+  }
+
+  @Test
+  public void orderBy_multiple() throws Exception {
+
+    if (!isPlatformOrderNullsSupport()) {
+      return;
+    }
+    ResetBasicData.reset();
+
+    Query<Customer> query = parse("order by billingAddress.city desc nulls last, name, id desc nulls last");
+    query.findList();
+    if (isH2()) {
+      assertThat(query.getGeneratedSql()).contains(" order by t1.city desc nulls last, t0.name, t0.id desc nulls last");
+    }
+  }
+
+  private Query<Customer> parse(String raw) {
+
+    Query<Customer> query = Ebean.find(Customer.class);
+    EqlParser.parse(raw, (SpiQuery) query);
+    return query;
+  }
+
+}

src/test/java/io/ebeaninternal/server/grammer/ParseFetchConfigTest.java

@@ -0,0 +1,46 @@
+package io.ebeaninternal.server.grammer;
+
+import io.ebean.FetchConfig;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNull;
+
+public class ParseFetchConfigTest {
+
+  @Test
+  public void parse() throws Exception {
+
+    assertNull(ParseFetchConfig.parse("junk"));
+    assertNull(ParseFetchConfig.parse("lazyFoo"));
+    assertNull(ParseFetchConfig.parse("queryFoo"));
+  }
+
+  @Test
+  public void parseLazy() throws Exception {
+
+    FetchConfig lazy = ParseFetchConfig.parse("lazy");
+    assertThat(lazy.getLazyBatchSize()).isEqualTo(0);
+  }
+
+  @Test
+  public void parseLazy100() throws Exception {
+
+    FetchConfig lazy = ParseFetchConfig.parse("lazy(100)");
+    assertThat(lazy.getLazyBatchSize()).isEqualTo(100);
+  }
+
+  @Test
+  public void parseQuery() throws Exception {
+
+    FetchConfig lazy = ParseFetchConfig.parse("query");
+    assertThat(lazy.getQueryBatchSize()).isEqualTo(0);
+  }
+
+  @Test
+  public void parseQuery100() throws Exception {
+
+    FetchConfig lazy = ParseFetchConfig.parse("query(50)");
+    assertThat(lazy.getQueryBatchSize()).isEqualTo(50);
+  }
+}

src/test/java/io/ebeaninternal/server/lib/ShutdownManagerTest.java

@@ -0,0 +1,32 @@
+package io.ebeaninternal.server.lib;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class ShutdownManagerTest extends BaseTestCase {
+
+  /**
+   * Run this test manually.
+   */
+  @Ignore
+  @Test
+  public void test_deregisterShutdownHook() {
+
+    Ebean.getDefaultServer();
+    ShutdownManager.deregisterShutdownHook();
+  }
+
+  /**
+   * Run this test manually.
+   */
+  @Ignore
+  @Test
+  public void test_noShutdownHook() {
+
+    System.setProperty("ebean.registerShutdownHook", "false");
+    Ebean.getDefaultServer();
+  }
+
+}

src/test/java/io/ebeaninternal/server/lib/sql/TestDataSourceMaxWithEntity.java

@@ -0,0 +1,66 @@
+package io.ebeaninternal.server.lib.sql;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebeaninternal.server.core.DefaultBackgroundExecutor;
+import org.tests.model.basic.Customer;
+import org.junit.Test;
+
+public class TestDataSourceMaxWithEntity extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    boolean skipThisTest = true;
+
+    if (skipThisTest) {
+      return;
+    }
+
+    EbeanServer server = Ebean.getServer(null);
+
+
+    DefaultBackgroundExecutor bg = new DefaultBackgroundExecutor(1, 30, "testDs");
+
+    try {
+      for (int i = 0; i < 12; i++) {
+        // Thread.sleep(10*i);
+        bg.execute(new ConnRunner(server, 4000, i));
+      }
+
+      Thread.sleep(30000);
+
+      server.shutdown(true, false);
+
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+  }
+
+  private static class ConnRunner implements Runnable {
+
+    final EbeanServer server;
+    final long sleepMillis;
+    final int position;
+
+    ConnRunner(EbeanServer server, long sleepMillis, int position) {
+      this.server = server;
+      this.sleepMillis = sleepMillis;
+      this.position = position;
+    }
+
+    public void run() {
+
+      server.find(Customer.class).findCount();
+      try {
+        System.out.println(position + " sleep " + sleepMillis);
+        Thread.sleep(sleepMillis);
+        System.out.println(position + " sleep done");
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+    }
+  }
+}

src/test/java/io/ebeaninternal/server/loadcontext/DLoadContextTest.java

@@ -0,0 +1,109 @@
+package io.ebeaninternal.server.loadcontext;
+
+import io.ebean.BaseTestCase;
+import io.ebean.FetchConfig;
+import io.ebean.Query;
+import io.ebeaninternal.server.core.OrmQueryRequest;
+import io.ebeaninternal.server.core.OrmQueryRequestTestHelper;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DLoadContextTest extends BaseTestCase {
+
+  private OrmQueryRequest<Order> queryRequest(Query<Order> query) {
+    return OrmQueryRequestTestHelper.queryRequest(query);
+  }
+
+  private Query<Order> query() {
+    return server().find(Order.class);
+  }
+
+  @Test
+  public void construct_when_defaults_expect_defaultLazyBatchSizeServerDefaults() {
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query());
+    queryRequest.initTransIfRequired();
+    queryRequest.endTransIfRequired();
+
+    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadBeanContext customer = graphContext.getBeanContext("customer");
+
+
+    assertThat(customer.firstBatchSize).isEqualTo(10);
+    assertThat(customer.secondaryBatchSize).isEqualTo(10);
+  }
+
+  @Test
+  public void construct_when_fetchQuery_expect_100_batchSize() {
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query().fetch("customer", new FetchConfig().query()));
+    queryRequest.initTransIfRequired();
+    queryRequest.endTransIfRequired();
+
+    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadBeanContext customer = graphContext.getBeanContext("customer");
+
+    assertThat(customer.firstBatchSize).isEqualTo(100);
+    assertThat(customer.secondaryBatchSize).isEqualTo(100);
+  }
+
+  @Test
+  public void construct_when_fetchQuery_expect_100_batchSize_viaFetchQuery() {
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query().fetchQuery("customer"));
+    queryRequest.initTransIfRequired();
+    queryRequest.endTransIfRequired();
+
+    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadBeanContext customer = graphContext.getBeanContext("customer");
+
+    assertThat(customer.firstBatchSize).isEqualTo(100);
+    assertThat(customer.secondaryBatchSize).isEqualTo(100);
+  }
+
+  @Test
+  public void construct_when_fetchQuery50_expect_50_batchSize() {
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query().fetch("customer", new FetchConfig().query(50)));
+    queryRequest.initTransIfRequired();
+    queryRequest.endTransIfRequired();
+
+    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadBeanContext customer = graphContext.getBeanContext("customer");
+
+    assertThat(customer.firstBatchSize).isEqualTo(50);
+    assertThat(customer.secondaryBatchSize).isEqualTo(50);
+  }
+
+  @Test
+  public void construct_when_fetchQueryFirst20Lazy5_expect_20_5_batchSize() {
+
+    OrmQueryRequest<Order> queryRequest = queryRequest(query().fetch("customer", new FetchConfig().queryFirst(20).lazy(5)));
+    queryRequest.initTransIfRequired();
+    queryRequest.endTransIfRequired();
+
+    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadBeanContext customer = graphContext.getBeanContext("customer");
+
+    assertThat(customer.firstBatchSize).isEqualTo(20);
+    assertThat(customer.secondaryBatchSize).isEqualTo(5);
+  }
+
+  @Test
+  public void construct_when_fetch_expect_100_100_batchSize() {
+
+    // the fetch is converted to a query join due to the maxRows
+    OrmQueryRequest<Order> queryRequest = queryRequest(query().fetch("details").setMaxRows(100));
+    queryRequest.initTransIfRequired();
+    queryRequest.endTransIfRequired();
+
+    DLoadContext graphContext = (DLoadContext) queryRequest.getGraphContext();
+    DLoadManyContext details = graphContext.getManyContext("details");
+
+    assertThat(details.firstBatchSize).isEqualTo(100);
+    assertThat(details.secondaryBatchSize).isEqualTo(100);
+  }
+
+}

src/test/java/io/ebeaninternal/server/persist/BatchedBeanHolderTest.java

@@ -0,0 +1,40 @@
+package io.ebeaninternal.server.persist;
+
+import io.ebeaninternal.api.TDSpiEbeanServer;
+import io.ebeaninternal.server.core.PersistRequest;
+import io.ebeaninternal.server.core.PersistRequestBean;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanManager;
+import org.tests.model.basic.Customer;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import static org.junit.Assert.assertEquals;
+
+public class BatchedBeanHolderTest {
+
+  @Test
+  public void testAppend() throws Exception {
+
+
+    TDSpiEbeanServer server = new TDSpiEbeanServer("foo");
+
+    BeanDescriptor beanDescriptor = Mockito.mock(BeanDescriptor.class);
+    BeanManager beanManager = new BeanManager(beanDescriptor, null);
+
+
+    BatchedBeanHolder holder = new BatchedBeanHolder(null, beanDescriptor, 1);
+
+    Customer customer = new Customer();
+    PersistRequestBean req1 = new PersistRequestBean(server, customer, null, beanManager, null, null, PersistRequest.Type.INSERT, false, false);
+
+
+    int size = holder.append(req1);
+    assertEquals(1, size);
+
+    PersistRequestBean req2 = new PersistRequestBean(server, customer, null, beanManager, null, null, PersistRequest.Type.INSERT, false, false);
+    size = holder.append(req2);
+    assertEquals(0, size);
+
+  }
+}

src/test/java/io/ebeaninternal/server/query/DefaultSqlRowTest.java

@@ -0,0 +1,22 @@
+package io.ebeaninternal.server.query;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultSqlRowTest {
+
+  @Test
+  public void test_keyConversion() {
+
+    DefaultSqlRow row = new DefaultSqlRow(16, 0.5f, "T");
+    row.put("Foo", "hello");
+
+    assertThat(row.containsKey("foo")).isTrue();
+    assertThat(row.getString("foo")).isEqualTo("hello");
+    assertThat(row.get("foo")).isEqualTo("hello");
+
+    row.remove("foo");
+    assertThat(row.isEmpty()).isTrue();
+  }
+}

src/test/java/io/ebeaninternal/server/query/LimitOffsetPagedListTest.java

@@ -0,0 +1,105 @@
+package io.ebeaninternal.server.query;
+
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebeaninternal.api.SpiQuery;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class LimitOffsetPagedListTest {
+
+  private EbeanServer server = Ebean.getDefaultServer();
+
+  @Test
+  public void getPageIndex_when_firstRowsZero() throws Exception {
+    assertEquals(limit(0, 10).getPageIndex(), 0);
+  }
+
+  @Test
+  public void getPageIndex_when_10_10() {
+    assertEquals(limit(10, 10).getPageIndex(), 1);
+  }
+
+  @Test
+  public void getPageIndex_when_20_10() {
+    assertEquals(limit(20, 10).getPageIndex(), 2);
+  }
+
+  @Test
+  public void getPageIndex_when_1_10() throws Exception {
+    assertEquals(limit(1, 10).getPageIndex(), 1);
+  }
+
+  @Test
+  public void getPageIndex_when_9_10() throws Exception {
+    assertEquals(limit(1, 10).getPageIndex(), 1);
+  }
+
+  @Test
+  public void getPageIndex_when_10_4() {
+    assertEquals(limit(10, 4).getPageIndex(), 3);
+  }
+
+  @Test
+  public void getPageIndex_when_10_5() {
+    assertEquals(limit(10, 5).getPageIndex(), 2);
+  }
+
+  @Test
+  public void getPageIndex_when_10_9() {
+    assertEquals(limit(10, 9).getPageIndex(), 2);
+  }
+
+  @Test
+  public void getPageIndex_when_10_11() {
+    assertEquals(limit(10, 11).getPageIndex(), 1);
+  }
+
+  @Test
+  public void getPageIndex_when_21_10() {
+    assertEquals(limit(21, 10).getPageIndex(), 3);
+  }
+
+  @Test
+  public void getPageIndex_when_29_10() {
+    assertEquals(limit(29, 10).getPageIndex(), 3);
+  }
+
+  @Test
+  public void getPageIndex_when_30_10() {
+    assertEquals(limit(30, 10).getPageIndex(), 3);
+  }
+
+  @Test
+  public void getPageIndex_when_31_10() {
+    assertEquals(limit(31, 10).getPageIndex(), 4);
+  }
+
+  @Test
+  public void getPageIndex_when_40_10() {
+    assertEquals(limit(40, 10).getPageIndex(), 4);
+  }
+
+
+  private LimitOffsetPagedList<Order> limit(int first, int max) {
+    return limitQuery(queryWith(first, max));
+  }
+
+  private LimitOffsetPagedList<Order> limitQuery(SpiQuery<Order> query) {
+    return new LimitOffsetPagedList<>(server, query);
+  }
+
+  private SpiQuery<Order> queryWith(int first, int max) {
+    SpiQuery<Order> query = query();
+    query.setFirstRow(first);
+    query.setMaxRows(max);
+    return query;
+  }
+
+  private SpiQuery<Order> query() {
+    return (SpiQuery<Order>) server.find(Order.class);
+  }
+
+}

src/test/java/io/ebeaninternal/server/query/OrderVersionDescTest.java

@@ -0,0 +1,81 @@
+package io.ebeaninternal.server.query;
+
+import io.ebean.Version;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class OrderVersionDescTest {
+
+  private final long now = System.currentTimeMillis();
+
+  @Test
+  public void sort() {
+
+    Version<?> atNull = atNull();
+    Version<?> at100 = at(100);
+    Version<?> at200 = at(200);
+    Version<?> at300 = at(300);
+
+    List<Version<?>> versions = new ArrayList<>();
+    versions.add(at200);
+    versions.add(atNull);
+    versions.add(at300);
+    versions.add(at100);
+
+    Collections.sort(versions, OrderVersionDesc.INSTANCE);
+
+    assertThat(versions.get(0)).isSameAs(at300);
+    assertThat(versions.get(1)).isSameAs(at200);
+    assertThat(versions.get(2)).isSameAs(at100);
+    assertThat(versions.get(3)).isSameAs(atNull);
+  }
+
+  @Test
+  public void compare_lt() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(at(0), at(1)), 1);
+  }
+
+  @Test
+  public void compare_gt() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(at(2), at(1)), -1);
+  }
+
+  @Test
+  public void compare_eq() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(at(1), at(1)), 0);
+  }
+
+  @Test
+  public void compare_nullFirst() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(atNull(), at(1)), 1);
+  }
+
+
+  @Test
+  public void compare_nullLast() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(at(0), atNull()), -1);
+  }
+
+  private Version<?> atNull() {
+    return new Version();
+  }
+
+  private Version at(long diff) {
+    Timestamp timestamp = new Timestamp(now + diff);
+    Version ver = new Version();
+    ver.setStart(timestamp);
+    return ver;
+  }
+}

src/test/java/io/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java

@@ -0,0 +1,61 @@
+package io.ebeaninternal.server.query;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RawSqlQueryPlanKeyTest {
+
+
+  @Test
+  public void test_equals_same_instance() {
+
+    RawSqlQueryPlanKey key = key("select foo", true, true, "");
+    assertThat(key).isEqualTo(key);
+    assertThat(key.hashCode()).isEqualTo(key.hashCode());
+  }
+
+  @Test
+  public void test_equals_diff_instance() {
+
+    assertThat(key("select foo", true, true, "")).isEqualTo(key("select foo", true, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isEqualTo(key("select foo", true, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_sql() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select bar", true, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select bar", true, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_rawSqlFlag() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", false, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", false, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_rowNumberIncluded() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", true, false, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", true, false, "").hashCode());
+  }
+
+
+  @Test
+  public void test_notEquals_diff_logWhereSql() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", true, true, "a"));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", true, true, "a").hashCode());
+  }
+
+  @NotNull
+  private RawSqlQueryPlanKey key(String sql, boolean rawSql, boolean rowNumberIncluded, String logWhereSql) {
+    return new RawSqlQueryPlanKey(sql, rawSql, rowNumberIncluded, logWhereSql);
+  }
+
+}

src/test/java/io/ebeaninternal/server/query/SplitNameTest.java

@@ -0,0 +1,83 @@
+package io.ebeaninternal.server.query;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+public class SplitNameTest {
+
+  @Test
+  public void add() throws Exception {
+
+    assertEquals(SplitName.add("a", "b"), "a.b");
+    assertEquals(SplitName.add("a", "b.c"), "a.b.c");
+  }
+
+  @Test
+  public void count() throws Exception {
+
+    assertEquals(SplitName.count("a"), 0);
+    assertEquals(SplitName.count("a.b"), 1);
+    assertEquals(SplitName.count("a.b.c"), 2);
+    assertEquals(SplitName.count("a.b.c.foo"), 3);
+  }
+
+  @Test
+  public void parent() throws Exception {
+    assertNull(SplitName.parent("a"));
+    assertEquals(SplitName.parent("a.b"), "a");
+    assertEquals(SplitName.parent("a.b.c"), "a.b");
+    assertNull(SplitName.parent(null));
+  }
+
+  @Test
+  public void split() throws Exception {
+
+    String[] split = SplitName.split("a.b.c");
+    assertEquals(split[0], "a.b");
+    assertEquals(split[1], "c");
+  }
+
+  @Test
+  public void begin_when_one() throws Exception {
+
+    assertEquals(SplitName.begin("a"), "a");
+  }
+
+  @Test
+  public void begin_when_both() throws Exception {
+
+    assertEquals(SplitName.begin("a.b"), "a");
+  }
+
+  @Test
+  public void begin_when_multi() throws Exception {
+
+    assertEquals(SplitName.begin("a.b.c"), "a");
+  }
+
+  @Test
+  public void splitBegin_when_both() throws Exception {
+
+    String[] split = SplitName.splitBegin("a.b");
+    assertEquals(split[0], "a");
+    assertEquals(split[1], "b");
+  }
+
+  @Test
+  public void splitBegin_when_bothPlus() throws Exception {
+
+    String[] split = SplitName.splitBegin("a.b.c");
+    assertEquals(split[0], "a");
+    assertEquals(split[1], "b.c");
+  }
+
+  @Test
+  public void splitBegin_when_one() throws Exception {
+
+    String[] split = SplitName.splitBegin("a");
+    assertEquals(split[0], "a");
+    assertNull(split[1]);
+  }
+}

src/test/java/io/ebeaninternal/server/query/TestFutureRowCountErrorHandling.java

@@ -0,0 +1,101 @@
+package io.ebeaninternal.server.query;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.FutureIds;
+import io.ebean.FutureList;
+import io.ebean.FutureRowCount;
+import io.ebean.Query;
+import io.ebean.Transaction;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ExecutionException;
+
+public class TestFutureRowCountErrorHandling extends BaseTestCase {
+
+  @Test
+  public void testFutureRowCount() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    Query<Customer> query = server.createQuery(Customer.class)
+      .where().eq("doesNotExist", "this will fail")
+      .query();
+
+    FutureRowCount<Customer> futureRowCount = server.findFutureCount(query, null);
+
+    QueryFutureRowCount<Customer> internalRowCount = (QueryFutureRowCount<Customer>) futureRowCount;
+    Transaction t = internalRowCount.getTransaction();
+
+    try {
+      futureRowCount.get();
+      Assert.assertTrue("never get here as the SQL is invalid", false);
+
+    } catch (ExecutionException e) {
+      // Confirm the Transaction has been rolled back
+      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+    }
+
+  }
+
+  @Test
+  public void testFutureIds() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    Query<Customer> query = server.createQuery(Customer.class)
+      .where().eq("doesNotExist", "this will fail")
+      .query();
+
+    FutureIds<Customer> futureIds = server.findFutureIds(query, null);
+
+    QueryFutureIds<Customer> internalFuture = (QueryFutureIds<Customer>) futureIds;
+    Transaction t = internalFuture.getTransaction();
+
+    try {
+      internalFuture.get();
+      Assert.assertTrue("never get here as the SQL is invalid", false);
+
+    } catch (ExecutionException e) {
+      // Confirm the Transaction has been rolled back
+      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+    }
+
+  }
+
+
+  @Test
+  public void testFutureList() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    Query<Customer> query = server.createQuery(Customer.class)
+      .where().eq("doesNotExist", "this will fail")
+      .query();
+
+    FutureList<Customer> futureList = server.findFutureList(query, null);
+
+    QueryFutureList<Customer> internalFuture = (QueryFutureList<Customer>) futureList;
+    Transaction t = internalFuture.getTransaction();
+
+    try {
+      internalFuture.get();
+      Assert.assertTrue("never get here as the SQL is invalid", false);
+
+    } catch (ExecutionException e) {
+      // Confirm the Transaction has been rolled back
+      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+    }
+
+  }
+}

src/test/java/io/ebeaninternal/server/querydefn/DefaultOrmQueryTest.java

@@ -0,0 +1,86 @@
+package io.ebeaninternal.server.querydefn;
+
+
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultOrmQueryTest {
+
+  @Test
+  public void checkForId_when_eqId_then_translatedTo_setId() {
+
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().eq("id", 42).query();
+    assertThat(q1.getWhereExpressions()).isNotNull();
+    assertThat(q1.getId()).isNull();
+
+    q1.checkIdEqualTo();
+
+    assertThat(q1.getId()).isEqualTo(42);
+    assertThat(q1.getWhereExpressions()).isNull();
+  }
+
+  @Test
+  public void checkForId_when_idEq_ok() {
+
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().idEq(42).query();
+    assertThat(q1.getId()).isEqualTo(42);
+    q1.checkIdEqualTo();
+    assertThat(q1.getId()).isEqualTo(42);
+  }
+
+  @Test
+  public void when_addWhere_then_planChanges() {
+
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("name", "a", "b", "c").query();
+    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 2, 2, 3).query();
+
+    prepare(q1, q2);
+    assertThat(q1.createQueryPlanKey()).isNotEqualTo(q2.createQueryPlanKey());
+    assertThat(q1.queryBindHash()).isNotEqualTo(q2.queryBindHash());
+  }
+
+  @Test
+  public void when_sameWhereWithDiffBindValues_then_planSame_bindDiff() {
+
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 1, 2, 3).query();
+    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 2, 2, 3).query();
+
+    prepare(q1, q2);
+    assertThat(q1.createQueryPlanKey()).isEqualTo(q2.createQueryPlanKey());
+    assertThat(q1.queryBindHash()).isNotEqualTo(q2.queryBindHash());
+  }
+
+  @Test
+  public void when_sameWhereAndBindValues_then_planSameAndBind() {
+
+    DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 1, 2, 3).query();
+    DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) Ebean.find(Order.class).where().in("id", 1, 2, 3).query();
+
+    prepare(q1, q2);
+    assertThat(q1.createQueryPlanKey()).isEqualTo(q2.createQueryPlanKey());
+    assertThat(q1.queryBindHash()).isEqualTo(q2.queryBindHash());
+  }
+
+  @Test
+  public void when_diffFirstMaxRows_then_differentPlan() throws Exception {
+
+    DefaultOrmQuery<?> query1 = (DefaultOrmQuery<?>) Ebean.find(Order.class)
+      .setFirstRow(0)
+      .setMaxRows(31);
+
+    DefaultOrmQuery<?> query2 = (DefaultOrmQuery<?>) Ebean.find(Order.class)
+      .setFirstRow(1)
+      .setMaxRows(0);
+
+    prepare(query1, query2);
+    assertThat(query1.createQueryPlanKey()).isNotEqualTo(query2.createQueryPlanKey());
+  }
+
+  private void prepare(DefaultOrmQuery<?> q1, DefaultOrmQuery<?> q2) {
+    q1.prepare(null);
+    q2.prepare(null);
+  }
+}

src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailParserTest.java

@@ -0,0 +1,116 @@
+package io.ebeaninternal.server.querydefn;
+
+import io.ebean.BaseTestCase;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+
+public class OrmQueryDetailParserTest extends BaseTestCase {
+
+  OrmQueryDetail parse(String query) {
+    return new OrmQueryDetailParser(query).parse();
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void parse_when_nullString() throws Exception {
+    parse(null);
+  }
+
+  @Test
+  public void parse_when_emptyString() throws Exception {
+    assertTrue(parse("").isEmpty());
+  }
+
+  @Test
+  public void testParseBasic() throws Exception {
+
+    OrmQueryDetail detail = parse("select (id,name)");
+
+    OrmQueryProperties root = detail.getChunk(null, false);
+    assertNull(root.getPath());
+    assertThat(root.getIncluded()).containsExactly("id", "name");
+  }
+
+  @Test
+  public void testParseEmptySelect() throws Exception {
+
+    OrmQueryDetail detail = parse("select  fetch customer (email)");
+
+    OrmQueryProperties root = detail.getChunk(null, false);
+    assertNull(root.getPath());
+    assertThat(root.getIncluded()).isNull();
+
+    OrmQueryProperties chunk = detail.getChunk("customer", false);
+    assertThat(chunk.getPath()).isEqualTo("customer");
+    assertThat(chunk.getIncluded()).contains("email");
+  }
+
+  @Test
+  public void testParseSelectFetch() throws Exception {
+
+    OrmQueryDetail detail = parse("select (id,name) fetch customer (email)");
+
+    OrmQueryProperties root = detail.getChunk(null, false);
+    assertNull(root.getPath());
+    assertThat(root.getIncluded()).contains("id", "name");
+
+    OrmQueryProperties chunk = detail.getChunk("customer", false);
+    assertThat(chunk.getPath()).isEqualTo("customer");
+    assertThat(chunk.getIncluded()).contains("email");
+  }
+
+  @Test
+  public void testParseSelectFetchMore() throws Exception {
+
+    OrmQueryDetail detail = parse("select (id,name) fetch customer (email) fetch details.product (sku,description)");
+
+    OrmQueryProperties root = detail.getChunk(null, false);
+    assertNull(root.getPath());
+    assertThat(root.getIncluded()).contains("id", "name");
+
+    OrmQueryProperties chunk = detail.getChunk("customer", false);
+    assertThat(chunk.getPath()).isEqualTo("customer");
+    assertThat(chunk.getIncluded()).contains("email");
+
+    chunk = detail.getChunk("details.product", false);
+    assertThat(chunk.getPath()).isEqualTo("details.product");
+    assertThat(chunk.getIncluded()).contains("sku", "description");
+  }
+
+  @Test
+  public void testParseWithPlusQuery() throws Exception {
+
+    OrmQueryDetail detail = parse("select (id,name) fetch customer (+query,id,name,email)");
+
+    OrmQueryProperties root = detail.getChunk(null, false);
+    assertNull(root.getPath());
+    assertThat(root.getIncluded()).contains("id", "name");
+
+    OrmQueryProperties chunk = detail.getChunk("customer", false);
+    assertThat(chunk.getPath()).isEqualTo("customer");
+    assertThat(chunk.getIncluded()).contains("id", "name", "email");
+    assertThat(chunk.isQueryFetch()).isTrue();
+  }
+
+  @Test
+  public void testTuneApply() {
+
+    OrmQueryDetail detail = parse("select (status) fetch customer (email)");
+    OrmQueryDetail tune = parse("select (id,name) fetch customer (+query,id,name,email)");
+
+    detail.tuneFetchProperties(tune);
+
+    OrmQueryProperties root = detail.getChunk(null, false);
+    assertNull(root.getPath());
+    assertThat(root.getIncluded()).contains("id", "name");
+
+    OrmQueryProperties chunk = detail.getChunk("customer", false);
+    assertThat(chunk.getPath()).isEqualTo("customer");
+    assertThat(chunk.getIncluded()).contains("id", "name", "email");
+    assertThat(chunk.isQueryFetch()).isTrue();
+  }
+
+}

src/test/java/io/ebeaninternal/server/querydefn/OrmQueryDetailTest.java

@@ -0,0 +1,258 @@
+package io.ebeaninternal.server.querydefn;
+
+import io.ebean.BaseTestCase;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+public class OrmQueryDetailTest extends BaseTestCase {
+
+  OrmQueryDetail parse(String query) {
+    return new OrmQueryDetailParser(query).parse();
+  }
+
+  @Test
+  public void isEmpty_when_empty() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    assertThat(detail.isEmpty()).isTrue();
+  }
+
+  @Test
+  public void isEmpty_when_hasFetch_expect_false() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.fetch("customer", null, null);
+    assertThat(detail.isEmpty()).isFalse();
+  }
+
+  @Test
+  public void isEmpty_when_hasSelect_expect_false() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.select("name");
+    assertThat(detail.isEmpty()).isFalse();
+  }
+
+  @Test
+  public void isAutoTuneEqual_when_fetchOrderIsDifferent_then_stillEqual() {
+
+    OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code)");
+    OrmQueryDetail detail2 = parse("select (id,name)  fetch details (code) fetch customer (name)");
+
+    assertTrue(detail1.isAutoTuneEqual(detail2));
+  }
+
+  @Test
+  public void isAutoTuneEqual_when_different_select() {
+
+    OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code)");
+    OrmQueryDetail detail2 = parse("select (id)  fetch details (code) fetch customer (name)");
+
+    assertFalse(detail1.isAutoTuneEqual(detail2));
+  }
+
+  @Test
+  public void isAutoTuneEqual_when_different_selectInFetch() {
+
+    OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code)");
+    OrmQueryDetail detail2 = parse("select (id,name) fetch customer (id,name) fetch details (code)");
+
+    assertFalse(detail1.isAutoTuneEqual(detail2));
+  }
+
+  @Test
+  public void isAutoTuneEqual_when_different_additionalFetch() {
+
+    OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code)");
+    OrmQueryDetail detail2 = parse("select (id,name) fetch customer (name) fetch details (code) fetch customer.contacts");
+
+    assertFalse(detail1.isAutoTuneEqual(detail2));
+  }
+
+  @Test
+  public void isAutoTuneEqual_when_different_removedFetch() {
+
+    OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code) fetch customer.contacts");
+    OrmQueryDetail detail2 = parse("select (id,name) fetch customer (name) fetch details (code)");
+
+    assertFalse(detail1.isAutoTuneEqual(detail2));
+    assertFalse(detail2.isAutoTuneEqual(detail1));
+  }
+
+  @Test
+  public void isAutoTuneEqual_when_different_removedFetchProperty() {
+
+    OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name)");
+    OrmQueryDetail detail2 = parse("select (id,name) fetch customer ");
+
+    assertFalse(detail1.isAutoTuneEqual(detail2));
+    assertFalse(detail2.isAutoTuneEqual(detail1));
+  }
+
+  @Test
+  public void isAutoTuneEqual_when_different_path() {
+
+    OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name)");
+    OrmQueryDetail detail2 = parse("select (id,name) fetch details (id) ");
+
+    assertFalse(detail1.isAutoTuneEqual(detail2));
+    assertFalse(detail2.isAutoTuneEqual(detail1));
+  }
+
+  @Test
+  public void select_whenMultiple() throws Exception {
+
+    OrmQueryDetail other = new OrmQueryDetail();
+    other.select("id,name");
+
+    OrmQueryProperties root = other.getChunk(null, false);
+    assertNull(root.getPath());
+    assertThat(root.getIncluded()).containsExactly("id", "name");
+  }
+
+  @Test
+  public void select_whenOne() throws Exception {
+
+    OrmQueryDetail other = new OrmQueryDetail();
+    other.select("name");
+
+    OrmQueryProperties root = other.getChunk(null, false);
+    assertNull(root.getPath());
+    assertThat(root.getIncluded()).containsExactly("name");
+  }
+
+  @Test
+  public void getFetchPaths_when_noFetches_then_expect_empty() {
+
+    assertThat(new OrmQueryDetail().getFetchPaths()).isEmpty();
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.select("foo");
+
+    assertThat(detail.getFetchPaths()).isEmpty();
+  }
+
+  @Test
+  public void getFetchPaths_when_oneFetch() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.select("foo");
+    detail.fetch("customer", null, null);
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer");
+  }
+
+  @Test
+  public void getFetchPaths_when_multipleFetch_expect_preserveOrder() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.select("foo");
+    detail.fetch("customer", null, null);
+    detail.fetch("details", null, null);
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer", "details");
+  }
+
+  @Test
+  public void getFetchPaths_when_multipleFetch_expect_preserveOrder_v2() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.select("foo");
+    detail.fetch("details", null, null);
+    detail.fetch("customer", null, null);
+    detail.fetch("details.product", null, null);
+
+    assertThat(detail.getFetchPaths()).containsExactly("details", "customer", "details.product");
+  }
+
+  @Test
+  public void markQueryJoins_when_allowOne_expect_stillFetchJoin() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.fetch("details", null, null);
+
+    detail.markQueryJoins(orderDesc(), null, true);
+
+    assertThat(detail.getChunk("details", false).isQueryFetch()).isFalse();
+  }
+
+  @Test
+  public void markQueryJoins_when_allowNone_expect_queryJoin() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.fetch("details", null, null);
+
+    detail.markQueryJoins(orderDesc(), null, false);
+
+    assertThat(detail.getChunk("details", false).isQueryFetch()).isTrue();
+  }
+
+  @Test
+  public void markQueryJoins_when_allowOneButSecond_expect_queryJoin() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.fetch("details", null, null);
+    detail.fetch("customer.contacts", null, null);
+
+    detail.markQueryJoins(orderDesc(), null, true);
+
+    assertThat(detail.getChunk("details", false).isQueryFetch()).isFalse();
+    assertThat(detail.getChunk("customer.contacts", false).isQueryFetch()).isTrue();
+  }
+
+  @Test
+  public void markQueryJoins_when_allowNone_expect_bothQueryJoin() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.fetch("details", null, null);
+    detail.fetch("customer.contacts", null, null);
+
+    detail.markQueryJoins(orderDesc(), null, false);
+
+    assertThat(detail.getChunk("details", false).isQueryFetch()).isTrue();
+    assertThat(detail.getChunk("customer.contacts", false).isQueryFetch()).isTrue();
+  }
+
+  @Test
+  public void sortFetchPaths_when_missingParent_expect_addsMissing() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.fetch("customer.contacts", null, null);
+
+    detail.sortFetchPaths(orderDesc());
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
+    assertThat(detail.getChunk("customer", false).getIncluded()).containsExactly("id");
+  }
+
+  @Test
+  public void sortFetchPaths_when_outOfOrder_expect_correctOrder() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.fetch("customer.contacts", "email", null);
+    detail.fetch("customer", "name", null);
+
+    detail.sortFetchPaths(orderDesc());
+
+    assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
+    assertThat(detail.getChunk("customer", false).getIncluded()).containsExactly("name");
+  }
+
+  @Test
+  public void sortFetchPaths_when_empty_expect_stillEmpty() {
+
+    OrmQueryDetail detail = new OrmQueryDetail();
+    detail.sortFetchPaths(orderDesc());
+
+    assertThat(detail.getFetchPaths()).isEmpty();
+  }
+
+  BeanDescriptor<Order> orderDesc() {
+    return getBeanDescriptor(Order.class);
+  }
+
+}

src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPlanKeyTest.java

@@ -0,0 +1,348 @@
+package io.ebeaninternal.server.querydefn;
+
+
+import io.ebean.OrderBy;
+import io.ebeaninternal.api.SpiExpression;
+import io.ebeaninternal.api.SpiExpressionList;
+import io.ebeaninternal.api.SpiQuery;
+import io.ebeaninternal.server.deploy.TableJoin;
+import io.ebeaninternal.server.deploy.meta.DeployTableJoin;
+import io.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
+import io.ebeaninternal.server.expression.BaseExpressionTest;
+import org.tests.model.basic.Customer;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class OrmQueryPlanKeyTest extends BaseExpressionTest {
+
+
+  @Test
+  public void equals_when_defaults() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffTableJoinNull() {
+
+    TableJoin tableJoin = tableJoin("table", "id", "customer_id");
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(tableJoin, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffTableJoin() {
+
+    TableJoin tableJoin1 = tableJoin("one", "id", "customer_id");
+    TableJoin tableJoin2 = tableJoin("two", "id", "customer_id");
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(tableJoin1, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(tableJoin2, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameTableJoin() {
+
+    TableJoin tableJoin1 = tableJoin("one", "id", "customer_id");
+    TableJoin tableJoin2 = tableJoin("one", "id", "customer_id");
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(tableJoin1, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(tableJoin2, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertSame(key1, key2);
+  }
+
+  @NotNull
+  private TableJoin tableJoin(String table, String col1, String col2) {
+    DeployTableJoin deploy = new DeployTableJoin();
+    deploy.setTable(table);
+    deploy.addJoinColumn(new DeployTableJoinColumn(col1, col2));
+    return new TableJoin(deploy);
+  }
+
+  @Test
+  public void equals_when_diffQueryType() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.LIST, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_firstRowsDifferent() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 10, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_maxRowsDifferent() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 10, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_firstRowsMaxRowsSame() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 10, 20, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 10, 20, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffDisableLazyLoading() {
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, true, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffOrderByNull() {
+
+    OrderBy<Object> o1 = new OrderBy<>("id");
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, o1, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_orderBySame() {
+
+    OrderBy<Object> o1 = new OrderBy<>("id, name");
+    OrderBy<Object> o2 = new OrderBy<>("id, name");
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, o1, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, o2, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffDistinct() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, true, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameDistinct() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, true, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, true, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffSqlDistinct() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, true, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameSqlDistinct() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, true, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, true, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffMapKeyNull() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, "mapKey", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffMapKey() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, "mapKey", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, "diff", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameMapKey() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, "mapKey", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, "mapKey", null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffIdNull() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, 42, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_idBothGiven() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, 42, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, 23, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffTemporalMode() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.DRAFT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffForUpdate() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, true, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffRootAliasNull() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "rootAlias", null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffRootAlias() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "rootAlias", null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "diff", null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameRootAlias() {
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "rootAlias", null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, "rootAlias", null, null);
+    assertSame(key1, key2);
+  }
+
+  SpiExpressionList<Customer> list_id_eq_42() {
+    return (SpiExpressionList<Customer>) server().find(Customer.class)
+      .where().eq("id", 42);
+  }
+
+  SpiExpressionList<Customer> list_id_eq_43() {
+    return (SpiExpressionList<Customer>) server().find(Customer.class)
+      .where().eq("id", 43);
+  }
+
+  SpiExpressionList<Customer> list_id_eq_42_and_name_eq_rob() {
+    return (SpiExpressionList<Customer>) server().find(Customer.class)
+      .where().eq("id", 43).eq("name", "rob");
+  }
+
+
+  @Test
+  public void equals_when_sameWhere() {
+
+
+    SpiExpressionList<Customer> list1 = list_id_eq_42();
+    SpiExpressionList<Customer> list2 = list_id_eq_43();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, list1, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, list2, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertSame(key1, key2);
+  }
+
+
+  @Test
+  public void equals_when_diffWhere() {
+
+    SpiExpressionList<Customer> where1 = list_id_eq_42();
+    SpiExpressionList<Customer> where2 = list_id_eq_42_and_name_eq_rob();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, where1, null, SpiQuery.TemporalMode.DRAFT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, where2, null, SpiQuery.TemporalMode.DRAFT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffWhereNullLast() {
+
+    SpiExpressionList<Customer> list1 = list_id_eq_42();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, list1, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffWhereNullFirst() {
+
+    SpiExpressionList<Customer> list1 = list_id_eq_42();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, list1, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_diffHaving() {
+
+    SpiExpression having1 = list_id_eq_42().copyForPlanKey();
+    SpiExpression having2 = list_id_eq_42_and_name_eq_rob().copyForPlanKey();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, having1, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, having2, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_sameHaving() {
+
+    SpiExpression having1 = list_id_eq_42().copyForPlanKey();
+    SpiExpression having2 = list_id_eq_42().copyForPlanKey();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, having1, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, having2, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertSame(key1, key2);
+  }
+
+  @Test
+  public void equals_when_havingNullLast() {
+
+    SpiExpression having1 = list_id_eq_42().copyForPlanKey();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, having1, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  @Test
+  public void equals_when_havingNullFirst() {
+
+    SpiExpression having1 = list_id_eq_42().copyForPlanKey();
+
+    OrmQueryPlanKey key1 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, null, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    OrmQueryPlanKey key2 = new OrmQueryPlanKey(null, SpiQuery.Type.BEAN, null, 0, 0, false, null, false, false, null, null, null, null, having1, SpiQuery.TemporalMode.CURRENT, false, null, null, null);
+    assertDifferent(key1, key2);
+  }
+
+  private void assertDifferent(OrmQueryPlanKey key1, OrmQueryPlanKey key2) {
+    assertThat(key1).isNotEqualTo(key2);
+    assertThat(key1.hashCode()).isNotEqualTo(key2.hashCode());
+  }
+
+  private void assertSame(OrmQueryPlanKey key1, OrmQueryPlanKey key2) {
+    assertThat(key1).isEqualTo(key2);
+    assertThat(key1.hashCode()).isEqualTo(key2.hashCode());
+  }
+}

src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesParserTest.java

@@ -0,0 +1,131 @@
+package io.ebeaninternal.server.querydefn;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class OrmQueryPropertiesParserTest {
+
+  @Test
+  public void when_null() {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse(null);
+    assertAllDefaults(res);
+    assertThat(res.properties).isEqualTo("");
+  }
+
+  @Test
+  public void when_empty() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("");
+    assertAllDefaults(res);
+    assertThat(res.properties).isEqualTo("");
+  }
+
+  @Test
+  public void when_hasStar() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("*");
+    assertAllDefaults(res);
+    assertThat(res.properties).isEqualTo("*");
+  }
+
+  @Test
+  public void when_hasCache() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("+cache");
+    assertThat(res.cache).isTrue();
+    assertThat(res.included).isNull();
+  }
+
+  @Test
+  public void when_hasCache_first() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("+cache,id");
+    assertThat(res.cache).isTrue();
+    assertThat(res.included).containsExactly("id");
+  }
+
+  @Test
+  public void when_hasCache_last() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("name,+cache");
+    assertThat(res.cache).isTrue();
+    assertThat(res.included).containsExactly("name");
+  }
+
+  @Test
+  public void when_hasCache_middle() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("name,+cache, id");
+    assertThat(res.cache).isTrue();
+    assertThat(res.included).containsExactly("name", "id");
+  }
+
+  @Test
+  public void when_hasReadOnly() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("+readonly");
+    assertThat(res.readOnly).isTrue();
+    assertThat(res.included).isNull();
+  }
+
+  @Test
+  public void when_hasLazy() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("+lazy");
+    assertThat(res.fetchConfig.getLazyBatchSize()).isEqualTo(0);
+    assertThat(res.included).isNull();
+  }
+
+  @Test
+  public void when_hasLazyValue() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("+lazy(20)");
+    assertThat(res.fetchConfig.getLazyBatchSize()).isEqualTo(20);
+    assertThat(res.included).isNull();
+  }
+
+  @Test
+  public void when_hasLazyValue_last() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("name,+lazy(20)");
+    assertThat(res.fetchConfig.getLazyBatchSize()).isEqualTo(20);
+    assertThat(res.included).containsExactly("name");
+  }
+
+  @Test
+  public void when_hasLazyValue_first() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("+lazy(20),id,name");
+    assertThat(res.fetchConfig.getLazyBatchSize()).isEqualTo(20);
+    assertThat(res.included).containsExactly("id", "name");
+  }
+
+  @Test
+  public void when_allProperties() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("+query(4),+lazy(5)");
+    assertThat(res.fetchConfig.getLazyBatchSize()).isEqualTo(5);
+    assertThat(res.included).isNull();
+  }
+
+  @Test
+  public void when_everything_set() throws Exception {
+
+    OrmQueryPropertiesParser.Response res = OrmQueryPropertiesParser.parse("id, name +readonly +lazy(20) +query(30) +cache");
+    assertThat(res.fetchConfig.getLazyBatchSize()).isEqualTo(20);
+    assertThat(res.fetchConfig.getQueryBatchSize()).isEqualTo(30);
+    assertThat(res.readOnly).isTrue();
+    assertThat(res.cache).isTrue();
+    assertThat(res.included).containsExactly("id", "name");
+  }
+
+  private void assertAllDefaults(OrmQueryPropertiesParser.Response res) {
+    assertThat(res.cache).isFalse();
+    assertThat(res.readOnly).isFalse();
+    assertThat(res.fetchConfig.getLazyBatchSize()).isEqualTo(-1);
+    assertThat(res.fetchConfig.getQueryBatchSize()).isEqualTo(-1);
+    assertThat(res.included).isNull();
+  }
+}

src/test/java/io/ebeaninternal/server/querydefn/OrmQueryPropertiesTest.java

@@ -0,0 +1,89 @@
+package io.ebeaninternal.server.querydefn;
+
+import org.junit.Test;
+
+import java.util.LinkedHashSet;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class OrmQueryPropertiesTest {
+
+  String append(String prefix, OrmQueryProperties p1) {
+    StringBuilder sb = new StringBuilder();
+    p1.append(prefix, sb);
+    return sb.toString();
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void construct_with_propertySet_when_null() {
+    new OrmQueryProperties(null, (LinkedHashSet<String>) null);
+  }
+
+  @Test
+  public void construct_with_propertySet_when_empty() {
+
+    OrmQueryProperties p1 = new OrmQueryProperties(null, new LinkedHashSet<>());
+    assertThat(p1.getProperties()).isEqualTo("");
+    assertThat(p1.allProperties()).isFalse();
+  }
+
+  @Test
+  public void construct_with_propertySet_when_one() {
+
+    LinkedHashSet<String> set = new LinkedHashSet<>();
+    set.add("name");
+    OrmQueryProperties p1 = new OrmQueryProperties(null, set);
+
+    assertThat(p1.getProperties()).isEqualTo("name");
+    assertThat(p1.allProperties()).isFalse();
+  }
+
+  @Test
+  public void construct_with_propertySet_when_some() {
+
+    LinkedHashSet<String> set = new LinkedHashSet<>();
+    set.add("id");
+    set.add("name");
+    set.add("startDate");
+    OrmQueryProperties p1 = new OrmQueryProperties(null, set);
+
+    assertThat(p1.getProperties()).isEqualTo("id,name,startDate");
+    assertThat(p1.allProperties()).isFalse();
+  }
+
+  @Test
+  public void append_when_empty() {
+
+    OrmQueryProperties p1 = new OrmQueryProperties();
+    assertThat(append("select ", p1)).isEqualTo("select ");
+  }
+
+  @Test
+  public void append_when_someProperties() {
+
+    OrmQueryProperties p1 = new OrmQueryProperties(null, "id,name");
+    assertThat(append("select ", p1)).isEqualTo("select (id,name) ");
+  }
+
+  @Test
+  public void append_when_somePropertiesWithOptions() {
+
+    OrmQueryProperties p1 = new OrmQueryProperties(null, "id,name +cache");
+    assertThat(append("select ", p1)).isEqualTo("select (id,name +cache) ");
+  }
+
+  @Test
+  public void append_when_path_and_emptyProperties() {
+
+    OrmQueryProperties p1 = new OrmQueryProperties("customer", "");
+    assertThat(append("fetch ", p1)).isEqualTo("fetch customer ");
+  }
+
+  @Test
+  public void append_when_path_and_somePropertiesWithOptions() {
+
+    OrmQueryProperties p1 = new OrmQueryProperties("customer", "id,name +cache");
+    assertThat(append("fetch ", p1)).isEqualTo("fetch customer (id,name +cache) ");
+  }
+
+}

src/test/java/io/ebeaninternal/server/rawsql/TestRawSqlParsing.java

@@ -0,0 +1,29 @@
+package io.ebeaninternal.server.rawsql;
+
+import io.ebean.RawSql;
+import io.ebean.RawSql.Sql;
+import io.ebean.RawSqlBuilder;
+import junit.framework.TestCase;
+
+public class TestRawSqlParsing extends TestCase {
+
+  public void test() {
+
+    String sql
+      = " select order_id, sum(order_qty*unit_price) as totalAmount"
+      + " from o_order_detail "
+      + " group by order_id";
+
+    RawSql rawSql = RawSqlBuilder
+      .parse(sql)
+      .columnMapping("order_id", "order.id")
+      //.columnMapping("sum(order_qty*unit_price)","totalAmount")
+      .create();
+
+    Sql rs = rawSql.getSql();
+
+    String s = rs.toString();
+    assertTrue(s, s.contains("[order_id, sum"));
+
+  }
+}

src/test/java/io/ebeaninternal/server/text/json/TestJsonWriteVisitor.java

@@ -0,0 +1,109 @@
+package io.ebeaninternal.server.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import io.ebean.text.json.JsonWriteBeanVisitor;
+import io.ebean.text.json.JsonWriteOptions;
+import io.ebean.text.json.JsonWriter;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestJsonWriteVisitor extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class)
+      .select("id, name, status")
+      .fetch("billingAddress", "line1, city")
+      .fetch("billingAddress.country", "*")
+      .fetch("contacts", "firstName,email")
+      .order().desc("id")
+      .findList();
+
+    JsonContext json = Ebean.json();
+
+    JsonWriteOptions options = new JsonWriteOptions();
+    options.setRootPathVisitor(new CustomerVisitor());
+    options.setPathVisitor("billingAddress", new BillingVisitor());
+    options.setPathVisitor("billingAddress.country", new CountryVisitor());
+    options.setPathVisitor("contacts", new ContactVisitor());
+
+    String jsonContent = json.toJson(list, options);
+
+    assertThat(jsonContent).contains("customerExtra");
+    assertThat(jsonContent).contains("contactExtra");
+    assertThat(jsonContent).contains("billingExtra");
+    assertThat(jsonContent).contains("countryExtra");
+  }
+
+  class CustomerVisitor implements JsonWriteBeanVisitor<Customer> {
+
+    @Override
+    public void visit(Customer bean, JsonWriter jsonWriter) {
+      jsonWriter.writeStringField("customerExtra", "extra4");
+      jsonWriter.writeStartObject("startObj");
+      jsonWriter.writeBooleanField("yesno", true);
+      jsonWriter.writeEndObject();
+
+      jsonWriter.writeFieldName("secObj");
+      jsonWriter.writeStartObject();
+      jsonWriter.writeBooleanField("yesno", false);
+      jsonWriter.writeEndObject();
+
+      jsonWriter.writeStartArray("startList");
+      jsonWriter.writeBoolean(true);
+      jsonWriter.writeString("one");
+      jsonWriter.writeNumber(1);
+      jsonWriter.writeNumber(2L);
+      jsonWriter.writeNumber(new BigDecimal("34.45"));
+      jsonWriter.writeNull();
+      jsonWriter.writeEndArray();
+
+      jsonWriter.writeFieldName("secondList");
+      jsonWriter.writeStartArray();
+      jsonWriter.writeNumber(3L);
+      jsonWriter.writeRawValue("\"rawVal\"");
+      jsonWriter.writeEndArray();
+
+      jsonWriter.writeRaw(",\"rawField\":{\"ra\":42}");
+
+    }
+  }
+
+  class ContactVisitor implements JsonWriteBeanVisitor<Contact> {
+
+    @Override
+    public void visit(Contact bean, JsonWriter jsonWriter) {
+      jsonWriter.writeStringField("contactExtra", "extra3");
+    }
+  }
+
+  class BillingVisitor implements JsonWriteBeanVisitor<Address> {
+
+    @Override
+    public void visit(Address bean, JsonWriter jsonWriter) {
+      jsonWriter.writeStringField("billingExtra", "extra1");
+    }
+  }
+
+  class CountryVisitor implements JsonWriteBeanVisitor<Country> {
+
+    @Override
+    public void visit(Country bean, JsonWriter jsonWriter) {
+      jsonWriter.writeStringField("countryExtra", "extra2");
+    }
+  }
+}

src/test/java/io/ebeaninternal/server/text/json/TestTextJsonBeanReadVisitor.java

@@ -0,0 +1,82 @@
+package io.ebeaninternal.server.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import io.ebean.text.json.JsonReadBeanVisitor;
+import io.ebean.text.json.JsonReadOptions;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.io.StringReader;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestTextJsonBeanReadVisitor extends BaseTestCase {
+
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class)
+      .select("id, name, status, shippingAddress")
+      .fetch("billingAddress", "line1, city")
+      .fetch("billingAddress.country", "*")
+      .fetch("contacts", "firstName,email")
+      .order().desc("id")
+      .findList();
+
+    JsonContext json = Ebean.json();
+
+    JsonReadOptions options = new JsonReadOptions();
+    options.addRootVisitor(new CVisitor());
+    options.addVisitor("contacts", new ContactVisitor());
+    options.addVisitor("billingAddress", new AVisitor());
+    options.addVisitor("shippingAddress", new ASVisitor());
+
+    String s = json.toJson(list);
+
+    List<Customer> mList = json.toList(Customer.class, s, options);
+
+    StringReader reader = new StringReader(s);
+    List<Customer> mList2 = json.toList(Customer.class, reader);
+
+    assertEquals(mList.size(), mList2.size());
+  }
+
+  private static class CVisitor implements JsonReadBeanVisitor<Customer> {
+
+    @Override
+    public void visit(Customer bean, Map<String, Object> unmapped) {
+      bean.getId();
+    }
+  }
+
+  private static class AVisitor implements JsonReadBeanVisitor<Address> {
+
+    public void visit(Address bean, Map<String, Object> unmapped) {
+      bean.getId();
+    }
+  }
+
+  private static class ASVisitor implements JsonReadBeanVisitor<Address> {
+
+    public void visit(Address bean, Map<String, Object> unmapped) {
+      bean.getId();
+    }
+  }
+
+  private static class ContactVisitor implements JsonReadBeanVisitor<Contact> {
+
+    public void visit(Contact bean, Map<String, Object> unmapped) {
+      bean.getId();
+    }
+  }
+}

src/test/java/io/ebeaninternal/server/text/json/WriteJsonDirtyTest.java

@@ -0,0 +1,55 @@
+package io.ebeaninternal.server.text.json;
+
+import io.ebean.Ebean;
+import io.ebean.bean.EntityBean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.sql.Date;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+public class WriteJsonDirtyTest {
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+    List<Customer> customers = Ebean.find(Customer.class).findList();
+
+    Customer customer = Ebean.find(Customer.class).setId(customers.get(0).getId())
+      .setUseCache(false)
+      .findUnique();
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    BeanDescriptor<Customer> descriptor = server.getBeanDescriptor(Customer.class);
+
+    customer.setName("dirtyCustName");
+    customer.setAnniversary(new Date(System.currentTimeMillis()));
+
+    EntityBean entityBean = (EntityBean) customer;
+    boolean[] dirtyProperties = entityBean._ebean_getIntercept().getDirtyProperties();
+
+    StringWriter writer = new StringWriter();
+    JsonFactory jsonFactory = new JsonFactory();
+    JsonGenerator generator = jsonFactory.createGenerator(writer);
+
+    WriteJson writeJson = new WriteJson(server, generator, null, null, null, null);
+    descriptor.jsonWriteDirty(writeJson, entityBean, dirtyProperties);
+
+    generator.flush();
+    generator.close();
+
+    String jsonContent = writer.toString();
+    assertTrue(jsonContent.contains("\"name\":"));
+    assertTrue(jsonContent.contains("\"anniversary\":"));
+  }
+}

src/test/java/io/ebeaninternal/server/text/json/WriteJsonTest.java

@@ -0,0 +1,59 @@
+package io.ebeaninternal.server.text.json;
+
+import io.ebean.FetchPath;
+import io.ebean.config.JsonConfig;
+import io.ebean.text.PathProperties;
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.StringWriter;
+
+import static org.junit.Assert.assertTrue;
+
+public class WriteJsonTest {
+
+  @Test
+  public void test_push() throws IOException {
+
+    JsonFactory jsonFactory = new JsonFactory();
+    JsonGenerator generator = jsonFactory.createGenerator(new StringWriter());
+
+    FetchPath fetchPath = PathProperties.parse("id,status,name,customer(id,name,address(street,city)),orders(qty,product(sku,prodName))");
+    WriteJson writeJson = new WriteJson(null, generator, fetchPath, null, null, JsonConfig.Include.ALL);
+
+    WriteJson.WriteBean rootLevel = writeJson.createWriteBean(null, null);
+    assertTrue(rootLevel.currentIncludeProps.contains("id"));
+    assertTrue(rootLevel.currentIncludeProps.contains("status"));
+    assertTrue(rootLevel.currentIncludeProps.contains("name"));
+    assertTrue(rootLevel.currentIncludeProps.contains("customer"));
+
+    writeJson.beginAssocOne("customer", null);
+    WriteJson.WriteBean customerLevel = writeJson.createWriteBean(null, null);
+    assertTrue(customerLevel.currentIncludeProps.contains("id"));
+    assertTrue(customerLevel.currentIncludeProps.contains("name"));
+    assertTrue(customerLevel.currentIncludeProps.contains("address"));
+
+    writeJson.beginAssocOne("address", null);
+    WriteJson.WriteBean addressLevel = writeJson.createWriteBean(null, null);
+    assertTrue(addressLevel.currentIncludeProps.contains("street"));
+    assertTrue(addressLevel.currentIncludeProps.contains("city"));
+
+    writeJson.endAssocOne();
+    writeJson.endAssocOne();
+
+    writeJson.beginAssocMany("orders");
+    WriteJson.WriteBean orderLevel = writeJson.createWriteBean(null, null);
+    assertTrue(orderLevel.currentIncludeProps.contains("qty"));
+    assertTrue(orderLevel.currentIncludeProps.contains("product"));
+
+    writeJson.beginAssocOne("product", null);
+    WriteJson.WriteBean productLevel = writeJson.createWriteBean(null, null);
+    assertTrue(productLevel.currentIncludeProps.contains("sku"));
+    assertTrue(productLevel.currentIncludeProps.contains("prodName"));
+    writeJson.endAssocOne();
+    writeJson.endAssocMany();
+
+  }
+}

src/test/java/io/ebeaninternal/server/transaction/DefaultPersistenceContextTest.java

@@ -0,0 +1,162 @@
+package io.ebeaninternal.server.transaction;
+
+import io.ebean.bean.PersistenceContext;
+import io.ebean.bean.PersistenceContextUtil;
+import org.tests.model.basic.Car;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Vehicle;
+import org.junit.Test;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class DefaultPersistenceContextTest {
+
+  Customer customer42;
+
+  Car car1;
+
+  public DefaultPersistenceContextTest() {
+    customer42 = new Customer();
+    customer42.setId(42);
+
+    car1 = new Car();
+    car1.setId(1);
+  }
+
+  PersistenceContext pc() {
+    return new DefaultPersistenceContext();
+  }
+
+  PersistenceContext pcWith42() {
+    PersistenceContext pc = pc();
+    pc.put(Customer.class, 42, customer42);
+    return pc;
+  }
+
+  Class<?> root(Class<?> cls) {
+    return PersistenceContextUtil.root(cls);
+  }
+
+  @Test
+  public void put_get_withInheritance() throws Exception {
+
+    PersistenceContext pc = pc();
+    pc.put(root(Vehicle.class), 1, car1);
+
+    Object found = pc.get(root(Car.class), 1);
+    assertThat(found).isSameAs(car1);
+  }
+
+  @Test
+  public void put_get() throws Exception {
+
+    PersistenceContext pc = pc();
+    pc.put(Customer.class, customer42.getId(), customer42);
+
+    Object found = pc.get(Customer.class, 42);
+    assertThat(found).isSameAs(customer42);
+  }
+
+  @Test
+  public void putIfAbsent_when_absent() throws Exception {
+
+    PersistenceContext pc = pc();
+    Object existing = pc.putIfAbsent(Customer.class, customer42.getId(), customer42);
+
+    assertThat(existing).isNull();
+  }
+
+  @Test
+  public void putIfAbsent_when_notAbsent() throws Exception {
+
+    PersistenceContext pc = pcWith42();
+    Object existing = pc.putIfAbsent(Customer.class, customer42.getId(), new Customer());
+
+    assertThat(existing).isSameAs(customer42);
+  }
+
+  @Test
+  public void get_when_empty() throws Exception {
+    PersistenceContext pc = pc();
+    Object found = pc.get(Customer.class, 42);
+    assertThat(found).isNull();
+  }
+
+  @Test
+  public void get_when_there() throws Exception {
+    PersistenceContext pc = pcWith42();
+    Object found = pc.get(Customer.class, 42);
+    assertThat(found).isSameAs(customer42);
+  }
+
+  @Test
+  public void getWithOption_when_empty() throws Exception {
+
+    PersistenceContext pc = pc();
+    PersistenceContext.WithOption withOption = pc.getWithOption(Customer.class, 42);
+    assertThat(withOption).isNull();
+  }
+
+  @Test
+  public void getWithOption_when_there() throws Exception {
+
+    PersistenceContext pc = pcWith42();
+
+    PersistenceContext.WithOption withOption = pc.getWithOption(Customer.class, 42);
+    assertThat(withOption.getBean()).isSameAs(customer42);
+  }
+
+  @Test
+  public void getWithOption_when_deleted() throws Exception {
+
+    PersistenceContext pc = pcWith42();
+    pc.deleted(Customer.class, 42);
+
+    PersistenceContext.WithOption withOption = pc.getWithOption(Customer.class, 42);
+    assertThat(withOption.isDeleted()).isTrue();
+    assertThat(withOption.getBean()).isNull();
+  }
+
+  @Test
+  public void size_when_empty() throws Exception {
+
+    PersistenceContext pc = pc();
+    assertThat(pc.size(Customer.class)).isEqualTo(0);
+  }
+
+  @Test
+  public void size_when_some() throws Exception {
+
+    PersistenceContext pc = pcWith42();
+    assertThat(pc.size(Customer.class)).isEqualTo(1);
+  }
+
+  @Test
+  public void clear() throws Exception {
+
+    PersistenceContext pc = pcWith42();
+    pc.clear();
+    assertThat(pc.size(Customer.class)).isEqualTo(0);
+  }
+
+  @Test
+  public void clearClass() throws Exception {
+
+    PersistenceContext pc = pcWith42();
+    pc.clear(Customer.class);
+    assertThat(pc.size(Customer.class)).isEqualTo(0);
+  }
+
+  @Test
+  public void clearClassAndId() throws Exception {
+
+    PersistenceContext pc = pcWith42();
+    pc.put(Customer.class, 43, new Customer());
+
+    pc.clear(Customer.class, 42);
+    assertThat(pc.size(Customer.class)).isEqualTo(1);
+
+    pc.clear(Customer.class, 43);
+    assertThat(pc.size(Customer.class)).isEqualTo(0);
+  }
+}

src/test/java/io/ebeaninternal/server/transaction/JdbcTransactionTest.java

@@ -0,0 +1,77 @@
+package io.ebeaninternal.server.transaction;
+
+import io.ebean.Ebean;
+import io.ebean.Transaction;
+import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheManager;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasic;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JdbcTransactionTest {
+
+  @Test
+  public void isSkipCache() throws Exception {
+
+    Transaction transaction = Ebean.beginTransaction();
+    try {
+      // implicitly skip false due to query only at this point
+      assertThat(transaction.isSkipCache()).isFalse();
+
+      EBasic basic = new EBasic("b1");
+      Ebean.save(basic);
+
+      // implicitly skip true due to save
+      assertThat(transaction.isSkipCache()).isTrue();
+
+      Customer.find.byId(1);
+
+      // explicit control
+      transaction.setSkipCache(false);
+      assertThat(transaction.isSkipCache()).isFalse();
+
+      transaction.setSkipCache(true);
+      assertThat(transaction.isSkipCache()).isTrue();
+
+    } finally {
+      transaction.end();
+    }
+  }
+
+  @Test
+  public void skipCacheAfterSave() throws Exception {
+
+    ServerCacheManager cacheManager = Ebean.getDefaultServer().getServerCacheManager();
+    ServerCache customerBeanCache = cacheManager.getBeanCache(Customer.class);
+    ServerCache contactNatKeyCache = cacheManager.getNaturalKeyCache(Contact.class);
+
+    Transaction transaction = Ebean.beginTransaction();
+    try {
+      customerBeanCache.getStatistics(true);
+      contactNatKeyCache.getStatistics(true);
+
+      Customer.find.byId(19898989);
+      Ebean.find(Contact.class).where().eq("email", "junk@foo.com").findUnique();
+
+      assertThat(customerBeanCache.getStatistics(true).getMissCount()).isEqualTo(1);
+      assertThat(contactNatKeyCache.getStatistics(true).getMissCount()).isEqualTo(1);
+
+      EBasic basic = new EBasic("b1");
+      Ebean.save(basic);
+
+      // these don't hit L2 cache due to the save of b1
+      Customer.find.byId(29898989);
+      Ebean.find(Contact.class).where().eq("email", "junk2@foo.com").findUnique();
+
+      assertThat(customerBeanCache.getStatistics(true).getMissCount()).isEqualTo(0);
+      assertThat(contactNatKeyCache.getStatistics(true).getMissCount()).isEqualTo(0);
+
+    } finally {
+      transaction.end();
+    }
+  }
+
+}

src/test/java/io/ebeaninternal/server/type/ConvertInetAddressTest.java

@@ -0,0 +1,34 @@
+package io.ebeaninternal.server.type;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.net.InetAddress;
+
+public class ConvertInetAddressTest {
+
+  @Test
+  public void forString() {
+
+    InetAddress addr = ConvertInetAddresses.forString("128.1.10.23");
+    Assert.assertNotNull(addr);
+    Assert.assertEquals("128.1.10.23", addr.getHostAddress());
+
+    String ip6addr = "2001:db8:85a3:0:0:8a2e:370:7334";
+    InetAddress addr6 = ConvertInetAddresses.forString(ip6addr);
+    String uriAddr6 = ConvertInetAddresses.toUriString(addr6);
+    Assert.assertEquals("[" + ip6addr + "]", uriAddr6);
+    Assert.assertEquals(ip6addr, addr6.getHostAddress());
+  }
+
+  @Test
+  public void toUriString() {
+
+    InetAddress addr = ConvertInetAddresses.forString("128.1.10.23");
+    Assert.assertEquals("128.1.10.23", addr.getHostAddress());
+
+    String uriAddr = ConvertInetAddresses.toUriString(addr);
+    Assert.assertEquals("128.1.10.23", uriAddr);
+  }
+
+}

src/test/java/io/ebeaninternal/server/type/ConvertInetAddressesTest.java

@@ -0,0 +1,46 @@
+package io.ebeaninternal.server.type;
+
+import org.junit.Test;
+
+import java.net.InetAddress;
+
+import static org.junit.Assert.*;
+
+public class ConvertInetAddressesTest {
+
+  @Test
+  public void testForString() throws Exception {
+
+    InetAddress loopbackAddress = InetAddress.getLoopbackAddress();
+
+    String uri = ConvertInetAddresses.toUriString(loopbackAddress);
+    InetAddress inetAddress = ConvertInetAddresses.forString(uri);
+
+    assertEquals(loopbackAddress, inetAddress);
+  }
+
+  @Test
+  public void testIsInetAddress() throws Exception {
+
+    assertTrue(ConvertInetAddresses.isInetAddress("127.0.0.1"));
+
+    assertFalse(ConvertInetAddresses.isInetAddress("junk"));
+    assertFalse(ConvertInetAddresses.isInetAddress("127.0.0.junk"));
+    assertFalse(ConvertInetAddresses.isInetAddress("junk.0.0.23"));
+    assertFalse(ConvertInetAddresses.isInetAddress(""));
+    assertFalse(ConvertInetAddresses.isInetAddress("127.0.0"));
+
+  }
+
+  @Test
+  public void testToUriString() throws Exception {
+
+    InetAddress loopbackAddress = InetAddress.getLoopbackAddress();
+
+    String uri = ConvertInetAddresses.toUriString(loopbackAddress);
+    InetAddress inetAddress = ConvertInetAddresses.forUriString(uri);
+
+    assertEquals(loopbackAddress, inetAddress);
+  }
+
+}

src/test/java/io/ebeaninternal/server/type/DateTimeJsonParserTest.java

@@ -0,0 +1,71 @@
+package io.ebeaninternal.server.type;
+
+
+import org.junit.Test;
+
+import java.sql.Timestamp;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+
+public class DateTimeJsonParserTest {
+
+  @Test
+  public void parseFormat_when_hasMillis() throws Exception {
+
+    DateTimeJsonParser parser = new DateTimeJsonParser();
+
+    String input = "2016-02-28T20:39:00.123Z";
+    String formatted = parseAndFormat(parser, input);
+
+    assertThat(formatted).isEqualTo("2016-02-28T20:39:00.123Z");
+  }
+
+  @Test
+  public void parseFormat_when_noMillis() throws Exception {
+
+    DateTimeJsonParser parser = new DateTimeJsonParser();
+
+    String input = "2016-02-28T20:39:00Z";
+    String formatted = parseAndFormat(parser, input);
+
+    assertThat(formatted).isEqualTo("2016-02-28T20:39:00.000Z");
+  }
+
+  @Test
+  public void parseFormat_when_millis_1dp() throws Exception {
+
+    DateTimeJsonParser parser = new DateTimeJsonParser();
+
+    String input = "2016-02-28T20:39:00.0Z";
+    String formatted = parseAndFormat(parser, input);
+
+    assertThat(formatted).isEqualTo("2016-02-28T20:39:00.000Z");
+  }
+
+  @Test
+  public void parseFormat_when_millis_2dp() throws Exception {
+
+    DateTimeJsonParser parser = new DateTimeJsonParser();
+
+    String input = "2016-02-28T20:39:00.00Z";
+    String formatted = parseAndFormat(parser, input);
+
+    assertThat(formatted).isEqualTo("2016-02-28T20:39:00.000Z");
+  }
+
+  @Test
+  public void parseFormat_when_millis_3dp() throws Exception {
+
+    DateTimeJsonParser parser = new DateTimeJsonParser();
+
+    String input = "2016-02-28T20:39:00.000Z";
+    String formatted = parseAndFormat(parser, input);
+
+    assertThat(formatted).isEqualTo("2016-02-28T20:39:00.000Z");
+  }
+
+  private String parseAndFormat(DateTimeJsonParser parser, String input) {
+    Timestamp timestamp = parser.parse(input);
+    return parser.format(timestamp);
+  }
+}