[maven-release-plugin] prepare release ebean-11.18.5

* Fix for unintentianal flush when ID is loaded

* fix duplicateKey Exception

* higher id

pom.xml

@@ -9,7 +9,7 @@
 
   <groupId>io.ebean</groupId>
   <artifactId>ebean</artifactId>
-  <version>11.17.2</version>
+  <version>11.18.5</version>
   <packaging>jar</packaging>
 
   <name>ebean</name>
@@ -22,7 +22,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-11.17.2</tag>
+    <tag>ebean-11.18.5</tag>
   </scm>
 
   <profiles>
@@ -117,7 +117,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>3.11</version>
+      <version>4.1</version>
     </dependency>
 
     <dependency>
@@ -135,7 +135,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-migration</artifactId>
-      <version>11.5.4</version>
+      <version>11.7.1</version>
     </dependency>
 
     <dependency>
@@ -192,7 +192,7 @@
     <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
-      <version>9.4.1212</version>
+      <version>42.2.2</version>
       <scope>provided</scope>
     </dependency>
 

src/main/java/io/ebean/BeanRepository.java

@@ -2,6 +2,8 @@ package io.ebean;
 
 import io.ebean.bean.EntityBean;
 
+import java.util.Collection;
+
 /**
  * Provides finder functionality for use with "Dependency Injection style" use of Ebean.
  * <p>
@@ -115,6 +117,13 @@ public abstract class BeanRepository<I, T> extends BeanFinder<I, T> {
     db().save(bean);
   }
 
+  /**
+   * Save all the beans in the collection.
+   */
+  public int saveAll(Collection<T> bean) {
+    return db().saveAll(bean);
+  }
+
   /**
    * Update this entity.
    *
@@ -154,6 +163,13 @@ public abstract class BeanRepository<I, T> extends BeanFinder<I, T> {
     return db().delete(bean);
   }
 
+  /**
+   * Delete all the beans in the collection.
+   */
+  public int deleteAll(Collection<T> beans) {
+    return db().deleteAll(beans);
+  }
+
   /**
    * Delete a bean permanently without soft delete.
    * <p>

src/main/java/io/ebean/EbeanServer.java

@@ -808,411 +808,18 @@ public interface EbeanServer {
   <T> T getReference(Class<T> beanType, Object id);
 
   /**
-   * Return the number of 'top level' or 'root' entities this query should return.
-   *
-   * @see Query#findCount()
-   * @see Query#findFutureCount()
-   */
-  <T> int findCount(Query<T> query, Transaction transaction);
-
-  /**
-   * Return the Id values of the query as a List.
-   *
-   * @see Query#findIds()
-   */
-  @Nonnull
-  <A, T> List<A> findIds(Query<T> query, Transaction transaction);
-
-  /**
-   * Return a QueryIterator for the query.
+   * Return the extended API for EbeanServer.
    * <p>
-   * Generally using {@link #findEach(Query, Consumer, Transaction)} or
-   * {@link #findEachWhile(Query, Predicate, Transaction)} is preferred
-   * to findIterate(). The reason is that those methods automatically take care of
-   * closing the queryIterator (and the underlying jdbc statement and resultSet).
+   * The extended API has the options for executing queries that take an explicit
+   * transaction as an argument.
    * </p>
    * <p>
-   * This is similar to findEach in that not all the result beans need to be held
-   * in memory at the same time and as such is good for processing large queries.
-   * </p>
-   *
-   * @see Query#findIterate()
-   * @see Query#findEach(Consumer)
-   * @see Query#findEachWhile(Predicate)
-   */
-  @Nonnull
-  <T> QueryIterator<T> findIterate(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query visiting the each bean one at a time.
-   * <p>
-   * Unlike findList() this is suitable for processing a query that will return
-   * a very large resultSet. The reason is that not all the result beans need to be
-   * held in memory at the same time and instead processed one at a time.
-   * </p>
-   * <p>
-   * Internally this query using a PersistenceContext scoped to each bean (and the
-   * beans associated object graph).
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   *     ebeanServer.find(Order.class)
-   *       .where().eq("status", Order.Status.NEW)
-   *       .order().asc("id")
-   *       .findEach((Order order) -> {
-   *
-   *         // do something with the order bean
-   *         System.out.println(" -- processing order ... " + order);
-   *       });
-   *
-   * }</pre>
-   *
-   * @see Query#findEach(Consumer)
-   * @see Query#findEachWhile(Predicate)
-   */
-  <T> void findEach(Query<T> query, Consumer<T> consumer, Transaction transaction);
-
-  /**
-   * Execute the query visiting the each bean one at a time.
-   * <p>
-   * Compared to findEach() this provides the ability to stop processing the query
-   * results early by returning false for the Predicate.
-   * </p>
-   * <p>
-   * Unlike findList() this is suitable for processing a query that will return
-   * a very large resultSet. The reason is that not all the result beans need to be
-   * held in memory at the same time and instead processed one at a time.
-   * </p>
-   * <p>
-   * Internally this query using a PersistenceContext scoped to each bean (and the
-   * beans associated object graph).
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   *     ebeanServer.find(Order.class)
-   *       .where().eq("status", Order.Status.NEW)
-   *       .order().asc("id")
-   *       .findEachWhile((Order order) -> {
-   *
-   *         // do something with the order bean
-   *         System.out.println(" -- processing order ... " + order);
-   *
-   *         boolean carryOnProcessing = ...
-   *         return carryOnProcessing;
-   *       });
-   *
-   * }</pre>
-   *
-   * @see Query#findEach(Consumer)
-   * @see Query#findEachWhile(Predicate)
-   */
-  <T> void findEachWhile(Query<T> query, Predicate<T> consumer, Transaction transaction);
-
-  /**
-   * Return versions of a @History entity bean.
-   * <p>
-   * Generally this query is expected to be a find by id or unique predicates query.
-   * It will execute the query against the history returning the versions of the bean.
+   * Typically we only need to use the extended API when we do NOT want to use the
+   * usual ThreadLocal based mechanism to obtain the current transaction but instead
+   * supply the transaction explicitly.
    * </p>
    */
