[maven-release-plugin] prepare release avaje-ebeanorm-6.16.5

Added support for custom database functions that have multiple arguments

.travis.yml

@@ -0,0 +1,32 @@
+sudo: required
+language: java
+jdk:
+  - oraclejdk8
+
+git:
+  depth: 3
+
+addons:
+  postgresql: "9.4"
+
+services:
+  - postgresql
+
+before_script:
+  - ./.travis/setup_database
+
+env:
+  - EBEAN_DB=h2
+  - EBEAN_DB=pg
+
+install: true
+
+script:
+  - mvn clean test
+
+after_failure:
+  - ./.travis/print_surefire_reports
+
+cache:
+  directories:
+  - $HOME/.m2

.travis/print_surefire_reports

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+echo "\n=== SUREFIRE REPORTS ===\n"
+
+for file in target/surefire-reports/*.txt
+do
+    echo ${file}
+    cat ${file}
+    echo
+done

.travis/setup_database

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+echo "\n=== SETUP DATABASE ===\n"
+
+#set -e
+#set -x
+
+# Setup postgres' users and databases
+sudo -u postgres psql -c "CREATE USER unit WITH PASSWORD 'unit';"
+sudo -u postgres psql -c 'CREATE DATABASE unit WITH OWNER unit;'
+sudo -u postgres psql unit -c 'CREATE EXTENSION hstore;'
+sudo -u postgres psql unit -c 'CREATE EXTENSION pgcrypto;'
+#sudo -u postgres psql test2 -c 'CREATE EXTENSION postgis;'
+

pom.xml

@@ -9,11 +9,11 @@
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>6.10.2</version>
+  <version>6.16.5</version>
   <packaging>jar</packaging>
 
   <name>avaje-ebeanorm</name>
-  <url>http://www.avaje.org</url>
+  <url>http://ebean-orm.github.io/</url>
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -152,7 +152,7 @@
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.7.1</version>
+      <version>4.9.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -219,7 +219,7 @@
       <plugin>
         <groupId>org.avaje.ebeanorm</groupId>
         <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.7.1</version>
+        <version>4.9.1</version>
         <executions>
           <!--   Not going to enhance Model bean -->
           <execution>

src/main/java/com/avaje/ebean/AutoTune.java

@@ -11,4 +11,14 @@ public interface AutoTune {
    */
   void collectProfiling();
 
+  /**
+   * Output the profiling.
+   * <p>
+   * When profiling updates are applied to tuning at runtime this reports all tuning and profiling combined.
+   * When profiling is not applied at runtime then this reports the diff report with new and diff entries relative
+   * to the existing tuning.
+   * </p>
+   */
+  void reportProfiling();
+
 }

src/main/java/com/avaje/ebean/DRawSqlColumnsParser.java

