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

Add test for broken fetching issue #462

.gitignore

@@ -1,5 +1,6 @@
 *.autofetch
-*.sql
+*create-all.sql
+*drop-all.sql
 *.orig
 .classpath
 .project
@@ -7,6 +8,8 @@
 target/
 logs/
 log/
+ebean-autotune.xml
+ebean-profiling*.xml
 /db
 /mydb.db
 !src/test/ddl-review/*.sql

.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;'
+

README.md

@@ -5,16 +5,7 @@
 
 Ebean ORM
 ==============
-[http://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Website")
-
-
-Maven Dependency
-----------------
-    <dependency>
-      <groupId>org.avaje.ebeanorm</groupId>
-      <artifactId>avaje-ebeanorm</artifactId>
-      <version>4.7.3</version>
-    </dependency>
+[https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Website")
 
 
 [Maven central - avaje-ebeanorm](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22org.avaje.ebeanorm%22%20AND%20a%3A%22avaje-ebeanorm%22 "maven central ebeanorm")

pom.xml

@@ -9,11 +9,11 @@
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>6.5.1</version>
+  <version>6.18.1</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>
@@ -61,6 +61,14 @@
       <version>1.7.7</version>
     </dependency>
 
+    <!-- provided scope for Spring boot loader classpath scanning support -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-loader</artifactId>
+      <version>1.2.7.RELEASE</version>
+      <scope>provided</scope>
+    </dependency>
+
     <!-- provided scope for JsonNode support -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
@@ -109,10 +117,24 @@
     <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
-      <version>9.4-1201-jdbc41</version>
+      <version>9.4-1202-jdbc41</version>
       <scope>provided</scope>
     </dependency>
 
+    <!--<dependency>-->
+      <!--<groupId>oracle</groupId>-->
+      <!--<artifactId>oracle-jdbc</artifactId>-->
+      <!--<version>7.0</version>-->
+      <!--<scope>test</scope>-->
+    <!--</dependency>-->
+
+    <!--<dependency>-->
+      <!--<groupId>microsoft</groupId>-->
+      <!--<artifactId>sqlserver-jdbc</artifactId>-->
+      <!--<version>4.2</version>-->
+      <!--<scope>test</scope>-->
+    <!--</dependency>-->
+
     <dependency>
       <groupId>com.squareup.okhttp</groupId>
       <artifactId>okhttp</artifactId>
@@ -130,15 +152,17 @@
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.5.1</version>
+      <version>4.9.1</version>
       <scope>test</scope>
     </dependency>
-        
+
+    <!-- Provided scope so that the H2HistoryTrigger can live in Ebean core
+         and not require a separate module for it -->
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.4.182</version>
-      <scope>test</scope>
+      <version>1.4.189</version>
+      <scope>provided</scope>
     </dependency>
     
     <dependency>
@@ -195,7 +219,7 @@
       <plugin>
         <groupId>org.avaje.ebeanorm</groupId>
         <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.5.1</version>
+        <version>4.9.1</version>
         <executions>
           <!--   Not going to enhance Model bean -->
           <execution>
@@ -249,11 +273,11 @@
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>2.9.1</version>
         <configuration>
-          <doctitle>Ebean 4</doctitle>
+          <doctitle>Ebean 6</doctitle>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
-          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames>
+          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util:com.avaje.ebean.dbmigration.ddlgeneration:com.avaje.ebean.dbmigration.migration:com.avaje.ebean.dbmigration.migrationreader:com.avaje.ebean.dbmigration.model</excludePackageNames>
           <docletArtifact>
             <groupId>org.avaje</groupId>
             <artifactId>pygments-doclet</artifactId>

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

@@ -1,137 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Administrative control of Autofetch during runtime.
- */
-public interface AdminAutofetch {
-
-  /**
-   * Return true if profiling is enabled.
-   */
-  boolean isProfiling();
-
-  /**
-   * Set to true to enable profiling.
-   */
-  void setProfiling(boolean enable);
-
-  /**
-   * Return true if autoFetch automatic query tuning is enabled.
-   */
-  boolean isQueryTuning();
-
-  /**
-   * Set to true to enable autoFetch automatic query tuning.
-   */
-  void setQueryTuning(boolean enable);
-
-  /**
-   * Returns the rate which profiling is collected. This is an int between 0 and
-   * 100.
-   */
-  double getProfilingRate();
-
-  /**
-   * Set the rate at which profiling is collected after the base.
-   * 
-   * @param rate
-   *          a int between 0 and 100.
-   */
-  void setProfilingRate(double rate);
-
-  /**
-   * Return the number of queries profiled after which profiling is collected at
-   * a percentage rate.
-   */
-  int getProfilingBase();
-
-  /**
-   * Set a base number of queries to profile per query point.
-   * <p>
-   * After this amount of profiling has been obtained profiling is collected at
-   * the Profiling Percentage rate.
-   * </p>
-   */
-  void setProfilingBase(int profilingBase);
-
-  /**
-   * Return the minimum number of queries profiled before autoFetch will start
-   * automatically tuning the queries.
-   * <p>
-   * This could be one which means start autoFetch tuning after the first
-   * profiling information is collected.
-   * </p>
-   */
-  int getProfilingMin();
-
-  /**
-   * Set the minimum number of queries profiled per query point before autoFetch
-   * will automatically tune the queries.
-   * <p>
-   * Increasing this number will mean more profiling is collected before
-   * autoFetch starts tuning the query.
-   * </p>
-   */
-  void setProfilingMin(int autoFetchMinThreshold);
-
-  /**
-   * Fire a garbage collection (hint to the JVM). Assuming garbage collection
-   * fires this will gather the usage profiling information.
-   */
-  String collectUsageViaGC();
-
-  /**
-   * This will take the current profiling information and update the "tuned
-   * query detail".
-   * <p>
-   * This is done periodically and can also be manually invoked.
-   * </p>
-   * 
-   * @return a summary of the updates that occurred
-   */
-  String updateTunedQueryInfo();
-
-  /**
-   * Clear all the tuned query info.
-   * <p>
-   * Should only need do this for testing and playing around.
-   * </p>
-   * 
-   * @return the amount of tuned query information cleared.
-   */
-  int clearTunedQueryInfo();
-
-  /**
-   * Clear all the profiling information.
-   * <p>
-   * This means the profiling information will need to be re-gathered.
-   * </p>
-   * <p>
-   * Should only need do this for testing and playing around.
-   * </p>
-   * 
-   * @return the amount of profiled information cleared.
-   */
-  int clearProfilingInfo();
-
-  /**
-   * Clear the query execution statistics.
-   */
-  void clearQueryStatistics();
-
-  /**
-   * Return the number of queries tuned by AutoFetch.
-   */
-  int getTotalTunedQueryCount();
-
-  /**
-   * Return the size of the TuneQuery map.
-   */
-  int getTotalTunedQuerySize();
-
-  /**
-   * Return the size of the profile map.
-   */
-  int getTotalProfileSize();
-
-}

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

