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

Change to add generics for FetchGroup

pom.xml

@@ -9,15 +9,20 @@
 
   <groupId>io.ebean</groupId>
   <artifactId>ebean</artifactId>
-  <version>11.15.7</version>
+  <version>11.19.2</version>
   <packaging>jar</packaging>
 
   <name>ebean</name>
   <url>http://ebean-orm.github.io/</url>
 
+  <properties>
+    <jackson-core.version>2.9.5</jackson-core.version>
+    <snakeyaml.version>1.21</snakeyaml.version>
+  </properties>
+
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-11.15.7</tag>
+    <tag>ebean-11.19.2</tag>
   </scm>
 
   <profiles>
@@ -89,7 +94,7 @@
     <dependency>
       <groupId>org.yaml</groupId>
       <artifactId>snakeyaml</artifactId>
-      <version>1.19</version>
+      <version>${snakeyaml.version}</version>
     </dependency>
 
     <!--
@@ -112,7 +117,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>3.11</version>
+      <version>4.1</version>
     </dependency>
 
     <dependency>
@@ -130,7 +135,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-migration</artifactId>
-      <version>11.5.4</version>
+      <version>11.7.1</version>
     </dependency>
 
     <dependency>
@@ -143,14 +148,14 @@
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
-      <version>2.9.0</version>
+      <version>${jackson-core.version}</version>
     </dependency>
 
     <!-- provided scope for JsonNode support -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
-      <version>2.9.0</version>
+      <version>${jackson-core.version}</version>
       <scope>provided</scope>
     </dependency>
 
@@ -169,6 +174,13 @@
       <scope>provided</scope>
     </dependency>
 
+    <dependency>
+      <groupId>javax.servlet</groupId>
+      <artifactId>javax.servlet-api</artifactId>
+      <version>3.1.0</version>
+      <scope>provided</scope>
+    </dependency>
+
     <dependency>
       <groupId>joda-time</groupId>
       <artifactId>joda-time</artifactId>
@@ -180,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>
 
@@ -348,7 +360,7 @@
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>2.9.1</version>
         <configuration>
-          <doctitle>Ebean 10</doctitle>
+          <doctitle>Ebean 11</doctitle>
           <overview>src/main/java/io/ebean/overview.html</overview>
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>

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>
@@ -167,6 +183,30 @@ public abstract class BeanRepository<I, T> extends BeanFinder<I, T> {
     return db().deletePermanent(bean);
   }
 
+  /**
+   * Merge this entity using the default merge options.
+   * <p>
+   * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
+   * insert or an update based on that.
+   *
+   * @see EbeanServer#merge(Object)
+   */
+  public void merge(T bean) {
+    db().merge(bean);
+  }
+
+  /**
+   * Merge this entity using the specified merge options.
+   * <p>
+   * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
+   * insert or an update based on that.
+   *
+   * @see EbeanServer#merge(Object, MergeOptions)
+   */
+  public void merge(T bean, MergeOptions options) {
+    db().merge(bean, options);
+  }
+
   /**
    * Refreshes this entity from the database.
    *

src/main/java/io/ebean/Ebean.java

@@ -638,6 +638,15 @@ public final class Ebean {
     serverMgr.getDefaultServer().updateAll(beans);
   }
 
+  /**
+   * Merge the bean using the default merge options.
+   *
+   * @param bean The bean to merge
+   */
+  public static void merge(Object bean) {
+    serverMgr.getDefaultServer().merge(bean);
+  }
+
   /**
    * Merge the bean using the given merge options.
    *

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.
@@ -1628,6 +1235,13 @@ public interface EbeanServer {
    */
   void updateAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException;
 