@@ -45,7 +45,7 @@ final class DRawSqlColumnsParser {
     String colInfo = sqlSelect.substring(start, pos++);
     colInfo = colInfo.trim();
 
-    String[] split = colInfo.split(" ");
+    String[] split = colInfo.split("\\s(?=[^\\)]*(?:\\(|$))");
     if (split.length > 1) {
       ArrayList<String> tmp = new ArrayList<String>(split.length);
       for (int i = 0; i < split.length; i++) {
@@ -82,11 +82,13 @@ final class DRawSqlColumnsParser {
 
   private void nextComma() {
     boolean inQuote = false;
+    int inbrackets = 0;
     while (pos < end) {
       char c = sqlSelect.charAt(pos);
-      if (c == '\'') {
-        inQuote = !inQuote;
-      } else if (!inQuote && c == ',') {
+      if (c == '\'') inQuote = !inQuote;
+      else if (c == '(') inbrackets++;
+      else if (c == ')') inbrackets--;
+      else if (!inQuote && inbrackets == 0 && c == ',') {
         return;
       }
       pos++;

src/main/java/com/avaje/ebean/DRawSqlParser.java

@@ -46,6 +46,7 @@ class DRawSqlParser {
 
   private DRawSqlParser(String sqlString) {
     sqlString = sqlString.trim();
+    sqlString = sqlString.replace('\n',' ');
     this.sql = sqlString;
     this.hasPlaceHolders = findAndRemovePlaceHolders();
     this.textParser = new SimpleTextParser(sqlString);
@@ -120,8 +121,7 @@ class DRawSqlParser {
       // trim of distinct keyword
       String distinct = preWhereExprSql.substring(0, 9);
       if (!distinct.equalsIgnoreCase("distinct ")) {
-        throw new RuntimeException("Expecting [" + preWhereExprSql
-            + "] to start with \"select distinct\"");
+        throw new RuntimeException("Expecting [" + preWhereExprSql + "] to start with \"select distinct\"");
       }
       preWhereExprSql = preWhereExprSql.substring(9);
     }

src/main/java/com/avaje/ebean/Ebean.java

@@ -697,12 +697,31 @@ public final class Ebean {
   /**
    * Delete the bean.
    * <p>
+   * This will return true if the bean was deleted successfully or JDBC batch is being used.
+   * </p>
+   * <p>
    * If there is no current transaction one will be created and committed for
    * you automatically.
    * </p>
+   * <p>
+   * If the bean is configured with <code>@SoftDelete</code> then this will perform a soft
+   * delete rather than a hard/permanent delete.
+   * </p>
+   * <p>
+   * If the Bean does not have a version property (or loaded version property) and
+   * the bean does not exist then this returns false indicating that nothing was
+   * deleted. Note that, if JDBC batch mode is used then this always returns true.
+   * </p>
    */
-  public static void delete(Object bean) throws OptimisticLockException {
-    serverMgr.getDefaultServer().delete(bean);
+  public static boolean delete(Object bean) throws OptimisticLockException {
+    return serverMgr.getDefaultServer().delete(bean);
+  }
+
+  /**
+   * Delete the bean in permanent fashion (will not use soft delete).
+   */
+  public static boolean deletePermanent(Object bean) throws OptimisticLockException {
+    return serverMgr.getDefaultServer().deletePermanent(bean);
   }
 
   /**
@@ -726,6 +745,13 @@ public final class Ebean {
     return serverMgr.getDefaultServer().deleteAll(beans);
   }
 
+  /**
+   * Delete permanent all the beans in the Collection (will not use soft delete).
+   */
+  public static int deleteAllPermanent(Collection<?> beans) throws OptimisticLockException {
+    return serverMgr.getDefaultServer().deleteAllPermanent(beans);
+  }
+
   /**
    * Refresh the values of a bean.
    * <p>

src/main/java/com/avaje/ebean/EbeanServer.java

@@ -9,6 +9,7 @@ import com.avaje.ebean.text.csv.CsvReader;
 import com.avaje.ebean.text.json.JsonContext;
 import org.jetbrains.annotations.Nullable;
 
+import javax.persistence.NonUniqueResultException;
 import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
 import java.util.Collection;
@@ -1019,7 +1020,7 @@ public interface EbeanServer {
   SqlFutureList findFutureList(SqlQuery query, Transaction transaction);
 
   /**
-   * Return a PagedList for this query.
+   * Return a PagedList for this query using pageIndex and pageSize.
    * <p>
    * The benefit of using this over just using the normal {@link Query#setFirstRow(int)} and
    * {@link Query#setMaxRows(int)} is that it additionally wraps an optional call to
@@ -1041,6 +1042,38 @@ public interface EbeanServer {
    */
   <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction, int pageIndex, int pageSize);
 
+  /**
+   * 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>
+   *
+   * <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()
+   */
+  <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction);
+
   /**
    * Execute the query returning a set of entity beans.
    * <p>
@@ -1091,14 +1124,17 @@ public interface EbeanServer {
   <T> Map<?, T> findMap(Query<T> query, Transaction transaction);
 
   /**
-   * Execute the query returning at most one entity bean. This will throw a
-   * PersistenceException if the query finds more than one result.
+   * 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#findUnique()} 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
@@ -1106,6 +1142,7 @@ public interface EbeanServer {
    * @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#findUnique()
    */
@@ -1246,16 +1283,52 @@ public interface EbeanServer {
   /**
    * Delete the bean.
    * <p>
+   * This will return true if the bean was deleted successfully or JDBC batch is being used.
+   * </p>
+   * <p>
    * If there is no current transaction one will be created and committed for
    * you automatically.
    * </p>
+   * <p>
+   * If the Bean does not have a version property (or loaded version property) and
+   * the bean does not exist then this returns false indicating that nothing was
+   * deleted. Note that, if JDBC batch mode is used then this always returns true.
+   * </p>
    */
-  void delete(Object bean) throws OptimisticLockException;
+  boolean delete(Object bean) throws OptimisticLockException;
 
   /**
    * Delete the bean with an explicit transaction.
+   * <p>
+   * This will return true if the bean was deleted successfully or JDBC batch is being used.
+   * </p>
+   * <p>
+   * If the Bean does not have a version property (or loaded version property) and
+   * the bean does not exist then this returns false indicating that nothing was
+   * deleted. However, if JDBC batch mode is used then this always returns true.
+   * </p>
    */
-  void delete(Object bean, Transaction transaction) throws OptimisticLockException;
+  boolean delete(Object bean, Transaction transaction) throws OptimisticLockException;
+
+  /**
+   * Delete a bean permanently without soft delete.
+   */
+  boolean deletePermanent(Object bean) throws OptimisticLockException;
+
+  /**
+   * Delete a bean permanently without soft delete using an explicit transaction.
+   */
+  boolean deletePermanent(Object bean, Transaction transaction) throws OptimisticLockException;
+
+  /**
+   * Delete all the beans in the collection permanently without soft delete.
+   */
+  int deleteAllPermanent(Collection<?> beans) throws OptimisticLockException;
+
+  /**
+   * Delete all the beans in the collection permanently without soft delete using an explicit transaction.
+   */
+  int deleteAllPermanent(Collection<?> beans, Transaction transaction) throws OptimisticLockException;
 
   /**
    * Delete the bean given its type and id.
@@ -1456,7 +1529,7 @@ public interface EbeanServer {
   void markAsDirty(Object bean);
   
   /**
-   * Saves the bean using an update. If you know you are updating a bean then it is preferrable to
+   * Saves the bean using an update. If you know you are updating a bean then it is preferable to
    * use this update() method rather than save().
    * <p>
    * <b>Stateless updates:</b> Note that the bean does not have to be previously fetched to call
@@ -1508,7 +1581,6 @@ public interface EbeanServer {
    * @param deleteMissingChildren
    *          specify false if you do not want 'missing children' of a OneToMany
    *          or ManyToMany to be automatically deleted.
-
    */
   void update(Object bean, Transaction transaction, boolean deleteMissingChildren) throws OptimisticLockException;
 
@@ -1819,4 +1891,114 @@ public interface EbeanServer {
    */
   JsonContext json();
 
+  /**
+   * Publish a single bean given its type and id returning the resulting live bean.
+   * <p>
+   * The values are published from the draft to the live bean.
+   * </p>
+   *
+   * @param <T>         the type of the entity bean
+   * @param beanType    the type of the entity bean
+   * @param id          the id of the entity bean
+   * @param transaction the transaction the publish process should use (can be null)
+   */
+  <T> T publish(Class<T> beanType, Object id, Transaction transaction);
+
+  /**
+   * Publish a single bean given its type and id returning the resulting live bean.
+   * This will use the current transaction or create one if required.
+   * <p>
+   * The values are published from the draft to the live bean.
+   * </p>
+   *
+   * @param <T>         the type of the entity bean
+   * @param beanType    the type of the entity bean
+   * @param id          the id of the entity bean
+   */
+  <T> T publish(Class<T> beanType, Object id);
+
+  /**
+   * Publish the beans that match the query returning the resulting published beans.
+   * <p>
+   * The values are published from the draft beans to the live beans.
+   * </p>
+   *
+   * @param <T>         the type of the entity bean
+   * @param query       the query used to select the draft beans to publish
+   * @param transaction the transaction the publish process should use (can be null)
+   */
+  <T> List<T> publish(Query<T> query, Transaction transaction);
+
+  /**
+   * Publish the beans that match the query returning the resulting published beans.
+   * This will use the current transaction or create one if required.
+   * <p>
+   * The values are published from the draft beans to the live beans.
+   * </p>
+   *
+   * @param <T>         the type of the entity bean
+   * @param query       the query used to select the draft beans to publish
+   */
+  <T> List<T> publish(Query<T> query);
+
+  /**
+   * Restore the draft bean back to the live state.
+   * <p>
+   * The values from the live beans are set back to the draft bean and the
+   * <code>@DraftDirty</code> and <code>@DraftReset</code> properties are reset.
+   * </p>
+   *
+   * @param <T>         the type of the entity bean
+   * @param beanType    the type of the entity bean
+   * @param id          the id of the entity bean to restore
+   * @param transaction the transaction the restore process should use (can be null)
+   */
+  <T> T draftRestore(Class<T> beanType, Object id, Transaction transaction);
+
+  /**
+   * Restore the draft bean back to the live state.
+   * <p>
+   * The values from the live beans are set back to the draft bean and the
+   * <code>@DraftDirty</code> and <code>@DraftReset</code> properties are reset.
+   * </p>
+   *
+   * @param <T>         the type of the entity bean
+   * @param beanType    the type of the entity bean
+   * @param id          the id of the entity bean to restore
+   */
+  <T> T draftRestore(Class<T> beanType, Object id);
+
+  /**
+   * Restore the draft beans matching the query back to the live state.
+   * <p>
+   * The values from the live beans are set back to the draft bean and the
+   * <code>@DraftDirty</code> and <code>@DraftReset</code> properties are reset.
+   * </p>
+   *
+   * @param <T>         the type of the entity bean
+   * @param query       the query used to select the draft beans to restore
+   * @param transaction the transaction the restore process should use (can be null)
+   */
+  <T> List<T> draftRestore(Query<T> query, Transaction transaction);
+
+  /**
+   * Restore the draft beans matching the query back to the live state.
+   * <p>
+   * The values from the live beans are set back to the draft bean and the
+   * <code>@DraftDirty</code> and <code>@DraftReset</code> properties are reset.
+   * </p>
+   *
+   * @param <T>         the type of the entity bean
+   * @param query       the query used to select the draft beans to restore
+   */
+  <T> List<T> draftRestore(Query<T> query);
+
+  /**
+   * Returns the set of properties/paths that are unknown (do not map to known properties or paths).
+   * <p>
+   * Validate the query checking the where and orderBy expression paths to confirm if
+   * they represent valid properties/path for the given bean type.
+   * </p>
+   */
+  <T> Set<String> validateQuery(Query<T> query);
 }

src/main/java/com/avaje/ebean/ExpressionList.java

@@ -3,6 +3,7 @@ package com.avaje.ebean;
 import com.avaje.ebean.text.PathProperties;
 import org.jetbrains.annotations.Nullable;
 
+import javax.persistence.NonUniqueResultException;
 import java.io.Serializable;
 import java.sql.Timestamp;
 import java.util.Collection;
@@ -107,6 +108,16 @@ public interface ExpressionList<T> extends Serializable {
    */
   Query<T> asOf(Timestamp asOf);
 
+  /**
+   * Execute the query against the draft set of tables.
+   */
+  Query<T> asDraft();
+
+  /**
+   * Execute the query including soft deleted rows.
+   */
+  Query<T> includeSoftDeletes();
+
   /**
    * Execute as a delete query deleting the 'root level' beans that match the predicates
    * in the query.
@@ -183,8 +194,15 @@ public interface ExpressionList<T> extends Serializable {
   <K> Map<K, T> findMap(String keyProperty, Class<K> keyType);
 
   /**
-   * Execute the query returning a single bean.
-   * 
+   * Execute the query returning a single bean or null (if no matching
+   * bean is found).
+   * <p>
+   * If more than 1 row is found for this query then a NonUniqueResultException is
+   * thrown.
+   * </p>
+   *
+   * @throws NonUniqueResultException if more than one result was found
+   *
    * @see Query#findUnique()
    */
   @Nullable
@@ -227,7 +245,7 @@ public interface ExpressionList<T> extends Serializable {
   FutureList<T> findFutureList();
 
   /**
-   * Return a PagedList for this query.
+   * Return a PagedList for this query using pageIndex and pageSize.
    * <p>
    * The benefit of using this over just using the normal {@link Query#setFirstRow(int)} and
    * {@link Query#setMaxRows(int)} is that it additionally wraps an optional call to
@@ -247,6 +265,38 @@ public interface ExpressionList<T> extends Serializable {
    */
   PagedList<T> findPagedList(int pageIndex, int pageSize);
 
+  /**
+   * 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>
+   *
+   * <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()
+   */
+  PagedList<T> findPagedList();
+
   /**
    * Return versions of a @History entity bean.
    * <p>
@@ -735,7 +785,7 @@ public interface ExpressionList<T> extends Serializable {
    * qualified) will still be translated to their physical name.
    * </p>
    */
-  ExpressionList<T> raw(String raw, Object[] values);
+  ExpressionList<T> raw(String raw, Object... values);
 
   /**
    * Add raw expression with no parameters.

src/main/java/com/avaje/ebean/Model.java

@@ -251,12 +251,24 @@ public abstract class Model {
   }
 
   /**
-   * Delete this entity.
+   * Delete this bean.
+   * <p>
+   * This will return true if the bean was deleted successfully or JDBC batch is being used.
+   * </p>
+   * <p>
+   * If there is no current transaction one will be created and committed for
+   * you automatically.
+   * </p>
+   * <p>
+   * If the Bean does not have a version property (or loaded version property) and
+   * the bean does not exist then this returns false indicating that nothing was
+   * deleted. Note that, if JDBC batch mode is used then this always returns true.
+   * </p>
    *
    * @see EbeanServer#delete(Object)
    */
-  public void delete() {
-    db().delete(this);
+  public boolean delete() {
+    return db().delete(this);
   }
 
   /**
@@ -276,8 +288,8 @@ public abstract class Model {
   /**
    * Perform a delete using this entity against the specified server.
    */
-  public void delete(String server) {
-    db(server).delete(this);
+  public boolean delete(String server) {
+    return db(server).delete(this);
   }
 
   /**

src/main/java/com/avaje/ebean/PagedList.java

@@ -17,6 +17,33 @@ import java.util.concurrent.Future;
  * limit the result set.
  * </p>
  *
+ *
+ * <h4>Example: typical use including total row count</h4>
+ * <pre>{@code
+ *
+ *     // We want to find the first 50 new orders
+ *     //  ... so we don't really need setFirstRow(0)
+ *
+ *     PagedList<Order> pagedList
+ *       = ebeanServer.find(Order.class)
+ *       .where().eq("status", Order.Status.NEW)
+ *       .order().asc("id")
+ *       .setFirstRow(0)
+ *       .setMaxRows(50)
+ *       .findPagedList();
+ *
+ *     // Optional: initiate the loading of the total
+ *     // row count in a background thread
+ *     pagedList.loadRowCount();
+ *
+ *     // fetch and return the list in the foreground thread
+ *     List<Order> orders = pagedList.getList();
+ *
+ *     // get the total row count (from the future)
+ *     int totalRowCount = pagedList.getTotalRowCount();
+ *
+ * }</pre>
+ *
  * <h4>Example: typical use including total row count</h4>
  * <pre>{@code
  *
@@ -156,11 +183,15 @@ public interface PagedList<T> {
 
   /**
    * Return the index position of this page. Zero based.
+   * <p>
+   * Note that if firstRows/maxRows is used rather than pageIndex/pageSize then
+   * this always returns 0.
+   * </p>
    */
   int getPageIndex();
 
   /**
-   * Return the page size used for this query.
+   * Return the page size used for this query. This is the same value as maxRows used by the query.
    */
   int getPageSize();
 

src/main/java/com/avaje/ebean/PrimaryServer.java

@@ -58,15 +58,18 @@ class PrimaryServer {
    */
   private static String determineDefaultServerName() {
 
-    String defaultServerName = System.getProperty("datasource.default");
+    String defaultServerName = System.getenv("EBEAN_DB");
     if (isEmpty(defaultServerName)) {
-      defaultServerName = System.getProperty("ebean.default.datasource");
-    }
-    if (isEmpty(defaultServerName)) {
-      defaultServerName = globalProperties.getProperty("datasource.default");
-    }
-    if (isEmpty(defaultServerName)) {
-      defaultServerName = globalProperties.getProperty("ebean.default.datasource");
+      defaultServerName = System.getProperty("datasource.default");
+      if (isEmpty(defaultServerName)) {
+        defaultServerName = System.getProperty("ebean.default.datasource");
+        if (isEmpty(defaultServerName)) {
+          defaultServerName = globalProperties.getProperty("datasource.default");
+          if (isEmpty(defaultServerName)) {
+            defaultServerName = globalProperties.getProperty("ebean.default.datasource");
+          }
+        }
+      }
     }
     return defaultServerName;
   }

src/main/java/com/avaje/ebean/Query.java

@@ -3,6 +3,7 @@ package com.avaje.ebean;
 import com.avaje.ebean.text.PathProperties;
 import org.jetbrains.annotations.Nullable;
 
+import javax.persistence.NonUniqueResultException;
 import java.io.Serializable;
 import java.sql.Timestamp;
 import java.util.List;
@@ -297,6 +298,16 @@ public interface Query<T> extends Serializable {
    */
   Query<T> asOf(Timestamp asOf);
 
+  /**
+   * Execute the query against the draft set of tables.
+   */
+  Query<T> asDraft();
+
+  /**
+   * Execute the query including soft deleted rows.
+   */
+  Query<T> includeSoftDeletes();
+
   /**
    * Cancel the query execution if supported by the underlying database and
    * driver.
@@ -690,7 +701,7 @@ public interface Query<T> extends Serializable {
    * Execute the query returning either a single bean or null (if no matching
    * bean is found).
    * <p>
-   * If more than 1 row is found for this query then a PersistenceException is
+   * If more than 1 row is found for this query then a NonUniqueResultException is
    * thrown.
    * </p>
    * <p>
@@ -726,6 +737,8 @@ public interface Query<T> extends Serializable {
    * List<OrderDetail> details = order.getDetails();
    * ...
    * }</pre>
+   *
+   * @throws NonUniqueResultException if more than one result was found
    */
   @Nullable
   T findUnique();
@@ -809,7 +822,7 @@ public interface Query<T> extends Serializable {
   FutureList<T> findFutureList();
 
   /**
-   * Return a PagedList for this query.
+   * Return a PagedList for this query using pageIndex and pageSize.
    * <p>
    * The benefit of using this over just using the normal {@link Query#setFirstRow(int)} and
    * {@link Query#setMaxRows(int)} is that it additionally wraps an optional call to
@@ -854,6 +867,36 @@ public interface Query<T> extends Serializable {
    */
   PagedList<T> findPagedList(int pageIndex, int pageSize);
 
+  /**
+   * 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>
+   *
+   * <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
+   */
+  PagedList<T> findPagedList();
+
   /**
    * Set a named bind parameter. Named parameters have a colon to prefix the name.
    * 
@@ -1313,4 +1356,13 @@ public interface Query<T> extends Serializable {
    * </p>
    */
   Query<T> setDisableLazyLoading(boolean disableLazyLoading);
+
+  /**
+   * Returns the set of properties or paths that are unknown (do not map to known properties or paths).
+   * <p>
+   * Validate the query checking the where and orderBy expression paths to confirm if
+   * they represent valid properties or paths for the given bean type.
+   * </p>
+   */
+  Set<String> validate();
 }

src/main/java/com/avaje/ebean/RawSql.java

@@ -585,6 +585,9 @@ public final class RawSql implements Serializable {
      * <p>
      * For example modify all mappings with table alias "c" to have the path prefix "customer".
      * </p>
+     * <p>
+     * For the "Root type" you don't need to specify a tableAliasMapping.
+     * </p>
      */
     public void tableAliasMapping(String tableAlias, String path) {
 

src/main/java/com/avaje/ebean/RawSqlBuilder.java

@@ -106,6 +106,9 @@ public class RawSqlBuilder {
    * <p>
    * For example modify all mappings with table alias "c" to have the path prefix "customer".
    * </p>
+   * <p>
+   * For the "Root type" you don't need to specify a tableAliasMapping.
+   * </p>
    */
   public RawSqlBuilder tableAliasMapping(String tableAlias, String path) {
     columnMapping.tableAliasMapping(tableAlias, path);

src/main/java/com/avaje/ebean/annotation/CreatedTimestamp.java

@@ -9,6 +9,10 @@ import java.lang.annotation.Target;
  * For a timestamp property that is set to the datetime when the entity is
  * created/inserted.
  * <p>
+ * This is effectively an alias for @WhenCreated which was added as it hints
+ * towards a better naming convention (WhenCreated, WhenModified).
+ * </p>
+ * <p>
  * An alternative to using this annotation would be to use insertable=false,
  * updateable=false with @Column and have the DB insert the current time
  * (default value on the DB column is SYSTIME etc).

src/main/java/com/avaje/ebean/annotation/DbComment.java

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A database table or column comment.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
+public @interface DbComment {
+
+  /**
+   * The database table or column comment.
+   */
+  String value();
+}

src/main/java/com/avaje/ebean/annotation/Draft.java

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a boolean property on a @Draftable bean that indicates if the bean instance is a 'draft' or 'live' bean.
+ * The property is transient and has no underlying DB column.
+ * <p>
+ * For beans returned from an <code>asDraft()</code> query this property will be set to true.
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Draft {
+
+}

src/main/java/com/avaje/ebean/annotation/DraftDirty.java

@@ -0,0 +1,20 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a boolean property on a @Draftable bean that only exists on the 'draft' table
+ * and is used to detect when a draft has unpublished changes.
+ * <p>
+ * This property will automatically have it's value set to true when a draft is saved and
+ * automatically have it's value set to false when the bean is published.
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DraftDirty {
+
+}

src/main/java/com/avaje/ebean/annotation/DraftOnly.java

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a property on a @Draftable bean that only exists on the 'draft' and not the 'live' table.
+ * <p>
+ * Typically this would be used on a property that is used as part of application 'workflow' such as
+ * a publish workflow status or when publish timestamp.
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DraftOnly {
+
+}

src/main/java/com/avaje/ebean/annotation/DraftReset.java

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a property on a @Draftable bean that is set to null on the 'draft bean' on publish.
+ * <p>
+ * This is expected to be put on properties that get 'reset' or 'cleared' after a publish.
+ * These properties might represent a publish comment or publish timestamp.
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DraftReset {
+
+}

src/main/java/com/avaje/ebean/annotation/Draftable.java

@@ -0,0 +1,29 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Used to indicate an entity bean that has 'draftable' support.
+ * <p>
+ * This means that a second set of tables is created to hold draft versions of
+ * the rows and that these can then be published which effectively copies/transfers
+ * the values from the 'draft' table to the 'live' table.
+ * </p>
+ * <p>
+ * Ebean Query supports 'find as draft' which builds the resulting object graph using
+ * the draft tables. This object graph is typically edited, approved in some application
+ * specific manor and then published.
+ * </p>
+ * <p>
+ * EbeanServer has a publish method which transfers/copies the draft object graph to
+ * the 'live' tables.
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface Draftable {
+
+}

src/main/java/com/avaje/ebean/annotation/DraftableElement.java

@@ -0,0 +1,20 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Used to indicate an entity bean that has 'draftable' support but it not a 'top level'
+ * (or root level) bean but instead child related to another @Draftable entity bean.
+ * <p>
+ * Relationships to @DraftableElements (@OneToMany, @ManyToMany etc) are automatically
+ * deemed to have Cascade.ALL for save and delete (as well as orphan removal mode).
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface DraftableElement {
+
+}

src/main/java/com/avaje/ebean/annotation/SoftDelete.java

@@ -0,0 +1,25 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Used to indicate a property on an entity bean used to control 'soft delete'
+ * (also known as 'logical delete').
+ * <p>
+ * The property should be of type boolean.
+ * </p>
+ * <pre>{@code
+ *
+ * @SoftDelete
+ * boolean deleted;
+ *
+ * }</pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface SoftDelete {
+
+}

src/main/java/com/avaje/ebean/annotation/UpdatedTimestamp.java

@@ -8,6 +8,10 @@ import java.lang.annotation.Target;
 /**
  * For a timestamp property that is set to the datetime when the entity was last
  * updated.
+ * <p>
+ * This is effectively an alias for @WhenModified which was added as it hints
+ * towards a better naming convention (WhenCreated, WhenModified).
+ * </p>
  */
 @Target({ ElementType.FIELD, ElementType.METHOD })
 @Retention(RetentionPolicy.RUNTIME)

src/main/java/com/avaje/ebean/annotation/WhenModified.java

@@ -11,7 +11,6 @@ import java.lang.annotation.Target;
  * This is effectively an alias for @UpdatedTimestamp and added to hint
  * towards a better naming convention (WhenCreated, WhenModified).
  * </p>
- * </p>
  */
 @Target({ ElementType.FIELD, ElementType.METHOD })
 @Retention(RetentionPolicy.RUNTIME)

src/main/java/com/avaje/ebean/bean/BeanCollection.java

@@ -31,6 +31,16 @@ public interface BeanCollection<E> extends Serializable {
     ALL
   }
 
+  /**
+   * Add a bean to the list/set with modifyListen notification.
+   */
+  void addBean(E bean);
+
+  /**
+   * Remove a bean to the list/set with modifyListen notification.
+   */
+  void removeBean(E bean);
+
   /**
    * Reset the collection back to an empty state ready for reloading.
    * <p>

src/main/java/com/avaje/ebean/bean/BeanCollectionAdd.java

@@ -12,5 +12,5 @@ public interface BeanCollectionAdd {
   /**
    * Add a loaded bean to the collection.
    */
-  void addBean(EntityBean bean);
+  void addEntityBean(EntityBean bean);
 }

src/main/java/com/avaje/ebean/bean/EntityBean.java

@@ -73,16 +73,6 @@ public interface EntityBean extends Serializable {
    */
   EntityBeanIntercept _ebean_intercept();
 
-  /**
-   * Create a copy of this entity bean.
-   * <p>
-   * This occurs when a bean is changed. The copy represents the bean as it was
-   * initially (oldValues) before any changes where made. This is used for
-   * optimistic concurrency control.
-   * </p>
-   */
-  Object _ebean_createCopy();
-
   /**
    * Set the value of a field of an entity bean of this type.
    * <p>

src/main/java/com/avaje/ebean/bean/EntityBeanIntercept.java

@@ -1,5 +1,10 @@
 package com.avaje.ebean.bean;
 
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.ValuePair;
+
+import javax.persistence.EntityNotFoundException;
+import javax.persistence.PersistenceException;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import java.beans.PropertyChangeSupport;
@@ -11,12 +16,6 @@ import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 
-import javax.persistence.EntityNotFoundException;
-import javax.persistence.PersistenceException;
-
-import com.avaje.ebean.Ebean;
-import com.avaje.ebean.ValuePair;
-
 /**
  * This is the object added to every entity bean using byte code enhancement.
  * <p>
@@ -92,6 +91,8 @@ public final class EntityBeanIntercept implements Serializable {
 
   private int lazyLoadProperty = -1;
 
+  private Object ownerId;
+
   /**
    * Create a intercept with a given entity.
    * <p>
@@ -342,18 +343,11 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Check if the lazy load succeeded. If not then mark this bean as having
-   * failed lazy loading due to the underlying row being deleted.
-   * <p>
-   * We mark the bean this way rather than immediately fail as we might be batch
-   * lazy loading and this bean might not be used by the client code at all.
-   * Instead we will fail as soon as the client code tries to use this bean.
-   * </p>
+   * Set lazy load failure flag.
    */
-  public void checkLazyLoadFailure() {
-    if (lazyLoadProperty != -1) {
-      this.lazyLoadFailure = true;
-    }
+  public void setLazyLoadFailure(Object ownerId) {
+    this.lazyLoadFailure = true;
+    this.ownerId = ownerId;
   }
 
   /**
@@ -507,7 +501,7 @@ public final class EntityBeanIntercept implements Serializable {
     setDirty(true);
   }
   
-  private void setChangedProperty(int propertyIndex) {
+  public void setChangedProperty(int propertyIndex) {
     if (changedProps == null) {
       changedProps = new boolean[owner._ebean_getPropertyNames().length];
     }
@@ -748,7 +742,7 @@ public final class EntityBeanIntercept implements Serializable {
 
     if (lazyLoadFailure) {
       // failed when batch lazy loaded by another bean in the batch
-      throw new EntityNotFoundException("Bean has been deleted - lazy loading failed");
+      throw new EntityNotFoundException("Lazy loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted");
     }
 
     if (lazyLoadProperty == -1) {
@@ -763,7 +757,7 @@ public final class EntityBeanIntercept implements Serializable {
 
       if (lazyLoadFailure) {
         // failed when lazy loading this bean
-        throw new EntityNotFoundException("Bean has been deleted - lazy loading failed");
+        throw new EntityNotFoundException("Lazy loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted.");
       }
 
       // bean should be loaded and intercepting now. setLoaded() has

src/main/java/com/avaje/ebean/common/BeanList.java

@@ -60,7 +60,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   }
 
   @SuppressWarnings("unchecked")
-  public void addBean(EntityBean bean) {
+  public void addEntityBean(EntityBean bean) {
     list.add((E) bean);
   }
 
@@ -206,6 +206,11 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     list.add(index, element);
   }
 
+  @Override
+  public void addBean(E bean) {
+    add(bean);
+  }
+
   public boolean add(E o) {
     checkReadOnly();
     init();
@@ -319,6 +324,13 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     return list.listIterator(index);
   }
 
+  @Override
+  public void removeBean(E bean) {
+    if (list.remove(bean)) {
+      getModifyHolder().modifyRemoval(bean);
+    }
+  }
+
   public E remove(int index) {
     checkReadOnly();
     init();

src/main/java/com/avaje/ebean/common/BeanMap.java

@@ -272,6 +272,16 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
     map.putAll(puts);
   }
 
+  @Override
+  public void addBean(E bean) {
+    throw new IllegalStateException("Method not allowed on Map. Please use List instead.");
+  }
+
+  @Override
+  public void removeBean(E bean) {
+    throw new IllegalStateException("Method not allowed on Map. Please use List instead.");
+  }
+
   public E remove(Object key) {
     checkReadOnly();
     init();

src/main/java/com/avaje/ebean/common/BeanSet.java

@@ -53,7 +53,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   }
 
   @SuppressWarnings("unchecked")
-  public void addBean(EntityBean bean) {
+  public void addEntityBean(EntityBean bean) {
     set.add((E) bean);
   }
 
@@ -174,6 +174,18 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
     return set.hashCode();
   }
 
+  @Override
+  public void addBean(E bean) {
+    add(bean);
+  }
+
+  @Override
+  public void removeBean(E bean) {
+    if (set.remove(bean)) {
+      getModifyHolder().modifyRemoval(bean);
+    }
+  }
+
   // -----------------------------------------------------//
   // proxy method for map
   // -----------------------------------------------------//

src/main/java/com/avaje/ebean/config/AutoTuneConfig.java

@@ -21,9 +21,13 @@ public class AutoTuneConfig {
 
   private double profilingRate = 0.01;
 
+  private int profilingUpdateFrequency;
+
   private int garbageCollectionWait = 100;
   
-  private boolean skipCollectionOnShutdown;
+  private boolean skipGarbageCollectionOnShutdown;
+
+  private boolean skipProfileReportingOnShutdown;
 
   public AutoTuneConfig() {
   }
@@ -56,6 +60,20 @@ public class AutoTuneConfig {
     this.profilingFile = profilingFile;
   }
 
+  /**
+   * Return the frequency in seconds the profiling should be collected and automatically applied to the tuning.
+   */
+  public int getProfilingUpdateFrequency() {
+    return profilingUpdateFrequency;
+  }
+
+  /**
+   * Set the frequency in seconds the profiling should be collected and automatically applied to the tuning.
+   */
+  public void setProfilingUpdateFrequency(int profilingUpdateFrequency) {
+    this.profilingUpdateFrequency = profilingUpdateFrequency;
+  }
+
   /**
    * Return the mode used when autoTune has not been explicit defined on a
    * query.
@@ -184,17 +202,33 @@ public class AutoTuneConfig {
   }
 
   /**
-   * Return true if profiling collection should be skipped on shutdown.
+   * Return true if triggering garbage collection should be skipped on shutdown.
+   * You might set this when System.GC() slows a application shutdown too much.
    */
-  public boolean isSkipCollectionOnShutdown() {
-    return skipCollectionOnShutdown;
+  public boolean isSkipGarbageCollectionOnShutdown() {
+    return skipGarbageCollectionOnShutdown;
   }
 
   /**
-   * Set to true if profiling collection should be skipped on shutdown.
+   * Set to true if triggering garbage collection should be skipped on shutdown.
+   * You might set this when System.GC() slows a application shutdown too much.
    */
-  public void setSkipCollectionOnShutdown(boolean skipCollectionOnShutdown) {
-    this.skipCollectionOnShutdown = skipCollectionOnShutdown;
+  public void setSkipGarbageCollectionOnShutdown(boolean skipGarbageCollectionOnShutdown) {
+    this.skipGarbageCollectionOnShutdown = skipGarbageCollectionOnShutdown;
+  }
+
+  /**
+   * Return true if profile reporting should be skipped on shutdown.
+   */
+  public boolean isSkipProfileReportingOnShutdown() {
+    return skipProfileReportingOnShutdown;
+  }
+
+  /**
+   * Set to true if profile reporting should be skipped on shutdown.
+   */
+  public void setSkipProfileReportingOnShutdown(boolean skipProfileReportingOnShutdown) {
+    this.skipProfileReportingOnShutdown = skipProfileReportingOnShutdown;
   }
 
   /**
@@ -206,13 +240,15 @@ public class AutoTuneConfig {
     queryTuningAddVersion = p.getBoolean("autoTune.queryTuningAddVersion", queryTuningAddVersion);
     queryTuningFile = p.get("autoTune.queryTuningFile", queryTuningFile);
 
-    skipCollectionOnShutdown = p.getBoolean("autoTune.skipCollectionOnShutdown", skipCollectionOnShutdown);
-    
+    skipGarbageCollectionOnShutdown = p.getBoolean("autoTune.skipGarbageCollectionOnShutdown", skipGarbageCollectionOnShutdown);
+    skipProfileReportingOnShutdown = p.getBoolean("autoTune.skipProfileReportingOnShutdown", skipProfileReportingOnShutdown);
+
     mode = p.getEnum(AutoTuneMode.class, "autoTune.mode", mode);
 
     profiling = p.getBoolean("autoTune.profiling", profiling);
     profilingBase = p.getInt("autoTune.profilingBase", profilingBase);
     profilingRate = p.getDouble("autoTune.profilingRate", profilingRate);
     profilingFile = p.get("autoTune.profilingFile", profilingFile);
+    profilingUpdateFrequency = p.getInt("autoTune.profilingUpdateFrequency", profilingUpdateFrequency);
   }
 }

src/main/java/com/avaje/ebean/config/ClassLoadConfig.java

@@ -0,0 +1,143 @@
+package com.avaje.ebean.config;
+
+
+/**
+ * Helper to find classes taking into account the context class loader.
+ */
+public class ClassLoadConfig {
+
+  protected final ClassLoaderContext context;
+
+  /**
+   * Construct with the default classLoader search with context classLoader first.
+   */
+  public ClassLoadConfig() {
+    this(null);
+  }
+
+  /**
+   * Specify the classLoader to use for class detection and new instance creation.
+   */
+  public ClassLoadConfig(ClassLoader classLoader) {
+    this.context = new ClassLoaderContext(classLoader);
+  }
+
+  /**
+   * Return true if the Java.time types are available and should be supported.
+   */
+  public boolean isJavaTimePresent() {
+    return isPresent("java.time.LocalDate");
+  }
+
+  /**
+   * Return true if the Joda types are available and should be supported.
+   */
+  public boolean isJodaTimePresent() {
+    return isPresent("org.joda.time.LocalDateTime");
+  }
+
+  /**
+   * Return true if javax validation annotations like Size and NotNull are present.
+   */
+  public boolean isJavaxValidationAnnotationsPresent() {
+    return isPresent("javax.validation.constraints.NotNull");
+  }
+
+  /**
+   * Return true if Jackson annotations like JsonIgnore are present.
+   */
+  public boolean isJacksonAnnotationsPresent() {
+    return isPresent("com.fasterxml.jackson.annotation.JsonIgnore");
+  }
+
+  /**
+   * Return true if Jackson ObjectMapper is present.
+   */
+  public boolean isJacksonObjectMapperPresent() {
+    return isPresent("com.fasterxml.jackson.databind.ObjectMapper");
+  }
+
+  /**
+   * Return a new instance of the class using the default constructor.
+   */
+  public Object newInstance(String className) {
+
+    try {
+      Class<?> cls = forName(className);
+      return cls.newInstance();
+    } catch (Exception e) {
+      throw new IllegalArgumentException("Error constructing " + className, e);
+    }
+  }
+
+  /**
+   * Return true if the given class is present.
+   */
+  protected boolean isPresent(String className) {
+    try {
+      forName(className);
+      return true;
+    } catch (Throwable ex) {
+      // Class or one of its dependencies is not present...
+      return false;
+    }
+  }
+
+  /**
+   * Load a class taking into account a context class loader (if present).
+   */
+  protected Class<?> forName(String name) throws ClassNotFoundException {
+    return context.forName(name);
+  }
+
+  /**
+   * Wraps the preferred, caller and context class loaders.
+   */
+  protected class ClassLoaderContext {
+
+    /**
+     * Optional - if set only use this classLoader (no fallback).
+     */
+    protected final ClassLoader preferredLoader;
+
+    protected final ClassLoader contextLoader;
+
+    protected final ClassLoader callerLoader;
+
+    ClassLoaderContext(ClassLoader preferredLoader) {
+      this.preferredLoader = preferredLoader;
+      this.callerLoader = ServerConfig.class.getClassLoader();
+      this.contextLoader = contextLoader();
+    }
+
+    ClassLoader contextLoader() {
+      ClassLoader loader = Thread.currentThread().getContextClassLoader();
+      return (loader != null) ? loader: callerLoader;
+    }
+
+    Class<?> forName(String name) throws ClassNotFoundException {
+
+      if (preferredLoader != null) {
+        // only use the explicitly set classLoader
+        return classForName(name, preferredLoader);
+      }
+      try {
+        // try the context loader first
+        return classForName(name, contextLoader);
+      } catch (ClassNotFoundException e) {
+        if (callerLoader == contextLoader) {
+          throw e;
+        } else {
+          // fallback to the caller classLoader
+          return classForName(name, callerLoader);
+        }
+      }
+    }
+
+    Class<?> classForName(String name, ClassLoader classLoader) throws ClassNotFoundException {
+      return Class.forName(name, true, classLoader);
+    }
+
+  }
+}
+

src/main/java/com/avaje/ebean/config/DbMigrationConfig.java

@@ -1,39 +1,410 @@
 package com.avaje.ebean.config;
 
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.config.dbplatform.DbPlatformName;
+import com.avaje.ebean.dbmigration.DbMigration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Configuration for the DB migration processing.
  */
 public class DbMigrationConfig {
 
+  protected static final Logger logger = LoggerFactory.getLogger(DbMigrationConfig.class);
+
+  /**
+   * The database platform to generate migration DDL for.
+   */
+  protected DbPlatformName platform;
+
+  /**
+   * Set to true if the DB migration should be generated on server start.
+   */
+  protected boolean generate;
+
+  /**
+   * Set to true to suppress the output of the rollback script.
+   */
+  protected boolean suppressRollback;
+
+  /**
+   * The migration version name (typically FlywayDb compatible).
+   * <p>
+   * Example: 1.1.1_2
+   * <p>
+   * The version is expected to be the combination of the current pom version plus
+   * a 'feature' id. The combined version must be unique and ordered to work with
+   * FlywayDb so each developer sets a unique version so that the migration script
+   * generated is unique (typically just prior to being submitted as a merge request).
+   */
+  protected String version;
+
+  /**
+   * Description text that can be appended to the version to become the ddl script file name.
+   * <p>
+   * So if the name is "a foo table" then the ddl script file could be:
+   * "1.1.1_2__a-foo-table.sql"
+   * <p>
+   * When the DB migration relates to a git feature (merge request) then this description text
+   * is a short description of the feature.
+   */
+  protected String name;
+
   /**
    * Resource path for the migration xml and sql.
-   * Typically you would change 'app' to be a better/more unique.
    */
-  private String resourcePath = "dbmigration/app";
+  protected String migrationPath = "dbmigration";
+
+  /**
+   * Subdirectory the model xml files go into.
+   */
+  protected String modelPath = "model";
+
+  /**
+   * Subdirectory the drop ddl scripts go into.
+   */
+  protected String dropPath = "drop";
+
+  /**
+   * Subdirectory the rollback ddl scripts go into.
+   */
+  protected String rollbackPath = "rollback";
+
+  /**
+   * Apply script suffix.
+   */
+  protected String applySuffix = ".sql";
+
+  /**
+   * Default drop script suffix to ddl so that it isn't picked up by FlywayDb.
+   */
+  protected String dropSuffix = ".drop.ddl";
+
+  /**
+   * Default rollback script suffix to ddl so that it isn't picked up by FlywayDb.
+   */
+  protected String rollbackSuffix = ".rollback.ddl";
+
+  protected String modelSuffix = ".model.xml";
+
+  protected boolean includeGeneratedFileComment;
+
+  /**
+   * Return the DB platform to generate migration DDL for.
+   *
+   * We typically need to explicitly specify this as migration can often be generated
+   * when running against H2.
+   */
+  public DbPlatformName getPlatform() {
+    return platform;
+  }
+
+  /**
+   * Set the DB platform to generate migration DDL for.
+   */
+  public void setPlatform(DbPlatformName platform) {
+    this.platform = platform;
+  }
 
   /**
    * Return the resource path for db migrations.
    */
-  public String getResourcePath() {
-    return resourcePath;
+  public String getMigrationPath() {
+    return migrationPath;
   }
 
   /**
    * Set the resource path for db migrations.
    * <p>
-   * Typically this would be something like "dbmigration/myapp" where myapp gives it a
-   * unique resource path in the case there are multiple EbeanServer applications in the
-   * single classpath.
+   * The default of "dbmigration" is reasonable in most cases. You may look to set this
+   * to be something like "dbmigration/myapp" where myapp gives it a unique resource path
+   * in the case there are multiple EbeanServer applications in the single classpath.
    * </p>
    */
-  public void setResourcePath(String resourcePath) {
-    this.resourcePath = resourcePath;
+  public void setMigrationPath(String migrationPath) {
+    this.migrationPath = migrationPath;
+  }
+
+  /**
+   * Return the relative path for the model files (defaults to model).
+   */
+  public String getModelPath() {
+    return modelPath;
+  }
+
+  /**
+   * Set the relative path for the model files.
+   */
+  public void setModelPath(String modelPath) {
+    this.modelPath = modelPath;
+  }
+
+  /**
+   * Return the relative path for the drop ddl scripts (defaults to drop).
+   */
+  public String getDropPath() {
+    return dropPath;
+  }
+
+  /**
+   * Set the relative path for the drop ddl scripts (defaults to drop).
+   */
+  public void setDropPath(String dropPath) {
+    this.dropPath = dropPath;
+  }
+
+  /**
+   * Return the relative path for the rollback ddl scripts (defaults to rollback).
+   */
+  public String getRollbackPath() {
+    return rollbackPath;
+  }
+
+  /**
+   * Set the relative path for the rollback ddl scripts (defaults to rollback).
+   */
+  public void setRollbackPath(String rollbackPath) {
+    this.rollbackPath = rollbackPath;
+  }
+
+  /**
+   * Return the model suffix (defaults to model.xml)
+   */
+  public String getModelSuffix() {
+    return modelSuffix;
+  }
+
+  /**
+   * Set the model suffix.
+   */
+  public void setModelSuffix(String modelSuffix) {
+    this.modelSuffix = modelSuffix;
+  }
+
+  /**
+   * Return true if the rollback script should not be output.
+   */
+  public boolean isSuppressRollback() {
+    return suppressRollback;
+  }
+
+  /**
+   * Set to true to suppress the output of the rollback script.
+   */
+  public void setSuppressRollback(boolean suppressRollback) {
+    this.suppressRollback = suppressRollback;
+  }
+
+  /**
+   * Return the apply script suffix (defaults to sql).
+   */
+  public String getApplySuffix() {
+    return applySuffix;
+  }
+
+  /**
+   * Set the apply script suffix (defaults to sql).
+   */
+  public void setApplySuffix(String applySuffix) {
+    this.applySuffix = applySuffix;
+  }
+
+  /**
+   * Return the drop script suffix (defaults to ddl so that it isn't picked up by FlywayDb).
+   */
+  public String getDropSuffix() {
+    return dropSuffix;
+  }
+
+  /**
+   * Set the drop script suffix (defaults to ddl so that it isn't picked up by FlywayDb).
+   */
+  public void setDropSuffix(String dropSuffix) {
+    this.dropSuffix = dropSuffix;
+  }
+
+  /**
+   * Return the rollback script suffix (defaults to ddl so that it isn't picked up by FlywayDb).
+   */
+  public String getRollbackSuffix() {
+    return rollbackSuffix;
+  }
+
+  /**
+   * Set the rollback script suffix (defaults to ddl so that it isn't picked up by FlywayDb).
+   */
+  public void setRollbackSuffix(String rollbackSuffix) {
+    this.rollbackSuffix = rollbackSuffix;
+  }
+
+  /**
+   * Return true if the generated file comment should be included.
+   */
+  public boolean isIncludeGeneratedFileComment() {
+    return includeGeneratedFileComment;
+  }
+
+  /**
+   * Set to true if the generated file comment should be included.
+   */
+  public void setIncludeGeneratedFileComment(boolean includeGeneratedFileComment) {
+    this.includeGeneratedFileComment = includeGeneratedFileComment;
+  }
+
+  /**
+   * Set the migration version.
+   * <p>
+   * Note that version set via System property or environment variable <code>ddl.migration.version</code> takes precedence.
+   */
+  public void setVersion(String version) {
+    this.version = version;
+  }
+
+  /**
+   * Set the migration name.
+   * <p>
+   * Note that name set via System property or environment variable <code>ddl.migration.name</code> takes precedence.
+   */
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  /**
+   * Set the model, rollback and drop paths to be empty such that all the migration files are generated
+   * into a single directory.
+   */
+  public void singleDirectory() {
+    this.dropPath = "";
+    this.rollbackPath = "";
+    this.modelPath = "";
   }
 
   /**
    * Load the settings from the PropertiesWrapper.
    */
   public void loadSettings(PropertiesWrapper properties) {
-    resourcePath = properties.get("migration.resourcePath", resourcePath);
+
+    migrationPath = properties.get("migration.migrationPath", migrationPath);
+    if (properties.getBoolean("migration.singleDirectory", false)) {
+      singleDirectory();
+    } else {
+      modelPath = properties.get("migration.modelPath", modelPath);
+      rollbackPath = properties.get("migration.rollbackPath", rollbackPath);
+      dropPath = properties.get("migration.dropPath", dropPath);
+    }
+    applySuffix = properties.get("migration.applySuffix", applySuffix);
+    dropSuffix = properties.get("migration.dropSuffix", dropSuffix);
+    rollbackSuffix = properties.get("migration.rollbackSuffix", rollbackSuffix);
+    modelSuffix = properties.get("migration.modelSuffix", modelSuffix);
+    includeGeneratedFileComment = properties.getBoolean("migration.includeGeneratedFileComment", includeGeneratedFileComment);
+
+    platform = properties.getEnum(DbPlatformName.class, "migration.platform", platform);
+    suppressRollback = properties.getBoolean("migration.suppressRollback", suppressRollback);
+
+    generate = properties.getBoolean("migration.generate", generate);
+    version = properties.get("migration.version", version);
+    name = properties.get("migration.name", name);
   }
+
+  /**
+   * Return true if the migration should be generated.
+   * <p>
+   * It is expected that when an environment variable <code>ddl.migration.enabled</code>
+   * is set to <code>true</code> then the DB migration will generate the migration DDL.
+   * </p>
+   */
+  public boolean isGenerateOnStart() {
+
+    // environment properties take precedence
+    String envGenerate = readEnvironment("ddl.migration.generate");
+    if (envGenerate != null) {
+      return "true".equalsIgnoreCase(envGenerate.trim());
+    }
+    return generate;
+  }
+
+
+  /**
+   * Called by EbeanServer on start.
+   *
+   * <p>
+   * If enabled this generates the migration xml and DDL scripts.
+   * </p>
+   */
+  public void generateOnStart(EbeanServer server) {
+
+    if (isGenerateOnStart()) {
+      if (platform == null) {
+        logger.warn("No platform set for migration DDL generation");
+      } else {
+        // generate the migration xml and platform specific DDL
+        DbMigration migration = new DbMigration(server);
+        migration.setPlatform(platform);
+        try {
+          migration.generateMigration();
+        } catch (Exception e) {
+          throw new RuntimeException("Error generating DB migration", e);
+        }
+      }
+    }
+  }
+
+  /**
+   * Return the migration version (typically FlywayDb compatible).
+   * <p>
+   * Example: 1.1.1_2
+   * <p>
+   * The version is expected to be the combination of the current pom version plus
+   * a 'feature' id. The combined version must be unique and ordered to work with
+   * FlywayDb so each developer sets a unique version so that the migration script
+   * generated is unique (typically just prior to being submitted as a merge request).
+   */
+  public String getVersion() {
+    String envVersion = readEnvironment("ddl.migration.version");
+    if (!isEmpty(envVersion)) {
+      return envVersion.trim();
+    }
+    return version;
+  }
+
+  /**
+   * Return the migration name which is short description text that can be appended to
+   * the migration version to become the ddl script file name.
+   * <p>
+   * So if the name is "a foo table" then the ddl script file could be:
+   * "1.1.1_2__a-foo-table.sql"
+   * </p>
+   * <p>
+   * When the DB migration relates to a git feature (merge request) then this description text
+   * is a short description of the feature.
+   * </p>
+   */
+  public String getName() {
+    String envName = readEnvironment("ddl.migration.name");
+    if (!isEmpty(envName)) {
+      return envName.trim();
+    }
+    return name;
+  }
+
+  /**
+   * Return the system or environment property.
+   */
+  protected String readEnvironment(String key) {
+
+    String val = System.getProperty(key);
+    if (val == null) {
+      val = System.getenv(key);
+    }
+    return val;
+  }
+
+  /**
+   * Return true if the string is null or empty.
+   */
+  protected boolean isEmpty(String val) {
+    return val == null || val.trim().isEmpty();
+  }
+
 }

src/main/java/com/avaje/ebean/config/PropertiesWrapper.java

@@ -141,8 +141,8 @@ public class PropertiesWrapper {
    * Return a Enum property value.
    */
   public <T extends Enum<T>> T getEnum(Class<T> enumType, String key, T defaultValue) {
-    String level = get(key, defaultValue.name());
-    return Enum.valueOf(enumType, level.toUpperCase());
+    String level = get(key, null);
+    return (level == null) ? defaultValue : Enum.valueOf(enumType, level.toUpperCase());
   }
 
 }

src/main/java/com/avaje/ebean/config/PropertyMapLoader.java

@@ -18,7 +18,7 @@ final class PropertyMapLoader {
    * Load the <code>test-ebean.properties</code>.
    */
   public static PropertyMap loadTestProperties() {
-    return load(null, "test-ebean.properties", false);
+    return load(null, "test-ebean.properties");
   }
 
   /**
@@ -36,10 +36,10 @@ final class PropertyMapLoader {
       }
     }
 
-    PropertyMap map = load(null, fileName, true);
+    PropertyMap map = load(null, fileName);
     if (loadTestProperties) {
       // load test properties if present in classpath
-      load(map, "test-ebean.properties", false);
+      map = load(map, "test-ebean.properties");
     }
     return map;
   }
@@ -52,13 +52,10 @@ final class PropertyMapLoader {
    * @param fileName
    *          the name of the properties file to load.
    */
-  public static PropertyMap load(PropertyMap p, String fileName, boolean errorOnNull) {
+  public static PropertyMap load(PropertyMap p, String fileName) {
 
     InputStream is = findInputStream(fileName);
     if (is == null) {
-      if (errorOnNull) {
-        logger.error(fileName + " not found");
-      }
       return p;
     } else {
       return load(p, is);
@@ -66,7 +63,7 @@ final class PropertyMapLoader {
   }
 
   /**
-   * Load the inputstream returning the property map.
+   * Load the InputStream returning the property map.
    * 
    * @param p
    *          an existing property map to load into.

src/main/java/com/avaje/ebean/config/ServerConfig.java

@@ -7,14 +7,20 @@ import com.avaje.ebean.cache.ServerCacheFactory;
 import com.avaje.ebean.cache.ServerCacheManager;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 import com.avaje.ebean.config.dbplatform.DbEncrypt;
-import com.avaje.ebean.event.*;
+import com.avaje.ebean.event.BeanFindController;
+import com.avaje.ebean.event.BeanPersistController;
+import com.avaje.ebean.event.BeanPersistListener;
+import com.avaje.ebean.event.BeanPostLoad;
+import com.avaje.ebean.event.BeanQueryAdapter;
+import com.avaje.ebean.event.BulkTableEventListener;
+import com.avaje.ebean.event.ServerConfigStartup;
+import com.avaje.ebean.event.TransactionEventListener;
 import com.avaje.ebean.event.changelog.ChangeLogListener;
 import com.avaje.ebean.event.changelog.ChangeLogPrepare;
 import com.avaje.ebean.event.changelog.ChangeLogRegister;
 import com.avaje.ebean.event.readaudit.ReadAuditLogger;
 import com.avaje.ebean.event.readaudit.ReadAuditPrepare;
 import com.avaje.ebean.meta.MetaInfoManager;
-import com.avaje.ebean.util.ClassUtil;
 import com.fasterxml.jackson.core.JsonFactory;
 
 import javax.sql.DataSource;
@@ -206,6 +212,12 @@ public class ServerConfig {
 
   private boolean ddlRun;
 
+  private boolean ddlCreateOnly;
+
+  private String ddlInitSql;
+
+  private String ddlSeedSql;
+
   private boolean useJtaTransactionManager;
 
   /**
@@ -228,6 +240,11 @@ public class ServerConfig {
    */
   private DbMigrationConfig migrationConfig = new DbMigrationConfig();
 
+  /**
+   * The ClassLoadConfig used to detect Joda, Java8, Jackson etc and create plugin instances given a className.
+   */
+  private ClassLoadConfig classLoadConfig = new ClassLoadConfig();
+
   /**
    * Set to true if the DataSource uses autoCommit.
    * <p>
@@ -1518,19 +1535,81 @@ public class ServerConfig {
   }
 
   /**
-   * Set to true to run the DDL generation on startup.
+   * Set to true to generate the "create all" DDL on startup.
+   *
+   * Typically we want this on when we are running tests locally (and often using H2)
+   * and we want to create the full DB schema from scratch to run tests.
    */
   public void setDdlGenerate(boolean ddlGenerate) {
     this.ddlGenerate = ddlGenerate;
   }
 
   /**
-   * Set to true to run the generated DDL on startup.
+   * Set to true to run the generated "create all DDL" on startup.
+   *
+   * Typically we want this on when we are running tests locally (and often using H2)
+   * and we want to create the full DB schema from scratch to run tests.
    */
   public void setDdlRun(boolean ddlRun) {
     this.ddlRun = ddlRun;
   }
 
+  /**
+   * Return true if the "drop all ddl" should be skipped.
+   *
+   * Typically we want to do this when using H2 (in memory) as our test database and the drop statements
+   * are not required so skipping the drop table statements etc makes it faster with less noise in the logs.
+   */
+  public boolean isDdlCreateOnly() {
+    return ddlCreateOnly;
+  }
+
+  /**
+   * Set to true if the "drop all ddl" should be skipped.
+   *
+   * Typically we want to do this when using H2 (in memory) as our test database and the drop statements
+   * are not required so skipping the drop table statements etc makes it faster with less noise in the logs.
+   */
+  public void setDdlCreateOnly(boolean ddlCreateOnly) {
+    this.ddlCreateOnly = ddlCreateOnly;
+  }
+
+  /**
+   * Return SQL script to execute after the "create all" DDL has been run.
+   * <p>
+   *   Typically this is a sql script that inserts test seed data when running tests.
+   *   Place a sql script in src/test/resources that inserts test seed data.
+   * </p>
+   */
+  public String getDdlSeedSql() {
+    return ddlSeedSql;
+  }
+
+  /**
+   * Set a SQL script to execute after the "create all" DDL has been run.
+   * <p>
+   *   Typically this is a sql script that inserts test seed data when running tests.
+   *   Place a sql script in src/test/resources that inserts test seed data.
+   * </p>
+   */
+  public void setDdlSeedSql(String ddlSeedSql) {
+    this.ddlSeedSql = ddlSeedSql;
+  }
+
+  /**
+   * Return a SQL script to execute before the "create all" DDL has been run.
+   */
+  public String getDdlInitSql() {
+    return ddlInitSql;
+  }
+
+  /**
+   * Set a SQL script to execute before the "create all" DDL has been run.
+   */
+  public void setDdlInitSql(String ddlInitSql) {
+    this.ddlInitSql = ddlInitSql;
+  }
+
   /**
    * Return true if the DDL should be generated.
    */
@@ -2023,6 +2102,22 @@ public class ServerConfig {
     this.persistenceContextScope = persistenceContextScope;
   }
 
+  /**
+   * Return the ClassLoadConfig which is used to detect Joda, Java8 types etc and also
+   * create new instances of plugins given a className.
+   */
+  public ClassLoadConfig getClassLoadConfig() {
+    return classLoadConfig;
+  }
+
+  /**
+   * Set the ClassLoadConfig which is used to detect Joda, Java8 types etc and also
+   * create new instances of plugins given a className.
+   */
+  public void setClassLoadConfig(ClassLoadConfig classLoadConfig) {
+    this.classLoadConfig = classLoadConfig;
+  }
+
   /**
    * Load settings from ebean.properties.
    */
@@ -2062,14 +2157,31 @@ public class ServerConfig {
     return properties;
   }
 
+  /**
+   * Return the instance to use (can be null) for the given plugin.
+   *
+   * @param properties the properties
+   * @param pluginType the type of plugin
+   * @param key        properties key
+   * @param instance   existing instance
+   */
   @SuppressWarnings("unchecked")
-  private <T> T createInstance(PropertiesWrapper p, Class<T> pluginType, String key, T instance) {
+  protected  <T> T createInstance(PropertiesWrapper properties, Class<T> pluginType, String key, T instance) {
 
     if (instance != null) {
       return instance;
     }
-    String classname = p.get(key, null);
-    return classname == null ? null : (T) ClassUtil.newInstance(classname);
+    String classname = properties.get(key, null);
+    return createInstance(pluginType, classname);
+  }
+
+  /**
+   * Return the instance to use (can be null) for the given plugin.
+   * @param pluginType the type of plugin
+   * @param classname the implementation class as per properties
+   */
+  protected <T> T createInstance(Class<T> pluginType, String classname) {
+    return classname == null ? null : (T) classLoadConfig.newInstance(classname);
   }
 
   /**
@@ -2188,6 +2300,9 @@ public class ServerConfig {
 
     ddlGenerate = p.getBoolean("ddl.generate", ddlGenerate);
     ddlRun = p.getBoolean("ddl.run", ddlRun);
+    ddlCreateOnly = p.getBoolean("ddl.createOnly", ddlCreateOnly);
+    ddlInitSql = p.get("ddl.initSql", ddlInitSql);
+    ddlSeedSql = p.get("ddl.seedSql", ddlSeedSql);
 
     classes = getClasses(p);
   }

src/main/java/com/avaje/ebean/config/dbplatform/DB2SequenceIdGenerator.java

@@ -17,7 +17,7 @@ public class DB2SequenceIdGenerator extends SequenceIdGenerator {
    */
   public DB2SequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
     super(be, ds, seqName, batchSize);
-    this.baseSql = "select nextval for " + seqName;
+    this.baseSql = "values nextval for " + seqName;
     this.unionBaseSql = " union " + baseSql;
   }
 

src/main/java/com/avaje/ebean/dbmigration/DbMigration.java

@@ -21,8 +21,8 @@ import com.avaje.ebean.dbmigration.model.CurrentModel;
 import com.avaje.ebean.dbmigration.model.MConfiguration;
 import com.avaje.ebean.dbmigration.model.MigrationModel;
 import com.avaje.ebean.dbmigration.model.ModelContainer;
-import com.avaje.ebean.dbmigration.model.PlatformDdlWriter;
 import com.avaje.ebean.dbmigration.model.ModelDiff;
+import com.avaje.ebean.dbmigration.model.PlatformDdlWriter;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -57,6 +57,15 @@ public class DbMigration {
 
   protected static final Logger logger = LoggerFactory.getLogger(DbMigration.class);
 
+  private static final String initialVersion = "1.0";
+
+  private static final String GENERATED_COMMENT = "THIS IS A GENERATED FILE - DO NOT MODIFY";
+
+  /**
+   * Set to true if DbMigration run with online EbeanServer instance.
+   */
+  protected final boolean online;
+
   protected SpiEbeanServer server;
 
   protected DbMigrationConfig migrationConfig;
@@ -71,7 +80,19 @@ public class DbMigration {
 
   protected DbConstraintNaming constraintNaming;
 
+  /**
+   * Create for offline migration generation.
+   */
   public DbMigration() {
+    this.online = false;
+  }
+
+  /**
+   * Create using online EbeanServer.
+   */
+  public DbMigration(EbeanServer server) {
+    this.online = true;
+    setServer(server);
   }
 
   /**
@@ -125,7 +146,9 @@ public class DbMigration {
    */
   public void setPlatform(DatabasePlatform databasePlatform) {
     this.databasePlatform = databasePlatform;
-    DbOffline.setPlatform(databasePlatform.getName());
+    if (!online) {
+      DbOffline.setPlatform(databasePlatform.getName());
+    }
   }
 
   /**
@@ -175,16 +198,19 @@ public class DbMigration {
   public void generateMigration() throws IOException {
 
     // use this flag to stop other plugins like full DDL generation
-    DbOffline.setRunningMigration();
+    if (!online) {
+      DbOffline.setRunningMigration();
+    }
 
     setDefaults();
 
     try {
-      MigrationModel migrationModel = new MigrationModel(migrationConfig.getResourcePath());
-      ModelContainer migrated = migrationModel.read();
-      int nextMajorVersion = migrationModel.getNextMajorVersion();
 
-      logger.info("next migration version {}", nextMajorVersion);
+      File migrationDir = getMigrationDirectory();
+      File modelDir = getModelDirectory(migrationDir);
+
+      MigrationModel migrationModel = new MigrationModel(modelDir, migrationConfig.getModelSuffix());
+      ModelContainer migrated = migrationModel.read();
 
       CurrentModel currentModel = new CurrentModel(server, constraintNaming);
       ModelContainer current = currentModel.read();
@@ -200,46 +226,90 @@ public class DbMigration {
       // there were actually changes to write
       Migration dbMigration = diff.getMigration();
 
-      File writePath = getWritePath();
-      logger.info("migration writing version {} to {}", nextMajorVersion, writePath.getAbsolutePath());
-      writeMigrationXml(dbMigration, writePath, nextMajorVersion);
+      String fullVersion = getFullVersion(migrationModel);
 
-      if (databasePlatform != null) {
-        // writer needs the current model to provide table/column details for
-        // history ddl generation (triggers, history tables etc)
-        DdlWrite write = new DdlWrite(new MConfiguration(), currentModel.read());
-        PlatformDdlWriter writer = new PlatformDdlWriter(databasePlatform, serverConfig);
-        writer.processMigration(dbMigration, write, writePath, nextMajorVersion);
+      logger.info("generating migration:{}", fullVersion);
+      if (!writeMigrationXml(dbMigration, modelDir, fullVersion)) {
+        logger.warn("migration already exists, not generating DDL");
+
+      } else {
+        if (databasePlatform != null) {
+          // writer needs the current model to provide table/column details for
+          // history ddl generation (triggers, history tables etc)
+          DdlWrite write = new DdlWrite(new MConfiguration(), current);
+          PlatformDdlWriter writer = createDdlWriter(databasePlatform, "");
+          writer.processMigration(dbMigration, write, migrationDir , fullVersion);
+        }
+        writeExtraPlatformDdl(fullVersion, currentModel, dbMigration, migrationDir);
       }
 
-      writeExtraPlatformDdl(nextMajorVersion, currentModel, dbMigration, writePath);
-
     } finally {
-      DbOffline.reset();
+      if (!online) {
+        DbOffline.reset();
+      }
     }
   }
 
+  /**
+   * Return the full version for the migration being generated.
+   */
+  private String getFullVersion(MigrationModel migrationModel) {
+
+    String version = migrationConfig.getVersion();
+    if (version == null) {
+      version = migrationModel.getNextVersion(initialVersion);
+    }
+
+    String fullVersion = version;
+
+    String name = migrationConfig.getName();
+    if (name != null) {
+      fullVersion += "__" + toUnderScore(name);
+    }
+    return fullVersion;
+  }
+
+  /**
+   * Replace spaces with underscores.
+   */
+  private String toUnderScore(String name) {
+    return name.replace(' ','_');
+  }
+
   /**
    * Write any extra platform ddl.
    */
-  protected void writeExtraPlatformDdl(int nextMajorVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
+  protected void writeExtraPlatformDdl(String fullVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
 
     for (Pair pair : platforms) {
       DdlWrite platformBuffer = new DdlWrite(new MConfiguration(), currentModel.read());
-
-      PlatformDdlWriter platformWriter = new PlatformDdlWriter(pair.platform, serverConfig, pair.prefix);
-      platformWriter.processMigration(dbMigration, platformBuffer, writePath, nextMajorVersion);
+      PlatformDdlWriter platformWriter = createDdlWriter(pair);
+      platformWriter.processMigration(dbMigration, platformBuffer, writePath, fullVersion);
     }
   }
 
+  private PlatformDdlWriter createDdlWriter(Pair pair) {
+    return createDdlWriter(pair.platform, pair.prefix);
+  }
+
+  private PlatformDdlWriter createDdlWriter(DatabasePlatform platform, String prefix) {
+    return new PlatformDdlWriter(platform, serverConfig, prefix, migrationConfig);
+  }
+
   /**
    * Write the migration xml.
    */
-  protected void writeMigrationXml(Migration dbMigration, File resourcePath, int migrationVersion) {
+  protected boolean writeMigrationXml(Migration dbMigration, File resourcePath, String fullVersion) {
 
-    File file = new File(resourcePath, "v"+migrationVersion+".0.xml");
-    MigrationXmlWriter xmlWriter = new MigrationXmlWriter();
+    String modelFile = fullVersion + migrationConfig.getModelSuffix();
+    File file = new File(resourcePath, modelFile);
+    if (file.exists()) {
+      return false;
+    }
+    String comment = migrationConfig.isIncludeGeneratedFileComment() ? GENERATED_COMMENT : null;
+    MigrationXmlWriter xmlWriter = new MigrationXmlWriter(comment);
     xmlWriter.write(dbMigration, file);
+    return true;
   }
 
   /**
@@ -260,14 +330,13 @@ public class DbMigration {
   /**
    * Return the file path to write the xml and sql to.
    */
-  protected File getWritePath() {
+  protected File getMigrationDirectory() {
 
     // path to src/main/resources in typical maven project
     File resourceRootDir = new File(pathToResources);
+    String resourcePath = migrationConfig.getMigrationPath();
 
-    String resourcePath = migrationConfig.getResourcePath();
-
-    // expect to be a path to something like - src/main/resources/dbmigration/myapp
+    // expect to be a path to something like - src/main/resources/dbmigration/model
     File path = new File(resourceRootDir, resourcePath);
     if (!path.exists()) {
       if (!path.mkdirs()) {
@@ -277,6 +346,21 @@ public class DbMigration {
     return path;
   }
 
+  /**
+   * Return the model directory (relative to the migration directory).
+   */
+  protected File getModelDirectory(File migrationDirectory) {
+    String modelPath = migrationConfig.getModelPath();
+    if (modelPath ==  null || modelPath.isEmpty()) {
+      return migrationDirectory;
+    }
+    File modelDir = new File(migrationDirectory, migrationConfig.getModelPath());
+    if (!modelDir.exists() && !modelDir.mkdirs()) {
+      logger.debug("Unable to ensure migration model directory exists at {}", modelDir.getAbsolutePath());
+    }
+    return modelDir;
+  }
+
   /**
    * Return the DatabasePlatform given the platform key.
    */

src/main/java/com/avaje/ebean/dbmigration/DdlGenerator.java

@@ -1,47 +1,43 @@
 package com.avaje.ebean.dbmigration;
 
-import com.avaje.ebean.Transaction;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.dbmigration.model.CurrentModel;
 import com.avaje.ebeaninternal.api.SpiEbeanPlugin;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import javax.persistence.PersistenceException;
-import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.io.LineNumberReader;
-import java.io.StringReader;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.List;
+import java.io.Reader;
 
 /**
- * Controls the generation of DDL and potentially runs the resulting scripts.
+ * Controls the generation and execution of "Create All" and "Drop All" DDL scripts.
+ *
+ * Typically the "Create All" DDL is executed for running tests etc and has nothing to do
+ * with DB Migration (diff based) DDL.
  */
-public class DdlGenerator implements SpiEbeanPlugin {
+public class DdlGenerator {
 
-  private static final Logger logger = LoggerFactory.getLogger(DdlGenerator.class);
+  private final SpiEbeanServer server;
 
-  private SpiEbeanServer server;
-
-  private boolean generateDdl;
-  private boolean runDdl;
+  private final boolean generateDdl;
+  private final boolean runDdl;
+  private final boolean createOnly;
 
   private CurrentModel currentModel;
   private String dropContent;
   private String createContent;
 
-  public void setup(SpiEbeanServer server, ServerConfig serverConfig) {
+  public DdlGenerator(SpiEbeanServer server, ServerConfig serverConfig) {
     this.server = server;
     this.generateDdl = serverConfig.isDdlGenerate();
     this.runDdl = serverConfig.isDdlRun();
+    this.createOnly = serverConfig.isDdlCreateOnly();
   }
 
   /**
@@ -58,9 +54,11 @@ public class DdlGenerator implements SpiEbeanPlugin {
   /**
    * Generate the DDL drop and create scripts if the properties have been set.
    */
-  public void generateDdl() {
+  protected void generateDdl() {
     if (generateDdl) {
-      writeDrop(getDropFileName());
+      if (!createOnly) {
+        writeDrop(getDropFileName());
+      }
       writeCreate(getCreateFileName());
     }
   }
@@ -68,18 +66,14 @@ public class DdlGenerator implements SpiEbeanPlugin {
   /**
    * Run the DDL drop and DDL create scripts if properties have been set.
    */
-  public void runDdl() {
+  protected void runDdl() {
 
     if (runDdl) {
       try {
-        if (dropContent == null) {
-          dropContent = readFile(getDropFileName());
-        }
-        if (createContent == null) {
-          createContent = readFile(getCreateFileName());
-        }
-        runScript(true, dropContent);
-        runScript(false, createContent);
+        runInitSql();
+        runDropSql();
+        runCreateSql();
+        runSeedSql();
 
       } catch (IOException e) {
         String msg = "Error reading drop/create script from file system";
@@ -88,6 +82,53 @@ public class DdlGenerator implements SpiEbeanPlugin {
     }
   }
 
+  protected void runDropSql() throws IOException {
+    if (!createOnly) {
+      if (dropContent == null) {
+        dropContent = readFile(getDropFileName());
+      }
+      runScript(true, dropContent, getDropFileName());
+    }
+  }
+
+  protected void runCreateSql() throws IOException {
+    if (createContent == null) {
+      createContent = readFile(getCreateFileName());
+    }
+    runScript(false, createContent, getCreateFileName());
+  }
+
+  protected void runInitSql() throws IOException {
+    runResourceScript(server.getServerConfig().getDdlInitSql());
+  }
+
+  protected void runSeedSql() throws IOException {
+    runResourceScript(server.getServerConfig().getDdlSeedSql());
+  }
+
+  protected void runResourceScript(String sqlScript) throws IOException {
+
+    if (sqlScript != null) {
+      InputStream is = getClassLoader().getResourceAsStream(sqlScript);
+      if (is != null) {
+        DdlRunner runner = new DdlRunner(false, sqlScript);
+        String content = readContent(new InputStreamReader(is));
+        runner.runAll(content, server);
+      }
+    }
+  }
+
+  /**
+   * Return the classLoader to use to read sql scripts as resources.
+   */
+  protected ClassLoader getClassLoader() {
+    ClassLoader cl = Thread.currentThread().getContextClassLoader();
+    if (cl == null) {
+      cl = this.getClassLoader();
+    }
+    return cl;
+  }
+
   protected void writeDrop(String dropFile) {
 
     try {
@@ -108,7 +149,7 @@ public class DdlGenerator implements SpiEbeanPlugin {
     }
   }
 
-  public String generateDropDdl() {
+  protected String generateDropDdl() {
 
     try {
       dropContent = currentModel().getDropDdl();
@@ -118,7 +159,7 @@ public class DdlGenerator implements SpiEbeanPlugin {
     }
   }
 
-  public String generateCreateDdl() {
+  protected String generateCreateDdl() {
 
     try {
       createContent = currentModel().getCreateDdl();
@@ -163,201 +204,33 @@ public class DdlGenerator implements SpiEbeanPlugin {
       return null;
     }
 
+    return readContent(new FileReader(f));
+  }
+
+  protected String readContent(Reader reader) throws IOException {
+
     StringBuilder buf = new StringBuilder();
 
-    FileReader fr = new FileReader(f);
-    LineNumberReader lr = new LineNumberReader(fr);
+    LineNumberReader lineReader = new LineNumberReader(reader);
     try {
       String s;
-      while ((s = lr.readLine()) != null) {
+      while ((s = lineReader.readLine()) != null) {
         buf.append(s).append("\n");
       }
-    } finally {
-      lr.close();
-    }
+      return buf.toString();
 
-    return buf.toString();
+    } finally {
+      lineReader.close();
+    }
   }
 
   /**
    * Execute all the DDL statements in the script.
    */
-  public void runScript(boolean expectErrors, String content) {
+  public int runScript(boolean expectErrors, String content, String scriptName) {
 
-    StringReader sr = new StringReader(content);
-    List<String> statements = parseStatements(sr);
-
-    Transaction t = server.createTransaction();
-    try {
-      Connection connection = t.getConnection();
-
-      logger.info("Running DDL");
-
-      runStatements(expectErrors, statements, connection);
-
-      logger.info("Running DDL Complete");
-
-      t.commit();
-
-    } catch (Exception e) {
-      throw new PersistenceException("Error: " + e.getMessage(), e);
-    } finally {
-      t.end();
-    }
+    DdlRunner runner = new DdlRunner(expectErrors, scriptName);
+    return runner.runAll(content, server);
   }
 
-  /**
-   * Execute the list of statements.
-   */
-  private void runStatements(boolean expectErrors, List<String> statements, Connection c) {
-    List<String> noDuplicates = new ArrayList<String>();
-
-    for (String statement : statements) {
-      if (!noDuplicates.contains(statement)) {
-        noDuplicates.add(statement);
-      }
-    }
-
-    for (int i = 0; i < noDuplicates.size(); i++) {
-      String xOfy = (i + 1) + " of " + noDuplicates.size();
-      runStatement(expectErrors, xOfy, noDuplicates.get(i), c);
-    }
-  }
-
-  /**
-   * Execute the statement.
-   */
-  private void runStatement(boolean expectErrors, String oneOf, String stmt, Connection c) {
-
-    PreparedStatement pstmt = null;
-    try {
-
-      // trim and remove trailing ; or /
-      stmt = stmt.trim();
-      if (stmt.endsWith(";")) {
-        stmt = stmt.substring(0, stmt.length() - 1);
-      } else if (stmt.endsWith("/")) {
-        stmt = stmt.substring(0, stmt.length() - 1);
-      }
-
-      logger.info("executing " + oneOf + " " + getSummary(stmt));
-
-      pstmt = c.prepareStatement(stmt);
-      pstmt.execute();
-
-    } catch (Exception e) {
-      if (expectErrors) {
-        logger.info(" ... ignoring error executing " + getSummary(stmt) + "  error: " + e.getMessage());
-      } else {
-        String msg = "Error executing stmt[" + stmt + "] error[" + e.getMessage() + "]";
-        throw new RuntimeException(msg, e);
-      }
-    } finally {
-      if (pstmt != null) {
-        try {
-          pstmt.close();
-        } catch (SQLException e) {
-          logger.error("Error closing pstmt", e);
-        }
-      }
-    }
-  }
-
-  /**
-   * Local utility used to detect the end of statements / separate statements.
-   * This is often just the semicolon character but for trigger/procedures this
-   * detects the $$ demarcation used in the history DDL generation for MySql and
-   * Postgres.
-   */
-  static class StatementsSeparator {
-
-    ArrayList<String> statements = new ArrayList<String>();
-
-    boolean trimDelimiter;
-
-    boolean inDbProcedure;
-
-    StringBuilder sb = new StringBuilder();
-
-    void lineContainsDollars(String line) {
-      if (inDbProcedure) {
-        if (trimDelimiter) {
-          line = line.replace("$$","");
-        }
-        endOfStatement(line);
-      } else {
-        // MySql style delimiter needs to be trimmed/removed
-        trimDelimiter = line.equals("delimiter $$");
-        if (!trimDelimiter) {
-          sb.append(line).append(" ");
-        }
-      }
-      inDbProcedure = !inDbProcedure;
-    }
-
-    void endOfStatement(String line) {
-      // end of Db procedure
-      sb.append(line);
-      statements.add(sb.toString().trim());
-      sb = new StringBuilder();
-    }
-
-    void nextLine(String line) {
-
-      if (line.contains("$$")) {
-        lineContainsDollars(line);
-        return;
-      }
-
-      if (inDbProcedure) {
-        sb.append(line).append(" ");
-        return;
-      }
-
-      int semiPos = line.indexOf(';');
-      if (semiPos == -1) {
-        sb.append(line).append(" ");
-
-      } else if (semiPos == line.length() - 1) {
-        // semicolon at end of line
-        endOfStatement(line);
-
-      } else {
-        // semicolon in middle of line
-        String preSemi = line.substring(0, semiPos);
-        endOfStatement(preSemi);
-        sb.append(line.substring(semiPos + 1));
-      }
-    }
-  }
-
-  /**
-   * Break up the sql in reader into a list of statements using the semi-colon
-   * character;
-   */
-  protected List<String> parseStatements(StringReader reader) {
-
-    try {
-      BufferedReader br = new BufferedReader(reader);
-      StatementsSeparator statements = new StatementsSeparator();
-
-      String s;
-      while ((s = br.readLine()) != null) {
-        s = s.trim();
-        statements.nextLine(s);
-      }
-
-      return statements.statements;
-
-    } catch (IOException e) {
-      throw new PersistenceException(e);
-    }
-  }
-
-  private String getSummary(String s) {
-    if (s.length() > 80) {
-      return s.substring(0, 80).trim() + "...";
-    }
-    return s;
-  }
 }

src/main/java/com/avaje/ebean/dbmigration/DdlParser.java

@@ -0,0 +1,110 @@
+package com.avaje.ebean.dbmigration;
+
+import javax.persistence.PersistenceException;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Parses string content into separate SQL/DDL statements.
+ */
+public class DdlParser {
+
+  /**
+   * Break up the sql in reader into a list of statements using the semi-colon and $$ delimiters;
+   */
+  public List<String> parse(StringReader reader) {
+
+    try {
+      BufferedReader br = new BufferedReader(reader);
+      StatementsSeparator statements = new StatementsSeparator();
+
+      String s;
+      while ((s = br.readLine()) != null) {
+        s = s.trim();
+        statements.nextLine(s);
+      }
+
+      return statements.statements;
+
+    } catch (IOException e) {
+      throw new PersistenceException(e);
+    }
+  }
+
+
+  /**
+   * Local utility used to detect the end of statements / separate statements.
+   * This is often just the semicolon character but for trigger/procedures this
+   * detects the $$ demarcation used in the history DDL generation for MySql and
+   * Postgres.
+   */
+  static class StatementsSeparator {
+
+    ArrayList<String> statements = new ArrayList<String>();
+
+    boolean trimDelimiter;
+
+    boolean inDbProcedure;
+
+    StringBuilder sb = new StringBuilder();
+
+    void lineContainsDollars(String line) {
+      if (inDbProcedure) {
+        if (trimDelimiter) {
+          line = line.replace("$$","");
+        }
+        endOfStatement(line);
+      } else {
+        // MySql style delimiter needs to be trimmed/removed
+        trimDelimiter = line.equals("delimiter $$");
+        if (!trimDelimiter) {
+          sb.append(line).append(" ");
+        }
+      }
+      inDbProcedure = !inDbProcedure;
+    }
+
+    void endOfStatement(String line) {
+      // end of Db procedure
+      sb.append(line);
+      statements.add(sb.toString().trim());
+      sb = new StringBuilder();
+    }
+
+    void nextLine(String line) {
+
+      if (line.contains("$$")) {
+        lineContainsDollars(line);
+        return;
+      }
+
+      if (sb.length() == 0 && (line.isEmpty() || line.startsWith("--"))) {
+        // ignore leading empty lines and sql comments
+        return;
+      }
+
+      if (inDbProcedure) {
+        sb.append(line).append(" ");
+        return;
+      }
+
+      int semiPos = line.indexOf(';');
+      if (semiPos == -1) {
+        sb.append(line).append(" ");
+
+      } else if (semiPos == line.length() - 1) {
+        // semicolon at end of line
+        endOfStatement(line);
+
+      } else {
+        // semicolon in middle of line
+        String preSemi = line.substring(0, semiPos);
+        endOfStatement(preSemi);
+        sb.append(line.substring(semiPos + 1));
+      }
+    }
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/DdlRunner.java

@@ -0,0 +1,138 @@
+package com.avaje.ebean.dbmigration;
+
+import com.avaje.ebean.Transaction;
+import com.avaje.ebeaninternal.api.SpiEbeanServer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.persistence.PersistenceException;
+import java.io.StringReader;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Runs DDL scripts.
+ */
+public class DdlRunner {
+
+  protected static final Logger logger = LoggerFactory.getLogger(DdlRunner.class);
+
+  protected DdlParser ddlParser = new DdlParser();
+
+  protected final String scriptName;
+
+  protected final boolean expectErrors;
+
+  /**
+   * Construct with a script name (for logging) and flag indicating if errors are expected.
+   */
+  public DdlRunner(boolean expectErrors, String scriptName) {
+    this.expectErrors = expectErrors;
+    this.scriptName = scriptName;
+  }
+
+  /**
+   * Parse the content into sql statements and execute them in a transaction.
+   */
+  public int runAll(String content, SpiEbeanServer server) {
+
+    List<String> statements = ddlParser.parse(new StringReader(content));
+    return runStatements(statements, server);
+  }
+
+  /**
+   * Execute all the statements in a single transaction.
+   */
+  public int runStatements(List<String> statements, SpiEbeanServer server) {
+
+    Transaction t = server.createTransaction();
+    try {
+      int statementCount = runStatements(expectErrors, statements, t.getConnection());
+      t.commit();
+
+      return statementCount;
+
+    } catch (Exception e) {
+      throw new PersistenceException("Error: " + e.getMessage(), e);
+
+    } finally {
+      t.end();
+    }
+  }
+
+  /**
+   * Execute the list of statements.
+   */
+  private int runStatements(boolean expectErrors, List<String> statements, Connection c) {
+
+    List<String> noDuplicates = new ArrayList<String>();
+
+    for (String statement : statements) {
+      if (!noDuplicates.contains(statement)) {
+        noDuplicates.add(statement);
+      }
+    }
+
+    logger.info("Executing {} - {} statements", scriptName, noDuplicates.size());
+
+    for (int i = 0; i < noDuplicates.size(); i++) {
+      String xOfy = (i + 1) + " of " + noDuplicates.size();
+      runStatement(expectErrors, xOfy, noDuplicates.get(i), c);
+    }
+
+    return noDuplicates.size();
+  }
+
+  /**
+   * Execute the statement.
+   */
+  private void runStatement(boolean expectErrors, String oneOf, String stmt, Connection c) {
+
+    PreparedStatement pstmt = null;
+    try {
+
+      // trim and remove trailing ; or /
+      stmt = stmt.trim();
+      if (stmt.endsWith(";")) {
+        stmt = stmt.substring(0, stmt.length() - 1);
+      } else if (stmt.endsWith("/")) {
+        stmt = stmt.substring(0, stmt.length() - 1);
+      }
+
+      if (logger.isDebugEnabled()) {
+        logger.debug("executing " + oneOf + " " + getSummary(stmt));
+      }
+
+      pstmt = c.prepareStatement(stmt);
+      pstmt.execute();
+
+    } catch (Exception e) {
+      if (expectErrors) {
+        logger.debug(" ... ignoring error executing " + getSummary(stmt) + "  error: " + e.getMessage());
+      } else {
+        String msg = "Error executing stmt[" + stmt + "] error[" + e.getMessage() + "]";
+        throw new RuntimeException(msg, e);
+      }
+
+    } finally {
+      if (pstmt != null) {
+        try {
+          pstmt.close();
+        } catch (SQLException e) {
+          logger.error("Error closing pstmt", e);
+        }
+      }
+    }
+  }
+
+  private String getSummary(String s) {
+    if (s.length() > 80) {
+      return s.substring(0, 80).trim() + "...";
+    }
+    return s;
+  }
+
+}

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/DdlWrite.java

@@ -10,14 +10,24 @@ import com.avaje.ebean.dbmigration.model.ModelContainer;
  */
 public class DdlWrite {
 
+  public enum Mode {
+    APPLY,
+    ROLLBACK,
+    DROP
+  }
+
   private final ModelContainer currentModel;
 
+  private final DdlBuffer applyDropDependencies;
+
   private final DdlBuffer apply;
 
   private final DdlBuffer applyForeignKeys;
 
   private final DdlBuffer applyHistory;
 
+  private final DdlBuffer rollbackDropDependencies;
+
   private final DdlBuffer rollbackForeignKeys;
 
   private final DdlBuffer rollback;
@@ -39,6 +49,11 @@ public class DdlWrite {
    */
   private final DdlBuffer dropHistory;
 
+  /**
+   * Buffer used to drop dependencies early in the 'drop script'.
+   */
+  private final DdlBuffer dropDropDependencies;
+
   /**
    * Create without any configuration or current model (no history support).
    */
@@ -51,13 +66,16 @@ public class DdlWrite {
    */
   public DdlWrite(MConfiguration configuration, ModelContainer currentModel) {
     this.currentModel = currentModel;
+    this.applyDropDependencies = new BaseDdlBuffer(configuration);
     this.apply = new BaseDdlBuffer(configuration);
     this.applyForeignKeys = new BaseDdlBuffer(configuration);
     this.applyHistory = new BaseDdlBuffer(configuration);
+    this.rollbackDropDependencies = new BaseDdlBuffer(configuration);
     this.rollbackForeignKeys = new BaseDdlBuffer(configuration);
     this.rollback = new BaseDdlBuffer(configuration);
     this.drop = new BaseDdlBuffer(configuration);
     this.dropHistory = new BaseDdlBuffer(configuration);
+    this.dropDropDependencies = new BaseDdlBuffer(configuration);
   }
 
   /**
@@ -77,7 +95,8 @@ public class DdlWrite {
   public boolean isApplyEmpty() {
     return apply.getBuffer().isEmpty()
         && applyForeignKeys.getBuffer().isEmpty()
-        && applyHistory.getBuffer().isEmpty();
+        && applyHistory.getBuffer().isEmpty()
+        && applyDropDependencies.getBuffer().isEmpty();
   }
 
   /**
@@ -85,9 +104,51 @@ public class DdlWrite {
    */
   public boolean isApplyRollbackEmpty() {
     return rollback.getBuffer().isEmpty()
-        && rollbackForeignKeys.getBuffer().isEmpty();
+        && rollbackForeignKeys.getBuffer().isEmpty()
+        && rollbackDropDependencies.getBuffer().isEmpty();
   }
 
+  /**
+   * Return the apply or rollback buffer.
+   */
+  public DdlBuffer buffer(Mode mode) {
+    switch (mode) {
+      case APPLY: return apply();
+      case ROLLBACK: return rollback();
+      case DROP: return drop();
+      default:
+        throw new IllegalStateException("Invalid mode" + mode);
+    }
+  }
+
+  /**
+   * Return the apply or rollback buffer.
+   */
+  public DdlBuffer historyBuffer(Mode mode) {
+    switch (mode) {
+      case APPLY: return applyHistory();
+      case ROLLBACK: return rollback();
+      case DROP: return dropHistory();
+      default:
+        throw new IllegalStateException("Invalid mode" + mode);
+    }
+  }
+
+  /**
+   * Return the apply or rollback drop dependencies buffer.
+   */
+  public DdlBuffer dropDependencies(Mode mode) {
+
+    switch (mode) {
+      case APPLY: return applyDropDependencies();
+      case ROLLBACK: return rollbackDropDependencies();
+      case DROP: return dropDropDependencies();
+      default:
+        throw new IllegalStateException("Invalid mode" + mode);
+    }
+  }
+
+
   /**
    * Return true the drop buffers are empty.
    */
@@ -102,6 +163,13 @@ public class DdlWrite {
     return apply;
   }
 
+  /**
+   * Return the buffer that executes early to drop dependencies like views etc.
+   */
+  public DdlBuffer applyDropDependencies() {
+    return applyDropDependencies;
+  }
+
   /**
    * Return the buffer that APPLY DDL is written to for foreign keys and their associated indexes.
    * <p>
@@ -119,6 +187,13 @@ public class DdlWrite {
     return applyHistory;
   }
 
+  /**
+   * Return the buffer that rollback executes early to drop dependencies like views.
+   */
+  public DdlBuffer rollbackDropDependencies() {
+    return rollbackDropDependencies;
+  }
+
   /**
    * Return the buffer that ROLLBACK DDL is written to for foreign keys and associated indexes.
    */
@@ -156,5 +231,11 @@ public class DdlWrite {
     return dropHistory;
   }
 
+  /**
+   * Return the buffer that executes early for 'drop' script.
+   */
+  public DdlBuffer dropDropDependencies() {
+    return dropDropDependencies;
+  }
 
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/BaseTableDdl.java

@@ -21,6 +21,7 @@ import com.avaje.ebean.dbmigration.migration.DropTable;
 import com.avaje.ebean.dbmigration.migration.ForeignKey;
 import com.avaje.ebean.dbmigration.migration.UniqueConstraint;
 import com.avaje.ebean.dbmigration.model.MTable;
+import com.avaje.ebean.util.StringHelper;
 
 import java.io.IOException;
 import java.math.BigInteger;
@@ -123,7 +124,11 @@ public class BaseTableDdl implements TableDdl {
       writePrimaryKeyConstraint(apply, createTable.getPkName(), toColumnNames(pk));
     }
 
-    apply.newLine().append(")").endOfStatement();
+    apply.newLine().append(")");
+    addTableCommentInline(apply, createTable);
+    apply.endOfStatement();
+
+    addComments(apply, createTable);
 
     writeUniqueOneToOneConstraints(writer, createTable);
 
@@ -150,6 +155,37 @@ public class BaseTableDdl implements TableDdl {
 
   }
 
+  /**
+   * Add table and column comments (separate from the create table statement).
+   */
+  private void addComments(DdlBuffer apply, CreateTable createTable) throws IOException {
+    if (!platformDdl.isInlineComments()) {
+      String tableComment = createTable.getComment();
+      if (!StringHelper.isNull(tableComment)) {
+        platformDdl.addTableComment(apply, createTable.getName(), tableComment);
+      }
+
+      List<Column> columns = createTable.getColumn();
+      for (Column column : columns) {
+        if (!StringHelper.isNull(column.getComment())) {
+          platformDdl.addColumnComment(apply, createTable.getName(), column.getName(), column.getComment());
+        }
+      }
+    }
+  }
+
+  /**
+   * Add the table comment inline with the create table statement.
+   */
+  private void addTableCommentInline(DdlBuffer apply, CreateTable createTable) throws IOException {
+    if (platformDdl.isInlineComments()) {
+      String tableComment = createTable.getComment();
+      if (!StringHelper.isNull(tableComment)) {
+        platformDdl.inlineTableComment(apply, tableComment);
+      }
+    }
+  }
+
   private void writeTableColumns(DdlBuffer apply, List<Column> columns, boolean useIdentity) throws IOException {
     platformDdl.writeTableColumns(apply, columns, useIdentity);
   }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/DbTriggerBasedHistoryDdl.java

@@ -10,7 +10,6 @@ import com.avaje.ebean.dbmigration.model.MColumn;
 import com.avaje.ebean.dbmigration.model.MTable;
 
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
@@ -45,21 +44,71 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
     this.historySuffix = serverConfig.getHistoryTableSuffix();
     this.constraintNaming = serverConfig.getConstraintNaming();
 
-    this.sysPeriodStart = sysPeriod+"_start";
-    this.sysPeriodEnd = sysPeriod+"_end";
+    this.sysPeriodStart = sysPeriod + "_start";
+    this.sysPeriodEnd = sysPeriod + "_end";
   }
 
   @Override
-  public void regenerateHistoryTriggers(DdlWrite writer, HistoryTableUpdate update) throws IOException {
+  public void updateTriggers(DdlWrite writer, HistoryTableUpdate update) throws IOException {
 
     MTable table = writer.getTable(update.getBaseTable());
     if (table == null) {
-      throw new IllegalStateException("MTable "+update.getBaseTable()+" not found in writer? (required for history DDL)");
+      throw new IllegalStateException("MTable " + update.getBaseTable() + " not found in writer? (required for history DDL)");
     }
-    regenerateHistoryTriggers(writer, table, update);
+    updateTriggers(writer, table, update);
   }
 
-  protected abstract void regenerateHistoryTriggers(DdlWrite writer, MTable table, HistoryTableUpdate update) throws IOException;
+  /**
+   * Replace the existing triggers/stored procedures/views for history table support given the included columns.
+   */
+  protected abstract void updateHistoryTriggers(DbTriggerUpdate triggerUpdate) throws IOException;
+
+  /**
+   * Process the HistoryTableUpdate which can result in changes to the apply, rollback
+   * and drop scripts.
+   */
+  protected void updateTriggers(DdlWrite writer, MTable table, HistoryTableUpdate update) throws IOException {
+
+    DbTriggerUpdate triggerUpdate = createDbTriggerUpdate(writer, table);
+
+    if (update.hasApplyChanges()) {
+      // includes add, include and exclude column changes
+
+      String applyChangeDescription = update.descriptionForApply();
+      List<String> includedColumns = columnNamesForApply(table);
+
+      DdlBuffer apply = writer.applyHistory();
+      apply.append("-- changes: ").append(applyChangeDescription).newLine();
+
+      triggerUpdate.prepare(DdlWrite.Mode.APPLY, includedColumns);
+      updateHistoryTriggers(triggerUpdate);
+
+      // put a reverted version into the rollback buffer
+      update.toRevertedColumns(includedColumns);
+
+      DdlBuffer rollback = writer.rollback();
+      rollback.append("-- revert changes: ").append(applyChangeDescription).newLine();
+
+      triggerUpdate.prepare(DdlWrite.Mode.ROLLBACK, includedColumns);
+      updateHistoryTriggers(triggerUpdate);//writer, DdlWrite.Mode.ROLLBACK, baseTableName, historyTableName, includedColumns);
+    }
+
+    if (update.hasDropChanges()) {
+      // effectively applies the dropped columns changes to history triggers
+
+      DdlBuffer drop = writer.dropHistory();
+      drop.append("-- changes: ").append(update.descriptionForDrop()).newLine();
+
+      triggerUpdate.prepare(DdlWrite.Mode.DROP, columnNamesForDrop(table));
+      updateHistoryTriggers(triggerUpdate);//writer, DdlWrite.Mode.DROP, baseTableName, historyTableName, columnNamesForDrop(table));
+    }
+  }
+
+  protected DbTriggerUpdate createDbTriggerUpdate(DdlWrite writer, MTable table) {
+    String baseTableName = table.getName();
+    String historyTableName = historyTableName(baseTableName);
+    return new DbTriggerUpdate(baseTableName, historyTableName, writer);
+  }
 
   @Override
   public void dropHistoryTable(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException {
@@ -78,7 +127,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
     String baseTable = addHistoryTable.getBaseTable();
     MTable table = writer.getTable(baseTable);
     if (table == null) {
-      throw new IllegalStateException("MTable "+baseTable+" not found in writer? (required for history DDL)");
+      throw new IllegalStateException("MTable " + baseTable + " not found in writer? (required for history DDL)");
     }
 
     createWithHistory(writer, table);
@@ -95,7 +144,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
     dropHistoryTableEtc(writer.rollback(), baseTable);
 
     addHistoryTable(writer, table, whenCreatedColumn);
-    addStoredFunction(writer, table, null);
+    createStoredFunction(writer, table);
     createTriggers(writer, table);
   }
 
@@ -103,7 +152,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
 
   protected abstract void dropTriggers(DdlBuffer buffer, String baseTable) throws IOException;
 
-  protected void addStoredFunction(DdlWrite writer, MTable table, HistoryTableUpdate update) throws IOException {
+  protected void createStoredFunction(DdlWrite writer, MTable table) throws IOException {
     // do nothing
   }
 
@@ -158,10 +207,12 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
 
     apply.append("create table ").append(table.getName()).append(historySuffix).append("(").newLine();
 
-    Collection<MColumn> cols = table.getColumns().values();
+    Collection<MColumn> cols = table.allColumns();
     for (MColumn column : cols) {
-      writeColumnDefinition(apply, column.getName(), column.getType());
-      apply.append(",").newLine();
+      if (!column.isDraftOnly()) {
+        writeColumnDefinition(apply, column.getName(), column.getType());
+        apply.append(",").newLine();
+      }
     }
     writeColumnDefinition(apply, sysPeriodStart, sysPeriodType);
     apply.append(",").newLine();
@@ -189,6 +240,26 @@ 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();
+  }
+
+  protected void appendSysPeriodColumns(DdlBuffer apply, String prefix) throws IOException {
+    appendColumnName(apply, prefix, sysPeriodStart);
+    appendColumnName(apply, prefix, sysPeriodEnd);
+  }
+
   protected void dropHistoryTableEtc(DdlBuffer buffer, String baseTableName) throws IOException {
 
     buffer.append("drop view ").append(baseTableName).append(viewSuffix).endOfStatement();
@@ -201,8 +272,6 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
     buffer.append("alter table ").append(baseTableName).append(" drop column ").append(sysPeriodEnd).endOfStatement();
   }
 
-  //protected abstract void addFunction(DdlBuffer apply, String procedureName, String historyTable, List<String> includedColumns) throws IOException;
-
   protected void appendInsertIntoHistory(DdlBuffer buffer, String historyTable, List<String> columns) throws IOException {
 
     buffer.append("    insert into ").append(historyTable).append(" (").append(sysPeriodStart).append(",").append(sysPeriodEnd).append(",");
@@ -214,7 +283,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
 
   protected void appendColumnNames(DdlBuffer buffer, List<String> columns, String columnPrefix) throws IOException {
 
-    for (int i=0; i< columns.size(); i++) {
+    for (int i = 0; i < columns.size(); i++) {
       if (i > 0) {
         buffer.append(", ");
       }
@@ -224,18 +293,33 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
   }
 
   /**
-   * Return the list of included columns in order.
+   * Append a single column to the buffer if it is not null.
    */
-  protected List<String> includedColumnNames(MTable table) throws IOException {
+  protected void appendColumnName(DdlBuffer buffer, String prefix, String columnName) throws IOException {
 
-    Collection<MColumn> columns = table.getColumns().values();
-    List<String> includedColumns = new ArrayList<String>(columns.size());
-
-    for (MColumn column : columns) {
-      if (!column.isHistoryExclude()) {
-        includedColumns.add(column.getName());
-      }
+    if (columnName != null) {
+      buffer.append(prefix).append(columnName);
     }
-    return includedColumns;
+  }
+
+  /**
+   * Return the column names included in history for the apply script.
+   * <p>
+   * Note that dropped columns are actually still included at this point as they are going
+   * to be removed from the history handling when the drop script runs that also deletes
+   * the column.
+   * </p>
+   */
+  protected List<String> columnNamesForApply(MTable table) throws IOException {
+
+    return table.allHistoryColumns(true);
+  }
+
+  /**
+   * Return the column names included in history for the drop script.
+   */
+  protected List<String> columnNamesForDrop(MTable table) throws IOException {
+
+    return table.allHistoryColumns(false);
   }
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/DbTriggerUpdate.java

@@ -0,0 +1,72 @@
+package com.avaje.ebean.dbmigration.ddlgeneration.platform;
+
+import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
+import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
+
+import java.util.List;
+
+/**
+ * DB trigger update when a change occurs on a table with history.
+ */
+public class DbTriggerUpdate {
+
+  private final String baseTableName;
+
+  private final String historyTableName;
+
+  private final DdlWrite writer;
+
+  private DdlWrite.Mode mode;
+
+  private List<String> includedColumns;
+
+  public DbTriggerUpdate(String baseTableName, String historyTableName, DdlWrite writer) {
+    this.baseTableName = baseTableName;
+    this.historyTableName = historyTableName;
+    this.writer = writer;
+  }
+
+  /**
+   * Prepare for use given the mode and columns included in history.
+   */
+  public void prepare(DdlWrite.Mode mode, List<String> includedColumns) {
+    this.mode = mode;
+    this.includedColumns = includedColumns;
+  }
+
+  /**
+   * Return the appropriate buffer for the current mode.
+   */
+  public DdlBuffer historyBuffer() {
+    return writer.historyBuffer(mode);
+  }
+
+  /**
+   * Return the appropriate drop dependency buffer for the current mode.
+   */
+  public DdlBuffer dropDependencyBuffer() {
+    return writer.dropDependencies(mode);
+  }
+
+  /**
+   * Return the base table name.
+   */
+  public String getBaseTable() {
+    return baseTableName;
+  }
+
+  /**
+   * Return the history table name.
+   */
+  public String getHistoryTable() {
+    return historyTableName;
+  }
+
+  /**
+   * Return the included columns.
+   */
+  public List<String> getColumns() {
+    return includedColumns;
+  }
+
+}

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/H2HistoryDdl.java

@@ -6,7 +6,6 @@ import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
 import com.avaje.ebean.dbmigration.model.MTable;
 
 import java.io.IOException;
-import java.util.List;
 
 /**
  * H2 history support using DB triggers to maintain a history table.
@@ -28,40 +27,20 @@ public class H2HistoryDdl extends DbTriggerBasedHistoryDdl {
   protected void createTriggers(DdlWrite writer, MTable table) throws IOException {
 
     String baseTableName = table.getName();
-    String historyTableName = historyTableName(baseTableName);
-    List<String> includedColumns = includedColumnNames(table);
-
     DdlBuffer apply = writer.applyHistory();
 
-    addCreateTrigger(apply, updateTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
+    addCreateTrigger(apply, updateTriggerName(baseTableName), baseTableName);
   }
 
   @Override
-  protected void regenerateHistoryTriggers(DdlWrite writer, MTable table, HistoryTableUpdate update) throws IOException {
+  protected void updateHistoryTriggers(DbTriggerUpdate update) throws IOException {
 
-    String baseTableName = table.getName();
-    String historyTableName = historyTableName(baseTableName);
-    List<String> includedColumns = includedColumnNames(table);
-
-    DdlBuffer apply = writer.applyHistory();
-
-    apply.append("-- Regenerated ").newLine();
-    apply.append("-- changes: ").append(update.description()).newLine();
-
-    dropTriggers(apply, baseTableName);
-    addCreateTrigger(apply, updateTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
-
-    // put a reverted version into the rollback buffer
-    update.toRevertedColumns(includedColumns);
-
-    DdlBuffer rollback = writer.rollback();
-    rollback.append("-- Revert regenerated ").newLine();
-    rollback.append("-- revert changes: ").append(update.description()).newLine();
-    dropTriggers(rollback, baseTableName);
-    addCreateTrigger(rollback, updateTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
+    DdlBuffer buffer = update.historyBuffer();
+    dropTriggers(buffer, update.getBaseTable());
+    addCreateTrigger(buffer, updateTriggerName(update.getBaseTable()), update.getBaseTable());
   }
 
-  private void addCreateTrigger(DdlBuffer apply, String triggerName, String baseTable, String historyTable, List<String> includedColumns) throws IOException {
+  private void addCreateTrigger(DdlBuffer apply, String triggerName, String baseTable) throws IOException {
 
     // Note that this does not take into account the historyTable name (excepts _history suffix) and
     // does not take into account excluded columns (all columns included in history)

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/HistoryTableUpdate.java

@@ -21,10 +21,12 @@ public class HistoryTableUpdate {
     EXCLUDE
   }
 
-  public static class Column {
+  private static class Column {
+
+    final Change change;
+
+    final String column;
 
-    public final Change change;
-    public final String column;
     public Column(Change change, String column) {
       this.change = change;
       this.column = column;
@@ -34,18 +36,23 @@ public class HistoryTableUpdate {
       return change.name().toLowerCase()+" "+column;
     }
 
-    public void apply(List<String> includedColumns) {
+    private boolean isChangeFor(boolean apply) {
+      return apply ? change != Change.DROP : change == Change.DROP;
+    }
+
+    private void revert(List<String> includedColumns) {
       switch (change) {
         case ADD:
         case INCLUDE: {
           includedColumns.remove(column);
           break;
         }
-        case DROP:
         case EXCLUDE: {
           includedColumns.add(column);
           break;
         }
+        case DROP:
+          break;
         default:
           throw new IllegalStateException("Unexpected change "+change);
       }
@@ -63,29 +70,73 @@ public class HistoryTableUpdate {
     this.baseTable = baseTable;
   }
 
+  private boolean isChangeFor(boolean apply) {
+    for (Column columnChange : columnChanges) {
+      if (columnChange.isChangeFor(apply)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Return true if the change includes apply changes (ADD, INCLUDE, EXCLUDE).
+   */
+  public boolean hasApplyChanges() {
+    return isChangeFor(true);
+  }
+
+  /**
+   * Return true if the change includes DROP column.
+   */
+  public boolean hasDropChanges() {
+    return isChangeFor(false);
+  }
+
   /**
    * Return a description of the changes that cause the history trigger/function
-   * to be regenerated (added, dropped, included or excluded columns).
+   * to be regenerated (added, included or excluded columns).
    */
-  public String description() {
+  public String descriptionForApply() {
+    return descriptionFor(true);
+  }
+
+  /**
+   * Return a description of the changes that cause the history trigger/function
+   * to be regenerated in the drop script (dropped columns only).
+   */
+  public String descriptionForDrop() {
+    return descriptionFor(false);
+  }
+
+  private String descriptionFor(boolean apply) {
+
     StringBuilder sb = new StringBuilder(90);
-    for (int i = 0; i < columnChanges.size(); i++) {
-      if (i > 0) {
-        sb.append(", ");
+    boolean first = true;
+    for (Column column : columnChanges) {
+      if (column.isChangeFor(apply)) {
+        if (first) {
+          first = false;
+        } else {
+          sb.append(", ");
+        }
+        sb.append(column.description());
       }
-      sb.append(columnChanges.get(i).description());
     }
     return sb.toString();
   }
 
+  /**
+   * Reverse the apply changes which equates to removing any newly added or
+   * included columns.
+   */
   public void toRevertedColumns(List<String> includedColumns) {
 
     for (Column columnChange : columnChanges) {
-      columnChange.apply(includedColumns);
+      columnChange.revert(includedColumns);
     }
   }
 
-
   /**
    * Add a comment for column added, dropped, included or excluded.
    */
@@ -100,10 +151,4 @@ public class HistoryTableUpdate {
     return baseTable;
   }
 
-  /**
-   * Return the comments.
-   */
-  public List<Column> getColumnChanges() {
-    return columnChanges;
-  }
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/MsSqlServerDdl.java

@@ -2,8 +2,11 @@ package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
 import com.avaje.ebean.config.dbplatform.DbIdentity;
 import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
 import com.avaje.ebean.dbmigration.migration.AlterColumn;
 
+import java.io.IOException;
+
 /**
  * MS SQL Server platform specific DDL.
  */
@@ -15,6 +18,7 @@ public class MsSqlServerDdl extends PlatformDdl {
     this.foreignKeyRestrict = "";
     this.inlineUniqueOneToOne = false;
     this.columnSetDefault = "add default";
+    this.dropConstraintIfExists = "drop constraint";
   }
 
   @Override
@@ -83,4 +87,20 @@ public class MsSqlServerDdl extends PlatformDdl {
     // can't alter itself - done in alterColumnBaseAttributes()
     return null;
   }
+
+  /**
+   * Add table comment as a separate statement (from the create table statement).
+   */
+  public void addTableComment(DdlBuffer apply, String tableName, String tableComment) throws IOException {
+
+    // do nothing for MS SQL Server (cause it requires stored procedures etc)
+  }
+
+  /**
+   * Add column comment as a separate statement.
+   */
+  public void addColumnComment(DdlBuffer apply, String table, String column, String comment) throws IOException {
+
+    // do nothing for MS SQL Server (cause it requires stored procedures etc)
+  }
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/MySqlDdl.java

@@ -2,7 +2,12 @@ package com.avaje.ebean.dbmigration.ddlgeneration.platform;
 
 import com.avaje.ebean.config.dbplatform.DbIdentity;
 import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
 import com.avaje.ebean.dbmigration.migration.AlterColumn;
+import com.avaje.ebean.dbmigration.migration.Column;
+import com.avaje.ebeaninternal.server.lib.util.StringHelper;
+
+import java.io.IOException;
 
 /**
  * MySql specific DDL.
@@ -14,6 +19,7 @@ public class MySqlDdl extends PlatformDdl {
     this.alterColumn =  "modify";
     this.dropUniqueConstraint = "drop index";
     this.historyDdl = new MySqlHistoryDdl();
+    this.inlineComments = true;
   }
 
   /**
@@ -64,4 +70,26 @@ public class MySqlDdl extends PlatformDdl {
     // use modify
     return "alter table " + tableName + " modify " + columnName + " " + type + notnullClause;
   }
+
+  @Override
+  protected void writeColumnDefinition(DdlBuffer buffer, Column column, boolean useIdentity) throws IOException {
+    super.writeColumnDefinition(buffer, column, useIdentity);
+    String comment = column.getComment();
+    if (!StringHelper.isNull(comment)) {
+      // in mysql 5.5 column comment save in information_schema.COLUMNS.COLUMN_COMMENT(VARCHAR 1024)
+      if (comment.length() > 500) {
+        comment = comment.substring(0, 500);
+      }
+      buffer.append(String.format(" comment '%s'", comment));
+    }
+
+  }
+
+  public void inlineTableComment(DdlBuffer apply, String tableComment) throws IOException {
+    if (tableComment.length() > 1000) {
+      tableComment = tableComment.substring(0, 1000);
+    }
+    apply.append(" comment='").append(tableComment).append("'");
+  }
+
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/MySqlHistoryDdl.java

@@ -5,7 +5,6 @@ import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
 import com.avaje.ebean.dbmigration.model.MTable;
 
 import java.io.IOException;
-import java.util.List;
 
 /**
  * MySql history support using DB triggers to maintain a history table.
@@ -26,67 +25,48 @@ public class MySqlHistoryDdl extends DbTriggerBasedHistoryDdl {
   @Override
   protected void createTriggers(DdlWrite writer, MTable table) throws IOException {
 
-    String baseTableName = table.getName();
-    String historyTableName = historyTableName(baseTableName);
-    List<String> includedColumns = includedColumnNames(table);
+    DbTriggerUpdate update = createDbTriggerUpdate(writer, table);
 
-    DdlBuffer apply = writer.applyHistory();
+    update.prepare(DdlWrite.Mode.APPLY, columnNamesForApply(table));
 
-    addBeforeUpdate(apply, updateTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
-    addBeforeDelete(apply, deleteTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
+    addBeforeUpdate(updateTriggerName(update.getBaseTable()), update);
+    addBeforeDelete(deleteTriggerName(update.getBaseTable()), update);
   }
 
   @Override
-  protected void regenerateHistoryTriggers(DdlWrite writer, MTable table, HistoryTableUpdate update) throws IOException {
+  protected void updateHistoryTriggers(DbTriggerUpdate update) throws IOException {
 
-    String baseTableName = table.getName();
-    String historyTableName = historyTableName(baseTableName);
-    List<String> includedColumns = includedColumnNames(table);
+    DdlBuffer buffer = update.historyBuffer();
+    String baseTable = update.getBaseTable();
 
-    DdlBuffer apply = writer.applyHistory();
-
-    apply.append("-- Regenerated ").newLine();
-    apply.append("-- changes: ").append(update.description()).newLine();
-    // lock the base table while we drop and recreate the triggers
-    apply.append("lock tables ").append(baseTableName).append(" write").endOfStatement();
-    dropTriggers(apply, baseTableName);
-    addBeforeUpdate(apply, updateTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
-    addBeforeDelete(apply, deleteTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
-    apply.append("unlock tables").endOfStatement();
-
-    // put a reverted version into the rollback buffer
-    update.toRevertedColumns(includedColumns);
-
-    DdlBuffer rollback = writer.rollback();
-    rollback.append("-- Revert regenerated ").newLine();
-    rollback.append("-- revert changes: ").append(update.description()).newLine();
-    // lock the base table while we drop and recreate the triggers
-    rollback.append("lock tables ").append(baseTableName).append(" write").endOfStatement();
-    dropTriggers(rollback, baseTableName);
-    addBeforeUpdate(rollback, updateTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
-    addBeforeDelete(rollback, deleteTriggerName(baseTableName), baseTableName, historyTableName, includedColumns);
-    rollback.append("unlock tables").endOfStatement();
+    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(DdlBuffer apply, String triggerName, String baseTable, String historyTable, List<String> includedColumns) throws IOException {
+  private void addBeforeUpdate(String triggerName, DbTriggerUpdate update) throws IOException {
 
+    DdlBuffer apply = update.historyBuffer();
     apply
         .append("delimiter $$").newLine()
-        .append("create trigger ").append(triggerName).append(" before update on ").append(baseTable)
+        .append("create trigger ").append(triggerName).append(" before update on ").append(update.getBaseTable())
         .append(" for each row begin").newLine();
-    appendInsertIntoHistory(apply, historyTable, includedColumns);
+    appendInsertIntoHistory(apply, update.getHistoryTable(), update.getColumns());
     apply
         .append("    set NEW.").append(sysPeriod).append("_start = now(6)").endOfStatement()
         .append("end$$").newLine();
   }
 
-  private void addBeforeDelete(DdlBuffer apply, String triggerName, String baseTable, String historyTable, List<String> includedColumns) throws IOException {
+  private void addBeforeDelete(String triggerName, DbTriggerUpdate update) throws IOException {
 
+    DdlBuffer apply = update.historyBuffer();
     apply
         .append("delimiter $$").newLine()
-        .append("create trigger ").append(triggerName).append(" before delete on ").append(baseTable)
+        .append("create trigger ").append(triggerName).append(" before delete on ").append(update.getBaseTable())
         .append(" for each row begin").newLine();
-    appendInsertIntoHistory(apply, historyTable, includedColumns);
+    appendInsertIntoHistory(apply, update.getHistoryTable(), update.getColumns());
     apply.append("end$$").newLine();
   }
 

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/NoHistorySupportDdl.java

@@ -35,7 +35,7 @@ public class NoHistorySupportDdl implements PlatformHistoryDdl {
   }
 
   @Override
-  public void regenerateHistoryTriggers(DdlWrite write, HistoryTableUpdate update) {
+  public void updateTriggers(DdlWrite write, HistoryTableUpdate update) {
     // does nothing
   }
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/PlatformDdl.java

@@ -37,6 +37,11 @@ public class PlatformDdl {
    */
   private final DbIdentity dbIdentity;
 
+  /**
+   * Set to true if table and column comments are included inline with the create statements.
+   */
+  protected boolean inlineComments;
+
   /**
    * Default assumes if exists is supported.
    */
@@ -53,6 +58,8 @@ public class PlatformDdl {
 
   protected String identitySuffix = " auto_increment";
 
+  protected String alterTableIfExists = "";
+
   protected String dropConstraintIfExists = "drop constraint if exists";
 
   protected String dropIndexIfExists = "drop index if exists ";
@@ -114,6 +121,13 @@ public class PlatformDdl {
     return columnDefn + identitySuffix;
   }
 
+  /**
+   * Return true if the table and column comments are included inline.
+   */
+  public boolean isInlineComments() {
+    return inlineComments;
+  }
+
   /**
    * Write all the table columns converting to platform types as necessary.
    */
@@ -150,7 +164,7 @@ public class PlatformDdl {
    * Return the drop foreign key clause.
    */
   public String alterTableDropForeignKey(String tableName, String fkName) {
-    return "alter table " + tableName + " " + dropConstraintIfExists + " " + fkName;
+    return "alter table " + alterTableIfExists + tableName + " " + dropConstraintIfExists + " " + fkName;
   }
 
   /**
@@ -186,7 +200,7 @@ public class PlatformDdl {
    * Regenerate the history triggers (or function) due to a column being added/dropped/excluded or included.
    */
   public void regenerateHistoryTriggers(DdlWrite write, HistoryTableUpdate update) throws IOException {
-    historyDdl.regenerateHistoryTriggers(write, update);
+    historyDdl.updateTriggers(write, update);
   }
 
   /**
@@ -384,4 +398,27 @@ public class PlatformDdl {
   protected boolean isTrue(Boolean value) {
     return Boolean.TRUE.equals(value);
   }
+
+  /**
+   * Add an inline table comment to the create table statement.
+   */
+  public void inlineTableComment(DdlBuffer apply, String tableComment) throws IOException {
+    // do nothing by default (MySql only)
+  }
+
+  /**
+   * Add table comment as a separate statement (from the create table statement).
+   */
+  public void addTableComment(DdlBuffer apply, String tableName, String tableComment) throws IOException {
+
+    apply.append(String.format("comment on table %s is '%s'", tableName, tableComment)).endOfStatement();
+  }
+
+  /**
+   * Add column comment as a separate statement.
+   */
+  public void addColumnComment(DdlBuffer apply, String table, String column, String comment) throws IOException {
+
+    apply.append(String.format("comment on column %s.%s is '%s'", table, column, comment)).endOfStatement();
+  }
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/PlatformHistoryDdl.java

@@ -36,5 +36,5 @@ public interface PlatformHistoryDdl {
   /**
    * Regenerate the history triggers/stored function due to column added/dropped/included or excluded.
    */
-  void regenerateHistoryTriggers(DdlWrite write, HistoryTableUpdate baseTable) throws IOException;
+  void updateTriggers(DdlWrite write, HistoryTableUpdate baseTable) throws IOException;
 }

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/PostgresDdl.java

@@ -13,6 +13,7 @@ public class PostgresDdl extends PlatformDdl {
     this.historyDdl = new PostgresHistoryDdl();
     this.dropTableCascade = " cascade";
     this.columnSetType = "type ";
+    this.alterTableIfExists = "if exists ";
   }
 
   /**

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/PostgresHistoryDdl.java

@@ -14,7 +14,7 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
 
 
   public PostgresHistoryDdl() {
-    this.currentTimestamp = "current_timestamp";
+    this.currentTimestamp = "statement_timestamp()";
   }
 
   /**
@@ -45,6 +45,11 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
     }
   }
 
+  @Override
+  protected void appendSysPeriodColumns(DdlBuffer apply, String prefix) throws IOException {
+    appendColumnName(apply, prefix, sysPeriod);
+  }
+
   @Override
   protected void dropSysPeriodColumns(DdlBuffer buffer, String baseTableName) throws IOException {
     buffer.append("alter table ").append(baseTableName).append(" drop column ").append(sysPeriod).endOfStatement();
@@ -72,7 +77,7 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
     buffer.end();
   }
 
-  protected void addFunction(DdlBuffer apply, String procedureName, String historyTable, List<String> includedColumns) throws IOException {
+  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();
@@ -80,13 +85,13 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
         .append("  if (TG_OP = 'UPDATE') then").newLine();
     appendInsertIntoHistory(apply, historyTable, includedColumns);
     apply
-        .append("    NEW.").append(sysPeriod).append(" = tstzrange(CURRENT_TIMESTAMP,null);").newLine()
-        .append("    return new;").newLine().newLine();
+        .append("    NEW.").append(sysPeriod).append(" = tstzrange(").append(currentTimestamp).append(",null);").newLine()
+        .append("    return new;").newLine();
     apply
         .append("  elsif (TG_OP = 'DELETE') then").newLine();
     appendInsertIntoHistory(apply, historyTable, includedColumns);
     apply
-        .append("    return old;").newLine().newLine();
+        .append("    return old;").newLine();
     apply
         .append("  end if;").newLine()
         .append("end;").newLine()
@@ -96,40 +101,36 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
   }
 
   @Override
-  protected void regenerateHistoryTriggers(DdlWrite writer, MTable table, HistoryTableUpdate update) throws IOException {
-
-    // just replace the stored function with 'create or replace'
-    addStoredFunction(writer, table, update);
-  }
-
-  @Override
-  protected void addStoredFunction(DdlWrite writer, MTable table, HistoryTableUpdate update) throws IOException {
+  protected void createStoredFunction(DdlWrite writer, MTable table) throws IOException {
 
     String procedureName = procedureName(table.getName());
     String historyTable = historyTableName(table.getName());
 
-    List<String> includedColumns = includedColumnNames(table);
+    List<String> columnNames = columnNamesForApply(table);
+    createOrReplaceFunction(writer.applyHistory(), procedureName, historyTable, columnNames);
+  }
 
-    DdlBuffer apply = writer.applyHistory();
+  @Override
+  protected void updateHistoryTriggers(DbTriggerUpdate update) throws IOException {
 
-    if (update != null) {
-      apply.append("-- Regenerated ").append(procedureName).newLine();
-      apply.append("-- changes: ").append(update.description()).newLine();
-    }
+    String procedureName = procedureName(update.getBaseTable());
 
-    addFunction(apply, procedureName, historyTable, includedColumns);
+    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 {
 
-    if (update != null) {
-      // put a reverted version into the rollback buffer
-      update.toRevertedColumns(includedColumns);
+    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();
 
-      DdlBuffer rollback = writer.rollback();
-      rollback.append("-- Revert regenerated ").append(procedureName).newLine();
-      rollback.append("-- revert changes: ").append(update.description()).newLine();
-
-      addFunction(rollback, procedureName, historyTable, includedColumns);
-    }
+    // recreate the view with specific columns specified (the columns generally are not dropped until later)
+    createWithHistoryView(update);
   }
 
   @Override
@@ -137,7 +138,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("), current_timestamp), ");
+    buffer.append(") values (tstzrange(lower(OLD.").append(sysPeriod).append("), ").append(currentTimestamp).append("), ");
     appendColumnNames(buffer, columns, "OLD.");
     buffer.append(");").newLine();
   }

src/main/java/com/avaje/ebean/dbmigration/migration/CreateTable.java

@@ -30,6 +30,7 @@ import javax.xml.bind.annotation.XmlType;
  *       <attGroup ref="{http://ebean-orm.github.io/xml/ns/dbmigration}tablespaceAttributes"/>
  *       <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
  *       <attribute name="withHistory" type="{http://www.w3.org/2001/XMLSchema}boolean" />
+ *       <attribute name="draft" type="{http://www.w3.org/2001/XMLSchema}boolean" />
  *       <attribute name="identityType" type="{http://ebean-orm.github.io/xml/ns/dbmigration}identityType" />
  *       <attribute name="sequenceName" type="{http://www.w3.org/2001/XMLSchema}string" />
  *       <attribute name="sequenceInitial" type="{http://www.w3.org/2001/XMLSchema}positiveInteger" />
@@ -59,6 +60,8 @@ public class CreateTable {
     protected String name;
     @XmlAttribute(name = "withHistory")
     protected Boolean withHistory;
+    @XmlAttribute(name = "draft")
+    protected Boolean draft;
     @XmlAttribute(name = "identityType")
     protected IdentityType identityType;
     @XmlAttribute(name = "sequenceName")
@@ -213,6 +216,30 @@ public class CreateTable {
         this.withHistory = value;
     }
 
+    /**
+     * Gets the value of the draft property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link Boolean }
+     *     
+     */
+    public Boolean isDraft() {
+        return draft;
+    }
+
+    /**
+     * Sets the value of the draft property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Boolean }
+     *     
+     */
+    public void setDraft(Boolean value) {
+        this.draft = value;
+    }
+
     /**
      * Gets the value of the identityType property.
      * 

src/main/java/com/avaje/ebean/dbmigration/migrationreader/MigrationXmlReader.java

@@ -6,6 +6,9 @@ import com.avaje.ebean.dbmigration.migration.Migration;
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
 import java.io.InputStream;
 
 /**
@@ -15,19 +18,6 @@ public class MigrationXmlReader {
 
   private static final MigrationXmlReader INSTANCE = new MigrationXmlReader();
 
-  /**
-   * Read and return a Migration from an xml document at the given resource path.
-   */
-  public static Migration readMaybe(String resourcePath) {
-
-    InputStream is = MigrationXmlReader.class.getResourceAsStream(resourcePath);
-    if (is == null) {
-      return null;
-    }
-
-    return INSTANCE.read(is);
-  }
-
   /**
    * Read and return a Migration from an xml document at the given resource path.
    */
@@ -41,10 +31,27 @@ public class MigrationXmlReader {
     return INSTANCE.read(is);
   }
 
+  /**
+   * Read and return a Migration from a migration xml file.
+   */
+  public static Migration read(File migrationFile) {
+
+    try {
+      FileInputStream is = new FileInputStream(migrationFile);
+      try {
+        return read(is);
+      } finally {
+        is.close();
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   /**
    * Read and return a Migration from an xml document.
    */
-  public Migration read(InputStream is) {
+  public static Migration read(InputStream is) {
 
     try {
       JAXBContext jaxbContext = JAXBContext.newInstance(Migration.class);

src/main/java/com/avaje/ebean/dbmigration/migrationreader/MigrationXmlWriter.java

@@ -7,22 +7,46 @@ import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Marshaller;
 import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
 
 /**
  * Simple writer for output of the Migration/ChangeSet as an XML document.
  */
 public class MigrationXmlWriter {
 
+  private final String comment;
+
+  public MigrationXmlWriter(String comment) {
+    this.comment = comment;
+  }
+
   /**
    * Write a Migration to a file as an xml document to the file.
    */
   public void write(Migration migration, File file) {
 
     try {
+
+      FileWriter writer = new FileWriter(file);
+      writer.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
+      if (comment != null) {
+        writer.write("<!-- ");
+        writer.write(comment);
+        writer.write(" -->\n");
+      }
+
       JAXBContext jaxbContext = JAXBContext.newInstance(Migration.class);
       Marshaller marshaller = jaxbContext.createMarshaller();
-      marshaller.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
-      marshaller.marshal(migration, file);
+      marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+      marshaller.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.TRUE);
+
+      marshaller.marshal(migration, writer);
+
+      writer.close();
+
+    } catch (IOException e) {
+      throw new RuntimeException(e);
 
     } catch (JAXBException e) {
       throw new RuntimeException(e);

src/main/java/com/avaje/ebean/dbmigration/model/CurrentModel.java

@@ -77,6 +77,9 @@ public class CurrentModel {
       ModelBuildBeanVisitor visitor = new ModelBuildBeanVisitor(context);
       VisitAllUsing visit = new VisitAllUsing(visitor, server);
       visit.visitAllBeans();
+
+      // adjust the foreign keys on the 'draft' tables
+      context.adjustDraftReferences();
     }
     return model;
   }

src/main/java/com/avaje/ebean/dbmigration/model/MColumn.java

@@ -16,6 +16,7 @@ public class MColumn {
   private String references;
   private String foreignKeyName;
   private String foreignKeyIndex;
+  private String comment;
 
   private boolean historyExclude;
   private boolean notnull;
@@ -35,12 +36,15 @@ public class MColumn {
    */
   private AlterColumn alterColumn;
 
+  private boolean draftOnly;
+
   public MColumn(Column column) {
     this.name = column.getName();
     this.type = column.getType();
     this.checkConstraint = column.getCheckConstraint();
     this.checkConstraintName = column.getCheckConstraintName();
     this.defaultValue = column.getDefaultValue();
+    this.comment = column.getComment();
     this.references = column.getReferences();
     this.foreignKeyName = column.getForeignKeyName();
     this.foreignKeyIndex = column.getForeignKeyIndex();
@@ -63,6 +67,29 @@ public class MColumn {
     this.notnull = notnull;
   }
 
+  /**
+   * Return a copy of this column used for creating the associated draft table.
+   */
+  public MColumn copyForDraft() {
+
+    MColumn copy = new MColumn(name, type);
+    copy.draftOnly = draftOnly;
+    copy.checkConstraint = checkConstraint;
+    copy.checkConstraintName = checkConstraintName;
+    copy.defaultValue = defaultValue;
+    copy.references = references;
+    copy.comment = comment;
+    copy.foreignKeyName = foreignKeyName;
+    copy.foreignKeyIndex = foreignKeyIndex;
+    copy.historyExclude = historyExclude;
+    copy.notnull = notnull;
+    copy.primaryKey = primaryKey;
+    copy.identity = identity;
+    copy.unique = unique;
+    copy.uniqueOneToOne = uniqueOneToOne;
+    return copy;
+  }
+
   public String getName() {
     return name;
   }
@@ -174,6 +201,41 @@ public class MColumn {
     return uniqueOneToOne;
   }
 
+  /**
+   * Return the column comment.
+   */
+  public String getComment() {
+    return comment;
+  }
+
+  /**
+   * Set the column comment.
+   */
+  public void setComment(String comment) {
+    this.comment = comment;
+  }
+
+  /**
+   * Set the draftOnly status for this column.
+   */
+  public void setDraftOnly(boolean draftOnly) {
+    this.draftOnly = draftOnly;
+  }
+
+  /**
+   * Return the draftOnly status for this column.
+   */
+  public boolean isDraftOnly() {
+    return draftOnly;
+  }
+
+  /**
+   * Return true if this column should be included in History DB triggers etc.
+   */
+  public boolean isIncludeInHistory() {
+    return !draftOnly && !historyExclude;
+  }
+
   public Column createColumn() {
 
     Column c = new Column();
@@ -191,6 +253,7 @@ public class MColumn {
     c.setForeignKeyName(foreignKeyName);
     c.setForeignKeyIndex(foreignKeyIndex);
     c.setDefaultValue(defaultValue);
+    c.setComment(comment);
     c.setUnique(unique);
     c.setUniqueOneToOne(uniqueOneToOne);
 
@@ -220,7 +283,6 @@ public class MColumn {
   /**
    * Compare the column meta data and return true if there is a change that means
    * the history table column needs
-
    */
   public void compare(ModelDiff modelDiff, MTable table, MColumn newColumn) {
 

src/main/java/com/avaje/ebean/dbmigration/model/MTable.java

@@ -10,13 +10,15 @@ import com.avaje.ebean.dbmigration.migration.DropHistoryTable;
 import com.avaje.ebean.dbmigration.migration.DropTable;
 import com.avaje.ebean.dbmigration.migration.IdentityType;
 import com.avaje.ebean.dbmigration.migration.UniqueConstraint;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -38,11 +40,24 @@ import java.util.Set;
  */
 public class MTable {
 
+  private static final Logger logger = LoggerFactory.getLogger(MTable.class);
+
   /**
    * Table name.
    */
   private final String name;
 
+  /**
+   * The associated draft table.
+   */
+  private MTable draftTable;
+
+  /**
+   * Marked true for draft tables. These need to have their FK references adjusted
+   * after all the draft tables have been identified.
+   */
+  private boolean draft;
+
   /**
    * Primary key name.
    */
@@ -107,6 +122,29 @@ public class MTable {
    */
   private AddColumn addColumn;
 
+  private List<DroppedColumn> droppedColumns = new ArrayList<DroppedColumn>();
+
+  /**
+   * Create a copy of this table structure as a 'draft' table.
+   *
+   * Note that both tables contain @DraftOnly MColumns and these are filtered out
+   * later when creating the CreateTable object.
+   */
+  public MTable createDraftTable() {
+
+    draftTable = new MTable(name+"_draft");
+    draftTable.draft = true;
+    draftTable.whenCreatedColumn = whenCreatedColumn;
+    // compoundKeys
+    // compoundUniqueConstraints
+    draftTable.identityType = identityType;
+
+    for (MColumn col: allColumns()) {
+      draftTable.addColumn(col.copyForDraft());
+    }
+
+    return draftTable;
+  }
 
   /**
    * Construct for migration.
@@ -118,6 +156,7 @@ public class MTable {
     this.tablespace = createTable.getTablespace();
     this.indexTablespace = createTable.getIndexTablespace();
     this.withHistory = Boolean.TRUE.equals(createTable.isWithHistory());
+    this.draft = Boolean.TRUE.equals(createTable.isDraft());
     this.sequenceName = createTable.getSequenceName();
     this.sequenceInitial = toInt(createTable.getSequenceInitial());
     this.sequenceAllocate = toInt(createTable.getSequenceAllocate());
@@ -162,9 +201,15 @@ public class MTable {
     if (withHistory) {
       createTable.setWithHistory(Boolean.TRUE);
     }
+    if (draft) {
+      createTable.setDraft(Boolean.TRUE);
+    }
 
-    for (MColumn column : this.columns.values()) {
-      createTable.getColumn().add(column.createColumn());
+    for (MColumn column : allColumns()) {
+      // filter out draftOnly columns from the base table
+      if (draft || !column.isDraftOnly()) {
+        createTable.getColumn().add(column.createColumn());
+      }
     }
 
     for (MCompoundForeignKey compoundKey : compoundKeys) {
@@ -209,26 +254,33 @@ public class MTable {
 
     addColumn = null;
 
-    Set<String> mappedColumns = new LinkedHashSet<String>();
+    Map<String, MColumn> newColumnMap = newTable.getColumns();
 
-    Collection<MColumn> newColumns = newTable.getColumns().values();
-    for (MColumn newColumn : newColumns) {
-      MColumn localColumn = columns.get(newColumn.getName());
+    // compare newColumns to existing columns (look for new and diff columns)
+    for (MColumn newColumn : newColumnMap.values()) {
+      MColumn localColumn = getColumn(newColumn.getName());
       if (localColumn == null) {
-        diffNewColumn(newColumn);
+        // can ignore if draftOnly column and non-draft table
+        if (!newColumn.isDraftOnly() || draft) {
+          diffNewColumn(newColumn);
+        }
       } else {
-        // note that if there are alter column changes in here then
-        // the table withHistory is taken into account
         localColumn.compare(modelDiff, this, newColumn);
-        mappedColumns.add(newColumn.getName());
       }
     }
 
-    Collection<MColumn> existingColumns = columns.values();
-    for (MColumn existingColumn : existingColumns) {
-      if (!mappedColumns.contains(existingColumn.getName())) {
-        diffDropColumn(modelDiff, existingColumn);
+    // compare existing columns (look for dropped columns)
+    int columnPosition = 0;
+    for (MColumn existingColumn : allColumns()) {
+      MColumn newColumn = newColumnMap.get(existingColumn.getName());
+      if (newColumn == null) {
+        diffDropColumn(modelDiff, existingColumn, columnPosition, newTable);
+      } else if (newColumn.isDraftOnly() && !draft) {
+        // effectively a drop column (draft only column on a non-draft table)
+        logger.trace("... drop column {} from table {} as now draftOnly", newColumn.getName(), name);
+        diffDropColumn(modelDiff, existingColumn, columnPosition, newTable);
       }
+      columnPosition++;
     }
 
     if (addColumn != null) {
@@ -252,7 +304,7 @@ public class MTable {
   public void apply(AlterColumn alterColumn) {
     checkTableName(alterColumn.getTableName());
     String columnName = alterColumn.getColumnName();
-    MColumn existingColumn = columns.get(columnName);
+    MColumn existingColumn = getColumn(columnName);
     if (existingColumn == null) {
       throw new IllegalStateException("Column [" + columnName + "] does not exist for AlterColumn change?");
     }
@@ -264,15 +316,21 @@ public class MTable {
    */
   public void apply(DropColumn dropColumn) {
     checkTableName(dropColumn.getTableName());
-    columns.remove(dropColumn.getColumnName());
+    MColumn removed = columns.remove(dropColumn.getColumnName());
+    if (removed == null) {
+      throw new IllegalStateException("Column [" + dropColumn.getColumnName() + "] does not exist for DropColumn change on table [" + dropColumn.getTableName() + "]?");
+    }
   }
 
   public String getName() {
     return name;
   }
 
-  public String getPkName() {
-    return pkName;
+  /**
+   * Return true if this table is a 'Draft' table.
+   */
+  public boolean isDraft() {
+    return draft;
   }
 
   public void setPkName(String pkName) {
@@ -283,6 +341,10 @@ public class MTable {
     return comment;
   }
 
+  public void setComment(String comment) {
+    this.comment = comment;
+  }
+
   public String getTablespace() {
     return tablespace;
   }
@@ -299,7 +361,43 @@ public class MTable {
     this.withHistory = withHistory;
   }
 
-  public Map<String, MColumn> getColumns() {
+  public List<String> allHistoryColumns(boolean includeDropped) {
+
+    List<String> columnNames = new ArrayList<String>(columns.size());
+    for (MColumn column : columns.values()) {
+      if (column.isIncludeInHistory()) {
+        columnNames.add(column.getName());
+      }
+    }
+    if (includeDropped && !droppedColumns.isEmpty()) {
+      Collections.sort(droppedColumns);
+      for (DroppedColumn droppedColumn : droppedColumns) {
+        if (droppedColumn.columnPosition >= columnNames.size()) {
+          columnNames.add(droppedColumn.name);
+        } else {
+          columnNames.add(droppedColumn.columnPosition, droppedColumn.name);
+        }
+      }
+    }
+    return columnNames;
+  }
+
+  /**
+   * Return all the columns (excluding columns marked as dropped).
+   */
+  public Collection<MColumn> allColumns() {
+
+    return columns.values();
+  }
+
+  /**
+   * Return the column by name.
+   */
+  public MColumn getColumn(String name) {
+    return columns.get(name);
+  }
+
+  private Map<String, MColumn> getColumns() {
     return columns;
   }
 
@@ -311,26 +409,14 @@ public class MTable {
     return compoundKeys;
   }
 
-  public String getSequenceName() {
-    return sequenceName;
-  }
-
   public void setSequenceName(String sequenceName) {
     this.sequenceName = sequenceName;
   }
 
-  public int getSequenceInitial() {
-    return sequenceInitial;
-  }
-
   public void setSequenceInitial(int sequenceInitial) {
     this.sequenceInitial = sequenceInitial;
   }
 
-  public int getSequenceAllocate() {
-    return sequenceAllocate;
-  }
-
   public void setSequenceAllocate(int sequenceAllocate) {
     this.sequenceAllocate = sequenceAllocate;
   }
@@ -353,22 +439,12 @@ public class MTable {
     this.identityType = identityType;
   }
 
-  /**
-   * Returns the identity type to use for this table.
-   * <p>
-   * If set then this overrides the platform default so for UUID generated values
-   * or DB's supporting both sequences and autoincrement.
-   */
-  public IdentityType getIdentityType() {
-    return identityType;
-  }
-
   /**
    * Return the list of columns that make the primary key.
    */
   public List<MColumn> primaryKeyColumns() {
     List<MColumn> pk = new ArrayList<MColumn>(3);
-    for (MColumn column : columns.values()) {
+    for (MColumn column : allColumns()) {
       if (column.isPrimaryKey()) {
         pk.add(column);
       }
@@ -427,7 +503,7 @@ public class MTable {
    */
   public MColumn addColumn(String dbCol, String columnDefn, boolean notnull) {
 
-    MColumn existingColumn = columns.get(dbCol);
+    MColumn existingColumn = getColumn(dbCol);
     if (existingColumn != null) {
       if (notnull) {
         existingColumn.setNotnull(true);
@@ -461,20 +537,46 @@ public class MTable {
   /**
    * Add a 'drop column' to the diff.
    */
-  private void diffDropColumn(ModelDiff modelDiff, MColumn existingColumn) {
+  private void diffDropColumn(ModelDiff modelDiff, MColumn existingColumn, int columnPosition, MTable newTable) {
 
     DropColumn dropColumn = new DropColumn();
     dropColumn.setTableName(name);
     dropColumn.setColumnName(existingColumn.getName());
-    if (withHistory) {
+    if (withHistory && !existingColumn.isHistoryExclude()) {
       // These dropColumns should occur on the history
       // table as well as the base table
       dropColumn.setWithHistory(Boolean.TRUE);
+      newTable.registerDroppedColumn(existingColumn.getName(), columnPosition);
     }
 
     modelDiff.addDropColumn(dropColumn);
   }
 
+  /**
+   * Register a dropped column with it's previous column position.
+   * We need this for history triggers and views as we don't actually drop the
+   * column until the 'drop script' is run so the 'apply script' for history changes
+   * still needs to include the columns that are going to be dropped.
+   */
+  protected void registerDroppedColumn(String name, int columnPosition) {
+    droppedColumns.add(new DroppedColumn(name, columnPosition));
+  }
+
+  private static class DroppedColumn implements Comparable<DroppedColumn> {
+    final String name;
+    final int columnPosition;
+
+    DroppedColumn(String name, int columnPosition) {
+      this.name = name;
+      this.columnPosition = columnPosition;
+    }
+
+    @Override
+    public int compareTo(DroppedColumn o) {
+      return Integer.compare(o.columnPosition, columnPosition);
+    }
+  }
+
   private int toInt(BigInteger value) {
     return (value == null) ? 0 : value.intValue();
   }
@@ -511,4 +613,42 @@ public class MTable {
     }
     return false;
   }
+
+  /**
+   * Adjust the references (FK) if it should relate to a draft table.
+   */
+  public void adjustReferences(ModelContainer modelContainer) {
+
+    Collection<MColumn> cols = allColumns();
+    for (MColumn col : cols) {
+      String references = col.getReferences();
+      if (references != null) {
+        String baseTable = extractBaseTable(references);
+        MTable refBaseTable = modelContainer.getTable(baseTable);
+        if (refBaseTable.draftTable != null) {
+          // change references to another associated 'draft' table
+          String newReferences = deriveReferences(references, refBaseTable.draftTable.getName());
+          col.setReferences(newReferences);
+        }
+      }
+    }
+  }
+
+  /**
+   * Return the base table name from references (table.column).
+   */
+  private String extractBaseTable(String references) {
+    int lastDot = references.lastIndexOf('.');
+    return references.substring(0,lastDot);
+  }
+
+  /**
+   * Return the new references using the given draftTableName.
+   * (The referenced column is the same as before).
+   */
+  private String deriveReferences(String references, String draftTableName) {
+    int lastDot = references.lastIndexOf('.');
+    return draftTableName+"."+references.substring(lastDot+1);
+  }
+
 }

src/main/java/com/avaje/ebean/dbmigration/model/MigrationModel.java

@@ -1,12 +1,13 @@
 package com.avaje.ebean.dbmigration.model;
 
-import com.avaje.ebean.dbmigration.migration.Migration;
-import com.avaje.ebean.dbmigration.migrationreader.MigrationXmlReader;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.LinkedHashSet;
-import java.util.Set;
+import java.io.File;
+import java.io.FileFilter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Build the model from the series of migrations.
@@ -17,26 +18,15 @@ public class MigrationModel {
 
   private final ModelContainer model = new ModelContainer();
 
-  private final Set<String> readVersions = new LinkedHashSet<String>();
+  private final File modelDirectory;
 
-  private final String resourcePath;
+  private final String modelSuffix;
 
-  int nextMajorVersion;
+  private MigrationVersion lastVersion;
 
-  public MigrationModel(String resourcePath) {
-    this.resourcePath = normaliseResourcePath(resourcePath);
-  }
-
-  private String normaliseResourcePath(String resourcePath) {
-    if (resourcePath.endsWith("/")) {
-      // trim trailing slash
-      resourcePath = resourcePath.substring(0, resourcePath.length()-1);
-    }
-    if (resourcePath.startsWith("/")) {
-      // trim leading slash
-      resourcePath = resourcePath.substring(1);
-    }
-    return resourcePath;
+  public MigrationModel(File modelDirectory, String modelSuffix) {
+    this.modelDirectory = modelDirectory;
+    this.modelSuffix = modelSuffix;
   }
 
   /**
@@ -46,57 +36,41 @@ public class MigrationModel {
   public ModelContainer read() {
 
     readMigrations();
-    logger.info("read versions {}", readVersions);
     return model;
   }
 
-  /**
-   * Return the set of versions that were read.
-   */
-  public Set<String> getReadVersions() {
-    return readVersions;
-  }
-
-  public int getNextMajorVersion() {
-    return nextMajorVersion;
-  }
-
   private void readMigrations() {
 
-    for (int majorVersion = 1; majorVersion < 100; majorVersion++) {
-      if (!readMinorVersions(majorVersion)){
-        // no major.0 version so stopping
-        nextMajorVersion = majorVersion;
-        return;
+    // find all the migration xml files
+    File[] xmlFiles = modelDirectory.listFiles(new FileFilter() {
+      @Override
+      public boolean accept(File pathname) {
+        return pathname.getName().toLowerCase().endsWith(modelSuffix);
       }
+    });
+
+    List<MigrationResource> resources = new ArrayList<MigrationResource>();
+
+    for (File xmlFile: xmlFiles) {
+      resources.add(new MigrationResource(xmlFile));
+    }
+
+    // sort into version order before applying
+    Collections.sort(resources);
+
+    for (MigrationResource migrationResource: resources) {
+      logger.debug("read {}", migrationResource);
+      model.apply(migrationResource.read());
+    }
+
+    // remember the last version
+    if (!resources.isEmpty()) {
+      lastVersion = resources.get(resources.size() - 1).getVersion();
     }
   }
 
-  private boolean readMinorVersions(int majorVersion) {
+  public String getNextVersion(String initialVersion) {
 
-    for (int minorVersion = 0; minorVersion < 100; minorVersion++) {
-      if (!readMigration(majorVersion, minorVersion)) {
-        // continue reading next major if minorVersion 0 was read
-        return (minorVersion > 0);
-      }
-    }
-    return true;
+    return lastVersion == null ? initialVersion : lastVersion.nextVersion();
   }
-
-  private boolean readMigration(int majorVersion, int minorVersion) {
-
-    String version = majorVersion+"."+minorVersion;
-    String path = "/"+resourcePath+"/v"+version+".xml";
-
-    Migration migration = MigrationXmlReader.readMaybe(path);
-    if (migration == null) {
-      logger.debug("... no migration at path:{}", path);
-      return false;
-    }
-    readVersions.add(version);
-    logger.trace("... read migration v{}", version);
-    model.apply(migration);
-    return true;
-  }
-
 }

src/main/java/com/avaje/ebean/dbmigration/model/MigrationResource.java

@@ -0,0 +1,51 @@
+package com.avaje.ebean.dbmigration.model;
+
+import com.avaje.ebean.dbmigration.migration.Migration;
+import com.avaje.ebean.dbmigration.migrationreader.MigrationXmlReader;
+
+import java.io.File;
+
+/**
+ * Migration XML resource that holds the changes to be applied.
+ */
+public class MigrationResource implements Comparable<MigrationResource> {
+
+  private final File migrationFile;
+
+  private final MigrationVersion version;
+
+  /**
+   * Construct with a migration xml file.
+   */
+  public MigrationResource(File migrationFile) {
+    this.migrationFile = migrationFile;
+    this.version = MigrationVersion.parse(migrationFile.getName());
+  }
+
+  public String toString() {
+    return migrationFile.getName();
+  }
+
+  /**
+   * Return the version associated with this resource.
+   */
+  public MigrationVersion getVersion() {
+    return version;
+  }
+
+  /**
+   * Read and return the migration from the resource.
+   */
+  public Migration read() {
+
+    return MigrationXmlReader.read(migrationFile);
+  }
+
+  /**
+   * Compare by underlying version.
+   */
+  @Override
+  public int compareTo(MigrationResource other) {
+    return version.compareTo(other.version);
+  }
+}

src/main/java/com/avaje/ebean/dbmigration/model/MigrationVersion.java

@@ -0,0 +1,86 @@
+package com.avaje.ebean.dbmigration.model;
+
+/**
+ * The version of a migration used so that migrations are processed in order.
+ */
+public class MigrationVersion implements Comparable<MigrationVersion> {
+
+  /**
+   * The raw version text.
+   */
+  private final String raw;
+
+  /**
+   * The ordering parts.
+   */
+  private final int[] ordering;
+
+  private MigrationVersion(String raw, int[] ordering) {
+    this.raw = raw;
+    this.ordering = ordering;
+  }
+
+  public String toString() {
+    return raw;
+  }
+
+
+  public String nextVersion() {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < ordering.length; i++) {
+      if (i < ordering.length -1 ) {
+        sb.append(ordering[i]).append(".");
+      } else {
+        sb.append(ordering[i]+1);
+      }
+    }
+    return sb.toString();
+  }
+
+  @Override
+  public int compareTo(MigrationVersion other) {
+
+    int otherLength = other.ordering.length;
+    for (int i = 0; i < ordering.length; i++) {
+      if (i >= otherLength) {
+        // considered greater
+        return 1;
+      }
+      if (ordering[i] != other.ordering[i]) {
+        return (ordering[i] > other.ordering[i]) ? 1 : -1;
+      }
+    }
+    // considered the same
+    return 0;
+  }
+
+  /**
+   * Parse the raw version string into a MigrationVersion.
+   */
+  public static MigrationVersion parse(String raw) {
+
+    String value = raw.replace("__",".");
+    value = value.replace('_','.');
+
+    String[] sections = value.split("\\.");
+
+    int[] ordering = new int[sections.length];
+
+    int stopIndex = 0;
+    for (int i = 0; i < sections.length; i++) {
+      try {
+        ordering[i] = Integer.parseInt(sections[i]);
+        stopIndex++;
+      } catch (NumberFormatException e) {
+        // stop parsing
+        break;
+      }
+    }
+
+    int[] actualOrder = new int[stopIndex];
+    System.arraycopy(ordering, 0, actualOrder, 0, stopIndex);
+
+    return new MigrationVersion(raw, actualOrder);
+  }
+
+}

src/main/java/com/avaje/ebean/dbmigration/model/ModelContainer.java

@@ -12,6 +12,7 @@ import com.avaje.ebean.dbmigration.migration.DropIndex;
 import com.avaje.ebean.dbmigration.migration.DropTable;
 import com.avaje.ebean.dbmigration.migration.Migration;
 
+import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -38,6 +39,18 @@ public class ModelContainer {
 
   }
 
+  /**
+   * Adjust the FK references on all the draft tables.
+   */
+  public void adjustDraftReferences() {
+    Collection<MTable> tables = this.tables.values();
+    for (MTable table : tables) {
+      if (table.isDraft()) {
+        table.adjustReferences(this);
+      }
+    }
+  }
+
   /**
    * Return the map of all the tables.
    */

src/main/java/com/avaje/ebean/dbmigration/model/PlatformDdlWriter.java

@@ -1,7 +1,9 @@
 package com.avaje.ebean.dbmigration.model;
 
+import com.avaje.ebean.config.DbMigrationConfig;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
+import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
 import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
 import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
 import com.avaje.ebean.dbmigration.migration.ChangeSet;
@@ -24,20 +26,19 @@ public class PlatformDdlWriter {
 
   private final String platformPrefix;
 
-  public PlatformDdlWriter(DatabasePlatform platform, ServerConfig serverConfig) {
-    this(platform, serverConfig, "");
-  }
+  private final DbMigrationConfig config;
 
-  public PlatformDdlWriter(DatabasePlatform platform, ServerConfig serverConfig, String platformPrefix) {
+  public PlatformDdlWriter(DatabasePlatform platform, ServerConfig serverConfig, String platformPrefix, DbMigrationConfig config) {
     this.platform = platform;
     this.serverConfig = serverConfig;
     this.platformPrefix = platformPrefix;
+    this.config = config;
   }
 
   /**
    * Write the migration as platform specific ddl.
    */
-  public void processMigration(Migration dbMigration, DdlWrite write, File writePath, int nextMajorVersion) throws IOException {
+  public void processMigration(Migration dbMigration, DdlWrite write, File writePath, String fullVersion) throws IOException {
 
     DdlHandler handler = handler();
 
@@ -49,16 +50,16 @@ public class PlatformDdlWriter {
     }
     handler.generateExtra(write);
 
-    writePlatformDdl(write, writePath, nextMajorVersion);
+    writePlatformDdl(write, writePath, fullVersion);
   }
 
   /**
    * Write the ddl files.
    */
-  protected void writePlatformDdl(DdlWrite write, File resourcePath, int migrationVersion) throws IOException {
+  protected void writePlatformDdl(DdlWrite write, File resourcePath, String fullVersion) throws IOException {
 
     if (!write.isApplyEmpty()) {
-      FileWriter applyWriter = createWriter(resourcePath, migrationVersion, "apply.sql");
+      FileWriter applyWriter = createWriter(resourcePath, fullVersion, "", config.getApplySuffix());
       try {
         writeApplyDdl(applyWriter, write);
         applyWriter.flush();
@@ -66,8 +67,8 @@ public class PlatformDdlWriter {
         applyWriter.close();
       }
 
-      if (!write.isApplyRollbackEmpty()) {
-        FileWriter applyRollbackWriter = createWriter(resourcePath, migrationVersion, "applyRollback.sql");
+      if (!config.isSuppressRollback() && !write.isApplyRollbackEmpty()) {
+        FileWriter applyRollbackWriter = createWriter(resourcePath, fullVersion, config.getRollbackPath(), config.getRollbackSuffix());
         try {
           writeApplyRollbackDdl(applyRollbackWriter, write);
           applyRollbackWriter.flush();
@@ -78,7 +79,7 @@ public class PlatformDdlWriter {
     }
 
     if (!write.isDropEmpty()) {
-      FileWriter dropWriter = createWriter(resourcePath, migrationVersion, "drop.sql");
+      FileWriter dropWriter = createWriter(resourcePath, fullVersion, config.getDropPath(), config.getDropSuffix());
       try {
         writeDropDdl(dropWriter, write);
         dropWriter.flush();
@@ -88,18 +89,36 @@ public class PlatformDdlWriter {
     }
   }
 
-  protected FileWriter createWriter(File resourcePath, int migrationVersion, String suffix) throws IOException {
+  protected FileWriter createWriter(File path, String fullVersion, String subPath, String suffix) throws IOException {
 
-    File applyFile = new File(resourcePath, "v" + migrationVersion + ".0-" + platformPrefix + suffix);
+    String fileName = fullVersion;
+    if (!platformPrefix.isEmpty()) {
+      fileName += "-"+platformPrefix;
+    }
+    if (subPath != null && !subPath.isEmpty()) {
+      path = subPath(path, subPath);
+    }
+    fileName += suffix;
+    File applyFile = new File(path,  fileName);
     return new FileWriter(applyFile);
   }
 
+  protected File subPath(File path, String suffix) {
+    File subPath = new File(path, suffix);
+    if (!subPath.exists()) {
+      subPath.mkdirs();
+    }
+    return subPath;
+  }
+
   /**
    * Write the 'Apply' DDL buffers to the writer.
    */
   protected void writeApplyDdl(Writer writer, DdlWrite write) throws IOException {
 
     // merge the apply buffers in the appropriate order
+    prependDropDependencies(writer, write.applyDropDependencies());
+    writer.append("-- apply changes\n");
     writer.append(write.apply().getBuffer());
     writer.append(write.applyForeignKeys().getBuffer());
     writer.append(write.applyHistory().getBuffer());
@@ -111,6 +130,8 @@ public class PlatformDdlWriter {
   protected void writeApplyRollbackDdl(Writer writer, DdlWrite write) throws IOException {
 
     // merge the rollback buffers in the appropriate order
+    prependDropDependencies(writer, write.rollbackDropDependencies());
+    writer.append("-- reverse changes\n");
     writer.append(write.rollbackForeignKeys().getBuffer());
     writer.append(write.rollback().getBuffer());
   }
@@ -121,10 +142,19 @@ public class PlatformDdlWriter {
   protected void writeDropDdl(Writer writer, DdlWrite write) throws IOException {
 
     // merge the rollback buffers in the appropriate order
+    prependDropDependencies(writer, write.dropDropDependencies());
     writer.append(write.dropHistory().getBuffer());
     writer.append(write.drop().getBuffer());
   }
 
+  private void prependDropDependencies(Writer writer, DdlBuffer buffer) throws IOException {
+    if (!buffer.isEmpty()) {
+      writer.append("-- drop dependencies\n");
+      writer.append(buffer.getBuffer());
+      writer.append("\n");
+    }
+  }
+
   /**
    * Return the platform specific DdlHandler (to generate DDL).
    */

src/main/java/com/avaje/ebean/dbmigration/model/build/ModelBuildBeanVisitor.java

@@ -5,7 +5,6 @@ import com.avaje.ebean.config.dbplatform.IdType;
 import com.avaje.ebean.dbmigration.migration.IdentityType;
 import com.avaje.ebean.dbmigration.model.MColumn;
 import com.avaje.ebean.dbmigration.model.MTable;
-import com.avaje.ebean.dbmigration.model.visitor.BeanPropertyVisitor;
 import com.avaje.ebean.dbmigration.model.visitor.BeanVisitor;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
 import com.avaje.ebeaninternal.server.deploy.BeanProperty;
@@ -29,13 +28,14 @@ public class ModelBuildBeanVisitor implements BeanVisitor {
    * This creates an MTable and adds it to the model.
    * </p>
    */
-  public BeanPropertyVisitor visitBean(BeanDescriptor<?> descriptor) {
+  public ModelBuildPropertyVisitor visitBean(BeanDescriptor<?> descriptor) {
 
     if (!descriptor.isInheritanceRoot()) {
       return null;
     }
 
     MTable table = new MTable(descriptor.getBaseTable());
+    table.setComment(descriptor.getDbComment());
     if (descriptor.isHistorySupport()) {
       table.setWithHistory(true);
       BeanProperty whenCreated = descriptor.findWhenCreatedProperty();
@@ -58,7 +58,7 @@ public class ModelBuildBeanVisitor implements BeanVisitor {
       table.addColumn(new MColumn(discColumn, discDbType, true));
     }
 
-    return new ModelBuildPropertyVisitor(ctx, table, descriptor.getCompoundUniqueConstraints());
+    return new ModelBuildPropertyVisitor(ctx, table, descriptor);
   }
 
   /**

src/main/java/com/avaje/ebean/dbmigration/model/build/ModelBuildContext.java

@@ -3,11 +3,15 @@ package com.avaje.ebean.dbmigration.model.build;
 import com.avaje.ebean.config.DbConstraintNaming;
 import com.avaje.ebean.config.dbplatform.DbType;
 import com.avaje.ebean.config.dbplatform.DbTypeMap;
+import com.avaje.ebean.dbmigration.model.MColumn;
 import com.avaje.ebean.dbmigration.model.MTable;
 import com.avaje.ebean.dbmigration.model.ModelContainer;
 import com.avaje.ebeaninternal.server.deploy.BeanProperty;
 import com.avaje.ebeaninternal.server.type.ScalarType;
 
+import java.util.Collection;
+import java.util.List;
+
 /**
  * The context used during DDL generation.
  */
@@ -31,6 +35,18 @@ public class ModelBuildContext {
     this.maxLength = maxLength;
   }
 
+  /**
+   * Adjust the foreign key references on any draft tables (that reference other draft tables).
+   * This is called as a 'second pass' after all the draft tables have been identified.
+   */
+  public void adjustDraftReferences() {
+    model.adjustDraftReferences();
+  }
+
+  public String normaliseTable(String baseTable) {
+    return constraintNaming.normaliseTable(baseTable);
+  }
+
   public String primaryKeyName(String tableName) {
     return maxLength(constraintNaming.primaryKeyName(tableName), 0);
   }
@@ -120,4 +136,49 @@ public class ModelBuildContext {
     return dbTypeMap.get(dbType);
   }
 
+  /**
+   * Create the draft table for a given table.
+   */
+  public void createDraft(MTable table, boolean draftable) {
+
+    MTable draftTable = table.createDraftTable();
+    draftTable.setPkName(primaryKeyName(draftTable.getName()));
+
+    if (draftable) {
+      // Add a FK from @Draftable live table back to it's draft table)
+      List<MColumn> pkCols = table.primaryKeyColumns();
+      if (pkCols.size() == 1) {
+        // only doing this for single column PK at this stage
+        MColumn pk = pkCols.get(0);
+        pk.setReferences(draftTable.getName() + "." + pk.getName());
+        pk.setForeignKeyName(foreignKeyConstraintName(table.getName(), pk.getName(), 0));
+      }
+    }
+
+    int fkCount = 0;
+    int ixCount = 0;
+    int uqCount = 0;
+    Collection<MColumn> cols = draftTable.allColumns();
+    for (MColumn col: cols) {
+      if (col.getForeignKeyName() != null) {
+        // Note that we adjust the 'references' table later in a second pass
+        // after we know all the tables that are 'draftable'
+        //col.setReferences(refTable + "." + refColumn);
+        col.setForeignKeyName(foreignKeyConstraintName(draftTable.getName(), col.getName(), ++fkCount));
+
+        String[] indexCols = {col.getName()};
+        col.setForeignKeyIndex(foreignKeyIndexName(draftTable.getName(), indexCols, ++ixCount));
+      }
+      // adjust the unique constraint names
+      if (col.getUnique() != null){
+        col.setUnique(uniqueConstraintName(draftTable.getName(), col.getName(), ++uqCount));
+      }
+      if (col.getUniqueOneToOne() != null){
+        col.setUniqueOneToOne(uniqueConstraintName(draftTable.getName(), col.getName(), ++uqCount));
+      }
+    }
+
+    addTable(draftTable);
+  }
+
 }

src/main/java/com/avaje/ebean/dbmigration/model/build/ModelBuildIntersectionTable.java

@@ -42,6 +42,11 @@ public class ModelBuildIntersectionTable {
     }
 
     buildFkConstraints();
+
+    if (manyProp.getTargetDescriptor().isDraftable()) {
+      ctx.createDraft(intersectionTable, false);
+    }
+
 	}
 
 	private void buildFkConstraints() {
@@ -59,8 +64,7 @@ public class ModelBuildIntersectionTable {
 	private void buildFkConstraints(BeanDescriptor<?> desc, TableJoinColumn[] columns, boolean direction) {
 
     String tableName = intersectionTableJoin.getTable();
-    String baseTable = desc.getBaseTable();
-
+    String baseTable = ctx.normaliseTable(desc.getBaseTable());
     String fkName = ctx.foreignKeyConstraintName(tableName, baseTable, ++countForeignKey);
     String fkIndex = ctx.foreignKeyIndexName(tableName, baseTable, countForeignKey);
 

src/main/java/com/avaje/ebean/dbmigration/model/build/ModelBuildPropertyVisitor.java

@@ -5,6 +5,7 @@ import com.avaje.ebean.dbmigration.model.MColumn;
 import com.avaje.ebean.dbmigration.model.MCompoundForeignKey;
 import com.avaje.ebean.dbmigration.model.MTable;
 import com.avaje.ebean.dbmigration.model.visitor.BaseTablePropertyVisitor;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
 import com.avaje.ebeaninternal.server.deploy.BeanProperty;
 import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
 import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocOne;
@@ -14,6 +15,7 @@ import com.avaje.ebeaninternal.server.deploy.TableJoinColumn;
 import com.avaje.ebeaninternal.server.deploy.id.ImportedId;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -26,6 +28,8 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
 
   private final MTable table;
 
+  private final BeanDescriptor<?> beanDescriptor;
+
   private final IndexSet indexSet = new IndexSet();
 
   private MColumn lastColumn;
@@ -36,11 +40,11 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
   private int countCheck;
 
 
-  public ModelBuildPropertyVisitor(ModelBuildContext ctx, MTable table, CompoundUniqueConstraint[] constraints) {
+  public ModelBuildPropertyVisitor(ModelBuildContext ctx, MTable table, BeanDescriptor<?> beanDescriptor) {
     this.ctx = ctx;
     this.table = table;
-
-    addCompoundUniqueConstraint(constraints);
+    this.beanDescriptor = beanDescriptor;
+    addCompoundUniqueConstraint(beanDescriptor.getCompoundUniqueConstraints());
   }
 
   /**
@@ -80,7 +84,7 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
     table.setPkName(determinePrimaryKeyName());
 
     // check if indexes on foreign keys should be suppressed
-    for (MColumn column : table.getColumns().values()) {
+    for (MColumn column : table.allColumns()) {
       if (hasValue(column.getForeignKeyIndex())) {
         if (indexSet.contains(column.getName())) {
           // suppress index on foreign key as there is already
@@ -97,6 +101,19 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
         compoundKey.setIndexName(null);
       }
     }
+
+    addDraftTable();
+  }
+
+  /**
+   * Create a 'draft' table that is mostly the same as the base table.
+   * It has @DraftOnly columns and adjusted primary and foreign keys.
+   */
+  private void addDraftTable() {
+    if (beanDescriptor.isDraftable() || beanDescriptor.isDraftableElement()) {
+      // create a 'Draft' table which looks very similar (change PK, FK etc)
+      ctx.createDraft(table, !beanDescriptor.isDraftableElement());
+    }
   }
 
 
@@ -213,6 +230,8 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
     }
 
     MColumn col = new MColumn(p.getDbColumn(), ctx.getColumnDefn(p));
+    col.setComment(p.getDbComment());
+    col.setDraftOnly(p.isDraftOnly());
 
     if (p.isId()) {
       col.setPrimaryKey(true);

src/main/java/com/avaje/ebean/dbmigration/model/visitor/BeanVisitor.java

@@ -1,5 +1,6 @@
 package com.avaje.ebean.dbmigration.model.visitor;
 
+import com.avaje.ebean.dbmigration.model.build.ModelBuildPropertyVisitor;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
 
 /**
@@ -12,6 +13,6 @@ public interface BeanVisitor {
 	 * Visit a BeanDescriptor and return a PropertyVisitor to use to visit each
    * property on the entity bean (return null to skip visiting this bean).
 	 */
-  BeanPropertyVisitor visitBean(BeanDescriptor<?> descriptor);
+  ModelBuildPropertyVisitor visitBean(BeanDescriptor<?> descriptor);
 
 }

src/main/java/com/avaje/ebean/plugin/SpiBeanType.java

@@ -17,8 +17,13 @@ public interface SpiBeanType<T> {
   Class<T> getBeanType();
 
   /**
-   * Return the base table this bean type maps to.
+   * Return true if the property is a valid known property or path for the given bean type.
    */
+  boolean isValidExpression(String property);
+
+    /**
+     * Return the base table this bean type maps to.
+     */
   String getBaseTable();
 
   /**

src/main/java/com/avaje/ebean/util/ClassUtil.java

@@ -9,20 +9,6 @@ import java.util.Arrays;
  */
 public class ClassUtil {
 
-  /**
-   * Return a new instance of the class using the default constructor.
-   */
-  public static Object newInstance(String className) {
-    try {
-      Class<?> cls = Class.forName(className);
-      return cls.newInstance();
-    } catch (Exception e) {
-      String msg = "Error constructing " + className;
-      throw new IllegalArgumentException(msg, e);
-    }
-  }
-
-
   /**
    * Returns the raw type for the 2nd generic parameter for a subclass.
    */

src/main/java/com/avaje/ebeaninternal/api/ClassLoadContext.java

@@ -1,147 +0,0 @@
-package com.avaje.ebeaninternal.api;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Wraps the caller and context class loaders.
- * <p>
- * Helper for ClassUtil.
- * </p>
- * 
- * @author rbygrave
- * 
- */
-class ClassLoadContext {
-
-    private static final Logger logger = LoggerFactory.getLogger(ClassLoadContext.class);
-    
-    private final ClassLoader callerLoader;
-
-    private final ClassLoader contextLoader;
-
-    private final boolean preferContext;
-    
-    private boolean ambiguous;
-    
-    public static ClassLoadContext of(Class<?> caller, boolean preferContext) {
-        return new ClassLoadContext(caller, preferContext);
-    }
-
-    /**
-     * This constructor is package-private to restrict instantiation to
-     */
-    ClassLoadContext(final Class<?> caller, boolean preferContext) {
-        if (caller == null){
-            throw new IllegalArgumentException("caller is null");
-        }
-        this.callerLoader = caller.getClassLoader();
-        this.contextLoader = Thread.currentThread().getContextClassLoader();
-        this.preferContext = preferContext;
-    }
-
-    public Class<?> forName(String name) throws ClassNotFoundException {
-
-        ClassLoader defaultLoader = getDefault(preferContext);
-
-        try {
-            return Class.forName(name, true, defaultLoader);
-        } catch (ClassNotFoundException e) {
-            if (callerLoader == defaultLoader) {
-                throw e;
-            } else {
-                return Class.forName(name, true, callerLoader);
-            }
-        }
-    }
-
-    
-    /**
-     * Return the expected class loader to use.
-     * <p>
-     * Works on the assumption that the child of the caller or context class
-     * loader is preferred.
-     * </p>
-     */
-    public ClassLoader getDefault(boolean preferContext) {
-        
-        if (contextLoader == null){
-            if (logger.isDebugEnabled()){
-                logger.debug("No Context ClassLoader, using "+callerLoader.getClass().getName());
-            }
-            return callerLoader;
-        }
-        if (contextLoader == callerLoader){
-          if (logger.isDebugEnabled()){
-                logger.debug("Context and Caller ClassLoader's same instance of "+contextLoader.getClass().getName());
-            }
-            return callerLoader;
-        }
-        
-        if (isChild(contextLoader, callerLoader)) {
-          if (logger.isDebugEnabled()){
-                logger.debug("Caller ClassLoader "+callerLoader.getClass().getName()
-                        +" child of ContextLoader "+contextLoader.getClass().getName());
-            }
-            return callerLoader;
-            
-        } else if (isChild(callerLoader, contextLoader)) {
-          if (logger.isDebugEnabled()){
-                logger.debug("Context ClassLoader "+contextLoader.getClass().getName()
-                        +" child of Caller ClassLoader "+callerLoader.getClass().getName());
-            }
-            return contextLoader;
-            
-        } else {            
-            // ambiguous case, perhaps both null
-            logger.debug("Ambiguous ClassLoader choice preferContext:"+preferContext
-                    +" Context:"+contextLoader.getClass().getName()+" Caller:"+callerLoader.getClass().getName());
-            ambiguous = true;
-            return preferContext ? contextLoader : callerLoader;
-        }
-    }
-
-    /**
-     * Return true if the 'default' class loader is ambiguous.
-     */
-    public boolean isAmbiguous() {
-        return ambiguous;
-    }
-
-    /**
-     * Return the ClassLoader of the caller.
-     */
-    public ClassLoader getCallerLoader() {
-        return callerLoader;
-    }
-
-    /**
-     * Return the Thread Context ClassLoader.
-     */
-    public ClassLoader getContextLoader() {
-        return contextLoader;
-    }
-
-    /**
-     * Return the ClassLoader for this class.
-     */
-    public ClassLoader getThisLoader() {
-        return this.getClass().getClassLoader();
-    }
-
-    /**
-     * Returns 'true' if 'loader2' is a delegation child of 'loader1' [or if
-     * 'loader1'=='loader2'].
-     */
-    private boolean isChild(final ClassLoader loader1, ClassLoader loader2) {
-
-        for (; loader2 != null; loader2 = loader2.getParent()) {
-            if (loader2 == loader1) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-}

src/main/java/com/avaje/ebeaninternal/api/ClassUtil.java

@@ -1,111 +1,65 @@
 package com.avaje.ebeaninternal.api;
 
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 /**
  * Helper to find classes taking into account the context class loader.
  */
 public class ClassUtil {
 
-  private static final Logger logger = LoggerFactory.getLogger(ClassUtil.class);
-
-  /**
-   * Load a class taking into account a context class loader (if present).
-   */
-  public static Class<?> forName(String name) throws ClassNotFoundException {
-    return forName(name, null);
-  }
-
-  /**
-   * Load a class taking into account a context class loader (if present).
-   */
-  public static Class<?> forName(String name, Class<?> caller) throws ClassNotFoundException {
-
-    if (caller == null) {
-      caller = ClassUtil.class;
-    }
-    ClassLoadContext ctx = ClassLoadContext.of(caller, true);
-
-    return ctx.forName(name);
-  }
-
-
-  public static ClassLoader getClassLoader(Class<?> caller, boolean preferContext) {
-
-    if (caller == null) {
-      caller = ClassUtil.class;
-    }
-    ClassLoadContext ctx = ClassLoadContext.of(caller, preferContext);
-    ClassLoader classLoader = ctx.getDefault(preferContext);
-    if (ctx.isAmbiguous()) {
-      logger.info("Ambigous ClassLoader (Context vs Caller) chosen " + classLoader);
-    }
-    return classLoader;
-  }
-
-  /**
-   * Return true if javax validation annotations like Size and NotNull are present.
-   */
-  public static boolean isJavaxValidationAnnotationsPresent() {
-    return isPresent("javax.validation.constraints.NotNull", null);
-  }
-
-  /**
-   * Return true if Jackson annotations like JsonIgnore are present.
-   */
-  public static boolean isJacksonAnnotationsPresent() {
-    return isPresent("com.fasterxml.jackson.annotation.JsonIgnore", null);
-  }
-
-  /**
-   * Return true if Jackson ObjectMapper is present.
-   */
-  public static boolean isJacksonObjectMapperPresent() {
-    return isPresent("com.fasterxml.jackson.databind.ObjectMapper", null);
-  }
-
-
-  /**
-   * Return true if the given class is present.
-   */
-  public static boolean isPresent(String className) {
-    return isPresent(className, null);
-  }
-
-  /**
-   * Return true if the given class is present.
-   */
-  public static boolean isPresent(String className, Class<?> caller) {
-    try {
-      forName(className, caller);
-      return true;
-    } catch (Throwable ex) {
-      // Class or one of its dependencies is not present...
-      return false;
-    }
-  }
-
   /**
    * Return a new instance of the class using the default constructor.
    */
   public static Object newInstance(String className) {
-    return newInstance(className, null);
-  }
-
-  /**
-   * Return a new instance of the class using the default constructor.
-   */
-  public static Object newInstance(String className, Class<?> caller) {
 
     try {
-      Class<?> cls = forName(className, caller);
+      Class<?> cls = forName(className);
       return cls.newInstance();
     } catch (Exception e) {
       String msg = "Error constructing " + className;
       throw new IllegalArgumentException(msg, e);
     }
   }
+
+  /**
+   * Load a class taking into account a context class loader (if present).
+   */
+  public static Class<?> forName(String name) throws ClassNotFoundException {
+    return new ClassLoadContext().forName(name);
+  }
+
+
+  /**
+   * Helper to wrap the context and caller classLoaders (to use/try both).
+   */
+  static class ClassLoadContext {
+
+    private final ClassLoader contextLoader;
+
+    private final ClassLoader callerLoader;
+
+    ClassLoadContext() {
+      this.callerLoader = ClassUtil.class.getClassLoader();
+      this.contextLoader = contextLoader();
+    }
+
+    ClassLoader contextLoader() {
+      ClassLoader loader = Thread.currentThread().getContextClassLoader();
+      return (loader != null) ? loader: callerLoader;
+    }
+
+    public Class<?> forName(String name) throws ClassNotFoundException {
+
+      try {
+        return Class.forName(name, true, contextLoader);
+      } catch (ClassNotFoundException e) {
+        if (callerLoader == contextLoader) {
+          throw e;
+        } else {
+          return Class.forName(name, true, callerLoader);
+        }
+      }
+    }
+
+  }
 }
 

src/main/java/com/avaje/ebeaninternal/api/LoadBeanRequest.java

@@ -1,18 +1,27 @@
 package com.avaje.ebeaninternal.api;
 
-import java.util.List;
-
+import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.bean.EntityBeanIntercept;
 import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 /**
  * Request for loading ManyToOne and OneToOne relationships.
  */
 public class LoadBeanRequest extends LoadRequest {
 
+  private static final Logger logger = LoggerFactory.getLogger(LoadBeanRequest.class);
+
   private final List<EntityBeanIntercept> batch;
 
-  private final LoadBeanBuffer LoadBuffer;
+  private final LoadBeanBuffer loadBuffer;
 
   private final String lazyLoadProperty;
 
@@ -32,20 +41,28 @@ public class LoadBeanRequest extends LoadRequest {
     this(LoadBuffer, parentRequest, false, null, false);
   }
 
-  private LoadBeanRequest(LoadBeanBuffer LoadBuffer, OrmQueryRequest<?> parentRequest, boolean lazy, String lazyLoadProperty, boolean loadCache) {
+  private LoadBeanRequest(LoadBeanBuffer loadBuffer, OrmQueryRequest<?> parentRequest, boolean lazy,
+                          String lazyLoadProperty, boolean loadCache) {
+
     super(parentRequest, lazy);
-    this.LoadBuffer = LoadBuffer;
-    this.batch = LoadBuffer.getBatch();
+    this.loadBuffer = loadBuffer;
+    this.batch = loadBuffer.getBatch();
     this.lazyLoadProperty = lazyLoadProperty;
     this.loadCache = loadCache;
   }
 
+  @Override
+  public Class<?> getBeanType() {
+    return loadBuffer.getBeanDescriptor().getBeanType();
+  }
+
   public boolean isLoadCache() {
     return loadCache;
   }
 
+
   public String getDescription() {
-    return "path:" + LoadBuffer.getFullPath() + " batch:" + batch.size();
+    return "path:" + loadBuffer.getFullPath() + " batch:" + batch.size();
   }
 
   /**
@@ -59,7 +76,7 @@ public class LoadBeanRequest extends LoadRequest {
    * Return the load context.
    */
   public LoadBeanBuffer getLoadContext() {
-    return LoadBuffer;
+    return loadBuffer;
   }
 
   /**
@@ -72,4 +89,90 @@ public class LoadBeanRequest extends LoadRequest {
   public int getBatchSize() {
     return getLoadContext().getBatchSize();
   }
+
+  /**
+   * Return the list of Id values for the beans in the lazy load buffer.
+   */
+  public List<Object> getIdList(int batchSize) {
+
+    List<Object> idList = new ArrayList<Object>(batchSize);
+
+    BeanDescriptor<?> desc = loadBuffer.getBeanDescriptor();
+    for (int i = 0; i < batch.size(); i++) {
+      EntityBeanIntercept ebi = batch.get(i);
+      EntityBean bean = ebi.getOwner();
+      idList.add(desc.getId(bean));
+    }
+
+    if (!idList.isEmpty()) {
+      int extraIds = batchSize - batch.size();
+      if (extraIds > 0) {
+        // for performance make up the Id's to the batch size
+        // so we get the same query (for Ebean and the db)
+        Object firstId = idList.get(0);
+        for (int i = 0; i < extraIds; i++) {
+          // just add the first Id again
+          idList.add(firstId);
+        }
+      }
+    }
+
+    return idList;
+  }
+
+  /**
+   * Configure the query for lazy loading execution.
+   */
+  public void configureQuery(SpiQuery<?> query, List<Object> idList) {
+
+    query.setMode(SpiQuery.Mode.LAZYLOAD_BEAN);
+    query.setPersistenceContext(loadBuffer.getPersistenceContext());
+
+    String mode = isLazy() ? "+lazy" : "+query";
+    query.setLoadDescription(mode, getDescription());
+
+    if (isLazy()) {
+      // cascade the batch size (if set) for further lazy loading
+      query.setLazyLoadBatchSize(getBatchSize());
+    }
+
+    loadBuffer.configureQuery(query, lazyLoadProperty);
+
+    if (idList.size() == 1) {
+      query.where().idEq(idList.get(0));
+    } else {
+      query.where().idIn(idList);
+    }
+  }
+
+  /**
+   * Load the beans into the L2 cache if that is requested and check for load failures due to deletes.
+   */
+  public void postLoad(List<?> list) {
+
+    Set<Object> loadedIds = new HashSet<Object>();
+
+    BeanDescriptor<?> desc = loadBuffer.getBeanDescriptor();
+    // collect Ids and maybe load bean cache
+    for (int i = 0; i < list.size(); i++) {
+      EntityBean loadedBean = (EntityBean) list.get(i);
+      loadedIds.add(desc.getId(loadedBean));
+      if (isLoadCache()) {
+        desc.cacheBeanPutData(loadedBean);
+      }
+    }
+
+    if (lazyLoadProperty != null) {
+      for (int i = 0; i < batch.size(); i++) {
+        // check if the underlying row in DB was deleted. Mark the bean as 'failed' if
+        // necessary but allow processing to continue until it is accessed by client code
+        EntityBeanIntercept ebi = batch.get(i);
+        Object id = desc.getId(ebi.getOwner());
+        if (!loadedIds.contains(id)) {
+          logger.info("Lazy loading unsuccessful for type:" + desc.getName() + " id:" + id + " - expecting when bean has been deleted");
+          ebi.setLazyLoadFailure(id);
+        }
+      }
+    }
+  }
 }

src/main/java/com/avaje/ebeaninternal/api/LoadManyRequest.java

@@ -1,15 +1,25 @@
 package com.avaje.ebeaninternal.api;
 
-import java.util.List;
-
+import com.avaje.ebean.EbeanServer;
 import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebeaninternal.server.core.OrmQueryRequest;
+import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
+import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import com.avaje.ebeaninternal.server.lib.util.StringHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Request for loading Associated Many Beans.
  */
 public class LoadManyRequest extends LoadRequest {
 
+  private static final Logger logger = LoggerFactory.getLogger(LoadManyRequest.class);
+
   private final List<BeanCollection<?>> batch;
 
   private final LoadManyBuffer loadContext;
@@ -40,6 +50,11 @@ public class LoadManyRequest extends LoadRequest {
     this.loadCache = loadCache;
   }
 
+  @Override
+  public Class<?> getBeanType() {
+    return loadContext.getBeanDescriptor().getBeanType();
+  }
+
   public String getDescription() {
     return "path:" + loadContext.getFullPath() + " size:" + batch.size();
   }
@@ -83,4 +98,98 @@ public class LoadManyRequest extends LoadRequest {
   public int getBatchSize() {
     return loadContext.getBatchSize();
   }
+
+  private List<Object> getParentIdList(int batchSize) {
+
+    ArrayList<Object> idList = new ArrayList<Object>(batchSize);
+
+    BeanPropertyAssocMany<?> many = getMany();
+    for (int i = 0; i < batch.size(); i++) {
+      BeanCollection<?> bc = batch.get(i);
+      idList.add(many.getParentId(bc.getOwnerBean()));
+    }
+    int extraIds = batchSize - batch.size();
+    if (extraIds > 0) {
+      Object firstId = idList.get(0);
+      for (int i = 0; i < extraIds; i++) {
+        idList.add(firstId);
+      }
+    }
+
+    return idList;
+  }
+
+  private BeanPropertyAssocMany<?> getMany() {
+    return loadContext.getBeanProperty();
+  }
+
+  public SpiQuery<?> createQuery(EbeanServer server, int batchSize) {
+
+    BeanPropertyAssocMany<?> many = getMany();
+
+    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(many.getTargetType());
+    String orderBy = many.getLazyFetchOrderBy();
+    if (orderBy != null) {
+      query.orderBy(orderBy);
+    }
+
+    String extraWhere = many.getExtraWhere();
+    if (extraWhere != null) {
+      // replace special ${ta} placeholder with the base table alias
+      // which is always t0 and add the extra where clause
+      String ew = StringHelper.replaceString(extraWhere, "${ta}", "t0");
+      query.where().raw(ew);
+    }
+
+    query.setLazyLoadForParents(many);
+
+    List<Object> idList = getParentIdList(batchSize);
+    many.addWhereParentIdIn(query, idList);
+
+    query.setPersistenceContext(loadContext.getPersistenceContext());
+
+    String mode = isLazy() ? "+lazy" : "+query";
+    query.setLoadDescription(mode, getDescription());
+
+    if (isLazy()) {
+      // cascade the batch size (if set) for further lazy loading
+      query.setLazyLoadBatchSize(getBatchSize());
+    }
+
+    // potentially changes the joins and selected properties
+    loadContext.configureQuery(query);
+
+    if (isOnlyIds()) {
+      // override to just select the Id values
+      query.select(many.getTargetIdProperty());
+    }
+
+    return query;
+  }
+
+  /**
+   * After the query execution check for empty collections and load L2 cache if desired.
+   */
+  public void postLoad() {
+
+    BeanDescriptor<?> desc = loadContext.getBeanDescriptor();
+    BeanPropertyAssocMany<?> many = getMany();
+
+    // check for BeanCollection's that where never processed
+    // in the +query or +lazy load due to no rows (predicates)
+    for (int i = 0; i < batch.size(); i++) {
+      BeanCollection<?> bc = batch.get(i);
+      if (bc.checkEmptyLazyLoad()) {
+        if (logger.isDebugEnabled()) {
+          EntityBean ownerBean = bc.getOwnerBean();
+          Object parentId = desc.getId(ownerBean);
+          logger.debug("BeanCollection after lazy load was empty. type:" + ownerBean.getClass().getName() + " id:" + parentId + " owner:" + ownerBean);
+        }
+      } else if (isLoadCache()) {
+        Object parentId = desc.getId(bc.getOwnerBean());
+        desc.cacheManyPropPut(many, bc, parentId);
+      }
+    }
+
+  }
 }

src/main/java/com/avaje/ebeaninternal/api/LoadRequest.java

@@ -21,6 +21,11 @@ public abstract class LoadRequest {
 		this.lazy = lazy;
 	}
 
+  /**
+   * Return the associated bean type for this load request.
+   */
+  public abstract Class<?> getBeanType();
+
   /**
    * Log the just executed secondary query with the 'root' query if 'logSecondaryQuery' is set to
    * true. This is for testing purposes to confirm the secondary query executes etc.

src/main/java/com/avaje/ebeaninternal/api/ManyWhereJoins.java

@@ -1,153 +1,153 @@
 package com.avaje.ebeaninternal.api;
 
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.TreeMap;
-import java.util.TreeSet;
-
 import com.avaje.ebeaninternal.server.deploy.BeanProperty;
 import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
 import com.avaje.ebeaninternal.server.el.ElPropertyDeploy;
 import com.avaje.ebeaninternal.server.query.SplitName;
 import com.avaje.ebeaninternal.server.query.SqlJoinType;
 
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
 /**
  * Holds the joins needs to support the many where predicates.
  * These joins are independent of any 'fetch' joins on the many.
  */
 public class ManyWhereJoins implements Serializable {
 
-    private static final long serialVersionUID = -6490181101871795417L;
-    
-    private final TreeMap<String,PropertyJoin> joins = new TreeMap<String,PropertyJoin>();
+  private static final long serialVersionUID = -6490181101871795417L;
 
-    private StringBuilder formulaProperties = new StringBuilder();
-    
-    private boolean formulaWithJoin;
+  private final TreeMap<String, PropertyJoin> joins = new TreeMap<String, PropertyJoin>();
+
+  private StringBuilder formulaProperties = new StringBuilder();
+
+  private boolean formulaWithJoin;
 
   /**
    * 'Mode' indicating that joins added while this is true are required to be outer joins.
    */
-    private boolean requireOuterJoins;
-    
-    /**
-     * Return the current 'mode' indicating if outer joins are currently required or not.
-     */
-    public boolean isRequireOuterJoins() {
-      return requireOuterJoins;
-    }
+  private boolean requireOuterJoins;
 
-    /**
-     * Set the 'mode' to be that joins added are required to be outer joins.
-     * This is set during the evaluation of disjunction predicates.
-     */
-    public void setRequireOuterJoins(boolean requireOuterJoins) {
-      this.requireOuterJoins = requireOuterJoins;
-    }
+  /**
+   * Return the current 'mode' indicating if outer joins are currently required or not.
+   */
+  public boolean isRequireOuterJoins() {
+    return requireOuterJoins;
+  }
 
-    /**
-     * Add a many where join.
-     */
-    public void add(ElPropertyDeploy elProp) {
-        
-        String join = elProp.getElPrefix();
-        BeanProperty p = elProp.getBeanProperty();
-        if (p instanceof BeanPropertyAssocMany<?>){
-            join = addManyToJoin(join, p.getName());          
-        }
-        if (join != null){
-            addJoin(join);
-            if (p != null) {
-              String secondaryTableJoinPrefix = p.getSecondaryTableJoinPrefix();
-              if (secondaryTableJoinPrefix != null) {
-                addJoin(join+"."+secondaryTableJoinPrefix);
-              }
-            }
-            addParentJoins(join);
-        }
-    }
-    
-    /**
-     * For 'many' properties we also need to add the name of the 
-     * many property to get the full logical name of the join.
-     */
-    private String addManyToJoin(String join, String manyPropName){
-        if (join == null){
-            return manyPropName;
-        } else {
-            return join+"."+manyPropName;
-        }
-    }
-    
-    private void addParentJoins(String join) {
-        String[] split = SplitName.split(join);
-        if (split[0] != null){
-            addJoin(split[0]);
-            addParentJoins(split[0]);
-        }
-    }
+  /**
+   * Set the 'mode' to be that joins added are required to be outer joins.
+   * This is set during the evaluation of disjunction predicates.
+   */
+  public void setRequireOuterJoins(boolean requireOuterJoins) {
+    this.requireOuterJoins = requireOuterJoins;
+  }
 
-    private void addJoin(String property) {
-      SqlJoinType joinType = (requireOuterJoins) ? SqlJoinType.OUTER: SqlJoinType.INNER; 
-      joins.put(property, new PropertyJoin(property, joinType));
-    }
-    
-    /**
-     * Return true if there are no extra many where joins.
-     */
-    public boolean isEmpty() {
-        return joins.isEmpty();
-    }
-    
-    /**
-     * Return the set of many where joins.
-     */
-    public Collection<PropertyJoin> getPropertyJoins() {
-        return joins.values();
-    }
+  /**
+   * Add a many where join.
+   */
+  public void add(ElPropertyDeploy elProp) {
 
-    /**
-     * Return the set of property names for the many where joins.
-     */
-    public TreeSet<String> getPropertyNames() {
-      
-      TreeSet<String> propertyNames = new TreeSet<String>();
-      for (PropertyJoin join : joins.values()) {
-        propertyNames.add(join.getProperty());
+    String join = elProp.getElPrefix();
+    BeanProperty p = elProp.getBeanProperty();
+    if (p instanceof BeanPropertyAssocMany<?>) {
+      join = addManyToJoin(join, p.getName());
+    }
+    if (join != null) {
+      addJoin(join);
+      if (p != null) {
+        String secondaryTableJoinPrefix = p.getSecondaryTableJoinPrefix();
+        if (secondaryTableJoinPrefix != null) {
+          addJoin(join + "." + secondaryTableJoinPrefix);
+        }
       }
-      return propertyNames;
+      addParentJoins(join);
     }
+  }
 
-    /**
-     * In findRowCount query found a formula property with a join clause so building a select clause
-     * specifically for the findRowCount query.
-     */
-    public void addFormulaWithJoin(String propertyName) {
-      if (formulaWithJoin) {
-        formulaProperties.append(",");
-      } else {
-        formulaProperties = new StringBuilder();
-        formulaWithJoin = true;
-      }
-      formulaProperties.append(propertyName);
+  /**
+   * For 'many' properties we also need to add the name of the
+   * many property to get the full logical name of the join.
+   */
+  private String addManyToJoin(String join, String manyPropName) {
+    if (join == null) {
+      return manyPropName;
+    } else {
+      return join + "." + manyPropName;
     }
-    
-    public boolean isHasMany() {
-      return formulaWithJoin || !joins.isEmpty();
+  }
+
+  private void addParentJoins(String join) {
+    String[] split = SplitName.split(join);
+    if (split[0] != null) {
+      addJoin(split[0]);
+      addParentJoins(split[0]);
     }
-    
-    /**
-     * Return true if the findRowCount query just needs the id property in the select clause.
-     */
-    public boolean isSelectId() {
-      return !formulaWithJoin;
+  }
+
+  private void addJoin(String property) {
+    SqlJoinType joinType = (requireOuterJoins) ? SqlJoinType.OUTER : SqlJoinType.INNER;
+    joins.put(property, new PropertyJoin(property, joinType));
+  }
+
+  /**
+   * Return true if there are no extra many where joins.
+   */
+  public boolean isEmpty() {
+    return joins.isEmpty();
+  }
+
+  /**
+   * Return the set of many where joins.
+   */
+  public Collection<PropertyJoin> getPropertyJoins() {
+    return joins.values();
+  }
+
+  /**
+   * Return the set of property names for the many where joins.
+   */
+  public TreeSet<String> getPropertyNames() {
+
+    TreeSet<String> propertyNames = new TreeSet<String>();
+    for (PropertyJoin join : joins.values()) {
+      propertyNames.add(join.getProperty());
     }
-    
-    /**
-     * Return the formula properties to build the select clause for a findRowCount query.
-     */
-    public String getFormulaProperties() {
-      return formulaProperties.toString();
+    return propertyNames;
+  }
+
+  /**
+   * In findRowCount query found a formula property with a join clause so building a select clause
+   * specifically for the findRowCount query.
+   */
+  public void addFormulaWithJoin(String propertyName) {
+    if (formulaWithJoin) {
+      formulaProperties.append(",");
+    } else {
+      formulaProperties = new StringBuilder();
+      formulaWithJoin = true;
     }
+    formulaProperties.append(propertyName);
+  }
+
+  public boolean isHasMany() {
+    return formulaWithJoin || !joins.isEmpty();
+  }
+
+  /**
+   * Return true if the findRowCount query just needs the id property in the select clause.
+   */
+  public boolean isSelectId() {
+    return !formulaWithJoin;
+  }
+
+  /**
+   * Return the formula properties to build the select clause for a findRowCount query.
+   */
+  public String getFormulaProperties() {
+    return formulaProperties.toString();
+  }
 
 }

src/main/java/com/avaje/ebeaninternal/api/SpiEbeanPlugin.java

@@ -7,6 +7,7 @@ import com.avaje.ebean.config.ServerConfig;
  *
  * author: Richard Vowles - http://gplus.to/RichardVowles
  */
+@Deprecated
 public interface SpiEbeanPlugin {
 
   /**

src/main/java/com/avaje/ebeaninternal/api/SpiEbeanServer.java

@@ -66,11 +66,6 @@ public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionL
    */
   PersistenceContextScope getPersistenceContextScope(SpiQuery<?> query);
 
-  /**
-   * Return the DDL generator.
-   */
-  DdlGenerator getDdlGenerator();
-
   /**
    * Clear the query execution statistics.
    */

src/main/java/com/avaje/ebeaninternal/api/SpiExpression.java

@@ -66,4 +66,9 @@ public interface SpiExpression extends Expression {
 	 *            the associated request.
 	 */
 	void addBindValues(SpiExpressionRequest request);
+
+  /**
+   * Validate all the properties/paths associated with this expression.
+   */
+  void validate(SpiExpressionValidation validation);
 }

src/main/java/com/avaje/ebeaninternal/api/SpiExpressionList.java

@@ -67,4 +67,8 @@ public interface SpiExpressionList<T> extends ExpressionList<T> {
    */
   void queryPlanHash(BeanQueryRequest<?> request, HashQueryPlanBuilder builder);
 
+  /**
+   * Validate all the properties/paths used in this expression list.
+   */
+  void validate(SpiExpressionValidation validation);
 }

src/main/java/com/avaje/ebeaninternal/api/SpiExpressionRequest.java

@@ -14,7 +14,7 @@ public interface SpiExpressionRequest {
   /**
    * Return the DB specific JSON expression handler.
    */
-  JsonExpressionHandler getJsonHander();
+  JsonExpressionHandler getJsonHandler();
 
   /**
    * Parse the logical property name to the deployment name.
@@ -35,7 +35,12 @@ public interface SpiExpressionRequest {
 	 * Append to the expression sql.
 	 */
 	SpiExpressionRequest append(String sql);
-	
+
+  /**
+   * Add an encryption key to bind to this request.
+   */
+  void addBindEncryptKey(Object encryptKey);
+
 	/**
 	 * Add a bind value to this request.
 	 */

src/main/java/com/avaje/ebeaninternal/api/SpiExpressionValidation.java

@@ -0,0 +1,37 @@
+package com.avaje.ebeaninternal.api;
+
+import com.avaje.ebean.plugin.SpiBeanType;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * Property expression validation request for a given root bean type.
+ */
+public class SpiExpressionValidation {
+
+  private final SpiBeanType<?> desc;
+
+  private final LinkedHashSet<String> unknown = new LinkedHashSet<String>();
+
+  public SpiExpressionValidation(SpiBeanType<?> desc) {
+    this.desc = desc;
+  }
+
+  /**
+   * Validate that the property expression (path) is valid.
+   */
+  public void validate(String propertyName) {
+    if (!desc.isValidExpression(propertyName)) {
+      unknown.add(propertyName);
+    }
+  }
+
+  /**
+   * Return the set of properties considered as having unknown paths.
+   */
+  public Set<String> getUnknownProperties() {
+    return unknown;
+  }
+
+}

src/main/java/com/avaje/ebeaninternal/api/SpiQuery.java

@@ -11,6 +11,7 @@ import com.avaje.ebean.bean.ObjectGraphNode;
 import com.avaje.ebean.bean.PersistenceContext;
 import com.avaje.ebean.event.BeanQueryRequest;
 import com.avaje.ebean.event.readaudit.ReadEvent;
+import com.avaje.ebean.plugin.SpiBeanType;
 import com.avaje.ebeaninternal.server.autotune.ProfilingListener;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
 import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
@@ -22,6 +23,7 @@ import com.avaje.ebeaninternal.server.querydefn.OrmQueryProperties;
 
 import java.sql.Timestamp;
 import java.util.List;
+import java.util.Set;
 
 /**
  * Object Relational query - Internal extension to Query object.
@@ -94,6 +96,16 @@ public interface SpiQuery<T> extends Query<T> {
   }
 
   enum TemporalMode {
+    /**
+     * Includes soft deletes rows in the result.
+     */
+    SOFT_DELETED,
+
+    /**
+     * Query runs against draft tables.
+     */
+    DRAFT,
+
     /**
      * Query runs against current data (normal).
      */
@@ -171,6 +183,16 @@ public interface SpiQuery<T> extends Query<T> {
    */
   boolean isAsOfQuery();
 
+  /**
+   * Return true if this is a 'As Draft' query.
+   */
+  boolean isAsDraft();
+
+  /**
+   * Return true if this query includes soft deleted rows.
+   */
+  boolean isIncludeSoftDeletes();
+
   /**
    * Return the asOf Timestamp which the query should run as.
    */
@@ -186,6 +208,10 @@ public interface SpiQuery<T> extends Query<T> {
    */
   List<String> getAsOfTableAlias();
 
+  void addSoftDeletePredicate(String softDeletePredicate);
+
+  List<String> getSoftDeletePredicates();
+
   /**
    * Return a listener that wants to be notified when the bean collection is
    * first used.
@@ -684,4 +710,10 @@ public interface SpiQuery<T> extends Query<T> {
    * Return root table alias set by {@link #alias(String)} command.
    */
   String getAlias();
+
+  /**
+   * Validate the query returning the set of properties with unknown paths.
+   */
+  Set<String> validate(SpiBeanType<T> desc);
+
 }

src/main/java/com/avaje/ebeaninternal/server/autotune/service/AutoTuneAllCollection.java

@@ -0,0 +1,61 @@
+package com.avaje.ebeaninternal.server.autotune.service;
+
+import com.avaje.ebeaninternal.server.autotune.model.Autotune;
+
+import java.util.Collection;
+
+/**
+ * Event where all tuned query information is collected.
+ * <p>
+ *  This is for writing the "all" file on shutdown when using runtime tuning.
+ * </p>
+ */
+public class AutoTuneAllCollection {
+
+  final Autotune document = new Autotune();
+
+  final BaseQueryTuner queryTuner;
+
+  /**
+   * Construct to collect/report all tuned queries.
+   */
+  public AutoTuneAllCollection(BaseQueryTuner queryTuner) {
+    this.queryTuner = queryTuner;
+    loadAllTuned();
+  }
+
+  /**
+   * Return the number of origin elements in the document.
+   */
+  public int size() {
+    return document.getOrigin().size();
+  }
+
+  /**
+   * Return the Autotune document object.
+   */
+  public Autotune getDocument() {
+    return document;
+  }
+
+  /**
+   * Write the document as an xml file.
+   */
+  public void writeFile(String filePrefix) {
+
+    AutoTuneXmlWriter writer = new AutoTuneXmlWriter();
+    writer.write(document, filePrefix);
+  }
+
+  /**
+   * Loads all the existing query tuning into the document.
+   */
+  private void loadAllTuned() {
+
+    Collection<TunedQueryInfo> all = queryTuner.getAll();
+    for (TunedQueryInfo tuned: all) {
+      document.getOrigin().add(tuned.getOrigin());
+    }
+  }
+
+}

src/main/java/com/avaje/ebeaninternal/server/autotune/service/AutoTuneDiffCollection.java

@@ -0,0 +1,162 @@
+package com.avaje.ebeaninternal.server.autotune.service;
+
+import com.avaje.ebean.bean.ObjectGraphOrigin;
+import com.avaje.ebeaninternal.server.autotune.AutoTuneCollection;
+import com.avaje.ebeaninternal.server.autotune.model.Autotune;
+import com.avaje.ebeaninternal.server.autotune.model.Origin;
+import com.avaje.ebeaninternal.server.autotune.model.ProfileDiff;
+import com.avaje.ebeaninternal.server.autotune.model.ProfileNew;
+import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
+
+/**
+ * Event where profiling information is collected and processed for differences
+ * relative to the current query tuning.
+ */
+public class AutoTuneDiffCollection {
+
+  final Autotune document = new Autotune();
+
+  final AutoTuneCollection profiling;
+
+  final BaseQueryTuner queryTuner;
+
+  final boolean updateTuning;
+
+  int newCount;
+
+  int diffCount;
+
+  /**
+   * Construct to collect/report the new/diff query tuning entries.
+   */
+  public AutoTuneDiffCollection(AutoTuneCollection profiling, BaseQueryTuner queryTuner, boolean updateTuning) {
+    this.profiling = profiling;
+    this.queryTuner = queryTuner;
+    this.updateTuning = updateTuning;
+  }
+
+  /**
+   * Return true if there are no new or diff entries.
+   */
+  public boolean isEmpty() {
+    return newCount == 0 && diffCount == 0;
+  }
+
+  /**
+   * Return the underlying Autotune document object.
+   */
+  public Autotune getDocument() {
+    return document;
+  }
+
+  /**
+   * Return the number of diff entries.
+   */
+  public int getDiffCount() {
+    return diffCount;
+  }
+
+  /**
+   * Return the number of new entries.
+   */
+  public int getNewCount() {
+    return newCount;
+  }
+
+  /**
+   * Return the total new and diff entries.
+   */
+  public int getChangeCount() {
+    return newCount + diffCount;
+  }
+
+  /**
+   * Write the underlying document as an xml file.
+   */
+  public void writeFile(String filePrefix) {
+
+    AutoTuneXmlWriter writer = new AutoTuneXmlWriter();
+    writer.write(document, filePrefix);
+  }
+
+  /**
+   * Process checking profiling entries against existing query tuning.
+   */
+  public void process() {
+
+    for (AutoTuneCollection.Entry entry : profiling.getEntries()) {
+      addToDocument(entry);
+    }
+  }
+
+  /**
+   * Check if the entry is new or diff and add as necessary.
+   */
+  private void addToDocument(AutoTuneCollection.Entry entry) {
+
+    ObjectGraphOrigin point = entry.getOrigin();
+    OrmQueryDetail profileDetail = entry.getDetail();
+
+    // compare with the existing query tuning entry
+    OrmQueryDetail tuneDetail = queryTuner.get(point.getKey());
+    if (tuneDetail == null) {
+      addToDocumentNewEntry(entry, point);
+
+    } else if (!tuneDetail.isAutoTuneEqual(profileDetail)) {
+      addToDocumentDiffEntry(entry, point, tuneDetail);
+    }
+  }
+
+  /**
+   * Add as a diff entry.
+   */
+  private void addToDocumentDiffEntry(AutoTuneCollection.Entry entry, ObjectGraphOrigin point, OrmQueryDetail tuneDetail) {
+
+    diffCount++;
+
+    Origin origin = createOrigin(entry, point, tuneDetail.toString());
+    ProfileDiff diff = document.getProfileDiff();
+    if (diff == null) {
+      diff = new ProfileDiff();
+      document.setProfileDiff(diff);
+    }
+    diff.getOrigin().add(origin);
+  }
+
+  /**
+   * Add as a "new" entry.
+   */
+  private void addToDocumentNewEntry(AutoTuneCollection.Entry entry, ObjectGraphOrigin point) {
+
+    newCount++;
+
+    ProfileNew profileNew = document.getProfileNew();
+    if (profileNew == null) {
+      profileNew = new ProfileNew();
+      document.setProfileNew(profileNew);
+    }
+    Origin origin = createOrigin(entry, point, entry.getOriginalQuery());
+    profileNew.getOrigin().add(origin);
+  }
+
+
+  /**
+   * Create the XML Origin bean for the given entry and ObjectGraphOrigin.
+   */
+  private Origin createOrigin(AutoTuneCollection.Entry entry, ObjectGraphOrigin point, String query) {
+
+    Origin origin = new Origin();
+    origin.setKey(point.getKey());
+    origin.setBeanType(point.getBeanType());
+    origin.setDetail(entry.getDetail().toString());
+    origin.setCallStack(point.getCallStack().description("\n"));
+    origin.setOriginal(query);
+
+    if (updateTuning) {
+      queryTuner.put(origin);
+    }
+
+    return origin;
+  }
+
+}

src/main/java/com/avaje/ebeaninternal/server/autotune/service/AutoTuneXmlWriter.java

@@ -7,12 +7,29 @@ import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Marshaller;
 import java.io.File;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 
 /**
  * Simple writer for output of the AutoTune Profiling as an XML document.
  */
 public class AutoTuneXmlWriter {
 
+  /**
+   * Write the document as xml file with the given prefix.
+   */
+  public void write(Autotune document, String filePrefix) {
+
+    SortAutoTuneDocument.sort(document);
+
+    SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd-HHmmss");
+    String now = df.format(new Date());
+
+    // write the file with serverName and now suffix as we can output the profiling many times
+    File file = new File(filePrefix + "-" + now + ".xml");
+    write(document, file);
+  }
+
   /**
    * Write Profiling to a file as xml.
    */

src/main/java/com/avaje/ebeaninternal/server/autotune/service/BaseQueryTuner.java

@@ -7,9 +7,11 @@ import com.avaje.ebean.config.AutoTuneMode;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import com.avaje.ebeaninternal.api.SpiQuery;
 import com.avaje.ebeaninternal.server.autotune.ProfilingListener;
+import com.avaje.ebeaninternal.server.autotune.model.Origin;
 import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
 
 import javax.persistence.PersistenceException;
+import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -48,6 +50,21 @@ public class BaseQueryTuner {
     this.skipAll = !queryTuning && !profiling;
   }
 
+  /**
+   * Return all the current tuned query entries.
+   */
+  public Collection<TunedQueryInfo> getAll() {
+    return tunedQueryInfoMap.values();
+  }
+
+  /**
+   * Put a query tuning entry.
+   */
+  public void put(Origin origin) {
+
+    tunedQueryInfoMap.put(origin.getKey(), new TunedQueryInfo(origin));
+  }
+
   /**
    * Load the tuned query information.
    */

src/main/java/com/avaje/ebeaninternal/server/autotune/service/DefaultAutoTuneService.java

@@ -1,6 +1,5 @@
 package com.avaje.ebeaninternal.server.autotune.service;
 
-import com.avaje.ebean.bean.ObjectGraphOrigin;
 import com.avaje.ebean.config.AutoTuneConfig;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
@@ -9,24 +8,11 @@ import com.avaje.ebeaninternal.server.autotune.AutoTuneCollection;
 import com.avaje.ebeaninternal.server.autotune.AutoTuneService;
 import com.avaje.ebeaninternal.server.autotune.model.Autotune;
 import com.avaje.ebeaninternal.server.autotune.model.Origin;
-import com.avaje.ebeaninternal.server.autotune.model.ProfileDiff;
-import com.avaje.ebeaninternal.server.autotune.model.ProfileEmpty;
-import com.avaje.ebeaninternal.server.autotune.model.ProfileNew;
-import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
-import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetailParser;
-import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
-import java.text.SimpleDateFormat;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Implementation of the AutoTuneService which is comprised of profiling and query tuning.
@@ -35,9 +21,13 @@ public class DefaultAutoTuneService implements AutoTuneService {
 
   private static final Logger logger = LoggerFactory.getLogger(DefaultAutoTuneService.class);
 
+  private final SpiEbeanServer server;
+
   private final long defaultGarbageCollectionWait;
 
-  private final boolean skipCollectionOnShutdown;
+  private final boolean skipGarbageCollectionOnShutdown;
+
+  private final boolean skipProfileReportingOnShutdown;
 
   private final BaseQueryTuner queryTuner;
 
@@ -53,18 +43,25 @@ public class DefaultAutoTuneService implements AutoTuneService {
 
   private final String serverName;
 
+  private final int profilingUpdateFrequency;
+
+  private long runtimeChangeCount;
+
   public DefaultAutoTuneService(SpiEbeanServer server, ServerConfig serverConfig) {
 
     AutoTuneConfig config = serverConfig.getAutoTuneConfig();
 
+    this.server = server;
     this.queryTuning = config.isQueryTuning();
     this.profiling = config.isProfiling();
     this.tuningFile = config.getQueryTuningFile();
     this.profilingFile = config.getProfilingFile();
+    this.profilingUpdateFrequency = config.getProfilingUpdateFrequency();
     this.serverName = server.getName();
     this.profileManager = new ProfileManager(config, server);
     this.queryTuner = new BaseQueryTuner(config, server, profileManager);
-    this.skipCollectionOnShutdown = config.isSkipCollectionOnShutdown();
+    this.skipGarbageCollectionOnShutdown = config.isSkipGarbageCollectionOnShutdown();
+    this.skipProfileReportingOnShutdown = config.isSkipProfileReportingOnShutdown();
     this.defaultGarbageCollectionWait = (long) config.getGarbageCollectionWait();
   }
 
@@ -75,169 +72,122 @@ public class DefaultAutoTuneService implements AutoTuneService {
   public void startup() {
 
     if (queryTuning) {
-      File file = new File(tuningFile);
-      if (!file.exists()) {
-        logger.warn("AutoTune file {} not found - no automatic tuning will be applied", file.getAbsolutePath());
-
-      } else {
-        AutoTuneXmlReader reader = new AutoTuneXmlReader();
-        Autotune profiling = reader.read(file);
-        logger.info("AutoTune loading {} tuning entries", profiling.getOrigin().size());
-        for (Origin origin : profiling.getOrigin()) {
-          queryTuner.load(origin.getKey(), createTunedQueryInfo(origin));
-        }
+      loadTuningFile();
+      if (isRuntimeTuningUpdates()) {
+        // periodically gather and update query tuning
+        server.getBackgroundExecutor().executePeriodically(new ProfilingUpdate(), profilingUpdateFrequency, TimeUnit.SECONDS);
       }
     }
   }
 
-  @NotNull
-  private TunedQueryInfo createTunedQueryInfo(Origin origin) {
-    OrmQueryDetail detail = new OrmQueryDetailParser(origin.getDetail()).parse();
-    return new TunedQueryInfo(detail);
+
+  /**
+   * Return true if the tuning should update periodically at runtime.
+   */
+  private boolean isRuntimeTuningUpdates() {
+    return profilingUpdateFrequency > 0;
   }
 
-  private void saveProfiling(boolean reset) {
+  private class ProfilingUpdate implements Runnable {
 
-    Autotune document = new Autotune();
-
-    AutoTuneCollection autoTuneCollection = profileManager.profilingCollection(reset);
-
-    List<AutoTuneCollection.Entry> entries = autoTuneCollection.getEntries();
-
-    // count "new" and "diff" profiling entries
-    AtomicInteger newCounter = new AtomicInteger();
-    AtomicInteger diffCounter = new AtomicInteger();
-
-    Set<String> profileKeys = new HashSet<String>();
-    for (AutoTuneCollection.Entry entry : entries) {
-      saveProfilingEntry(document, entry, newCounter, diffCounter);
-      profileKeys.add(entry.getOrigin().getKey());
+    @Override
+    public void run() {
+      runtimeTuningUpdate();
     }
+  }
 
-    // report the origin keys that we didn't collect any profiling on
-    Set<String> tunerKeys = queryTuner.keySet();
-    for (String tuneKey : tunerKeys) {
-      if (!profileKeys.contains(tuneKey)) {
-        ProfileEmpty profileEmpty = document.getProfileEmpty();
-        if (profileEmpty == null) {
-          profileEmpty = new ProfileEmpty();
-          document.setProfileEmpty(profileEmpty);
-        }
-        Origin emptyOrigin = new Origin();
-        emptyOrigin.setKey(tuneKey);
-        profileEmpty.getOrigin().add(emptyOrigin);
-      }
-    }
-
-    int totalNew = newCounter.get();
-    int totalDiff = diffCounter.get();
-    if (totalNew == 0 && totalDiff == 0) {
-      logger.info("No new or diff entries for profiling server:{}", serverName);
+  /**
+   * Load tuning information from an existing tuning file.
+   */
+  private void loadTuningFile() {
+    File file = new File(tuningFile);
+    if (!file.exists()) {
+      logger.warn("AutoTune file {} not found - no initial automatic query tuning", file.getAbsolutePath());
 
     } else {
-      sortDocument(document);
-
-      SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd-HHmmss");
-      String now = df.format(new Date());
-
-      // write the file with serverName and now suffix as we can output the profiling many times
-      File file = new File(profilingFile + "-" + serverName + "-" + now + ".xml");
-      AutoTuneXmlWriter writer = new AutoTuneXmlWriter();
-      writer.write(document, file);
-
-      logger.info("writing new:{} diff:{} profiling entries for server:{}", totalNew, totalDiff, serverName);
-    }
-  }
-
-  /**
-   * Set the diff and new entries by bean type followed by key.
-   */
-  private void sortDocument(Autotune document) {
-
-    ProfileDiff profileDiff = document.getProfileDiff();
-    if (profileDiff != null) {
-      Collections.sort(profileDiff.getOrigin(), new OriginNameKeySort());
-    }
-    ProfileNew profileNew = document.getProfileNew();
-    if (profileNew != null) {
-      Collections.sort(profileNew.getOrigin(), new OriginNameKeySort());
-    }
-    ProfileEmpty profileEmpty = document.getProfileEmpty();
-    if (profileEmpty != null) {
-      Collections.sort(profileEmpty.getOrigin(), new OriginKeySort());
-    }
-  }
-
-  /**
-   * Comparator sort by bean type then key.
-   */
-  class OriginNameKeySort implements Comparator<Origin> {
-
-    @Override
-    public int compare(Origin o1, Origin o2) {
-      int comp = o1.getBeanType().compareTo(o2.getBeanType());
-      if (comp == 0) {
-        comp = o1.getKey().compareTo(o2.getKey());
+      AutoTuneXmlReader reader = new AutoTuneXmlReader();
+      Autotune profiling = reader.read(file);
+      logger.info("AutoTune loading {} tuning entries", profiling.getOrigin().size());
+      for (Origin origin : profiling.getOrigin()) {
+        queryTuner.put(origin);
       }
-      return comp;
     }
   }
 
   /**
-   * Comparator sort by bean type then key.
+   * Collect profiling, check for new/diff to existing tuning and apply changes.
    */
-  class OriginKeySort implements Comparator<Origin> {
+  private void runtimeTuningUpdate() {
 
-    @Override
-    public int compare(Origin o1, Origin o2) {
-      return o1.getKey().compareTo(o2.getKey());
+    synchronized (this) {
+      try {
+        long start = System.currentTimeMillis();
+
+        AutoTuneCollection profiling = profileManager.profilingCollection(false);
+
+        AutoTuneDiffCollection event = new AutoTuneDiffCollection(profiling, queryTuner, true);
+        event.process();
+        if (event.isEmpty()) {
+          long exeMillis = System.currentTimeMillis() - start;
+          logger.debug("No query tuning updates for server:{} executionMillis:{}", serverName, exeMillis);
+
+        } else {
+          // report the query tuning changes that have been made
+          runtimeChangeCount += event.getChangeCount();
+          event.writeFile(profilingFile + "-" + serverName + "-update");
+          long exeMillis = System.currentTimeMillis() - start;
+          logger.info("query tuning updates - new:{} diff:{} for server:{} executionMillis:{}", event.getNewCount(), event.getDiffCount(), serverName, exeMillis);
+        }
+      } catch (Throwable e) {
+        logger.error("Error collecting or applying automatic query tuning", e);
+      }
     }
   }
 
-  private void saveProfilingEntry(Autotune document, AutoTuneCollection.Entry entry, AtomicInteger newCount, AtomicInteger diffCount) {
+  private void saveProfilingOnShutdown(boolean reset) {
 
-    ObjectGraphOrigin point = entry.getOrigin();
-    OrmQueryDetail profileDetail = entry.getDetail();
+    synchronized (this) {
+      if (isRuntimeTuningUpdates()) {
+        runtimeTuningUpdate();
+        outputAllTuning();
 
-    // compare with the existing query tuning entry
-    OrmQueryDetail tuneDetail = queryTuner.get(point.getKey());
-    if (tuneDetail == null) {
-      // New entry
-      newCount.incrementAndGet();
-      ProfileNew profileNew = document.getProfileNew();
-      if (profileNew == null) {
-        profileNew = new ProfileNew();
-        document.setProfileNew(profileNew);
+      } else {
+
+        AutoTuneCollection profiling = profileManager.profilingCollection(reset);
+
+        AutoTuneDiffCollection event = new AutoTuneDiffCollection(profiling, queryTuner, false);
+        event.process();
+        if (event.isEmpty()) {
+          logger.info("No new or diff entries for profiling server:{}", serverName);
+
+        } else {
+          event.writeFile(profilingFile + "-" + serverName);
+          logger.info("writing new:{} diff:{} profiling entries for server:{}", event.getNewCount(), event.getDiffCount(), serverName);
+        }
       }
-      Origin origin = createOrigin(entry, point);
-      origin.setOriginal(entry.getOriginalQuery());
-      profileNew.getOrigin().add(origin);
-
-    } else if (!tuneDetail.isAutoTuneEqual(profileDetail)) {
-      // Diff entry
-      diffCount.incrementAndGet();
-      Origin origin = createOrigin(entry, point);
-      origin.setOriginal(tuneDetail.toString());
-      ProfileDiff diff = document.getProfileDiff();
-      if (diff == null) {
-        diff = new ProfileDiff();
-        document.setProfileDiff(diff);
-      }
-      diff.getOrigin().add(origin);
     }
   }
 
   /**
-   * Create the XML Origin bean for the given entry and ObjectGraphOrigin.
+   * Output all the query tuning (the "all" file).
+   * <p>
+   * This is the originally loaded tuning plus any tuning changes picked up and applied at runtime.
+   * </p>
+   * <p>
+   * This "all" file can be used as the next "ebean-autotune.xml" file.
+   * </p>
    */
-  @NotNull
-  private Origin createOrigin(AutoTuneCollection.Entry entry, ObjectGraphOrigin point) {
-    Origin origin = new Origin();
-    origin.setKey(point.getKey());
-    origin.setBeanType(point.getBeanType());
-    origin.setDetail(entry.getDetail().toString());
-    origin.setCallStack(point.getCallStack().description("\n"));
-    return origin;
+  private void outputAllTuning() {
+
+    if (runtimeChangeCount == 0) {
+      logger.info("no runtime query tuning changes for server:{}", serverName);
+
+    } else {
+      AutoTuneAllCollection event = new AutoTuneAllCollection(queryTuner);
+      int size = event.size();
+      event.writeFile(profilingFile + "-" + serverName + "-all");
+      logger.info("query tuning detected [{}] changes, writing all [{}] tuning entries for server:{}", runtimeChangeCount, size, serverName);
+    }
   }
 
   /**
@@ -250,12 +200,29 @@ public class DefaultAutoTuneService implements AutoTuneService {
    */
   @Override
   public void shutdown() {
-    if (profiling && !skipCollectionOnShutdown) {
-      collectProfiling(-1);
-      saveProfiling(false);
+    if (profiling) {
+      if (!skipGarbageCollectionOnShutdown && !skipProfileReportingOnShutdown) {
+        // trigger GC to update profiling information on recently executed queries
+        collectProfiling(-1);
+      }
+      if (!skipProfileReportingOnShutdown) {
+        saveProfilingOnShutdown(false);
+      }
     }
   }
 
+  /**
+   * Output the profiling.
+   * <p>
+   * When profiling updates are applied to tuning at runtime this reports all tuning and profiling combined.
+   * When profiling is not applied at runtime then this reports the diff report with new and diff entries relative
+   * to the existing tuning.
+   * </p>
+   */
+  public void reportProfiling() {
+    saveProfilingOnShutdown(false);
+  }
+
   /**
    * Ask for a System.gc() so that we gather node usage information.
    * <p>

src/main/java/com/avaje/ebeaninternal/server/autotune/service/ProfileManager.java

@@ -118,7 +118,6 @@ public class ProfileManager implements ProfilingListener {
     AutoTuneCollection req = new AutoTuneCollection();
 
     for (ProfileOrigin origin : profileMap.values()) {
-
       BeanDescriptor<?> desc = server.getBeanDescriptorById(origin.getOrigin().getBeanType());
       if (desc != null) {
         origin.profilingCollection(desc, req, reset);

src/main/java/com/avaje/ebeaninternal/server/autotune/service/SortAutoTuneDocument.java

@@ -0,0 +1,71 @@
+package com.avaje.ebeaninternal.server.autotune.service;
+
+import com.avaje.ebeaninternal.server.autotune.model.Autotune;
+import com.avaje.ebeaninternal.server.autotune.model.Origin;
+import com.avaje.ebeaninternal.server.autotune.model.ProfileDiff;
+import com.avaje.ebeaninternal.server.autotune.model.ProfileEmpty;
+import com.avaje.ebeaninternal.server.autotune.model.ProfileNew;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Sorts Autotune document by
+ */
+public class SortAutoTuneDocument {
+
+
+  /**
+   * Set the diff and new entries by bean type followed by key.
+   */
+  public static void sort(Autotune document) {
+
+    ProfileDiff profileDiff = document.getProfileDiff();
+    if (profileDiff != null) {
+      Collections.sort(profileDiff.getOrigin(), NAME_KEY_SORT);
+    }
+    ProfileNew profileNew = document.getProfileNew();
+    if (profileNew != null) {
+      Collections.sort(profileNew.getOrigin(), NAME_KEY_SORT);
+    }
+    ProfileEmpty profileEmpty = document.getProfileEmpty();
+    if (profileEmpty != null) {
+      Collections.sort(profileEmpty.getOrigin(), KEY_SORT);
+    }
+    List<Origin> origins = document.getOrigin();
+    if (!origins.isEmpty()) {
+      Collections.sort(origins, NAME_KEY_SORT);
+    }
+  }
+
+  private static final OriginNameKeySort NAME_KEY_SORT = new OriginNameKeySort();
+
+  private static final OriginKeySort KEY_SORT = new OriginKeySort();
+
+  /**
+   * Comparator sort by bean type then key.
+   */
+  private static class OriginNameKeySort implements Comparator<Origin> {
+
+    @Override
+    public int compare(Origin o1, Origin o2) {
+      int comp = o1.getBeanType().compareTo(o2.getBeanType());
+      if (comp == 0) {
+        comp = o1.getKey().compareTo(o2.getKey());
+      }
+      return comp;
+    }
+  }
+
+  /**
+   * Comparator sort by bean type then key.
+   */
+  private static class OriginKeySort implements Comparator<Origin> {
+
+    @Override
+    public int compare(Origin o1, Origin o2) {
+      return o1.getKey().compareTo(o2.getKey());
+    }
+  }
+}

src/main/java/com/avaje/ebeaninternal/server/autotune/service/TunedQueryInfo.java

@@ -1,7 +1,9 @@
 package com.avaje.ebeaninternal.server.autotune.service;
 
 import com.avaje.ebeaninternal.api.SpiQuery;
+import com.avaje.ebeaninternal.server.autotune.model.Origin;
 import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
+import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetailParser;
 
 import java.io.Serializable;
 
@@ -11,10 +13,20 @@ import java.io.Serializable;
  */
 public class TunedQueryInfo implements Serializable {
 
+  private final Origin origin;
+
   private final OrmQueryDetail tunedDetail;
 
-  public TunedQueryInfo(OrmQueryDetail tunedDetail) {
-    this.tunedDetail = tunedDetail;
+  public TunedQueryInfo(Origin origin) {
+    this.origin = origin;
+    this.tunedDetail = new OrmQueryDetailParser(origin.getDetail()).parse();
+  }
+
+  /**
+   * Return the origin entry (includes call stack and bean type).
+   */
+  public Origin getOrigin() {
+    return origin;
   }
 
   /**

src/main/java/com/avaje/ebeaninternal/server/core/DefaultBeanLoader.java

@@ -6,23 +6,20 @@ import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.bean.EntityBeanIntercept;
 import com.avaje.ebean.bean.PersistenceContext;
-import com.avaje.ebeaninternal.api.LoadBeanBuffer;
 import com.avaje.ebeaninternal.api.LoadBeanRequest;
-import com.avaje.ebeaninternal.api.LoadManyBuffer;
 import com.avaje.ebeaninternal.api.LoadManyRequest;
+import com.avaje.ebeaninternal.api.LoadRequest;
 import com.avaje.ebeaninternal.api.SpiQuery;
 import com.avaje.ebeaninternal.api.SpiQuery.Mode;
 import com.avaje.ebeaninternal.api.SpiTransaction;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
 import com.avaje.ebeaninternal.server.deploy.BeanDescriptor.EntityType;
 import com.avaje.ebeaninternal.server.deploy.BeanPropertyAssocMany;
-import com.avaje.ebeaninternal.server.lib.util.StringHelper;
 import com.avaje.ebeaninternal.server.transaction.DefaultPersistenceContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.persistence.EntityNotFoundException;
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -86,89 +83,11 @@ public class DefaultBeanLoader {
 
     int batchSize = getBatchSize(batch.size());
 
-    LoadManyBuffer ctx = loadRequest.getLoadContext();
-    BeanPropertyAssocMany<?> many = ctx.getBeanProperty();
+    SpiQuery<?> query = loadRequest.createQuery(server, batchSize);
 
-    PersistenceContext pc = ctx.getPersistenceContext();
+    executeQuery(loadRequest, query);
 
-    ArrayList<Object> idList = new ArrayList<Object>(batchSize);
-
-    for (int i = 0; i < batch.size(); i++) {
-      BeanCollection<?> bc = batch.get(i);
-      EntityBean ownerBean = bc.getOwnerBean();
-      Object id = many.getParentId(ownerBean);
-      idList.add(id);
-    }
-    int extraIds = batchSize - batch.size();
-    if (extraIds > 0) {
-      Object firstId = idList.get(0);
-      for (int i = 0; i < extraIds; i++) {
-        idList.add(firstId);
-      }
-    }
-
-    BeanDescriptor<?> desc = ctx.getBeanDescriptor();
-
-    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(many.getTargetType());
-    String orderBy = many.getLazyFetchOrderBy();
-    if (orderBy != null) {
-      query.orderBy(orderBy);
-    }
-
-    String extraWhere = many.getExtraWhere();
-    if (extraWhere != null) {
-      // replace special ${ta} placeholder with the base table alias 
-      // which is always t0 and add the extra where clause
-      String ew = StringHelper.replaceString(extraWhere, "${ta}", "t0");
-      query.where().raw(ew);
-    }
-
-    query.setLazyLoadForParents(many);
-    many.addWhereParentIdIn(query, idList);
-
-    query.setPersistenceContext(pc);
-
-    String mode = loadRequest.isLazy() ? "+lazy" : "+query";
-    query.setLoadDescription(mode, loadRequest.getDescription());
-
-    if (loadRequest.isLazy()) {
-      // cascade the batch size (if set) for further lazy loading
-      query.setLazyLoadBatchSize(loadRequest.getBatchSize());
-    }
-
-    // potentially changes the joins and selected properties
-    ctx.configureQuery(query);
-
-    if (loadRequest.isOnlyIds()) {
-      // override to just select the Id values
-      query.select(many.getTargetIdProperty());
-    }
-
-    if (onIterateUseExtraTxn && loadRequest.isParentFindIterate()) {
-      // MySql - we need a different transaction to execute the secondary query
-      SpiTransaction extraTxn = server.createQueryTransaction();
-      try {
-        server.findList(query, extraTxn);
-      } finally {
-        extraTxn.end();
-      }
-    } else {
-      server.findList(query, loadRequest.getTransaction());
-    }
-
-    // check for BeanCollection's that where never processed
-    // in the +query or +lazy load due to no rows (predicates)
-    for (int i = 0; i < batch.size(); i++) {
-      BeanCollection<?> bc = batch.get(i);
-      if (bc.checkEmptyLazyLoad()) {
-        if (logger.isDebugEnabled()) {
-          logger.debug("BeanCollection after load was empty. Owner:" + batch.get(i).getOwnerBean());
-        }
-      } else if (loadRequest.isLoadCache()) {
-        Object parentId = desc.getId(bc.getOwnerBean());
-        desc.cacheManyPropPut(many, bc, parentId);
-      }
-    }
+    loadRequest.postLoad();
 
     // log the query (for testing secondary queries)
     loadRequest.logSecondaryQuery(query);
@@ -274,96 +193,43 @@ public class DefaultBeanLoader {
   public void loadBean(LoadBeanRequest loadRequest) {
 
     List<EntityBeanIntercept> batch = loadRequest.getBatch();
-
     if (batch.isEmpty()) {
       throw new RuntimeException("Nothing in batch?");
     }
 
     int batchSize = getBatchSize(batch.size());
 
-    LoadBeanBuffer ctx = loadRequest.getLoadContext();
-    BeanDescriptor<?> desc = ctx.getBeanDescriptor();
-
-    Class<?> beanType = desc.getBeanType();
-
-    EntityBeanIntercept[] ebis = batch.toArray(new EntityBeanIntercept[batch.size()]);
-    ArrayList<Object> idList = new ArrayList<Object>(batchSize);
-
-    for (int i = 0; i < batch.size(); i++) {
-      EntityBeanIntercept ebi = batch.get(i);
-      EntityBean bean = ebi.getOwner();
-      Object id = desc.getId(bean);
-      idList.add(id);
-    }
-
+    List<Object> idList = loadRequest.getIdList(batchSize);
     if (idList.isEmpty()) {
       // everything was loaded from cache
       return;
     }
 
-    int extraIds = batchSize - batch.size();
-    if (extraIds > 0) {
-      // for performance make up the Id's to the batch size
-      // so we get the same query (for Ebean and the db)
-      Object firstId = idList.get(0);
-      for (int i = 0; i < extraIds; i++) {
-        // just add the first Id again
-        idList.add(firstId);
-      }
-    }
+    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(loadRequest.getBeanType());
+    loadRequest.configureQuery(query, idList);
 
-    PersistenceContext persistenceContext = ctx.getPersistenceContext();
+    List<?> list = executeQuery(loadRequest, query);
+    loadRequest.postLoad(list);
 
-    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(beanType);
+    // log the query (for testing secondary queries)
+    loadRequest.logSecondaryQuery(query);
+  }
 
-    query.setMode(Mode.LAZYLOAD_BEAN);
-    query.setPersistenceContext(persistenceContext);
-
-    String mode = loadRequest.isLazy() ? "+lazy" : "+query";
-    query.setLoadDescription(mode, loadRequest.getDescription());
-
-    if (loadRequest.isLazy()) {
-      // cascade the batch size (if set) for further lazy loading
-      query.setLazyLoadBatchSize(loadRequest.getBatchSize());
-    }
-
-    ctx.configureQuery(query, loadRequest.getLazyLoadProperty());
-
-    // make sure the query doesn't use the cache
-    // query.setUseCache(false);
-    if (idList.size() == 1) {
-      query.where().idEq(idList.get(0));
-    } else {
-      query.where().idIn(idList);
-    }
-
-    List<?> list;
+  /**
+   * Execute the lazy load query taking into account MySql transaction oddness.
+   */
+  private List<?> executeQuery(LoadRequest loadRequest, SpiQuery<?> query) {
     if (onIterateUseExtraTxn && loadRequest.isParentFindIterate()) {
       // MySql - we need a different transaction to execute the secondary query
       SpiTransaction extraTxn = server.createQueryTransaction();
       try {
-        list = server.findList(query, extraTxn);
+        return server.findList(query, extraTxn);
       } finally {
         extraTxn.end();
       }
     } else {
-      list = server.findList(query, loadRequest.getTransaction());
+      return server.findList(query, loadRequest.getTransaction());
     }
-
-    if (loadRequest.isLoadCache()) {
-      for (int i = 0; i < list.size(); i++) {
-        desc.cacheBeanPutData((EntityBean) list.get(i));
-      }
-    }
-
-    for (int i = 0; i < ebis.length; i++) {
-      // Check if the underlying row in DB was deleted. Mark this bean as 'failed' if
-      // necessary but allow processing to continue until it is accessed by client code
-      ebis[i].checkLazyLoadFailure();
-    }
-
-    // log the query (for testing secondary queries)
-    loadRequest.logSecondaryQuery(query);
   }
 
   public void refresh(EntityBean bean) {
@@ -401,8 +267,10 @@ public class DefaultBeanLoader {
       ebi.setPersistenceContext(pc);
     }
 
+    boolean draft = desc.isDraftInstance(bean);
+
     if (embeddedOwnerIndex == -1) {
-      if (SpiQuery.Mode.LAZYLOAD_BEAN.equals(mode) && desc.isBeanCaching()) {
+      if (!draft && SpiQuery.Mode.LAZYLOAD_BEAN.equals(mode) && desc.isBeanCaching()) {
         // lazy loading and the bean cache is active 
         if (desc.cacheBeanLoad(bean, ebi, id)) {
           return;
@@ -415,10 +283,12 @@ public class DefaultBeanLoader {
 
     SpiQuery<?> query = (SpiQuery<?>) server.createQuery(desc.getBeanType());
     query.setLazyLoadProperty(ebi.getLazyLoadProperty());
+    if (draft) {
+      query.asDraft();
+    }
 
     if (embeddedOwnerIndex > -1) {
-      String embeddedBeanPropertyName = ebi.getProperty(embeddedOwnerIndex);
-      query.select("id," + embeddedBeanPropertyName);
+      query.select("id," + ebi.getProperty(embeddedOwnerIndex));
     }
 
     // don't collect AutoTune usage profiling information

src/main/java/com/avaje/ebeaninternal/server/core/DefaultContainer.java

@@ -20,6 +20,7 @@ import com.avaje.ebeaninternal.server.cluster.ClusterManager;
 import com.avaje.ebeaninternal.server.lib.ShutdownManager;
 import com.avaje.ebeaninternal.server.lib.sql.DataSourceAlert;
 import com.avaje.ebeaninternal.server.lib.sql.DataSourcePool;
+import com.avaje.ebeaninternal.server.lib.sql.DataSourcePoolListener;
 import com.avaje.ebeaninternal.server.lib.sql.SimpleDataSourceAlert;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -46,8 +47,6 @@ public class DefaultContainer implements SpiContainer {
 
   private final JndiDataSourceLookup jndiDataSourceFactory;
 
-//  private final AtomicInteger serverId = new AtomicInteger(1);
-
   public DefaultContainer(ContainerConfig containerConfig) {
 
     this.clusterManager = new ClusterManager(containerConfig);
@@ -115,7 +114,6 @@ public class DefaultContainer implements SpiContainer {
 
       ServerCacheManager cacheManager = getCacheManager(serverConfig);
 
-//      int uniqueServerId = serverId.incrementAndGet();
       SpiBackgroundExecutor bgExecutor = createBackgroundExecutor(serverConfig);
 
       XmlConfigLoader xmlConfigLoader = new XmlConfigLoader(null);
@@ -127,19 +125,6 @@ public class DefaultContainer implements SpiContainer {
 
       cacheManager.init(server);
 
-//      if (serverConfig.isRegisterJmxMBeans()) {
-//        MBeanServer mbeanServer;
-//        ArrayList<?> list = MBeanServerFactory.findMBeanServer(null);
-//        if (list.size() == 0) {
-//          // probably not running in a server
-//          mbeanServer = MBeanServerFactory.createMBeanServer();
-//        } else {
-//          // use the first MBeanServer
-//          mbeanServer = (MBeanServer) list.get(0);
-//        }
-//        server.registerMBeans(mbeanServer, uniqueServerId);
-//      }
-
       // generate and run DDL if required
       // if there are any other tasks requiring action in their plugins, do them as well
       if (!DbOffline.isRunningMigration()) {
@@ -311,7 +296,17 @@ public class DefaultContainer implements SpiContainer {
     }
 
     DataSourceAlert notify = new SimpleDataSourceAlert();
-    return new DataSourcePool(notify, config.getName(), dsConfig);
+    DataSourcePoolListener listener = createListener(config, dsConfig);
+
+    return new DataSourcePool(notify, config.getName(), dsConfig, listener);
+  }
+
+  /**
+   * Create and return a DataSourcePoolListener if it has been specified.
+   */
+  private DataSourcePoolListener createListener(ServerConfig config, DataSourceConfig dsConfig) {
+    String poolListener = dsConfig.getPoolListener();
+    return poolListener != null ? (DataSourcePoolListener) config.getClassLoadConfig().newInstance(poolListener) : null;
   }
 
   /**