@@ -0,0 +1,24 @@
+package com.avaje.ebean;
+
+/**
+ * Administrative control of AutoTune during runtime.
+ */
+public interface AutoTune {
+
+  /**
+   * Fire a garbage collection (hint to the JVM). Assuming garbage collection
+   * fires this will gather remaining usage profiling information.
+   */
+  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/BeanState.java

@@ -38,6 +38,33 @@ public interface BeanState {
    */
   void setDisableLazyLoad(boolean disableLazyLoading);
 
+  /**
+   * Set the loaded state of the property given it's name.
+   *
+   * <p>
+   *   Typically this would be used to set the loaded state of a property
+   *   to false to ensure that the specific property is excluded from a
+   *   stateless update.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *   // populate a bean via say JSON
+   *   User user = ...;
+   *
+   *   // set loaded state on the email property to false so that
+   *   // the email property is not included in a stateless update
+   *   Ebean.getBeanState(user).setPropertyLoaded("email", false);
+   *
+   *   user.update();
+   *
+   * }</pre>
+   *
+   *
+   * This will throw an IllegalArgumentException if the property is unknown.
+   */
+  void setPropertyLoaded(String propertyName, boolean loaded);
+
   /**
    * For partially populated beans returns the properties that are loaded on the
    * bean.

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);
@@ -70,7 +71,7 @@ class DRawSqlParser {
 
     preFrom = trimSelectKeyword(preFrom);
 
-    return new Sql(sql.hashCode(), preFrom, preWhere, whereExprAnd, preHaving, havingExprAnd, orderByPrefix, orderBySql, (distinctPos > -1));
+    return new Sql(sql, preFrom, preWhere, whereExprAnd, preHaving, havingExprAnd, orderByPrefix, orderBySql, (distinctPos > -1));
   }
 
   /**
@@ -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

@@ -22,7 +22,7 @@ import com.avaje.ebean.text.json.JsonContext;
 /**
  * This Ebean object is effectively a singleton that holds a map of registered
  * {@link EbeanServer}s. It additionally provides a convenient way to use the
- * 'default/primary' EbeanServer.
+ * 'default' EbeanServer.
  * <p>
  * If you are using a Dependency Injection framework such as
  * <strong>Spring</strong> or <strong>Guice</strong> you will probably
@@ -178,7 +178,7 @@ public final class Ebean {
       if (defaultServer == null) {
         String msg = "The default EbeanServer has not been defined?";
         msg += " This is normally set via the ebean.datasource.default property.";
-        msg += " Otherwise it should be registered programatically via registerServer()";
+        msg += " Otherwise it should be registered programmatically via registerServer()";
         throw new PersistenceException(msg);
       }
       return defaultServer;
@@ -217,8 +217,8 @@ public final class Ebean {
     /**
      * Register a server so we can get it by its name.
      */
-    private void register(EbeanServer server, boolean isPrimaryServer) {
-      registerWithName(server.getName(), server, isPrimaryServer);
+    private void register(EbeanServer server, boolean isDefaultServer) {
+      registerWithName(server.getName(), server, isDefaultServer);
     }
     
     private void registerWithName(String name, EbeanServer server, boolean isDefaultServer) {
@@ -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;
@@ -106,10 +107,9 @@ public interface EbeanServer {
   void shutdown(boolean shutdownDataSource, boolean deregisterDriver);
   
   /**
-   * Return the AdminAutofetch which is used to control and configure the
-   * Autofetch service at runtime.
+   * Return AutoTune which is used to control the AutoTune service at runtime.
    */
-  AdminAutofetch getAdminAutofetch();
+  AutoTune getAutoTune();
 
   /**
    * Return the name. This is used with {@link Ebean#getServer(String)} to get a
@@ -1020,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
@@ -1042,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>
@@ -1092,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
@@ -1107,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()
    */
@@ -1247,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.
@@ -1457,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
@@ -1509,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;
 
@@ -1820,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/ExpressionFactory.java

@@ -36,6 +36,51 @@ import java.util.Map;
  */
 public interface ExpressionFactory {
 
+  /**
+   * Path exists - for the given path in a JSON document.
+   */
+  Expression jsonExists(String propertyName, String path);
+
+  /**
+   * Path does not exist - for the given path in a JSON document.
+   */
+  Expression jsonNotExists(String propertyName, String path);
+
+  /**
+   * Equal to - for the given path in a JSON document.
+   */
+  Expression jsonEqualTo(String propertyName, String path, Object val);
+
+  /**
+   * Not Equal to - for the given path in a JSON document.
+   */
+  Expression jsonNotEqualTo(String propertyName, String path, Object val);
+
+  /**
+   * Greater than - for the given path in a JSON document.
+   */
+  Expression jsonGreaterThan(String propertyName, String path, Object val);
+
+  /**
+   * Greater than or equal to - for the given path in a JSON document.
+   */
+  Expression jsonGreaterOrEqual(String propertyName, String path, Object val);
+
+  /**
+   * Less than - for the given path in a JSON document.
+   */
+  Expression jsonLessThan(String propertyName, String path, Object val);
+
+  /**
+   * Less than or equal to - for the given path in a JSON document.
+   */
+  Expression jsonLessOrEqualTo(String propertyName, String path, Object val);
+
+  /**
+   * Between - for the given path in a JSON document.
+   */
+  Expression jsonBetween(String propertyName, String path, Object lowerValue, Object upperValue);
+
   /**
    * Equal To - property equal to the given value.
    */

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>
@@ -324,6 +374,13 @@ public interface ExpressionList<T> extends Serializable {
    */
   Query<T> setUseCache(boolean useCache);
 
+  /**
+   * Set to true to use the query for executing this query.
+   *
+   * @see Query#setUseQueryCache(boolean)
+   */
+  Query<T> setUseQueryCache(boolean useCache);
+
   /**
    * Add expressions to the having clause.
    * <p>
@@ -338,20 +395,136 @@ public interface ExpressionList<T> extends Serializable {
    */
   ExpressionList<T> where();
 
+  /**
+   * Path exists - for the given path in a JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonExists("content", "path.other")
+   *
+   * }</pre>
+   *
+   * @param propertyName the property that holds a JSON document
+   * @param path the nested path in the JSON document in dot notation
+   */
+  ExpressionList<T> jsonExists(String propertyName, String path);
+
+  /**
+   * Path does not exist - for the given path in a JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonNotExists("content", "path.other")
+   *
+   * }</pre>
+   *
+   * @param propertyName the property that holds a JSON document
+   * @param path the nested path in the JSON document in dot notation
+   */
+  ExpressionList<T> jsonNotExists(String propertyName, String path);
+
+  /**
+   * Equal to expression for the value at the given path in the JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonEqualTo("content", "path.other", 34)
+   *
+   * }</pre>
+   *
+   * @param propertyName the property that holds a JSON document
+   * @param path the nested path in the JSON document in dot notation
+   * @param value the value used to test against the document path's value
+   */
+  ExpressionList<T> jsonEqualTo(String propertyName, String path, Object value);
+
+  /**
+   * Not Equal to - for the given path in a JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonNotEqualTo("content", "path.other", 34)
+   *
+   * }</pre>
+   *
+   * @param propertyName the property that holds a JSON document
+   * @param path the nested path in the JSON document in dot notation
+   * @param value the value used to test against the document path's value
+   */
+  ExpressionList<T> jsonNotEqualTo(String propertyName, String path, Object value);
+
+  /**
+   * Greater than - for the given path in a JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonGreaterThan("content", "path.other", 34)
+   *
+   * }</pre>
+   */
+  ExpressionList<T> jsonGreaterThan(String propertyName, String path, Object value);
+
+  /**
+   * Greater than or equal to - for the given path in a JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonGreaterOrEqual("content", "path.other", 34)
+   *
+   * }</pre>
+   */
+  ExpressionList<T> jsonGreaterOrEqual(String propertyName, String path, Object value);
+
+  /**
+   * Less than - for the given path in a JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonLessThan("content", "path.other", 34)
+   *
+   * }</pre>
+   */
+  ExpressionList<T> jsonLessThan(String propertyName, String path, Object value);
+
+  /**
+   * Less than or equal to - for the given path in a JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonLessOrEqualTo("content", "path.other", 34)
+   *
+   * }</pre>
+   */
+  ExpressionList<T> jsonLessOrEqualTo(String propertyName, String path, Object value);
+
+  /**
+   * Between - for the given path in a JSON document.
+   *
+   * <pre>{@code
+   *
+   *   where().jsonBetween("content", "orderDate", lowerDateTime, upperDateTime)
+   *
+   * }</pre>
+   */
+  ExpressionList<T> jsonBetween(String propertyName, String path, Object lowerValue, Object upperValue);
+
   /**
    * Add an Expression to the list.
    * <p>
    * This returns the list so that add() can be chained.
    * </p>
-   * 
-   * <pre class="code">
-   * Query&lt;Customer&gt; query = Ebean.createQuery(Customer.class);
+   *
+   * <pre>{@code
+   *
+   * Query<Customer> query = Ebean.find(Customer.class);
    * query.where()
-   *     .like(&quot;name&quot;,&quot;Rob%&quot;)
-   *     .eq(&quot;status&quot;, Customer.ACTIVE);
-   * List&lt;Customer&gt; list = query.findList();
+   *     .like("name","Rob%")
+   *     .eq("status", Customer.ACTIVE);
+   *
+   * List<Customer> list = query.findList();
    * ...
-   * </pre>
+   *
+   * }</pre>
    */
   ExpressionList<T> add(Expression expr);
 
@@ -432,33 +605,36 @@ public interface ExpressionList<T> extends Serializable {
    * those options such as case insensitive etc.
    * </p>
    * 
-   * <pre class="code">
+   * <pre>{@code
+   *
    * // create an example bean and set the properties
    * // with the query parameters you want
    * Customer example = new Customer();
-   * example.setName(&quot;Rob%&quot;);
-   * example.setNotes(&quot;%something%&quot;);
+   * example.setName("Rob%");
+   * example.setNotes("%something%");
    * 
    * List&lt;Customer&gt; list = Ebean.find(Customer.class).where()
    *     // pass the bean into the where() clause
    *     .exampleLike(example)
    *     // you can add other expressions to the same query
-   *     .gt(&quot;id&quot;, 2).findList();
+   *     .gt("id", 2).findList();
    * 
-   * </pre>
+   * }</pre>
    * 
    * Similarly you can create an ExampleExpression
    * 
-   * <pre>
+   * <pre>{@code
+   *
    * Customer example = new Customer();
-   * example.setName(&quot;Rob%&quot;);
-   * example.setNotes(&quot;%something%&quot;);
+   * example.setName("Rob%");
+   * example.setNotes("%something%");
    * 
    * // create a ExampleExpression with more control
    * ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO).includeZeros();
    * 
-   * List&lt;Customer&gt; list = Ebean.find(Customer.class).where().add(qbe).findList();
-   * </pre>
+   * List<Customer> list = Ebean.find(Customer.class).where().add(qbe).findList();
+   *
+   * }</pre>
    */
   ExpressionList<T> exampleLike(Object example);
 
@@ -586,6 +762,14 @@ public interface ExpressionList<T> extends Serializable {
    * then they are not translated. logical property name names (not fully
    * qualified) will still be translated to their physical name.
    * </p>
+   *
+   * <h4>Example:</h4>
+   * <pre>{@code
+   *
+   *   // use a database function
+   *   raw("add_days(orderDate, 10) < ?", someDate)
+   *
+   * }</pre>
    */
   ExpressionList<T> raw(String raw, Object value);
 
@@ -601,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.
@@ -610,6 +794,12 @@ public interface ExpressionList<T> extends Serializable {
    * then they are not translated. logical property name names (not fully
    * qualified) will still be translated to their physical name.
    * </p>
+   *
+   * <pre>{@code
+   *
+   *   raw("orderQty < shipQty")
+   *
+   * }</pre>
    */
   ExpressionList<T> raw(String raw);
 

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

@@ -249,4 +249,22 @@ public class FetchConfig implements Serializable {
     return queryAll;
   }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    FetchConfig that = (FetchConfig) o;
+    if (lazyBatchSize != that.lazyBatchSize) return false;
+    if (queryBatchSize != that.queryBatchSize) return false;
+    return queryAll == that.queryAll;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = lazyBatchSize;
+    result = 92821 * result + queryBatchSize;
+    result = 92821 * result + (queryAll ? 1 : 0);
+    return result;
+  }
 }

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

@@ -36,7 +36,7 @@ import java.util.Set;
  *         .sort("avgTimeMicros desc")
  *         .gt("executionCount", 0)
  *         .gt("lastQueryTime", nowMinus24Hrs)
- *         .eq("autofetchTuned", true)
+ *         .eq("autoTuned", true)
  *         .maxRows(10)
  *         .filter(list);
  * 

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

@@ -1,5 +1,6 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.text.PathProperties;
 import com.avaje.ebean.util.ClassUtil;
 import org.jetbrains.annotations.Nullable;
@@ -193,7 +194,31 @@ public abstract class Model {
   public void markAsDirty() {
     db().markAsDirty(this);
   }
-  
+
+  /**
+   * Mark the property as unset or 'not loaded'.
+   * <p>
+   *   This would be used to specify a property that we did not wish to include in a stateless update.
+   * </p>
+   * <pre>{@code
+   *
+   *   // populate an entity bean from JSON or whatever
+   *   User user = ...;
+   *
+   *   // mark the email property as 'unset' so that it is not
+   *   // included in a 'stateless update'
+   *   user.markPropertyUnset("email");
+   *
+   *   user.update();
+   *
+   * }</pre>
+   *
+   * @param propertyName the name of the property on the bean to be marked as 'unset'
+   */
+  public void markPropertyUnset(String propertyName) {
+    ((EntityBean)this)._ebean_getIntercept().setPropertyLoaded(propertyName, false);
+  }
+
   /**
    * Insert or update this entity depending on its state.
    * 
@@ -226,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);
   }
 
   /**
@@ -251,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);
   }
 
   /**
@@ -836,10 +873,10 @@ public abstract class Model {
     }
 
     /**
-     * Create a query with explicit 'Autofetch' use.
+     * Create a query with explicit 'AutoTune' use.
      */
-    public Query<T> setAutofetch(boolean autofetch) {
-      return query().setAutofetch(autofetch);
+    public Query<T> setAutoTune(boolean autoTune) {
+      return query().setAutoTune(autoTune);
     }
 
     /**

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

@@ -28,7 +28,7 @@ public final class OrderBy<T> implements Serializable {
    * Create an empty OrderBy with no associated query.
    */
   public OrderBy() {
-    this.list = new ArrayList<Property>(2);
+    this.list = new ArrayList<Property>(3);
   }
   
   private OrderBy(List<Property> list) {
@@ -52,7 +52,7 @@ public final class OrderBy<T> implements Serializable {
    */
   public OrderBy(Query<T> query, String orderByClause) {
     this.query = query;
-    this.list = new ArrayList<Property>(2);
+    this.list = new ArrayList<Property>(3);
     parse(orderByClause);
   }
 
@@ -83,6 +83,19 @@ public final class OrderBy<T> implements Serializable {
     return query;
   }
 
+  /**
+   * Return true if the property is known to be contained in the order by clause.
+   */
+  public boolean containsProperty(String propertyName) {
+
+    for (int i = 0; i < list.size(); i++) {
+      if (propertyName.equals(list.get(i).getProperty())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Return a copy of this OrderBy with the path trimmed.
    */
@@ -185,6 +198,18 @@ public final class OrderBy<T> implements Serializable {
     return list.hashCode();
   }
 
+  /**
+   * Clear the orderBy removing any current order by properties.
+   * <p>
+   * This is intended to be used when some code creates a query with a
+   * 'default' order by clause and some other code may clear the 'default'
+   * order by clause and replace.
+   * </p>
+   */
+  public void clear() {
+    list.clear();
+  }
+
   /**
    * A property and its ascending descending order.
    */

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;
@@ -67,9 +68,9 @@ import java.util.Set;
  * ...
  * }</pre>
  * 
- * <h3>Autofetch</h3>
+ * <h3>AutoTune</h3>
  * <p>
- * Ebean has built in support for "Autofetch". This is a mechanism where a query
+ * Ebean has built in support for "AutoTune". This is a mechanism where a query
  * can be automatically tuned based on profiling information that is collected.
  * </p>
  * <p>
@@ -78,7 +79,7 @@ import java.util.Set;
  * more.
  * </p>
  * <p>
- * It is expected that Autofetch will be the default approach for many queries
+ * It is expected that AutoTune will be the default approach for many queries
  * in a system. It is possibly not as useful where the result of a query is sent
  * to a remote client or where there is some requirement for "Read Consistency"
  * guarantees.
@@ -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.
@@ -338,23 +349,23 @@ public interface Query<T> extends Serializable {
   ExpressionFactory getExpressionFactory();
 
   /**
-   * Returns true if this query was tuned by autoFetch.
+   * Returns true if this query was tuned by autoTune.
    */
-  boolean isAutofetchTuned();
+  boolean isAutoTuned();
 
   /**
-   * Explicitly specify whether to use Autofetch for this query.
+   * Explicitly specify whether to use AutoTune for this query.
    * <p>
-   * If you do not call this method on a query the "Implicit Autofetch mode" is
-   * used to determine if Autofetch should be used for a given query.
+   * If you do not call this method on a query the "Implicit AutoTune mode" is
+   * used to determine if AutoTune should be used for a given query.
    * </p>
    * <p>
-   * Autofetch can add additional fetch paths to the query and specify which
+   * AutoTune can add additional fetch paths to the query and specify which
    * properties are included for each path. If you have explicitly defined some
-   * fetch paths Autofetch will not remove.
+   * fetch paths AutoTune will not remove them.
    * </p>
    */
-  Query<T> setAutofetch(boolean autofetch);
+  Query<T> setAutoTune(boolean autoTune);
 
   /**
    * Set the default lazy loading batch size to use.
@@ -366,6 +377,16 @@ public interface Query<T> extends Serializable {
    */
   Query<T> setLazyLoadBatchSize(int lazyLoadBatchSize);
 
+  /**
+   * Disable read auditing for this query.
+   * <p>
+   * This is intended to be used when the query is not a user initiated query and instead
+   * part of the internal processing in an application to load a cache or document store etc.
+   * In these cases we don't want the query to be part of read auditing.
+   * </p>
+   */
+  Query<T> setDisableReadAuditing();
+
   /**
    * Explicitly set a comma delimited list of the properties to fetch on the
    * 'main' root level entity bean (aka partial object). Note that '*' means all
@@ -680,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>
@@ -716,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();
@@ -799,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
@@ -844,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.
    * 
@@ -1303,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

@@ -206,6 +206,14 @@ public final class RawSql implements Serializable {
     return sql;
   }
 
+  /**
+   * Return the key;
+   */
+  public Key getKey() {
+    boolean parsed = sql != null && sql.parsed;
+    String unParsedSql = (sql == null) ? "" : sql.unparsedSql;
+    return new Key(parsed, unParsedSql, columnMapping);
+  }
   
   /**
    * Return the resultSet if this is a ResultSet based RawSql.
@@ -221,16 +229,6 @@ public final class RawSql implements Serializable {
     return columnMapping;
   }
 
-  /**
-   * Return the hash for this query.
-   */
-  public int queryHash() {
-    if (resultSet != null) {
-      return 31 * columnMapping.queryHash();
-    }
-    return 31 * sql.queryHash() + columnMapping.queryHash();
-  }
-
   /**
    * Represents the sql part of the query. For parsed RawSql the sql is broken
    * up so that Ebean can insert extra WHERE and HAVING expressions into the
@@ -260,13 +258,10 @@ public final class RawSql implements Serializable {
 
     private final boolean distinct;
 
-    private final int queryHashCode;
-
     /**
      * Construct for unparsed SQL.
      */
     protected Sql(String unparsedSql) {
-      this.queryHashCode = unparsedSql.hashCode();
       this.parsed = false;
       this.unparsedSql = unparsedSql;
       this.preFrom = null;
@@ -282,12 +277,11 @@ public final class RawSql implements Serializable {
     /**
      * Construct for parsed SQL.
      */
-    protected Sql(int queryHashCode, String preFrom, String preWhere, boolean andWhereExpr,
+    protected Sql(String unparsedSql, String preFrom, String preWhere, boolean andWhereExpr,
         String preHaving, boolean andHavingExpr, String orderByPrefix, String orderBy, boolean distinct) {
 
-      this.queryHashCode = queryHashCode;
+      this.unparsedSql = unparsedSql;
       this.parsed = true;
-      this.unparsedSql = null;
       this.preFrom = preFrom;
       this.preHaving = preHaving;
       this.preWhere = preWhere;
@@ -298,13 +292,6 @@ public final class RawSql implements Serializable {
       this.distinct = distinct;
     }
 
-    /**
-     * Return a hash for this query.
-     */
-    public int queryHash() {
-      return queryHashCode;
-    }
-
     public String toString() {
       if (!parsed) {
         return "unparsed[" + unparsedSql + "]";
@@ -406,13 +393,10 @@ public final class RawSql implements Serializable {
 
     private final boolean immutable;
 
-    private final int queryHashCode;
-
     /**
      * Construct from parsed sql where the columns have been identified.
      */
     protected ColumnMapping(List<Column> columns) {
-      this.queryHashCode = 0;
       this.immutable = false;
       this.parsed = true;
       this.propertyMap = null;
@@ -428,7 +412,6 @@ public final class RawSql implements Serializable {
      * Construct for unparsed sql.
      */
     protected ColumnMapping() {
-      this.queryHashCode = 0;
       this.immutable = false;
       this.parsed = false;
       this.propertyMap = null;
@@ -443,17 +426,13 @@ public final class RawSql implements Serializable {
       this.immutable = false;
       this.parsed = false;
       this.propertyMap = null;
-      //this.propertyColumnMap = null;
       this.dbColumnMap = new LinkedHashMap<String, Column>();
-      
-      int hc = 31;
+
       int pos = 0;
       for (String prop : propertyNames) {
-        hc = 31 * hc + prop.hashCode();
         dbColumnMap.put(prop, new Column(pos++, prop, null, prop));
       }
       propertyColumnMap = dbColumnMap;
-      this.queryHashCode = hc;
     }
 
     /**
@@ -464,20 +443,28 @@ public final class RawSql implements Serializable {
       this.parsed = parsed;
       this.dbColumnMap = dbColumnMap;
 
-      int hc = ColumnMapping.class.getName().hashCode();
-
       HashMap<String, Column> pcMap = new HashMap<String, Column>();
       HashMap<String, String> pMap = new HashMap<String, String>();
 
       for (Column c : dbColumnMap.values()) {
         pMap.put(c.getPropertyName(), c.getDbColumn());
         pcMap.put(c.getPropertyName(), c);
-        hc = 31 * hc + ((c.getPropertyName() == null) ? 0 : c.getPropertyName().hashCode());
-        hc = 31 * hc + ((c.getDbColumn() == null) ? 0 : c.getDbColumn().hashCode());
       }
       this.propertyMap = Collections.unmodifiableMap(pMap);
       this.propertyColumnMap = Collections.unmodifiableMap(pcMap);
-      this.queryHashCode = hc;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      ColumnMapping that = (ColumnMapping) o;
+      return dbColumnMap.equals(that.dbColumnMap);
+    }
+
+    @Override
+    public int hashCode() {
+      return dbColumnMap.hashCode();
     }
 
     /**
@@ -521,16 +508,6 @@ public final class RawSql implements Serializable {
       }
     }
 
-    /**
-     * Return the query hash for this column mapping.
-     */
-    public int queryHash() {
-      if (queryHashCode == 0) {
-        throw new RuntimeException("Bug: queryHashCode == 0");
-      }
-      return queryHashCode;
-    }
-
     /**
      * Returns true if the Columns where supplied by parsing the sql select
      * clause.
@@ -585,6 +562,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) {
 
@@ -645,6 +625,27 @@ public final class RawSql implements Serializable {
         }
       }
 
+      @Override
+      public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Column that = (Column) o;
+        if (indexPos != that.indexPos) return false;
+        if (!dbColumn.equals(that.dbColumn)) return false;
+        if (dbAlias != null ? !dbAlias.equals(that.dbAlias) : that.dbAlias != null) return false;
+        return propertyName != null ? propertyName.equals(that.propertyName) : that.propertyName == null;
+      }
+
+      @Override
+      public int hashCode() {
+        int result = indexPos;
+        result = 31 * result + dbColumn.hashCode();
+        result = 31 * result + (dbAlias != null ? dbAlias.hashCode() : 0);
+        result = 31 * result + (propertyName != null ? propertyName.hashCode() : 0);
+        return result;
+      }
+
       public String toString() {
         return dbColumn + "->" + propertyName;
       }
@@ -696,4 +697,39 @@ public final class RawSql implements Serializable {
       }
     }
   }
+
+  /**
+   * A key for the RawSql object using for the query plan.
+   */
+  public static final class Key {
+
+    private final boolean parsed;
+    private final ColumnMapping columnMapping;
+    private final String unParsedSql;
+
+    Key(boolean parsed, String unParsedSql, ColumnMapping columnMapping) {
+      this.parsed = parsed;
+      this.unParsedSql = unParsedSql;
+      this.columnMapping = columnMapping;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+
+      Key that = (Key) o;
+      return parsed == that.parsed
+          && columnMapping.equals(that.columnMapping)
+          && unParsedSql.equals(that.unParsedSql);
+    }
+
+    @Override
+    public int hashCode() {
+      int result = (parsed ? 1 : 0);
+      result = 31 * result + columnMapping.hashCode();
+      result = 31 * result + unParsedSql.hashCode();
+      return result;
+    }
+  }
 }

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

@@ -0,0 +1,17 @@
+package com.avaje.ebean.annotation;
+
+/**
+ * Specify the DB storage type used to with <code>@DbEnumValue</code>.
+ */
+public enum DbEnumType {
+
+  /**
+   * Store values as database INTEGER.
+   */
+  INTEGER,
+
+  /**
+   * Store values as database VARCHAR.
+   */
+  VARCHAR
+}

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

@@ -0,0 +1,44 @@
+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;
+
+/**
+ * Specify a method on an Enum that returns the value that should be stored in the DB.
+ * <p>
+ * This is the preferred option for mapping Enum's to DB values (preferred over the JPA
+ * standard @Enumerated and Ebean's @EnumValue annotations).
+ * </p>
+ * <h3>Example:</h3>
+ * <pre>{@code
+ *
+ *   public enum Status {
+ *     NEW("N"),
+ *     ACTIVE("A"),
+ *     INACTIVE("I");
+ *
+ *     String dbValue;
+ *     Status(String dbValue) {
+ *       this.dbValue = dbValue;
+ *     }
+ *
+ *     @DbEnumValue
+ *     public String getValue() {
+ *       return dbValue;
+ *     }
+ *   }
+ *
+ * }</pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface DbEnumValue {
+
+  /**
+   * Specify the database type used to store the values (VARCHAR or INTEGER).
+   */
+  DbEnumType storage() default DbEnumType.VARCHAR;
+
+}

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

@@ -25,7 +25,7 @@ import java.lang.annotation.Target;
  * }</pre>
  * <p>
  * This is an alternative to using the JPA standard approach or Ebean's
- * {@link EnumMapping} annotation.
+ * {@link DbEnumValue} annotation.
  * </p>
  * <p>
  * Note that if all the EnumValue values are parsable as Integers then Ebean

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

@@ -0,0 +1,15 @@
+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 an entity bean as being included in read auditing.
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ReadAudit {
+
+}

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>
@@ -115,6 +125,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   void internalAdd(Object bean);
 
+  /**
+   * Add the bean with a check to see if it is already contained.
+   */
+  void internalAddWithCheck(Object bean);
+
   /**
    * Return the number of elements in the List Set or Map.
    */

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

@@ -6,7 +6,7 @@ import java.util.Arrays;
 /**
  * Represent the call stack (stack trace elements).
  * <p>
- * Used with a query to identify a CallStackQuery for AutoFetch automatic query
+ * Used with a query to identify a CallStackQuery for AutoTune automatic query
  * tuning.
  * </p>
  * <p>
@@ -26,16 +26,12 @@ public final class CallStack implements Serializable {
 
   private final StackTraceElement[] callStack;
 
-  public CallStack(StackTraceElement[] callStack) {
+  public CallStack(StackTraceElement[] callStack, int zeroHash, int pathHash) {
     this.callStack = callStack;
-    this.zeroHash = enc(callStack[0].hashCode());
-    int hc = 0;
-    for (int i = 1; i < callStack.length; i++) {
-      hc = 31 * hc + callStack[i].hashCode();
-    }
-    this.pathHash = enc(hc);
+    this.zeroHash = enc(zeroHash);
+    this.pathHash = enc(pathHash);
   }
-  
+
   public int hashCode() {
     int hc = 0;
     for (int i = 0; i < callStack.length; i++) {
@@ -87,8 +83,19 @@ public final class CallStack implements Serializable {
     return zeroHash + ":" + pathHash + ":" + callStack[0];
   }
 
+  /**
+   * Return the call stack lines appended with the given newLine string.
+   */
+  public String description(String newLine) {
+    StringBuilder sb = new StringBuilder(400);
+    for (int i = 0; i < callStack.length; i++) {
+      sb.append(callStack[i].toString()).append(newLine);
+    }
+    return sb.toString();
+  }
+
   public String getOriginKey(int queryHash) {
-    return zeroHash + "." + enc(queryHash) + "." + pathHash;
+    return enc(queryHash)+ "." + zeroHash + "." + pathHash;
   }
 
   private static final int radix = 1 << 6;

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;
   }
 
   /**
@@ -449,7 +443,18 @@ public final class EntityBeanIntercept implements Serializable {
   public int getPropertyLength() {
     return owner._ebean_getPropertyNames().length;
   }
-  
+
+  /**
+   * Set the loaded state of the property given it's name.
+   */
+  public void setPropertyLoaded(String propertyName, boolean loaded) {
+    int position = findProperty(propertyName);
+    if (position == -1) {
+      throw new IllegalArgumentException("Property "+propertyName+" not found");
+    }
+    loadedProps[position] = loaded;
+  }
+
   /**
    * Set the property to be treated as unloaded. Used for properties initialised in default
    * constructor.
@@ -496,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];
     }
@@ -737,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) {
@@ -752,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/bean/NodeUsageCollector.java

@@ -1,13 +1,13 @@
 package com.avaje.ebean.bean;
 
 import java.lang.ref.WeakReference;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
 
 /**
- * Collects profile information for a bean (or reference/proxy bean) at a given
- * AutoFetchNode.
+ * Collects profile information for a bean (or reference/proxy bean) at a given node.
  * <p>
- * The AutoFetchNode identifies the location of the bean in the object graph.
+ * The node identifies the location of the bean in the object graph.
  * </p>
  * <p>
  * It has to use a weak reference so as to ensure that it does not stop the
@@ -29,7 +29,7 @@ public final class NodeUsageCollector {
   /**
    * The properties used at this profile point.
    */
-  private final HashSet<String> used = new HashSet<String>();
+  private final Set<String> used = new LinkedHashSet<String>();
 
   /**
    * set to true if the bean is modified (setter called)
@@ -105,7 +105,7 @@ public final class NodeUsageCollector {
   /**
    * Return the set of used properties.
    */
-  public HashSet<String> getUsed() {
+  public Set<String> getUsed() {
     return used;
   }
 

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

@@ -9,7 +9,7 @@ public interface NodeUsageListener {
    * Collect node usage "profiling" information.
    * <p>
    * This is the properties that are used for a given bean in the object graph.
-   * This information is used by autoFetch to tune queries.
+   * This information is used by autoTune to tune queries.
    * </p>
    */
   void collectNodeUsage(NodeUsageCollector collector);

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

@@ -9,7 +9,7 @@ import java.io.Serializable;
  * The call stack is included so that the query can have different tuned fetches
  * for each unique call stack. For example, a query to fetch a customer could be
  * called by three different methods and each can be treated as a separate
- * origin point (and autoFetch can tune each one separately).
+ * origin point (and autoTune can tune each one separately).
  * </p>
  */
 public final class ObjectGraphOrigin implements Serializable {

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

@@ -1,5 +1,9 @@
 package com.avaje.ebean.common;
 
+import com.avaje.ebean.bean.BeanCollectionAdd;
+import com.avaje.ebean.bean.BeanCollectionLoader;
+import com.avaje.ebean.bean.EntityBean;
+
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -8,17 +12,13 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 
-import com.avaje.ebean.bean.BeanCollectionAdd;
-import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
-
 /**
  * List capable of lazy loading.
  */
 public final class BeanList<E> extends AbstractBeanCollection<E> implements List<E>, BeanCollectionAdd {
 
   private static final long serialVersionUID = 1L;
-  
+
   /**
    * The underlying List implementation.
    */
@@ -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);
   }
 
@@ -74,6 +74,13 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     }
   }
 
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    if (list == null || !list.contains(bean)) {
+      internalAdd(bean);
+    }
+  }
+
   public boolean checkEmptyLazyLoad() {
     if (list == null) {
       list = new ArrayList<E>();
@@ -99,11 +106,11 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   private void initAsUntouched() {
     init(false);
   }
-  
+
   private void init() {
     init(true);
   }
-  
+
   private void init(boolean setTouched) {
     synchronized (this) {
       if (list == null) {
@@ -134,7 +141,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   public Collection<E> getActualDetails() {
     return list;
   }
-  
+
   @Override
   public Collection<?> getActualEntries() {
     return list;
@@ -206,6 +213,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 +331,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

@@ -66,7 +66,18 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
       map.put((K) key, (E) bean);
     }
   }
-  
+
+  public void internalPutWithCheck(Object key, Object bean) {
+    if (map == null || !map.containsKey(key)) {
+      internalPut(key, bean);
+    }
+  }
+
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    throw new RuntimeException("Not allowed for map");
+  }
+
   public void internalAdd(Object bean) {
     throw new RuntimeException("Not allowed for map");
   }
@@ -272,6 +283,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

@@ -1,15 +1,15 @@
 package com.avaje.ebean.common;
 
+import com.avaje.ebean.bean.BeanCollectionAdd;
+import com.avaje.ebean.bean.BeanCollectionLoader;
+import com.avaje.ebean.bean.EntityBean;
+
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Set;
 
-import com.avaje.ebean.bean.BeanCollectionAdd;
-import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
-
 /**
  * Set capable of lazy loading.
  */
@@ -53,10 +53,17 @@ 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);
   }
 
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    if (set == null || !set.contains(bean)) {
+      internalAdd(bean);
+    }
+  }
+
   @SuppressWarnings("unchecked")
   public void internalAdd(Object bean) {
     if (set == null) {
@@ -107,11 +114,11 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   private void initAsUntouched() {
     init(false);
   }
-  
+
   private void init() {
     init(true);
   }
-  
+
   private void init(boolean setTouched) {
     synchronized (this) {
       if (set == null) {
@@ -174,6 +181,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

@@ -0,0 +1,254 @@
+package com.avaje.ebean.config;
+
+/**
+ * Defines the AutoTune behaviour for a EbeanServer.
+ */
+public class AutoTuneConfig {
+
+  private AutoTuneMode mode = AutoTuneMode.DEFAULT_ON;
+
+  private String queryTuningFile = "ebean-autotune.xml";
+
+  private boolean queryTuning;
+
+  private boolean queryTuningAddVersion;
+
+  private boolean profiling;
+
+  private String profilingFile = "ebean-profiling";
+
+  private int profilingBase = 5;
+
+  private double profilingRate = 0.01;
+
+  private int profilingUpdateFrequency;
+
+  private int garbageCollectionWait = 100;
+  
+  private boolean skipGarbageCollectionOnShutdown;
+
+  private boolean skipProfileReportingOnShutdown;
+
+  public AutoTuneConfig() {
+  }
+
+  /**
+   * Return the name of the file that holds the query tuning information.
+   */
+  public String getQueryTuningFile() {
+    return queryTuningFile;
+  }
+
+  /**
+   * Set the name of the file that holds the query tuning information.
+   */
+  public void setQueryTuningFile(String queryTuningFile) {
+    this.queryTuningFile = queryTuningFile;
+  }
+
+  /**
+   * Return the name of the file that profiling information is written to.
+   */
+  public String getProfilingFile() {
+    return profilingFile;
+  }
+
+  /**
+   * Set the name of the file that profiling information is written to.
+   */
+  public void setProfilingFile(String profilingFile) {
+    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.
+   */
+  public AutoTuneMode getMode() {
+    return mode;
+  }
+
+  /**
+   * Set the mode used when autoTune has not been explicit defined on a query.
+   */
+  public void setMode(AutoTuneMode mode) {
+    this.mode = mode;
+  }
+
+  /**
+   * Return true if the queries are being tuned.
+   */
+  public boolean isQueryTuning() {
+    return queryTuning;
+  }
+
+  /**
+   * Set to true if the queries should be tuned by autoTune.
+   */
+  public void setQueryTuning(boolean queryTuning) {
+    this.queryTuning = queryTuning;
+  }
+
+  /**
+   * Return true if the version property should be added when the query is
+   * tuned.
+   * <p>
+   * If this is false then the version property will be added when profiling
+   * detects that the bean is possibly going to be modified.
+   * </p>
+   */
+  public boolean isQueryTuningAddVersion() {
+    return queryTuningAddVersion;
+  }
+
+  /**
+   * Set to true to force the version property to be always added by the query
+   * tuning.
+   * <p>
+   * If this is false then the version property will be added when profiling
+   * detects that the bean is possibly going to be modified.
+   * </p>
+   * <p>
+   * Generally this is not expected to be turned on.
+   * </p>
+   */
+  public void setQueryTuningAddVersion(boolean queryTuningAddVersion) {
+    this.queryTuningAddVersion = queryTuningAddVersion;
+  }
+
+  /**
+   * Return true if profiling information should be collected.
+   */
+  public boolean isProfiling() {
+    return profiling;
+  }
+
+  /**
+   * Set to true if profiling information should be collected.
+   * <p>
+   * The profiling information is collected and then used to generate the tuned
+   * queries for autoTune.
+   * </p>
+   */
+  public void setProfiling(boolean profiling) {
+    this.profiling = profiling;
+  }
+
+  /**
+   * Return the base number of queries to profile before changing to profile
+   * only a percentage of following queries (profileRate).
+   */
+  public int getProfilingBase() {
+    return profilingBase;
+  }
+
+  /**
+   * Set the based number of queries to profile.
+   */
+  public void setProfilingBase(int profilingBase) {
+    this.profilingBase = profilingBase;
+  }
+
+  /**
+   * Return the rate (%) of queries to be profiled after the 'base' amount of
+   * profiling.
+   */
+  public double getProfilingRate() {
+    return profilingRate;
+  }
+
+  /**
+   * Set the rate (%) of queries to be profiled after the 'base' amount of
+   * profiling.
+   */
+  public void setProfilingRate(double profilingRate) {
+    this.profilingRate = profilingRate;
+  }
+
+  /**
+   * Return the time in millis to wait after a system gc to collect profiling
+   * information.
+   * <p>
+   * The profiling information is collected on object finalise. As such we
+   * generally don't want to trigger GC (let the JVM do its thing) but on
+   * shutdown the autoTune manager will trigger System.gc() and then wait
+   * (default 100 millis) to hopefully collect profiling information -
+   * especially for short run unit tests.
+   * </p>
+   */
+  public int getGarbageCollectionWait() {
+    return garbageCollectionWait;
+  }
+
+  /**
+   * Set the time in millis to wait after a System.gc() to collect profiling information.
+   */
+  public void setGarbageCollectionWait(int garbageCollectionWait) {
+    this.garbageCollectionWait = garbageCollectionWait;
+  }
+
+  /**
+   * 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 isSkipGarbageCollectionOnShutdown() {
+    return skipGarbageCollectionOnShutdown;
+  }
+
+  /**
+   * 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 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;
+  }
+
+  /**
+   * Load the settings from the properties file.
+   */
+  public void loadSettings(PropertiesWrapper p) {
+
+    queryTuning = p.getBoolean("autoTune.queryTuning", queryTuning);
+    queryTuningAddVersion = p.getBoolean("autoTune.queryTuningAddVersion", queryTuningAddVersion);
+    queryTuningFile = p.get("autoTune.queryTuningFile", queryTuningFile);
+
+    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/AutoTuneMode.java

@@ -0,0 +1,32 @@
+package com.avaje.ebean.config;
+
+import com.avaje.ebean.Query;
+
+/**
+ * The mode for determining if AutoTune will be used for a given query when
+ * {@link Query#setAutoTune(boolean)} has not been explicitly set on a query.
+ * <p>
+ * The explicit control of {@link Query#setAutoTune(boolean)} will always take
+ * precedence. This mode is used when this has not been explicitly set on a
+ * query.
+ * </p>
+ */
+public enum AutoTuneMode {
+
+  /**
+   * Don't implicitly use AutoTune. Must explicitly turn it on.
+   */
+  DEFAULT_OFF,
+
+  /**
+   * Use AutoTune implicitly. Must explicitly turn it off.
+   */
+  DEFAULT_ON,
+
+  /**
+   * Implicitly use AutoTune if the query has not got either select() or join()
+   * defined.
+   */
+  DEFAULT_ONIFEMPTY
+
+}

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

@@ -1,245 +0,0 @@
-package com.avaje.ebean.config;
-
-/**
- * Defines the Autofetch behaviour for a EbeanServer.
- */
-public class AutofetchConfig {
-
-  private AutofetchMode mode = AutofetchMode.DEFAULT_ONIFEMPTY;
-
-  private boolean queryTuning = false;
-
-  private boolean queryTuningAddVersion = false;
-
-  private boolean profiling = false;
-
-  private int profilingMin = 1;
-
-  private int profilingBase = 10;
-
-  private double profilingRate = 0.05;
-
-  private String logDirectory;
-
-  private int profileUpdateFrequency = 60;
-
-  private int garbageCollectionWait = 100;
-  
-  private boolean garbageCollectionOnShutdown;
-
-  public AutofetchConfig() {
-  }
-
-  /**
-   * Return the mode used when autofetch has not been explicit defined on a
-   * query.
-   */
-  public AutofetchMode getMode() {
-    return mode;
-  }
-
-  /**
-   * Set the mode used when autofetch has not been explicit defined on a query.
-   */
-  public void setMode(AutofetchMode mode) {
-    this.mode = mode;
-  }
-
-  /**
-   * Return true if the queries are being tuned.
-   */
-  public boolean isQueryTuning() {
-    return queryTuning;
-  }
-
-  /**
-   * Set to true if the queries should be tuned by autofetch.
-   */
-  public void setQueryTuning(boolean queryTuning) {
-    this.queryTuning = queryTuning;
-  }
-
-  /**
-   * Return true if the version property should be added when the query is
-   * tuned.
-   * <p>
-   * If this is false then the version property will be added when profiling
-   * detects that the bean is possibly going to be modified.
-   * </p>
-   */
-  public boolean isQueryTuningAddVersion() {
-    return queryTuningAddVersion;
-  }
-
-  /**
-   * Set to true to force the version property to be always added by the query
-   * tuning.
-   * <p>
-   * If this is false then the version property will be added when profiling
-   * detects that the bean is possibly going to be modified.
-   * </p>
-   */
-  public void setQueryTuningAddVersion(boolean queryTuningAddVersion) {
-    this.queryTuningAddVersion = queryTuningAddVersion;
-  }
-
-  /**
-   * Return true if profiling information should be collected.
-   */
-  public boolean isProfiling() {
-    return profiling;
-  }
-
-  /**
-   * Set to true if profiling information should be collected.
-   * <p>
-   * The profiling information is collected and then used to generate the tuned
-   * queries for autofetch.
-   * </p>
-   */
-  public void setProfiling(boolean profiling) {
-    this.profiling = profiling;
-  }
-
-  /**
-   * Return the minimum number of queries to profile before autofetch will start
-   * tuning the queries.
-   */
-  public int getProfilingMin() {
-    return profilingMin;
-  }
-
-  /**
-   * Set the minimum number of queries to profile before autofetch will start
-   * tuning the queries.
-   */
-  public void setProfilingMin(int profilingMin) {
-    this.profilingMin = profilingMin;
-  }
-
-  /**
-   * Return the base number of queries to profile before changing to profile
-   * only a percentage of following queries (profileRate).
-   */
-  public int getProfilingBase() {
-    return profilingBase;
-  }
-
-  /**
-   * Set the based number of queries to profile.
-   */
-  public void setProfilingBase(int profilingBase) {
-    this.profilingBase = profilingBase;
-  }
-
-  /**
-   * Return the rate (%) of queries to be profiled after the 'base' amount of
-   * profiling.
-   */
-  public double getProfilingRate() {
-    return profilingRate;
-  }
-
-  /**
-   * Set the rate (%) of queries to be profiled after the 'base' amount of
-   * profiling.
-   */
-  public void setProfilingRate(double profilingRate) {
-    this.profilingRate = profilingRate;
-  }
-
-  /**
-   * Return the log directory to put the autofetch log.
-   */
-  public String getLogDirectory() {
-    return logDirectory;
-  }
-
-  /**
-   * Set the directory to put the autofetch log in.
-   */
-  public void setLogDirectory(String logDirectory) {
-    this.logDirectory = logDirectory;
-  }
-
-  /**
-   * Return the frequency in seconds to update the autofetch tuned queries from
-   * the profiled information.
-   */
-  public int getProfileUpdateFrequency() {
-    return profileUpdateFrequency;
-  }
-
-  /**
-   * Set the frequency in seconds to update the autofetch tuned queries from the
-   * profiled information.
-   */
-  public void setProfileUpdateFrequency(int profileUpdateFrequency) {
-    this.profileUpdateFrequency = profileUpdateFrequency;
-  }
-
-  /**
-   * Return the time in millis to wait after a system gc to collect profiling
-   * information.
-   * <p>
-   * The profiling information is collected on object finalise. As such we
-   * generally don't want to trigger GC (let the JVM do its thing) but on
-   * shutdown the autofetch manager will trigger System.gc() and then wait
-   * (default 100 millis) to hopefully collect profiling information -
-   * especially for short run unit tests.
-   * </p>
-   */
-  public int getGarbageCollectionWait() {
-    return garbageCollectionWait;
-  }
-
-  /**
-   * Set the time in millis to wait after a System.gc() to collect profiling
-   * information.
-   */
-  public void setGarbageCollectionWait(int garbageCollectionWait) {
-    this.garbageCollectionWait = garbageCollectionWait;
-  }
-
-  
-  /**
-   * Return true if GC should be trigger on shutdown.
-   * <p>
-   * Autofetch profiling information is collected as part of garbage collection. 
-   * </p>
-   */
-  public boolean isGarbageCollectionOnShutdown() {
-    return garbageCollectionOnShutdown;
-  }
-
-  /**
-   * Set to true if you want GC to trigger on shutdown.
-   * <p>
-   *  This would be done if you want to try and collect Autofetch profiling information
-   *  on shutdown.
-   * </p>
-   */
-  public void setGarbageCollectionOnShutdown(boolean garbageCollectionOnShutdown) {
-    this.garbageCollectionOnShutdown = garbageCollectionOnShutdown;
-  }
-
-  /**
-   * Load the settings from the properties file.
-   */
-  public void loadSettings(PropertiesWrapper p) {
-
-    logDirectory = p.get("autofetch.logDirectory", logDirectory);
-    queryTuning = p.getBoolean("autofetch.querytuning", queryTuning);
-    queryTuningAddVersion = p.getBoolean("autofetch.queryTuningAddVersion", queryTuningAddVersion);
-    garbageCollectionOnShutdown = p.getBoolean("autofetch.garbageCollectionOnShutdown", garbageCollectionOnShutdown);
-    
-    profiling = p.getBoolean("autofetch.profiling", profiling);
-    mode = p.getEnum(AutofetchMode.class, "autofetch.implicitmode", mode);
-
-    profilingMin = p.getInt("autofetch.profiling.min", profilingMin);
-    profilingBase = p.getInt("autofetch.profiling.base", profilingBase);
-
-    profilingRate = p.getDouble("autofetch.profiling.rate", profilingRate);
-    profileUpdateFrequency = p.getInt("autofetch.profiling.updatefrequency", profileUpdateFrequency);
-  }
-}

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

@@ -1,32 +0,0 @@
-package com.avaje.ebean.config;
-
-import com.avaje.ebean.Query;
-
-/**
- * The mode for determining if Autofetch will be used for a given query when
- * {@link Query#setAutofetch(boolean)} has not been explicitly set on a query.
- * <p>
- * The explicit control of {@link Query#setAutofetch(boolean)} will always take
- * precedence. This mode is used when this has not been explicitly set on a
- * query.
- * </p>
- */
-public enum AutofetchMode {
-
-  /**
-   * Don't implicitly use Autofetch. Must explicitly turn it on.
-   */
-  DEFAULT_OFF,
-
-  /**
-   * Use Autofetch implicitly. Must explicitly turn it off.
-   */
-  DEFAULT_ON,
-
-  /**
-   * Implicitly use Autofetch if the query has not got either select() or join()
-   * defined.
-   */
-  DEFAULT_ONIFEMPTY
-
-}

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

@@ -45,13 +45,29 @@ public class DbConstraintNaming {
   protected String ckPrefix = "ck_";
   protected String ckSuffix = "";
 
-  protected boolean lowerCaseNames = true;
-
   protected MaxLength maxLength;
 
-  protected DbConstraintNormalise normalise = new DbConstraintNormalise();
+  protected DbConstraintNormalise normalise;
 
+  /**
+   * Construct using default of lower case for both table and column names.
+   */
   public DbConstraintNaming() {
+    this(true, true);
+  }
+
+  /**
+   * Construct specifying if lower case should be used (for both table and column names).
+   */
+  public DbConstraintNaming(boolean lowerCase) {
+    this(lowerCase, lowerCase);
+  }
+
+  /**
+   * Construct specifying if lower case should be used for both table and column names.
+   */
+  public DbConstraintNaming(boolean lowerCaseTableNames, boolean lowerCaseColumnNames) {
+    this.normalise = new DbConstraintNormalise(lowerCaseTableNames, lowerCaseColumnNames);
   }
 
   /**
@@ -167,7 +183,6 @@ public class DbConstraintNaming {
    * quoted identifier characters (",',[,] etc).
    */
   public String normaliseTable(String tableName) {
-
     return normalise.normaliseTable(tableName);
   }
 
@@ -175,18 +190,20 @@ public class DbConstraintNaming {
    * Normalise the column name by removing any quoted identifier characters (",',[,] etc).
    */
   public String normaliseColumn(String tableName) {
-
     return normalise.normaliseColumn(tableName);
   }
 
   /**
-   * Lower case the table or column name checking for quoted identifiers.
+   * Lower case the table name checking for quoted identifiers.
    */
-  public String lowerName(String tableName) {
-    if (lowerCaseNames && normalise.notQuoted(tableName)) {
-      return tableName.toLowerCase();
-    }
-    return tableName;
+  public String lowerTableName(String tableName) {
+    return normalise.lowerTableName(tableName);
   }
 
+  /**
+   * Lower case the column name checking for quoted identifiers.
+   */
+  public String lowerColumnName(String name) {
+    return normalise.lowerColumnName(name);
+  }
 }

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

@@ -8,11 +8,17 @@ public class DbConstraintNormalise {
 
   protected final String[] quotedIdentifiers;
 
-  protected boolean lowerCaseTables = true;
+  protected final boolean lowerCaseTables;
 
-  protected boolean lowerCaseColumns = true;
+  protected final boolean lowerCaseColumns;
 
   public DbConstraintNormalise() {
+    this(true, true);
+  }
+
+  public DbConstraintNormalise(boolean lowerCaseTables, boolean lowerCaseColumns) {
+    this.lowerCaseTables = lowerCaseTables;
+    this.lowerCaseColumns = lowerCaseColumns;
     this.quotedIdentifiers = new String[]{"\"", "'", "[", "]", "`"};
   }
 
@@ -46,6 +52,26 @@ public class DbConstraintNormalise {
     return columnName;
   }
 
+  /**
+   * Lower case the table name checking for quoted identifiers.
+   */
+  public String lowerTableName(String tableName) {
+    if (lowerCaseTables && notQuoted(tableName)) {
+      return tableName.toLowerCase();
+    }
+    return tableName;
+  }
+
+  /**
+   * Lower case the column name checking for quoted identifiers.
+   */
+  public String lowerColumnName(String name) {
+    if (lowerCaseColumns && notQuoted(name)) {
+      return name.toLowerCase();
+    }
+    return name;
+  }
+
   /**
    * Trim off the platform quoted identifier quotes like [ ' and ".
    */

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

@@ -1,39 +1,324 @@
 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;
+
+  /**
+   * 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";
+
+  protected String applySuffix = ".sql";
+
+  protected String modelSuffix = ".model.xml";
+
+  protected boolean includeGeneratedFileComment;
+
+  /**
+   * The version of a pending drop that should be generated as the next migration.
+   */
+  protected String generatePendingDrop;
+
+  /**
+   * 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 model suffix (defaults to model.xml)
+   */
+  public String getModelSuffix() {
+    return modelSuffix;
+  }
+
+  /**
+   * Set the model suffix.
+   */
+  public void setModelSuffix(String modelSuffix) {
+    this.modelSuffix = modelSuffix;
+  }
+
+  /**
+   * 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 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;
+  }
+
+  /**
+   * Return the migration version (or "next") to generate pending drops for.
+   */
+  public String getGeneratePendingDrop() {
+    return generatePendingDrop;
+  }
+
+  /**
+   * Set the migration version (or "next") to generate pending drops for.
+   */
+  public void setGeneratePendingDrop(String generatePendingDrop) {
+    this.generatePendingDrop = generatePendingDrop;
+  }
+
+  /**
+   * 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.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);
+    }
+    applySuffix = properties.get("migration.applySuffix", applySuffix);
+    modelSuffix = properties.get("migration.modelSuffix", modelSuffix);
+    includeGeneratedFileComment = properties.getBoolean("migration.includeGeneratedFileComment", includeGeneratedFileComment);
+    generatePendingDrop = properties.get("migration.generatePendingDrop", generatePendingDrop);
+
+    platform = properties.getEnum(DbPlatformName.class, "migration.platform", platform);
+
+    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/PropertyMap.java

@@ -18,6 +18,14 @@ public final class PropertyMap implements Serializable {
 
   private final LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
 
+  /**
+   * Return properties loaded from test-ebean.properties.
+   */
+  public static Properties testProperties() {
+    PropertyMap propertyMap = PropertyMapLoader.loadTestProperties();
+    return (propertyMap == null) ? new Properties() : propertyMap.asProperties();
+  }
+
   public static Properties defaultProperties() {
     PropertyMap propertyMap = PropertyMapLoader.loadGlobalProperties();
     return (propertyMap == null) ? new Properties() : propertyMap.asProperties();

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

@@ -14,17 +14,34 @@ final class PropertyMapLoader {
 
   private static final Logger logger = LoggerFactory.getLogger(PropertyMapLoader.class);
 
+  /**
+   * Load the <code>test-ebean.properties</code>.
+   */
+  public static PropertyMap loadTestProperties() {
+    return load(null, "test-ebean.properties");
+  }
+
+  /**
+   * Load the ebean.properties (and test-ebean.properties if present).
+   */
   public static PropertyMap loadGlobalProperties() {
 
+    boolean loadTestProperties = false;
     String fileName = System.getenv("EBEAN_PROPS_FILE");
     if (fileName == null) {
       fileName = System.getProperty("ebean.props.file");
       if (fileName == null) {
+        loadTestProperties = true;
         fileName = "ebean.properties";
       }
     }
 
-    return load(null, fileName);
+    PropertyMap map = load(null, fileName);
+    if (loadTestProperties) {
+      // load test properties if present in classpath
+      map = load(map, "test-ebean.properties");
+    }
+    return map;
   }
 
   /**
@@ -39,7 +56,6 @@ final class PropertyMapLoader {
 
     InputStream is = findInputStream(fileName);
     if (is == null) {
-      logger.error(fileName + " not found");
       return p;
     } else {
       return load(p, is);
@@ -47,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,12 +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;
@@ -128,9 +136,9 @@ public class ServerConfig {
   private CurrentUserProvider currentUserProvider;
 
   /** 
-   * Config controlling the autofetch behaviour.
+   * Config controlling the AutoTune behaviour.
    */
-  private AutofetchConfig autofetchConfig = new AutofetchConfig();
+  private AutoTuneConfig autoTuneConfig = new AutoTuneConfig();
 
   /**
    * The JSON format used for DateTime types. Default to millis.
@@ -204,6 +212,12 @@ public class ServerConfig {
 
   private boolean ddlRun;
 
+  private boolean ddlCreateOnly;
+
+  private String ddlInitSql;
+
+  private String ddlSeedSql;
+
   private boolean useJtaTransactionManager;
 
   /**
@@ -226,13 +240,23 @@ 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>
    * Indicates that Ebean should use autoCommit friendly Transactions and TransactionManager.
    */
   private boolean autoCommitMode;
-  
+
+  /**
+   * Set to true if transaction begin should be started with explicit statement.
+   */
+  private boolean explicitTransactionBeginMode;
+
   /** 
    * The data source JNDI name if using a JNDI DataSource. 
    */
@@ -274,9 +298,9 @@ public class ServerConfig {
   private boolean updatesDeleteMissingChildren = true;
   
   /**
-   * Setting to indicate if UUID should be stored as binary(16) or varchar(40).
+   * Setting to indicate if UUID should be stored as binary(16) or varchar(40) or native DB type (for H2 and Postgres).
    */
-  private boolean uuidStoreAsBinary;
+  private DbUuid dbUuid = DbUuid.AUTO;
 
 
   private List<BeanFindController> findControllers = new ArrayList<BeanFindController>();
@@ -299,6 +323,10 @@ public class ServerConfig {
 
   private ChangeLogRegister changeLogRegister;
 
+  private ReadAuditLogger readAuditLogger;
+
+  private ReadAuditPrepare readAuditPrepare;
+
   private EncryptKeyManager encryptKeyManager;
 
   private EncryptDeployManager encryptDeployManager;
@@ -353,13 +381,14 @@ public class ServerConfig {
   private int queryCacheMaxIdleTime = 600;
   private int queryCacheMaxTimeToLive = 60*60*6;
   private Object objectMapper;
-  private boolean diffFlatMode = true;
 
   /**
    * Set to true if you want eq("someProperty", null) to generate 1=1 rather than "is null" sql expression.
    */
   private boolean expressionEqualsWithNullAsNoop;
 
+  private String jodaLocalTimeMode;
+
   /**
    * Construct a Server Configuration for programmatically creating an EbeanServer.
    */
@@ -725,6 +754,41 @@ public class ServerConfig {
     this.changeLogIncludeInserts = changeLogIncludeInserts;
   }
 
+  /**
+   * Return the ReadAuditLogger to use.
+   */
+  public ReadAuditLogger getReadAuditLogger() {
+    return readAuditLogger;
+  }
+
+  /**
+   * Set the ReadAuditLogger to use. If not set the default implementation is used
+   * which logs the read events in JSON format to a standard named SLF4J logger
+   * (which can be configured in say logback to log to a separate log file).
+   */
+  public void setReadAuditLogger(ReadAuditLogger readAuditLogger) {
+    this.readAuditLogger = readAuditLogger;
+  }
+
+  /**
+   * Return the ReadAuditPrepare to use.
+   */
+  public ReadAuditPrepare getReadAuditPrepare() {
+    return readAuditPrepare;
+  }
+
+  /**
+   * Set the ReadAuditPrepare to use.
+   * <p>
+   * It is expected that an implementation is used that read user context information
+   * (user id, user ip address etc) and sets it on the ReadEvent bean before it is sent
+   * to the ReadAuditLogger.
+   * </p>
+   */
+  public void setReadAuditPrepare(ReadAuditPrepare readAuditPrepare) {
+    this.readAuditPrepare = readAuditPrepare;
+  }
+
   /**
    * Return the DB migration configuration.
    */
@@ -1104,17 +1168,17 @@ public class ServerConfig {
   }
 
   /**
-   * Return the configuration for the Autofetch feature.
+   * Return the configuration for AutoTune.
    */
-  public AutofetchConfig getAutofetchConfig() {
-    return autofetchConfig;
+  public AutoTuneConfig getAutoTuneConfig() {
+    return autoTuneConfig;
   }
 
   /**
-   * Set the configuration for the Autofetch feature.
+   * Set the configuration for AutoTune.
    */
-  public void setAutofetchConfig(AutofetchConfig autofetchConfig) {
-    this.autofetchConfig = autofetchConfig;
+  public void setAutoTuneConfig(AutoTuneConfig autoTuneConfig) {
+    this.autoTuneConfig = autoTuneConfig;
   }
 
   /**
@@ -1180,6 +1244,28 @@ public class ServerConfig {
     this.autoCommitMode = autoCommitMode;
   }
 
+  /**
+   * Return true if transaction begin should be started with explicit statement.
+   */
+  public boolean isExplicitTransactionBeginMode() {
+    return explicitTransactionBeginMode;
+  }
+
+  /**
+   * Set to true if transaction begin should be started with explicit statement.
+   * <p>
+   * This works for H2 and Postgres but not for Oracle - only use this if you first name
+   * is Daryl or you have explicitly talked to Rob about this feature.
+   * </p>
+   * <p>
+   * This is generally not expected to be turned on but instead allow transactions to start
+   * implicitly which is generally the standard approach.
+   * </p>
+   */
+  public void setExplicitTransactionBeginMode(boolean explicitTransactionBeginMode) {
+    this.explicitTransactionBeginMode = explicitTransactionBeginMode;
+  }
+
   /**
    * Return a value used to represent TRUE in the database.
    * <p>
@@ -1399,19 +1485,18 @@ public class ServerConfig {
     this.dbEncrypt = dbEncrypt;
   }
 
-  
   /**
-   * Return true if UUID should be stored as binary(16) (as opposed to varchar(40)).
+   * Return the DB type used to store UUID.
    */
-  public boolean isUuidStoreAsBinary() {
-    return uuidStoreAsBinary;
+  public DbUuid getDbUuid() {
+    return dbUuid;
   }
 
   /**
-   * Set to true if UUID should be stored as binary(16) (as opposed to varchar(40)).
+   * Set the DB type used to store UUID.
    */
-  public void setUuidStoreAsBinary(boolean uuidStoreAsBinary) {
-    this.uuidStoreAsBinary = uuidStoreAsBinary;
+  public void setDbUuid(DbUuid dbUuid) {
+    this.dbUuid = dbUuid;
   }
 
   /**
@@ -1452,19 +1537,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.
    */
@@ -1495,6 +1642,20 @@ public class ServerConfig {
     this.disableClasspathSearch = disableClasspathSearch;
   }
 
+  /**
+   * Return the mode to use for Joda LocalTime support 'normal' or 'utc'.
+   */
+  public String getJodaLocalTimeMode() {
+    return jodaLocalTimeMode;
+  }
+
+  /**
+   * Set the mode to use for Joda LocalTime support 'normal' or 'utc'.
+   */
+  public void setJodaLocalTimeMode(String jodaLocalTimeMode) {
+    this.jodaLocalTimeMode = jodaLocalTimeMode;
+  }
+
   /**
    * Programmatically add classes (typically entities) that this server should
    * use.
@@ -1957,6 +2118,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.
    */
@@ -1974,6 +2151,21 @@ public class ServerConfig {
     loadSettings(p);
   }
 
+  /**
+   * Load settings from test-ebean.properties and do nothing if the properties is not found.
+   * <p>
+   * This is typically used when test-ebean.properties is put into the test class path and used
+   * to configure Ebean for running tests.
+   * </p>
+   */
+  public void loadTestProperties() {
+    Properties properties = PropertyMap.testProperties();
+    if (!properties.isEmpty()) {
+      PropertiesWrapper p = new PropertiesWrapper("ebean", name, properties);
+      loadSettings(p);
+    }
+  }
+
   /**
    * Return the properties that we used for configuration and were set via a call to loadFromProperties().
    */
@@ -1981,11 +2173,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) {
+  protected  <T> T createInstance(PropertiesWrapper properties, Class<T> pluginType, String key, T instance) {
 
-    String classname = p.get(key, null);
-    return classname == null ? null : (T) ClassUtil.newInstance(classname);
+    if (instance != null) {
+      return instance;
+    }
+    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);
   }
 
   /**
@@ -2002,8 +2214,8 @@ public class ServerConfig {
   /**
    * This is broken out for the same reason as above - preserve existing behaviour but let it be overridden.
    */
-  protected void loadAutofetchSettings(PropertiesWrapper p) {
-    autofetchConfig.loadSettings(p);
+  protected void loadAutoTuneSettings(PropertiesWrapper p) {
+    autoTuneConfig.loadSettings(p);
   }
 
   /**
@@ -2017,28 +2229,29 @@ public class ServerConfig {
     if (namingConvention != null) {
       namingConvention.loadFromProperties(p);
     }
-    if (autofetchConfig == null) {
-      autofetchConfig = new AutofetchConfig();
+    if (autoTuneConfig == null) {
+      autoTuneConfig = new AutoTuneConfig();
     }
-    loadAutofetchSettings(p);
+    loadAutoTuneSettings(p);
 
     if (dataSourceConfig == null) {
       dataSourceConfig = new DataSourceConfig();
     }
     loadDataSourceSettings(p);
 
+    explicitTransactionBeginMode = p.getBoolean("explicitTransactionBeginMode", explicitTransactionBeginMode);
     autoCommitMode = p.getBoolean("autoCommitMode", autoCommitMode);
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
 
-    currentUserProvider = createInstance(p, CurrentUserProvider.class, "currentUserProvider");
     disableClasspathSearch = p.getBoolean("disableClasspathSearch", disableClasspathSearch);
-    databasePlatform = createInstance(p, DatabasePlatform.class, "databasePlatform");
-    encryptKeyManager = createInstance(p, EncryptKeyManager.class, "encryptKeyManager");
-    encryptDeployManager = createInstance(p, EncryptDeployManager.class, "encryptDeployManager");
-    encryptor = createInstance(p, Encryptor.class, "encryptor");
-    dbEncrypt = createInstance(p, DbEncrypt.class, "dbEncrypt");
-    serverCacheFactory = createInstance(p, ServerCacheFactory.class, "serverCacheFactory");
-    serverCacheManager = createInstance(p, ServerCacheManager.class, "serverCacheManager");
+    currentUserProvider = createInstance(p, CurrentUserProvider.class, "currentUserProvider", currentUserProvider);
+    databasePlatform = createInstance(p, DatabasePlatform.class, "databasePlatform", databasePlatform);
+    encryptKeyManager = createInstance(p, EncryptKeyManager.class, "encryptKeyManager", encryptKeyManager);
+    encryptDeployManager = createInstance(p, EncryptDeployManager.class, "encryptDeployManager", encryptDeployManager);
+    encryptor = createInstance(p, Encryptor.class, "encryptor", encryptor);
+    dbEncrypt = createInstance(p, DbEncrypt.class, "dbEncrypt", dbEncrypt);
+    serverCacheFactory = createInstance(p, ServerCacheFactory.class, "serverCacheFactory", serverCacheFactory);
+    serverCacheManager = createInstance(p, ServerCacheManager.class, "serverCacheManager", serverCacheManager);
     cacheWarmingDelay = p.getInt("cacheWarmingDelay", cacheWarmingDelay);
     classPathReaderClassName = p.get("classpathreader");
     
@@ -2075,7 +2288,7 @@ public class ServerConfig {
 
     changeLogIncludeInserts = p.getBoolean("changeLogIncludeInserts", changeLogIncludeInserts);
     expressionEqualsWithNullAsNoop = p.getBoolean("expressionEqualsWithNullAsNoop", expressionEqualsWithNullAsNoop);
-    diffFlatMode = p.getBoolean("diffFlatMode", diffFlatMode);
+
     asOfViewSuffix = p.get("asOfViewSuffix", asOfViewSuffix);
     asOfSysPeriod = p.get("asOfSysPeriod", asOfSysPeriod);
     historyTableSuffix = p.get("historyTableSuffix", historyTableSuffix);
@@ -2084,8 +2297,12 @@ public class ServerConfig {
     databaseBooleanTrue = p.get("databaseBooleanTrue", databaseBooleanTrue);
     databaseBooleanFalse = p.get("databaseBooleanFalse", databaseBooleanFalse);
     databasePlatformName = p.get("databasePlatformName", databasePlatformName);
-    uuidStoreAsBinary = p.getBoolean("uuidStoreAsBinary", uuidStoreAsBinary);
+    dbUuid = p.getEnum(DbUuid.class, "dbuuid", dbUuid);
+    if (p.getBoolean("uuidStoreAsBinary", false)) {
+      dbUuid = DbUuid.BINARY;
+    }
     localTimeWithNanos = p.getBoolean("localTimeWithNanos", localTimeWithNanos);
+    jodaLocalTimeMode = p.get("jodaLocalTimeMode", jodaLocalTimeMode);
 
     lazyLoadBatchSize = p.getInt("lazyLoadBatchSize", lazyLoadBatchSize);
     queryBatchSize = p.getInt("queryBatchSize", queryBatchSize);
@@ -2100,13 +2317,16 @@ 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);
   }
 
   private NamingConvention createNamingConvention(PropertiesWrapper properties, NamingConvention namingConvention) {
 
-    NamingConvention nc = createInstance(properties, NamingConvention.class, "namingconvention");
+    NamingConvention nc = createInstance(properties, NamingConvention.class, "namingconvention", null);
     return (nc != null) ? nc : namingConvention;
   }
 
@@ -2188,22 +2408,6 @@ public class ServerConfig {
     this.objectMapper = objectMapper;
   }
 
-  /**
-   * Return true if diff should return flat properties with dot notation rather than
-   * embedded beans or reference beans (when the associated bean id is different).
-   */
-  public boolean isDiffFlatMode() {
-    return diffFlatMode;
-  }
-
-  /**
-   * Set to true if diff should return flat properties with dot notation rather than
-   * embedded beans or reference beans (when the associated bean id is different).
-   */
-  public void setDiffFlatMode(boolean diffFlatMode) {
-    this.diffFlatMode = diffFlatMode;
-  }
-
   /**
    * Return true if eq("someProperty", null) should to generate "1=1" rather than "is null" sql expression.
    */
@@ -2222,4 +2426,25 @@ public class ServerConfig {
   public void setExpressionEqualsWithNullAsNoop(boolean expressionEqualsWithNullAsNoop) {
     this.expressionEqualsWithNullAsNoop = expressionEqualsWithNullAsNoop;
   }
+
+  /**
+   * Specify how UUID is stored.
+   */
+  public enum DbUuid {
+
+    /**
+     * Store using native UUID in H2 and Postgres.
+     */
+    AUTO,
+
+    /**
+     * Store using DB VARCHAR.
+     */
+    VARCHAR,
+
+    /**
+     * Store using DB BINARY.
+     */
+    BINARY
+  }
 }

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/config/dbplatform/DatabasePlatform.java

@@ -1,18 +1,16 @@
 package com.avaje.ebean.config.dbplatform;
 
-import java.sql.Types;
-
-import javax.sql.DataSource;
-
 import com.avaje.ebean.BackgroundExecutor;
 import com.avaje.ebean.Query;
-
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
 import com.avaje.ebean.dbmigration.ddlgeneration.platform.PlatformDdl;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.sql.DataSource;
+import java.sql.Types;
+
 /**
  * Database platform specific settings.
  */
@@ -54,28 +52,33 @@ public class DatabasePlatform {
    */
   protected OnQueryOnly onQueryOnly = OnQueryOnly.ROLLBACK;
 
-  /** 
-   * The open quote used by quoted identifiers. 
+  /**
+   * The open quote used by quoted identifiers.
    */
   protected String openQuote = "\"";
 
   /**
-   *  The close quote used by quoted identifiers. 
+   * The close quote used by quoted identifiers.
    */
   protected String closeQuote = "\"";
 
-  /** 
-   * For limit/offset, row_number etc limiting of SQL queries. 
+  /**
+   * For limit/offset, row_number etc limiting of SQL queries.
    */
   protected SqlLimiter sqlLimiter = new LimitOffsetSqlLimiter();
 
-  /** 
-   * Mapping of JDBC to Database types. 
+  /**
+   * Mapping of JDBC to Database types.
    */
   protected DbTypeMap dbTypeMap = new DbTypeMap();
 
   /**
-   * Defines DB identity/sequence features. 
+   * Set to true if the DB has native UUID type support.
+   */
+  protected boolean nativeUuidType;
+
+  /**
+   * Defines DB identity/sequence features.
    */
   protected DbIdentity dbIdentity = new DbIdentity();
 
@@ -84,28 +87,28 @@ public class DatabasePlatform {
    */
   protected DbHistorySupport historySupport;
 
-  /** 
-   * The JDBC type to map booleans to (by default). 
+  /**
+   * The JDBC type to map booleans to (by default).
    */
   protected int booleanDbType = Types.BOOLEAN;
 
-  /** 
-   * The JDBC type to map Blob to. 
+  /**
+   * The JDBC type to map Blob to.
    */
   protected int blobDbType = Types.BLOB;
 
-  /** 
-   * The JDBC type to map Clob to. 
+  /**
+   * The JDBC type to map Clob to.
    */
   protected int clobDbType = Types.CLOB;
 
-  /** 
-   * For Oracle treat empty strings as null. 
+  /**
+   * For Oracle treat empty strings as null.
    */
   protected boolean treatEmptyStringsAsNull;
 
-  /** 
-   * The database platform name. 
+  /**
+   * The database platform name.
    */
   protected String name = "generic";
 
@@ -124,7 +127,7 @@ public class DatabasePlatform {
    * The like clause. Can be overridden to disable default escape character.
    */
   protected String likeClause = "like ?";
-  
+
   protected DbEncrypt dbEncrypt;
 
   protected boolean idInExpandedForm;
@@ -219,16 +222,12 @@ public class DatabasePlatform {
 
   /**
    * Return a DB Sequence based IdGenerator.
-   * 
-   * @param be
-   *          the BackgroundExecutor that can be used to load the sequence if
-   *          desired
-   * @param ds
-   *          the DataSource
-   * @param seqName
-   *          the name of the sequence
-   * @param batchSize
-   *          the number of sequences that should be loaded
+   *
+   * @param be        the BackgroundExecutor that can be used to load the sequence if
+   *                  desired
+   * @param ds        the DataSource
+   * @param seqName   the name of the sequence
+   * @param batchSize the number of sequences that should be loaded
    */
   public IdGenerator createSequenceIdGenerator(BackgroundExecutor be, DataSource ds, String seqName, int batchSize) {
     return null;
@@ -276,9 +275,16 @@ public class DatabasePlatform {
     this.historySupport = historySupport;
   }
 
+  /**
+   * Return true if the DB supports native UUID.
+   */
+  public boolean isNativeUuidType() {
+    return nativeUuidType;
+  }
+
   /**
    * Return the mapping of JDBC to DB types.
-   * 
+   *
    * @return the db type map
    */
   public DbTypeMap getDbTypeMap() {
@@ -315,7 +321,7 @@ public class DatabasePlatform {
 
   /**
    * Return the close quote for quoted identifiers.
-   * 
+   *
    * @return the close quote
    */
   public String getCloseQuote() {
@@ -324,7 +330,7 @@ public class DatabasePlatform {
 
   /**
    * Return the open quote for quoted identifiers.
-   * 
+   *
    * @return the open quote
    */
   public String getOpenQuote() {
@@ -333,7 +339,7 @@ public class DatabasePlatform {
 
   /**
    * Return the JDBC type used to store booleans.
-   * 
+   *
    * @return the boolean db type
    */
   public int getBooleanDbType() {
@@ -363,7 +369,7 @@ public class DatabasePlatform {
 
   /**
    * Return true if empty strings should be treated as null.
-   * 
+   *
    * @return true, if checks if is treat empty strings as null
    */
   public boolean isTreatEmptyStringsAsNull() {
@@ -399,7 +405,7 @@ public class DatabasePlatform {
 
   /**
    * Return the DB identity/sequence features for this platform.
-   * 
+   *
    * @return the db identity
    */
   public DbIdentity getDbIdentity() {
@@ -412,7 +418,7 @@ public class DatabasePlatform {
    * <p>
    * Basically add the clauses for limit/offset, rownum, row_number().
    * </p>
-   * 
+   *
    * @return the sql limiter
    */
   public SqlLimiter getSqlLimiter() {
@@ -421,15 +427,12 @@ public class DatabasePlatform {
 
   /**
    * Convert backticks to the platform specific open quote and close quote
-   * 
    * <p>
    * Specific plugins may implement this method to cater for platform specific
    * naming rules.
    * </p>
-   * 
-   * @param dbName
-   *          the db name
-   * 
+   *
+   * @param dbName the db name
    * @return the string
    */
   public String convertQuotedIdentifiers(String dbName) {

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

@@ -8,6 +8,11 @@ package com.avaje.ebean.config.dbplatform;
  */
 public class DbType {
 
+  /**
+   * DB native UUID type (H2 and Postgres).
+   */
+  public static final int UUID = 5010;
+
   /**
    * Type to map Map content to Postgres HSTORE.
    */

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

@@ -49,6 +49,8 @@ public class DbTypeMap {
     lookup.put("TIME", Types.TIME);
     lookup.put("TIMESTAMP", Types.TIMESTAMP);
 
+    lookup.put("UUID", DbType.UUID);
+
     // Not standard java.sql.Types
     // logical JSON storage types
     lookup.put("JSON", DbType.JSON);
@@ -101,6 +103,9 @@ public class DbTypeMap {
     put(Types.BLOB, new DbType("blob"));
     put(Types.CLOB, new DbType("clob"));
 
+    // DB native UUID support (H2 and Postgres)
+    put(DbType.UUID, new DbType("uuid"));
+
     if (logicalTypes) {
       // keep it logical for 2 layer DDL generation
       put(DbType.HSTORE, new DbType("hstore"));

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

@@ -55,7 +55,7 @@ public abstract class DbViewHistorySupport implements DbHistorySupport {
   public String getAsOfPredicate(String asOfTableAlias, String asOfSysPeriod) {
 
     // (sys_period_start < ? and (sys_period_end is null or sys_period_end > ?));
-    return "(" + asOfTableAlias + "." + asOfSysPeriod + "_start" + " < ? and (" + asOfTableAlias + "." + asOfSysPeriod + "_end" + " is null or " + asOfTableAlias + "." + asOfSysPeriod + "_end" + " > ?))";
+    return "(" + asOfTableAlias + "." + asOfSysPeriod + "_start" + " <= ? and (" + asOfTableAlias + "." + asOfSysPeriod + "_end" + " is null or " + asOfTableAlias + "." + asOfSysPeriod + "_end" + " > ?))";
   }
 
   /**

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

@@ -0,0 +1,8 @@
+package com.avaje.ebean.config.dbplatform;
+
+/**
+ * Runtime support for @History with H2.
+ */
+public class H2HistorySupport extends DbViewHistorySupport {
+
+}

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

@@ -0,0 +1,127 @@
+package com.avaje.ebean.config.dbplatform;
+
+import org.h2.api.Trigger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * H2 database trigger used to populate history tables to support the @History feature.
+ */
+public class H2HistoryTrigger implements Trigger {
+
+  private static final Logger logger = LoggerFactory.getLogger(H2HistoryTrigger.class);
+
+  /**
+   * Hardcoding the column and history table suffix for now. Not sure how to get that
+   * configuration into the trigger instance nicely as it is instantiated by H2.
+   */
+  private static final String SYS_PERIOD_START = "SYS_PERIOD_START";
+  private static final String SYS_PERIOD_END = "SYS_PERIOD_END";
+  private static final String HISTORY_SUFFIX = "_history";
+
+  /**
+   * SQL to insert into the history table.
+   */
+  private String insertHistorySql;
+
+  /**
+   * Position of SYS_PERIOD_START column in the Object[].
+   */
+  private int effectStartPosition;
+
+  /**
+   * Position of SYS_PERIOD_END column in the Object[].
+   */
+  private int effectEndPosition;
+
+  @Override
+  public void init(Connection conn, String schemaName, String triggerName, String tableName, boolean before, int type) throws SQLException {
+
+    // get the columns for the table
+    ResultSet rs = conn.getMetaData().getColumns(null, schemaName, tableName, null);
+
+    // build the insert into history table SQL
+    StringBuilder insertSql = new StringBuilder(150);
+    insertSql.append("insert into ").append(tableName).append(HISTORY_SUFFIX).append(" (");
+
+    int count = 0;
+    List<String> columns = new ArrayList<String>();
+    while (rs.next()) {
+      if (++count > 1) {
+        insertSql.append(",");
+      }
+      String columnName = rs.getString("COLUMN_NAME");
+      if (columnName.equalsIgnoreCase(SYS_PERIOD_START)) {
+        this.effectStartPosition = count - 1;
+      } else if (columnName.equalsIgnoreCase(SYS_PERIOD_END)) {
+        this.effectEndPosition = count - 1;
+      }
+      insertSql.append(columnName);
+      columns.add(columnName);
+    }
+    insertSql.append(") values (");
+    for (int i = 0; i < count; i++) {
+      if (i > 0) {
+        insertSql.append(",");
+      }
+      insertSql.append("?");
+    }
+    insertSql.append(");");
+
+    this.insertHistorySql = insertSql.toString();
+    logger.debug("History table insert sql: {}", insertHistorySql);
+  }
+
+  @Override
+  public void fire(Connection connection, Object[] oldRow, Object[] newRow) throws SQLException {
+
+    if (oldRow != null) {
+      // a delete or update event
+      Timestamp now = new Timestamp(System.currentTimeMillis());
+      oldRow[effectEndPosition] = now;
+      if (newRow != null) {
+        // update event. Set the effective start timestamp to now.
+        newRow[effectStartPosition] = now;
+      }
+      if (logger.isDebugEnabled()) {
+        logger.debug("History insert: {}", Arrays.toString(oldRow));
+      }
+      insertIntoHistory(connection, oldRow);
+    }
+  }
+
+  /**
+   * Insert the data into the history table.
+   */
+  private void insertIntoHistory(Connection connection, Object[] oldRow) throws SQLException {
+
+    PreparedStatement stmt = connection.prepareStatement(insertHistorySql);
+    try {
+      for (int i = 0; i < oldRow.length; i++) {
+        stmt.setObject(i + 1, oldRow[i]);
+      }
+      stmt.executeUpdate();
+    } finally {
+      stmt.close();
+    }
+  }
+
+  @Override
+  public void close() throws SQLException {
+
+  }
+
+  @Override
+  public void remove() throws SQLException {
+
+  }
+}

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

@@ -15,6 +15,8 @@ public class H2Platform extends DatabasePlatform {
     this.name = "h2";
     this.dbEncrypt = new H2DbEncrypt();
     this.platformDdl = new H2Ddl(this.dbTypeMap, dbIdentity);
+    this.historySupport = new H2HistorySupport();
+    this.nativeUuidType = true;
 
     // only support getGeneratedKeys with non-batch JDBC
     // so generally use SEQUENCE instead of IDENTITY for H2

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

@@ -5,5 +5,4 @@ package com.avaje.ebean.config.dbplatform;
  */
 public class MySqlHistorySupport extends DbViewHistorySupport {
 
-
 }

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

@@ -23,10 +23,10 @@ public class PostgresPlatform extends DatabasePlatform {
     // OnQueryOnly.CLOSE as a performance optimisation on Postgres
     this.onQueryOnly = OnQueryOnly.CLOSE;
     this.likeClause = "like ? escape''";
-
     this.selectCountWithAlias = true;
     this.blobDbType = Types.LONGVARBINARY;
     this.clobDbType = Types.VARCHAR;
+    this.nativeUuidType = true;
 
     this.dbEncrypt = new PostgresDbEncrypt();
     this.historySupport = new PostgresHistorySupport();

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

@@ -20,9 +20,10 @@ import com.avaje.ebean.dbmigration.migrationreader.MigrationXmlWriter;
 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.MigrationVersion;
 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 +58,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 +81,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 +147,9 @@ public class DbMigration {
    */
   public void setPlatform(DatabasePlatform databasePlatform) {
     this.databasePlatform = databasePlatform;
-    DbOffline.setPlatform(databasePlatform.getName());
+    if (!online) {
+      DbOffline.setPlatform(databasePlatform.getName());
+    }
   }
 
   /**
@@ -175,71 +199,210 @@ 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();
+      Request request = createRequest();
 
-      logger.info("next migration version {}", nextMajorVersion);
-
-      CurrentModel currentModel = new CurrentModel(server, constraintNaming);
-      ModelContainer current = currentModel.read();
-
-      ModelDiff diff = new ModelDiff(migrated);
-      diff.compareTo(current);
-
-      if (diff.isEmpty()) {
-        logger.info("no changes detected - no migration written");
-        return;
+      String pendingVersion = generatePendingDrop();
+      if (pendingVersion != null) {
+        generatePendingDrop(request, pendingVersion);
+      } else {
+        generateDiff(request);
       }
 
+    } finally {
+      if (!online) {
+        DbOffline.reset();
+      }
+    }
+  }
+
+  /**
+   * Generate the diff migration.
+   */
+  private void generateDiff(Request request) throws IOException {
+
+    List<String> pendingDrops = request.getPendingDrops();
+    if (!pendingDrops.isEmpty()) {
+      logger.info("Pending un-applied drops in versions {}", pendingDrops);
+    }
+
+    Migration migration = request.createDiffMigration();
+    if (migration == null) {
+      logger.info("no changes detected - no migration written");
+    } else {
       // there were actually changes to write
-      Migration dbMigration = diff.getMigration();
+      generateMigration(request, migration, null);
+    }
+  }
 
-      File writePath = getWritePath();
-      logger.info("migration writing version {} to {}", nextMajorVersion, writePath.getAbsolutePath());
-      writeMigrationXml(dbMigration, writePath, nextMajorVersion);
+  /**
+   * Generate the migration based on the pendingDrops from a prior version.
+   */
+  private void generatePendingDrop(Request request, String pendingVersion) throws IOException {
 
+    Migration migration = request.migrationForPendingDrop(pendingVersion);
+
+    generateMigration(request, migration, pendingVersion);
+
+    List<String> pendingDrops = request.getPendingDrops();
+    if (!pendingDrops.isEmpty()) {
+      logger.info("... remaining pending un-applied drops in versions {}", pendingDrops);
+    }
+  }
+
+  private Request createRequest() {
+    return new Request();
+  }
+
+  private class Request {
+
+    final File migrationDir;
+    final File modelDir;
+    final MigrationModel migrationModel;
+    final CurrentModel currentModel;
+    final ModelContainer migrated;
+    final ModelContainer current;
+
+    private Request() {
+      this.migrationDir = getMigrationDirectory();
+      this.modelDir = getModelDirectory(migrationDir);
+      this.migrationModel = new MigrationModel(modelDir, migrationConfig.getModelSuffix());
+      this.migrated = migrationModel.read();
+      this.currentModel = new CurrentModel(server, constraintNaming);
+      this.current = currentModel.read();
+    }
+
+    /**
+     * Return the migration for the pending drops for a given version.
+     */
+    public Migration migrationForPendingDrop(String pendingVersion) {
+
+      Migration migration = migrated.migrationForPendingDrop(pendingVersion);
+
+      // register any remaining pending drops
+      migrated.registerPendingHistoryDropColumns(current);
+      return migration;
+    }
+
+    /**
+     * Return the list of versions that have pending un-applied drops.
+     */
+    public List<String> getPendingDrops() {
+      return migrated.getPendingDrops();
+    }
+
+    /**
+     * Create and return the diff of the current model to the migration model.
+     */
+    public Migration createDiffMigration() {
+      ModelDiff diff = new ModelDiff(migrated);
+      diff.compareTo(current);
+      return diff.isEmpty() ? null : diff.getMigration();
+    }
+  }
+
+  private void generateMigration(Request request, Migration dbMigration, String dropsFor) throws IOException {
+
+    String fullVersion = getFullVersion(request.migrationModel, dropsFor);
+
+    logger.info("generating migration:{}", fullVersion);
+    if (!writeMigrationXml(dbMigration, request.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(), currentModel.read());
-        PlatformDdlWriter writer = new PlatformDdlWriter(databasePlatform, serverConfig);
-        writer.processMigration(dbMigration, write, writePath, nextMajorVersion);
+        DdlWrite write = new DdlWrite(new MConfiguration(), request.current);
+        PlatformDdlWriter writer = createDdlWriter(databasePlatform, "");
+        writer.processMigration(dbMigration, write, request.migrationDir , fullVersion);
       }
-
-      writeExtraPlatformDdl(nextMajorVersion, currentModel, dbMigration, writePath);
-
-    } finally {
-      DbOffline.reset();
+      writeExtraPlatformDdl(fullVersion, request.currentModel, dbMigration, request.migrationDir);
     }
   }
 
+  /**
+   * Return true if the next pending drop changeSet should be generated as the next migration.
+   */
+  private String generatePendingDrop() {
+
+    String nextDrop = System.getProperty("ddl.migration.pendingDropsFor");
+    if (nextDrop != null) {
+      return nextDrop;
+    }
+    return migrationConfig.getGeneratePendingDrop();
+  }
+
+  /**
+   * Return the full version for the migration being generated.
+   *
+   * The full version can contain a comment suffix after a "__" double underscore.
+   */
+  private String getFullVersion(MigrationModel migrationModel, String dropsFor) {
+
+    String version = migrationConfig.getVersion();
+    if (version == null) {
+      version = migrationModel.getNextVersion(initialVersion);
+    }
+
+    String fullVersion = version;
+    if (migrationConfig.getName() != null) {
+      fullVersion += "__" + toUnderScore(migrationConfig.getName());
+
+    } else if (dropsFor != null) {
+      fullVersion += "__" + toUnderScore("dropsFor_" + MigrationVersion.trim(dropsFor));
+
+    } else if (version.equals(initialVersion)) {
+      fullVersion += "__initial";
+    }
+    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 +423,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 +439,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,42 @@
 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;
+  private String dropAllContent;
+  private String createAllContent;
 
-  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 +53,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 +65,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,11 +81,57 @@ public class DdlGenerator implements SpiEbeanPlugin {
     }
   }
 
+  protected void runDropSql() throws IOException {
+    if (!createOnly) {
+      if (dropAllContent == null) {
+        dropAllContent = readFile(getDropFileName());
+      }
+      runScript(true, dropAllContent, getDropFileName());
+    }
+  }
+
+  protected void runCreateSql() throws IOException {
+    if (createAllContent == null) {
+      createAllContent = readFile(getCreateFileName());
+    }
+    runScript(false, createAllContent, 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 {
-      String c = generateDropDdl();
-      writeFile(dropFile, c);
+      writeFile(dropFile, generateDropAllDdl());
     } catch (IOException e) {
       throw new PersistenceException("Error generating Drop DDL", e);
     }
@@ -101,28 +140,27 @@ public class DdlGenerator implements SpiEbeanPlugin {
   protected void writeCreate(String createFile) {
 
     try {
-      String c = generateCreateDdl();
-      writeFile(createFile, c);
+      writeFile(createFile, generateCreateAllDdl());
     } catch (IOException e) {
       throw new PersistenceException("Error generating Create DDL", e);
     }
   }
 
-  public String generateDropDdl() {
+  protected String generateDropAllDdl() {
 
     try {
-      dropContent = currentModel().getDropDdl();
-      return dropContent;
+      dropAllContent = currentModel().getDropAllDdl();
+      return dropAllContent;
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
   }
 
-  public String generateCreateDdl() {
+  protected String generateCreateAllDdl() {
 
     try {
-      createContent = currentModel().getCreateDdl();
-      return createContent;
+      createAllContent = currentModel().getCreateDdl();
+      return createAllContent;
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
@@ -163,152 +201,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);
-        }
-      }
-    }
-  }
-
-  /**
-   * 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);
-
-      ArrayList<String> statements = new ArrayList<String>();
-
-      StringBuilder sb = new StringBuilder();
-      String s;
-      while ((s = br.readLine()) != null) {
-        s = s.trim();
-        int semiPos = s.indexOf(';');
-        if (semiPos == -1) {
-          sb.append(s).append(" ");
-
-        } else if (semiPos == s.length() - 1) {
-          // semicolon at end of line
-          sb.append(s);
-          statements.add(sb.toString().trim());
-          sb = new StringBuilder();
-
-        } else {
-          // semicolon in middle of line
-          String preSemi = s.substring(0, semiPos);
-          sb.append(preSemi);
-          statements.add(sb.toString().trim());
-          sb = new StringBuilder();
-          sb.append(s.substring(semiPos + 1));
-
-        }
-      }
-
-      return 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

@@ -12,32 +12,17 @@ public class DdlWrite {
 
   private final ModelContainer currentModel;
 
+  private final DdlBuffer applyDropDependencies;
+
   private final DdlBuffer apply;
 
   private final DdlBuffer applyForeignKeys;
 
   private final DdlBuffer applyHistory;
 
-  private final DdlBuffer rollbackForeignKeys;
+  private final DdlBuffer dropAllForeignKeys;
 
-  private final DdlBuffer rollback;
-
-  /**
-   * For DDL that drops tables and columns etc.
-   *
-   * This DDL typically can not run automatically in production as there is most commonly
-   * existing servers running the application using these tables and columns. Typically
-   * these drop statements may be executed AFTER all the servers in the application have
-   * migrated onto new code.
-   */
-  private final DdlBuffer drop;
-
-  /**
-   * For use when History is turned off for a base table or history is no longer
-   * desired on specific columns. This DDL should typically execute manually after review
-   * by DBA's.
-   */
-  private final DdlBuffer dropHistory;
+  private final DdlBuffer dropAll;
 
   /**
    * Create without any configuration or current model (no history support).
@@ -51,13 +36,12 @@ 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.rollbackForeignKeys = new BaseDdlBuffer(configuration);
-    this.rollback = new BaseDdlBuffer(configuration);
-    this.drop = new BaseDdlBuffer(configuration);
-    this.dropHistory = new BaseDdlBuffer(configuration);
+    this.dropAllForeignKeys = new BaseDdlBuffer(configuration);
+    this.dropAll = new BaseDdlBuffer(configuration);
   }
 
   /**
@@ -77,22 +61,8 @@ public class DdlWrite {
   public boolean isApplyEmpty() {
     return apply.getBuffer().isEmpty()
         && applyForeignKeys.getBuffer().isEmpty()
-        && applyHistory.getBuffer().isEmpty();
-  }
-
-  /**
-   * Return true if the apply rollback buffers are all empty.
-   */
-  public boolean isApplyRollbackEmpty() {
-    return rollback.getBuffer().isEmpty()
-        && rollbackForeignKeys.getBuffer().isEmpty();
-  }
-
-  /**
-   * Return true the drop buffers are empty.
-   */
-  public boolean isDropEmpty() {
-    return drop.getBuffer().isEmpty() && dropHistory.getBuffer().isEmpty();
+        && applyHistory.getBuffer().isEmpty()
+        && applyDropDependencies.getBuffer().isEmpty();
   }
 
   /**
@@ -102,6 +72,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>
@@ -120,41 +97,17 @@ public class DdlWrite {
   }
 
   /**
-   * Return the buffer that ROLLBACK DDL is written to for foreign keys and associated indexes.
+   * Return the buffer used for the 'drop all DDL' for dropping foreign keys and associated indexes.
    */
-  public DdlBuffer rollbackForeignKeys() {
-    return rollbackForeignKeys;
+  public DdlBuffer dropAllForeignKeys() {
+    return dropAllForeignKeys;
   }
 
   /**
-   * Return the buffer that ROLLBACK DDL is written to which is considered safe to run when
-   * apply changes fail to execute. This will reverse the apply changes typically dropping
-   * newly created tables, foreign keys etc.
-   * <p>
-   * When apply changes are made against DB's that support transactional DDL you could argue
-   * that these rollback statements are not necessary.
-   * <p>
-   * Note that statements added to this rollback buffer are executed after foreign key rollback
-   * has been executed.
+   * Return the buffer used for the 'drop all DDL' to drop tables, views and history triggers etc.
    */
-  public DdlBuffer rollback() {
-    return rollback;
+  public DdlBuffer dropAll() {
+    return dropAll;
   }
 
-  /**
-   * Return the buffer that destructive changes are written to. This is typically drop table and
-   * drop column.
-   */
-  public DdlBuffer drop() {
-    return drop;
-  }
-
-  /**
-   * Return the buffer that is used when history is no longer required on a table or specific columns.
-   */
-  public DdlBuffer dropHistory() {
-    return dropHistory;
-  }
-
-
 }

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

@@ -58,6 +58,7 @@ public class BaseDdlBuffer implements DdlBuffer {
         append(" ");
       }
     }
+    append(" ");
   }
 
   @Override

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;
@@ -98,7 +99,7 @@ public class BaseTableDdl implements TableDdl {
 
     reset();
 
-    String tableName = lowerName(createTable.getName());
+    String tableName = lowerTableName(createTable.getName());
     List<Column> columns = createTable.getColumn();
     List<Column> pk = determinePrimaryKeyColumns(columns);
 
@@ -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);
 
@@ -135,7 +140,7 @@ public class BaseTableDdl implements TableDdl {
 
     // add drop table to the rollback buffer - do this before
     // we drop the related sequence (if sequences are used)
-    dropTable(writer.rollback(), tableName);
+    dropTable(writer.dropAll(), tableName);
 
     if (useSequence) {
       String pkCol = pk.get(0).getName();
@@ -144,12 +149,43 @@ public class BaseTableDdl implements TableDdl {
 
     // add blank line for a bit of whitespace between tables
     apply.end();
-    writer.rollback().end();
+    writer.dropAll().end();
 
     writeAddForeignKeys(writer, createTable);
 
   }
 
+  /**
+   * 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);
   }
@@ -168,7 +204,7 @@ public class BaseTableDdl implements TableDdl {
           .append(platformDdl.alterTableAddUniqueConstraint(tableName, uqName, columnNames))
           .endOfStatement();
 
-      write.rollbackForeignKeys()
+      write.dropAllForeignKeys()
           .append(platformDdl.dropIndex(uqName, tableName))
           .endOfStatement();
     }
@@ -189,7 +225,7 @@ public class BaseTableDdl implements TableDdl {
     String createSeq = platformDdl.createSequence(seqName, initial, allocate);
     if (createSeq != null) {
       writer.apply().append(createSeq).newLine();
-      writer.rollback().append(platformDdl.dropSequence(seqName)).endOfStatement();
+      writer.dropAll().append(platformDdl.dropSequence(seqName)).endOfStatement();
     }
   }
 
@@ -248,7 +284,7 @@ public class BaseTableDdl implements TableDdl {
 
   protected void writeForeignKey(DdlWrite write, String fkName, String tableName, String[] columns, String refTable, String[] refColumns, String indexName) throws IOException {
 
-    tableName = lowerName(tableName);
+    tableName = lowerTableName(tableName);
     DdlBuffer fkeyBuffer = write.applyForeignKeys();
     alterTableAddForeignKey(fkeyBuffer, fkName, tableName, columns, refTable, refColumns);
 
@@ -259,15 +295,15 @@ public class BaseTableDdl implements TableDdl {
 
     fkeyBuffer.end();
 
-    write.rollbackForeignKeys()
+    write.dropAllForeignKeys()
         .append(platformDdl.alterTableDropForeignKey(tableName, fkName)).endOfStatement();
 
     if (indexName != null) {
-      write.rollbackForeignKeys()
+      write.dropAllForeignKeys()
           .append(platformDdl.dropIndex(indexName, tableName)).endOfStatement();
     }
 
-    write.rollbackForeignKeys().end();
+    write.dropAllForeignKeys().end();
 
   }
 
@@ -282,7 +318,7 @@ public class BaseTableDdl implements TableDdl {
       if (i > 0) {
         buffer.append(",");
       }
-      buffer.append(lowerName(columns[i].trim()));
+      buffer.append(lowerColumnName(columns[i].trim()));
     }
     buffer.append(")");
   }
@@ -367,7 +403,7 @@ public class BaseTableDdl implements TableDdl {
     buffer.append(",").newLine();
     buffer.append("  constraint ").append(uqName).append(" unique ");
     buffer.append("(");
-    buffer.append(lowerName(column.getName()));
+    buffer.append(lowerColumnName(column.getName()));
     buffer.append(")");
   }
 
@@ -401,14 +437,17 @@ public class BaseTableDdl implements TableDdl {
   }
 
   /**
-   * Convert the table or column name to lower case.
-   * <p>
-   * This is passed up to the platformDdl to override as desired.
-   * Generally lower case with underscore is a good cross database
-   * choice for column/table names.
+   * Convert the table lower case.
    */
-  protected String lowerName(String name) {
-    return naming.lowerName(name);
+  protected String lowerTableName(String name) {
+    return naming.lowerTableName(name);
+  }
+
+  /**
+   * Convert the column name to lower case.
+   */
+  protected String lowerColumnName(String name) {
+    return naming.lowerColumnName(name);
   }
 
   /**
@@ -432,7 +471,7 @@ public class BaseTableDdl implements TableDdl {
         .append(platformDdl.createIndex(createIndex.getIndexName(), createIndex.getTableName(), cols))
         .endOfStatement();
 
-    writer.rollback()
+    writer.dropAll()
         .append(platformDdl.dropIndex(createIndex.getIndexName(), createIndex.getTableName()))
         .endOfStatement();
   }
@@ -481,7 +520,6 @@ public class BaseTableDdl implements TableDdl {
     List<Column> columns = addColumn.getColumn();
     for (Column column : columns) {
       alterTableAddColumn(writer.apply(), tableName, column, false);
-      alterTableDropColumn(writer.rollback(), tableName, column.getName());
     }
 
     if (isTrue(addColumn.isWithHistory())) {
@@ -490,13 +528,11 @@ public class BaseTableDdl implements TableDdl {
       for (Column column : columns) {
         regenerateHistoryTriggers(tableName, HistoryTableUpdate.Change.ADD, column.getName());
         alterTableAddColumn(writer.apply(), historyTable, column, true);
-        alterTableDropColumn(writer.rollback(), historyTable, column.getName());
       }
     }
 
     // add a bit of whitespace
     writer.apply().end();
-    writer.rollback().end();
   }
 
   /**
@@ -505,7 +541,7 @@ public class BaseTableDdl implements TableDdl {
   @Override
   public void generate(DdlWrite writer, DropTable dropTable) throws IOException {
 
-    dropTable(writer.drop(), dropTable.getName());
+    dropTable(writer.apply(), dropTable.getName());
   }
 
   /**
@@ -516,14 +552,14 @@ public class BaseTableDdl implements TableDdl {
 
     String tableName = dropColumn.getTableName();
 
-    alterTableDropColumn(writer.drop(), tableName, dropColumn.getColumnName());
+    alterTableDropColumn(writer.apply(), tableName, dropColumn.getColumnName());
     if (isTrue(dropColumn.isWithHistory())) {
       // also drop from the history table
       regenerateHistoryTriggers(tableName, HistoryTableUpdate.Change.DROP, dropColumn.getColumnName());
-      alterTableDropColumn(writer.drop(), historyTable(tableName), dropColumn.getColumnName());
+      alterTableDropColumn(writer.apply(), historyTable(tableName), dropColumn.getColumnName());
     }
 
-    writer.drop().end();
+    writer.apply().end();
   }
 
   /**
@@ -603,21 +639,6 @@ public class BaseTableDdl implements TableDdl {
     if (hasValue(ddl)) {
       writer.apply().append(ddl).endOfStatement();
 
-      // reverse and generate the rollback statement
-      String currentType = alter.getCurrentType();
-      String type = alter.getType();
-      Boolean currentNotnull = alter.isCurrentNotnull();
-      Boolean notnull = alter.isNotnull();
-
-      alter.setCurrentType(type);
-      alter.setType(currentType);
-      alter.setNotnull(currentNotnull);
-      alter.setCurrentNotnull(notnull);
-
-      // write the rollback
-      ddl = platformDdl.alterColumnBaseAttributes(alter);
-      writer.rollback().append(ddl).endOfStatement();
-
       if (isTrue(alter.isWithHistory()) && alter.getType() != null) {
         // mysql and sql server column type change allowing nulls in the history table column
         AlterColumn alterHistoryColumn = new AlterColumn();
@@ -628,11 +649,6 @@ public class BaseTableDdl implements TableDdl {
 
         // write the apply to history table
         writer.apply().append(histColumnDdl).endOfStatement();
-
-        // write the rollback from history table
-        alterHistoryColumn.setType(currentType);
-        histColumnDdl = platformDdl.alterColumnBaseAttributes(alterHistoryColumn);
-        writer.rollback().append(histColumnDdl).endOfStatement();
       }
     }
   }
@@ -650,8 +666,6 @@ public class BaseTableDdl implements TableDdl {
     String ddl = platformDdl.alterColumnNotnull(alter.getTableName(), alter.getColumnName(), alter.isNotnull());
     if (hasValue(ddl)) {
       writer.apply().append(ddl).endOfStatement();
-      ddl = platformDdl.alterColumnNotnull(alter.getTableName(), alter.getColumnName(), alter.isCurrentNotnull());
-      writer.rollback().append(ddl).endOfStatement();
     }
   }
 
@@ -660,14 +674,10 @@ public class BaseTableDdl implements TableDdl {
     String ddl = platformDdl.alterColumnType(alter.getTableName(), alter.getColumnName(), alter.getType());
     if (hasValue(ddl)) {
       writer.apply().append(ddl).endOfStatement();
-      ddl = platformDdl.alterColumnType(alter.getTableName(), alter.getColumnName(), alter.getCurrentType());
-      writer.rollback().append(ddl).endOfStatement();
       if (isTrue(alter.isWithHistory())) {
         // apply same type change to matching column in the history table
         ddl = platformDdl.alterColumnType(historyTable(alter.getTableName()), alter.getColumnName(), alter.getType());
         writer.apply().append(ddl).endOfStatement();
-        ddl = platformDdl.alterColumnType(historyTable(alter.getTableName()), alter.getColumnName(), alter.getCurrentType());
-        writer.rollback().append(ddl).endOfStatement();
       }
     }
   }
@@ -723,7 +733,7 @@ public class BaseTableDdl implements TableDdl {
         .append(platformDdl.alterTableAddUniqueConstraint(alter.getTableName(), uqName, cols))
         .endOfStatement();
 
-    writer.rollbackForeignKeys()
+    writer.dropAllForeignKeys()
         .append(platformDdl.dropIndex(uqName, alter.getTableName()))
         .endOfStatement();
   }

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,43 @@ 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 {
+
+    writer.applyHistory().append("-- changes: ").append(update.description()).newLine();
+
+    updateHistoryTriggers(createDbTriggerUpdate(writer, table));
+  }
+
+  protected DbTriggerUpdate createDbTriggerUpdate(DdlWrite writer, MTable table) {
+
+    List<String> columns = columnNamesForApply(table);
+    String baseTableName = table.getName();
+    String historyTableName = historyTableName(baseTableName);
+    return new DbTriggerUpdate(baseTableName, historyTableName, writer, columns);
+  }
 
   @Override
   public void dropHistoryTable(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException {
@@ -67,18 +88,17 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
     String baseTable = dropHistoryTable.getBaseTable();
 
     // drop in appropriate order
-    dropTriggers(writer.dropHistory(), baseTable);
-    dropHistoryTableEtc(writer.dropHistory(), baseTable);
+    dropTriggers(writer.applyDropDependencies(), baseTable);
+    dropHistoryTableEtc(writer.applyDropDependencies(), baseTable);
   }
 
-
   @Override
   public void addHistoryTable(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException {
 
     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);
@@ -90,12 +110,11 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
     String baseTable = table.getName();
     String whenCreatedColumn = table.getWhenCreatedColumn();
 
-    // rollback changes in appropriate order
-    dropTriggers(writer.rollback(), baseTable);
-    dropHistoryTableEtc(writer.rollback(), baseTable);
+    dropTriggers(writer.dropAll(), baseTable);
+    dropHistoryTableEtc(writer.dropAll(), baseTable);
 
     addHistoryTable(writer, table, whenCreatedColumn);
-    addStoredFunction(writer, table, null);
+    createStoredFunction(writer, table);
     createTriggers(writer, table);
   }
 
@@ -103,7 +122,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 +177,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();
@@ -176,7 +197,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
 
     String platformType = platformDdl.convert(type, false);
     buffer.append("  ");
-    buffer.append(platformDdl.lowerName(columnName), 30);
+    buffer.append(platformDdl.lowerColumnName(columnName), 29);
     buffer.append(platformType);
   }
 
@@ -189,6 +210,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 +242,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 +253,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 +263,26 @@ 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) {
+
+    return table.allHistoryColumns(true);
+  }
+
 }

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

@@ -0,0 +1,63 @@
+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 final List<String> columns;
+
+  public DbTriggerUpdate(String baseTableName, String historyTableName, DdlWrite writer, List<String> columns) {
+    this.baseTableName = baseTableName;
+    this.historyTableName = historyTableName;
+    this.writer = writer;
+    this.columns = columns;
+  }
+
+  /**
+   * Return the appropriate buffer for the current mode.
+   */
+  public DdlBuffer historyBuffer() {
+    return writer.applyHistory();
+  }
+
+  /**
+   * Return the appropriate drop dependency buffer for the current mode.
+   */
+  public DdlBuffer dropDependencyBuffer() {
+    return writer.applyDropDependencies();
+  }
+
+  /**
+   * 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 columns;
+  }
+
+}

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

@@ -10,6 +10,7 @@ public class H2Ddl extends PlatformDdl {
 
   public H2Ddl(DbTypeMap platformTypes, DbIdentity dbIdentity) {
     super(platformTypes, dbIdentity);
+    this.historyDdl = new H2HistoryDdl();
   }
 
 }

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

@@ -0,0 +1,52 @@
+package com.avaje.ebean.dbmigration.ddlgeneration.platform;
+
+import com.avaje.ebean.config.dbplatform.H2HistoryTrigger;
+import com.avaje.ebean.dbmigration.ddlgeneration.DdlBuffer;
+import com.avaje.ebean.dbmigration.ddlgeneration.DdlWrite;
+import com.avaje.ebean.dbmigration.model.MTable;
+
+import java.io.IOException;
+
+/**
+ * H2 history support using DB triggers to maintain a history table.
+ */
+public class H2HistoryDdl extends DbTriggerBasedHistoryDdl {
+
+  private static final String TRIGGER_CLASS = H2HistoryTrigger.class.getName();
+
+  public H2HistoryDdl() {
+  }
+
+  @Override
+  protected void dropTriggers(DdlBuffer buffer, String baseTable) throws IOException {
+
+    buffer.append("drop trigger ").append(updateTriggerName(baseTable)).endOfStatement();
+  }
+
+  @Override
+  protected void createTriggers(DdlWrite writer, MTable table) throws IOException {
+
+    String baseTableName = table.getName();
+    DdlBuffer apply = writer.applyHistory();
+
+    addCreateTrigger(apply, updateTriggerName(baseTableName), baseTableName);
+  }
+
+  @Override
+  protected void updateHistoryTriggers(DbTriggerUpdate update) throws IOException {
+
+    DdlBuffer buffer = update.historyBuffer();
+    dropTriggers(buffer, update.getBaseTable());
+    addCreateTrigger(buffer, updateTriggerName(update.getBaseTable()), update.getBaseTable());
+  }
+
+  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)
+    apply
+        .append("create trigger ").append(triggerName).append(" before update,delete on ").append(baseTable)
+        .append(" for each row call \"" + TRIGGER_CLASS + "\";").newLine();
+  }
+
+}

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

@@ -10,7 +10,6 @@ import java.util.List;
  */
 public class HistoryTableUpdate {
 
-
   /**
    * Column change type.
    */
@@ -21,35 +20,25 @@ 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;
     }
 
+    public String toString() {
+      return description();
+    }
+
     public String description() {
       return change.name().toLowerCase()+" "+column;
     }
 
-    public void apply(List<String> includedColumns) {
-      switch (change) {
-        case ADD:
-        case INCLUDE: {
-          includedColumns.remove(column);
-          break;
-        }
-        case DROP:
-        case EXCLUDE: {
-          includedColumns.add(column);
-          break;
-        }
-        default:
-          throw new IllegalStateException("Unexpected change "+change);
-      }
-    }
   }
 
   private final String baseTable;
@@ -65,27 +54,12 @@ public class HistoryTableUpdate {
 
   /**
    * 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, excluded and dropped columns).
    */
   public String description() {
-    StringBuilder sb = new StringBuilder(90);
-    for (int i = 0; i < columnChanges.size(); i++) {
-      if (i > 0) {
-        sb.append(", ");
-      }
-      sb.append(columnChanges.get(i).description());
-    }
-    return sb.toString();
+    return columnChanges.toString();
   }
 
-  public void toRevertedColumns(List<String> includedColumns) {
-
-    for (Column columnChange : columnChanges) {
-      columnChange.apply(includedColumns);
-    }
-  }
-
-
   /**
    * Add a comment for column added, dropped, included or excluded.
    */
@@ -100,10 +74,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,46 @@ 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();
-
-    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.
    */
@@ -136,7 +150,7 @@ public class PlatformDdl {
     String platformType = convert(column.getType(), identityColumn);
 
     buffer.append("  ");
-    buffer.append(lowerName(column.getName()), 30);
+    buffer.append(lowerColumnName(column.getName()), 29);
     buffer.append(platformType);
     if (isTrue(column.isNotnull()) || isTrue(column.isPrimaryKey())) {
       buffer.append(" not null");
@@ -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);
   }
 
   /**
@@ -254,7 +268,7 @@ public class PlatformDdl {
     appendColumns(columns, buffer);
     buffer
         .append(" references ")
-        .append(lowerName(refTable));
+        .append(lowerTableName(refTable));
     appendColumns(refColumns, buffer);
     appendWithSpace(foreignKeyRestrict, buffer);
 
@@ -346,7 +360,7 @@ public class PlatformDdl {
       if (i > 0) {
         buffer.append(",");
       }
-      buffer.append(lowerName(columns[i].trim()));
+      buffer.append(lowerColumnName(columns[i].trim()));
     }
     buffer.append(")");
   }
@@ -358,20 +372,53 @@ public class PlatformDdl {
   }
 
   /**
-   * Convert the table or column name to lower case.
+   * Convert the table to lower case.
    * <p>
-   * This is passed up to the platformDdl to override as desired.
-   * Generally lower case with underscore is a good cross database
+   * Override as desired. Generally lower case with underscore is a good cross database
    * choice for column/table names.
    */
-  protected String lowerName(String name) {
-    return naming.lowerName(name);
+  protected String lowerTableName(String name) {
+    return naming.lowerTableName(name);
   }
 
+  /**
+   * Convert the column name to lower case.
+   * <p>
+   * Override as desired. Generally lower case with underscore is a good cross database
+   * choice for column/table names.
+   */
+  protected String lowerColumnName(String name) {
+    return naming.lowerColumnName(name);
+  }
+
+
   /**
    * Null safe Boolean true test.
    */
   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()";
   }
 
   /**
@@ -40,11 +40,16 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
         .endOfStatement();
 
     if (whenCreatedColumn != null) {
-      apply.append("update table ").append(baseTableName).append(" set ")
+      apply.append("update ").append(baseTableName).append(" set ")
           .append(sysPeriod).append(" = tstzrange(").append(whenCreatedColumn).append(", null)").endOfStatement();
     }
   }
 
+  @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/ddlgeneration/platform/util/PlatformTypeConverter.java

@@ -5,7 +5,7 @@ import com.avaje.ebean.config.dbplatform.DbTypeMap;
 
 /**
  * Converts a logical column definition into platform specific one.
- *
+ * <p>
  * This translates standard sql types into platform specific ones.
  */
 public class PlatformTypeConverter {
@@ -44,20 +44,21 @@ public class PlatformTypeConverter {
       return columnDefinition;
     }
 
-    String type = columnDefinition.substring(0,open);
+    String suffix = close + 1 < columnDefinition.length() ? columnDefinition.substring(close + 1) : "";
+    String type = columnDefinition.substring(0, open);
     try {
       DbType dbType = platformTypes.lookup(type);
-      int comma = columnDefinition.indexOf(',',open);
+      int comma = columnDefinition.indexOf(',', open);
       if (comma > -1) {
         // scale and precision - decimal(10,4)
-        int scale = Integer.parseInt(columnDefinition.substring(open+1, comma));
-        int precision = Integer.parseInt(columnDefinition.substring(comma+1, close));
-        return  dbType.renderType(scale,precision);
+        int scale = Integer.parseInt(columnDefinition.substring(open + 1, comma));
+        int precision = Integer.parseInt(columnDefinition.substring(comma + 1, close));
+        return dbType.renderType(scale, precision) + suffix;
 
       } else {
         // scale - varchar(10)
-        int scale = Integer.parseInt(columnDefinition.substring(open+1, close));
-        return  dbType.renderType(scale,0);
+        int scale = Integer.parseInt(columnDefinition.substring(open + 1, close));
+        return dbType.renderType(scale, 0) + suffix;
       }
 
     } catch (IllegalArgumentException e) {
@@ -73,7 +74,7 @@ public class PlatformTypeConverter {
 
     try {
       DbType dbType = platformTypes.lookup(columnDefinition);
-      return  dbType.renderType(0,0);
+      return dbType.renderType(0, 0);
 
     } catch (IllegalArgumentException e) {
       // assume already platform specific, leave as is

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

@@ -27,6 +27,8 @@ import javax.xml.bind.annotation.XmlType;
  *         </choice>
  *       </sequence>
  *       <attribute name="type" use="required" type="{http://ebean-orm.github.io/xml/ns/dbmigration}changeSetType" />
+ *       <attribute name="dropsFor" type="{http://www.w3.org/2001/XMLSchema}string" />
+ *       <attribute name="suppressDropsForever" type="{http://www.w3.org/2001/XMLSchema}boolean" />
  *       <attribute name="generated" type="{http://www.w3.org/2001/XMLSchema}boolean" />
  *       <attribute name="author" type="{http://www.w3.org/2001/XMLSchema}string" />
  *       <attribute name="comment" type="{http://www.w3.org/2001/XMLSchema}string" />
@@ -62,6 +64,10 @@ public class ChangeSet {
     protected List<Object> changeSetChildren;
     @XmlAttribute(name = "type", required = true)
     protected ChangeSetType type;
+    @XmlAttribute(name = "dropsFor")
+    protected String dropsFor;
+    @XmlAttribute(name = "suppressDropsForever")
+    protected Boolean suppressDropsForever;
     @XmlAttribute(name = "generated")
     protected Boolean generated;
     @XmlAttribute(name = "author")
@@ -134,6 +140,54 @@ public class ChangeSet {
         this.type = value;
     }
 
+    /**
+     * Gets the value of the dropsFor property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getDropsFor() {
+        return dropsFor;
+    }
+
+    /**
+     * Sets the value of the dropsFor property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setDropsFor(String value) {
+        this.dropsFor = value;
+    }
+
+    /**
+     * Gets the value of the suppressDropsForever property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link Boolean }
+     *     
+     */
+    public Boolean isSuppressDropsForever() {
+        return suppressDropsForever;
+    }
+
+    /**
+     * Sets the value of the suppressDropsForever property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Boolean }
+     *     
+     */
+    public void setSuppressDropsForever(Boolean value) {
+        this.suppressDropsForever = value;
+    }
+
     /**
      * Gets the value of the generated property.
      * 

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

@@ -15,7 +15,7 @@ import javax.xml.bind.annotation.XmlType;
  * <simpleType name="changeSetType">
  *   <restriction base="{http://www.w3.org/2001/XMLSchema}string">
  *     <enumeration value="apply"/>
- *     <enumeration value="drop"/>
+ *     <enumeration value="pendingDrops"/>
  *     <enumeration value="baseline"/>
  *   </restriction>
  * </simpleType>
@@ -28,8 +28,8 @@ public enum ChangeSetType {
 
     @XmlEnumValue("apply")
     APPLY("apply"),
-    @XmlEnumValue("drop")
-    DROP("drop"),
+    @XmlEnumValue("pendingDrops")
+    PENDING_DROPS("pendingDrops"),
     @XmlEnumValue("baseline")
     BASELINE("baseline");
     private final String value;

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;
   }
@@ -114,13 +117,13 @@ public class CurrentModel {
   /**
    * Return the 'Drop' DDL.
    */
-  public String getDropDdl() throws IOException {
+  public String getDropAllDdl() throws IOException {
 
     createDdl();
 
     StringBuilder ddl = new StringBuilder(2000);
-    ddl.append(write.rollbackForeignKeys().getBuffer());
-    ddl.append(write.rollback().getBuffer());
+    ddl.append(write.dropAllForeignKeys().getBuffer());
+    ddl.append(write.dropAll().getBuffer());
 
     return ddl.toString();
   }
@@ -156,12 +159,7 @@ public class CurrentModel {
     ModelDiff diff = new ModelDiff();
     diff.compareTo(model);
 
-    List<Object> applyChanges = diff.getApplyChanges();
-
-    // put the changes into a ChangeSet
-    ChangeSet applyChangeSet = new ChangeSet();
-    applyChangeSet.getChangeSetChildren().addAll(applyChanges);
-    return applyChangeSet;
+    return diff.getApplyChangeSet();
   }
 
 }

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) {