-  @Nonnull
-  <T> List<Version<T>> findVersions(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute a query returning a list of beans.
-   * <p>
-   * Generally you are able to use {@link Query#findList()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   * List<Customer> customers =
-   *     ebeanServer.find(Customer.class)
-   *     .where().ilike("name", "rob%")
-   *     .findList();
-   *
-   * }</pre>
-   *
-   * @param <T>         the type of entity bean to fetch.
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the list of fetched beans.
-   * @see Query#findList()
-   */
-  @Nonnull
-  <T> List<T> findList(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute find row count query in a background thread.
-   * <p>
-   * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a
-   * timeout).
-   * </p>
-   *
-   * @param query       the query to execute the row count on
-   * @param transaction the transaction (can be null).
-   * @return a Future object for the row count query
-   * @see Query#findFutureCount()
-   */
-  @Nonnull
-  <T> FutureRowCount<T> findFutureCount(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute find Id's query in a background thread.
-   * <p>
-   * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a
-   * timeout).
-   * </p>
-   *
-   * @param query       the query to execute the fetch Id's on
-   * @param transaction the transaction (can be null).
-   * @return a Future object for the list of Id's
-   * @see Query#findFutureIds()
-   */
-  @Nonnull
-  <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute find list query in a background thread returning a FutureList object.
-   * <p>
-   * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a timeout).
-   * <p>
-   * This query will execute in it's own PersistenceContext and using its own transaction.
-   * What that means is that it will not share any bean instances with other queries.
-   *
-   * @param query       the query to execute in the background
-   * @param transaction the transaction (can be null).
-   * @return a Future object for the list result of the query
-   * @see Query#findFutureList()
-   */
-  @Nonnull
-  <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction);
-
-  /**
-   * Return a PagedList for this query using firstRow and maxRows.
-   * <p>
-   * The benefit of using this over findList() is that it provides functionality to get the
-   * total row count etc.
-   * </p>
-   * <p>
-   * If maxRows is not set on the query prior to calling findPagedList() then a
-   * PersistenceException is thrown.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   *  PagedList<Order> pagedList = Ebean.find(Order.class)
-   *       .setFirstRow(50)
-   *       .setMaxRows(20)
-   *       .findPagedList();
-   *
-   *       // fetch the total row count in the background
-   *       pagedList.loadRowCount();
-   *
-   *       List<Order> orders = pagedList.getList();
-   *       int totalRowCount = pagedList.getTotalRowCount();
-   *
-   * }</pre>
-   *
-   * @return The PagedList
-   * @see Query#findPagedList()
-   */
-  @Nonnull
-  <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning a set of entity beans.
-   * <p>
-   * Generally you are able to use {@link Query#findSet()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   * <p>
-   * <pre>{@code
-   *
-   * Set<Customer> customers =
-   *     ebeanServer.find(Customer.class)
-   *     .where().ilike("name", "rob%")
-   *     .findSet();
-   *
-   * }</pre>
-   *
-   * @param <T>         the type of entity bean to fetch.
-   * @param query       the query to execute
-   * @param transaction the transaction to use (can be null).
-   * @return the set of fetched beans.
-   * @see Query#findSet()
-   */
-  @Nonnull
-  <T> Set<T> findSet(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning the entity beans in a Map.
-   * <p>
-   * Generally you are able to use {@link Query#findMap()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   *
-   * @param <T>         the type of entity bean to fetch.
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the map of fetched beans.
-   * @see Query#findMap()
-   */
-  @Nonnull
-  <K, T> Map<K, T> findMap(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning a list of values for a single property.
-   * <p>
-   * <h3>Example 1:</h3>
-   * <pre>{@code
-   *
-   *  List<String> names =
-   *    Ebean.find(Customer.class)
-   *      .select("name")
-   *      .orderBy().asc("name")
-   *      .findSingleAttributeList();
-   *
-   * }</pre>
-   * <h3>Example 2:</h3>
-   * <pre>{@code
-   *
-   *  List<String> names =
-   *    Ebean.find(Customer.class)
-   *      .setDistinct(true)
-   *      .select("name")
-   *      .where().eq("status", Customer.Status.NEW)
-   *      .orderBy().asc("name")
-   *      .setMaxRows(100)
-   *      .findSingleAttributeList();
-   *
-   * }</pre>
-   *
-   * @return the list of values for the selected property
-   * @see Query#findSingleAttributeList()
-   */
-  @Nonnull
-  <A, T> List<A> findSingleAttributeList(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the query returning at most one entity bean or null (if no matching
-   * bean is found).
-   * <p>
-   * This will throw a NonUniqueResultException if the query finds more than one result.
-   * </p>
-   * <p>
-   * Generally you are able to use {@link Query#findOne()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   *
-   * @param <T>         the type of entity bean to fetch.
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the list of fetched beans.
-   * @throws NonUniqueResultException if more than one result was found
-   * @see Query#findOne()
-   */
-  @Nullable
-  <T> T findOne(Query<T> query, Transaction transaction);
-
-  /**
-   * Similar to findOne() but returns an Optional (rather than nullable).
-   */
-  @Nonnull
-  <T> Optional<T> findOneOrEmpty(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute as a delete query deleting the 'root level' beans that match the predicates
-   * in the query.
-   * <p>
-   * Note that if the query includes joins then the generated delete statement may not be
-   * optimal depending on the database platform.
-   * </p>
-   *
-   * @param query       the query used for the delete
-   * @param transaction the transaction to use (can be null)
-   * @param <T>         the type of entity bean to fetch.
-   * @return the number of beans/rows that were deleted
-   */
-  <T> int delete(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the update query returning the number of rows updated.
-   * <p>
-   * The update query must be created using {@link #update(Class)}.
-   * </p>
-   *
-   * @param query       the update query to execute
-   * @param transaction the optional transaction to use for the update (can be null)
-   * @param <T>         the type of entity bean
-   * @return The number of rows updated
-   */
-  <T> int update(Query<T> query, Transaction transaction);
-
-  /**
-   * Execute the sql query returning a list of MapBean.
-   * <p>
-   * Generally you are able to use {@link SqlQuery#findList()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   *
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the list of fetched MapBean.
-   * @see SqlQuery#findList()
-   */
-  @Nonnull
-  List<SqlRow> findList(SqlQuery query, Transaction transaction);
-
-  /**
-   * Execute the SqlQuery iterating a row at a time.
-   * <p>
-   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
-   * </p>
-   */
-  void findEach(SqlQuery query, Consumer<SqlRow> consumer, Transaction transaction);
-
-  /**
-   * Execute the SqlQuery iterating a row at a time with the ability to stop consuming part way through.
-   * <p>
-   * Returning false after processing a row stops the iteration through the query results.
-   * </p>
-   * <p>
-   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
-   * </p>
-   */
-  void findEachWhile(SqlQuery query, Predicate<SqlRow> consumer, Transaction transaction);
-
-  /**
-   * Execute the sql query returning a single MapBean or null.
-   * <p>
-   * This will throw a PersistenceException if the query found more than one
-   * result.
-   * </p>
-   * <p>
-   * Generally you are able to use {@link SqlQuery#findOne()} rather than
-   * explicitly calling this method. You could use this method if you wish to
-   * explicitly control the transaction used for the query.
-   * </p>
-   *
-   * @param query       the query to execute.
-   * @param transaction the transaction to use (can be null).
-   * @return the fetched MapBean or null if none was found.
-   * @see SqlQuery#findOne()
-   */
-  @Nullable
-  SqlRow findOne(SqlQuery query, Transaction transaction);
+  ExtendedServer extended();
 
   /**
    * Either Insert or Update the bean depending on its state.

src/main/java/io/ebean/ExpressionList.java

@@ -120,6 +120,14 @@ public interface ExpressionList<T> {
    */
   Query<T> asDraft();
 
+  /**
+   * Convert the query to a DTO bean query.
+   * <p>
+   * We effectively use the underlying ORM query to build the SQL and then execute
+   * and map it into DTO beans.
+   */
+  <D> DtoQuery<D> asDto(Class<D> dtoClass);
+
   /**
    * Execute using "for update" clause which results in the DB locking the record.
    */
@@ -1023,6 +1031,20 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> bitwiseAll(String propertyName, long flags);
 
+  /**
+   * Add expression for the given bit flags to be NOT set.
+   * <p>
+   * <pre>{@code
+   *
+   * where().bitwiseNot("flags", BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseNot(String propertyName, long flags);
+
   /**
    * Add bitwise AND expression of the given bit flags to compare with the match/mask.
    * <p>

src/main/java/io/ebean/ExtendedServer.java

@@ -0,0 +1,452 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.persistence.NonUniqueResultException;
+import java.time.Clock;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * The extended API for EbeanServer.
+ * <p>
+ * This provides the finder methods that take an explicit transaction rather than obtaining
+ * the transaction from the usual mechanism (which is ThreadLocal based).
+ * </p>
+ * <p>
+ * In general we only want to use this ExtendedServer API when we want to avoid / bypass
+ * the use of the mechanism to get the current transaction and instead explicitly supply
+ * the transaction to use.
+ * </p>
+ * <p>
+ * Note that in all cases the transaction supplied can be null and in this case the EbeanServer
+ * will use the normal mechanism to obtain the transaction to use.
+ * </p>
+ */
+public interface ExtendedServer {
+
+  /**
+   * Return the NOW time from the Clock.
+   */
+  long clockNow();
+
+  /**
+   * Set the Clock to use for <code>@WhenCreated</code> and <code>@WhenModified</code>.
+   * <p>
+   * Note that we only expect to change the Clock for testing purposes.
+   * </p>
+   */
+  void setClock(Clock clock);
+
+  /**
+   * Return the number of 'top level' or 'root' entities this query should return.
+   *
+   * @see Query#findCount()
+   * @see Query#findFutureCount()
+   */
+  <T> int findCount(Query<T> query, Transaction transaction);
+
+  /**
+   * Return the Id values of the query as a List.
+   *
+   * @see Query#findIds()
+   */
+  @Nonnull
+  <A, T> List<A> findIds(Query<T> query, Transaction transaction);
+
+  /**
+   * Return a QueryIterator for the query.
+   * <p>
+   * Generally using {@link #findEach(Query, Consumer, Transaction)} or
+   * {@link #findEachWhile(Query, Predicate, Transaction)} is preferred
+   * to findIterate(). The reason is that those methods automatically take care of
+   * closing the queryIterator (and the underlying jdbc statement and resultSet).
+   * </p>
+   * <p>
+   * This is similar to findEach in that not all the result beans need to be held
+   * in memory at the same time and as such is good for processing large queries.
+   * </p>
+   *
+   * @see Query#findIterate()
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  @Nonnull
+  <T> QueryIterator<T> findIterate(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query visiting the each bean one at a time.
+   * <p>
+   * Unlike findList() this is suitable for processing a query that will return
+   * a very large resultSet. The reason is that not all the result beans need to be
+   * held in memory at the same time and instead processed one at a time.
+   * </p>
+   * <p>
+   * Internally this query using a PersistenceContext scoped to each bean (and the
+   * beans associated object graph).
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *     ebeanServer.find(Order.class)
+   *       .where().eq("status", Order.Status.NEW)
+   *       .order().asc("id")
+   *       .findEach((Order order) -> {
+   *
+   *         // do something with the order bean
+   *         System.out.println(" -- processing order ... " + order);
+   *       });
+   *
+   * }</pre>
+   *
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  <T> void findEach(Query<T> query, Consumer<T> consumer, Transaction transaction);
+
+  /**
+   * Execute the query visiting the each bean one at a time.
+   * <p>
+   * Compared to findEach() this provides the ability to stop processing the query
+   * results early by returning false for the Predicate.
+   * </p>
+   * <p>
+   * Unlike findList() this is suitable for processing a query that will return
+   * a very large resultSet. The reason is that not all the result beans need to be
+   * held in memory at the same time and instead processed one at a time.
+   * </p>
+   * <p>
+   * Internally this query using a PersistenceContext scoped to each bean (and the
+   * beans associated object graph).
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *     ebeanServer.find(Order.class)
+   *       .where().eq("status", Order.Status.NEW)
+   *       .order().asc("id")
+   *       .findEachWhile((Order order) -> {
+   *
+   *         // do something with the order bean
+   *         System.out.println(" -- processing order ... " + order);
+   *
+   *         boolean carryOnProcessing = ...
+   *         return carryOnProcessing;
+   *       });
+   *
+   * }</pre>
+   *
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  <T> void findEachWhile(Query<T> query, Predicate<T> consumer, Transaction transaction);
+
+  /**
+   * Return versions of a @History entity bean.
+   * <p>
+   * Generally this query is expected to be a find by id or unique predicates query.
+   * It will execute the query against the history returning the versions of the bean.
+   * </p>
+   */
+  @Nonnull
+  <T> List<Version<T>> findVersions(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute a query returning a list of beans.
+   * <p>
+   * Generally you are able to use {@link Query#findList()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   * List<Customer> customers =
+   *     ebeanServer.find(Customer.class)
+   *     .where().ilike("name", "rob%")
+   *     .findList();
+   *
+   * }</pre>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched beans.
+   * @see Query#findList()
+   */
+  @Nonnull
+  <T> List<T> findList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find row count query in a background thread.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a
+   * timeout).
+   * </p>
+   *
+   * @param query       the query to execute the row count on
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the row count query
+   * @see Query#findFutureCount()
+   */
+  @Nonnull
+  <T> FutureRowCount<T> findFutureCount(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find Id's query in a background thread.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a
+   * timeout).
+   * </p>
+   *
+   * @param query       the query to execute the fetch Id's on
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the list of Id's
+   * @see Query#findFutureIds()
+   */
+  @Nonnull
+  <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find list query in a background thread returning a FutureList object.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a timeout).
+   * <p>
+   * This query will execute in it's own PersistenceContext and using its own transaction.
+   * What that means is that it will not share any bean instances with other queries.
+   *
+   * @param query       the query to execute in the background
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the list result of the query
+   * @see Query#findFutureList()
+   */
+  @Nonnull
+  <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction);
+
+  /**
+   * Return a PagedList for this query using firstRow and maxRows.
+   * <p>
+   * The benefit of using this over findList() is that it provides functionality to get the
+   * total row count etc.
+   * </p>
+   * <p>
+   * If maxRows is not set on the query prior to calling findPagedList() then a
+   * PersistenceException is thrown.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *  PagedList<Order> pagedList = Ebean.find(Order.class)
+   *       .setFirstRow(50)
+   *       .setMaxRows(20)
+   *       .findPagedList();
+   *
+   *       // fetch the total row count in the background
+   *       pagedList.loadRowCount();
+   *
+   *       List<Order> orders = pagedList.getList();
+   *       int totalRowCount = pagedList.getTotalRowCount();
+   *
+   * }</pre>
+   *
+   * @return The PagedList
+   * @see Query#findPagedList()
+   */
+  @Nonnull
+  <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning a set of entity beans.
+   * <p>
+   * Generally you are able to use {@link Query#findSet()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   * Set<Customer> customers =
+   *     ebeanServer.find(Customer.class)
+   *     .where().ilike("name", "rob%")
+   *     .findSet();
+   *
+   * }</pre>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute
+   * @param transaction the transaction to use (can be null).
+   * @return the set of fetched beans.
+   * @see Query#findSet()
+   */
+  @Nonnull
+  <T> Set<T> findSet(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning the entity beans in a Map.
+   * <p>
+   * Generally you are able to use {@link Query#findMap()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the map of fetched beans.
+   * @see Query#findMap()
+   */
+  @Nonnull
+  <K, T> Map<K, T> findMap(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning a list of values for a single property.
+   * <p>
+   * <h3>Example 1:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    Ebean.find(Customer.class)
+   *      .select("name")
+   *      .orderBy().asc("name")
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   * <h3>Example 2:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    Ebean.find(Customer.class)
+   *      .setDistinct(true)
+   *      .select("name")
+   *      .where().eq("status", Customer.Status.NEW)
+   *      .orderBy().asc("name")
+   *      .setMaxRows(100)
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   *
+   * @return the list of values for the selected property
+   * @see Query#findSingleAttributeList()
+   */
+  @Nonnull
+  <A, T> List<A> findSingleAttributeList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning at most one entity bean or null (if no matching
+   * bean is found).
+   * <p>
+   * This will throw a NonUniqueResultException if the query finds more than one result.
+   * </p>
+   * <p>
+   * Generally you are able to use {@link Query#findOne()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched beans.
+   * @throws NonUniqueResultException if more than one result was found
+   * @see Query#findOne()
+   */
+  @Nullable
+  <T> T findOne(Query<T> query, Transaction transaction);
+
+  /**
+   * Similar to findOne() but returns an Optional (rather than nullable).
+   */
+  @Nonnull
+  <T> Optional<T> findOneOrEmpty(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute as a delete query deleting the 'root level' beans that match the predicates
+   * in the query.
+   * <p>
+   * Note that if the query includes joins then the generated delete statement may not be
+   * optimal depending on the database platform.
+   * </p>
+   *
+   * @param query       the query used for the delete
+   * @param transaction the transaction to use (can be null)
+   * @param <T>         the type of entity bean to fetch.
+   * @return the number of beans/rows that were deleted
+   */
+  <T> int delete(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the update query returning the number of rows updated.
+   * <p>
+   * The update query must be created using {@link EbeanServer#update(Class)}.
+   * </p>
+   *
+   * @param query       the update query to execute
+   * @param transaction the optional transaction to use for the update (can be null)
+   * @param <T>         the type of entity bean
+   * @return The number of rows updated
+   */
+  <T> int update(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the sql query returning a list of MapBean.
+   * <p>
+   * Generally you are able to use {@link SqlQuery#findList()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched MapBean.
+   * @see SqlQuery#findList()
+   */
+  @Nonnull
+  List<SqlRow> findList(SqlQuery query, Transaction transaction);
+
+  /**
+   * Execute the SqlQuery iterating a row at a time.
+   * <p>
+   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
+   * </p>
+   */
+  void findEach(SqlQuery query, Consumer<SqlRow> consumer, Transaction transaction);
+
+  /**
+   * Execute the SqlQuery iterating a row at a time with the ability to stop consuming part way through.
+   * <p>
+   * Returning false after processing a row stops the iteration through the query results.
+   * </p>
+   * <p>
+   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
+   * </p>
+   */
+  void findEachWhile(SqlQuery query, Predicate<SqlRow> consumer, Transaction transaction);
+
+  /**
+   * Execute the sql query returning a single MapBean or null.
+   * <p>
+   * This will throw a PersistenceException if the query found more than one
+   * result.
+   * </p>
+   * <p>
+   * Generally you are able to use {@link SqlQuery#findOne()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the fetched MapBean or null if none was found.
+   * @see SqlQuery#findOne()
+   */
+  @Nullable
+  SqlRow findOne(SqlQuery query, Transaction transaction);
+
+}

src/main/java/io/ebean/PrimaryServer.java

@@ -76,7 +76,6 @@ class PrimaryServer {
     if (defaultServerName == null) {
       defaultServerName = "db";
     }
-    System.setProperty("ebean_db", defaultServerName);
     return defaultServerName;
   }
 

src/main/java/io/ebean/Query.java

@@ -602,8 +602,6 @@ public interface Query<T> {
    * <p>
    * This query will execute against the EbeanServer that was used to create it.
    * </p>
-   *
-   * @see EbeanServer#findIds(Query, Transaction)
    */
   @Nonnull
   <A> List<A> findIds();
@@ -740,8 +738,6 @@ public interface Query<T> {
    *     .findList();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findList(Query, Transaction)
    */
   @Nonnull
   List<T> findList();
@@ -759,8 +755,6 @@ public interface Query<T> {
    *     .findSet();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findSet(Query, Transaction)
    */
   @Nonnull
   Set<T> findSet();
@@ -782,8 +776,6 @@ public interface Query<T> {
    *     .findMap();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findMap(Query, Transaction)
    */
   @Nonnull
   <K> Map<K, T> findMap();

src/main/java/io/ebean/Transaction.java

@@ -359,7 +359,10 @@ public interface Transaction extends AutoCloseable {
   void setBatchMode(boolean useBatch);
 
   /**
-   * The JDBC batch mode to use for this transaction.
+   * Deprecated - migrate to {@link #setBatchMode(boolean)}.
+   * <p>
+   * Set the JDBC batch mode to use for this transaction.
+   * </p>
    * <p>
    * If this is NONE then JDBC batch can still be used for each request - save(), insert(), update() or delete()
    * and this would be useful if the request cascades to detail beans.
@@ -368,15 +371,23 @@ public interface Transaction extends AutoCloseable {
    * @param persistBatchMode the batch mode to use for this transaction
    * @see io.ebean.config.ServerConfig#setPersistBatch(PersistBatch)
    */
+  @Deprecated
   void setBatch(PersistBatch persistBatchMode);
 
+  /**
+   * Deprecated - migrate to {@link #isBatchMode()}.
+   * Return the batch mode at the transaction level.
+   */
+  @Deprecated
+  PersistBatch getBatch();
+
   /**
    * Return the batch mode at the transaction level.
    */
-  PersistBatch getBatch();
+  boolean isBatchMode();
 
   /**
-   * Set the JDBC batch mode to use for a save() or delete() request.
+   * Set the JDBC batch mode to use for a save() or delete() when cascading to children.
    * <p>
    * This only takes effect when batch mode on the transaction has not already meant that
    * JDBC batch mode is being used.
@@ -385,17 +396,36 @@ public interface Transaction extends AutoCloseable {
    * This is useful when the single save() or delete() cascades. For example, inserting a 'master' cascades
    * and inserts a collection of 'detail' beans. The detail beans can be inserted using JDBC batch.
    * </p>
+   * <p>
+   * This is effectively already turned on for all platforms apart from older Sql Server.
+   * </p>
    *
-   * @param batchOnCascadeMode the batch mode to use per save(), insert(), update() or delete()
+   * @param batchMode the batch mode to use per save(), insert(), update() or delete()
    * @see io.ebean.config.ServerConfig#setPersistBatchOnCascade(PersistBatch)
    */
+  void setBatchOnCascade(boolean batchMode);
+
+  /**
+   * Set the batch mode when cascading.
+   * <p>
+   * Deprecated in favour of {@link #setBatchOnCascade(boolean)}
+   * </p>
+   */
+  @Deprecated
   void setBatchOnCascade(PersistBatch batchOnCascadeMode);
 
   /**
+   * Deprecated - migrate to {@link #isBatchMode()}.
    * Return the batch mode at the request level (for each save(), insert(), update() or delete()).
    */
+  @Deprecated
   PersistBatch getBatchOnCascade();
 
+  /**
+   * Return the batch mode at the request level.
+   */
+  boolean isBatchOnCascade();
+
   /**
    * Specify the number of statements before a batch is flushed automatically.
    */

src/main/java/io/ebean/cache/QueryCacheEntry.java

@@ -0,0 +1,54 @@
+package io.ebean.cache;
+
+import java.util.Set;
+
+/**
+ * For query cache entries we additionally hold the dependent tables and timestamp for the query result.
+ * <p>
+ * We use the dependent tables and timestamp to validate that tables the query joins to have not been
+ * modified since the query cache entry was cached. If any dependent tables have since been modified
+ * the query cache entry is treated as invalid.
+ * </p>
+ */
+public class QueryCacheEntry {
+
+  private final Object value;
+
+  private final Set<String> dependentTables;
+
+  private final long timestamp;
+
+  /**
+   * Create with dependent tables and timestamp.
+   *
+   * @param value           The query result being cached
+   * @param dependentTables The extra tables the query is dependent on (joins to)
+   * @param timestamp       The timestamp that the query uses to check for modifications
+   */
+  public QueryCacheEntry(Object value, Set<String> dependentTables, long timestamp) {
+    this.value = value;
+    this.dependentTables = dependentTables;
+    this.timestamp = timestamp;
+  }
+
+  /**
+   * Return the actual query result.
+   */
+  public Object getValue() {
+    return value;
+  }
+
+  /**
+   * Return the tables the query result is dependent on.
+   */
+  public Set<String> getDependentTables() {
+    return dependentTables;
+  }
+
+  /**
+   * Return the timestamp used to check for modifications on the dependent tables.
+   */
+  public long getTimestamp() {
+    return timestamp;
+  }
+}

src/main/java/io/ebean/cache/QueryCacheEntryValidate.java

@@ -0,0 +1,12 @@
+package io.ebean.cache;
+
+/**
+ * Used to validate that a query cache entry is still valid based on dependent tables.
+ */
+public interface QueryCacheEntryValidate {
+
+  /**
+   * Return true if the entry is still valid based on dependent tables.
+   */
+  boolean isValid(QueryCacheEntry queryCacheEntry);
+}

src/main/java/io/ebean/cache/ServerCacheConfig.java

@@ -0,0 +1,65 @@
+package io.ebean.cache;
+
+import io.ebean.config.CurrentTenantProvider;
+
+/**
+ * Configuration used to create ServerCache instances.
+ */
+public class ServerCacheConfig {
+
+  private final ServerCacheType type;
+  private final String cacheKey;
+  private final ServerCacheOptions cacheOptions;
+  private final CurrentTenantProvider tenantProvider;
+  private final QueryCacheEntryValidate queryCacheEntryValidate;
+
+  public ServerCacheConfig(ServerCacheType type, String cacheKey, ServerCacheOptions cacheOptions, CurrentTenantProvider tenantProvider, QueryCacheEntryValidate queryCacheEntryValidate) {
+    this.type = type;
+    this.cacheKey = cacheKey;
+    this.cacheOptions = cacheOptions;
+    this.tenantProvider = tenantProvider;
+    this.queryCacheEntryValidate = queryCacheEntryValidate;
+  }
+
+  /**
+   * Return the cache type.
+   */
+  public ServerCacheType getType() {
+    return type;
+  }
+
+  /**
+   * Return the name of the cache.
+   */
+  public String getCacheKey() {
+    return cacheKey;
+  }
+
+  /**
+   * Return the tuning options.
+   */
+  public ServerCacheOptions getCacheOptions() {
+    return cacheOptions;
+  }
+
+  /**
+   * Return the current tenant provider.
+   */
+  public CurrentTenantProvider getTenantProvider() {
+    return tenantProvider;
+  }
+
+  /**
+   * Return the service that provides validation for query cache entries.
+   */
+  public QueryCacheEntryValidate getQueryCacheEntryValidate() {
+    return queryCacheEntryValidate;
+  }
+
+  /**
+   * Return true if the cache is a query cache.
+   */
+  public boolean isQueryCache() {
+    return type == ServerCacheType.QUERY;
+  }
+}

src/main/java/io/ebean/cache/ServerCacheFactory.java

@@ -1,7 +1,5 @@
 package io.ebean.cache;
 
-import io.ebean.config.CurrentTenantProvider;
-
 /**
  * Defines method for constructing caches for beans and queries.
  */
@@ -10,6 +8,15 @@ public interface ServerCacheFactory {
   /**
    * Create the cache for the given type with options.
    */
-  ServerCache createCache(ServerCacheType type, String cacheKey, CurrentTenantProvider tenantProvider, ServerCacheOptions cacheOptions);
+  ServerCache createCache(ServerCacheConfig config);
 
+  /**
+   * Return a ServerCacheNotify that we will send ServerCacheNotification events to.
+   * <p>
+   * This is used if a ServerCacheNotifyPlugin is not supplied.
+   * </p>
+   *
+   * @param listener The listener that should be used to process the notification events.
+   */
+  ServerCacheNotify createCacheNotify(ServerCacheNotify listener);
 }

src/main/java/io/ebean/cache/ServerCacheNotification.java

@@ -0,0 +1,29 @@
+package io.ebean.cache;
+
+import java.util.Set;
+
+/**
+ * Notification event that dependent tables have been modified.
+ * <p>
+ * This is sent to other interested servers (in the cluster).
+ * </p>
+ */
+public class ServerCacheNotification {
+
+  private final long modifyTimestamp;
+
+  private final Set<String> dependentTables;
+
+  public ServerCacheNotification(long modifyTimestamp, Set<String> dependentTables) {
+    this.modifyTimestamp = modifyTimestamp;
+    this.dependentTables = dependentTables;
+  }
+
+  public long getModifyTimestamp() {
+    return modifyTimestamp;
+  }
+
+  public Set<String> getDependentTables() {
+    return dependentTables;
+  }
+}

src/main/java/io/ebean/cache/ServerCacheNotify.java

@@ -0,0 +1,12 @@
+package io.ebean.cache;
+
+/**
+ * Interface for both listening to notification changes and sending them to other members of the cluster.
+ */
+public interface ServerCacheNotify {
+
+  /**
+   * Notify other server cache members of the table modifications or process the notifications.
+   */
+  void notify(ServerCacheNotification notification);
+}

src/main/java/io/ebean/cache/ServerCacheNotifyPlugin.java

@@ -0,0 +1,17 @@
+package io.ebean.cache;
+
+import io.ebean.config.ServerConfig;
+
+/**
+ * Plugin that provides a ServerCacheNotify implementation.
+ * <p>
+ * Is supplied this will be used to send the ServerCacheNotification event to other cluster members.
+ * </p>
+ */
+public interface ServerCacheNotifyPlugin {
+
+  /**
+   * Create a ServerCacheNotify implementation given the server configuration.
+   */
+  ServerCacheNotify create(ServerConfig serverConfig);
+}

src/main/java/io/ebean/config/DbMigrationConfig.java

@@ -102,6 +102,11 @@ public class DbMigrationConfig {
    */
   protected Map<String, String> runPlaceholderMap;
 
+  /**
+   * DB schema used for the migration (and testing).
+   */
+  protected String dbSchema;
+
   /**
    * DB user used to run the DB migration.
    */
@@ -373,6 +378,33 @@ public class DbMigrationConfig {
     this.dbPassword = dbPassword;
   }
 
+  /**
+   * Return the DB schema to use (for migration, testing etc).
+   */
+  public String getDbSchema() {
+    String schema = readEnvironment("ddl.migration.schema");
+    if (schema != null) {
+      return schema;
+    }
+    return dbSchema;
+  }
+
+  /**
+   * Set the Db schema to use.
+   */
+  public void setDbSchema(String dbSchema) {
+    this.dbSchema = dbSchema;
+  }
+
+  /**
+   * Set the Db schema if it hasn't already been defined.
+   */
+  public void setDefaultDbSchema(String dbSchema) {
+    if (this.dbSchema == null) {
+      this.dbSchema = dbSchema;
+    }
+  }
+
   /**
    * Return migration versions that should be added to history without running.
    */
@@ -475,6 +507,7 @@ public class DbMigrationConfig {
     runMigration = properties.getBoolean("migration.run", runMigration);
     metaTable = properties.get("migration.metaTable", metaTable);
     runPlaceholders = properties.get("migration.placeholders", runPlaceholders);
+    dbSchema = properties.get("migration.dbSchema", dbSchema);
 
     //Do not set user and pass from "datasource.db.username"
     //There is a null test in MigrationRunner::getConnection to handle this
@@ -557,6 +590,7 @@ public class DbMigrationConfig {
     runnerConfig.setRunPlaceholders(runPlaceholders);
     runnerConfig.setDbUsername(getDbUsername());
     runnerConfig.setDbPassword(getDbPassword());
+    runnerConfig.setDbSchema(getDbSchema());
     runnerConfig.setClassLoader(classLoader);
     if (patchInsertOn != null) {
       runnerConfig.setPatchInsertOn(patchInsertOn);

src/main/java/io/ebean/config/ServerConfig.java

@@ -33,6 +33,7 @@ import io.ebean.util.StringHelper;
 import org.avaje.datasource.DataSourceConfig;
 
 import javax.sql.DataSource;
+import java.time.Clock;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -57,22 +58,24 @@ import java.util.ServiceLoader;
  * <pre>{@code
  *
  * ServerConfig c = new ServerConfig();
- * c.setName("db");
  *
  * // read the ebean.properties and load
  * // those settings into this serverConfig object
  * c.loadFromProperties();
  *
- * // add any classes found in the app.data package
- * c.addPackage("com.myapp.domain");
- *
- * // register as the 'Default' server
- * c.setDefaultServer(true);
+ * // explicitly register the entity beans to avoid classpath scanning
+ * c.addClass(Customer.class);
+ * c.addClass(User.class);
  *
  * EbeanServer server = EbeanServerFactory.create(c);
  *
  * }</pre>
  *
+ * <p>
+ * Note that ServerConfigProvider provides a standard Java ServiceLoader mechanism that can
+ * be used to apply configuration to the ServerConfig.
+ * </p>
+ *
  * @author emcgreal
  * @author rbygrave
  * @see EbeanServerFactory
@@ -293,6 +296,11 @@ public class ServerConfig {
    */
   private DataSourceConfig readOnlyDataSourceConfig = new DataSourceConfig();
 
+  /**
+   * Optional - the database schema that should be used to own the tables etc.
+   */
+  private String dbSchema;
+
   /**
    * The db migration config (migration resource path etc).
    */
@@ -360,6 +368,11 @@ public class ServerConfig {
    */
   private String uuidStateFile = "ebean-uuid.state";
 
+  /**
+   * The clock used for setting the timestamps (e.g. @UpdatedTimestamp) on objects.
+   */
+  private Clock clock = Clock.systemUTC();
+
   private List<IdGenerator> idGenerators = new ArrayList<>();
   private List<BeanFindController> findControllers = new ArrayList<>();
   private List<BeanPersistController> persistControllers = new ArrayList<>();
@@ -505,6 +518,20 @@ public class ServerConfig {
 
   }
 
+  /**
+   * Get the clock used for setting the timestamps (e.g. @UpdatedTimestamp) on objects.
+   */
+  public Clock getClock() {
+    return clock;
+  }
+
+  /**
+   * Set the clock used for setting the timestamps (e.g. @UpdatedTimestamp) on objects.
+   */
+  public void setClock(final Clock clock) {
+    this.clock = clock;
+  }
+
   /**
    * Return the slow query time in millis.
    */
@@ -1098,6 +1125,25 @@ public class ServerConfig {
     this.profilingConfig = profilingConfig;
   }
 
+  /**
+   * Return the DB schema to use.
+   */
+  public String getDbSchema() {
+    return dbSchema;
+  }
+
+  /**
+   * Set the DB schema to use. This specifies to use this schema for:
+   * <ul>
+   * <li>Running Database migrations - Create and use the DB schema</li>
+   * <li>Testing DDL - Create-all.sql DDL execution creates and uses schema</li>
+   * <li>Testing Docker - Set default schema on connection URL</li>
+   * </ul>
+   */
+  public void setDbSchema(String dbSchema) {
+    this.dbSchema = dbSchema;
+  }
+
   /**
    * Return the DB migration configuration.
    */
@@ -2742,6 +2788,10 @@ public class ServerConfig {
    */
   protected void loadSettings(PropertiesWrapper p) {
 
+    dbSchema = p.get("dbSchema", dbSchema);
+    if (dbSchema != null) {
+      migrationConfig.setDefaultDbSchema(dbSchema);
+    }
     profilingConfig.loadSettings(p, name);
     migrationConfig.loadSettings(p, name);
     platformConfig.loadSettings(p);

src/main/java/io/ebean/config/ServerConfigProvider.java

@@ -0,0 +1,39 @@
+package io.ebean.config;
+
+/**
+ * Provides a ServiceLoader based mechanism to configure a ServerConfig.
+ * <p>
+ * Provide an implementation and register it via the standard Java ServiceLoader mechanism
+ * via a file at <code>META-INF/services/io.ebean.config.ServerConfigProvider</code>.
+ * </p>
+ * <p>
+ * If you are using a DI container like Spring or Guice you are unlikely to use this but instead use a
+ * spring specific configuration.  When we are not using a DI container we may use this mechanism to
+ * explicitly register the entity beans and avoid classpath scanning.
+ * </p>
+ * <pre>{@code
+ *
+ * public class EbeanConfigProvider implements ServerConfigProvider {
+ *
+ *   @Override
+ *   public void apply(ServerConfig config) {
+ *
+ *     // register the entity bean classes explicitly
+ *     config.addClass(Customer.class);
+ *     config.addClass(User.class);
+ *     ...
+ *   }
+ * }
+ *
+ * }</pre>
+ */
+public interface ServerConfigProvider {
+
+  /**
+   * Apply the configuration to the ServerConfig.
+   * <p>
+   * Typically we explicitly register entity bean classes and thus avoid classpath scanning.
+   * </p>
+   */
+  void apply(ServerConfig config);
+}

src/main/java/io/ebean/config/dbplatform/DatabasePlatform.java

@@ -16,6 +16,7 @@ import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.Types;
 
 /**
@@ -658,6 +659,39 @@ public class DatabasePlatform {
     return persistBatchOnCascade;
   }
 
+  /**
+   * Create the DB schema if it does not exist.
+   */
+  public void createSchemaIfNotExists(String dbSchema, Connection connection) throws SQLException {
+    if (!schemaExists(dbSchema, connection)) {
+      Statement query = connection.createStatement();
+      try {
+        logger.info("create schema:{}", dbSchema);
+        query.executeUpdate("create schema " + dbSchema);
+      } finally {
+        JdbcClose.close(query);
+      }
+    }
+  }
+
+  /**
+   * Return true if the schema exists.
+   */
+  public boolean schemaExists(String dbSchema, Connection connection) throws SQLException {
+    ResultSet schemas = connection.getMetaData().getSchemas();
+    try {
+      while (schemas.next()) {
+        String schema = schemas.getString(1);
+        if (schema.equalsIgnoreCase(dbSchema)) {
+          return true;
+        }
+      }
+    } finally {
+      JdbcClose.close(schemas);
+    }
+    return false;
+  }
+
   /**
    * Return true if the table exists.
    */

src/main/java/io/ebeaninternal/api/BinaryReadContext.java

@@ -0,0 +1,47 @@
+package io.ebeaninternal.api;
+
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+
+/**
+ * Context used to read binary format messages.
+ */
+public class BinaryReadContext {
+
+  private final DataInputStream in;
+
+  /**
+   * Create with protocol 0 and byte data.
+   */
+  public BinaryReadContext(byte[] byteData) {
+    this(new DataInputStream(new ByteArrayInputStream(byteData)));
+  }
+
+  /**
+   * Create with protocol version and DataInputStream data.
+   */
+  public BinaryReadContext(DataInputStream in) {
+    this.in = in;
+  }
+
+  public DataInputStream in() {
+    return in;
+  }
+
+  public boolean readBoolean() throws IOException {
+    return in.readBoolean();
+  }
+
+  public int readInt() throws IOException {
+    return in.readInt();
+  }
+
+  public String readUTF() throws IOException {
+    return in.readUTF();
+  }
+
+  public long readLong() throws IOException {
+    return in.readLong();
+  }
+}

src/main/java/io/ebeaninternal/api/BinaryWritable.java

@@ -0,0 +1,23 @@
+package io.ebeaninternal.api;
+
+import java.io.IOException;
+
+/**
+ * Messages that can be sent in binary form.
+ * <p>
+ * Mainly RemoteTransactionEvent which is sent to cluster members.
+ * </p>
+ */
+public interface BinaryWritable {
+
+  int TYPE_BEANIUD = 1;
+  int TYPE_TABLEIUD = 2;
+  int TYPE_CACHE = 3;
+  int TYPE_TABLEMOD = 4;
+
+  /**
+   * Write message in binary format.
+   */
+  void writeBinary(BinaryWriteContext out) throws IOException;
+
+}

src/main/java/io/ebeaninternal/api/BinaryWriteContext.java

@@ -0,0 +1,49 @@
+package io.ebeaninternal.api;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * Context used to write binary message (like RemoteTransactionEvent).
+ */
+public class BinaryWriteContext {
+
+  private final DataOutputStream out;
+
+  private long counter;
+
+  public BinaryWriteContext(DataOutputStream out) {
+    this.out = out;
+  }
+
+  /**
+   * Return the number of message parts that have been written.
+   */
+  public long counter() {
+    return counter;
+  }
+
+  /**
+   * Return the output stream to write to.
+   */
+  public DataOutputStream os() {
+    return out;
+  }
+
+  /**
+   * Start a message part with a given type code.
+   */
+  public DataOutputStream start(int type) throws IOException {
+    counter++;
+    out.writeBoolean(true);
+    out.writeInt(type);
+    return out;
+  }
+
+  /**
+   * End of message parts.
+   */
+  public void end() throws IOException {
+    out.writeBoolean(false);
+  }
+}

src/main/java/io/ebeaninternal/api/BindParams.java

@@ -1,5 +1,6 @@
 package io.ebeaninternal.api;
 
+import io.ebeaninternal.server.persist.MultiValueWrapper;
 import io.ebeaninternal.server.querydefn.NaturalKeyBindParam;
 
 import java.io.Serializable;
@@ -154,6 +155,10 @@ public class BindParams implements Serializable {
   public void setParameter(int position, Object value) {
 
     Param p = getParam(position);
+    if (value instanceof Collection) {
+      // use of postgres ANY with positioned parameter
+      value = new MultiValueWrapper((Collection)value);
+    }
     p.setInValue(value);
   }
 

src/main/java/io/ebeaninternal/api/ScopeTrans.java

@@ -53,6 +53,10 @@ public class ScopeTrans {
    */
   private boolean rolledBack;
 
+  /**
+   * Flag set when nested commit has occurred.
+   */
+  private boolean nestedCommit;
 
   public ScopeTrans(boolean rollbackOnChecked, boolean created, SpiTransaction transaction, TxScope txScope) {
 
@@ -113,7 +117,6 @@ public class ScopeTrans {
     complete();
   }
 
-
   /**
    * Complete the transaction programmatically. Try to commit.
    */
@@ -124,7 +127,7 @@ public class ScopeTrans {
   }
 
   public void end() {
-    if (created) {
+    if (created || !nestedCommit) {
       transaction.end();
     }
   }
@@ -133,6 +136,7 @@ public class ScopeTrans {
     if (created) {
       transaction.commit();
     } else {
+      nestedCommit = true;
       transaction.setBatchFlushOnQuery(restoreBatchFlushOnQuery);
       if (restoreBatch != null) {
         transaction.setBatch(restoreBatch);

src/main/java/io/ebeaninternal/api/SpiContainerBootup.java

@@ -1,18 +0,0 @@
-package io.ebeaninternal.api;
-
-/**
- * Plugin API available to invoke something prior to container bootup.
- * <p>
- * The initial intent is to provide a hook for 'docker-run' such that we can automatically ensure
- * we have a test DB docker container running and setup ready to go.
- * </p>
- */
-public interface SpiContainerBootup {
-
-  /**
-   * Run something at bootup prior to the container starting.
-   *
-   * For example, start DB docker container(s).
-   */
-  void bootup();
-}

src/main/java/io/ebeaninternal/api/SpiEbeanServer.java

@@ -2,6 +2,7 @@ package io.ebeaninternal.api;
 
 import io.ebean.DtoQuery;
 import io.ebean.EbeanServer;
+import io.ebean.ExtendedServer;
 import io.ebean.PersistenceContextScope;
 import io.ebean.Query;
 import io.ebean.RowConsumer;
@@ -31,7 +32,7 @@ import java.util.function.Predicate;
 /**
  * Service Provider extension to EbeanServer.
  */
-public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionLoader {
+public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanLoader, BeanCollectionLoader {
 
   /**
    * Return the log manager.

src/main/java/io/ebeaninternal/api/SpiTransaction.java

@@ -101,6 +101,11 @@ public interface SpiTransaction extends Transaction {
    */
   String getId();
 
+  /**
+   * Return the start timestamp for the transaction (JVM side).
+   */
+  long getStartMillis();
+
   /**
    * Return true if this transaction has updateAllLoadedProperties set.
    * If null is returned the server default is used (set on ServerConfig).
@@ -179,7 +184,7 @@ public interface SpiTransaction extends Transaction {
    * Return true if this request should be batched. Conversely returns false
    * if this request should be executed immediately.
    */
-  boolean isBatchThisRequest(PersistRequest.Type type);
+  boolean isBatchThisRequest();
 
   /**
    * Return the BatchControl used to batch up persist requests.

src/main/java/io/ebeaninternal/api/SpiTransactionProxy.java

@@ -30,6 +30,11 @@ public abstract class SpiTransactionProxy implements SpiTransaction {
     return transaction.translate(message, cause);
   }
 
+  @Override
+  public long getStartMillis() {
+    return transaction.getStartMillis();
+  }
+
   @Override
   public void setLabel(String label) {
     transaction.setLabel(label);
@@ -245,6 +250,11 @@ public abstract class SpiTransactionProxy implements SpiTransaction {
     transaction.setBatchMode(useBatch);
   }
 
+  @Override
+  public boolean isBatchMode() {
+    return transaction.isBatchMode();
+  }
+
   @Override
   public void setBatch(PersistBatch persistBatchMode) {
     transaction.setBatch(persistBatchMode);
@@ -255,11 +265,21 @@ public abstract class SpiTransactionProxy implements SpiTransaction {
     return transaction.getBatch();
   }
 
+  @Override
+  public void setBatchOnCascade(boolean batchMode) {
+    transaction.setBatchOnCascade(batchMode);
+  }
+
   @Override
   public void setBatchOnCascade(PersistBatch batchOnCascadeMode) {
     transaction.setBatchOnCascade(batchOnCascadeMode);
   }
 
+  @Override
+  public boolean isBatchOnCascade() {
+    return transaction.isBatchOnCascade();
+  }
+
   @Override
   public PersistBatch getBatchOnCascade() {
     return transaction.getBatchOnCascade();
@@ -356,8 +376,8 @@ public abstract class SpiTransactionProxy implements SpiTransaction {
   }
 
   @Override
-  public boolean isBatchThisRequest(PersistRequest.Type type) {
-    return transaction.isBatchThisRequest(type);
+  public boolean isBatchThisRequest() {
+    return transaction.isBatchThisRequest();
   }
 
   @Override

src/main/java/io/ebeaninternal/api/TransactionEvent.java

@@ -3,7 +3,9 @@ package io.ebeaninternal.api;
 import io.ebeaninternal.server.cache.CacheChangeSet;
 import io.ebeaninternal.server.core.PersistRequestBean;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanDescriptorManager;
 import io.ebeaninternal.server.transaction.DeleteByIdMap;
+import io.ebeaninternal.server.transaction.TransactionManager;
 import io.ebeanservice.docstore.api.DocStoreUpdates;
 
 import java.io.Serializable;
@@ -108,8 +110,20 @@ public class TransactionEvent implements Serializable {
   /**
    * Build and return the cache changeSet.
    */
-  public CacheChangeSet buildCacheChanges(boolean viewInvalidation) {
-    CacheChangeSet changeSet = new CacheChangeSet(viewInvalidation);
+  public CacheChangeSet buildCacheChanges(TransactionManager manager) {
+
+    if (eventBeans == null && deleteByIdMap == null && eventTables == null) {
+      return null;
+    }
+
+    CacheChangeSet changeSet = new CacheChangeSet(manager.clockNowMillis());
+    if (eventTables != null && !eventTables.isEmpty()) {
+      // notify cache with table based changes
+      BeanDescriptorManager dm = manager.getBeanDescriptorManager();
+      for (TransactionEventTable.TableIUD tableIUD : eventTables.values()) {
+        dm.cacheNotify(tableIUD, changeSet);
+      }
+    }
     if (eventBeans != null) {
       eventBeans.notifyCache(changeSet);
     }

src/main/java/io/ebeaninternal/api/TransactionEventTable.java

@@ -1,10 +1,7 @@
 package io.ebeaninternal.api;
 
 import io.ebean.event.BulkTableEvent;
-import io.ebeaninternal.server.cluster.BinaryMessage;
-import io.ebeaninternal.server.cluster.BinaryMessageList;
 
-import java.io.DataInput;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.io.Serializable;
@@ -12,7 +9,7 @@ import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 
-public final class TransactionEventTable implements Serializable {
+public final class TransactionEventTable implements Serializable, BinaryWritable {
 
   private static final long serialVersionUID = 2236555729767483264L;
 
@@ -23,20 +20,13 @@ public final class TransactionEventTable implements Serializable {
     return "TransactionEventTable " + map.values();
   }
 
-  public void writeBinaryMessage(BinaryMessageList msgList) throws IOException {
-
+  @Override
+  public void writeBinary(BinaryWriteContext out) throws IOException {
     for (TableIUD tableIud : map.values()) {
-      tableIud.writeBinaryMessage(msgList);
+      tableIud.writeBinary(out);
     }
   }
 
-  public void readBinaryMessage(DataInput dataInput) throws IOException {
-
-    TableIUD tableIud = TableIUD.readBinaryMessage(dataInput);
-    map.put(tableIud.getTableName(), tableIud);
-  }
-
-
   public void add(TransactionEventTable table) {
 
     for (TableIUD iud : table.values()) {
@@ -47,7 +37,6 @@ public final class TransactionEventTable implements Serializable {
   public void add(String table, boolean insert, boolean update, boolean delete) {
 
     table = table.toUpperCase();
-
     add(new TableIUD(table, insert, update, delete));
   }
 
@@ -67,7 +56,7 @@ public final class TransactionEventTable implements Serializable {
     return map.values();
   }
 
-  public static class TableIUD implements Serializable, BulkTableEvent {
+  public static class TableIUD implements Serializable, BulkTableEvent, BinaryWritable {
 
     private static final long serialVersionUID = -1958317571064162089L;
 
@@ -83,7 +72,7 @@ public final class TransactionEventTable implements Serializable {
       this.delete = delete;
     }
 
-    public static TableIUD readBinaryMessage(DataInput dataInput) throws IOException {
+    public static TableIUD readBinaryMessage(BinaryReadContext dataInput) throws IOException {
 
       String table = dataInput.readUTF();
       boolean insert = dataInput.readBoolean();
@@ -93,17 +82,13 @@ public final class TransactionEventTable implements Serializable {
       return new TableIUD(table, insert, update, delete);
     }
 
-    public void writeBinaryMessage(BinaryMessageList msgList) throws IOException {
-
-      BinaryMessage msg = new BinaryMessage(table.length() + 10);
-      DataOutputStream os = msg.getOs();
-      os.writeInt(BinaryMessage.TYPE_TABLEIUD);
+    @Override
+    public void writeBinary(BinaryWriteContext out) throws IOException {
+      DataOutputStream os = out.start(TYPE_TABLEIUD);
       os.writeUTF(table);
       os.writeBoolean(insert);
       os.writeBoolean(update);
       os.writeBoolean(delete);
-
-      msgList.add(msg);
     }
 
     @Override

src/main/java/io/ebeaninternal/api/TxnProfileEventCodes.java

@@ -13,7 +13,7 @@ public interface TxnProfileEventCodes {
   String EVT_INSERT = "i";
   String EVT_UPDATE = "u";
   String EVT_DELETE = "d";
-  String EVT_SOFT_DELETE = "ds";
+  String EVT_DELETE_SOFT = "ds";
   String EVT_DELETE_PERMANENT = "dp";
   String EVT_ORMUPDATE = "uo";
   String FIND_UPDATE = "uq";

src/main/java/io/ebeaninternal/dbmigration/DdlGenerator.java

@@ -1,8 +1,8 @@
 package io.ebeaninternal.dbmigration;
 
-import io.ebean.Transaction;
 import io.ebean.config.ServerConfig;
 import io.ebean.migration.ddl.DdlRunner;
+import io.ebean.util.JdbcClose;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.dbmigration.model.CurrentModel;
 import io.ebeaninternal.extraddl.model.ExtraDdlXmlReader;
@@ -38,6 +38,7 @@ public class DdlGenerator {
   private final boolean createOnly;
   private final boolean jaxbPresent;
   private final boolean ddlCommitOnCreateIndex;
+  private final String dbSchema;
 
   private CurrentModel currentModel;
   private String dropAllContent;
@@ -48,6 +49,7 @@ public class DdlGenerator {
     this.jaxbPresent = serverConfig.getClassLoadConfig().isJavaxJAXBPresent();
     this.generateDdl = serverConfig.isDdlGenerate();
     this.createOnly = serverConfig.isDdlCreateOnly();
+    this.dbSchema = serverConfig.getDbSchema();
     if (!serverConfig.getTenantMode().isDdlEnabled() && serverConfig.isDdlRun()) {
       log.warn("DDL can't be run on startup with TenantMode " + serverConfig.getTenantMode());
       this.runDdl = false;
@@ -85,30 +87,54 @@ public class DdlGenerator {
    * Run the DDL drop and DDL create scripts if properties have been set.
    */
   protected void runDdl() {
-
     if (runDdl) {
+      Connection connection = null;
       try {
-        runInitSql();
-        runDropSql();
-        runCreateSql();
-        runSeedSql();
-
-      } catch (IOException e) {
-        String msg = "Error reading drop/create script from file system";
-        throw new RuntimeException(msg, e);
+        connection = obtainConnection();
+        runDdlWith(connection);
+      } finally {
+        JdbcClose.rollback(connection);
+        JdbcClose.close(connection);
       }
     }
   }
 
+  private void runDdlWith(Connection connection) {
+    try {
+      if (dbSchema != null) {
+        createSchemaIfRequired(connection);
+      }
+      runInitSql(connection);
+      runDropSql(connection);
+      runCreateSql(connection);
+      runSeedSql(connection);
+    } catch (IOException e) {
+      throw new RuntimeException("Error reading drop/create script from file system", e);
+    }
+  }
+
+  private Connection obtainConnection() {
+    try {
+      return server.getPluginApi().getDataSource().getConnection();
+    } catch (SQLException e) {
+      throw new PersistenceException("Failed to obtain connection to run DDL", e);
+    }
+  }
+
+  private void createSchemaIfRequired(Connection connection) {
+    try {
+      server.getDatabasePlatform().createSchemaIfNotExists(dbSchema, connection);
+    } catch (SQLException e) {
+      throw new PersistenceException("Failed to create DB Schema", e);
+    }
+  }
+
   /**
    * Execute all the DDL statements in the script.
    */
-  public int runScript(boolean expectErrors, String content, String scriptName) {
+  public int runScript(Connection connection, boolean expectErrors, String content, String scriptName) {
 
     DdlRunner runner = new DdlRunner(expectErrors, scriptName);
-
-    Transaction transaction = server.createTransaction();
-    Connection connection = transaction.getConnection();
     try {
       if (expectErrors) {
         connection.setAutoCommit(true);
@@ -119,64 +145,63 @@ public class DdlGenerator {
       if (expectErrors) {
         connection.setAutoCommit(false);
       }
-      transaction.commit();
+      connection.commit();
       return count;
 
     } catch (SQLException e) {
       throw new PersistenceException("Failed to run script", e);
-
     } finally {
-      transaction.end();
+      JdbcClose.rollback(connection);
     }
   }
 
-  protected void runDropSql() throws IOException {
+  protected void runDropSql(Connection connection) throws IOException {
     if (!createOnly) {
       String ignoreExtraDdl = System.getProperty("ebean.ignoreExtraDdl");
       if (!"true".equalsIgnoreCase(ignoreExtraDdl) && jaxbPresent) {
         String extraApply = ExtraDdlXmlReader.buildExtra(server.getDatabasePlatform().getName(), true);
         if (extraApply != null) {
-          runScript(false, extraApply, "extra-dll");
+          runScript(connection, false, extraApply, "extra-dll");
         }
       }
 
       if (dropAllContent == null) {
         dropAllContent = readFile(getDropFileName());
       }
-      runScript(true, dropAllContent, getDropFileName());
+      runScript(connection, true, dropAllContent, getDropFileName());
     }
   }
 
-  protected void runCreateSql() throws IOException {
+  protected void runCreateSql(Connection connection) throws IOException {
     if (createAllContent == null) {
       createAllContent = readFile(getCreateFileName());
     }
-    runScript(false, createAllContent, getCreateFileName());
+    runScript(connection, false, createAllContent, getCreateFileName());
 
     String ignoreExtraDdl = System.getProperty("ebean.ignoreExtraDdl");
     if (!"true".equalsIgnoreCase(ignoreExtraDdl) && jaxbPresent) {
       String extraApply = ExtraDdlXmlReader.buildExtra(server.getDatabasePlatform().getName(), false);
       if (extraApply != null) {
-        runScript(false, extraApply, "extra-dll");
+        runScript(connection, false, extraApply, "extra-dll");
       }
     }
   }
 
-  protected void runInitSql() throws IOException {
-    runResourceScript(server.getServerConfig().getDdlInitSql());
+  protected void runInitSql(Connection connection) throws IOException {
+    runResourceScript(connection, server.getServerConfig().getDdlInitSql());
   }
 
-  protected void runSeedSql() throws IOException {
-    runResourceScript(server.getServerConfig().getDdlSeedSql());
+  protected void runSeedSql(Connection connection) throws IOException {
+    runResourceScript(connection, server.getServerConfig().getDdlSeedSql());
   }
 
-  protected void runResourceScript(String sqlScript) throws IOException {
+  protected void runResourceScript(Connection connection, String sqlScript) throws IOException {
 
     if (sqlScript != null) {
       try (InputStream is = getClassLoader().getResourceAsStream(sqlScript)) {
         if (is != null) {
           String content = readContent(new InputStreamReader(is));
-          runScript(false, content, sqlScript);
+          runScript(connection,  false, content, sqlScript);
         }
       }
     }

src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdl.java

@@ -840,12 +840,15 @@ public class BaseTableDdl implements TableDdl {
     if (hasValue(alterColumn.getComment())) {
       alterColumnComment(writer, alterColumn);
     }
+    if (hasValue(alterColumn.getDropCheckConstraint())) {
+      dropCheckConstraint(writer, alterColumn, alterColumn.getDropCheckConstraint());
+    }
 
     boolean alterCheckConstraint = hasValue(alterColumn.getCheckConstraint());
 
     if (alterCheckConstraint) {
       // drop constraint before altering type etc
-      dropCheckConstraint(writer, alterColumn);
+      dropCheckConstraint(writer, alterColumn, alterColumn.getCheckConstraintName());
     }
     boolean alterBaseAttributes = false;
     if (hasValue(alterColumn.getType())) {
@@ -922,9 +925,9 @@ public class BaseTableDdl implements TableDdl {
     }
   }
 
-  protected void dropCheckConstraint(DdlWrite writer, AlterColumn alter) throws IOException {
+  protected void dropCheckConstraint(DdlWrite writer, AlterColumn alter, String constraintName) throws IOException {
 
-    String ddl = platformDdl.alterTableDropConstraint(alter.getTableName(), alter.getCheckConstraintName());
+    String ddl = platformDdl.alterTableDropConstraint(alter.getTableName(), constraintName);
     if (hasValue(ddl)) {
       writer.apply().append(ddl).endOfStatement();
     }

src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/MySqlDdl.java

@@ -40,7 +40,8 @@ public class MySqlDdl extends PlatformDdl {
 
   @Override
   public String alterTableDropConstraint(String tableName, String constraintName) {
-    // drop constraint not supported
+    // drop constraint not supported in MySQL 5.7 and 8.0 but starting with MariaDB 10.2.1 CHECK is evaluated
+    // TODO: Implement for MariaDB >= 10.2.1
     return null;
   }
 

src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PlatformDdl.java

@@ -79,8 +79,6 @@ public class PlatformDdl {
 
   protected String alterColumn = "alter column";
 
-  protected String dropConstraint = "drop constraint";
-
   protected String dropUniqueConstraint = "drop constraint";
 
   protected String addConstraint = "add constraint";
@@ -420,7 +418,7 @@ public class PlatformDdl {
    * Drop a unique constraint from the table.
    */
   public String alterTableDropConstraint(String tableName, String constraintName) {
-    return "alter table " + tableName + " " + dropConstraint + " " + maxConstraintName(constraintName);
+    return "alter table " + tableName + " " + dropConstraintIfExists + " " + maxConstraintName(constraintName);
   }
 
   /**

src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/PostgresHistoryDdl.java

@@ -79,13 +79,21 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
 
   protected void createOrReplaceFunction(DdlBuffer apply, String procedureName, String historyTable, List<String> includedColumns) throws IOException {
     apply
-      .append("create or replace function ").append(procedureName).append("() returns trigger as $$").newLine()
-      .append("begin").newLine();
+      .append("create or replace function ").append(procedureName).append("() returns trigger as $$").newLine();
+
+    apply.append("declare").newLine()
+      .append("  lowerTs timestamptz;").newLine()
+      .append("  upperTs timestamptz;").newLine();
+
+    apply.append("begin").newLine()
+      .append("  lowerTs = lower(OLD.sys_period);").newLine()
+      .append("  upperTs = greatest(lowerTs + '1 microsecond',current_timestamp);").newLine();
+
     apply
       .append("  if (TG_OP = 'UPDATE') then").newLine();
     appendInsertIntoHistory(apply, historyTable, includedColumns);
     apply
-      .append("    NEW.").append(sysPeriod).append(" = tstzrange(").append(currentTimestamp).append(",null);").newLine()
+      .append("    NEW.").append(sysPeriod).append(" = tstzrange(upperTs,null);").newLine()
       .append("    return new;").newLine();
     apply
       .append("  elsif (TG_OP = 'DELETE') then").newLine();
@@ -124,7 +132,7 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
 
     buffer.append("    insert into ").append(historyTable).append(" (").append(sysPeriod).append(",");
     appendColumnNames(buffer, columns, "");
-    buffer.append(") values (tstzrange(lower(OLD.").append(sysPeriod).append("), ").append(currentTimestamp).append("), ");
+    buffer.append(") values (tstzrange(lowerTs,upperTs), ");
     appendColumnNames(buffer, columns, "OLD.");
     buffer.append(");").newLine();
   }

src/main/java/io/ebeaninternal/dbmigration/migration/AlterForeignKey.java

@@ -25,9 +25,9 @@ public class AlterForeignKey {
   protected String name;
   @XmlAttribute(name = "columnNames", required = true)
   protected String columnNames;
-  @XmlAttribute(name = "refColumnNames", required = true)
+  @XmlAttribute(name = "refColumnNames")
   protected String refColumnNames;
-  @XmlAttribute(name = "refTableName", required = true)
+  @XmlAttribute(name = "refTableName")
   protected String refTableName;
   @XmlAttribute(name = "indexName")
   protected String indexName;

src/main/java/io/ebeaninternal/dbmigration/model/ModelContainer.java

@@ -17,6 +17,7 @@ import io.ebeaninternal.dbmigration.migration.DropHistoryTable;
 import io.ebeaninternal.dbmigration.migration.DropIndex;
 import io.ebeaninternal.dbmigration.migration.DropTable;
 import io.ebeaninternal.dbmigration.migration.Migration;
+import io.ebeaninternal.dbmigration.migration.Sql;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -143,6 +144,8 @@ public class ModelContainer {
         applyChange((AlterForeignKey) change);
       } else if (change instanceof AddTableComment) {
         applyChange((AddTableComment) change);
+      } else if (change instanceof Sql) {
+        // do nothing
       } else {
         throw new IllegalArgumentException("No rule for " + change);
       }

src/main/java/io/ebeaninternal/dbmigration/model/PendingDrops.java

@@ -3,6 +3,7 @@ package io.ebeaninternal.dbmigration.model;
 import io.ebeaninternal.dbmigration.migration.ChangeSet;
 import io.ebeaninternal.dbmigration.migration.ChangeSetType;
 import io.ebeaninternal.dbmigration.migration.DropColumn;
+import io.ebeaninternal.dbmigration.migration.DropHistoryTable;
 import io.ebeaninternal.dbmigration.migration.DropTable;
 import io.ebeaninternal.dbmigration.migration.Migration;
 
@@ -207,10 +208,26 @@ public class PendingDrops {
 
         } else if (pendingDrop instanceof DropTable && dropTableIn((DropTable) pendingDrop, appliedDrops)) {
           iterator.remove();
+
+        } else if (pendingDrop instanceof DropHistoryTable && dropHistoryTableIn((DropHistoryTable) pendingDrop, appliedDrops)) {
+          iterator.remove();
+
         }
       }
     }
 
+    /**
+     * Return true if the pendingDrop is contained in the appliedDrops.
+     */
+    private boolean dropHistoryTableIn(DropHistoryTable pendingDrop, ChangeSet appliedDrops) {
+      for (Object o : appliedDrops.getChangeSetChildren()) {
+        if (o instanceof DropHistoryTable && sameHistoryTable(pendingDrop, (DropHistoryTable) o)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
     /**
      * Return true if the pendingDrop is contained in the appliedDrops.
      */
@@ -235,6 +252,13 @@ public class PendingDrops {
       return false;
     }
 
+    /**
+     * Return true if the DropHistoryTable match by base-table name.
+     */
+    private boolean sameHistoryTable(DropHistoryTable pendingDrop, DropHistoryTable o) {
+      return pendingDrop.getBaseTable().equals(o.getBaseTable());
+    }
+
     /**
      * Return true if the DropTable match by table name.
      */

src/main/java/io/ebeaninternal/dbmigration/model/visitor/VisitAllUsing.java

@@ -133,8 +133,7 @@ public class VisitAllUsing {
     InheritInfo inheritInfo = descriptor.getInheritInfo();
     if (inheritInfo != null && inheritInfo.isRoot()) {
       // add all properties on the children objects
-      InheritChildVisitor childVisitor = new InheritChildVisitor(this, pv);
-      inheritInfo.visitChildren(childVisitor);
+      inheritInfo.visitChildren(new InheritChildVisitor(this, pv));
     }
   }
 
@@ -155,9 +154,10 @@ public class VisitAllUsing {
 
     @Override
     public void visit(InheritInfo inheritInfo) {
-      BeanProperty[] propertiesLocal = inheritInfo.desc().propertiesLocal();
-      for (BeanProperty aPropertiesLocal : propertiesLocal) {
-        owner.visit(pv, aPropertiesLocal);
+      for (BeanProperty beanProperty : inheritInfo.desc().propertiesLocal()) {
+        if (beanProperty.isDDLColumn()) {
+          owner.visit(pv, beanProperty);
+        }
       }
     }
   }

src/main/java/io/ebeaninternal/server/cache/CacheChangeBeanRemove.java

@@ -2,6 +2,9 @@ package io.ebeaninternal.server.cache;
 
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 
+import java.util.ArrayList;
+import java.util.Collection;
+
 /**
  * Change to remove bean from L2 cache.
  */
@@ -9,15 +12,35 @@ class CacheChangeBeanRemove implements CacheChange {
 
   private final BeanDescriptor<?> descriptor;
 
-  private final Object id;
+  private final Collection<Object> ids;
 
-  CacheChangeBeanRemove(BeanDescriptor<?> descriptor, Object id) {
+  CacheChangeBeanRemove(Object id, BeanDescriptor<?> descriptor) {
     this.descriptor = descriptor;
-    this.id = id;
+    this.ids = new ArrayList<>();
+    ids.add(id);
+  }
+
+  CacheChangeBeanRemove(BeanDescriptor<?> descriptor, Collection<Object> ids) {
+    this.descriptor = descriptor;
+    this.ids = ids;
   }
 
   @Override
   public void apply() {
-    descriptor.cacheHandleDeleteById(id);
+    descriptor.cacheApplyInvalidate(ids);
+  }
+
+  /**
+   * Add more id values.
+   */
+  public void addIds(Collection<Object> moreIds) {
+    ids.addAll(moreIds);
+  }
+
+  /**
+   * Add another id value.
+   */
+  public void addId(Object id) {
+    ids.add(id);
   }
 }

src/main/java/io/ebeaninternal/server/cache/CacheChangeBeanUpdate.java

@@ -25,6 +25,6 @@ class CacheChangeBeanUpdate implements CacheChange {
 
   @Override
   public void apply() {
-    desc.cacheBeanUpdate(id, changes, updateNaturalKey, version);
+    desc.cacheApplyBeanUpdate(id, changes, updateNaturalKey, version);
   }
 }

src/main/java/io/ebeaninternal/server/cache/CacheChangeSet.java

@@ -3,6 +3,7 @@ package io.ebeaninternal.server.cache;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -17,22 +18,30 @@ public class CacheChangeSet {
 
   private final List<CacheChange> entries = new ArrayList<>();
 
+  private final Set<String> touchedTables = new HashSet<>();
+
   private final Set<BeanDescriptor<?>> queryCaches = new HashSet<>();
 
+  private final Set<BeanDescriptor<?>> beanCaches = new HashSet<>();
+
+  private final Map<BeanDescriptor<?>, CacheChangeBeanRemove> beanRemoveMap = new HashMap<>();
+
   private final Map<ManyKey, ManyChange> manyChangeMap = new HashMap<>();
 
-  /**
-   * Set of "base tables" modified used to invalidate entities based on views.
-   */
-  private final Set<String> viewInvalidation = new HashSet<>();
-
-  private final boolean viewEntityInvalidation;
+  private final long modificationTimestamp;
 
   /**
    * Construct specifying if we also need to process invalidation for entities based on views.
    */
-  public CacheChangeSet(boolean viewEntityInvalidation) {
-    this.viewEntityInvalidation = viewEntityInvalidation;
+  public CacheChangeSet(long modificationTimestamp) {
+    this.modificationTimestamp = modificationTimestamp;
+  }
+
+  /**
+   * Return the touched tables.
+   */
+  public Set<String> touchedTables() {
+    return touchedTables;
   }
 
   /**
@@ -40,17 +49,36 @@ public class CacheChangeSet {
    * <p>
    * Return the set of table changes to process invalidation for entities based on views.
    */
-  public Set<String> apply() {
+  public void apply() {
     for (BeanDescriptor<?> entry : queryCaches) {
       entry.clearQueryCache();
     }
+    for (BeanDescriptor<?> entry : beanCaches) {
+      entry.clearBeanCache();
+    }
     for (CacheChange entry : entries) {
       entry.apply();
     }
     for (CacheChange entry : manyChangeMap.values()) {
       entry.apply();
     }
-    return viewInvalidation;
+    for (CacheChange entry : beanRemoveMap.values()) {
+      entry.apply();
+    }
+  }
+
+  /**
+   * Add an entry to clear a query cache.
+   */
+  public void addInvalidate(BeanDescriptor<?> descriptor) {
+    touchedTables.add(descriptor.getBaseTable());
+  }
+
+  /**
+   * Add invalidation on a set of tables.
+   */
+  public void addInvalidate(Set<String> tables) {
+    touchedTables.addAll(tables);
   }
 
   /**
@@ -60,6 +88,13 @@ public class CacheChangeSet {
     queryCaches.add(descriptor);
   }
 
+  /**
+   * Add an entry to clear a bean cache.
+   */
+  public void addClearBean(BeanDescriptor<?> descriptor) {
+    beanCaches.add(descriptor);
+  }
+
   /**
    * Add many property clear.
    */
@@ -85,18 +120,32 @@ public class CacheChangeSet {
    * On bean insert register table for view based entity invalidation.
    */
   public void addBeanInsert(String baseTable) {
-    if (viewEntityInvalidation) {
-      viewInvalidation.add(baseTable);
-    }
+    touchedTables.add(baseTable);
   }
 
   /**
    * Remove a bean from the cache.
    */
   public <T> void addBeanRemove(BeanDescriptor<T> desc, Object id) {
-    entries.add(new CacheChangeBeanRemove(desc, id));
-    if (viewEntityInvalidation) {
-      viewInvalidation.add(desc.getBaseTable());
+    CacheChangeBeanRemove entry = beanRemoveMap.get(desc);
+    if (entry != null) {
+      entry.addId(id);
+    } else {
+      beanRemoveMap.put(desc, new CacheChangeBeanRemove(id, desc));
+      touchedTables.add(desc.getBaseTable());
+    }
+  }
+
+  /**
+   * Remove a bean from the cache.
+   */
+  public <T> void addBeanRemoveMany(BeanDescriptor<T> desc, Collection<Object> ids) {
+    CacheChangeBeanRemove entry = beanRemoveMap.get(desc);
+    if (entry != null) {
+      entry.addIds(ids);
+    } else {
+      beanRemoveMap.put(desc, new CacheChangeBeanRemove(desc, ids));
+      touchedTables.add(desc.getBaseTable());
     }
   }
 
@@ -104,10 +153,8 @@ public class CacheChangeSet {
    * Update a bean entry.
    */
   public <T> void addBeanUpdate(BeanDescriptor<T> desc, Object id, Map<String, Object> changes, boolean updateNaturalKey, long version) {
+    touchedTables.add(desc.getBaseTable());
     entries.add(new CacheChangeBeanUpdate(desc, id, changes, updateNaturalKey, version));
-    if (viewEntityInvalidation) {
-      viewInvalidation.add(desc.getBaseTable());
-    }
   }
 
   /**
@@ -125,6 +172,13 @@ public class CacheChangeSet {
     return manyChangeMap.computeIfAbsent(key, ManyChange::new);
   }
 
+  /**
+   * Return the modification timestamp for these changes.
+   */
+  public long modificationTimestamp() {
+    return modificationTimestamp;
+  }
+
   /**
    * Changes for a specific many property.
    */

src/main/java/io/ebeaninternal/server/cache/CacheManagerOptions.java

@@ -1,5 +1,6 @@
 package io.ebeaninternal.server.cache;
 
+import io.ebean.cache.QueryCacheEntryValidate;
 import io.ebean.cache.ServerCacheFactory;
 import io.ebean.cache.ServerCacheOptions;
 import io.ebean.config.CurrentTenantProvider;
@@ -19,6 +20,8 @@ public class CacheManagerOptions {
 
   private CurrentTenantProvider currentTenantProvider;
 
+  private QueryCacheEntryValidate queryCacheEntryValidate;
+
   private ServerCacheFactory cacheFactory = new DefaultServerCacheFactory();
   private ServerCacheOptions beanDefault = new ServerCacheOptions();
   private ServerCacheOptions queryDefault = new ServerCacheOptions();
@@ -45,8 +48,9 @@ public class CacheManagerOptions {
     return this;
   }
 
-  public CacheManagerOptions with(ServerCacheFactory cacheFactory) {
+  public CacheManagerOptions with(ServerCacheFactory cacheFactory, QueryCacheEntryValidate queryCacheEntryValidate) {
     this.cacheFactory = cacheFactory;
+    this.queryCacheEntryValidate = queryCacheEntryValidate;
     return this;
   }
 
@@ -82,4 +86,8 @@ public class CacheManagerOptions {
   public ClusterManager getClusterManager() {
     return clusterManager;
   }
+
+  public QueryCacheEntryValidate getQueryCacheEntryValidate() {
+    return queryCacheEntryValidate;
+  }
 }

src/main/java/io/ebeaninternal/server/cache/DefaultCacheHolder.java

@@ -2,7 +2,9 @@ package io.ebeaninternal.server.cache;
 
 import io.ebean.annotation.CacheBeanTuning;
 import io.ebean.annotation.CacheQueryTuning;
+import io.ebean.cache.QueryCacheEntryValidate;
 import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheConfig;
 import io.ebean.cache.ServerCacheFactory;
 import io.ebean.cache.ServerCacheOptions;
 import io.ebean.cache.ServerCacheType;
@@ -33,22 +35,14 @@ class DefaultCacheHolder {
 
   private final CurrentTenantProvider tenantProvider;
 
-  DefaultCacheHolder(CacheManagerOptions builder) {
-    this(builder.getCacheFactory(), builder.getBeanDefault(), builder.getQueryDefault(), builder.getCurrentTenantProvider());
-  }
+  private final QueryCacheEntryValidate queryCacheEntryValidate;
 
-  /**
-   * Create with a cache factory and default cache options.
-   *
-   * @param cacheFactory the factory for creating the cache
-   * @param beanDefault  the default options for tuning bean caches
-   * @param queryDefault the default options for tuning query caches
-   */
-  DefaultCacheHolder(ServerCacheFactory cacheFactory, ServerCacheOptions beanDefault, ServerCacheOptions queryDefault, CurrentTenantProvider tenantProvider) {
-    this.cacheFactory = cacheFactory;
-    this.beanDefault = beanDefault;
-    this.queryDefault = queryDefault;
-    this.tenantProvider = tenantProvider;
+  DefaultCacheHolder(CacheManagerOptions builder) {
+    this.cacheFactory = builder.getCacheFactory();
+    this.beanDefault = builder.getBeanDefault();
+    this.queryDefault = builder.getQueryDefault();
+    this.tenantProvider = builder.getCurrentTenantProvider();
+    this.queryCacheEntryValidate = builder.getQueryCacheEntryValidate();
   }
 
   ServerCache getCache(Class<?> beanType, String cacheKey, ServerCacheType type) {
@@ -76,7 +70,7 @@ class DefaultCacheHolder {
         collectIdCaches.computeIfAbsent(beanType.getName(), s -> new ConcurrentSkipListSet<>()).add(key);
       }
     }
-    return cacheFactory.createCache(type, key, tenantProvider, options);
+    return cacheFactory.createCache(new ServerCacheConfig(type, key, options, tenantProvider, queryCacheEntryValidate));
   }
 
   void clearAll() {

src/main/java/io/ebeaninternal/server/cache/DefaultServerCache.java

@@ -2,10 +2,8 @@ package io.ebeaninternal.server.cache;
 
 import io.ebean.BackgroundExecutor;
 import io.ebean.cache.ServerCache;
-import io.ebean.cache.ServerCacheOptions;
 import io.ebean.cache.ServerCacheStatistics;
 import io.ebean.cache.TenantAwareKey;
-import io.ebean.config.CurrentTenantProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -15,7 +13,6 @@ import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.LongAdder;
 
@@ -65,47 +62,14 @@ public class DefaultServerCache implements ServerCache {
 
   protected TenantAwareKey tenantAwareKey;
 
-  /**
-   * Construct using a ConcurrentHashMap and cache options.
-   */
-  public DefaultServerCache(String name, CurrentTenantProvider tenantProvider, ServerCacheOptions options) {
-    this(name, new ConcurrentHashMap<>(), tenantProvider, options);
-  }
-
-  /**
-   * Construct passing in name, map and base eviction controls as ServerCacheOptions.
-   */
-  public DefaultServerCache(String name, Map<Object, CacheEntry> map, CurrentTenantProvider tenantProvider, ServerCacheOptions options) {
-    this(name, map, tenantProvider, options.getMaxSize(), options.getMaxIdleSecs(), options.getMaxSecsToLive(), options.getTrimFrequency());
-  }
-
-  /**
-   * Construct passing in name, map and base eviction controls.
-   */
-  public DefaultServerCache(String name, Map<Object, CacheEntry> map, CurrentTenantProvider tenantProvider, int maxSize, int maxIdleSecs, int maxSecsToLive, int trimFrequency) {
-    this.name = name;
-    this.map = map;
-    this.maxSize = maxSize;
-    this.tenantAwareKey = new TenantAwareKey(tenantProvider);
-    this.maxIdleSecs = maxIdleSecs;
-    this.maxSecsToLive = maxSecsToLive;
-    this.trimFrequency = determineTrim(maxIdleSecs, maxSecsToLive, trimFrequency);
-  }
-
-  /**
-   * Determine a good trimFrequency as half of maxIdleSecs (or maxSecsToLive).
-   */
-  int determineTrim(int maxIdleSecs, int maxSecsToLive, int trimFrequency) {
-    if (trimFrequency > 0) {
-      return trimFrequency;
-    }
-    if (maxIdleSecs > 0) {
-      return maxIdleSecs / 2 - 1;
-    }
-    if (maxSecsToLive > 0) {
-      return maxSecsToLive / 2 - 1;
-    }
-    return 0;
+  public DefaultServerCache(DefaultServerCacheConfig config) {
+    this.name = config.getName();
+    this.map = config.getMap();
+    this.maxSize = config.getMaxSize();
+    this.tenantAwareKey = new TenantAwareKey(config.getTenantProvider());
+    this.maxIdleSecs = config.getMaxIdleSecs();
+    this.maxSecsToLive = config.getMaxSecsToLive();
+    this.trimFrequency = config.determineTrimFrequency();
   }
 
   public void periodicTrim(BackgroundExecutor executor) {
@@ -193,7 +157,7 @@ public class DefaultServerCache implements ServerCache {
   /**
    * Return the tenant aware key.
    */
-  private Object key(Object id) {
+  protected Object key(Object id) {
     return tenantAwareKey.key(id);
   }
 
@@ -203,7 +167,7 @@ public class DefaultServerCache implements ServerCache {
   @Override
   public Object get(Object id) {
 
-    CacheEntry entry = map.get(key(id));
+    CacheEntry entry = getCacheEntry(id);
     if (entry == null) {
       missCount.increment();
       return null;
@@ -212,10 +176,24 @@ public class DefaultServerCache implements ServerCache {
       // Important that hitCount.increment() MUST be low latency under concurrent
       // use hence must use LongAdder or better here
       hitCount.increment();
-      return entry.getValue();
+      return unwrapEntry(entry);
     }
   }
 
+  /**
+   * Unwrap the cache entry - override for query cache to unwrap to the query result.
+   */
+  protected Object unwrapEntry(CacheEntry entry) {
+    return entry.getValue();
+  }
+
+  /**
+   * Get the cache entry - override for query cache to validate dependent tables.
+   */
+  protected CacheEntry getCacheEntry(Object id) {
+    return map.get(key(id));
+  }
+
   @Override
   public void putAll(Map<Object, Object> keyValues) {
     keyValues.forEach(this::put);

src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheConfig.java

@@ -0,0 +1,80 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.cache.QueryCacheEntryValidate;
+import io.ebean.cache.ServerCacheConfig;
+import io.ebean.cache.ServerCacheOptions;
+import io.ebean.config.CurrentTenantProvider;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class DefaultServerCacheConfig {
+
+  private final ServerCacheConfig config;
+
+  private int maxSize;
+  private int maxIdleSecs;
+  private int maxSecsToLive;
+  private int trimFrequency;
+
+  private Map<Object, DefaultServerCache.CacheEntry> map;
+
+  public DefaultServerCacheConfig(ServerCacheConfig config) {
+    this(config,  new ConcurrentHashMap<>());
+  }
+
+  public DefaultServerCacheConfig(ServerCacheConfig config, Map<Object, DefaultServerCache.CacheEntry> map) {
+    this.config = config;
+    this.map = map;
+
+    ServerCacheOptions options = config.getCacheOptions();
+    this.maxIdleSecs = options.getMaxIdleSecs();
+    this.maxSecsToLive = options.getMaxSecsToLive();
+    this.trimFrequency = options.getTrimFrequency();
+    this.maxSize = options.getMaxSize();
+  }
+
+  public CurrentTenantProvider getTenantProvider() {
+    return config.getTenantProvider();
+  }
+
+  public QueryCacheEntryValidate getQueryCacheEntryValidate() {
+    return config.getQueryCacheEntryValidate();
+  }
+
+  public String getName() {
+    return config.getCacheKey();
+  }
+
+  public Map<Object, DefaultServerCache.CacheEntry> getMap() {
+    return map;
+  }
+
+  public int getMaxSize() {
+    return maxSize;
+  }
+
+  public int getMaxIdleSecs() {
+    return maxIdleSecs;
+  }
+
+  public int getMaxSecsToLive() {
+    return maxSecsToLive;
+  }
+
+  /**
+   * Determine a good trimFrequency as half of maxIdleSecs (or maxSecsToLive).
+   */
+  public int determineTrimFrequency() {
+    if (trimFrequency > 0) {
+      return trimFrequency;
+    }
+    if (maxIdleSecs > 0) {
+      return maxIdleSecs / 2 - 1;
+    }
+    if (maxSecsToLive > 0) {
+      return maxSecsToLive / 2 - 1;
+    }
+    return 0;
+  }
+}

src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheFactory.java

@@ -2,10 +2,10 @@ package io.ebeaninternal.server.cache;
 
 import io.ebean.BackgroundExecutor;
 import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheConfig;
 import io.ebean.cache.ServerCacheFactory;
-import io.ebean.cache.ServerCacheOptions;
-import io.ebean.cache.ServerCacheType;
-import io.ebean.config.CurrentTenantProvider;
+import io.ebean.cache.ServerCacheNotification;
+import io.ebean.cache.ServerCacheNotify;
 
 
 /**
@@ -18,25 +18,43 @@ class DefaultServerCacheFactory implements ServerCacheFactory {
   /**
    * Construct when l2 cache is disabled.
    */
-  public DefaultServerCacheFactory() {
+  DefaultServerCacheFactory() {
     this.executor = null;
   }
 
   /**
    * Construct with executor service.
    */
-  public DefaultServerCacheFactory(BackgroundExecutor executor) {
+  DefaultServerCacheFactory(BackgroundExecutor executor) {
     this.executor = executor;
   }
 
   @Override
-  public ServerCache createCache(ServerCacheType type, String cacheKey, CurrentTenantProvider tenantProvider, ServerCacheOptions cacheOptions) {
+  public ServerCache createCache(ServerCacheConfig config) {
 
-    DefaultServerCache cache = new DefaultServerCache(cacheKey, tenantProvider, cacheOptions);
+    DefaultServerCache cache;
+    if (config.isQueryCache()) {
+      // use a server cache aware of extra validation and QueryCacheEntry
+      cache = new DefaultServerQueryCache(new DefaultServerCacheConfig(config));
+    } else {
+      cache = new DefaultServerCache(new DefaultServerCacheConfig(config));
+    }
     if (executor != null) {
       cache.periodicTrim(executor);
     }
     return cache;
   }
 
+  @Override
+  public ServerCacheNotify createCacheNotify(ServerCacheNotify listener) {
+    return new NoopServerCacheNotify();
+  }
+
+  private static class NoopServerCacheNotify implements ServerCacheNotify {
+
+    @Override
+    public void notify(ServerCacheNotification notification) {
+      // do nothing
+    }
+  }
 }

src/main/java/io/ebeaninternal/server/cache/DefaultServerQueryCache.java

@@ -0,0 +1,41 @@
+package io.ebeaninternal.server.cache;
+
+import io.ebean.cache.QueryCacheEntry;
+import io.ebean.cache.QueryCacheEntryValidate;
+
+/**
+ * Server cache for query caching.
+ * <p>
+ * Entries in this cache contain QueryCacheEntry and we need to additionally
+ * validate the entries when hit for changes to dependent tables.
+ * </p>
+ */
+public class DefaultServerQueryCache extends DefaultServerCache {
+
+  private final QueryCacheEntryValidate queryCacheEntryValidate;
+
+  public DefaultServerQueryCache(DefaultServerCacheConfig config) {
+    super(config);
+    this.queryCacheEntryValidate = config.getQueryCacheEntryValidate();
+  }
+
+  protected Object unwrapEntry(CacheEntry entry) {
+    return ((QueryCacheEntry) entry.getValue()).getValue();
+  }
+
+  @Override
+  protected CacheEntry getCacheEntry(Object id) {
+    Object key = key(id);
+    CacheEntry entry = map.get(key);
+    if (entry == null) {
+      return null;
+    }
+    QueryCacheEntry value = (QueryCacheEntry) entry.getValue();
+    if (!queryCacheEntryValidate.isValid(value)) {
+      map.remove(key);
+      removeCount.increment();
+      return null;
+    }
+    return entry;
+  }
+}

src/main/java/io/ebeaninternal/server/cache/RemoteCacheEvent.java

@@ -1,9 +1,9 @@
 package io.ebeaninternal.server.cache;
 
-import io.ebeaninternal.server.cluster.BinaryMessage;
-import io.ebeaninternal.server.cluster.BinaryMessageList;
+import io.ebeaninternal.api.BinaryReadContext;
+import io.ebeaninternal.api.BinaryWritable;
+import io.ebeaninternal.api.BinaryWriteContext;
 
-import java.io.DataInput;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -12,7 +12,7 @@ import java.util.List;
 /**
  * Cache events broadcast across the cluster.
  */
-public class RemoteCacheEvent {
+public class RemoteCacheEvent implements BinaryWritable {
 
   private boolean clearAll;
 
@@ -53,10 +53,10 @@ public class RemoteCacheEvent {
 
   @Override
   public String toString() {
-    return "clearAll:" + clearAll + " caches:" + clearCaches;
+    return "CacheEvent[ clearAll:" + clearAll + " caches:" + clearCaches + "]";
   }
 
-  public static RemoteCacheEvent readBinaryMessage(DataInput dataInput) throws IOException {
+  public static RemoteCacheEvent readBinaryMessage(BinaryReadContext dataInput) throws IOException {
 
     boolean clearAll = dataInput.readBoolean();
     int size = dataInput.readInt();
@@ -72,13 +72,9 @@ public class RemoteCacheEvent {
     return new RemoteCacheEvent(clearAll, clearCache);
   }
 
-  public void writeBinaryMessage(BinaryMessageList msgList) throws IOException {
-
-    int bufferSize = (clearCaches == null) ? 0 : clearCaches.size() * 30;
-
-    BinaryMessage msg = new BinaryMessage(bufferSize + 10);
-    DataOutputStream os = msg.getOs();
-    os.writeInt(BinaryMessage.TYPE_CACHE);
+  @Override
+  public void writeBinary(BinaryWriteContext out) throws IOException {
+    DataOutputStream os = out.start(TYPE_CACHE);
     os.writeBoolean(clearAll);
     if (clearCaches == null) {
       os.writeInt(0);
@@ -88,7 +84,5 @@ public class RemoteCacheEvent {
         os.writeUTF(cacheName);
       }
     }
-    msgList.add(msg);
-
   }
 }

src/main/java/io/ebeaninternal/server/cluster/BinaryMessage.java

@@ -1,59 +0,0 @@
-package io.ebeaninternal.server.cluster;
-
-import java.io.ByteArrayOutputStream;
-import java.io.DataOutputStream;
-
-/**
- * Represents a relatively small independent message.
- * <p>
- * In general terms we break up a potentially large object like
- * RemoteTransactionEvent into many smaller BinaryMessages. This is so that if
- * they don't all fit on a single Packet we can easily break them up and put
- * them on multiple packets.
- * </p>
- * <p>
- * Also note that for the Multicast approach a Packet will generally contain
- * many messages each directed to different members of the cluster. So it would
- * be common for many Ack, Resend and Control messages to all be contained in a
- * single packet.
- * </p>
- */
-public class BinaryMessage {
-
-  public static final int TYPE_MSGCONTROL = 0;
-  public static final int TYPE_BEANIUD = 1;
-  public static final int TYPE_TABLEIUD = 2;
-  public static final int TYPE_CACHE = 3;
-
-  public static final int TYPE_MSGACK = 8;
-  public static final int TYPE_MSGRESEND = 9;
-
-  private final ByteArrayOutputStream buffer;
-  private final DataOutputStream os;
-  private byte[] bytes;
-
-  /**
-   * Create with an estimated buffer size.
-   */
-  public BinaryMessage(int bufSize) {
-    this.buffer = new ByteArrayOutputStream(bufSize);
-    this.os = new DataOutputStream(buffer);
-  }
-
-  /**
-   * Return the DataOutputStream to write content to.
-   */
-  public DataOutputStream getOs() {
-    return os;
-  }
-
-  /**
-   * Return all the content as a byte array.
-   */
-  public byte[] getByteArray() {
-    if (bytes == null) {
-      bytes = buffer.toByteArray();
-    }
-    return bytes;
-  }
-}

src/main/java/io/ebeaninternal/server/cluster/BinaryMessageList.java

@@ -1,21 +0,0 @@
-package io.ebeaninternal.server.cluster;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Holds a List of BinaryMessage's.
- */
-public class BinaryMessageList {
-
-  final List<BinaryMessage> list = new ArrayList<>();
-
-  public void add(BinaryMessage msg) {
-    list.add(msg);
-  }
-
-  public List<BinaryMessage> getList() {
-    return list;
-  }
-
-}

src/main/java/io/ebeaninternal/server/cluster/BinaryTransactionEventReader.java

@@ -0,0 +1,41 @@
+package io.ebeaninternal.server.cluster;
+
+import io.ebeaninternal.api.BinaryReadContext;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.transaction.RemoteTransactionEvent;
+
+import java.io.IOException;
+
+/**
+ * Mechanism to convert RemoteTransactionEvent to/from byte[] content.
+ */
+public class BinaryTransactionEventReader {
+
+  private final ServerLookup serverLookup;
+
+  public BinaryTransactionEventReader(ServerLookup serverLookup) {
+    this.serverLookup = serverLookup;
+  }
+
+  /**
+   * Read Transaction from bytes.
+   */
+  public RemoteTransactionEvent read(byte[] byteData) throws IOException {
+    return read(new BinaryReadContext(byteData));
+  }
+
+  /**
+   * Read Transaction using BinaryReadContext.
+   */
+  public RemoteTransactionEvent read(BinaryReadContext dataInput) throws IOException {
+
+    String serverName = dataInput.readUTF();
+    SpiEbeanServer server = (SpiEbeanServer) serverLookup.getServer(serverName);
+    if (server == null) {
+      throw new IllegalStateException("EbeanServer not found for name [" + serverName + "]");
+    }
+    RemoteTransactionEvent event =  new RemoteTransactionEvent(server);
+    event.readBinary(dataInput);
+    return event;
+  }
+}

src/main/java/io/ebeaninternal/server/cluster/ClusterManager.java

@@ -13,7 +13,7 @@ import java.util.concurrent.ConcurrentHashMap;
 /**
  * Manages the cluster service.
  */
-public class ClusterManager {
+public class ClusterManager implements ServerLookup {
 
   private static final Logger clusterLogger = LoggerFactory.getLogger("io.ebean.Cluster");
 

src/main/java/io/ebeaninternal/server/cluster/ServerLookup.java

@@ -0,0 +1,14 @@
+package io.ebeaninternal.server.cluster;
+
+import io.ebean.EbeanServer;
+
+/**
+ * Returns EbeanServer instances for remote message reading.
+ */
+public interface ServerLookup {
+
+  /**
+   * Return the EbeanServer instance by name.
+   */
+  EbeanServer getServer(String name);
+}

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

@@ -12,6 +12,9 @@ public class CacheOptions {
    */
   public static final CacheOptions NO_CACHING = new CacheOptions();
 
+  public static final CacheOptions INVALIDATE_QUERY_CACHE = new CacheOptions(true);
+
+  private final boolean invalidateQueryCache;
   private final boolean enableBeanCache;
   private final boolean enableQueryCache;
   private final boolean readOnly;
@@ -21,6 +24,18 @@ public class CacheOptions {
    * Construct for no caching.
    */
   private CacheOptions() {
+    invalidateQueryCache = false;
+    enableBeanCache = false;
+    enableQueryCache = false;
+    readOnly = false;
+    naturalKey = null;
+  }
+
+  /**
+   * Construct for invalidateQueryCache.
+   */
+  private CacheOptions(boolean invalidateQueryCache) {
+    this.invalidateQueryCache = invalidateQueryCache;
     enableBeanCache = false;
     enableQueryCache = false;
     readOnly = false;
@@ -31,12 +46,21 @@ public class CacheOptions {
    * Construct with cache annotation.
    */
   public CacheOptions(Cache cache, String[] naturalKey) {
+    invalidateQueryCache = false;
     enableBeanCache = cache.enableBeanCache();
     enableQueryCache = cache.enableQueryCache();
     readOnly = cache.readOnly();
     this.naturalKey = naturalKey;
   }
 
+  /**
+   * Return true if this is InvalidateQueryCache. A Bean that itself isn't L2
+   * cached but invalidates query cache entries that join to it.
+   */
+  public boolean isInvalidateQueryCache() {
+    return invalidateQueryCache;
+  }
+
   /**
    * Return true if bean caching is enabled.
    */

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

@@ -0,0 +1,29 @@
+package io.ebeaninternal.server.core;
+
+import java.time.Clock;
+
+/**
+ * Wraps the Clock such that we can change the Clock for testing purposes.
+ */
+public class ClockService {
+
+  private Clock clock;
+
+  public ClockService(Clock clock) {
+    this.clock = clock;
+  }
+
+  /**
+   * Change the clock for testing purposes.
+   */
+  public void setClock(Clock clock) {
+    this.clock = clock;
+  }
+
+  /**
+   * Return the Clock current timestamp in millis.
+   */
+  public long nowMillis() {
+    return clock.millis();
+  }
+}

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

@@ -1,24 +1,16 @@
 package io.ebeaninternal.server.core;
 
-import io.ebean.BackgroundExecutor;
-import io.ebean.cache.ServerCacheFactory;
-import io.ebean.cache.ServerCacheOptions;
-import io.ebean.cache.ServerCachePlugin;
 import io.ebean.config.ContainerConfig;
 import io.ebean.config.ServerConfig;
+import io.ebean.config.ServerConfigProvider;
 import io.ebean.config.TenantMode;
 import io.ebean.config.UnderscoreNamingConvention;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.h2.H2Platform;
 import io.ebean.service.SpiContainer;
 import io.ebeaninternal.api.SpiBackgroundExecutor;
-import io.ebeaninternal.api.SpiContainerBootup;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.dbmigration.DbOffline;
-import io.ebeaninternal.server.cache.CacheManagerOptions;
-import io.ebeaninternal.server.cache.DefaultServerCacheManager;
-import io.ebeaninternal.server.cache.DefaultServerCachePlugin;
-import io.ebeaninternal.server.cache.SpiCacheManager;
 import io.ebeaninternal.server.cluster.ClusterManager;
 import io.ebeaninternal.server.core.bootup.BootupClassPathSearch;
 import io.ebeaninternal.server.core.bootup.BootupClasses;
@@ -34,7 +26,6 @@ import javax.persistence.PersistenceException;
 import javax.sql.DataSource;
 import java.sql.Connection;
 import java.sql.SQLException;
-import java.util.Iterator;
 import java.util.List;
 import java.util.ServiceLoader;
 
@@ -51,8 +42,6 @@ public class DefaultContainer implements SpiContainer {
 
   public DefaultContainer(ContainerConfig containerConfig) {
 
-    invokeBootupPlugin();
-
     this.clusterManager = new ClusterManager(containerConfig);
     this.jndiDataSourceFactory = new JndiDataSourceLookup();
 
@@ -61,13 +50,6 @@ public class DefaultContainer implements SpiContainer {
     ShutdownManager.registerContainer(this);
   }
 
-  private void invokeBootupPlugin() {
-    Iterator<SpiContainerBootup> it = ServiceLoader.load(SpiContainerBootup.class).iterator();
-    while (it.hasNext()) {
-      it.next().bootup();
-    }
-  }
-
   @Override
   public void shutdown() {
     clusterManager.shutdown();
@@ -103,8 +85,13 @@ public class DefaultContainer implements SpiContainer {
   public SpiEbeanServer createServer(ServerConfig serverConfig) {
 
     synchronized (this) {
-      setNamingConvention(serverConfig);
+      if (serverConfig.isDefaultServer()) {
+        for (ServerConfigProvider configProvider : ServiceLoader.load(ServerConfigProvider.class)) {
+          configProvider.apply(serverConfig);
+        }
+      }
 
+      setNamingConvention(serverConfig);
       BootupClasses bootupClasses = getBootupClasses(serverConfig);
 
       boolean online = true;
@@ -133,11 +120,10 @@ public class DefaultContainer implements SpiContainer {
 
       // executor and l2 caching service setup early (used during server construction)
       SpiBackgroundExecutor executor = createBackgroundExecutor(serverConfig);
-      SpiCacheManager cacheManager = getCacheManager(online, serverConfig, executor);
 
-      InternalConfiguration c = new InternalConfiguration(clusterManager, cacheManager, executor, serverConfig, bootupClasses);
+      InternalConfiguration c = new InternalConfiguration(online, clusterManager, executor, serverConfig, bootupClasses);
 
-      DefaultServer server = new DefaultServer(c, c.cache());
+      DefaultServer server = new DefaultServer(c, c.cacheManager());
 
       // generate and run DDL if required
       // if there are any other tasks requiring action in their plugins, do them as well
@@ -160,52 +146,6 @@ public class DefaultContainer implements SpiContainer {
     }
   }
 
-  /**
-   * Create and return the CacheManager.
-   */
-  private SpiCacheManager getCacheManager(boolean online, ServerConfig serverConfig, BackgroundExecutor executor) {
-
-    if (!online || serverConfig.isDisableL2Cache()) {
-      // use local only L2 cache implementation as placeholder
-      return new DefaultServerCacheManager();
-    }
-
-    // reasonable default settings are for a cache per bean type
-    ServerCacheOptions beanOptions = new ServerCacheOptions();
-    beanOptions.setMaxSize(serverConfig.getCacheMaxSize());
-    beanOptions.setMaxIdleSecs(serverConfig.getCacheMaxIdleTime());
-    beanOptions.setMaxSecsToLive(serverConfig.getCacheMaxTimeToLive());
-
-    // reasonable default settings for the query cache per bean type
-    ServerCacheOptions queryOptions = new ServerCacheOptions();
-    queryOptions.setMaxSize(serverConfig.getQueryCacheMaxSize());
-    queryOptions.setMaxIdleSecs(serverConfig.getQueryCacheMaxIdleTime());
-    queryOptions.setMaxSecsToLive(serverConfig.getQueryCacheMaxTimeToLive());
-
-    boolean localL2Caching = false;
-    ServerCachePlugin plugin = serverConfig.getServerCachePlugin();
-    if (plugin == null) {
-      ServiceLoader<ServerCachePlugin> cacheFactories = ServiceLoader.load(ServerCachePlugin.class);
-      Iterator<ServerCachePlugin> iterator = cacheFactories.iterator();
-      if (iterator.hasNext()) {
-        // use the cacheFactory (via classpath service loader)
-        plugin = iterator.next();
-        logger.debug("using ServerCacheFactory {}", plugin.getClass());
-      } else {
-        // use the built in default l2 caching which is local cache based
-        localL2Caching = true;
-        plugin = new DefaultServerCachePlugin();
-      }
-    }
-
-    ServerCacheFactory factory = plugin.create(serverConfig, executor);
-
-    CacheManagerOptions builder = new CacheManagerOptions(clusterManager, serverConfig, localL2Caching)
-      .with(beanOptions, queryOptions)
-      .with(factory);
-    return new DefaultServerCacheManager(builder);
-  }
-
   /**
    * Get the entities, scalarTypes, Listeners etc combining the class registered
    * ones with the already created instances.

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

@@ -8,6 +8,7 @@ import io.ebean.DocumentStore;
 import io.ebean.DtoQuery;
 import io.ebean.ExpressionFactory;
 import io.ebean.ExpressionList;
+import io.ebean.ExtendedServer;
 import io.ebean.Filter;
 import io.ebean.FutureIds;
 import io.ebean.FutureList;
@@ -118,10 +119,10 @@ import javax.persistence.NonUniqueResultException;
 import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
 import javax.sql.DataSource;
+import java.time.Clock;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
@@ -150,6 +151,11 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   private final DataTimeZone dataTimeZone;
 
+  /**
+   * Clock to use for WhenModified and WhenCreated.
+   */
+  private ClockService clockService;
+
   private final CallStackFactory callStackFactory;
 
   /**
@@ -277,6 +283,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     this.beanLoader = new DefaultBeanLoader(this);
     this.jsonContext = config.createJsonContext(this);
     this.dataTimeZone = config.getDataTimeZone();
+    this.clockService = config.getClockService();
 
     DocStoreIntegration docStoreComponents = config.createDocStoreIntegration(this);
     this.transactionManager = config.createTransactionManager(docStoreComponents.updateProcessor());
@@ -501,6 +508,21 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     return serverName;
   }
 
+  @Override
+  public ExtendedServer extended() {
+    return this;
+  }
+
+  @Override
+  public long clockNow() {
+    return clockService.nowMillis();
+  }
+
+  @Override
+  public void setClock(Clock clock) {
+    this.clockService.setClock(clock);
+  }
+
   @Override
   public BeanState getBeanState(Object bean) {
     if (bean instanceof EntityBean) {
@@ -1362,7 +1384,18 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     try {
       request.initTransIfRequired();
       request.markNotQueryOnly();
-      return request.delete();
+      if (request.isDeleteByStatement()) {
+        return request.delete();
+      } else {
+        // escalate to fetch the ids of the beans to delete due
+        // to cascading deletes or l2 caching etc
+        List<Object> ids = request.findIds();
+        if (ids.isEmpty()) {
+          return 0;
+        } else {
+          return persister.deleteByIds(request.getBeanDescriptor(), ids, request.getTransaction(), false);
+        }
+      }
     } finally {
       request.endTransIfRequired();
     }
@@ -1734,7 +1767,6 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     if (beans == null || beans.isEmpty()) {
       return;
     }
-
     executeInTrans((txn) -> {
       for (Object bean : beans) {
         update(checkEntityBean(bean), txn);
@@ -1776,7 +1808,6 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     if (beans == null || beans.isEmpty()) {
       return;
     }
-
     executeInTrans((txn) -> {
       for (Object bean : beans) {
         persister.insert(checkEntityBean(bean), txn);
@@ -1845,24 +1876,27 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public int saveAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException {
-    return saveAllInternal(beans.iterator(), transaction);
+    return saveAllInternal(beans, transaction);
   }
 
   @Override
   public int saveAll(Collection<?> beans) throws OptimisticLockException {
-    return saveAllInternal(beans.iterator(), null);
+    return saveAllInternal(beans, null);
   }
 
   /**
    * Save all beans in the iterator with an explicit transaction.
    */
-  private int saveAllInternal(Iterator<?> it, Transaction transaction) {
+  private int saveAllInternal(Collection<?> beans, Transaction transaction) {
 
+    if (beans == null || beans.isEmpty()) {
+      return 0;
+    }
     return executeInTrans((txn) -> {
       txn.checkBatchEscalationOnCollection();
       int saveCount = 0;
-      while (it.hasNext()) {
-        persister.save(checkEntityBean(it.next()), txn);
+      for (Object bean : beans) {
+        persister.save(checkEntityBean(bean), txn);
         saveCount++;
       }
 
@@ -1950,12 +1984,12 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public int deleteAllPermanent(Collection<?> beans) {
-    return deleteAllInternal(beans.iterator(), null, true);
+    return deleteAllInternal(beans, null, true);
   }
 
   @Override
   public int deleteAllPermanent(Collection<?> beans, Transaction t) {
-    return deleteAllInternal(beans.iterator(), t, true);
+    return deleteAllInternal(beans, t, true);
   }
 
   /**
@@ -1963,7 +1997,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    */
   @Override
   public int deleteAll(Collection<?> beans) {
-    return deleteAllInternal(beans.iterator(), null, false);
+    return deleteAllInternal(beans, null, false);
   }
 
   /**
@@ -1971,21 +2005,23 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    */
   @Override
   public int deleteAll(Collection<?> beans, Transaction t) {
-    return deleteAllInternal(beans.iterator(), t, false);
+    return deleteAllInternal(beans, t, false);
   }
 
   /**
    * Delete all the beans in the iterator with an explicit transaction.
    */
-  private int deleteAllInternal(Iterator<?> it, Transaction transaction, boolean permanent) {
+  private int deleteAllInternal(Collection<?> beans, Transaction transaction, boolean permanent) {
 
+    if (beans == null || beans.isEmpty()) {
+      return 0;
+    }
     return executeInTrans((txn) -> {
 
       txn.checkBatchEscalationOnCollection();
       int deleteCount = 0;
-      while (it.hasNext()) {
-        EntityBean bean = checkEntityBean(it.next());
-        persister.delete(bean, txn, permanent);
+      for (Object bean : beans) {
+        persister.delete(checkEntityBean(bean), txn, permanent);
         deleteCount++;
       }
 

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

@@ -3,7 +3,12 @@ package io.ebeaninternal.server.core;
 import com.fasterxml.jackson.core.JsonFactory;
 import io.ebean.ExpressionFactory;
 import io.ebean.annotation.Platform;
+import io.ebean.cache.ServerCacheFactory;
 import io.ebean.cache.ServerCacheManager;
+import io.ebean.cache.ServerCacheNotify;
+import io.ebean.cache.ServerCacheNotifyPlugin;
+import io.ebean.cache.ServerCacheOptions;
+import io.ebean.cache.ServerCachePlugin;
 import io.ebean.config.ExternalTransactionManager;
 import io.ebean.config.ProfilingConfig;
 import io.ebean.config.ServerConfig;
@@ -27,7 +32,10 @@ import io.ebeaninternal.api.SpiProfileHandler;
 import io.ebeaninternal.dbmigration.DbOffline;
 import io.ebeaninternal.server.autotune.AutoTuneService;
 import io.ebeaninternal.server.autotune.service.AutoTuneServiceFactory;
+import io.ebeaninternal.server.cache.CacheManagerOptions;
 import io.ebeaninternal.server.cache.DefaultCacheAdapter;
+import io.ebeaninternal.server.cache.DefaultServerCacheManager;
+import io.ebeaninternal.server.cache.DefaultServerCachePlugin;
 import io.ebeaninternal.server.cache.SpiCacheManager;
 import io.ebeaninternal.server.changelog.DefaultChangeLogListener;
 import io.ebeaninternal.server.changelog.DefaultChangeLogPrepare;
@@ -69,6 +77,7 @@ import io.ebeaninternal.server.transaction.ExplicitTransactionManager;
 import io.ebeaninternal.server.transaction.ExternalTransactionScopeManager;
 import io.ebeaninternal.server.transaction.JtaTransactionManager;
 import io.ebeaninternal.server.transaction.NoopProfileHandler;
+import io.ebeaninternal.server.transaction.TableModState;
 import io.ebeaninternal.server.transaction.TransactionManager;
 import io.ebeaninternal.server.transaction.TransactionManagerOptions;
 import io.ebeaninternal.server.transaction.TransactionScopeManager;
@@ -84,6 +93,7 @@ import org.slf4j.LoggerFactory;
 
 import javax.sql.DataSource;
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.ServiceLoader;
@@ -96,6 +106,10 @@ public class InternalConfiguration {
 
   private static final Logger logger = LoggerFactory.getLogger(InternalConfiguration.class);
 
+  private final TableModState tableModState;
+
+  private final boolean online;
+
   private final ServerConfig serverConfig;
 
   private final BootupClasses bootupClasses;
@@ -108,6 +122,8 @@ public class InternalConfiguration {
 
   private final DtoBeanManager dtoBeanManager;
 
+  private final ClockService clockService;
+
   private final DataTimeZone dataTimeZone;
 
   private final Binder binder;
@@ -124,6 +140,12 @@ public class InternalConfiguration {
 
   private final SpiCacheManager cacheManager;
 
+  private final ServerCachePlugin serverCachePlugin;
+
+  private ServerCacheNotify cacheNotify;
+
+  private boolean localL2Caching;
+
   private final ExpressionFactory expressionFactory;
 
   private final SpiBackgroundExecutor backgroundExecutor;
@@ -141,17 +163,18 @@ public class InternalConfiguration {
 
   private final SpiLogManager logManager;
 
-  public InternalConfiguration(ClusterManager clusterManager,
-                               SpiCacheManager cacheManager, SpiBackgroundExecutor backgroundExecutor,
+  public InternalConfiguration(boolean online, ClusterManager clusterManager, SpiBackgroundExecutor backgroundExecutor,
                                ServerConfig serverConfig, BootupClasses bootupClasses) {
 
+    this.online = online;
     this.serverConfig = serverConfig;
+    this.clockService = new ClockService(serverConfig.getClock());
+    this.tableModState = new TableModState(clockService);
     this.logManager = initLogManager();
     this.docStoreFactory = initDocStoreFactory(serverConfig.service(DocStoreFactory.class));
     this.jsonFactory = serverConfig.getJsonFactory();
     this.clusterManager = clusterManager;
     this.backgroundExecutor = backgroundExecutor;
-    this.cacheManager = cacheManager;
     this.bootupClasses = bootupClasses;
 
     this.databasePlatform = serverConfig.getDatabasePlatform();
@@ -164,6 +187,9 @@ public class InternalConfiguration {
     this.deployCreateProperties = new DeployCreateProperties(typeManager);
     this.deployUtil = new DeployUtil(typeManager, serverConfig);
 
+    this.serverCachePlugin = initServerCachePlugin();
+    this.cacheManager = initCacheManager();
+
     InternalConfigXmlRead xmlRead = new InternalConfigXmlRead(serverConfig);
 
     this.dtoBeanManager = new DtoBeanManager(typeManager, xmlRead.readDtoMapping());
@@ -211,6 +237,10 @@ public class InternalConfiguration {
     return docStoreFactory;
   }
 
+  public ClockService getClockService() {
+    return clockService;
+  }
+
   /**
    * Check if this is a SpiServerPlugin and if so 'collect' it to give the complete list
    * later on the DefaultServer for late call to configure().
@@ -400,7 +430,8 @@ public class InternalConfiguration {
 
     TransactionManagerOptions options =
       new TransactionManagerOptions(notifyL2CacheInForeground, serverConfig, scopeManager, clusterManager, backgroundExecutor,
-                                    indexUpdateProcessor, beanDescriptorManager, dataSource(), profileHandler(), logManager);
+                                    indexUpdateProcessor, beanDescriptorManager, dataSource(), profileHandler(), logManager,
+                                    tableModState, cacheNotify, clockService);
 
     if (serverConfig.isExplicitTransactionBeginMode()) {
       return new ExplicitTransactionManager(options);
@@ -493,7 +524,7 @@ public class InternalConfiguration {
     return dataTimeZone;
   }
 
-  public ServerCacheManager cache() {
+  public ServerCacheManager cacheManager() {
     return new DefaultCacheAdapter(cacheManager);
   }
 
@@ -537,4 +568,62 @@ public class InternalConfiguration {
   public SpiLogManager getLogManager() {
     return logManager;
   }
+
+  private ServerCachePlugin initServerCachePlugin() {
+
+    ServerCachePlugin plugin = serverConfig.getServerCachePlugin();
+    if (plugin == null) {
+      ServiceLoader<ServerCachePlugin> cacheFactories = ServiceLoader.load(ServerCachePlugin.class);
+      Iterator<ServerCachePlugin> iterator = cacheFactories.iterator();
+      if (iterator.hasNext()) {
+        // use the cacheFactory (via classpath service loader)
+        plugin = iterator.next();
+        logger.debug("using ServerCacheFactory {}", plugin.getClass());
+      } else {
+        // use the built in default l2 caching which is local cache based
+        localL2Caching = true;
+        plugin = new DefaultServerCachePlugin();
+      }
+    }
+    return plugin;
+  }
+
+  /**
+   * Create and return the CacheManager.
+   */
+  private SpiCacheManager initCacheManager() {
+
+    if (!online || serverConfig.isDisableL2Cache()) {
+      // use local only L2 cache implementation as placeholder
+      return new DefaultServerCacheManager();
+    }
+
+    ServerCacheFactory factory = serverCachePlugin.create(serverConfig, backgroundExecutor);
+
+    ServerCacheNotifyPlugin notifyPlugin = serverConfig.service(ServerCacheNotifyPlugin.class);
+    if (notifyPlugin != null) {
+      // plugin supplied so use that to send notifications
+      cacheNotify = notifyPlugin.create(serverConfig);
+    } else {
+      cacheNotify = factory.createCacheNotify(tableModState);
+    }
+
+    // reasonable default settings are for a cache per bean type
+    ServerCacheOptions beanOptions = new ServerCacheOptions();
+    beanOptions.setMaxSize(serverConfig.getCacheMaxSize());
+    beanOptions.setMaxIdleSecs(serverConfig.getCacheMaxIdleTime());
+    beanOptions.setMaxSecsToLive(serverConfig.getCacheMaxTimeToLive());
+
+    // reasonable default settings for the query cache per bean type
+    ServerCacheOptions queryOptions = new ServerCacheOptions();
+    queryOptions.setMaxSize(serverConfig.getQueryCacheMaxSize());
+    queryOptions.setMaxIdleSecs(serverConfig.getQueryCacheMaxIdleTime());
+    queryOptions.setMaxSecsToLive(serverConfig.getQueryCacheMaxTimeToLive());
+
+    CacheManagerOptions builder = new CacheManagerOptions(clusterManager, serverConfig, localL2Caching)
+      .with(beanOptions, queryOptions)
+      .with(factory, tableModState);
+
+    return new DefaultServerCacheManager(builder);
+  }
 }

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

@@ -8,6 +8,7 @@ import io.ebean.Version;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.PersistenceContext;
+import io.ebean.cache.QueryCacheEntry;
 import io.ebean.common.BeanList;
 import io.ebean.common.CopyOnFirstWriteList;
 import io.ebean.event.BeanFindController;
@@ -83,6 +84,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
 
   private boolean inlineCountDistinct;
 
+  private Set<String> dependentTables;
+
   /**
    * Create the InternalQueryRequest.
    */
@@ -113,6 +116,11 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
     }
   }
 
+  @Override
+  public boolean isDeleteByStatement() {
+    return beanDescriptor.isDeleteByStatement();
+  }
+
   @Override
   public boolean isMultiValueIdSupported() {
     return beanDescriptor.isMultiValueIdSupported();
@@ -207,7 +215,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   /**
    * Prepare the query and calculate the query plan key.
    */
-  public void prepareQuery() {
+  void prepareQuery() {
     beanDescriptor.prepareQuery(query);
     adapterPreQuery();
     this.secondaryQueries = query.convertJoins();
@@ -381,8 +389,8 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   }
 
   private int notifyCache(int rows, boolean update) {
-    if (rows > 0 && beanDescriptor.isCaching()) {
-      transaction.getEvent().add(beanDescriptor.getBaseTable(), false, update, !update);
+    if (rows > 0) {
+      beanDescriptor.cacheUpdateQuery(update, transaction);
     }
     return rows;
   }
@@ -680,8 +688,10 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
     }
   }
 
-  public void putToQueryCache(Object queryResult) {
-    beanDescriptor.queryCachePut(cacheKey, queryResult);
+  public void putToQueryCache(Object result) {
+    // use transaction start where as query statement start would be better at READ_COMMITTED
+    long asOfTimestamp = transaction.getStartMillis();
+    beanDescriptor.queryCachePut(cacheKey, new QueryCacheEntry(result, dependentTables, asOfTimestamp));
   }
 
   /**
@@ -752,4 +762,13 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
   public boolean isInlineCountDistinct() {
     return inlineCountDistinct;
   }
+
+  public void addDependentTables(Set<String> tables) {
+    if (tables != null && !tables.isEmpty()) {
+      if (dependentTables == null) {
+        dependentTables = new LinkedHashSet<>();
+      }
+      dependentTables.addAll(tables);
+    }
+  }
 }

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

@@ -17,7 +17,7 @@ public abstract class PersistRequest extends BeanRequest implements BatchPostExe
     INSERT(EVT_INSERT),
     UPDATE(EVT_UPDATE),
     DELETE(EVT_DELETE),
-    SOFT_DELETE(EVT_SOFT_DELETE),
+    DELETE_SOFT(EVT_DELETE_SOFT),
     DELETE_PERMANENT(EVT_DELETE_PERMANENT),
     UPDATESQL(EVT_UPDATESQL),
     CALLABLESQL(EVT_CALLABLESQL);
@@ -92,7 +92,7 @@ public abstract class PersistRequest extends BeanRequest implements BatchPostExe
    * Return true if this persist request should use JDBC batch.
    */
   public boolean isBatchThisRequest() {
-    return transaction.isBatchThisRequest(type);
+    return transaction.isBatchThisRequest();
   }
 
   /**

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

@@ -23,6 +23,7 @@ import io.ebeaninternal.server.deploy.generatedproperty.GeneratedProperty;
 import io.ebeaninternal.server.deploy.id.ImportedId;
 import io.ebeaninternal.server.persist.BatchControl;
 import io.ebeaninternal.server.persist.BatchedSqlException;
+import io.ebeaninternal.server.persist.DeleteMode;
 import io.ebeaninternal.server.persist.Flags;
 import io.ebeaninternal.server.persist.PersistExecute;
 import io.ebeaninternal.server.transaction.BeanPersistIdMap;
@@ -271,7 +272,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
           onUpdateGeneratedProperties();
         }
         break;
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         onUpdateGeneratedProperties();
         break;
     }
@@ -355,7 +356,15 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
   private boolean flushBatchOnGetter(int propertyIndex) {
     // propertyIndex of -1 the Id property, no flush for get Id on UPDATE
-    return propertyIndex == -1 ? type == Type.INSERT : beanDescriptor.isGeneratedProperty(propertyIndex);
+    if (propertyIndex == -1) {
+      if (beanDescriptor.isIdLoaded(intercept)) {
+        return false;
+      } else {
+        return type == Type.INSERT;
+      }
+    } else {
+      return beanDescriptor.isGeneratedProperty(propertyIndex);
+    }
   }
 
   public void setSkipBatchForTopLevel() {
@@ -449,14 +458,14 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     if (notifyCache) {
       switch (type) {
         case INSERT:
-          beanDescriptor.cacheHandleInsert(this, changeSet);
+          beanDescriptor.cachePersistInsert(this, changeSet);
           break;
         case UPDATE:
-          beanDescriptor.cacheHandleUpdate(idValue, this, changeSet);
+          beanDescriptor.cachePersistUpdate(idValue, this, changeSet);
           break;
         case DELETE:
-        case SOFT_DELETE:
-          beanDescriptor.cacheHandleDelete(idValue, this, changeSet);
+        case DELETE_SOFT:
+          beanDescriptor.cachePersistDelete(idValue, this, changeSet);
           break;
         default:
           throw new IllegalStateException("Invalid type " + type);
@@ -475,7 +484,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
         beanDescriptor.docStoreInsert(idValue, this, txn);
         break;
       case UPDATE:
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         beanDescriptor.docStoreUpdate(idValue, this, txn);
         break;
       case DELETE:
@@ -496,7 +505,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
         docStoreUpdates.queueIndex(beanDescriptor.getDocStoreQueueId(), idValue);
         break;
       case UPDATE:
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         docStoreUpdates.queueIndex(beanDescriptor.getDocStoreQueueId(), idValue);
         break;
       case DELETE:
@@ -527,7 +536,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
           beanPersistListener.deleted(bean);
           break;
 
-        case SOFT_DELETE:
+        case DELETE_SOFT:
           beanPersistListener.softDeleted(bean);
           break;
 
@@ -772,7 +781,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
         executeUpdate();
         return -1;
 
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         prepareForSoftDelete();
         executeSoftDelete();
         return -1;
@@ -855,7 +864,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     }
     switch (type) {
       case DELETE:
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         postDelete();
         break;
       case UPDATE:
@@ -968,7 +977,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
           pendingPostUpdateNotify++;
         }
         break;
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         controller.postSoftDelete(this);
         break;
       case DELETE:
@@ -993,7 +1002,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       case DELETE:
         transaction.logSummary("Deleted [" + name + "] [" + idValue + "]" + draft);
         break;
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         transaction.logSummary("SoftDelete [" + name + "] [" + idValue + "]" + draft);
         break;
       default:
@@ -1184,10 +1193,10 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   /**
-   * Return true if this is a soft delete request.
+   * Return the delete mode - Soft or Hard.
    */
-  public boolean isSoftDelete() {
-    return Type.SOFT_DELETE == type;
+  public DeleteMode deleteMode() {
+    return Type.DELETE_SOFT == type ? DeleteMode.SOFT : DeleteMode.HARD;
   }
 
   /**
@@ -1274,7 +1283,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   public long now() {
     if (now == 0) {
-      now = System.currentTimeMillis();
+      now = ebeanServer.clockNow();
     }
     return now;
   }

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

@@ -63,6 +63,11 @@ public interface Persister {
    */
   int deleteMany(Class<?> beanType, Collection<?> ids, Transaction transaction, boolean permanent);
 
+  /**
+   * Delete multiple beans when escalated from a delete query.
+   */
+  int deleteByIds(BeanDescriptor<?> descriptor, List<Object> idList, Transaction transaction, boolean permanent);
+
   /**
    * Execute the Update.
    */

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

@@ -171,4 +171,9 @@ public interface SpiOrmQueryRequest<T> extends BeanQueryRequest<T>, DocQueryRequ
    * Set profile location for "find all" if not set.
    */
   void profileLocationAll();
+
+  /**
+   * Return true if delete by statement is allowed for this type given cascade rules etc.
+   */
+  boolean isDeleteByStatement();
 }

src/main/java/io/ebeaninternal/server/deploy/BeanCollectionHelp.java

@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.deploy;
 
-import io.ebean.EbeanServer;
 import io.ebean.Query;
 import io.ebean.Transaction;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.BeanCollectionAdd;
 import io.ebean.bean.BeanCollectionLoader;
 import io.ebean.bean.EntityBean;
+import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.json.SpiJsonWriter;
 import io.ebeaninternal.server.query.CQueryCollectionAdd;
 
@@ -59,7 +59,7 @@ public interface BeanCollectionHelp<T> extends CQueryCollectionAdd<T> {
   /**
    * Refresh the List Set or Map.
    */
-  void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean);
+  void refresh(SpiEbeanServer server, Query<?> query, Transaction t, EntityBean parentBean);
 
   /**
    * Apply the new refreshed BeanCollection to the appropriate property of the parent bean.

src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java

@@ -11,6 +11,7 @@ import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
 import io.ebean.bean.PersistenceContext;
+import io.ebean.cache.QueryCacheEntry;
 import io.ebean.config.EncryptKey;
 import io.ebean.config.ServerConfig;
 import io.ebean.config.dbplatform.IdType;
@@ -39,6 +40,7 @@ import io.ebeaninternal.api.ConcurrencyMode;
 import io.ebeaninternal.api.LoadContext;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.SpiQuery;
+import io.ebeaninternal.api.SpiTransaction;
 import io.ebeaninternal.api.SpiUpdatePlan;
 import io.ebeaninternal.api.TransactionEventTable.TableIUD;
 import io.ebeaninternal.api.json.SpiJsonReader;
@@ -62,6 +64,7 @@ import io.ebeaninternal.server.el.ElComparatorProperty;
 import io.ebeaninternal.server.el.ElPropertyChainBuilder;
 import io.ebeaninternal.server.el.ElPropertyDeploy;
 import io.ebeaninternal.server.el.ElPropertyValue;
+import io.ebeaninternal.server.persist.DeleteMode;
 import io.ebeaninternal.server.persist.DmlUtil;
 import io.ebeaninternal.server.query.CQueryPlan;
 import io.ebeaninternal.server.query.ExtraJoin;
@@ -288,6 +291,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
    */
   protected final InheritInfo inheritInfo;
 
+  private final boolean abstractType;
+
   /**
    * Derived list of properties that make up the unique id.
    */
@@ -543,7 +548,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
     this.whenCreatedProperty = findWhenCreatedProperty();
 
     // derive the index position of the Id and Version properties
-    if (Modifier.isAbstract(beanType.getModifiers())) {
+    this.abstractType = Modifier.isAbstract(beanType.getModifiers());
+    if (abstractType) {
       this.idPropertyIndex = -1;
       this.versionPropertyIndex = -1;
       this.unloadProperties = new int[0];
@@ -650,6 +656,13 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
     return ebeanServer;
   }
 
+  /**
+   * Return true if this is an abstract type.
+   */
+  public boolean isAbstractType() {
+    return abstractType;
+  }
+
   /**
    * Return true if this is a "Doc Store only" entity bean.
    */
@@ -826,8 +839,11 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
    */
   @SuppressWarnings("unchecked")
   public void initialiseDocMapping() {
-    for (BeanPropertyAssocMany<?> aPropertiesMany : propertiesMany) {
-      aPropertiesMany.initialisePostTarget();
+    for (BeanPropertyAssocMany<?> many : propertiesMany) {
+      many.initialisePostTarget();
+    }
+    for (BeanPropertyAssocOne<?> one : propertiesOne) {
+      one.initialisePostTarget();
     }
     if (inheritInfo != null && !inheritInfo.isRoot()) {
       docStoreAdapter = (DocStoreBeanAdapter<T>) inheritInfo.getRoot().desc().docStoreAdapter();
@@ -907,7 +923,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
       case INSERT:
         return changeLogFilter.includeInsert(request) ? insertBeanChange(request) : null;
       case UPDATE:
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         return changeLogFilter.includeUpdate(request) ? updateBeanChange(request) : null;
       case DELETE:
         return changeLogFilter.includeDelete(request) ? deleteBeanChange(request) : null;
@@ -991,11 +1007,11 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
     jsonWriter.writeEndObject();
   }
 
-  public SqlUpdate deleteById(Object id, List<Object> idList, boolean softDelete) {
+  public SqlUpdate deleteById(Object id, List<Object> idList, DeleteMode mode) {
     if (id != null) {
-      return deleteById(id, softDelete);
+      return deleteById(id, mode);
     } else {
-      return deleteByIdList(idList, softDelete);
+      return deleteByIdList(idList, mode);
     }
   }
 
@@ -1017,9 +1033,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
    * Return SQL that can be used to delete a list of Id's without any optimistic
    * concurrency checking.
    */
-  private SqlUpdate deleteByIdList(List<Object> idList, boolean softDelete) {
+  private SqlUpdate deleteByIdList(List<Object> idList, DeleteMode mode) {
 
-    String baseSql = softDelete ? softDeleteByIdInSql : deleteByIdInSql;
+    String baseSql = mode.isHard() ? deleteByIdInSql : softDeleteByIdInSql;
     StringBuilder sb = new StringBuilder(baseSql);
     String inClause = idBinder.getIdInValueExprDelete(idList.size());
     sb.append(inClause);
@@ -1033,9 +1049,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
    * Return SQL that can be used to delete by Id without any optimistic
    * concurrency checking.
    */
-  private SqlUpdate deleteById(Object id, boolean softDelete) {
+  private SqlUpdate deleteById(Object id, DeleteMode mode) {
 
-    String baseSql = softDelete ? softDeleteByIdSql : deleteByIdSql;
+    String baseSql = mode.isHard() ? deleteByIdSql : softDeleteByIdSql;
     DefaultSqlUpdate sqlDelete = new DefaultSqlUpdate(baseSql);
 
     Object[] bindValues = idBinder.getBindValues(id);
@@ -1360,15 +1376,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
   /**
    * Put a query result into the query cache.
    */
-  public void queryCachePut(Object id, Object queryResult) {
-    cacheHelp.queryCachePut(id, queryResult);
-  }
-
-  /**
-   * Add a query cache clear into the changeSet.
-   */
-  public void queryCacheClear(CacheChangeSet changeSet) {
-    cacheHelp.queryCacheClear(changeSet);
+  public void queryCachePut(Object id, QueryCacheEntry entry) {
+    cacheHelp.queryCachePut(id, entry);
   }
 
   /**
@@ -1468,10 +1477,10 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
   }
 
   /**
-   * Remove a bean from the cache given its Id.
+   * Remove a collection of beans from the cache given the ids.
    */
-  public void cacheHandleDeleteById(Object id) {
-    cacheHelp.beanCacheRemove(id);
+  public void cacheApplyInvalidate(Collection<Object> ids) {
+    cacheHelp.beanCacheApplyInvalidate(ids);
   }
 
   /**
@@ -1502,44 +1511,51 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
   }
 
   /**
-   * Invalidate parts of cache due to SqlUpdate or external modification etc.
+   * Check if bulk update or delete query has a cache impact.
    */
-  public void cacheHandleBulkUpdate(TableIUD tableIUD) {
-    cacheHelp.handleBulkUpdate(tableIUD);
+  public void cacheUpdateQuery(boolean update, SpiTransaction transaction) {
+    cacheHelp.cacheUpdateQuery(update, transaction);
   }
 
   /**
-   * Handle a delete by id request adding an cache change into the changeSet.
+   * Invalidate parts of cache due to SqlUpdate or external modification etc.
    */
-  public void cacheHandleDeleteById(Object id, CacheChangeSet changeSet) {
-    cacheHelp.handleDelete(id, changeSet);
+  public void cachePersistTableIUD(TableIUD tableIUD, CacheChangeSet changeSet) {
+    cacheHelp.persistTableIUD(tableIUD, changeSet);
   }
 
   /**
    * Remove a bean from the cache given its Id.
    */
-  public void cacheHandleDelete(Object id, PersistRequestBean<T> deleteRequest, CacheChangeSet changeSet) {
-    cacheHelp.handleDelete(id, deleteRequest, changeSet);
+  public void cachePersistDeleteByIds(Collection<Object> ids, CacheChangeSet changeSet) {
+    cacheHelp.persistDeleteIds(ids, changeSet);
+  }
+
+  /**
+   * Remove a bean from the cache given its Id.
+   */
+  public void cachePersistDelete(Object id, PersistRequestBean<T> deleteRequest, CacheChangeSet changeSet) {
+    cacheHelp.persistDelete(id, deleteRequest, changeSet);
   }
 
   /**
    * Add the insert changes to the changeSet.
    */
-  public void cacheHandleInsert(PersistRequestBean<T> insertRequest, CacheChangeSet changeSet) {
-    cacheHelp.handleInsert(insertRequest, changeSet);
+  public void cachePersistInsert(PersistRequestBean<T> insertRequest, CacheChangeSet changeSet) {
+    cacheHelp.persistInsert(insertRequest, changeSet);
   }
 
   /**
    * Add the update to the changeSet.
    */
-  public void cacheHandleUpdate(Object id, PersistRequestBean<T> updateRequest, CacheChangeSet changeSet) {
-    cacheHelp.handleUpdate(id, updateRequest, changeSet);
+  public void cachePersistUpdate(Object id, PersistRequestBean<T> updateRequest, CacheChangeSet changeSet) {
+    cacheHelp.persistUpdate(id, updateRequest, changeSet);
   }
 
   /**
    * Apply the update to the cache.
    */
-  public void cacheBeanUpdate(Object id, Map<String, Object> changes, boolean updateNaturalKey, long version) {
+  public void cacheApplyBeanUpdate(Object id, Map<String, Object> changes, boolean updateNaturalKey, long version) {
     cacheHelp.cacheBeanUpdate(id, changes, updateNaturalKey, version);
   }
 
@@ -3144,6 +3160,10 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
   public boolean hasIdPropertyOnly(EntityBeanIntercept ebi) {
     return ebi.hasIdOnly(idPropertyIndex);
   }
+  
+  public boolean isIdLoaded(EntityBeanIntercept ebi) {
+    return ebi.isLoadedProperty(idPropertyIndex);
+  }
 
   public boolean hasIdValue(EntityBean bean) {
     return (idProperty != null && !DmlUtil.isNullOrZero(idProperty.getValue(bean)));
@@ -3427,11 +3447,11 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
   }
 
   public T jsonRead(SpiJsonReader jsonRead, String path) throws IOException {
-    return jsonHelp.jsonRead(jsonRead, path);
+    return jsonHelp.jsonRead(jsonRead, path, true);
   }
 
-  protected T jsonReadObject(SpiJsonReader jsonRead, String path) throws IOException {
-    return jsonHelp.jsonReadObject(jsonRead, path);
+  public T jsonReadObject(SpiJsonReader jsonRead, String path) throws IOException {
+    return jsonHelp.jsonRead(jsonRead, path, false);
   }
 
   public List<BeanProperty[]> getUniqueProps() {

src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorCacheHelp.java

@@ -4,8 +4,10 @@ import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
 import io.ebean.bean.PersistenceContext;
+import io.ebean.cache.QueryCacheEntry;
 import io.ebean.cache.ServerCache;
 import io.ebeaninternal.api.BeanCacheResult;
+import io.ebeaninternal.api.SpiTransaction;
 import io.ebeaninternal.api.TransactionEventTable.TableIUD;
 import io.ebeaninternal.server.cache.CacheChangeSet;
 import io.ebeaninternal.server.cache.CachedBeanData;
@@ -54,6 +56,7 @@ final class BeanDescriptorCacheHelp<T> {
    * Flag indicating this bean has no relationships.
    */
   private final boolean cacheSharableBeans;
+  private final boolean invalidateQueryCache;
 
   private final Class<?> beanType;
 
@@ -66,6 +69,8 @@ final class BeanDescriptorCacheHelp<T> {
   private final ServerCache naturalKeyCache;
   private final ServerCache queryCache;
 
+  private final boolean noCaching;
+
   /**
    * Set to true if all persist changes need to notify the cache.
    */
@@ -84,6 +89,7 @@ final class BeanDescriptorCacheHelp<T> {
     this.cacheName = beanType.getSimpleName();
     this.cacheManager = cacheManager;
     this.cacheOptions = cacheOptions;
+    this.invalidateQueryCache = cacheOptions.isInvalidateQueryCache();
     this.cacheSharableBeans = cacheSharableBeans;
     this.propertiesOneImported = propertiesOneImported;
     this.naturalKey = cacheOptions.getNaturalKey();
@@ -105,13 +111,14 @@ final class BeanDescriptorCacheHelp<T> {
       this.beanCache = null;
       this.naturalKeyCache = null;
     }
+    this.noCaching = (beanCache == null && queryCache == null);
   }
 
   /**
    * Derive the cache notify flags.
    */
   void deriveNotifyFlags() {
-    cacheNotifyOnAll = (beanCache != null || queryCache != null);
+    cacheNotifyOnAll = (invalidateQueryCache || beanCache != null || queryCache != null);
     cacheNotifyOnDelete = !cacheNotifyOnAll && isNotifyOnDeletes();
 
     if (logger.isDebugEnabled()) {
@@ -129,7 +136,7 @@ final class BeanDescriptorCacheHelp<T> {
    */
   private boolean isNotifyOnDeletes() {
     for (BeanPropertyAssocOne<?> imported : propertiesOneImported) {
-      if (imported.isCacheNotify()) {
+      if (imported.isCacheNotifyRelationship()) {
         return true;
       }
     }
@@ -225,14 +232,14 @@ final class BeanDescriptorCacheHelp<T> {
   /**
    * Put a query result into the query cache.
    */
-  void queryCachePut(Object id, Object queryResult) {
+  void queryCachePut(Object id, QueryCacheEntry entry) {
     if (queryCache == null) {
       throw new IllegalStateException("No query cache enabled on " + desc + ". Need explicit @Cache(enableQueryCache=true)");
     }
     if (queryLog.isDebugEnabled()) {
       queryLog.debug("   PUT {}({})", cacheName, id);
     }
-    queryCache.put(id, queryResult);
+    queryCache.put(id, entry);
   }
 
 
@@ -680,12 +687,12 @@ final class BeanDescriptorCacheHelp<T> {
   /**
    * Remove a bean from the cache given its Id.
    */
-  void beanCacheRemove(Object id) {
+  void beanCacheApplyInvalidate(Collection<Object> ids) {
     if (beanCache != null) {
       if (beanLog.isDebugEnabled()) {
-        beanLog.debug("   REMOVE {}({})", cacheName, id);
+        beanLog.debug("   REMOVE {}({})", cacheName, ids);
       }
-      beanCache.remove(id);
+      beanCache.removeAll(new HashSet<>(ids));
     }
     for (BeanPropertyAssocOne<?> imported : propertiesOneImported) {
       imported.cacheClear();
@@ -719,34 +726,53 @@ final class BeanDescriptorCacheHelp<T> {
     return true;
   }
 
+  void cacheUpdateQuery(boolean update, SpiTransaction transaction) {
+    if (invalidateQueryCache || cacheNotifyOnAll || (!update && cacheNotifyOnDelete)) {
+      transaction.getEvent().add(desc.getBaseTable(), false, update, !update);
+    }
+  }
+
   /**
    * Add appropriate cache changes to support delete by id.
    */
-  void handleDelete(Object id, CacheChangeSet changeSet) {
-    if (beanCache != null) {
-      changeSet.addBeanRemove(desc, id);
+  void persistDeleteIds(Collection<Object> ids, CacheChangeSet changeSet) {
+    if (invalidateQueryCache) {
+     changeSet.addInvalidate(desc);
+    } else {
+      queryCacheClear(changeSet);
+      if (beanCache != null) {
+        changeSet.addBeanRemoveMany(desc, ids);
+      }
+      cacheDeleteImported(true, null, changeSet);
     }
-    cacheDeleteImported(true, null, changeSet);
   }
 
   /**
    * Add appropriate cache changes to support delete bean.
    */
-  void handleDelete(Object id, PersistRequestBean<T> deleteRequest, CacheChangeSet changeSet) {
-    queryCacheClear(changeSet);
-    if (beanCache != null) {
-      changeSet.addBeanRemove(desc, id);
+  void persistDelete(Object id, PersistRequestBean<T> deleteRequest, CacheChangeSet changeSet) {
+    if (invalidateQueryCache) {
+      changeSet.addInvalidate(desc);
+    } else {
+      queryCacheClear(changeSet);
+      if (beanCache != null) {
+        changeSet.addBeanRemove(desc, id);
+      }
+      cacheDeleteImported(true, deleteRequest.getEntityBean(), changeSet);
     }
-    cacheDeleteImported(true, deleteRequest.getEntityBean(), changeSet);
   }
 
   /**
    * Add appropriate cache changes to support insert.
    */
-  void handleInsert(PersistRequestBean<T> insertRequest, CacheChangeSet changeSet) {
-    queryCacheClear(changeSet);
-    cacheDeleteImported(false, insertRequest.getEntityBean(), changeSet);
-    changeSet.addBeanInsert(desc.getBaseTable());
+  void persistInsert(PersistRequestBean<T> insertRequest, CacheChangeSet changeSet) {
+    if (invalidateQueryCache) {
+      changeSet.addInvalidate(desc);
+    } else {
+      queryCacheClear(changeSet);
+      cacheDeleteImported(false, insertRequest.getEntityBean(), changeSet);
+      changeSet.addBeanInsert(desc.getBaseTable());
+    }
   }
 
   private void cacheDeleteImported(boolean clear, EntityBean entityBean, CacheChangeSet changeSet) {
@@ -758,44 +784,54 @@ final class BeanDescriptorCacheHelp<T> {
   /**
    * Add appropriate changes to support update.
    */
-  void handleUpdate(Object id, PersistRequestBean<T> updateRequest, CacheChangeSet changeSet) {
+  void persistUpdate(Object id, PersistRequestBean<T> updateRequest, CacheChangeSet changeSet) {
+    if (invalidateQueryCache) {
+      changeSet.addInvalidate(desc);
 
-    queryCacheClear(changeSet);
+    } else {
+      queryCacheClear(changeSet);
+      if (beanCache == null) {
+        // query caching only
+        return;
+      }
 
-    if (beanCache == null) {
-      // query caching only
-      return;
-    }
-
-    List<BeanPropertyAssocMany<?>> manyCollections = updateRequest.getUpdatedManyCollections();
-    if (manyCollections != null) {
-      for (BeanPropertyAssocMany<?> many : manyCollections) {
-        if (!many.isElementCollection()) {
-          Object details = many.getValue(updateRequest.getEntityBean());
-          CachedManyIds entry = createManyIds(many, details);
-          if (entry != null) {
-            changeSet.addManyPut(desc, many.getName(), id, entry);
+      List<BeanPropertyAssocMany<?>> manyCollections = updateRequest.getUpdatedManyCollections();
+      if (manyCollections != null) {
+        for (BeanPropertyAssocMany<?> many : manyCollections) {
+          if (!many.isElementCollection()) {
+            Object details = many.getValue(updateRequest.getEntityBean());
+            CachedManyIds entry = createManyIds(many, details);
+            if (entry != null) {
+              changeSet.addManyPut(desc, many.getName(), id, entry);
+            }
           }
         }
       }
+      updateRequest.addBeanUpdate(changeSet);
     }
-
-    updateRequest.addBeanUpdate(changeSet);
   }
 
   /**
    * Invalidate parts of cache due to SqlUpdate or external modification etc.
    */
-  void handleBulkUpdate(TableIUD tableIUD) {
+  void persistTableIUD(TableIUD tableIUD, CacheChangeSet changeSet) {
+    if (invalidateQueryCache) {
+      changeSet.addInvalidate(desc);
+      return;
+    }
+    if (noCaching) {
+      return;
+    }
+    changeSet.addInvalidate(desc);
     // inserts don't invalidate the bean cache
     if (tableIUD.isUpdateOrDelete()) {
-      beanCacheClear();
+      changeSet.addClearBean(desc);
     }
     // any change invalidates the query cache
-    queryCacheClear();
+    changeSet.addClearQuery(desc);
     // any change invalidates the collection IDs cache
     for (BeanPropertyAssocOne<?> imported : propertiesOneImported) {
-      imported.cacheClear();
+      imported.cacheClear(changeSet);
     }
   }
 

src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorJsonHelp.java

@@ -3,6 +3,8 @@ package io.ebeaninternal.server.deploy;
 import com.fasterxml.jackson.core.JsonParseException;
 import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import io.ebean.bean.EntityBean;
 import io.ebean.text.json.EJson;
 import io.ebeaninternal.api.json.SpiJsonReader;
@@ -12,18 +14,18 @@ import java.io.IOException;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-public class BeanDescriptorJsonHelp<T> {
+class BeanDescriptorJsonHelp<T> {
 
   private final BeanDescriptor<T> desc;
 
   private final InheritInfo inheritInfo;
 
-  public BeanDescriptorJsonHelp(BeanDescriptor<T> desc) {
+  BeanDescriptorJsonHelp(BeanDescriptor<T> desc) {
     this.desc = desc;
     this.inheritInfo = desc.inheritInfo;
   }
 
-  public void jsonWrite(SpiJsonWriter writeJson, EntityBean bean, String key) throws IOException {
+  void jsonWrite(SpiJsonWriter writeJson, EntityBean bean, String key) throws IOException {
 
     writeJson.writeStartObject(key);
 
@@ -42,13 +44,11 @@ public class BeanDescriptorJsonHelp<T> {
     writeJson.writeEndObject();
   }
 
-  protected void jsonWriteProperties(SpiJsonWriter writeJson, EntityBean bean) throws IOException {
-
+  void jsonWriteProperties(SpiJsonWriter writeJson, EntityBean bean) {
     writeJson.writeBean(desc, bean);
   }
 
-  public void jsonWriteDirty(SpiJsonWriter writeJson, EntityBean bean, boolean[] dirtyProps) throws IOException {
-
+  void jsonWriteDirty(SpiJsonWriter writeJson, EntityBean bean, boolean[] dirtyProps) throws IOException {
     if (inheritInfo == null) {
       jsonWriteDirtyProperties(writeJson, bean, dirtyProps);
     } else {
@@ -56,7 +56,7 @@ public class BeanDescriptorJsonHelp<T> {
     }
   }
 
-  protected void jsonWriteDirtyProperties(SpiJsonWriter writeJson, EntityBean bean, boolean[] dirtyProps) throws IOException {
+  void jsonWriteDirtyProperties(SpiJsonWriter writeJson, EntityBean bean, boolean[] dirtyProps) throws IOException {
 
     writeJson.writeStartObject(null);
     // render the dirty properties
@@ -70,7 +70,7 @@ public class BeanDescriptorJsonHelp<T> {
   }
 
   @SuppressWarnings("unchecked")
-  public T jsonRead(SpiJsonReader jsonRead, String path) throws IOException {
+  T jsonRead(SpiJsonReader jsonRead, String path, boolean withInheritance) throws IOException {
 
     JsonParser parser = jsonRead.getParser();
     //noinspection StatementWithEmptyBody
@@ -87,43 +87,39 @@ public class BeanDescriptorJsonHelp<T> {
       }
     }
 
-    if (desc.inheritInfo == null) {
+    if (desc.inheritInfo == null || !withInheritance) {
       return jsonReadObject(jsonRead, path);
     }
 
+    ObjectNode node = jsonRead.getObjectMapper().readTree(parser);
+    if (node.isNull()) {
+      return null;
+    }
+    JsonParser newParser = node.traverse();
+    SpiJsonReader newReader = jsonRead.forJson(newParser, false);
+
     // check for the discriminator value to determine the correct sub type
     String discColumn = inheritInfo.getRoot().getDiscriminatorColumn();
-
-    if (parser.nextToken() != JsonToken.FIELD_NAME) {
-      String msg = "Error reading inheritance discriminator - expected [" + discColumn + "] but no json key?";
-      throw new JsonParseException(parser, msg, parser.getCurrentLocation());
-    }
-
-    String propName = parser.getCurrentName();
-    if (!propName.equalsIgnoreCase(discColumn)) {
-      // just try to assume this is the correct bean type in the inheritance
-      BeanProperty property = desc.getBeanProperty(propName);
-      if (property != null) {
-        EntityBean bean = desc.createEntityBean();
-        property.jsonRead(jsonRead, bean);
-        return jsonReadProperties(jsonRead, bean, path);
+    JsonNode discNode = node.get(discColumn);
+    if (discNode == null || discNode.isNull()) {
+      if (!desc.isAbstractType()) {
+        return desc.jsonReadObject(newReader, path);
       }
-      String msg = "Error reading inheritance discriminator, expected property [" + discColumn + "] but got [" + propName + "] ?";
-      throw new JsonParseException(parser, msg, parser.getCurrentLocation());
+      String msg = "Error reading inheritance discriminator - expected [" + discColumn + "] but no json key?";
+      throw new JsonParseException(newParser, msg, parser.getCurrentLocation());
     }
 
-    String discValue = parser.nextTextValue();
-    return (T) inheritInfo.readType(discValue).desc().jsonReadObject(jsonRead, path);
+    return (T) inheritInfo.readType(discNode.asText()).desc().jsonReadObject(newReader, path);
   }
 
-  protected T jsonReadObject(SpiJsonReader readJson, String path) throws IOException {
+  private T jsonReadObject(SpiJsonReader readJson, String path) throws IOException {
 
     EntityBean bean = desc.createEntityBeanForJson();
     return jsonReadProperties(readJson, bean, path);
   }
 
   @SuppressWarnings("unchecked")
-  protected T jsonReadProperties(SpiJsonReader readJson, EntityBean bean, String path) throws IOException {
+  private T jsonReadProperties(SpiJsonReader readJson, EntityBean bean, String path) throws IOException {
 
     if (path != null) {
       readJson.pushPath(path);

src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorManager.java

@@ -25,6 +25,7 @@ import io.ebean.util.AnnotationUtil;
 import io.ebeaninternal.api.ConcurrencyMode;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.TransactionEventTable;
+import io.ebeaninternal.server.cache.CacheChangeSet;
 import io.ebeaninternal.server.cache.SpiCacheManager;
 import io.ebeaninternal.server.core.InternString;
 import io.ebeaninternal.server.core.InternalConfiguration;
@@ -447,24 +448,23 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
   }
 
   /**
-   * For SQL based modifications we need to invalidate appropriate parts of the
-   * cache.
+   * For SQL based modifications we need to invalidate appropriate parts of the cache.
    */
-  public void cacheNotify(TransactionEventTable.TableIUD tableIUD) {
+  public void cacheNotify(TransactionEventTable.TableIUD tableIUD, CacheChangeSet changeSet) {
 
     String tableName = tableIUD.getTableName().toLowerCase();
     List<BeanDescriptor<?>> normalBeanTypes = tableToDescMap.get(tableName);
     if (normalBeanTypes != null) {
       // 'normal' entity beans based on a "base table"
       for (BeanDescriptor<?> normalBeanType : normalBeanTypes) {
-        normalBeanType.cacheHandleBulkUpdate(tableIUD);
+        normalBeanType.cachePersistTableIUD(tableIUD, changeSet);
       }
     }
     List<BeanDescriptor<?>> viewBeans = tableToViewDescMap.get(tableName);
     if (viewBeans != null) {
       // entity beans based on a "view"
       for (BeanDescriptor<?> viewBean : viewBeans) {
-        viewBean.cacheHandleBulkUpdate(tableIUD);
+        viewBean.cachePersistTableIUD(tableIUD, changeSet);
       }
     }
   }

src/main/java/io/ebeaninternal/server/deploy/BeanListHelp.java

@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.deploy;
 
-import io.ebean.EbeanServer;
 import io.ebean.Query;
 import io.ebean.Transaction;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.BeanCollectionAdd;
 import io.ebean.bean.EntityBean;
 import io.ebean.common.BeanList;
+import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.json.SpiJsonWriter;
 
 import java.io.IOException;
@@ -64,7 +64,7 @@ public class BeanListHelp<T> extends BaseCollectionHelp<T> {
   }
 
   @Override
-  public void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
+  public void refresh(SpiEbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
 
     BeanList<?> newBeanList = (BeanList<?>) server.findList(query, t);
     refresh(newBeanList, parentBean);

src/main/java/io/ebeaninternal/server/deploy/BeanMapHelp.java

@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.deploy;
 
-import io.ebean.EbeanServer;
 import io.ebean.Query;
 import io.ebean.Transaction;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.BeanCollectionAdd;
 import io.ebean.bean.EntityBean;
 import io.ebean.common.BeanMap;
+import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.json.SpiJsonWriter;
 
 import java.io.IOException;
@@ -124,7 +124,7 @@ public class BeanMapHelp<T> extends BaseCollectionHelp<T> {
   }
 
   @Override
-  public void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
+  public void refresh(SpiEbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
     BeanMap<?, ?> newBeanMap = (BeanMap<?, ?>) server.findMap(query, t);
     refresh(newBeanMap, parentBean);
   }

src/main/java/io/ebeaninternal/server/deploy/BeanPropertyAssocOne.java

@@ -1,6 +1,5 @@
 package io.ebeaninternal.server.deploy;
 
-import io.ebean.EbeanServer;
 import io.ebean.Query;
 import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
@@ -8,6 +7,7 @@ import io.ebean.ValuePair;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.PersistenceContext;
 import io.ebean.util.SplitName;
+import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.SpiQuery;
 import io.ebeaninternal.api.json.SpiJsonReader;
 import io.ebeaninternal.api.json.SpiJsonWriter;
@@ -56,6 +56,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   private String deleteByParentIdInSql;
 
   private BeanPropertyAssocMany<?> relationshipProperty;
+  private boolean cacheNotifyRelationship;
 
   /**
    * Create based on deploy information of an EmbeddedId.
@@ -127,6 +128,13 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     }
   }
 
+  /**
+   * Derive late in lifecycle cache notification on this relationship.
+   */
+  public void initialisePostTarget() {
+    this.cacheNotifyRelationship = isCacheNotifyRelationship();
+  }
+
   /**
    * Return the property value as an entity bean.
    */
@@ -141,25 +149,31 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
   /**
    * Return true if this relationship needs to maintain/update L2 cache.
    */
-  boolean isCacheNotify() {
-    return targetDescriptor.isBeanCaching() && relationshipProperty != null;
+  boolean isCacheNotifyRelationship() {
+    return relationshipProperty != null && targetDescriptor.isBeanCaching();
   }
 
   /**
    * Clear the L2 relationship cache for this property.
    */
   void cacheClear() {
-    if (isCacheNotify()) {
+    if (cacheNotifyRelationship) {
       targetDescriptor.cacheManyPropClear(relationshipProperty.getName());
     }
   }
 
+  void cacheClear(CacheChangeSet changeSet) {
+    if (cacheNotifyRelationship) {
+      changeSet.addManyClear(targetDescriptor, relationshipProperty.getName());
+    }
+  }
+
   /**
    * Clear part of the L2 relationship cache for this property.
    */
   void cacheDelete(boolean clear, EntityBean bean, CacheChangeSet changeSet) {
 
-    if (isCacheNotify()) {
+    if (cacheNotifyRelationship) {
       if (clear) {
         changeSet.addManyClear(targetDescriptor, relationshipProperty.getName());
       } else {
@@ -238,7 +252,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
 
     String rawWhere = deriveWhereParentIdSql(false);
 
-    EbeanServer server = server();
+    SpiEbeanServer server = server();
     Query<?> q = server.find(getPropertyType());
     bindParentIdEq(rawWhere, parentId, q);
     return server.findIds(q, t);
@@ -250,7 +264,7 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> implements STr
     String inClause = targetIdBinder.getIdInValueExpr(false, parentIds.size());
     String expr = rawWhere + inClause;
 
-    EbeanServer server = server();
+    SpiEbeanServer server = server();
     Query<?> q = server.find(getPropertyType());
     bindParentIdsIn(expr, parentIds, q);
 

src/main/java/io/ebeaninternal/server/deploy/BeanSetHelp.java

@@ -1,12 +1,12 @@
 package io.ebeaninternal.server.deploy;
 
-import io.ebean.EbeanServer;
 import io.ebean.Query;
 import io.ebean.Transaction;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.BeanCollectionAdd;
 import io.ebean.bean.EntityBean;
 import io.ebean.common.BeanSet;
+import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.json.SpiJsonWriter;
 
 import java.io.IOException;
@@ -69,7 +69,7 @@ public class BeanSetHelp<T> extends BaseCollectionHelp<T> {
   }
 
   @Override
-  public void refresh(EbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
+  public void refresh(SpiEbeanServer server, Query<?> query, Transaction t, EntityBean parentBean) {
 
     BeanSet<?> newBeanSet = (BeanSet<?>) server.findSet(query, t);
     refresh(newBeanSet, parentBean);

src/main/java/io/ebeaninternal/server/deploy/DeployParser.java

@@ -187,6 +187,6 @@ public abstract class DeployParser {
   }
 
   private boolean isWordStart(char ch) {
-    return Character.isLetter(ch);
+    return Character.isLetter(ch) || ch == UNDERSCORE;
   }
 }

src/main/java/io/ebeaninternal/server/deploy/FormulaPropertyPath.java

@@ -8,7 +8,7 @@ import java.sql.Types;
 
 class FormulaPropertyPath {
 
-  private static final String[] AGG_FUNCTIONS = {"count", "max", "min", "avg"};
+  private static final String[] AGG_FUNCTIONS = {"count", "max", "min", "avg", "sum"};
 
   private static final String DISTINCT_ = "distinct ";
 
@@ -118,12 +118,8 @@ class FormulaPropertyPath {
       }
     }
 
-    String logicalName = (alias == null) ? formula : alias;
-    BeanProperty targetProperty = null;
-    if (alias != null) {
-      targetProperty = descriptor._findBeanProperty(alias);
-    }
-
+    String logicalName = (alias == null) ? internalExpression : alias;
+    BeanProperty targetProperty = descriptor._findBeanProperty(logicalName);
     String parsedAggregation = buildFormula(parsed);
     return new DynamicPropertyAggregationFormula(logicalName, scalarType, parsedAggregation, isAggregate(), targetProperty, alias);
   }

src/main/java/io/ebeaninternal/server/deploy/InheritInfo.java

@@ -151,7 +151,6 @@ public class InheritInfo {
    * Set the descriptor for this node.
    */
   public void setDescriptor(BeanDescriptor<?> descriptor) {
-
     this.descriptor = descriptor;
   }
 

src/main/java/io/ebeaninternal/server/deploy/IntersectionRow.java

@@ -6,6 +6,7 @@ import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.server.core.DefaultSqlUpdate;
 import io.ebeaninternal.server.expression.DefaultExpressionRequest;
 import io.ebeaninternal.server.expression.IdInExpression;
+import io.ebeaninternal.server.persist.DeleteMode;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -72,16 +73,16 @@ public class IntersectionRow {
     return new DefaultSqlUpdate(server, sb.toString(), bindParams);
   }
 
-  public SqlUpdate createDelete(SpiEbeanServer server, boolean softDelete) {
+  public SqlUpdate createDelete(SpiEbeanServer server, DeleteMode deleteMode) {
 
     BindParams bindParams = new BindParams();
 
     StringBuilder sb = new StringBuilder();
-    if (softDelete) {
+    if (deleteMode.isHard()) {
+      sb.append("delete from ").append(tableName);
+    } else {
       sb.append("update ").append(tableName).append(" set ");
       sb.append(targetDescriptor.getSoftDeleteDbSet());
-    } else {
-      sb.append("delete from ").append(tableName);
     }
     sb.append(" where ");
 

src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanDescriptor.java

@@ -440,6 +440,13 @@ public class DeployBeanDescriptor<T> {
     this.inheritInfo = inheritInfo;
   }
 
+  /**
+   * Set that this type invalidates query caches.
+   */
+  public void setInvalidateQueryCache() {
+    this.cacheOptions = CacheOptions.INVALIDATE_QUERY_CACHE;
+  }
+
   /**
    * Enable L2 bean and query caching based on Cache annotation.
    */

src/main/java/io/ebeaninternal/server/deploy/meta/DeployBeanPropertyLists.java

@@ -1,5 +1,6 @@
 package io.ebeaninternal.server.deploy.meta;
 
+import io.ebean.bean.EntityBean;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanDescriptorMap;
 import io.ebeaninternal.server.deploy.BeanProperty;
@@ -11,6 +12,7 @@ import io.ebeaninternal.server.deploy.BeanPropertySimpleCollection;
 import io.ebeaninternal.server.deploy.InheritInfo;
 import io.ebeaninternal.server.deploy.TableJoin;
 import io.ebeaninternal.server.deploy.generatedproperty.GeneratedProperty;
+import io.ebeaninternal.server.properties.BeanPropertySetter;
 import io.ebeaninternal.server.type.ScalarTypeString;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -26,6 +28,8 @@ public class DeployBeanPropertyLists {
 
   private static final Logger logger = LoggerFactory.getLogger(DeployBeanPropertyLists.class);
 
+  private static final NoopSetter NOOP_SETTER = new NoopSetter();
+
   private BeanProperty versionProperty;
 
   private BeanProperty unmappedJson;
@@ -100,6 +104,7 @@ public class DeployBeanPropertyLists {
       discDeployProp.setDiscriminator();
       discDeployProp.setName(discriminatorColumn);
       discDeployProp.setDbColumn(discriminatorColumn);
+      discDeployProp.setSetter(NOOP_SETTER);
 
       // only register it in the propertyMap. This might not be used if
       // an explicit property is mapped to the discriminator on the bean
@@ -491,4 +496,17 @@ public class DeployBeanPropertyLists {
 
     return new BeanProperty(desc, deployProp);
   }
+
+  private static class NoopSetter implements BeanPropertySetter {
+
+    @Override
+    public void set(EntityBean bean, Object value) {
+      // do nothing
+    }
+
+    @Override
+    public void setIntercept(EntityBean bean, Object value) {
+      // do nothing
+    }
+  }
 }

src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationAssocManys.java

@@ -28,6 +28,7 @@ import javax.persistence.CascadeType;
 import javax.persistence.CollectionTable;
 import javax.persistence.Column;
 import javax.persistence.ElementCollection;
+import javax.persistence.EnumType;
 import javax.persistence.JoinColumn;
 import javax.persistence.JoinTable;
 import javax.persistence.ManyToMany;
@@ -245,6 +246,10 @@ class AnnotationAssocManys extends AnnotationParser {
     }
 
     ScalarType<?> valueScalarType = util.getTypeManager().getScalarType(elementType);
+    if (valueScalarType == null && elementType.isEnum()) {
+      Class<? extends Enum<?>> enumClass = (Class<? extends Enum<?>>)elementType;
+      valueScalarType = util.getTypeManager().createEnumScalarType(enumClass, EnumType.STRING);
+    }
 
     boolean scalar = true;
     if (valueScalarType == null) {
@@ -275,6 +280,10 @@ class AnnotationAssocManys extends AnnotationParser {
   }
 
   private void setElementProperty(DeployBeanProperty elementProp, String name, String dbColumn, int sortOrder) {
+
+    if (dbColumn == null) {
+      dbColumn = "value";
+    }
     elementProp.setName(name);
     elementProp.setDbColumn(dbColumn);
     elementProp.setNullable(false);

src/main/java/io/ebeaninternal/server/deploy/parse/AnnotationClass.java

@@ -7,6 +7,7 @@ import io.ebean.annotation.Draftable;
 import io.ebean.annotation.DraftableElement;
 import io.ebean.annotation.History;
 import io.ebean.annotation.Index;
+import io.ebean.annotation.InvalidateQueryCache;
 import io.ebean.annotation.ReadAudit;
 import io.ebean.annotation.UpdateMode;
 import io.ebean.annotation.View;
@@ -181,9 +182,16 @@ public class AnnotationClass extends AnnotationParser {
       descriptor.setUpdateChangesOnly(updateMode.updateChangesOnly());
     }
 
-    Cache cache = AnnotationUtil.findAnnotationRecursive(cls, Cache.class);
-    if (cache != null && !disableL2Cache) {
-      descriptor.setCache(cache);
+    if (!disableL2Cache) {
+      Cache cache = AnnotationUtil.findAnnotationRecursive(cls, Cache.class);
+      if (cache != null) {
+        descriptor.setCache(cache);
+      } else {
+        InvalidateQueryCache invalidateQueryCache = AnnotationUtil.findAnnotationRecursive(cls, InvalidateQueryCache.class);
+        if (invalidateQueryCache != null) {
+          descriptor.setInvalidateQueryCache();
+        }
+      }
     }
 
     Set<NamedQuery> namedQueries = AnnotationUtil.findAnnotationsRecursive(cls, NamedQuery.class);

src/main/java/io/ebeaninternal/server/expression/DefaultExpressionList.java

@@ -2,6 +2,7 @@ package io.ebeaninternal.server.expression;
 
 import io.ebean.CacheMode;
 import io.ebean.CountDistinctOrder;
+import io.ebean.DtoQuery;
 import io.ebean.Expression;
 import io.ebean.ExpressionFactory;
 import io.ebean.ExpressionList;
@@ -294,6 +295,11 @@ public class DefaultExpressionList<T> implements SpiExpressionList<T> {
     return query.asDraft();
   }
 
+  @Override
+  public <D> DtoQuery<D> asDto(Class<D> dtoClass) {
+    return query.asDto(dtoClass);
+  }
+
   @Override
   public Query<T> setIncludeSoftDeletes() {
     return query.setIncludeSoftDeletes();
@@ -705,6 +711,12 @@ public class DefaultExpressionList<T> implements SpiExpressionList<T> {
     return this;
   }
 
+  @Override
+  public ExpressionList<T> bitwiseNot(String propertyName, long flags) {
+    add(expr.bitwiseAnd(propertyName, flags, 0));
+    return this;
+  }
+
   @Override
   public ExpressionList<T> bitwiseAll(String propertyName, long flags) {
     add(expr.bitwiseAll(propertyName, flags));

src/main/java/io/ebeaninternal/server/expression/JunctionExpression.java

@@ -2,6 +2,7 @@ package io.ebeaninternal.server.expression;
 
 import io.ebean.CacheMode;
 import io.ebean.CountDistinctOrder;
+import io.ebean.DtoQuery;
 import io.ebean.Expression;
 import io.ebean.ExpressionList;
 import io.ebean.FetchPath;
@@ -331,6 +332,11 @@ class JunctionExpression<T> implements SpiJunction<T>, SpiExpression, Expression
     return exprList.asDraft();
   }
 
+  @Override
+  public <D> DtoQuery<D> asDto(Class<D> dtoClass) {
+    return exprList.asDto(dtoClass);
+  }
+
   @Override
   public Query<T> setIncludeSoftDeletes() {
     return exprList.setIncludeSoftDeletes();
@@ -548,6 +554,11 @@ class JunctionExpression<T> implements SpiJunction<T>, SpiExpression, Expression
     return exprList.bitwiseAnd(propertyName, flags, match);
   }
 
+  @Override
+  public ExpressionList<T> bitwiseNot(String propertyName, long flags) {
+    return exprList.bitwiseNot(propertyName, flags);
+  }
+
   @Override
   public ExpressionList<T> ge(String propertyName, Object value) {
     return exprList.ge(propertyName, value);

src/main/java/io/ebeaninternal/server/expression/LogicExpression.java

@@ -23,7 +23,7 @@ abstract class LogicExpression implements SpiExpression {
   static class And extends LogicExpression {
 
     And(Expression expOne, Expression expTwo) {
-      super(AND, expOne, expTwo);
+      super(true, expOne, expTwo);
     }
 
     @Override
@@ -36,7 +36,7 @@ abstract class LogicExpression implements SpiExpression {
   static class Or extends LogicExpression {
 
     Or(Expression expOne, Expression expTwo) {
-      super(OR, expOne, expTwo);
+      super(false, expOne, expTwo);
     }
 
     @Override
@@ -45,14 +45,14 @@ abstract class LogicExpression implements SpiExpression {
     }
   }
 
-  protected SpiExpression expOne;
+  SpiExpression expOne;
 
-  protected SpiExpression expTwo;
+  SpiExpression expTwo;
 
-  private final String joinType;
+  private final boolean conjunction;
 
-  LogicExpression(String joinType, Expression expOne, Expression expTwo) {
-    this.joinType = joinType;
+  LogicExpression(boolean conjunction, Expression expOne, Expression expTwo) {
+    this.conjunction = conjunction;
     this.expOne = (SpiExpression) expOne;
     this.expTwo = (SpiExpression) expTwo;
   }
@@ -71,7 +71,6 @@ abstract class LogicExpression implements SpiExpression {
   @Override
   public void writeDocQuery(DocQueryContext context) throws IOException {
 
-    boolean conjunction = joinType.equals(AND);
     context.startBool(conjunction ? Junction.Type.AND : Junction.Type.OR);
     expOne.writeDocQuery(context);
     expTwo.writeDocQuery(context);
@@ -107,8 +106,19 @@ abstract class LogicExpression implements SpiExpression {
 
   @Override
   public void containsMany(BeanDescriptor<?> desc, ManyWhereJoins manyWhereJoin) {
+
+    // get the current state for 'require outer joins'
+    boolean parentOuterJoins = manyWhereJoin.isRequireOuterJoins();
+    if (!conjunction) {
+      // turn on outer joins required for disjunction expressions
+      manyWhereJoin.setRequireOuterJoins(true);
+    }
     expOne.containsMany(desc, manyWhereJoin);
     expTwo.containsMany(desc, manyWhereJoin);
+    if (!conjunction && !parentOuterJoins) {
+      // restore state to not forcing outer joins
+      manyWhereJoin.setRequireOuterJoins(false);
+    }
   }
 
   @Override
@@ -128,7 +138,7 @@ abstract class LogicExpression implements SpiExpression {
 
     request.append("(");
     expOne.addSql(request);
-    request.append(joinType);
+    request.append(conjunction ? AND : OR);
     expTwo.addSql(request);
     request.append(") ");
   }
@@ -144,7 +154,7 @@ abstract class LogicExpression implements SpiExpression {
    */
   @Override
   public void queryPlanHash(StringBuilder builder) {
-    builder.append("Logic").append(joinType).append("[");
+    builder.append("Logic").append(conjunction ? AND : OR).append("[");
     expOne.queryPlanHash(builder);
     builder.append(",");
     expTwo.queryPlanHash(builder);

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

@@ -142,7 +142,7 @@ public class BatchedBeanHolder {
         return inserts.size();
 
       case UPDATE:
-      case SOFT_DELETE:
+      case DELETE_SOFT:
         if (updates == null) {
           updates = new ArrayList<>();
         }

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

@@ -2,11 +2,16 @@ package io.ebeaninternal.server.persist;
 
 import io.ebeaninternal.api.SpiTransaction;
 import io.ebeaninternal.api.SpiProfileTransactionEvent;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import java.io.IOException;
+import java.io.InputStream;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * A batched statement that is held in BatchedPstmtHolder. It has a list of
@@ -17,6 +22,8 @@ import java.util.ArrayList;
  */
 public class BatchedPstmt implements SpiProfileTransactionEvent {
 
+  private static final Logger log = LoggerFactory.getLogger(BatchedPstmt.class);
+
   /**
    * The underlying statement.
    */
@@ -40,6 +47,8 @@ public class BatchedPstmt implements SpiProfileTransactionEvent {
 
   private int[] results;
 
+  private List<InputStream> inputStreams;
+
   /**
    * Create with a given statement.
    */
@@ -117,16 +126,19 @@ public class BatchedPstmt implements SpiProfileTransactionEvent {
   }
 
   private void executeAndCheckRowCounts() throws SQLException {
+    try {
+      results = pstmt.executeBatch();
+      if (results.length != list.size()) {
+        String s = "results array error " + results.length + " " + list.size();
+        throw new SQLException(s);
+      }
 
-    results = pstmt.executeBatch();
-    if (results.length != list.size()) {
-      String s = "results array error " + results.length + " " + list.size();
-      throw new SQLException(s);
-    }
-
-    // check for concurrency exceptions...
-    for (int i = 0; i < results.length; i++) {
-      list.get(i).checkRowCount(results[i]);
+      // check for concurrency exceptions...
+      for (int i = 0; i < results.length; i++) {
+        list.get(i).checkRowCount(results[i]);
+      }
+    } finally {
+      closeInputStreams();
     }
   }
 
@@ -148,4 +160,23 @@ public class BatchedPstmt implements SpiProfileTransactionEvent {
   public int[] getResults() {
     return results;
   }
+
+  /**
+   * Register any inputStreams that should be closed after execution.
+   */
+  public void registerInputStreams(List<InputStream> inputStreams) {
+    this.inputStreams = inputStreams;
+  }
+
+  private void closeInputStreams() {
+    if (inputStreams != null) {
+      for (InputStream inputStream : inputStreams) {
+        try {
+          inputStream.close();
+        } catch (IOException e) {
+          log.warn("Error closing inputStream ", e);
+        }
+      }
+    }
+  }
 }

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

@@ -39,6 +39,15 @@ public class BatchedPstmtHolder {
    * This will return null if no matching PreparedStatement is found.
    */
   public PreparedStatement getStmt(String stmtKey, BatchPostExecute postExecute) {
+    BatchedPstmt batchedPstmt = getBatchedPstmt(stmtKey, postExecute);
+    return (batchedPstmt == null) ? null : batchedPstmt.getStatement();
+  }
+
+  /**
+   * Return the BatchedPstmt that holds the batched statement.
+   */
+  public BatchedPstmt getBatchedPstmt(String stmtKey, BatchPostExecute postExecute) {
+
     BatchedPstmt bs = stmtMap.get(stmtKey);
     if (bs == null) {
       // the PreparedStatement has need been created
@@ -53,7 +62,7 @@ public class BatchedPstmtHolder {
     if (bsSize > maxSize) {
       maxSize = bsSize;
     }
-    return bs.getStatement();
+    return bs;
   }
 
   /**

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

@@ -357,9 +357,8 @@ public final class DefaultPersister implements Persister {
   /**
    * Recursively delete the bean. This calls back to the EbeanServer.
    */
-  private int deleteRecurse(EntityBean detailBean, Transaction t, boolean softDelete) {
-    Type deleteType = softDelete ? Type.SOFT_DELETE : Type.DELETE_PERMANENT;
-    return deleteRequest(createRequest(detailBean, t, deleteType));
+  private int deleteRecurse(EntityBean detailBean, Transaction t, DeleteMode deleteMode) {
+    return deleteRequest(createRequest(detailBean, t, deleteMode.persistType()));
   }
 
   @Override
@@ -605,13 +604,13 @@ public final class DefaultPersister implements Persister {
     }
   }
 
-  private void deleteList(List<?> beanList, SpiTransaction t, boolean softDelete, boolean children) {
+  private void deleteList(List<?> beanList, SpiTransaction t, DeleteMode deleteMode, boolean children) {
     if (children) {
       t.depth(-1);
       t.checkBatchEscalationOnCollection();
     }
     for (Object aBeanList : beanList) {
-      deleteRecurse((EntityBean) aBeanList, t, softDelete);
+      deleteRecurse((EntityBean) aBeanList, t, deleteMode);
     }
     if (children) {
       t.flushBatchOnCollection();
@@ -630,9 +629,9 @@ public final class DefaultPersister implements Persister {
     }
 
     BeanDescriptor<?> descriptor = beanDescriptorManager.getBeanDescriptor(beanType);
-    boolean softDelete = !permanent && descriptor.isSoftDelete();
+    DeleteMode deleteMode = (permanent || !descriptor.isSoftDelete()) ? DeleteMode.HARD : DeleteMode.SOFT;
     if (descriptor.isMultiTenant()) {
-      return deleteAsBeans(ids, transaction, permanent, descriptor);
+      return deleteAsBeans(ids, transaction, deleteMode, descriptor);
     }
 
     ArrayList<Object> idList = new ArrayList<>(ids.size());
@@ -641,19 +640,19 @@ public final class DefaultPersister implements Persister {
       idList.add(descriptor.convertId(id));
     }
 
-    return delete(descriptor, null, idList, transaction, softDelete);
+    return delete(descriptor, null, idList, transaction, deleteMode);
   }
 
   /**
    * Convert delete by Ids into delete many beans.
    */
-  private int deleteAsBeans(Collection<?> ids, Transaction transaction, boolean permanent, BeanDescriptor<?> descriptor) {
+  private int deleteAsBeans(Collection<?> ids, Transaction transaction, DeleteMode deleteMode, BeanDescriptor<?> descriptor) {
     // convert to a delete by bean
     int total = 0;
     for (Object id : ids) {
       EntityBean bean = descriptor.createEntityBean();
       descriptor.convertSetId(id, bean);
-      int rowCount = deleteRecurse(bean, transaction, permanent);
+      int rowCount = deleteRecurse(bean, transaction, deleteMode);
       if (rowCount == -1) {
         total = -1;
       } else if (total != -1) {
@@ -677,14 +676,20 @@ public final class DefaultPersister implements Persister {
     }
 
     id = descriptor.convertId(id);
-    boolean softDelete = !permanent && descriptor.isSoftDelete();
-    return delete(descriptor, id, null, transaction, softDelete);
+    DeleteMode deleteMode = (permanent || !descriptor.isSoftDelete()) ? DeleteMode.HARD : DeleteMode.SOFT;
+    return delete(descriptor, id, null, transaction, deleteMode);
+  }
+
+  @Override
+  public int deleteByIds(BeanDescriptor<?> descriptor, List<Object> idList, Transaction transaction, boolean permanent) {
+    DeleteMode deleteMode = (permanent || !descriptor.isSoftDelete()) ? DeleteMode.HARD : DeleteMode.SOFT;
+    return delete(descriptor, null, idList, transaction, deleteMode);
   }
 
   /**
    * Delete by Id or a List of Id's.
    */
-  private int delete(BeanDescriptor<?> descriptor, Object id, List<Object> idList, Transaction transaction, boolean softDelete) {
+  private int delete(BeanDescriptor<?> descriptor, Object id, List<Object> idList, Transaction transaction, DeleteMode deleteMode) {
 
     SpiTransaction t = (SpiTransaction) transaction;
     if (t.isPersistCascade()) {
@@ -693,14 +698,14 @@ public final class DefaultPersister implements Persister {
         // We actually need to execute a query to get the foreign key values
         // as they are required for the delete cascade. Query back just the
         // Id and the appropriate foreign key values
-        Query<?> q = deleteRequiresQuery(descriptor, propImportDelete, softDelete);
+        Query<?> q = deleteRequiresQuery(descriptor, propImportDelete, deleteMode);
         if (idList != null) {
           q.where().idIn(idList);
           if (t.isLogSummary()) {
             t.logSummary("-- DeleteById of " + descriptor.getName() + " ids[" + idList + "] requires fetch of foreign key values");
           }
           List<?> beanList = server.findList(q, t);
-          deleteList(beanList, t, softDelete, false);
+          deleteList(beanList, t, deleteMode, false);
           return beanList.size();
 
         } else {
@@ -712,7 +717,7 @@ public final class DefaultPersister implements Persister {
           if (bean == null) {
             return 0;
           } else {
-            return deleteRecurse(bean, t, softDelete);
+            return deleteRecurse(bean, t, deleteMode);
           }
         }
       }
@@ -724,14 +729,14 @@ public final class DefaultPersister implements Persister {
       for (BeanPropertyAssocOne<?> expOne : expOnes) {
         BeanDescriptor<?> targetDesc = expOne.getTargetDescriptor();
         // only cascade soft deletes when supported by target
-        if (!softDelete || targetDesc.isSoftDelete()) {
-          if (!softDelete && targetDesc.isDeleteByStatement()) {
+        if (deleteMode.isHard() || targetDesc.isSoftDelete()) {
+          if (deleteMode.isHard() && targetDesc.isDeleteByStatement()) {
             SqlUpdate sqlDelete = expOne.deleteByParentId(id, idList);
             executeSqlUpdate(sqlDelete, t);
           } else {
             List<Object> childIds = expOne.findIdsByParentId(id, idList, t);
             if (childIds != null && !childIds.isEmpty()) {
-              deleteChildrenById(t, targetDesc, childIds, softDelete);
+              deleteChildrenById(t, targetDesc, childIds, deleteMode);
             }
           }
         }
@@ -740,25 +745,27 @@ public final class DefaultPersister implements Persister {
       // OneToMany's with delete cascade
       BeanPropertyAssocMany<?>[] manys = descriptor.propertiesManyDelete();
       for (BeanPropertyAssocMany<?> many : manys) {
-        BeanDescriptor<?> targetDesc = many.getTargetDescriptor();
-        // only cascade soft deletes when supported by target
-        if (!softDelete || targetDesc.isSoftDelete()) {
-          if (!softDelete && targetDesc.isDeleteByStatement()) {
-            // we can just delete children with a single statement
-            SqlUpdate sqlDelete = many.deleteByParentId(id, idList);
-            executeSqlUpdate(sqlDelete, t);
-          } else {
-            // we need to fetch the Id's to delete (recurse or notify L2 cache)
-            List<Object> childIds = many.findIdsByParentId(id, idList, t, null);
-            if (!childIds.isEmpty()) {
-              delete(targetDesc, null, childIds, t, softDelete);
+        if (!many.isManyToMany()) {
+          BeanDescriptor<?> targetDesc = many.getTargetDescriptor();
+          // only cascade soft deletes when supported by target
+          if (deleteMode.isHard() || targetDesc.isSoftDelete()) {
+            if (deleteMode.isHard() && targetDesc.isDeleteByStatement()) {
+              // we can just delete children with a single statement
+              SqlUpdate sqlDelete = many.deleteByParentId(id, idList);
+              executeSqlUpdate(sqlDelete, t);
+            } else {
+              // we need to fetch the Id's to delete (recurse or notify L2 cache)
+              List<Object> childIds = many.findIdsByParentId(id, idList, t, null);
+              if (!childIds.isEmpty()) {
+                delete(targetDesc, null, childIds, t, deleteMode);
+              }
             }
           }
         }
       }
     }
 
-    if (!softDelete) {
+    if (deleteMode.isHard()) {
       // ManyToMany's ... delete from intersection table
       BeanPropertyAssocMany<?>[] manys = descriptor.propertiesManyToMany();
       for (BeanPropertyAssocMany<?> many : manys) {
@@ -771,7 +778,7 @@ public final class DefaultPersister implements Persister {
     }
 
     // delete the bean(s)
-    SqlUpdate deleteById = descriptor.deleteById(id, idList, softDelete);
+    SqlUpdate deleteById = descriptor.deleteById(id, idList, deleteMode);
     if (t.isLogSummary()) {
       if (idList != null) {
         t.logSummary("-- Deleting " + descriptor.getName() + " Ids: " + idList);
@@ -822,7 +829,7 @@ public final class DefaultPersister implements Persister {
    * We need to create and execute a query to get the foreign key values as
    * the delete cascades to them (foreign keys).
    */
-  private Query<?> deleteRequiresQuery(BeanDescriptor<?> desc, BeanPropertyAssocOne<?>[] propImportDelete, boolean softDelete) {
+  private Query<?> deleteRequiresQuery(BeanDescriptor<?> desc, BeanPropertyAssocOne<?>[] propImportDelete, DeleteMode deleteMode) {
 
     Query<?> q = server.createQuery(desc.getBeanType());
     StringBuilder sb = new StringBuilder(30);
@@ -831,7 +838,7 @@ public final class DefaultPersister implements Persister {
     }
     q.setAutoTune(false);
     q.select(sb.toString());
-    if (!softDelete) {
+    if (deleteMode.isHard() && desc.isSoftDelete()) {
       // hard delete so we want this query to include logically deleted rows (if any)
       q.setIncludeSoftDeletes();
     }
@@ -956,7 +963,7 @@ public final class DefaultPersister implements Persister {
 
     BeanDescriptor<?> desc = request.getBeanDescriptor();
     EntityBean parentBean = request.getEntityBean();
-    boolean softDelete = request.isSoftDelete();
+    DeleteMode deleteMode = request.deleteMode();
 
     BeanPropertyAssocOne<?>[] expOnes = desc.propertiesOneExportedDelete();
     if (expOnes.length > 0) {
@@ -964,11 +971,11 @@ public final class DefaultPersister implements Persister {
       DeleteUnloadedForeignKeys unloaded = null;
       for (BeanPropertyAssocOne<?> prop : expOnes) {
         // for soft delete check cascade type also supports soft delete
-        if (!softDelete || prop.isTargetSoftDelete()) {
+        if (deleteMode.isHard() || prop.isTargetSoftDelete()) {
           if (request.isLoadedProperty(prop)) {
             Object detailBean = prop.getValue(parentBean);
             if (detailBean != null) {
-              deleteRecurse((EntityBean) detailBean, t, softDelete);
+              deleteRecurse((EntityBean) detailBean, t, deleteMode);
             }
           } else {
             if (unloaded == null) {
@@ -987,7 +994,7 @@ public final class DefaultPersister implements Persister {
     // Many's with delete cascade
     for (BeanPropertyAssocMany<?> many : desc.propertiesManyDelete()) {
       if (many.hasJoinTable()) {
-        if (!softDelete) {
+        if (deleteMode.isHard()) {
           // delete associated rows from intersection table (but not during soft delete)
           deleteAssocManyIntersection(parentBean, many, t, request.isPublish());
         }
@@ -996,7 +1003,7 @@ public final class DefaultPersister implements Persister {
         if (ModifyListenMode.REMOVALS == many.getModifyListenMode()) {
           // PrivateOwned ...
           // if soft delete then check target also supports soft delete
-          if (!softDelete || many.isTargetSoftDelete()) {
+          if (deleteMode.isHard() || many.isTargetSoftDelete()) {
             Object details = many.getValue(parentBean);
             if (details instanceof BeanCollection<?>) {
               Set<?> modifyRemovals = ((BeanCollection<?>) details).getModifyRemovals();
@@ -1006,7 +1013,7 @@ public final class DefaultPersister implements Persister {
                 for (Object detail : modifyRemovals) {
                   EntityBean detailBean = (EntityBean) detail;
                   if (many.hasId(detailBean)) {
-                    deleteRecurse(detailBean, t, softDelete);
+                    deleteRecurse(detailBean, t, deleteMode);
                   }
                 }
               }
@@ -1014,7 +1021,7 @@ public final class DefaultPersister implements Persister {
           }
         }
 
-        deleteManyDetails(t, desc, parentBean, many, null, softDelete);
+        deleteManyDetails(t, desc, parentBean, many, null, deleteMode);
       }
     }
 
@@ -1031,16 +1038,16 @@ public final class DefaultPersister implements Persister {
    * </p>
    */
   void deleteManyDetails(SpiTransaction t, BeanDescriptor<?> desc, EntityBean parentBean,
-                         BeanPropertyAssocMany<?> many, List<Object> excludeDetailIds, boolean softDelete) {
+                         BeanPropertyAssocMany<?> many, List<Object> excludeDetailIds, DeleteMode deleteMode) {
 
     if (many.getCascadeInfo().isDelete()) {
       // cascade delete the beans in the collection
       BeanDescriptor<?> targetDesc = many.getTargetDescriptor();
-      if (!softDelete || targetDesc.isSoftDelete()) {
+      if (deleteMode.isHard() || targetDesc.isSoftDelete()) {
         if (targetDesc.isDeleteByStatement()) {
           // Just delete all the children with one statement
           IntersectionRow intRow = many.buildManyDeleteChildren(parentBean, excludeDetailIds);
-          SqlUpdate sqlDelete = intRow.createDelete(server, softDelete);
+          SqlUpdate sqlDelete = intRow.createDelete(server, deleteMode);
           executeSqlUpdate(sqlDelete, t);
 
         } else {
@@ -1048,7 +1055,7 @@ public final class DefaultPersister implements Persister {
           Object parentId = desc.getId(parentBean);
           List<Object> idsByParentId = many.findIdsByParentId(parentId, null, t, excludeDetailIds);
           if (!idsByParentId.isEmpty()) {
-            deleteChildrenById(t, targetDesc, idsByParentId, softDelete);
+            deleteChildrenById(t, targetDesc, idsByParentId, deleteMode);
           }
         }
       }
@@ -1060,7 +1067,7 @@ public final class DefaultPersister implements Persister {
    * <p>
    * Will use delete by object if the child entity has manyToMany relationships.
    */
-  private void deleteChildrenById(SpiTransaction t, BeanDescriptor<?> targetDesc, List<Object> childIds, boolean softDelete) {
+  private void deleteChildrenById(SpiTransaction t, BeanDescriptor<?> targetDesc, List<Object> childIds, DeleteMode deleteMode) {
 
     if (!targetDesc.isDeleteByBulk()) {
       // convert into a list of reference objects and perform delete by object
@@ -1068,11 +1075,11 @@ public final class DefaultPersister implements Persister {
       for (Object id : childIds) {
         refList.add(targetDesc.createReference(id, null));
       }
-      deleteList(refList, t, softDelete, true);
+      deleteList(refList, t, deleteMode, true);
 
     } else {
       // perform delete by statement if possible
-      delete(targetDesc, null, childIds, t, softDelete);
+      delete(targetDesc, null, childIds, t, deleteMode);
     }
   }
 
@@ -1137,16 +1144,16 @@ public final class DefaultPersister implements Persister {
    */
   private void deleteAssocOne(PersistRequestBean<?> request) {
 
-    boolean softDelete = request.isSoftDelete();
+    DeleteMode deleteMode = request.deleteMode();
 
     for (BeanPropertyAssocOne<?> prop : request.getBeanDescriptor().propertiesOneImportedDelete()) {
-      if (!softDelete || prop.isTargetSoftDelete()) {
+      if (deleteMode.isHard() || prop.isTargetSoftDelete()) {
         if (request.isLoadedProperty(prop)) {
           Object detailBean = prop.getValue(request.getEntityBean());
           if (detailBean != null) {
             EntityBean detail = (EntityBean) detailBean;
             if (prop.hasId(detail)) {
-              deleteRecurse(detail, request.getTransaction(), request.isSoftDelete());
+              deleteRecurse(detail, request.getTransaction(), deleteMode);
             }
           }
         }
@@ -1245,7 +1252,7 @@ public final class DefaultPersister implements Persister {
       type = Type.DELETE;
     } else if (type == Type.DELETE && mgr.getBeanDescriptor().isSoftDelete()) {
       // automatically convert to soft delete for types that support it
-      type = Type.SOFT_DELETE;
+      type = Type.DELETE_SOFT;
     }
 
     return new PersistRequestBean(server, bean, parentBean, mgr, (SpiTransaction) t, persistExecute, type, flags);

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

@@ -0,0 +1,38 @@
+package io.ebeaninternal.server.persist;
+
+import io.ebeaninternal.server.core.PersistRequest;
+
+/**
+ * The delete mode of the persistence request. The mode is determined at the beginning of the request
+ * as being a Hard or Soft delete based and then the mode is used for that request and any cascading.
+ */
+public enum DeleteMode {
+
+  /**
+   * Soft/logical delete.
+   */
+  SOFT(PersistRequest.Type.DELETE_SOFT, false),
+
+  /**
+   * Hard/permanent delete.
+   */
+  HARD(PersistRequest.Type.DELETE_PERMANENT, true);
+
+  private boolean hard;
+
+  private PersistRequest.Type persistType;
+
+  DeleteMode(PersistRequest.Type persistType, boolean hard) {
+    this.persistType = persistType;
+    this.hard = hard;
+  }
+
+  public PersistRequest.Type persistType() {
+    return persistType;
+  }
+
+  public boolean isHard() {
+    return hard;
+  }
+
+}

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

@@ -33,6 +33,7 @@ class SaveManyBeans extends SaveManyBase {
   private final BeanDescriptor<?> targetDescriptor;
   private final boolean isMap;
   private final boolean saveRecurseSkippable;
+  private final DeleteMode deleteMode;
 
   private Collection<?> collection;
   private DefaultPersister persister;
@@ -47,6 +48,7 @@ class SaveManyBeans extends SaveManyBase {
     this.targetDescriptor = many.getTargetDescriptor();
     this.isMap = many.getManyType().isMap();
     this.saveRecurseSkippable = many.isSaveRecurseSkippable();
+    this.deleteMode = targetDescriptor.isSoftDelete() ? DeleteMode.SOFT : DeleteMode.HARD;
   }
 
   @Override
@@ -58,7 +60,7 @@ class SaveManyBeans extends SaveManyBase {
       // we only allow one direction based on first traversed basis
       boolean saveIntersectionFromThisDirection = isSaveIntersection();
       if (cascade) {
-        saveAssocManyDetails( false);
+        saveAssocManyDetails(false);
       }
       // for ManyToMany save the 'relationship' via inserts/deletes
       // into/from the intersection table
@@ -125,7 +127,7 @@ class SaveManyBeans extends SaveManyBase {
       // collect the Id's (to exclude from deleteManyDetails)
       List<Object> detailIds = collectIds(collection, targetDescriptor, isMap);
       // deleting missing children - children not in our collected detailIds
-      persister.deleteManyDetails(transaction, many.getBeanDescriptor(), parentBean, many, detailIds, false);
+      persister.deleteManyDetails(transaction, many.getBeanDescriptor(), parentBean, many, detailIds, deleteMode);
     }
 
     transaction.depth(+1);
@@ -320,7 +322,7 @@ class SaveManyBeans extends SaveManyBase {
         // the object from the 'other' side of the ManyToMany
         // build a intersection row for 'delete'
         IntersectionRow intRow = many.buildManyToManyMapBean(parentBean, otherDelete, publish);
-        SqlUpdate sqlDelete = intRow.createDelete(server, false);
+        SqlUpdate sqlDelete = intRow.createDelete(server, DeleteMode.HARD);
         persister.executeSqlUpdate(sqlDelete, transaction);
       }
     }

src/main/java/io/ebeaninternal/server/persist/dml/DmlHandler.java

@@ -46,6 +46,8 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
    */
   protected DataBind dataBind;
 
+  protected BatchedPstmt batchedPstmt;
+
   protected String sql;
 
   /**
@@ -273,20 +275,18 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
   /**
    * Return a prepared statement taking into account batch requirements.
    */
-  protected PreparedStatement getPstmt(SpiTransaction t, String sql, PersistRequestBean<?> request,
-                                       boolean genKeys) throws SQLException {
+  protected PreparedStatement getPstmt(SpiTransaction t, String sql, PersistRequestBean<?> request, boolean genKeys) throws SQLException {
 
     BatchedPstmtHolder batch = t.getBatchControl().getPstmtHolder();
-    PreparedStatement stmt = batch.getStmt(sql, request);
-
-    if (stmt != null) {
-      return stmt;
+    batchedPstmt = batch.getBatchedPstmt(sql, request);
+    if (batchedPstmt != null) {
+      return batchedPstmt.getStatement();
     }
 
-    stmt = getPstmt(t, sql, genKeys);
+    PreparedStatement stmt = getPstmt(t, sql, genKeys);
 
-    BatchedPstmt bs = new BatchedPstmt(stmt, genKeys, sql, t);
-    batch.addStmt(bs, request);
+    batchedPstmt = new BatchedPstmt(stmt, genKeys, sql, t);
+    batch.addStmt(batchedPstmt, request);
     return stmt;
   }
 

src/main/java/io/ebeaninternal/server/persist/dml/InsertHandler.java

@@ -91,7 +91,9 @@ public class InsertHandler extends DmlHandler {
     }
     dataBind = bind(pstmt);
     meta.bind(this, bean, withId, persistRequest.isPublish());
-
+    if (persistRequest.isBatched()) {
+      batchedPstmt.registerInputStreams(dataBind.getInputStreams());
+    }
     logSql(sql);
   }
 

src/main/java/io/ebeaninternal/server/persist/dml/UpdateHandler.java

@@ -47,7 +47,9 @@ public class UpdateHandler extends DmlHandler {
     }
     dataBind = bind(pstmt);
     meta.bind(persistRequest, this, updatePlan);
-
+    if (persistRequest.isBatched()) {
+      batchedPstmt.registerInputStreams(dataBind.getInputStreams());
+    }
     setUpdateGenValues();
 
     logSql(sql);

src/main/java/io/ebeaninternal/server/query/CQuery.java

@@ -38,6 +38,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
+import java.util.Set;
 
 /**
  * An object that represents a SqlSelect statement.
@@ -811,4 +812,8 @@ public class CQuery<T> implements DbReadContext, CancelableQuery, SpiProfileTran
   PreparedStatement getPstmt() {
     return pstmt;
   }
+
+  public Set<String> getDependentTables() {
+    return queryPlan.getDependentTables();
+  }
 }

src/main/java/io/ebeaninternal/server/query/CQueryEngine.java

@@ -25,6 +25,8 @@ import org.slf4j.LoggerFactory;
 import javax.persistence.PersistenceException;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -111,6 +113,15 @@ public class CQueryEngine {
       if (request.isLogSummary()) {
         request.getTransaction().logSummary(rcQuery.getSummary());
       }
+      if (request.isQueryCachePut() && !list.isEmpty()) {
+        request.addDependentTables(rcQuery.getDependentTables());
+
+        list = Collections.unmodifiableList(list);
+        request.putToQueryCache(list);
+        if (Boolean.FALSE.equals(request.getQuery().isReadOnly())) {
+          list = new ArrayList<>(list);
+        }
+      }
       return list;
 
     } catch (SQLException e) {
@@ -173,6 +184,11 @@ public class CQueryEngine {
         request.getTransaction().end();
       }
 
+      if (request.isQueryCachePut()) {
+        request.addDependentTables(rcQuery.getDependentTables());
+        request.putToQueryCache(count);
+      }
+
       return count;
 
     } catch (SQLException e) {
@@ -385,6 +401,9 @@ public class CQueryEngine {
       }
 
       request.executeSecondaryQueries(false);
+      if (request.isQueryCachePut()) {
+        request.addDependentTables(cquery.getDependentTables());
+      }
 
       return beanCollection;
 

src/main/java/io/ebeaninternal/server/query/CQueryFetchSingleAttribute.java

@@ -17,6 +17,7 @@ import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 
 /**
  * Base compiled query request for single attribute queries.
@@ -188,4 +189,8 @@ class CQueryFetchSingleAttribute implements SpiProfileTransactionEvent {
       .profileStream()
       .addQueryEvent(query.profileEventId(), profileOffset, desc.getProfileId(), rowCount, query.getProfileId());
   }
+
+  Set<String> getDependentTables() {
+    return queryPlan.getDependentTables();
+  }
 }

src/main/java/io/ebeaninternal/server/query/CQueryOrderBy.java

@@ -2,7 +2,6 @@ package io.ebeaninternal.server.query;
 
 import io.ebean.OrderBy;
 import io.ebean.OrderBy.Property;
-import io.ebeaninternal.api.SpiQuery;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
 import io.ebeaninternal.server.deploy.BeanPropertyAssoc;
@@ -18,27 +17,22 @@ class CQueryOrderBy {
 
   private final BeanDescriptor<?> desc;
 
-  private final SpiQuery<?> query;
+  private final OrderBy<?> orderBy;
 
   /**
    * Create the logical order by clause.
    */
-  public static String parse(BeanDescriptor<?> desc, SpiQuery<?> query) {
-    return new CQueryOrderBy(desc, query).parseInternal();
+  public static String parse(BeanDescriptor<?> desc, OrderBy<?> orderBy) {
+    return new CQueryOrderBy(desc, orderBy).parseInternal();
   }
 
-  private CQueryOrderBy(BeanDescriptor<?> desc, SpiQuery<?> query) {
+  private CQueryOrderBy(BeanDescriptor<?> desc, OrderBy<?> orderBy) {
     this.desc = desc;
-    this.query = query;
+    this.orderBy = orderBy;
   }
 
   private String parseInternal() {
 
-    OrderBy<?> orderBy = query.getOrderBy();
-    if (orderBy == null) {
-      return null;
-    }
-
     StringBuilder sb = new StringBuilder();
 
     List<Property> properties = orderBy.getProperties();

src/main/java/io/ebeaninternal/server/query/CQueryPlan.java

@@ -24,6 +24,8 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.Collections;
+import java.util.Set;
 
 /**
  * Represents a query for a given SQL statement.
@@ -88,6 +90,8 @@ public class CQueryPlan {
    */
   private volatile String auditQueryHash;
 
+  private final Set<String> dependentTables;
+
   /**
    * Create a query plan based on a OrmQueryRequest.
    */
@@ -110,6 +114,7 @@ public class CQueryPlan {
     this.logWhereSql = logWhereSql;
     this.encryptedProps = sqlTree.getEncryptedProps();
     this.stats = new CQueryPlanStats(this, server.isCollectQueryOrigins());
+    this.dependentTables = sqlTree.dependentTables();
   }
 
   /**
@@ -134,6 +139,7 @@ public class CQueryPlan {
     this.logWhereSql = logWhereSql;
     this.encryptedProps = sqlTree.getEncryptedProps();
     this.stats = new CQueryPlanStats(this, server.isCollectQueryOrigins());
+    this.dependentTables = (rawSql) ? Collections.emptySet() : sqlTree.dependentTables();
   }
 
   private String location() {
@@ -154,6 +160,10 @@ public class CQueryPlan {
     return beanType;
   }
 
+  public Set<String> getDependentTables() {
+    return dependentTables;
+  }
+
   public ProfileLocation getProfileLocation() {
     return profileLocation;
   }

src/main/java/io/ebeaninternal/server/query/CQueryPredicates.java

@@ -1,5 +1,6 @@
 package io.ebeaninternal.server.query;
 
+import io.ebean.OrderBy;
 import io.ebeaninternal.api.BindParams;
 import io.ebeaninternal.api.SpiExpressionList;
 import io.ebeaninternal.api.SpiQuery;
@@ -329,7 +330,11 @@ public class CQueryPredicates {
 
   private String parseOrderBy() {
 
-    return CQueryOrderBy.parse(request.getBeanDescriptor(), query);
+    OrderBy<?> orderBy = query.getOrderBy();
+    if (orderBy == null) {
+      return null;
+    }
+    return CQueryOrderBy.parse(request.getBeanDescriptor(), orderBy);
   }
 
   /**