+  /**
+   * Merge the bean using the default merge options (no paths specified, default delete).
+   *
+   * @param bean The bean to merge
+   */
+  void merge(Object bean);
+
   /**
    * Merge the bean using the given merge options.
    *

src/main/java/io/ebean/EbeanVersion.java

@@ -1,11 +1,11 @@
 package io.ebean;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Properties;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 /**
  * Class to determine the ebean version. (
  * @author Roland Praml, FOCONIS AG
@@ -13,31 +13,32 @@ import org.slf4j.LoggerFactory;
  */
 public class EbeanVersion {
   private EbeanVersion() {
-    
+
   }
   private static final Logger logger = LoggerFactory.getLogger(EbeanVersion.class);
-  
+
   private static String version = "unknown";
   static {
     try {
       Properties prop = new Properties();
-      InputStream in = Ebean.class.getResourceAsStream("/META-INF/maven/io.ebean/ebean/pom.properties");
-      if (in != null) {
-        prop.load(in);
-        in.close();
-        version = prop.getProperty("version");
+      try (InputStream in = Ebean.class.getResourceAsStream("/META-INF/maven/io.ebean/ebean/pom.properties")) {
+        if (in != null) {
+          prop.load(in);
+          in.close();
+          version = prop.getProperty("version");
+        }
       }
       logger.info("ebean version: {}", version);
     } catch (IOException e) {
       logger.warn("Could not determine ebean version: {}", e.getMessage());
     }
   }
-  
+
   /**
    * Returns the ebean version (read from /META-INF/maven/io.ebean/ebean/pom.properties)
    */
   public static String getVersion() {
     return version;
   }
-  
+
 }

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.
    */
@@ -404,6 +412,11 @@ public interface ExpressionList<T> {
    */
   Query<T> select(String properties);
 
+  /**
+   * Apply the fetchGroup which defines what part of the object graph to load.
+   */
+  Query<T> select(FetchGroup<T> fetchGroup);
+
   /**
    * Set whether this query uses DISTINCT.
    * <p>
@@ -1023,6 +1036,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/FetchGroup.java

@@ -0,0 +1,114 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Defines what part of the object graph to load (select and fetch clauses).
+ * <p>
+ * Using a FetchGroup effectively sets the select() and fetch() clauses for a query. It is alternative
+ * to specifying the select() and fetch() clauses on the query allowing for more re-use of "what to load"
+ * that can be defined separately from the query and combined with other FetchGroups.
+ * </p>
+ *
+ * <h3>Select example</h3>*
+ * <pre>{@code
+ *
+ * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class, "name, status");
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .findList();
+ *
+ * }</pre>
+ *
+ * <h3>Select and fetch example</h3>
+ * <pre>{@code
+ *
+ * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class)
+ *   .select("name, status")
+ *   .fetch("contacts", "firstName, lastName, email")
+ *   .build();
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .findList();
+ *
+ * }</pre>
+ *
+ * <h3>Combining FetchGroups</h3>
+ * <p>
+ *   FetchGroups can be combined together to form another FetchGroup.
+ * </p>
+ * <pre>{@code
+ *
+ *  FetchGroup<Address> FG_ADDRESS = FetchGroup.of(Address.class)
+ *    .select("line1, line2, city")
+ *    .fetch("country", "name")
+ *    .build();
+ *
+ *  FetchGroup<Customer> FG_CUSTOMER = FetchGroup.of(Customer.class)
+ *    .select("name, version")
+ *    .fetch("billingAddress", FG_ADDRESS)
+ *    .build();
+ *
+ *
+ *  Customer.query()
+ *    .select(FG_CUSTOMER)
+ *    .findList();
+ *
+ * }</pre>
+ *
+ * @param <T> The bean type the Fetch group can be applied to
+ */
+public interface FetchGroup<T> {
+
+  /**
+   * Return the FetchGroup with the given select clause.
+   * <p>
+   *   We use this for simple FetchGroup that only select() properties and do not have additional fetch() clause.
+   * </p>
+   * <pre>{@code
+   *
+   * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class, "name, status");
+   *
+   * Customer.query()
+   *   .select(fetchGroup)
+   *   .findList();
+   *
+   * }</pre>
+   *
+   * @param select The select clause of the FetchGroup
+   *
+   * @return The FetchGroup with the given select clause
+   */
+  @Nonnull
+  static <T> FetchGroup<T> of(Class<T> cls, String select) {
+    return XServiceProvider.fetchGroupOf(cls, select);
+  }
+
+  /**
+   * Return the FetchGroupBuilder with the given select clause that we can add fetch clauses to.
+   * <p>
+   * We chain select() with one or more fetch() clauses to define the object graph to load.
+   * </p>
+   * <pre>{@code
+   *
+   * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class)
+   *   .select("name, status")
+   *   .fetch("contacts", "firstName, lastName, email")
+   *   .build();
+   *
+   * Customer.query()
+   *   .select(fetchGroup)
+   *   .findList();
+   *
+   * }</pre>
+   *
+   * @return The FetchGroupBuilder with the given select clause which we will add fetch clauses to
+   */
+  @Nonnull
+  static <T> FetchGroupBuilder<T> of(Class<T> cls) {
+    return XServiceProvider.fetchGroupOf(cls);
+  }
+
+}

src/main/java/io/ebean/FetchGroupBuilder.java

@@ -0,0 +1,93 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Builds a FetchGroup by adding fetch clauses.
+ * <p>
+ * We add select() and fetch() clauses to define the object graph we want to load.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ * FetchGroup fetchGroup = FetchGroup
+ *   .select("name, status")
+ *   .fetch("contacts", "firstName, lastName, email")
+ *   .build();
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .where()
+ *   ...
+ *   .findList();
+ *
+ * }</pre>
+ */
+public interface FetchGroupBuilder<T> {
+
+  /**
+   * Specify specific properties to select (top level properties).
+   */
+  @Nonnull
+  FetchGroupBuilder<T> select(String select);
+
+  /**
+   * Fetch all the properties at the given path.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path);
+
+  /**
+   * Fetch the path with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path using a query join with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path lazily with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path including specified properties.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path, String properties);
+
+  /**
+   * Fetch the path including all its properties using a query join.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path);
+
+  /**
+   * Fetch the path including specified properties using a query join.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path, String properties);
+
+  /**
+   * Fetch the path including all its properties lazily.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path);
+
+  /**
+   * Fetch the path including specified properties lazily.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path, String properties);
+
+  /**
+   * Build and return the FetchGroup.
+   */
+  @Nonnull
+  FetchGroup<T> build();
+}

src/main/java/io/ebean/MergeOptionsBuilder.java

@@ -8,11 +8,20 @@ import java.util.Set;
  */
 public class MergeOptionsBuilder {
 
+  private static final MOptions DEFAULT_OPTIONS = new MOptions();
+
   private Set<String> paths = new LinkedHashSet<>();
 
   private boolean clientGeneratedIds;
 
-  private boolean deletePermanent = true;
+  private boolean deletePermanent;
+
+  /**
+   * Return the default options.
+   */
+  public static MergeOptions defaultOptions() {
+    return DEFAULT_OPTIONS;
+  }
 
   /**
    * Add a path that will included in the merge.
@@ -47,7 +56,7 @@ public class MergeOptionsBuilder {
   /**
    * Build and return the MergeOptions instance.
    */
-  public MOptions build() {
+  public MergeOptions build() {
     return new MOptions(paths, clientGeneratedIds, deletePermanent);
   }
 
@@ -57,6 +66,12 @@ public class MergeOptionsBuilder {
     private final boolean deletePermanent;
     private final Set<String> paths;
 
+    private MOptions(){
+      this.clientGeneratedIds = false;
+      this.paths = new LinkedHashSet<>();
+      this.deletePermanent = false;
+    }
+
     private MOptions(Set<String> paths, boolean clientGeneratedIds, boolean deletePermanent) {
       this.paths = paths;
       this.clientGeneratedIds = clientGeneratedIds;

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

@@ -397,6 +397,11 @@ public interface Query<T> {
    */
   Query<T> select(String fetchProperties);
 
+  /**
+   * Apply the fetchGroup which defines what part of the object graph to load.
+   */
+  Query<T> select(FetchGroup<T> fetchGroup);
+
   /**
    * Specify a path to fetch eagerly including specific properties.
    * <p>
@@ -602,8 +607,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 +743,6 @@ public interface Query<T> {
    *     .findList();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findList(Query, Transaction)
    */
   @Nonnull
   List<T> findList();
@@ -759,8 +760,6 @@ public interface Query<T> {
    *     .findSet();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findSet(Query, Transaction)
    */
   @Nonnull
   Set<T> findSet();
@@ -782,8 +781,6 @@ public interface Query<T> {
    *     .findMap();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findMap(Query, Transaction)
    */
   @Nonnull
   <K> Map<K, T> findMap();

src/main/java/io/ebean/RowConsumer.java

@@ -0,0 +1,40 @@
+package io.ebean;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * Used with SqlQuery to process potentially large queries reading directly from the JDBC ResultSet.
+ * <p>
+ * This provides a low level option that reads directly from the JDBC ResultSet.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ *  String sql = "select id, name, status from o_customer order by name desc";
+ *
+ *  Ebean.createSqlQuery(sql)
+ *    .findEachRow((resultSet, rowNum) -> {
+ *
+ *      // read directly from ResultSet
+ *
+ *      long id = resultSet.getLong(1);
+ *      String name = resultSet.getString(2);
+ *
+ *      // do something interesting with the data
+ *
+ *    });
+ *
+ * }</pre>
+ */
+@FunctionalInterface
+public interface RowConsumer {
+
+  /**
+   * Read the data from the ResultSet and process it.
+   *
+   * @param resultSet The JDBC ResultSet positioned to the current row
+   * @param rowNum    The number of the current row being mapped.
+   */
+  void accept(ResultSet resultSet, int rowNum) throws SQLException;
+}

src/main/java/io/ebean/RowMapper.java

@@ -0,0 +1,62 @@
+package io.ebean;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * Used with SqlQuery to map raw JDBC ResultSet to objects.
+ * <p>
+ * This provides a low level mapping option with direct use of JDBC ResultSet
+ * with the option of having logic in the mapping. For example, only map some
+ * columns depending on the values read from other columns.
+ * </p>
+ * <p>
+ * For straight mapping into beans then DtoQuery would be the first choice as
+ * it can automatically map the ResultSet into beans.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ *    //
+ *    // A mapper from ResultSet into our CustomerDto bean
+ *    //
+ *    class CustomerMapper implements RowMapper<CustomerDto> {
+ *
+ *     @Override
+ *     public CustomerDto map(ResultSet rset, int rowNum) throws SQLException {
+ *
+ *       long id = rset.getLong(1);
+ *       String name = rset.getString(2);
+ *       String status = rset.getString(3);
+ *
+ *       return new CustomerDto(id, name, status);
+ *     }
+ *   }
+ *
+ *
+ *   //
+ *   // Then use the mapper
+ *   //
+ *
+ *   String sql = "select id, name, status from o_customer where name = ?";
+ *
+ *  CustomerDto rob = Ebean.createSqlQuery(sql)
+ *    .setParameter(1, "Rob")
+ *    .findOne(CUSTOMER_MAPPER);
+ *
+ *
+ * }</pre>
+ *
+ * @param <T> The type the row data is mapped into.
+ */
+@FunctionalInterface
+public interface RowMapper<T> {
+
+  /**
+   * Read the data from the ResultSet and map to the return type.
+   *
+   * @param resultSet The JDBC ResultSet positioned to the current row
+   * @param rowNum    The number of the current row being mapped.
+   */
+  T map(ResultSet resultSet, int rowNum) throws SQLException;
+}

src/main/java/io/ebean/SqlQuery.java

@@ -3,6 +3,7 @@ package io.ebean;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.io.Serializable;
+import java.math.BigDecimal;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Consumer;
@@ -77,12 +78,118 @@ public interface SqlQuery extends Serializable {
   @Nullable
   SqlRow findOne();
 
+  /**
+   * Execute the query returning a single result using the mapper.
+   *
+   * @param mapper Used to map each ResultSet row into the result object.
+   */
+  <T> T findOne(RowMapper<T> mapper);
+
+  /**
+   * Execute the query returning a list using the mapper.
+   *
+   * @param mapper Used to map each ResultSet row into the result object.
+   */
+  <T> List<T> findList(RowMapper<T> mapper);
+
+  /**
+   * Execute the query reading each row from ResultSet using the RowConsumer.
+   * <p>
+   * This provides a low level option that reads directly from the JDBC ResultSet
+   * and is good for processing very large results where (unlike findList) we don't
+   * hold all the results in memory but instead can process row by row.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  String sql = "select id, name, status from customer order by name desc";
+   *
+   *  Ebean.createSqlQuery(sql)
+   *    .findEachRow((resultSet, rowNum) -> {
+   *
+   *      // read directly from ResultSet
+   *
+   *      long id = resultSet.getLong(1);
+   *      String name = resultSet.getString(2);
+   *
+   *      // do something interesting with the data
+   *
+   *    });
+   *
+   * }</pre>
+   *
+   * @param consumer Used to read and process each ResultSet row.
+   */
+  void findEachRow(RowConsumer consumer);
+
   /**
    * Execute the query returning an optional row.
    */
   @Nonnull
   Optional<SqlRow> findOneOrEmpty();
 
+  /**
+   * Execute the query returning a single scalar attribute.
+   * <pre>@{code
+   *
+   *   String sql = "select max(unit_price) from o_order_detail where order_qty > ?";
+   *
+   *   BigDecimal maxPrice = Ebean.createSqlQuery(sql)
+   *     .setParameter(1, 2)
+   *     .findSingleAttribute(BigDecimal.class);
+   *
+   * }</pre>
+   *
+   * <p>
+   * The attributeType can be any scalar type that Ebean supports (includes javax time types, Joda types etc).
+   * </p>
+   *
+   * @param attributeType The type of the returned value
+   */
+  <T> T findSingleAttribute(Class<T> attributeType);
+
+  /**
+   * Execute the query returning a single BigDecimal value.
+   * <p>
+   * This is an alias for <code>findSingleAttribute(BigDecimal.class)</code>
+   * </p>
+   */
+  BigDecimal findSingleDecimal();
+
+  /**
+   * Execute the query returning a single Long value.
+   * <p>
+   * This is an alias for <code>findSingleAttribute(Long.class)</code>
+   * </p>
+   */
+  Long findSingleLong();
+
+  /**
+   * Execute the query returning a list of scalar attribute values.
+   *
+   * <pre>{@code
+   *
+   *   String sql =
+   *   " select (unit_price * order_qty) " +
+   *   " from o_order_detail " +
+   *   " where unit_price > ? " +
+   *   " order by (unit_price * order_qty) desc";
+   *
+   *   //
+   *   List<BigDecimal> lineAmounts = Ebean.createSqlQuery(sql)
+   *     .setParameter(1, 3)
+   *     .findSingleAttributeList(BigDecimal.class);
+   *
+   * }</pre>
+   *
+   * <p>
+   * The attributeType can be any scalar type that Ebean supports (includes javax time types, Joda types etc).
+   * </p>
+   *
+   * @param attributeType The type of the returned value
+   */
+  <T> List<T> findSingleAttributeList(Class<T> attributeType);
+
   /**
    * The same as bind for named parameters.
    */

src/main/java/io/ebean/SqlUpdate.java

@@ -19,15 +19,17 @@ package io.ebean;
  * <p>
  * <pre>{@code
  *
- * // example that uses 'named' parameters
- * String s = "UPDATE f_topic set post_count = :count where id = :id";
- * SqlUpdate update = Ebean.createSqlUpdate(s);
- * update.setParameter("id", 1);
- * update.setParameter("count", 50);
+ *   // example that uses 'named' parameters
  *
- * int modifiedCount = Ebean.execute(update);
+ *   String s = "UPDATE f_topic set post_count = :count where id = :id";
  *
- * String msg = "There were " + modifiedCount + " rows updated";
+ *   SqlUpdate update = Ebean.createSqlUpdate(s);
+ *   update.setParameter("id", 1);
+ *   update.setParameter("count", 50);
+ *
+ *   int modifiedCount = update.execute();
+ *
+ *   String msg = "There were " + modifiedCount + " rows updated";
  *
  * }</pre>
  * <p>
@@ -57,6 +59,33 @@ package io.ebean;
  *
  *    txn.commit();
  *  }
+ * }</pre>
+ * <p>
+ * An alternative to the batch mode on the transaction is to use addBatch() and executeBatch() like:
+ * </p>
+ * <pre>{@code
+ *
+ *   try (Transaction txn = Ebean.beginTransaction()) {
+ *
+ *     insert.setNextParameter(10000);
+ *     insert.setNextParameter("hello");
+ *     insert.setNextParameter("rob");
+ *     insert.addBatch();
+ *
+ *     insert.setNextParameter(10001);
+ *     insert.setNextParameter("goodbye");
+ *     insert.setNextParameter("rob");
+ *     insert.addBatch();
+ *
+ *     insert.setNextParameter(10002);
+ *     insert.setNextParameter("chow");
+ *     insert.setNextParameter("bob");
+ *     insert.addBatch();
+ *
+ *     int[] rows = insert.executeBatch();
+ *
+ *     txn.commit();
+ *   }
  *
  * }</pre>
  *
@@ -83,6 +112,18 @@ public interface SqlUpdate {
    */
   int execute();
 
+  /**
+   * Execute when addBatch() has been used to batch multiple bind executions.
+   *
+   * @return The row counts for each of the batched statements.
+   */
+  int[] executeBatch();
+
+  /**
+   * Add the statement to batch processing to then later execute via executeBatch().
+   */
+  void addBatch();
+
   /**
    * Return the generated key value.
    */

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/XServiceProvider.java

@@ -1,5 +1,6 @@
 package io.ebean;
 
+import io.ebean.service.SpiFetchGroupService;
 import io.ebean.service.SpiProfileLocationFactory;
 import io.ebean.service.SpiRawSqlService;
 
@@ -15,6 +16,16 @@ class XServiceProvider {
 
   private static SpiProfileLocationFactory profileLocationFactory = initProfileLocation();
 
+  private static SpiFetchGroupService fetchGroupService = initSpiFetchGroupService();
+
+  private static SpiFetchGroupService initSpiFetchGroupService() {
+    Iterator<SpiFetchGroupService> loader = ServiceLoader.load(SpiFetchGroupService.class).iterator();
+    if (loader.hasNext()) {
+      return loader.next();
+    }
+    throw new IllegalStateException("No service implementation found for SpiFetchGroupService?");
+  }
+
   private static SpiRawSqlService initRawSql() {
 
     Iterator<SpiRawSqlService> loader = ServiceLoader.load(SpiRawSqlService.class).iterator();
@@ -47,4 +58,17 @@ class XServiceProvider {
     return profileLocationFactory;
   }
 
+  /**
+   * Return the FetchGroup with the given select clause.
+   */
+  static <T> FetchGroup<T> fetchGroupOf(Class<T> cls, String select) {
+    return fetchGroupService.of(cls, select);
+  }
+
+  /**
+   * Return the FetchGroupBuilder with the given select clause.
+   */
+  static <T> FetchGroupBuilder<T> fetchGroupOf(Class<T> cls) {
+    return fetchGroupService.of(cls);
+  }
 }

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.
    */
@@ -402,9 +434,20 @@ public class DbMigrationConfig {
    * You can use placeholders like ${version} or ${timestamp} in properties file.
    */
   public String getDdlHeader() {
+    if (ddlHeader != null && !ddlHeader.isEmpty()) {
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${version}", EbeanVersion.getVersion());
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${timestamp}", ZonedDateTime.now().format( DateTimeFormatter.ISO_INSTANT ));
+    }
     return ddlHeader;
   }
 
+  /**
+   * Set the header prepended to the DDL.
+   */
+  public void setDdlHeader(String ddlHeader) {
+    this.ddlHeader = ddlHeader;
+  }
+
   /**
    * Set migration versions that should have their checksum reset and not run.
    * <p>
@@ -464,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
@@ -475,10 +519,6 @@ public class DbMigrationConfig {
     String adminPwd = properties.get("datasource." + serverName + ".adminpassword", dbPassword);
     dbPassword = properties.get("migration.dbpassword", adminPwd);
     ddlHeader = properties.get("ddl.header", ddlHeader);
-    if (ddlHeader != null && !ddlHeader.isEmpty()) {
-      ddlHeader = StringHelper.replaceString(ddlHeader, "${version}", EbeanVersion.getVersion());
-      ddlHeader = StringHelper.replaceString(ddlHeader, "${timestamp}", ZonedDateTime.now().format( DateTimeFormatter.ISO_INSTANT ));
-    }
   }
 
   /**
@@ -550,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<>();
@@ -493,6 +506,11 @@ public class ServerConfig {
    */
   private List<String> mappingLocations = new ArrayList<>();
 
+  /**
+   * When true we do not need explicit GeneratedValue mapping.
+   */
+  private boolean idGeneratorAutomatic = true;
+
   /**
    * Construct a Server Configuration for programmatically creating an EbeanServer.
    */
@@ -500,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.
    */
@@ -1093,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.
    */
@@ -1967,7 +2018,7 @@ public class ServerConfig {
    * This is the same as serverConfig.getMigrationConfig().setRunMigration(). We have added this method here
    * as it is often the only thing we need to configure for migrations.
    */
-  public void setRunMigration(boolean runMigration){
+  public void setRunMigration(boolean runMigration) {
     migrationConfig.setRunMigration(runMigration);
   }
 
@@ -2737,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);
@@ -2772,6 +2827,7 @@ public class ServerConfig {
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
     useJavaxValidationNotNull = p.getBoolean("useJavaxValidationNotNull", useJavaxValidationNotNull);
     autoReadOnlyDataSource = p.getBoolean("autoReadOnlyDataSource", autoReadOnlyDataSource);
+    idGeneratorAutomatic = p.getBoolean("idGeneratorAutomatic", idGeneratorAutomatic);
 
     backgroundExecutorSchedulePoolSize = p.getInt("backgroundExecutorSchedulePoolSize", backgroundExecutorSchedulePoolSize);
     backgroundExecutorShutdownSecs = p.getInt("backgroundExecutorShutdownSecs", backgroundExecutorShutdownSecs);
@@ -3109,6 +3165,23 @@ public class ServerConfig {
     this.mappingLocations = mappingLocations;
   }
 
+  /**
+   * When false we need explicit <code>@GeneratedValue</code> mapping to assign
+   * Identity or Sequence generated values. When true Id properties are automatically
+   * assigned Identity or Sequence without the GeneratedValue mapping.
+   */
+  public boolean isIdGeneratorAutomatic() {
+    return idGeneratorAutomatic;
+  }
+
+  /**
+   * Set to false such that Id properties require explicit <code>@GeneratedValue</code>
+   * mapping before they are assigned Identity or Sequence generation based on platform.
+   */
+  public void setIdGeneratorAutomatic(boolean idGeneratorAutomatic) {
+    this.idGeneratorAutomatic = idGeneratorAutomatic;
+  }
+
   public enum UuidVersion {
     VERSION4,
     VERSION1,

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/ebean/config/properties/LoadContext.java

@@ -18,26 +18,26 @@ import java.util.Set;
  */
 class LoadContext {
 
-	private static final Logger log = LoggerFactory.getLogger(LoadContext.class);
+  private static final Logger log = LoggerFactory.getLogger(LoadContext.class);
 
   /**
    * Map we are loading the properties into.
    */
-	private final Map<String, String> map = new LinkedHashMap<>();
+  private final Map<String, String> map = new LinkedHashMap<>();
 
   /**
    * Names of resources/files that were loaded.
    */
-	private final Set<String> loadedResources = new LinkedHashSet<>();
+  private final Set<String> loadedResources = new LinkedHashSet<>();
 
   /**
    * Return the input stream (maybe null) for the given source.
    */
-	InputStream resource(String resourcePath, Loader.Source source) {
+  InputStream resource(String resourcePath, Loader.Source source) {
 
     InputStream is = null;
     if (source == Loader.Source.RESOURCE) {
-      is = getClass().getResourceAsStream("/" + resourcePath);
+      is = resourceStream(resourcePath);
       if (is != null) {
         loadedResources.add(resourcePath);
       }
@@ -46,43 +46,52 @@ class LoadContext {
       if (file.exists()) {
         try {
           is = new FileInputStream(file);
-          loadedResources.add("file:"+resourcePath);
+          loadedResources.add("file:" + resourcePath);
         } catch (FileNotFoundException e) {
           throw new IllegalStateException(e);
         }
       }
     }
 
-		return is;
-	}
+    return is;
+  }
+
+  private InputStream resourceStream(String resourcePath) {
+    InputStream is = getClass().getResourceAsStream("/" + resourcePath);
+    if (is == null) {
+      // search the module path for top level resource
+      is = ClassLoader.getSystemResourceAsStream(resourcePath);
+    }
+    return is;
+  }
 
   /**
    * Add a property entry.
    */
-	void put(String key, String val) {
-	  if (val != null) {
-	    val = val.trim();
+  void put(String key, String val) {
+    if (val != null) {
+      val = val.trim();
     }
-		map.put(key, val);
-	}
+    map.put(key, val);
+  }
 
   /**
    * Evaluate all the expressions and return as a Properties object.
    */
-	Properties eval() {
+  Properties eval() {
 
-		log.info("loaded properties from {}", loadedResources);
+    log.info("loaded properties from {}", loadedResources);
 
-		Properties properties = new Properties();
+    Properties properties = new Properties();
 
-		for (Map.Entry<String, String> entry : map.entrySet()) {
-			String key = entry.getKey();
-			String value = PropertyEval.eval(entry.getValue());
-			properties.setProperty(key, value);
-		}
+    for (Map.Entry<String, String> entry : map.entrySet()) {
+      String key = entry.getKey();
+      String value = PropertyEval.eval(entry.getValue());
+      properties.setProperty(key, value);
+    }
 
-		return properties;
-	}
+    return properties;
+  }
 
   /**
    * Read the special properties that can point to an external properties source.

src/main/java/io/ebean/config/properties/Loader.java

@@ -16,10 +16,10 @@ import java.util.Properties;
  */
 class Loader {
 
-	private static final Logger log = LoggerFactory.getLogger(Loader.class);
+  private static final Logger log = LoggerFactory.getLogger(Loader.class);
 
-	enum Source {
-	  RESOURCE,
+  enum Source {
+    RESOURCE,
     FILE
   }
 
@@ -27,7 +27,7 @@ class Loader {
 
   private YamlLoader yamlLoader;
 
-	Loader() {
+  Loader() {
     String skipYaml = System.getProperty("ebeanSkipYaml");
     if (!"true".equals(skipYaml)) {
       try {
@@ -44,19 +44,19 @@ class Loader {
   /**
    * Load the configuration with the expected ordering.
    */
-	void load() {
+  void load() {
 
     loadMain(Source.RESOURCE);
     // external file configuration overrides the resources configuration
     loadMain(Source.FILE);
 
-		loadViaSystemProperty();
-		loadViaIndirection();
+    loadViaSystemProperty();
+    loadViaIndirection();
 
-		// test configuration (if found) overrides main configuration
+    // test configuration (if found) overrides main configuration
     // we should only find these resources when running tests
-		loadTest();
-	}
+    loadTest();
+  }
 
   /**
    * Load test configuration.
@@ -89,7 +89,7 @@ class Loader {
   }
 
   private void loadViaSystemProperty() {
-	  String fileName = System.getenv("EBEAN_PROPS_FILE");
+    String fileName = System.getenv("EBEAN_PROPS_FILE");
     if (fileName == null) {
       fileName = System.getProperty("ebean.props.file");
       if (fileName != null) {
@@ -112,59 +112,66 @@ class Loader {
    * Evaluate all the configuration entries and return as properties.
    */
   Properties eval() {
-		return loadContext.eval();
-	}
+    return loadContext.eval();
+  }
 
-	void loadYaml(String resourcePath, Source source) {
-		if (yamlLoader != null) {
-		  try {
-			  yamlLoader.load(resource(resourcePath, source));
+  void loadYaml(String resourcePath, Source source) {
+    if (yamlLoader != null) {
+      try {
+        try (InputStream is = resource(resourcePath, source)) {
+          yamlLoader.load(is);
+        }
       } catch (Exception e) {
         log.warn("Failed to read yml from:" + resourcePath, e);
       }
-		}
-	}
+    }
+  }
 
-	void loadProperties(String resourcePath, Source source) {
-		InputStream is = resource(resourcePath, source);
-		if (is != null) {
-			loadProperties(is);
-		}
-	}
+  void loadProperties(String resourcePath, Source source) {
+    try {
+      try (InputStream is = resource(resourcePath, source)) {
+        if (is != null) {
+          loadProperties(is);
+        }
+      }
+    } catch (Exception e) {
+      log.warn("Failed to read properties from:" + resourcePath, e);
+    }
+  }
 
-	private InputStream resource(String resourcePath, Source source) {
-		return loadContext.resource(resourcePath, source);
-	}
+  private InputStream resource(String resourcePath, Source source) {
+    return loadContext.resource(resourcePath, source);
+  }
 
-	private void loadProperties(InputStream is) {
+  private void loadProperties(InputStream is) {
 
-		if (is != null) {
-			try {
-				Properties properties = new Properties();
-				properties.load(is);
-				put(properties);
-			} catch (IOException e) {
-				throw new RuntimeException("Failed to load properties?", e);
-			} finally {
-				close(is);
-			}
-		}
-	}
+    if (is != null) {
+      try {
+        Properties properties = new Properties();
+        properties.load(is);
+        put(properties);
+      } catch (IOException e) {
+        throw new RuntimeException("Failed to load properties?", e);
+      } finally {
+        close(is);
+      }
+    }
+  }
 
-	private void put(Properties properties) {
-		Enumeration<?> enumeration = properties.propertyNames();
-		while (enumeration.hasMoreElements()) {
-			String key = (String) enumeration.nextElement();
-			String property = properties.getProperty(key);
-			loadContext.put(key, property);
-		}
-	}
+  private void put(Properties properties) {
+    Enumeration<?> enumeration = properties.propertyNames();
+    while (enumeration.hasMoreElements()) {
+      String key = (String) enumeration.nextElement();
+      String property = properties.getProperty(key);
+      loadContext.put(key, property);
+    }
+  }
 
-	private void close(InputStream is) {
-		try {
-			is.close();
-		} catch (IOException e) {
-			log.warn("Error closing input stream for properties", e);
-		}
-	}
+  private void close(InputStream is) {
+    try {
+      is.close();
+    } catch (IOException e) {
+      log.warn("Error closing input stream for properties", e);
+    }
+  }
 }

src/main/java/io/ebean/dbmigration/DbMigration.java

@@ -93,6 +93,38 @@ public interface DbMigration {
    */
   void setStrictMode(boolean strictMode);
 
+  /**
+   * Set to true to include a generated header comment in the DDL script.
+   */
+  void setIncludeGeneratedFileComment(boolean includeGeneratedFileComment);
+
+  /**
+   * Set the header that is included in the generated DDL script.
+   */
+  void setHeader(String header);
+
+  /**
+   * Set the prefix for the version. Set this to "V" for use with Flyway.
+   */
+  void setApplyPrefix(String applyPrefix);
+
+  /**
+   * Set the version of the migration to be generated.
+   */
+  void setVersion(String version);
+
+  /**
+   * Set the name of the migration to be generated.
+   */
+  void setName(String name);
+
+  /**
+   * Generate a migration for the version specified that contains pending drops.
+   *
+   * @param generatePendingDrop The version of a prior migration that holds pending drops.
+   */
+  void setGeneratePendingDrop(String generatePendingDrop);
+
   /**
    * Add an additional platform to write the migration DDL.
    * <p>

src/main/java/io/ebean/event/ServletContextListener.java

@@ -0,0 +1,38 @@
+package io.ebean.event;
+
+import io.ebeaninternal.server.lib.ShutdownManager;
+
+import javax.servlet.ServletContextEvent;
+
+/**
+ * Listens for webserver server starting and stopping events.
+ * <p>
+ * This should be used when the deployment is into a servlet container where the webapp
+ * can be shutdown or redeployed without the JVM stopping.
+ * </p>
+ * <p>
+ * If deployment is into a container where the JVM is completely shutdown (like spring boot,
+ * runnable war or when using a servlet container that only contains the single webapp and
+ * the JVM is shutdown then this isn't required. Instead we can just rely on the JVM shutdown
+ * hook that Ebean registers.
+ * </p>
+ */
+public class ServletContextListener implements javax.servlet.ServletContextListener {
+
+  /**
+   * The servlet container is stopping.
+   */
+  @Override
+  public void contextDestroyed(ServletContextEvent event) {
+    ShutdownManager.shutdown();
+  }
+
+  /**
+   * Do nothing on startup.
+   */
+  @Override
+  public void contextInitialized(ServletContextEvent event) {
+
+  }
+
+}

src/main/java/io/ebean/service/SpiFetchGroupService.java

@@ -0,0 +1,26 @@
+package io.ebean.service;
+
+import io.ebean.FetchGroup;
+import io.ebean.FetchGroupBuilder;
+
+/**
+ * Service that parses FetchGroup expressions.
+ */
+public interface SpiFetchGroupService {
+
+  /**
+   * Return the FetchGroup with the given select clause.
+   *
+   * @param beanType The type of entity bean the fetch group is for
+   * @param select   The properties to select (top level properties)
+   */
+  <T> FetchGroup<T> of(Class<T> beanType, String select);
+
+  /**
+   * Create and return a FetchGroupBuilder starting with a select() clause.
+   *
+   * @param beanType The type of entity bean the fetch group is for
+   * @return The FetchGroupBuilder to add additional select and fetch clauses
+   */
+  <T> FetchGroupBuilder<T> of(Class<T> beanType);
+}

src/main/java/io/ebean/text/PathProperties.java

@@ -89,8 +89,7 @@ public class PathProperties implements FetchPath {
   }
 
   Props getProps(String path) {
-    Props props = pathMap.computeIfAbsent(path, p -> new Props(this, null, p));
-    return props;
+    return pathMap.computeIfAbsent(path, p -> new Props(this, null, p));
   }
 
   public Collection<Props> getPathProps() {

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,8 +2,11 @@ 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;
+import io.ebean.RowMapper;
 import io.ebean.Transaction;
 import io.ebean.TxScope;
 import io.ebean.bean.BeanCollectionLoader;
@@ -29,7 +32,12 @@ 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.
+   */
+  SpiLogManager log();
 
   /**
    * Return the server extended Json context.
@@ -229,6 +237,31 @@ public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionL
    */
   void scopedTransactionExit(Object returnOrThrowable, int opCode);
 
+  /**
+   * SqlQuery find single attribute.
+   */
+  <T> T findSingleAttribute(SpiSqlQuery query, Class<T> cls);
+
+  /**
+   * SqlQuery find single attribute list.
+   */
+  <T> List<T> findSingleAttributeList(SpiSqlQuery query, Class<T> cls);
+
+  /**
+   * SqlQuery find one with mapper.
+   */
+  <T> T findOneMapper(SpiSqlQuery query, RowMapper<T> mapper);
+
+  /**
+   * SqlQuery find list with mapper.
+   */
+  <T> List<T> findListMapper(SpiSqlQuery query, RowMapper<T> mapper);
+
+  /**
+   * SqlQuery find each with consumer.
+   */
+  void findEachRow(SpiSqlQuery query, RowConsumer consumer);
+
   /**
    * DTO findList query.
    */
@@ -268,4 +301,15 @@ public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionL
    * Return true if a row for the bean type and id exists.
    */
   boolean exists(Class<?> beanType, Object beanId, Transaction transaction);
+
+  /**
+   * Add to JDBC batch for later execution.
+   */
+  void addBatch(SpiSqlUpdate defaultSqlUpdate, SpiTransaction transaction);
+
+  /**
+   * Execute the batched statement.
+   */
+  int[] executeBatch(SpiSqlUpdate defaultSqlUpdate, SpiTransaction transaction);
+
 }

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

@@ -0,0 +1,27 @@
+package io.ebeaninternal.api;
+
+/**
+ * Log manager for SQL, TXN and Summary logging.
+ * <p>
+ * In general at runtime this uses SLF4J Logger but this abstraction allows us to capture
+ * the logged SQL during testing such that we can assert against the executed sql if desired.
+ * </p>
+ */
+public interface SpiLogManager {
+
+  /**
+   * Return the SQL logger.
+   */
+  SpiLogger sql();
+
+  /**
+   * Return the TXN logger.
+   */
+  SpiLogger txn();
+
+  /**
+   * Return the Summary logger.
+   */
+  SpiLogger sum();
+
+}

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

@@ -0,0 +1,31 @@
+package io.ebeaninternal.api;
+
+/**
+ * Logger for SQL, TXN and Summary logging.
+ * <p>
+ * In general at runtime this uses SLF4J Logger but this abstraction allows us to capture
+ * the logged SQL during testing such that we can assert against the executed sql if desired.
+ * </p>
+ */
+public interface SpiLogger {
+
+  /**
+   * Is debug logging enabled.
+   */
+  boolean isDebug();
+
+  /**
+   * Is trace logging enabled.
+   */
+  boolean isTrace();
+
+  /**
+   * Log a debug level message.
+   */
+  void debug(String msg);
+
+  /**
+   * Log a trace level message.
+   */
+  void trace(String msg);
+}

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

@@ -0,0 +1,12 @@
+package io.ebeaninternal.api;
+
+/**
+ * API for Plugins to define the logger for io.ebean.SQL, io.ebean.TXN and io.ebean.SUM.
+ */
+public interface SpiLoggerFactory {
+
+  /**
+   * Create the logger given the name.
+   */
+  SpiLogger create(String name);
+}

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

@@ -644,9 +644,9 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
   boolean isBeanCachePut();
 
   /**
-   * Return true if the bean cache is being explicitly loaded via RECACHE mode.
+   * Return true if we must hit the DB (Cache reload or select for update).
    */
-  boolean isBeanCacheReload();
+  boolean isForceHitDatabase();
 
   /**
    * Return the cache mode for using the bean cache (Get and Put).

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,11 +1,11 @@
 package io.ebeaninternal.dbmigration;
 
-import io.ebean.Transaction;
 import io.ebean.config.ServerConfig;
-import io.ebeaninternal.dbmigration.model.CurrentModel;
-import io.ebeaninternal.api.SpiEbeanServer;
-import io.ebeaninternal.extraddl.model.ExtraDdlXmlReader;
 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;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -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,64 @@ 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) {
-      InputStream is = getClassLoader().getResourceAsStream(sqlScript);
-      if (is != null) {
-        String content = readContent(new InputStreamReader(is));
-        runScript(false, content, sqlScript);
+      try (InputStream is = getClassLoader().getResourceAsStream(sqlScript)) {
+        if (is != null) {
+          String content = readContent(new InputStreamReader(is));
+          runScript(connection,  false, content, sqlScript);
+        }
       }
     }
   }

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

@@ -91,6 +91,12 @@ public class DefaultDbMigration implements DbMigration {
   protected DbConstraintNaming constraintNaming;
 
   protected Boolean strictMode;
+  protected Boolean includeGeneratedFileComment;
+  protected String header;
+  protected String applyPrefix;
+  protected String version;
+  protected String name;
+  protected String generatePendingDrop;
 
   /**
    * Create for offline migration generation.
@@ -148,6 +154,36 @@ public class DefaultDbMigration implements DbMigration {
     this.strictMode = strictMode;
   }
 
+  @Override
+  public void setApplyPrefix(String applyPrefix) {
+    this.applyPrefix = applyPrefix;
+  }
+
+  @Override
+  public void setVersion(String version) {
+    this.version = version;
+  }
+
+  @Override
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public void setGeneratePendingDrop(String generatePendingDrop) {
+    this.generatePendingDrop = generatePendingDrop;
+  }
+
+  @Override
+  public void setIncludeGeneratedFileComment(boolean includeGeneratedFileComment) {
+    this.includeGeneratedFileComment = includeGeneratedFileComment;
+  }
+
+  @Override
+  public void setHeader(String header) {
+    this.header = header;
+  }
+
   /**
    * Set the specific platform to generate DDL for.
    * <p>
@@ -278,24 +314,28 @@ public class DefaultDbMigration implements DbMigration {
   private void generateExtraDdl(File migrationDir, DatabasePlatform dbPlatform) throws IOException {
 
     if (dbPlatform != null) {
-      ExtraDdl extraDdl = ExtraDdlXmlReader.read("/extra-ddl.xml");
-      if (extraDdl != null) {
-        List<DdlScript> ddlScript = extraDdl.getDdlScript();
-        for (DdlScript script : ddlScript) {
-          if (!script.isDrop() && ExtraDdlXmlReader.matchPlatform(dbPlatform.getName(), script.getPlatforms())) {
+      generateExtraDdl(migrationDir, dbPlatform, ExtraDdlXmlReader.readBuiltin());
+      generateExtraDdl(migrationDir, dbPlatform, ExtraDdlXmlReader.read());
+    }
+  }
+
+  private void generateExtraDdl(File migrationDir, DatabasePlatform dbPlatform, ExtraDdl extraDdl) throws IOException {
+    if (extraDdl != null) {
+      List<DdlScript> ddlScript = extraDdl.getDdlScript();
+      for (DdlScript script : ddlScript) {
+        if (!script.isDrop() && ExtraDdlXmlReader.matchPlatform(dbPlatform.getName(), script.getPlatforms())) {
             writeExtraDdl(migrationDir, script);
           }
         }
       }
     }
-  }
 
   /**
    * Write (or override) the "repeatable" migration script.
    */
   private void writeExtraDdl(File migrationDir, DdlScript script) throws IOException {
 
-    String fullName = repeatableMigrationName(script.getName());
+    String fullName = repeatableMigrationName(script.isInit(), script.getName());
 
     logger.info("writing repeatable script {}", fullName);
 
@@ -306,8 +346,18 @@ public class DefaultDbMigration implements DbMigration {
     }
   }
 
-  private String repeatableMigrationName(String scriptName) {
-    return "R__" + scriptName.replace(' ', '_') + migrationConfig.getApplySuffix();
+
+
+  private String repeatableMigrationName(boolean init, String scriptName) {
+    StringBuilder sb = new StringBuilder();
+    if (init) {
+      sb.append("I__");
+    } else {
+      sb.append("R__");
+    }
+    sb.append(scriptName.replace(' ', '_'));
+    sb.append(migrationConfig.getApplySuffix());
+    return sb.toString();
   }
 
   /**
@@ -512,8 +562,28 @@ public class DefaultDbMigration implements DbMigration {
       databasePlatform = server.getDatabasePlatform();
       logger.debug("set platform to {}", databasePlatform.getName());
     }
-    if (strictMode != null && migrationConfig != null) {
-      migrationConfig.setStrictMode(strictMode);
+    if (migrationConfig != null) {
+      if (strictMode != null) {
+        migrationConfig.setStrictMode(strictMode);
+      }
+      if (applyPrefix != null) {
+        migrationConfig.setApplyPrefix(applyPrefix);
+      }
+      if (header != null) {
+        migrationConfig.setDdlHeader(header);
+      }
+      if (includeGeneratedFileComment != null) {
+        migrationConfig.setIncludeGeneratedFileComment(includeGeneratedFileComment);
+      }
+      if (version != null) {
+        migrationConfig.setVersion(version);
+      }
+      if (name != null) {
+        migrationConfig.setName(name);
+      }
+      if (generatePendingDrop != null) {
+        migrationConfig.setGeneratePendingDrop(generatePendingDrop);
+      }
     }
   }
 

src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/DdlWrite.java

@@ -18,7 +18,9 @@ public class DdlWrite {
 
   private final DdlBuffer applyForeignKeys;
 
-  private final DdlBuffer applyHistory;
+  private final DdlBuffer applyHistoryView;
+
+  private final DdlBuffer applyHistoryTrigger;
 
   private final DdlBuffer dropAllForeignKeys;
 
@@ -39,7 +41,8 @@ public class DdlWrite {
     this.applyDropDependencies = new BaseDdlBuffer(configuration);
     this.apply = new BaseDdlBuffer(configuration);
     this.applyForeignKeys = new BaseDdlBuffer(configuration);
-    this.applyHistory = new BaseDdlBuffer(configuration);
+    this.applyHistoryView = new BaseDdlBuffer(configuration);
+    this.applyHistoryTrigger = new BaseDdlBuffer(configuration);
     this.dropAllForeignKeys = new BaseDdlBuffer(configuration);
     this.dropAll = new BaseDdlBuffer(configuration);
   }
@@ -61,7 +64,8 @@ public class DdlWrite {
   public boolean isApplyEmpty() {
     return apply.getBuffer().isEmpty()
       && applyForeignKeys.getBuffer().isEmpty()
-      && applyHistory.getBuffer().isEmpty()
+      && applyHistoryView.getBuffer().isEmpty()
+      && applyHistoryTrigger.getBuffer().isEmpty()
       && applyDropDependencies.getBuffer().isEmpty();
   }
 
@@ -90,10 +94,17 @@ public class DdlWrite {
   }
 
   /**
-   * Return the buffer that apply history DDL is written to.
+   * Return the buffer that apply history-view DDL is written to.
    */
-  public DdlBuffer applyHistory() {
-    return applyHistory;
+  public DdlBuffer applyHistoryView() {
+    return applyHistoryView;
+  }
+
+  /**
+   * Return the buffer that apply history-trigger DDL is written to.
+   */
+  public DdlBuffer applyHistoryTrigger() {
+    return applyHistoryTrigger;
   }
 
   /**

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

@@ -42,6 +42,12 @@ import java.util.Map;
  */
 public class BaseTableDdl implements TableDdl {
 
+  enum HistorySupport {
+    NONE,
+    SQL2011,
+    TRIGGER_BASED
+  }
+
   protected final DbConstraintNaming naming;
 
   protected final NamingConvention namingConvention;
@@ -78,22 +84,23 @@ public class BaseTableDdl implements TableDdl {
 
   private boolean strictMode;
 
-  private final boolean sql2011History;
+  private final HistorySupport historySupport;
 
   /**
    * Helper class that is used to execute the migration ddl before and after the migration action.
    */
   private class DdlMigrationHelp {
-    private List<String> before;
-    private List<String> after;
-    private String tableName;
-    private String columnName;
-    private String defaultValue;
+    private final List<String> before;
+    private final List<String> after;
+    private final String tableName;
+    private final String columnName;
+    private final String defaultValue;
+    private final boolean withHistory;
 
     /**
      * Constructor for DdlMigrationHelp when adding a NEW column.
      */
-    DdlMigrationHelp(String tableName, Column column) {
+    DdlMigrationHelp(String tableName, Column column, boolean withHistory) {
       this.tableName = tableName;
       this.columnName = column.getName();
       this.defaultValue = platformDdl.convertDefaultValue(column.getDefaultValue());
@@ -105,6 +112,7 @@ public class BaseTableDdl implements TableDdl {
 
       before = getScriptsForPlatform(column.getBefore(), platformDdl.getPlatform().getName());
       after = getScriptsForPlatform(column.getAfter(), platformDdl.getPlatform().getName());
+      this.withHistory = withHistory;
     }
 
     /**
@@ -119,6 +127,7 @@ public class BaseTableDdl implements TableDdl {
 
       boolean alterNotNull = Boolean.TRUE.equals(alter.isNotnull());
       // here we add the platform's default update script
+      withHistory = isTrue(alter.isWithHistory());
       if (alter.getBefore().isEmpty() && alterNotNull) {
         if (defaultValue == null) {
           handleStrictError(tableName, columnName);
@@ -134,6 +143,10 @@ public class BaseTableDdl implements TableDdl {
       if (!before.isEmpty()) {
         buffer.end();
       }
+
+      if (!before.isEmpty() && withHistory) {
+        buffer.append("-- NOTE: table has @History - special migration may be necessary").newLine();
+      }
       for (String ddlScript : before) {
         buffer.append(translate(ddlScript, tableName, columnName, this.defaultValue));
         buffer.endOfStatement();
@@ -141,6 +154,9 @@ public class BaseTableDdl implements TableDdl {
     }
 
     void writeAfter(DdlBuffer buffer) throws IOException {
+      if (!after.isEmpty() && withHistory) {
+        buffer.append("-- NOTE: table has @History - special migration may be necessary").newLine();
+      }
       // here we run post migration scripts
       for (String ddlScript : after) {
         buffer.append(translate(ddlScript, tableName, columnName, defaultValue));
@@ -198,7 +214,11 @@ public class BaseTableDdl implements TableDdl {
     this.platformDdl.configure(serverConfig);
     this.strictMode = serverConfig.getMigrationConfig().isStrictMode();
     DbHistorySupport hist = platformDdl.getPlatform().getHistorySupport();
-    this.sql2011History = hist != null && hist.isStandardsBased();
+    if (hist == null) {
+      this.historySupport = HistorySupport.NONE;
+    } else {
+      this.historySupport = hist.isStandardsBased() ? HistorySupport.SQL2011 : HistorySupport.TRIGGER_BASED;
+    }
   }
 
   /**
@@ -700,8 +720,14 @@ public class BaseTableDdl implements TableDdl {
    */
   @Override
   public void generateEpilog(DdlWrite write) throws IOException {
-    for (HistoryTableUpdate update : this.regenerateHistoryTriggers.values()) {
-      platformDdl.regenerateHistoryTriggers(write, update);
+    if (!regenerateHistoryTriggers.isEmpty()) {
+      platformDdl.lockTables(write.applyHistoryTrigger(), regenerateHistoryTriggers.keySet());
+
+      for (HistoryTableUpdate update : this.regenerateHistoryTriggers.values()) {
+        platformDdl.regenerateHistoryTriggers(write, update);
+      }
+
+      platformDdl.unlockTables(write.applyHistoryTrigger(), regenerateHistoryTriggers.keySet());
     }
     platformDdl.generateEpilog(write);
   }
@@ -722,15 +748,15 @@ public class BaseTableDdl implements TableDdl {
     String tableName = addColumn.getTableName();
     List<Column> columns = addColumn.getColumn();
     for (Column column : columns) {
-      alterTableAddColumn(writer.apply(), tableName, column, false);
+      alterTableAddColumn(writer.apply(), tableName, column, false, isTrue(addColumn.isWithHistory()));
     }
 
-    if (isTrue(addColumn.isWithHistory()) && !sql2011History) {
+    if (isTrue(addColumn.isWithHistory()) && historySupport == HistorySupport.TRIGGER_BASED) {
       // make same changes to the history table
       String historyTable = historyTable(tableName);
       for (Column column : columns) {
         regenerateHistoryTriggers(tableName, HistoryTableUpdate.Change.ADD, column.getName());
-        alterTableAddColumn(writer.apply(), historyTable, column, true);
+        alterTableAddColumn(writer.apply(), historyTable, column, true, true);
       }
     }
 
@@ -771,7 +797,8 @@ public class BaseTableDdl implements TableDdl {
     String tableName = dropColumn.getTableName();
 
     alterTableDropColumn(writer.apply(), tableName, dropColumn.getColumnName());
-    if (isTrue(dropColumn.isWithHistory()) && !sql2011History) {
+
+    if (isTrue(dropColumn.isWithHistory())  && historySupport == HistorySupport.TRIGGER_BASED) {
       // also drop from the history table
       regenerateHistoryTriggers(tableName, HistoryTableUpdate.Change.DROP, dropColumn.getColumnName());
       alterTableDropColumn(writer.apply(), historyTable(tableName), dropColumn.getColumnName());
@@ -813,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())) {
@@ -872,8 +902,9 @@ public class BaseTableDdl implements TableDdl {
     if (hasValue(ddl)) {
       writer.apply().append(ddl).endOfStatement();
 
-      if (isTrue(alter.isWithHistory()) && alter.getType() != null && !sql2011History) {
+      if (isTrue(alter.isWithHistory()) && alter.getType() != null && historySupport == historySupport.TRIGGER_BASED) {
         // mysql and sql server column type change allowing nulls in the history table column
+        regenerateHistoryTriggers(alter.getTableName(), HistoryTableUpdate.Change.ALTER, alter.getColumnName());
         AlterColumn alterHistoryColumn = new AlterColumn();
         alterHistoryColumn.setTableName(historyTable(alter.getTableName()));
         alterHistoryColumn.setColumnName(alter.getColumnName());
@@ -894,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();
     }
@@ -923,7 +954,8 @@ public class BaseTableDdl implements TableDdl {
     String ddl = platformDdl.alterColumnType(alter.getTableName(), alter.getColumnName(), alter.getType());
     if (hasValue(ddl)) {
       writer.apply().append(ddl).endOfStatement();
-      if (isTrue(alter.isWithHistory()) && !sql2011History) {
+      if (isTrue(alter.isWithHistory()) && historySupport == HistorySupport.TRIGGER_BASED) {
+        regenerateHistoryTriggers(alter.getTableName(), HistoryTableUpdate.Change.ALTER, alter.getColumnName());
         // apply same type change to matching column in the history table
         ddl = platformDdl.alterColumnType(historyTable(alter.getTableName()), alter.getColumnName(), alter.getType());
         writer.apply().append(ddl).endOfStatement();
@@ -979,8 +1011,8 @@ public class BaseTableDdl implements TableDdl {
     platformDdl.alterTableDropColumn(buffer, tableName, columnName);
   }
 
-  protected void alterTableAddColumn(DdlBuffer buffer, String tableName, Column column, boolean onHistoryTable) throws IOException {
-    DdlMigrationHelp help = new DdlMigrationHelp(tableName, column);
+  protected void alterTableAddColumn(DdlBuffer buffer, String tableName, Column column, boolean onHistoryTable, boolean withHistory) throws IOException {
+    DdlMigrationHelp help = new DdlMigrationHelp(tableName, column, withHistory);
     if (!onHistoryTable) {
       help.writeBefore(buffer);
     }

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

@@ -69,7 +69,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
    */
   protected void updateTriggers(DdlWrite writer, MTable table, HistoryTableUpdate update) throws IOException {
 
-    writer.applyHistory().append("-- changes: ").append(update.description()).newLine();
+    writer.applyHistoryTrigger().append("-- changes: ").append(update.description()).newLine();
 
     updateHistoryTriggers(createDbTriggerUpdate(writer, table));
   }
@@ -154,7 +154,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
 
     String baseTableName = table.getName();
 
-    DdlBuffer apply = writer.applyHistory();
+    DdlBuffer apply = writer.applyHistoryView();
 
     addSysPeriodColumns(apply, baseTableName, whenCreatedColumn);
     createHistoryTable(apply, table);
@@ -210,19 +210,19 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
       .endOfStatement().end();
   }
 
-  /**
-   * Create or replace the with_history view with explicit columns.
-   */
-  protected void createWithHistoryView(DbTriggerUpdate update) throws IOException {
 
-    DdlBuffer apply = update.historyBuffer();
-    apply.append("create or replace view ").append(update.getBaseTable()).append(viewSuffix).append(" as select ");
-    appendColumnNames(apply, update.getColumns(), "");
-    appendSysPeriodColumns(apply, ", ");
-    apply.append(" from ").append(update.getBaseTable()).append(" union all select ");
-    appendColumnNames(apply, update.getColumns(), "");
-    appendSysPeriodColumns(apply, ", ");
-    apply.append(" from ").append(update.getHistoryTable()).endOfStatement().end();
+  /**
+   * For postgres/h2/mysql we need to drop and recreate the view. Well, we could add columns to the end of the view
+   * but otherwise we need to drop and create it.
+   */
+  protected void recreateHistoryView(DbTriggerUpdate update) throws IOException {
+
+    DdlBuffer buffer = update.dropDependencyBuffer();
+    // we need to drop the view early/first before any changes to the tables etc
+    buffer.append("drop view if exists ").append(update.getBaseTable()).append(viewSuffix).endOfStatement();
+
+    // recreate the view after all ddl modifications - the view requires ALL columns, also the historyExclude ones.
+    createWithHistoryView(update.historyViewBuffer(), update.getBaseTable());
   }
 
   protected void appendSysPeriodColumns(DdlBuffer apply, String prefix) throws IOException {

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

@@ -28,10 +28,18 @@ public class DbTriggerUpdate {
   /**
    * Return the appropriate buffer for the current mode.
    */
-  public DdlBuffer historyBuffer() {
-    return writer.applyHistory();
+  public DdlBuffer historyViewBuffer() {
+    return writer.applyHistoryView();
   }
 
+  /**
+   * Return the appropriate buffer for the current mode.
+   */
+  public DdlBuffer historyTriggerBuffer() {
+    return writer.applyHistoryTrigger();
+  }
+
+
   /**
    * Return the appropriate drop dependency buffer for the current mode.
    */

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

@@ -27,7 +27,7 @@ public class H2HistoryDdl extends DbTriggerBasedHistoryDdl {
   protected void createTriggers(DdlWrite writer, MTable table) throws IOException {
 
     String baseTableName = table.getName();
-    DdlBuffer apply = writer.applyHistory();
+    DdlBuffer apply = writer.applyHistoryTrigger();
 
     addCreateTrigger(apply, updateTriggerName(baseTableName), baseTableName);
   }
@@ -35,7 +35,9 @@ public class H2HistoryDdl extends DbTriggerBasedHistoryDdl {
   @Override
   protected void updateHistoryTriggers(DbTriggerUpdate update) throws IOException {
 
-    DdlBuffer buffer = update.historyBuffer();
+    recreateHistoryView(update);
+
+    DdlBuffer buffer = update.historyTriggerBuffer();
     dropTriggers(buffer, update.getBaseTable());
     addCreateTrigger(buffer, updateTriggerName(update.getBaseTable()), update.getBaseTable());
   }

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

@@ -17,7 +17,8 @@ public class HistoryTableUpdate {
     ADD,
     DROP,
     INCLUDE,
-    EXCLUDE
+    EXCLUDE,
+    ALTER
   }
 
   private static class Column {

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

@@ -7,6 +7,7 @@ import io.ebeaninternal.dbmigration.migration.AlterColumn;
 import io.ebeaninternal.dbmigration.migration.Column;
 
 import java.io.IOException;
+import java.util.Collection;
 
 /**
  * MySql specific DDL.
@@ -37,9 +38,20 @@ public class MySqlDdl extends PlatformDdl {
     return "alter table " + tableName + " drop foreign key " + maxConstraintName(fkName);
   }
 
+  /**
+   * It is rather complex to delete a column on MySql as there must not exist any foreign keys.
+   * That's why we call a user stored procedure here
+   */
+  @Override
+  public void alterTableDropColumn(DdlBuffer buffer, String tableName, String columnName) throws IOException {
+
+    buffer.append("CALL usp_ebean_drop_column('").append(tableName).append("', '").append(columnName).append("')").endOfStatement();
+  }
+
   @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;
   }
 
@@ -59,7 +71,7 @@ public class MySqlDdl extends PlatformDdl {
   @Override
   public String alterColumnDefaultValue(String tableName, String columnName, String defaultValue) {
 
-    String suffix = DdlHelp.isDropDefault(defaultValue) ? columnDropDefault : columnSetDefault + " " + defaultValue;
+    String suffix = DdlHelp.isDropDefault(defaultValue) ? columnDropDefault : columnSetDefault + " " + convertDefaultValue(defaultValue);
 
     // use alter
     return "alter table " + tableName + " alter " + columnName + " " + suffix;
@@ -113,10 +125,39 @@ public class MySqlDdl extends PlatformDdl {
     }
     apply.append(String.format("alter table %s comment = '%s'", tableName, tableComment)).endOfStatement();
   }
-  
+
   @Override
   public void addColumnComment(DdlBuffer apply, String table, String column, String comment) throws IOException {
     // alter comment currently not supported as it requires to repeat whole column definition
   }
-  
+
+
+  /**
+   * Locks all tables for triggers that have to be updated.
+   */
+  @Override
+  public void lockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
+    if (!tables.isEmpty()) {
+      buffer.append("lock tables ");
+      int i = 0;
+      for (String table : tables) {
+        if (i > 0) {
+          buffer.append(", ");
+        }
+        buffer.append(table).append(" write");
+        i++;
+      }
+      buffer.endOfStatement();
+
+    }
+  }
+
+  /**
+   * Unlocks all tables for triggers that have to be updated.
+   */
+  @Override
+  public void unlockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
+    buffer.append("unlock tables").endOfStatement();
+  }
+
 }

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

@@ -34,19 +34,19 @@ public class MySqlHistoryDdl extends DbTriggerBasedHistoryDdl {
   @Override
   protected void updateHistoryTriggers(DbTriggerUpdate update) throws IOException {
 
-    DdlBuffer buffer = update.historyBuffer();
+    recreateHistoryView(update);
+
+    DdlBuffer buffer = update.historyTriggerBuffer();
     String baseTable = update.getBaseTable();
 
-    buffer.append("lock tables ").append(baseTable).append(" write").endOfStatement();
     dropTriggers(buffer, baseTable);
     addBeforeUpdate(updateTriggerName(baseTable), update);
     addBeforeDelete(deleteTriggerName(baseTable), update);
-    buffer.append("unlock tables").endOfStatement();
   }
 
   private void addBeforeUpdate(String triggerName, DbTriggerUpdate update) throws IOException {
 
-    DdlBuffer apply = update.historyBuffer();
+    DdlBuffer apply = update.historyTriggerBuffer();
     apply
       .append("delimiter $$").newLine()
       .append("create trigger ").append(triggerName).append(" before update on ").append(update.getBaseTable())
@@ -59,7 +59,7 @@ public class MySqlHistoryDdl extends DbTriggerBasedHistoryDdl {
 
   private void addBeforeDelete(String triggerName, DbTriggerUpdate update) throws IOException {
 
-    DdlBuffer apply = update.historyBuffer();
+    DdlBuffer apply = update.historyTriggerBuffer();
     apply
       .append("delimiter $$").newLine()
       .append("create trigger ").append(triggerName).append(" before delete on ").append(update.getBaseTable())

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

@@ -20,10 +20,12 @@ import io.ebeaninternal.dbmigration.migration.Column;
 import io.ebeaninternal.dbmigration.migration.DropHistoryTable;
 import io.ebeaninternal.dbmigration.migration.IdentityType;
 import io.ebeaninternal.dbmigration.model.MTable;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -77,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";
@@ -246,6 +246,9 @@ public class PlatformDdl {
    * Convert the standard type to the platform specific type.
    */
   public String convert(String type, boolean identity) {
+    if (type == null) {
+      return null;
+    }
     if (type.contains("[]")) {
       return convertArrayType(type);
     }
@@ -418,7 +421,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);
   }
 
   /**
@@ -442,13 +445,16 @@ public class PlatformDdl {
       .append(" ").append(addColumn).append(" ").append(column.getName())
       .append(" ").append(convertedType);
 
-    if (!onHistoryTable) {
 
-      if (defaultValue != null) {
+    // Add default value also to history table if it is not excluded
+    if (defaultValue != null) {
+      if (!onHistoryTable || !isTrue(column.isHistoryExclude())) {
         buffer.append(" default ");
         buffer.append(defaultValue);
       }
+    }
 
+    if (!onHistoryTable) {
       if (isTrue(column.isNotnull())) {
         buffer.append(" not null");
       }
@@ -456,7 +462,8 @@ public class PlatformDdl {
 
       // check constraints cannot be added in one statement for h2
       if (!StringHelper.isNull(column.getCheckConstraint())) {
-        String ddl = alterTableAddCheckConstraint(tableName, column.getCheckConstraintName(), column.getCheckConstraint());
+        String ddl = alterTableAddCheckConstraint(tableName, column.getCheckConstraintName(),
+            column.getCheckConstraint());
         buffer.append(ddl).endOfStatement();
       }
     } else {
@@ -641,4 +648,18 @@ public class PlatformDdl {
     }
     return name;
   }
+
+  /**
+   * Mysql-specific: Locks all tables for triggers that have to be updated.
+   */
+  public void lockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
+
+  }
+
+  /**
+   * Mysql-specific: Unlocks all tables for triggers that have to be updated.
+   */
+  public void unlockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
+
+  }
 }

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

@@ -62,7 +62,7 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
     String procedureName = procedureName(baseTableName);
     String triggerName = triggerName(baseTableName);
 
-    DdlBuffer apply = writer.applyHistory();
+    DdlBuffer apply = writer.applyHistoryTrigger();
     apply
       .append("create trigger ").append(triggerName).newLine()
       .append("  before update or delete on ").append(baseTableName).newLine()
@@ -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();
@@ -107,7 +115,7 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
     String historyTable = historyTableName(table.getName());
 
     List<String> columnNames = columnNamesForApply(table);
-    createOrReplaceFunction(writer.applyHistory(), procedureName, historyTable, columnNames);
+    createOrReplaceFunction(writer.applyHistoryTrigger(), procedureName, historyTable, columnNames);
   }
 
   @Override
@@ -116,21 +124,7 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
     String procedureName = procedureName(update.getBaseTable());
 
     recreateHistoryView(update);
-    createOrReplaceFunction(update.historyBuffer(), procedureName, update.getHistoryTable(), update.getColumns());
-  }
-
-  /**
-   * For postgres we need to drop and recreate the view. Well, we could add columns to the end of the view
-   * but otherwise we need to drop and create it.
-   */
-  private void recreateHistoryView(DbTriggerUpdate update) throws IOException {
-
-    DdlBuffer buffer = update.dropDependencyBuffer();
-    // we need to drop the view early/first before any changes to the tables etc
-    buffer.append("drop view if exists ").append(update.getBaseTable()).append(viewSuffix).endOfStatement();
-
-    // recreate the view with specific columns specified (the columns generally are not dropped until later)
-    createWithHistoryView(update);
+    createOrReplaceFunction(update.historyTriggerBuffer(), procedureName, update.getHistoryTable(), update.getColumns());
   }
 
   @Override
@@ -138,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/ddlgeneration/platform/SqlServerDdl.java

@@ -3,7 +3,9 @@ package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 import io.ebean.annotation.ConstraintMode;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
 import io.ebeaninternal.dbmigration.migration.AlterColumn;
+import io.ebeaninternal.server.persist.platform.MultiValueBind;
 
 import java.io.IOException;
 
@@ -137,13 +139,7 @@ public class SqlServerDdl extends PlatformDdl {
     // a rather complex statement.
     StringBuilder sb = new StringBuilder();
     if (DdlHelp.isDropDefault(defaultValue)) {
-      sb.append("delimiter $$\n");
-      sb.append("DECLARE @Tmp nvarchar(200);");
-      sb.append("select @Tmp = t1.name  from sys.default_constraints t1\n");
-      sb.append("  join sys.columns t2 on t1.object_id = t2.default_object_id\n");
-      sb.append("  where t1.parent_object_id = OBJECT_ID('").append(tableName)
-        .append("') and t2.name = '").append(columnName).append("';\n");
-      sb.append("if @Tmp is not null EXEC('alter table ").append(tableName).append(" drop constraint ' + @Tmp)$$");
+      sb.append("EXEC usp_ebean_drop_default_constraint ").append(tableName).append(", ").append(columnName);
     } else {
       sb.append("alter table ").append(tableName);
       sb.append(" add default ").append(convertDefaultValue(defaultValue)).append(" for ").append(columnName);
@@ -200,25 +196,50 @@ public class SqlServerDdl extends PlatformDdl {
 
   /**
    * It is rather complex to delete a column on SqlServer as there must not exist any references
-   * (constraints, default values, indices and foreign keys). The list is not yet complete, as
-   * indices over multiple columns will not yet deleted.
-   * (This may be changed to delete all refering objects by using the sys.* tables later)
+   * (constraints, default values, indices and foreign keys). That's why we call a user stored procedure here
    */
   @Override
   public void alterTableDropColumn(DdlBuffer buffer, String tableName, String columnName) throws IOException {
-    buffer.append("-- drop column ").append(tableName).append(".").append(columnName).endOfStatement();
 
-    buffer.append(alterTableDropUniqueConstraint(tableName, naming.uniqueConstraintName(tableName, columnName)));
-    buffer.endOfStatement();
-    buffer.append(alterColumnDefaultValue(tableName, columnName, DdlHelp.DROP_DEFAULT));
-    buffer.endOfStatement();
-    buffer.append(alterTableDropConstraint(tableName, naming.checkConstraintName(tableName, columnName)));
-    buffer.endOfStatement();
-    buffer.append(dropIndex(naming.indexName(tableName, columnName), tableName));
-    buffer.endOfStatement();
-    buffer.append(alterTableDropForeignKey(tableName, naming.foreignKeyConstraintName(tableName, columnName)));
-    buffer.endOfStatement();
-    super.alterTableDropColumn(buffer, tableName, columnName);
+    buffer.append("EXEC usp_ebean_drop_column ").append(tableName).append(", ").append(columnName).endOfStatement();
+  }
+
+  /**
+   * This writes the multi value datatypes needed for {@link MultiValueBind}
+   */
+  @Override
+  public void generateProlog(DdlWrite write) throws IOException {
+    super.generateProlog(write);
+
+    generateTVPDefinitions(write, "bigint");
+    generateTVPDefinitions(write, "float");
+    generateTVPDefinitions(write, "bit");
+    generateTVPDefinitions(write, "date");
+    generateTVPDefinitions(write, "time");
+    //generateTVPDefinitions(write, "datetime2");
+    generateTVPDefinitions(write, "uniqueidentifier");
+    generateTVPDefinitions(write, "nvarchar(max)");
+
+  }
+
+  private void generateTVPDefinitions(DdlWrite write, String definition) throws IOException {
+    int pos = definition.indexOf('(');
+    String name = pos == -1 ? definition : definition.substring(0, pos);
+
+    dropTVP(write.dropAll(), name);
+    //TVPs are included in "I__create_procs.sql"
+    //createTVP(write.apply(), name, definition);
+  }
+
+  private void dropTVP(DdlBuffer ddl, String name) throws IOException {
+    ddl.append("if exists (select name  from sys.types where name = 'ebean_").append(name)
+        .append("_tvp') drop type ebean_").append(name).append("_tvp").endOfStatement();
+  }
+
+  private void createTVP(DdlBuffer ddl, String name, String definition) throws IOException {
+    ddl.append("if not exists (select name  from sys.types where name = 'ebean_").append(name)
+    .append("_tvp') create type ebean_").append(name).append("_tvp as table (c1 ").append(definition).append(")")
+        .endOfStatement();
   }
 
 }

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

@@ -31,19 +31,24 @@ public class SqlServerHistoryDdl implements PlatformHistoryDdl {
     enableSystemVersioning(writer, baseTable);
   }
 
-  private void enableSystemVersioning(DdlWrite writer, String baseTable) throws IOException {
-    DdlBuffer apply = writer.applyHistory();
-    apply.append("alter table ").append(baseTable).newLine()
-      .append("    add ").append(systemPeriodStart).append(" datetime2 GENERATED ALWAYS AS ROW START NOT NULL DEFAULT SYSUTCDATETIME(),").newLine()
-      .append("        ").append(systemPeriodEnd).append("   datetime2 GENERATED ALWAYS AS ROW END   NOT NULL DEFAULT '9999-12-31T23:59:59.9999999',").newLine()
-      .append("period for system_time (").append(systemPeriodStart).append(", ").append(systemPeriodEnd).append(")").endOfStatement();
-
+  private String getHistoryTable(String baseTable) {
     String historyTable = baseTable + "_history"; // history must contain schema, otherwise you'll get
     // Setting SYSTEM_VERSIONING to ON failed because history table 'xxx_history' is not specified in two-part name format.
     if (historyTable.indexOf('.') == -1) {
       historyTable = "dbo." +historyTable; // so add the default schema, if none was specified.
     }
-    apply.append("alter table ").append(baseTable).append(" set (system_versioning = on (history_table=").append(historyTable).append("))").endOfStatement();
+    return historyTable;
+  }
+
+  private void enableSystemVersioning(DdlWrite writer, String baseTable) throws IOException {
+    DdlBuffer apply = writer.applyHistoryView();
+    apply.append("alter table ").append(baseTable).newLine()
+      .append("    add ").append(systemPeriodStart).append(" datetime2 GENERATED ALWAYS AS ROW START NOT NULL DEFAULT SYSUTCDATETIME(),").newLine()
+      .append("        ").append(systemPeriodEnd).append("   datetime2 GENERATED ALWAYS AS ROW END   NOT NULL DEFAULT '9999-12-31T23:59:59.9999999',").newLine()
+      .append("period for system_time (").append(systemPeriodStart).append(", ").append(systemPeriodEnd).append(")").endOfStatement();
+
+    apply.append("alter table ").append(baseTable).append(" set (system_versioning = on (history_table=")
+      .append(getHistoryTable(baseTable)).append("))").endOfStatement();
 
     DdlBuffer drop = writer.dropAll();
     drop.append("IF OBJECT_ID('").append(baseTable).append("', 'U') IS NOT NULL alter table ").append(baseTable).append(" set (system_versioning = off)").endOfStatement();
@@ -53,7 +58,7 @@ public class SqlServerHistoryDdl implements PlatformHistoryDdl {
   @Override
   public void dropHistoryTable(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException {
     String baseTable = dropHistoryTable.getBaseTable();
-    DdlBuffer apply = writer.applyHistory();
+    DdlBuffer apply = writer.applyHistoryView();
     apply.append("-- dropping history support for ").append(baseTable).endOfStatement();
     // drop default constraints
 
@@ -76,7 +81,15 @@ public class SqlServerHistoryDdl implements PlatformHistoryDdl {
   }
 
   @Override
-  public void updateTriggers(DdlWrite write, HistoryTableUpdate baseTable) throws IOException {
+  public void updateTriggers(DdlWrite writer, HistoryTableUpdate baseTable) throws IOException {
     // SQL Server 2016 does not need triggers
+    DdlBuffer apply = writer.applyHistoryView();
+    String baseTableName = baseTable.getBaseTable();
+    apply.append("-- alter table ").append(baseTableName).append(" set (system_versioning = off (history_table=")
+    .append(getHistoryTable(baseTableName)).append("))").endOfStatement();
+    apply.append("-- history migration goes here").newLine();
+    apply.append("-- alter table ").append(baseTableName).append(" set (system_versioning = on (history_table=")
+    .append(getHistoryTable(baseTableName)).append("))").endOfStatement();
+
   }
 }

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/migrationreader/MigrationXmlReader.java

@@ -24,12 +24,14 @@ public class MigrationXmlReader {
    */
   public static Migration read(String resourcePath) {
 
-    InputStream is = MigrationXmlReader.class.getResourceAsStream(resourcePath);
-    if (is == null) {
-      throw new IllegalArgumentException("No resource found for path [" + resourcePath + "]");
+    try (InputStream is = MigrationXmlReader.class.getResourceAsStream(resourcePath)) {
+      if (is == null) {
+        throw new IllegalArgumentException("No resource found for path [" + resourcePath + "]");
+      }
+      return read(is);
+    } catch (IOException e) {
+      throw new IllegalArgumentException("Failed to auto close resource " + resourcePath, e);
     }
-
-    return read(is);
   }
 
   /**

src/main/java/io/ebeaninternal/dbmigration/migrationreader/MigrationXmlWriter.java

@@ -29,7 +29,6 @@ public class MigrationXmlWriter {
     try (FileWriter writer = new FileWriter(file)) {
 
       writer.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
-      writer.write("<!DOCTYPE xml>\n");
       if (comment != null) {
         writer.write("<!-- ");
         writer.write(comment);

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

@@ -9,8 +9,12 @@ import io.ebeaninternal.dbmigration.migration.ChangeSet;
 import io.ebeaninternal.dbmigration.model.build.ModelBuildBeanVisitor;
 import io.ebeaninternal.dbmigration.model.build.ModelBuildContext;
 import io.ebeaninternal.dbmigration.model.visitor.VisitAllUsing;
+import io.ebeaninternal.extraddl.model.DdlScript;
+import io.ebeaninternal.extraddl.model.ExtraDdl;
+import io.ebeaninternal.extraddl.model.ExtraDdlXmlReader;
 
 import java.io.IOException;
+import java.util.List;
 
 /**
  * Reads EbeanServer bean descriptors to build the current model.
@@ -111,9 +115,23 @@ public class CurrentModel {
     if (header != null && !header.isEmpty()) {
       ddl.append(header).append('\n');
     }
+
+    ExtraDdl extraDdl = ExtraDdlXmlReader.readBuiltin();
+    if (extraDdl != null) {
+      List<DdlScript> ddlScript = extraDdl.getDdlScript();
+      for (DdlScript script : ddlScript) {
+        if (script.isInit() && ExtraDdlXmlReader.matchPlatform(server.getDatabasePlatform().getName(), script.getPlatforms())) {
+          ddl.append("-- init script " + script.getName()).append('\n');
+          ddl.append(script.getValue());
+        }
+      }
+    }
+
+
     ddl.append(write.apply().getBuffer());
     ddl.append(write.applyForeignKeys().getBuffer());
-    ddl.append(write.applyHistory().getBuffer());
+    ddl.append(write.applyHistoryView().getBuffer());
+    ddl.append(write.applyHistoryTrigger().getBuffer());
 
     return ddl.toString();
   }

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

@@ -527,5 +527,8 @@ public class MColumn {
     if (hasValue(alterColumn.getForeignKeyOnUpdate())) {
       fkeyOnUpdate = fkeyMode(alterColumn.getForeignKeyOnUpdate());
     }
+    if (hasValue(alterColumn.isHistoryExclude())) {
+      historyExclude = alterColumn.isHistoryExclude();
+    }
   }
 }

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

@@ -621,7 +621,7 @@ public class MTable {
     DropColumn dropColumn = new DropColumn();
     dropColumn.setTableName(name);
     dropColumn.setColumnName(existingColumn.getName());
-    if (withHistory && !existingColumn.isHistoryExclude()) {
+    if (withHistory) {
       // These dropColumns should occur on the history
       // table as well as the base table
       dropColumn.setWithHistory(Boolean.TRUE);

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/PlatformDdlWriter.java

@@ -97,7 +97,8 @@ public class PlatformDdlWriter {
     writer.append("-- apply changes\n");
     writer.append(write.apply().getBuffer());
     writer.append(write.applyForeignKeys().getBuffer());
-    writer.append(write.applyHistory().getBuffer());
+    writer.append(write.applyHistoryView().getBuffer());
+    writer.append(write.applyHistoryTrigger().getBuffer());
   }
 
   private void prependDropDependencies(Writer writer, DdlBuffer buffer) throws IOException {

src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildIntersectionTable.java

@@ -5,6 +5,7 @@ import io.ebeaninternal.dbmigration.model.MTable;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import io.ebeaninternal.server.deploy.PropertyForeignKey;
 import io.ebeaninternal.server.deploy.TableJoin;
 import io.ebeaninternal.server.deploy.TableJoinColumn;
 
@@ -48,10 +49,12 @@ class ModelBuildIntersectionTable {
 
   private void buildFkConstraints() {
 
-    ctx.fkeyBuilder(intersectionTable)
-      .addForeignKey(manyProp.getBeanDescriptor(), intersectionTableJoin, true)
-      .addForeignKey(manyProp.getTargetDescriptor(), tableJoin, false);
-
+    PropertyForeignKey foreignKey = manyProp.getForeignKey();
+    if (foreignKey == null || !foreignKey.isNoConstraint()) {
+      ctx.fkeyBuilder(intersectionTable)
+        .addForeignKey(manyProp.getBeanDescriptor(), intersectionTableJoin, true)
+        .addForeignKey(manyProp.getTargetDescriptor(), tableJoin, false);
+    }
     intersectionTable.checkDuplicateForeignKeys();
   }
 

src/main/java/io/ebeaninternal/dbmigration/model/build/ModelBuildPropertyVisitor.java

@@ -258,12 +258,13 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
       }
     } else {
       col.setDefaultValue(p.getDbColumnDefault());
-      col.setDbMigrationInfos(p.getDbMigrationInfos());
       if (!p.isNullable() || p.isDDLNotNull()) {
         col.setNotnull(true);
       }
     }
 
+    col.setDbMigrationInfos(p.getDbMigrationInfos());
+
     if (p.isUnique() && !p.isId()) {
       col.setUnique(determineUniqueConstraintName(col.getName()));
       indexSetAdd(col.getName());

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/extraddl/model/DdlScript.java

@@ -39,7 +39,8 @@ public class DdlScript {
   protected String platforms;
   @XmlAttribute(name = "drop")
   protected boolean drop;
-
+  @XmlAttribute(name = "init")
+  protected boolean init;
   /**
    * Gets the value of the value property.
    *
@@ -114,4 +115,17 @@ public class DdlScript {
     this.drop = drop;
   }
 
+  /**
+   * Return if this a init script.
+   */
+  public boolean isInit() {
+    return init;
+  }
+
+  /**
+   * Sets that this is a init script.
+   */
+  public void setInit(boolean init) {
+    this.init = init;
+  }
 }

src/main/java/io/ebeaninternal/extraddl/model/ExtraDdlXmlReader.java

@@ -8,6 +8,7 @@ import org.slf4j.LoggerFactory;
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
+import java.io.IOException;
 import java.io.InputStream;
 
 /**
@@ -82,17 +83,34 @@ public class ExtraDdlXmlReader {
     }
   }
 
+  /**
+   * Read the builtin extra ddl. (Stored procedures, tvp types etc)
+   */
+  public static ExtraDdl readBuiltin() {
+    return read("/io/ebeaninternal/dbmigration/builtin-extra-ddl.xml");
+  }
+
+  /**
+   * Read the extra ddl.
+   */
+  public static ExtraDdl read() {
+    return read("/extra-ddl.xml");
+  }
+
   /**
    * Read and return a ExtraDdl from an xml document at the given resource path.
    */
-  public static ExtraDdl read(String resourcePath) {
+  private static ExtraDdl read(String resourcePath) {
 
-    InputStream is = ExtraDdlXmlReader.class.getResourceAsStream(resourcePath);
-    if (is == null) {
-      // we expect this and check for null
-      return null;
+    try (InputStream is = ExtraDdlXmlReader.class.getResourceAsStream(resourcePath)) {
+      if (is == null) {
+        // we expect this and check for null
+        return null;
+      }
+      return read(is);
+    } catch (IOException e) {
+      throw new IllegalStateException("Error on auto close of " + resourcePath, e);
     }
-    return read(is);
   }
 
   /**

src/main/java/io/ebeaninternal/server/autotune/service/BaseQueryTuner.java

@@ -144,7 +144,7 @@ public class BaseQueryTuner {
       default:
         // not using autoTune when explicitly loading the l2 bean cache
         // or when using Versions query
-        return !query.isBeanCacheReload() && SpiQuery.TemporalMode.VERSIONS != query.getTemporalMode();
+        return !query.isForceHitDatabase() && SpiQuery.TemporalMode.VERSIONS != query.getTemporalMode();
     }
   }
 

src/main/java/io/ebeaninternal/server/autotune/service/DefaultAutoTuneService.java

@@ -12,6 +12,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.InputStream;
 import java.util.concurrent.TimeUnit;
 
@@ -106,11 +107,14 @@ public class DefaultAutoTuneService implements AutoTuneService {
       loadAutoTuneProfiling(AutoTuneXmlReader.read(file));
     } else {
       // look for autotune as a resource
-      InputStream stream = getClass().getResourceAsStream("/" + tuningFile);
-      if (stream != null) {
-        loadAutoTuneProfiling(AutoTuneXmlReader.read(stream));
-      } else {
-        logger.warn("AutoTune file {} not found - no initial automatic query tuning", tuningFile);
+      try (InputStream stream = getClass().getResourceAsStream("/" + tuningFile)) {
+        if (stream != null) {
+          loadAutoTuneProfiling(AutoTuneXmlReader.read(stream));
+        } else {
+          logger.warn("AutoTune file {} not found - no initial automatic query tuning", tuningFile);
+        }
+      } catch (IOException e) {
+        throw new IllegalStateException("Error on auto close of " + tuningFile, e);
       }
     }
   }

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/AbstractSqlQueryRequest.java

@@ -170,11 +170,7 @@ public abstract class AbstractSqlQueryRequest {
     }
 
     if (isLogSql()) {
-      String logSql = TrimLogSql.trim(sql);
-      if (TransactionManager.SQL_LOGGER.isTraceEnabled()) {
-        logSql = Str.add(logSql, "; --bind(", bindLog, ")");
-      }
-      trans.logSql(logSql);
+      trans.logSql(Str.add(TrimLogSql.trim(sql), "; --bind(", bindLog, ")"));
     }
 
     setResultSet(pstmt.executeQuery(), null);

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/DatabasePlatformFactory.java

@@ -14,7 +14,7 @@ import io.ebean.config.dbplatform.sqlanywhere.SqlAnywherePlatform;
 import io.ebean.config.dbplatform.sqlite.SQLitePlatform;
 import io.ebean.config.dbplatform.sqlserver.SqlServer16Platform;
 import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
-import io.ebean.migration.util.JdbcClose;
+import io.ebean.util.JdbcClose;
 import io.ebeaninternal.dbmigration.DbOffline;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -126,13 +126,7 @@ public class DatabasePlatformFactory {
       throw new PersistenceException(ex);
 
     } finally {
-      try {
-        if (connection != null) {
-          connection.close();
-        }
-      } catch (SQLException ex) {
-        logger.error(null, ex);
-      }
+      JdbcClose.close(connection);
     }
   }