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

Added support for custom database functions that have multiple arguments

pom.xml

@@ -9,7 +9,7 @@
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>6.9.1</version>
+  <version>6.14.1</version>
   <packaging>jar</packaging>
 
   <name>avaje-ebeanorm</name>
@@ -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>
@@ -144,7 +152,7 @@
     <dependency>
       <groupId>org.avaje.ebeanorm</groupId>
       <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.7.1</version>
+      <version>4.8.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -211,7 +219,7 @@
       <plugin>
         <groupId>org.avaje.ebeanorm</groupId>
         <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.7.1</version>
+        <version>4.8.1</version>
         <executions>
           <!--   Not going to enhance Model bean -->
           <execution>
@@ -220,7 +228,7 @@
             <configuration>
               <classSource>target/test-classes</classSource>
               <packages>com.avaje.tests.**</packages>
-              <transformArgs>debug=2</transformArgs>
+              <transformArgs>debug=1</transformArgs>
             </configuration>
             <goals>
               <goal>enhance</goal>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/main/java/com/avaje/ebean/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/SoftDelete.java

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

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

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

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

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

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

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

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

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

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

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

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

@@ -507,7 +507,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];
     }

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

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

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

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

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

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

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

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

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

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

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

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

src/main/java/com/avaje/ebean/config/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,14 +7,20 @@ import com.avaje.ebean.cache.ServerCacheFactory;
 import com.avaje.ebean.cache.ServerCacheManager;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 import com.avaje.ebean.config.dbplatform.DbEncrypt;
-import com.avaje.ebean.event.*;
+import com.avaje.ebean.event.BeanFindController;
+import com.avaje.ebean.event.BeanPersistController;
+import com.avaje.ebean.event.BeanPersistListener;
+import com.avaje.ebean.event.BeanPostLoad;
+import com.avaje.ebean.event.BeanQueryAdapter;
+import com.avaje.ebean.event.BulkTableEventListener;
+import com.avaje.ebean.event.ServerConfigStartup;
+import com.avaje.ebean.event.TransactionEventListener;
 import com.avaje.ebean.event.changelog.ChangeLogListener;
 import com.avaje.ebean.event.changelog.ChangeLogPrepare;
 import com.avaje.ebean.event.changelog.ChangeLogRegister;
 import com.avaje.ebean.event.readaudit.ReadAuditLogger;
 import com.avaje.ebean.event.readaudit.ReadAuditPrepare;
 import com.avaje.ebean.meta.MetaInfoManager;
-import com.avaje.ebean.util.ClassUtil;
 import com.fasterxml.jackson.core.JsonFactory;
 
 import javax.sql.DataSource;
@@ -228,6 +234,11 @@ public class ServerConfig {
    */
   private DbMigrationConfig migrationConfig = new DbMigrationConfig();
 
+  /**
+   * The ClassLoadConfig used to detect Joda, Java8, Jackson etc and create plugin instances given a className.
+   */
+  private ClassLoadConfig classLoadConfig = new ClassLoadConfig();
+
   /**
    * Set to true if the DataSource uses autoCommit.
    * <p>
@@ -281,9 +292,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>();
@@ -1466,19 +1477,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;
   }
 
   /**
@@ -2024,6 +2034,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.
    */
@@ -2041,6 +2067,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().
    */
@@ -2048,11 +2089,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);
   }
 
   /**
@@ -2098,15 +2159,15 @@ public class ServerConfig {
     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");
     
@@ -2152,7 +2213,10 @@ 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);
 
     lazyLoadBatchSize = p.getInt("lazyLoadBatchSize", lazyLoadBatchSize);
@@ -2174,7 +2238,7 @@ public class ServerConfig {
 
   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;
   }
 
@@ -2274,4 +2338,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/H2Platform.java

@@ -16,6 +16,7 @@ public class H2Platform extends DatabasePlatform {
     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/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

@@ -21,8 +21,8 @@ import com.avaje.ebean.dbmigration.model.CurrentModel;
 import com.avaje.ebean.dbmigration.model.MConfiguration;
 import com.avaje.ebean.dbmigration.model.MigrationModel;
 import com.avaje.ebean.dbmigration.model.ModelContainer;
-import com.avaje.ebean.dbmigration.model.PlatformDdlWriter;
 import com.avaje.ebean.dbmigration.model.ModelDiff;
+import com.avaje.ebean.dbmigration.model.PlatformDdlWriter;
 import com.avaje.ebeaninternal.api.SpiEbeanServer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -57,6 +57,13 @@ public class DbMigration {
 
   protected static final Logger logger = LoggerFactory.getLogger(DbMigration.class);
 
+  private static final String initialVersion = "1.0";
+
+  /**
+   * Set to true if DbMigration run with online EbeanServer instance.
+   */
+  protected final boolean online;
+
   protected SpiEbeanServer server;
 
   protected DbMigrationConfig migrationConfig;
@@ -71,7 +78,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 +144,9 @@ public class DbMigration {
    */
   public void setPlatform(DatabasePlatform databasePlatform) {
     this.databasePlatform = databasePlatform;
-    DbOffline.setPlatform(databasePlatform.getName());
+    if (!online) {
+      DbOffline.setPlatform(databasePlatform.getName());
+    }
   }
 
   /**
@@ -175,16 +196,19 @@ public class DbMigration {
   public void generateMigration() throws IOException {
 
     // use this flag to stop other plugins like full DDL generation
-    DbOffline.setRunningMigration();
+    if (!online) {
+      DbOffline.setRunningMigration();
+    }
 
     setDefaults();
 
     try {
-      MigrationModel migrationModel = new MigrationModel(migrationConfig.getResourcePath());
-      ModelContainer migrated = migrationModel.read();
-      int nextMajorVersion = migrationModel.getNextMajorVersion();
 
-      logger.info("next migration version {}", nextMajorVersion);
+      File migrationDir = getMigrationDirectory();
+      File modelDir = getModelDirectory(migrationDir);
+
+      MigrationModel migrationModel = new MigrationModel(modelDir, migrationConfig.getModelSuffix());
+      ModelContainer migrated = migrationModel.read();
 
       CurrentModel currentModel = new CurrentModel(server, constraintNaming);
       ModelContainer current = currentModel.read();
@@ -200,46 +224,89 @@ public class DbMigration {
       // there were actually changes to write
       Migration dbMigration = diff.getMigration();
 
-      File writePath = getWritePath();
-      logger.info("migration writing version {} to {}", nextMajorVersion, writePath.getAbsolutePath());
-      writeMigrationXml(dbMigration, writePath, nextMajorVersion);
+      String fullVersion = getFullVersion(migrationModel);
 
-      if (databasePlatform != null) {
-        // writer needs the current model to provide table/column details for
-        // history ddl generation (triggers, history tables etc)
-        DdlWrite write = new DdlWrite(new MConfiguration(), currentModel.read());
-        PlatformDdlWriter writer = new PlatformDdlWriter(databasePlatform, serverConfig);
-        writer.processMigration(dbMigration, write, writePath, nextMajorVersion);
+      logger.info("generating migration:{}", fullVersion);
+      if (!writeMigrationXml(dbMigration, modelDir, fullVersion)) {
+        logger.warn("migration already exists, not generating DDL");
+
+      } else {
+        if (databasePlatform != null) {
+          // writer needs the current model to provide table/column details for
+          // history ddl generation (triggers, history tables etc)
+          DdlWrite write = new DdlWrite(new MConfiguration(), currentModel.read());
+          PlatformDdlWriter writer = createDdlWriter(databasePlatform, "");
+          writer.processMigration(dbMigration, write, migrationDir , fullVersion);
+        }
+        writeExtraPlatformDdl(fullVersion, currentModel, dbMigration, migrationDir);
       }
 
-      writeExtraPlatformDdl(nextMajorVersion, currentModel, dbMigration, writePath);
-
     } finally {
-      DbOffline.reset();
+      if (!online) {
+        DbOffline.reset();
+      }
     }
   }
 
+  /**
+   * Return the full version for the migration being generated.
+   */
+  private String getFullVersion(MigrationModel migrationModel) {
+
+    String version = migrationConfig.getVersion();
+    if (version == null) {
+      version = migrationModel.getNextVersion(initialVersion);
+    }
+
+    String fullVersion = version;
+
+    String name = migrationConfig.getName();
+    if (name != null) {
+      fullVersion += "__" + toUnderScore(name);
+    }
+    return fullVersion;
+  }
+
+  /**
+   * Replace spaces with underscores.
+   */
+  private String toUnderScore(String name) {
+    return name.replace(' ','_');
+  }
+
   /**
    * Write any extra platform ddl.
    */
-  protected void writeExtraPlatformDdl(int nextMajorVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
+  protected void writeExtraPlatformDdl(String fullVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
 
     for (Pair pair : platforms) {
       DdlWrite platformBuffer = new DdlWrite(new MConfiguration(), currentModel.read());
-
-      PlatformDdlWriter platformWriter = new PlatformDdlWriter(pair.platform, serverConfig, pair.prefix);
-      platformWriter.processMigration(dbMigration, platformBuffer, writePath, nextMajorVersion);
+      PlatformDdlWriter platformWriter = createDdlWriter(pair);
+      platformWriter.processMigration(dbMigration, platformBuffer, writePath, fullVersion);
     }
   }
 
+  private PlatformDdlWriter createDdlWriter(Pair pair) {
+    return createDdlWriter(pair.platform, pair.prefix);
+  }
+
+  private PlatformDdlWriter createDdlWriter(DatabasePlatform platform, String prefix) {
+    return new PlatformDdlWriter(platform, serverConfig, prefix, migrationConfig);
+  }
+
   /**
    * Write the migration xml.
    */
-  protected void writeMigrationXml(Migration dbMigration, File resourcePath, int migrationVersion) {
+  protected boolean writeMigrationXml(Migration dbMigration, File resourcePath, String fullVersion) {
 
-    File file = new File(resourcePath, "v"+migrationVersion+".0.xml");
+    String modelFile = fullVersion + migrationConfig.getModelSuffix();
+    File file = new File(resourcePath, modelFile);
+    if (file.exists()) {
+      return false;
+    }
     MigrationXmlWriter xmlWriter = new MigrationXmlWriter();
     xmlWriter.write(dbMigration, file);
+    return true;
   }
 
   /**
@@ -260,14 +327,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 +343,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/ddlgeneration/platform/BaseTableDdl.java

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

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

@@ -160,8 +160,10 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
 
     Collection<MColumn> cols = table.getColumns().values();
     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();
@@ -232,7 +234,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
     List<String> includedColumns = new ArrayList<String>(columns.size());
 
     for (MColumn column : columns) {
-      if (!column.isHistoryExclude()) {
+      if (column.isIncludeInHistory()) {
         includedColumns.add(column.getName());
       }
     }

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

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

src/main/java/com/avaje/ebean/dbmigration/ddlgeneration/platform/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

@@ -81,12 +81,12 @@ public class PostgresHistoryDdl extends DbTriggerBasedHistoryDdl {
     appendInsertIntoHistory(apply, historyTable, includedColumns);
     apply
         .append("    NEW.").append(sysPeriod).append(" = tstzrange(CURRENT_TIMESTAMP,null);").newLine()
-        .append("    return new;").newLine().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()

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

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

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

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

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

@@ -14,7 +14,7 @@ import java.util.List;
  */
 public class MCompoundForeignKey {
 
-  private final String name;
+  private String name;
   private final String referenceTable;
   private final List<String> columns = new ArrayList<String>();
   private final List<String> referenceColumns = new ArrayList<String>();
@@ -47,6 +47,28 @@ public class MCompoundForeignKey {
     return fk;
   }
 
+  /**
+   * Add a counter to the foreign key and index names to avoid duplication.
+   */
+  public void addNameSuffix(int counter) {
+    this.name = name + "_" + counter;
+    this.indexName = indexName + "_" + counter;
+  }
+
+  /**
+   * Return the foreign key name.
+   */
+  public String getName() {
+    return name;
+  }
+
+  /**
+   * Return the index name.
+   */
+  public String getIndexName() {
+    return indexName;
+  }
+
   /**
    * Return the columns making up the foreign key in order.
    */

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

@@ -14,6 +14,7 @@ import com.avaje.ebean.dbmigration.migration.UniqueConstraint;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -42,6 +43,17 @@ public class MTable {
    */
   private final String name;
 
+  /**
+   * The associated draft table.
+   */
+  private MTable draftTable;
+
+  /**
+   * Marked true for draft tables. These need to have their FK references adjusted
+   * after all the draft tables have been identified.
+   */
+  private boolean draft;
+
   /**
    * Primary key name.
    */
@@ -106,6 +118,27 @@ public class MTable {
    */
   private AddColumn addColumn;
 
+  /**
+   * Create a copy of this table structure as a 'draft' table.
+   *
+   * Note that both tables contain @DraftOnly MColumns and these are filtered out
+   * later when creating the CreateTable object.
+   */
+  public MTable createDraftTable() {
+
+    draftTable = new MTable(name+"_draft");
+    draftTable.draft = true;
+    draftTable.whenCreatedColumn = whenCreatedColumn;
+    // compoundKeys
+    // compoundUniqueConstraints
+    draftTable.identityType = identityType;
+
+    for (MColumn col: columns.values()) {
+      draftTable.addColumn(col.copyForDraft());
+    }
+
+    return draftTable;
+  }
 
   /**
    * Construct for migration.
@@ -163,7 +196,10 @@ public class MTable {
     }
 
     for (MColumn column : this.columns.values()) {
-      createTable.getColumn().add(column.createColumn());
+      // filter out draftOnly columns from the base table
+      if (draft || !column.isDraftOnly()) {
+        createTable.getColumn().add(column.createColumn());
+      }
     }
 
     for (MCompoundForeignKey compoundKey : compoundKeys) {
@@ -270,6 +306,13 @@ public class MTable {
     return name;
   }
 
+  /**
+   * Return true if this table is a 'Draft' table.
+   */
+  public boolean isDraft() {
+    return draft;
+  }
+
   public String getPkName() {
     return pkName;
   }
@@ -282,6 +325,10 @@ public class MTable {
     return comment;
   }
 
+  public void setComment(String comment) {
+    this.comment = comment;
+  }
+
   public String getTablespace() {
     return tablespace;
   }
@@ -482,4 +529,70 @@ public class MTable {
     return (value == 0) ? null : BigInteger.valueOf(value);
   }
 
+  /**
+   * Check if there are duplicate foreign keys.
+   * <p>
+   *   This can occur when an ManyToMany relates back to itself.
+   * </p>
+   */
+  public void checkDuplicateForeignKeys() {
+
+    if (hasDuplicateForeignKeys()) {
+      int counter = 1;
+      for (MCompoundForeignKey fk : compoundKeys) {
+        fk.addNameSuffix(counter++);
+      }
+    }
+  }
+
+  /**
+   * Return true if the foreign key names are not unique.
+   */
+  private boolean hasDuplicateForeignKeys() {
+    Set<String> fkNames = new HashSet<String>();
+    for (MCompoundForeignKey fk : compoundKeys) {
+      if (!fkNames.add(fk.getName())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Adjust the references (FK) if it should relate to a draft table.
+   */
+  public void adjustReferences(ModelContainer modelContainer) {
+
+    Collection<MColumn> cols = columns.values();
+    for (MColumn col : cols) {
+      String references = col.getReferences();
+      if (references != null) {
+        String baseTable = extractBaseTable(references);
+        MTable refBaseTable = modelContainer.getTable(baseTable);
+        if (refBaseTable.draftTable != null) {
+          // change references to another associated 'draft' table
+          String newReferences = deriveReferences(references, refBaseTable.draftTable.getName());
+          col.setReferences(newReferences);
+        }
+      }
+    }
+  }
+
+  /**
+   * Return the base table name from references (table.column).
+   */
+  private String extractBaseTable(String references) {
+    int lastDot = references.lastIndexOf('.');
+    return references.substring(0,lastDot);
+  }
+
+  /**
+   * Return the new references using the given draftTableName.
+   * (The referenced column is the same as before).
+   */
+  private String deriveReferences(String references, String draftTableName) {
+    int lastDot = references.lastIndexOf('.');
+    return draftTableName+"."+references.substring(lastDot+1);
+  }
+
 }

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,6 @@
 package com.avaje.ebean.dbmigration.model;
 
+import com.avaje.ebean.config.DbMigrationConfig;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
 import com.avaje.ebean.dbmigration.ddlgeneration.DdlHandler;
@@ -24,20 +25,19 @@ public class PlatformDdlWriter {
 
   private final String platformPrefix;
 
-  public PlatformDdlWriter(DatabasePlatform platform, ServerConfig serverConfig) {
-    this(platform, serverConfig, "");
-  }
+  private final DbMigrationConfig config;
 
-  public PlatformDdlWriter(DatabasePlatform platform, ServerConfig serverConfig, String platformPrefix) {
+  public PlatformDdlWriter(DatabasePlatform platform, ServerConfig serverConfig, String platformPrefix, DbMigrationConfig config) {
     this.platform = platform;
     this.serverConfig = serverConfig;
     this.platformPrefix = platformPrefix;
+    this.config = config;
   }
 
   /**
    * Write the migration as platform specific ddl.
    */
-  public void processMigration(Migration dbMigration, DdlWrite write, File writePath, int nextMajorVersion) throws IOException {
+  public void processMigration(Migration dbMigration, DdlWrite write, File writePath, String fullVersion) throws IOException {
 
     DdlHandler handler = handler();
 
@@ -49,16 +49,16 @@ public class PlatformDdlWriter {
     }
     handler.generateExtra(write);
 
-    writePlatformDdl(write, writePath, nextMajorVersion);
+    writePlatformDdl(write, writePath, fullVersion);
   }
 
   /**
    * Write the ddl files.
    */
-  protected void writePlatformDdl(DdlWrite write, File resourcePath, int migrationVersion) throws IOException {
+  protected void writePlatformDdl(DdlWrite write, File resourcePath, String fullVersion) throws IOException {
 
     if (!write.isApplyEmpty()) {
-      FileWriter applyWriter = createWriter(resourcePath, migrationVersion, "apply.sql");
+      FileWriter applyWriter = createWriter(resourcePath, fullVersion, "", config.getApplySuffix());
       try {
         writeApplyDdl(applyWriter, write);
         applyWriter.flush();
@@ -66,8 +66,8 @@ public class PlatformDdlWriter {
         applyWriter.close();
       }
 
-      if (!write.isApplyRollbackEmpty()) {
-        FileWriter applyRollbackWriter = createWriter(resourcePath, migrationVersion, "applyRollback.sql");
+      if (!config.isSuppressRollback() && !write.isApplyRollbackEmpty()) {
+        FileWriter applyRollbackWriter = createWriter(resourcePath, fullVersion, config.getRollbackPath(), config.getRollbackSuffix());
         try {
           writeApplyRollbackDdl(applyRollbackWriter, write);
           applyRollbackWriter.flush();
@@ -78,7 +78,7 @@ public class PlatformDdlWriter {
     }
 
     if (!write.isDropEmpty()) {
-      FileWriter dropWriter = createWriter(resourcePath, migrationVersion, "drop.sql");
+      FileWriter dropWriter = createWriter(resourcePath, fullVersion, config.getDropPath(), config.getDropSuffix());
       try {
         writeDropDdl(dropWriter, write);
         dropWriter.flush();
@@ -88,12 +88,28 @@ public class PlatformDdlWriter {
     }
   }
 
-  protected FileWriter createWriter(File resourcePath, int migrationVersion, String suffix) throws IOException {
+  protected FileWriter createWriter(File path, String fullVersion, String subPath, String suffix) throws IOException {
 
-    File applyFile = new File(resourcePath, "v" + migrationVersion + ".0-" + platformPrefix + suffix);
+    String fileName = fullVersion;
+    if (!platformPrefix.isEmpty()) {
+      fileName += "-"+platformPrefix;
+    }
+    if (subPath != null && !subPath.isEmpty()) {
+      path = subPath(path, subPath);
+    }
+    fileName += suffix;
+    File applyFile = new File(path,  fileName);
     return new FileWriter(applyFile);
   }
 
+  protected File subPath(File path, String suffix) {
+    File subPath = new File(path, suffix);
+    if (!subPath.exists()) {
+      subPath.mkdirs();
+    }
+    return subPath;
+  }
+
   /**
    * Write the 'Apply' DDL buffers to the writer.
    */

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

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

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

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

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

@@ -35,9 +35,18 @@ public class ModelBuildIntersectionTable {
   public void build() {
 
     intersectionTable = createTable();
-    ctx.addTable(intersectionTable);
+    MTable existingTable = ctx.addTable(intersectionTable);
+    if (existingTable != null) {
+      throw new IllegalStateException("Property " + manyProp.getFullBeanName() + " has duplicate ManyToMany intersection table " + intersectionTable.getName()
+          + ". Please use @JoinTable to define unique table to use");
+    }
 
     buildFkConstraints();
+
+    if (manyProp.getTargetDescriptor().isDraftable()) {
+      ctx.createDraft(intersectionTable, false);
+    }
+
 	}
 
 	private void buildFkConstraints() {
@@ -47,6 +56,8 @@ public class ModelBuildIntersectionTable {
 
 		BeanDescriptor<?> targetDesc = manyProp.getTargetDescriptor();
 		buildFkConstraints(targetDesc, tableJoin.columns(), false);
+
+    intersectionTable.checkDuplicateForeignKeys();
 	}
 
 	

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -59,11 +59,6 @@ public class ScopedTransaction implements SpiTransaction {
     }
   }
 
-  @Override
-  public void endQueryOnly() {
-    transaction.endQueryOnly();
-  }
-
   @Override
   public String getLogPrefix() {
     return transaction.getLogPrefix();

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

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

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

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

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

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

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

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

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

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

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

@@ -19,11 +19,6 @@ import com.avaje.ebeaninternal.server.persist.BatchControl;
  */
 public interface SpiTransaction extends Transaction {
 
-  /**
-   * End the transaction when had query only use.
-   */
-  void endQueryOnly();
-
   /**
    * Return the string prefix with the transactin id and label used in logging.
    */

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

@@ -401,8 +401,10 @@ public class DefaultBeanLoader {
       ebi.setPersistenceContext(pc);
     }
 
+    boolean draft = desc.isDraftInstance(bean);
+
     if (embeddedOwnerIndex == -1) {
-      if (SpiQuery.Mode.LAZYLOAD_BEAN.equals(mode) && desc.isBeanCaching()) {
+      if (!draft && SpiQuery.Mode.LAZYLOAD_BEAN.equals(mode) && desc.isBeanCaching()) {
         // lazy loading and the bean cache is active 
         if (desc.cacheBeanLoad(bean, ebi, id)) {
           return;
@@ -415,10 +417,12 @@ public class DefaultBeanLoader {
 
     SpiQuery<?> query = (SpiQuery<?>) server.createQuery(desc.getBeanType());
     query.setLazyLoadProperty(ebi.getLazyLoadProperty());
+    if (draft) {
+      query.asDraft();
+    }
 
     if (embeddedOwnerIndex > -1) {
-      String embeddedBeanPropertyName = ebi.getProperty(embeddedOwnerIndex);
-      query.select("id," + embeddedBeanPropertyName);
+      query.select("id," + ebi.getProperty(embeddedOwnerIndex));
     }
 
     // don't collect AutoTune usage profiling information

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

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

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

@@ -9,6 +9,7 @@ import com.avaje.ebean.bean.ObjectGraphNode;
 import com.avaje.ebean.bean.PersistenceContext;
 import com.avaje.ebean.bean.PersistenceContext.WithOption;
 import com.avaje.ebean.cache.ServerCacheManager;
+import com.avaje.ebean.config.DbMigrationConfig;
 import com.avaje.ebean.config.EncryptKeyManager;
 import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.config.dbplatform.DatabasePlatform;
@@ -70,6 +71,7 @@ import com.avaje.ebeaninternal.util.ParamTypeHelper.TypeInfo;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.persistence.NonUniqueResultException;
 import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
 import java.util.ArrayList;
@@ -372,6 +374,10 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    * Start any services after registering with the ClusterManager.
    */
   public void start() {
+    DbMigrationConfig migrationConfig = serverConfig.getMigrationConfig();
+    if (migrationConfig != null) {
+      migrationConfig.generateOnStart(this);
+    }
   }
 
   /**
@@ -908,8 +914,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     Class<T> beanType = (Class<T>) list.get(0).getClass();
     BeanDescriptor<T> beanDescriptor = getBeanDescriptor(beanType);
     if (beanDescriptor == null) {
-      String m = "BeanDescriptor not found, is [" + beanType + "] an entity bean?";
-      throw new PersistenceException(m);
+      throw new PersistenceException("BeanDescriptor not found, is [" + beanType + "] an entity bean?");
     }
     beanDescriptor.sort(list, sortByClause);
   }
@@ -933,6 +938,16 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     return new DefaultOrmQuery<T>(beanType, this, expressionFactory, deployQuery);
   }
 
+  @Override
+  public <T> Set<String> validateQuery(Query<T> query) {
+
+    BeanDescriptor<T> beanDescriptor = getBeanDescriptor(query.getBeanType());
+    if (beanDescriptor == null) {
+      throw new PersistenceException("BeanDescriptor not found, is [" + query.getBeanType() + "] an entity bean?");
+    }
+    return ((SpiQuery<T>)query).validate(beanDescriptor);
+  }
+
   public <T> Filter<T> filter(Class<T> beanType) {
     BeanDescriptor<T> desc = getBeanDescriptor(beanType);
     if (desc == null) {
@@ -1209,13 +1224,16 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
     // a query that is expected to return either 0 or 1 rows
     List<T> list = findList(query, t);
+    return extractUnique(list);
+  }
 
-    if (list.size() == 0) {
+  private <T> T extractUnique(List<T> list) {
+    if (list.isEmpty()) {
       return null;
-      
+
     } else if (list.size() > 1) {
-      throw new PersistenceException("Unique expecting 0 or 1 rows but got [" + list.size() + "]");
-      
+      throw new NonUniqueResultException("Unique expecting 0 or 1 results but got [" + list.size() + "]");
+
     } else {
       return list.get(0);
     }
@@ -1301,6 +1319,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     SpiOrmQueryRequest<T> request = createQueryRequest(Type.DELETE, query, t);
     try {
       request.initTransIfRequired();
+      request.markNotQueryOnly();
       return request.delete();
     } finally {
       request.endTransIfRequired();
@@ -1370,6 +1389,18 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     return new LimitOffsetPagedList<T>(this, (SpiQuery<T>)query, pageIndex, pageSize);
   }
 
+  @Override
+  public <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction) {
+
+    SpiQuery<T> spiQuery = (SpiQuery<T>)query;
+    int maxRows = spiQuery.getMaxRows();
+    if (maxRows == 0) {
+      throw new PersistenceException("maxRows must be specified for findPagedList() query");
+    }
+
+    return new LimitOffsetPagedList<T>(this, spiQuery);
+  }
+
   public <T> void findEach(Query<T> query, QueryEachConsumer<T> consumer, Transaction t) {
 
     SpiOrmQueryRequest<T> request = createQueryRequest(Type.ITERATE, query, t);
@@ -1439,17 +1470,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     // no findId() method for SqlQuery...
     // a query that is expected to return either 0 or 1 rows
     List<SqlRow> list = findList(query, t);
-
-    if (list.size() == 0) {
-      return null;
-
-    } else if (list.size() > 1) {
-      String m = "Unique expecting 0 or 1 rows but got [" + list.size() + "]";
-      throw new PersistenceException(m);
-
-    } else {
-      return list.get(0);
-    }
+    return extractUnique(list);
   }
 
   public SqlFutureList findFutureList(SqlQuery query, Transaction t) {
@@ -1624,6 +1645,75 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     }
   }
 
+  public <T> List<T> publish(Query<T> query, Transaction transaction) {
+
+    TransWrapper wrap = initTransIfRequired(transaction);
+    try {
+      SpiTransaction trans = wrap.transaction;
+      List<T> liveBeans = persister.publish(query, trans);
+      wrap.commitIfCreated();
+
+      return liveBeans;
+
+    } catch (RuntimeException e) {
+      wrap.rollbackIfCreated();
+      throw e;
+    }
+  }
+
+  @Override
+  public <T> T publish(Class<T> beanType, Object id) {
+    return publish(beanType, id, null);
+  }
+
+  @Override
+  public <T> List<T> publish(Query<T> query) {
+    return publish(query, null);
+  }
+
+  @Override
+  public <T> T publish(Class<T> beanType, Object id, Transaction transaction) {
+
+    Query<T> query = find(beanType).setId(id);
+    List<T> liveBeans = publish(query, transaction);
+    return (liveBeans.size() == 1) ? liveBeans.get(0) : null;
+  }
+
+  @Override
+  public <T> List<T> draftRestore(Query<T> query, Transaction transaction) {
+
+    TransWrapper wrap = initTransIfRequired(transaction);
+    try {
+      SpiTransaction trans = wrap.transaction;
+      List<T> beans = persister.draftRestore(query, trans);
+      wrap.commitIfCreated();
+
+      return beans;
+
+    } catch (RuntimeException e) {
+      wrap.rollbackIfCreated();
+      throw e;
+    }
+  }
+
+  @Override
+  public <T> T draftRestore(Class<T> beanType, Object id, Transaction transaction) {
+
+    Query<T> query = find(beanType).setId(id);
+    List<T> beans = draftRestore(query, transaction);
+    return (beans.size() == 1) ? beans.get(0) : null;
+  }
+
+  @Override
+  public <T> T draftRestore(Class<T> beanType, Object id) {
+    return draftRestore(beanType, id, null);
+  }
+
+  @Override
+  public <T> List<T> draftRestore(Query<T> query) {
+    return draftRestore(query, null);
+  }
+
   private EntityBean checkEntityBean(Object bean) {
     if (bean == null) {
       throw new IllegalArgumentException(Message.msg("bean.isnull"));
@@ -1797,16 +1887,35 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   /**
    * Delete the bean.
    */
-  public void delete(Object bean) {
-    delete(bean, null);
+  public boolean delete(Object bean) {
+    return delete(bean, null);
   }
 
   /**
    * Delete the bean with the explicit transaction.
    */
-  public void delete(Object bean, Transaction t) {
-    
-    persister.delete(checkEntityBean(bean), t);
+  public boolean delete(Object bean, Transaction t) throws OptimisticLockException {
+    return persister.delete(checkEntityBean(bean), t, false);
+  }
+
+  @Override
+  public boolean deletePermanent(Object bean) throws OptimisticLockException {
+    return deletePermanent(bean, null);
+  }
+
+  @Override
+  public boolean deletePermanent(Object bean, Transaction t) throws OptimisticLockException {
+    return persister.delete(checkEntityBean(bean), t, true);
+  }
+
+  @Override
+  public int deleteAllPermanent(Collection<?> beans) {
+    return deleteAllInternal(beans.iterator(), null, true);
+  }
+
+  @Override
+  public int deleteAllPermanent(Collection<?> beans, Transaction t) {
+    return deleteAllInternal(beans.iterator(), t, true);
   }
 
   /**
@@ -1814,7 +1923,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    */
   @Override
   public int deleteAll(Collection<?> beans) {
-    return deleteAllInternal(beans.iterator(), null);
+    return deleteAllInternal(beans.iterator(), null, false);
   }
 
   /**
@@ -1822,13 +1931,13 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
    */
   @Override
   public int deleteAll(Collection<?> beans, Transaction t) {
-    return deleteAllInternal(beans.iterator(), t);
+    return deleteAllInternal(beans.iterator(), t, false);
   }
 
   /**
    * Delete all the beans in the iterator with an explicit transaction.
    */
-  private int deleteAllInternal(Iterator<?> it, Transaction t) {
+  private int deleteAllInternal(Iterator<?> it, Transaction t, boolean permanent) {
 
     TransWrapper wrap = initTransIfRequired(t);
 
@@ -1838,7 +1947,7 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
       int deleteCount = 0;
       while (it.hasNext()) {
         EntityBean bean = checkEntityBean(it.next());
-        persister.delete(bean, trans);
+        persister.delete(bean, trans, permanent);
         deleteCount++;
       }
 

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

@@ -127,13 +127,14 @@ public class InternalConfiguration {
 
     this.beanDescriptorManager = new BeanDescriptorManager(this);
     Map<String, String> asOfTableMapping = beanDescriptorManager.deploy();
+    Map<String, String> draftTableMap = beanDescriptorManager.getDraftTableMap();
 
     this.transactionManager = createTransactionManager();
 
     DatabasePlatform databasePlatform = serverConfig.getDatabasePlatform();
 
     this.binder = getBinder(typeManager, databasePlatform);
-    this.cQueryEngine = new CQueryEngine(databasePlatform, binder, asOfTableMapping, serverConfig.getAsOfSysPeriod());
+    this.cQueryEngine = new CQueryEngine(databasePlatform, binder, asOfTableMapping, serverConfig.getAsOfSysPeriod(), draftTableMap);
 
     ExternalTransactionManager externalTransactionManager = serverConfig.getExternalTransactionManager();
     if (externalTransactionManager == null && serverConfig.isUseJtaTransactionManager()) {
@@ -356,6 +357,6 @@ public class InternalConfiguration {
   }
 
   public GeneratedPropertyFactory getGeneratedPropertyFactory() {
-    return new GeneratedPropertyFactory(serverConfig.getCurrentUserProvider());
+    return new GeneratedPropertyFactory(serverConfig);
   }
 }

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

@@ -72,6 +72,13 @@ public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRe
     this.readOnly = query.isReadOnly();
   }
 
+  /**
+   * Mark the transaction as not being query only.
+   */
+  @Override
+  public void markNotQueryOnly() {
+    transaction.markNotQueryOnly();
+  }
 
   /**
    * Return the database platform like clause.
@@ -219,7 +226,7 @@ public final class OrmQueryRequest<T> extends BeanRequest implements BeanQueryRe
    */
   public void endTransIfRequired() {
     if (createdTransaction) {
-      transaction.endQueryOnly();
+      transaction.commit();
     }
   }
 

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

@@ -12,7 +12,7 @@ import com.avaje.ebeaninternal.server.persist.PersistExecute;
 public abstract class PersistRequest extends BeanRequest implements BatchPostExecute {
 
 	public enum Type {
-	  INSERT, UPDATE, DELETE, UPDATESQL, CALLABLESQL
+	  INSERT, UPDATE, DELETE, SOFT_DELETE, DELETE_PERMANENT, UPDATESQL, CALLABLESQL
 	}
 
 	protected boolean persistCascade;

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

@@ -21,6 +21,7 @@ import com.avaje.ebeaninternal.server.persist.PersistExecute;
 import com.avaje.ebeaninternal.server.transaction.BeanPersistIdMap;
 
 import javax.persistence.OptimisticLockException;
+import javax.persistence.PersistenceException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -61,6 +62,8 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
   private final boolean dirty;
 
+  private final boolean publish;
+
   private ConcurrencyMode concurrencyMode;
 
   /**
@@ -120,7 +123,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   private boolean requestUpdateAllLoadedProps;
 
   public PersistRequestBean(SpiEbeanServer server, T bean, Object parentBean, BeanManager<T> mgr, SpiTransaction t,
-      PersistExecute persistExecute, PersistRequest.Type type, boolean saveRecurse) {
+                            PersistExecute persistExecute, PersistRequest.Type type, boolean saveRecurse, boolean publish) {
 
     super(server, t, persistExecute);
     this.entityBean = (EntityBean) bean;
@@ -132,7 +135,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     this.parentBean = parentBean;
     this.controller = beanDescriptor.getPersistController();
     this.type = type;
-    
+
     if (saveRecurse) {
       this.persistCascade = t.isPersistCascade();
     }
@@ -147,9 +150,30 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       beanDescriptor.checkMutableProperties(intercept);
     }
     this.concurrencyMode = beanDescriptor.getConcurrencyMode(intercept);
+    this.publish = publish;
+    if (isMarkDraftDirty(publish)) {
+      beanDescriptor.setDraftDirty(entityBean, true);
+    }
     this.dirty = intercept.isDirty();
   }
 
+  /**
+   * Return true if the draftDirty property should be set to true for this request.
+   */
+  private boolean isMarkDraftDirty(boolean publish) {
+    return !publish && type != Type.DELETE && beanDescriptor.isDraftable();
+  }
+
+  /**
+   * Set the transaction from prior persist request.
+   * Only used when hard deleting draft & associated live beans.
+   */
+  public void setTrans(SpiTransaction transaction) {
+    this.transaction = transaction;
+    this.createdTransaction = false;
+    this.persistCascade = transaction.isPersistCascade();
+  }
+
   /**
    * Init the transaction and also check for batch on cascade escalation.
    */
@@ -229,7 +253,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   }
 
   public boolean isNotify() {
-    this.notifyCache = beanDescriptor.isCacheNotify();
+    this.notifyCache = beanDescriptor.isCacheNotify(publish);
     return notifyCache || isNotifyPersistListener();
   }
 
@@ -243,17 +267,18 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   public void notifyCache() {
     if (notifyCache) {
       switch (type) {
-      case INSERT:
-        beanDescriptor.cacheHandleInsert(this);
-        break;
-      case UPDATE:
-        beanDescriptor.cacheHandleUpdate(idValue, this);
-        break;
-      case DELETE:
-        // Bean deleted from cache early via postDelete()
-        break;
-      default:
-        throw new IllegalStateException("Invalid type " + type);
+        case INSERT:
+          beanDescriptor.cacheHandleInsert(this);
+          break;
+        case UPDATE:
+          beanDescriptor.cacheHandleUpdate(idValue, this);
+          break;
+        case DELETE:
+        case SOFT_DELETE:
+          // Bean deleted from cache early via postDelete()
+          break;
+        default:
+          throw new IllegalStateException("Invalid type " + type);
       }
     }
   }
@@ -415,6 +440,45 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     return beanDescriptor.getId(entityBean);
   }
 
+  /**
+   * Create and return a new reference bean matching this beans Id value.
+   */
+  public T createReference() {
+    return beanDescriptor.createReference(Boolean.FALSE, getBeanId());
+  }
+
+  /**
+   * Return true if the bean type is a Draftable.
+   */
+  public boolean isDraftable() {
+    return beanDescriptor.isDraftable();
+  }
+
+  /**
+   * Return true if this request is a hard delete of a draftable bean.
+   * If this is true Ebean is expected to auto-publish and delete the associated live bean.
+   */
+  public boolean isHardDeleteDraft() {
+    if (type == Type.DELETE && beanDescriptor.isDraftable() && !beanDescriptor.isDraftableElement()) {
+      // deleting a top level draftable bean
+      if (beanDescriptor.isLiveInstance(entityBean)) {
+        throw new PersistenceException("Explicit Delete is not allowed on a 'live' bean - only draft beans");
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Checks for @Draftable entity beans with @Draft property that the bean is a 'draft'.
+   * Save or Update is not allowed to execute using 'live' beans - must use publish().
+   */
+  public void checkDraft() {
+    if (beanDescriptor.isDraftable() && beanDescriptor.isLiveInstance(entityBean)) {
+      throw new PersistenceException("Save or update is not allowed on a 'live' bean - only draft beans");
+    }
+  }
+
   /**
    * Return the parent bean for cascading save with unidirectional relationship.
    */
@@ -447,27 +511,39 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   @Override
   public int executeNow() {
     switch (type) {
-    case INSERT:
-      persistExecute.executeInsertBean(this);
-      return -1;
+      case INSERT:
+        persistExecute.executeInsertBean(this);
+        return -1;
 
-    case UPDATE:
-      if (beanPersistListener != null) {
-        // store the updated properties for sending later
-        updatedProperties = getUpdatedProperties();
-      }
-      persistExecute.executeUpdateBean(this);
-      return -1;
+      case UPDATE:
+        if (beanPersistListener != null) {
+          // store the updated properties for sending later
+          updatedProperties = getUpdatedProperties();
+        }
+        persistExecute.executeUpdateBean(this);
+        return -1;
 
-    case DELETE:
-      persistExecute.executeDeleteBean(this);
-      return -1;
+      case SOFT_DELETE:
+        prepareForSoftDelete();
+        persistExecute.executeUpdateBean(this);
+        return -1;
 
-    default:
-      throw new RuntimeException("Invalid type " + type);
+      case DELETE:
+        return persistExecute.executeDeleteBean(this);
+
+      default:
+        throw new RuntimeException("Invalid type " + type);
     }
   }
 
+  /**
+   * Soft delete is executed as update so we want to set deleted=true property.
+   */
+  private void prepareForSoftDelete() {
+
+    beanDescriptor.setSoftDeleteValue(entityBean);
+  }
+
   @Override
   public int executeOrQueue() {
 
@@ -508,13 +584,18 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    * Check for optimistic concurrency exception.
    */
   public final void checkRowCount(int rowCount) {
-    if (rowCount != 1) {
+    if (ConcurrencyMode.VERSION == concurrencyMode && rowCount != 1) {
       String m = Message.msg("persist.conc2", "" + rowCount);
       throw new OptimisticLockException(m, null, bean);
     }
     switch (type) {
-      case DELETE: postDelete(); break;
-      case UPDATE: postUpdate(); break;
+      case DELETE:
+      case SOFT_DELETE:
+        postDelete();
+        break;
+      case UPDATE:
+        postUpdate();
+        break;
       default: // do nothing
     }
   }
@@ -571,35 +652,40 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
   private void controllerPost() {
     switch (type) {
-    case INSERT:
-      controller.postInsert(this);
-      break;
-    case UPDATE:
-      controller.postUpdate(this);
-      break;
-    case DELETE:
-      controller.postDelete(this);
-      break;
-    default:
-      break;
+      case INSERT:
+        controller.postInsert(this);
+        break;
+      case UPDATE:
+        controller.postUpdate(this);
+        break;
+      case DELETE:
+      case SOFT_DELETE:
+        controller.postDelete(this);
+        break;
+      default:
+        break;
     }
   }
 
   private void logSummary() {
 
+    String draft = (beanDescriptor.isDraftable() && !publish) ? " draft[true]" : "";
     String name = beanDescriptor.getName();
     switch (type) {
-    case INSERT:
-      transaction.logSummary("Inserted [" + name + "] [" + idValue + "]");
-      break;
-    case UPDATE:
-      transaction.logSummary("Updated [" + name + "] [" + idValue + "]");
-      break;
-    case DELETE:
-      transaction.logSummary("Deleted [" + name + "] [" + idValue + "]");
-      break;
-    default:
-      break;
+      case INSERT:
+        transaction.logSummary("Inserted [" + name + "] [" + idValue + "]" + draft);
+        break;
+      case UPDATE:
+        transaction.logSummary("Updated [" + name + "] [" + idValue + "]" + draft);
+        break;
+      case DELETE:
+        transaction.logSummary("Deleted [" + name + "] [" + idValue + "]" + draft);
+        break;
+      case SOFT_DELETE:
+        transaction.logSummary("SoftDelete [" + name + "] [" + idValue + "]" + draft);
+        break;
+      default:
+        break;
     }
   }
 
@@ -667,6 +753,10 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     for (int i = 0; i < len; i++) {
       intercept.setLoadedProperty(i);
     }
+    beanDescriptor.setEmbeddedOwner(entityBean);
+    if (!publish) {
+      beanDescriptor.setDraft(entityBean);
+    }
   }
 
   public boolean isReference() {
@@ -720,7 +810,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   /**
    * Determine if all loaded properties should be used for an update.
    * <p>
-   *   Takes into account transaction setting and JDBC batch.
+   * Takes into account transaction setting and JDBC batch.
    * </p>
    */
   public boolean determineUpdateAllLoadedProperties() {
@@ -736,4 +826,52 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
     return requestUpdateAllLoadedProps;
   }
+
+  /**
+   * Return true if this request is a 'publish' action.
+   */
+  public boolean isPublish() {
+    return publish;
+  }
+
+  /**
+   * Return the key for an update persist request.
+   */
+  public int getUpdatePlanHash() {
+
+    int hash;
+    if (determineUpdateAllLoadedProperties()) {
+      hash = intercept.getLoadedPropertyHash();
+    } else {
+      hash = intercept.getDirtyPropertyHash();
+    }
+
+    BeanProperty versionProperty = beanDescriptor.getVersionProperty();
+    if (versionProperty != null) {
+      if (intercept.isLoadedProperty(versionProperty.getPropertyIndex())) {
+        hash = hash * 31 + 7;
+      }
+    }
+
+    if (publish) {
+      hash = hash * 31;
+    }
+
+    return hash;
+  }
+
+  /**
+   * Return the table to update depending if the request is a 'publish' one or normal.
+   */
+  public String getUpdateTable() {
+    return publish ? beanDescriptor.getBaseTable() : beanDescriptor.getDraftTable();
+  }
+
+  /**
+   * Return true if this is a soft delete request.
+   */
+  public boolean isSoftDelete() {
+    return Type.SOFT_DELETE == type;
+  }
+
 }

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

@@ -1,14 +1,15 @@
 package com.avaje.ebeaninternal.server.core;
 
 import java.util.Collection;
+import java.util.List;
 
 import com.avaje.ebean.CallableSql;
+import com.avaje.ebean.Query;
 import com.avaje.ebean.SqlUpdate;
 import com.avaje.ebean.Transaction;
 import com.avaje.ebean.Update;
 import com.avaje.ebean.bean.EntityBean;
 
-
 /**
  * API for persisting a bean.
  */
@@ -17,77 +18,84 @@ public interface Persister {
   /**
    * Update the bean.
    */
-    void update(EntityBean entityBean, Transaction t);
+  void update(EntityBean entityBean, Transaction t);
 
-    /**
-     * Update the bean specifying deleteMissingChildren.
-     */
-    void update(EntityBean entityBean, Transaction t, boolean deleteMissingChildren);
+  /**
+   * Update the bean specifying deleteMissingChildren.
+   */
+  void update(EntityBean entityBean, Transaction t, boolean deleteMissingChildren);
 
-    /**
-     * Force an Insert using the given bean.
-     */
-    void insert(EntityBean entityBean, Transaction t);
+  /**
+   * Force an Insert using the given bean.
+   */
+  void insert(EntityBean entityBean, Transaction t);
 
-    /**
-     * Insert or update the bean depending on its state.
-     */
-    void save(EntityBean entityBean, Transaction t);
+  /**
+   * Insert or update the bean depending on its state.
+   */
+  void save(EntityBean entityBean, Transaction t);
 
-    /**
-     * Save the associations of a ManyToMany given the owner bean and the
-     * propertyName of the ManyToMany collection.
-     */
-    void saveManyToManyAssociations(EntityBean ownerBean, String propertyName, Transaction t);
+  /**
+   * Save the associations of a ManyToMany given the owner bean and the
+   * propertyName of the ManyToMany collection.
+   */
+  void saveManyToManyAssociations(EntityBean ownerBean, String propertyName, Transaction t);
 
-    /**
-     * Save an association (OneToMany, ManyToOne, OneToOne or ManyToMany).
-     * 
-     * @param parentBean
-     *            the bean that owns the association.
-     * @param propertyName
-     *            the name of the property to save.
-     * @param t
-     *            the transaction to use.
-     */
-    void saveAssociation(EntityBean parentBean, String propertyName, Transaction t);
+  /**
+   * Save an association (OneToMany, ManyToOne, OneToOne or ManyToMany).
+   *
+   * @param parentBean   the bean that owns the association.
+   * @param propertyName the name of the property to save.
+   * @param t            the transaction to use.
+   */
+  void saveAssociation(EntityBean parentBean, String propertyName, Transaction t);
 
-    /**
-     * Delete the associations of a ManyToMany given the owner bean and the property name of the ManyToMany.
-     */
-    int deleteManyToManyAssociations(EntityBean ownerBean, String propertyName, Transaction t);
+  /**
+   * Delete the associations of a ManyToMany given the owner bean and the property name of the ManyToMany.
+   */
+  int deleteManyToManyAssociations(EntityBean ownerBean, String propertyName, Transaction t);
 
-    /**
-     * Delete a bean given it's type and id value.
-     * <p>
-     * This will also cascade delete one level of children.
-     * </p>
-     */
-    int delete(Class<?> beanType, Object id, Transaction transaction);
+  /**
+   * Delete a bean given it's type and id value.
+   * <p>
+   * This will also cascade delete one level of children.
+   * </p>
+   */
+  int delete(Class<?> beanType, Object id, Transaction transaction);
 
-    /**
-     * Delete the bean.
-     */
-    void delete(EntityBean entityBean, Transaction t);
+  /**
+   * Delete the bean.
+   */
+  boolean delete(EntityBean entityBean, Transaction t, boolean permanent);
 
-    /**
-     * Delete multiple beans given a collection of Id values.
-     */
-    void deleteMany(Class<?> beanType, Collection<?> ids, Transaction transaction);
+  /**
+   * Delete multiple beans given a collection of Id values.
+   */
+  void deleteMany(Class<?> beanType, Collection<?> ids, Transaction transaction);
+
+  /**
+   * Execute the Update.
+   */
+  int executeOrmUpdate(Update<?> update, Transaction t);
+
+  /**
+   * Execute the UpdateSql.
+   */
+  int executeSqlUpdate(SqlUpdate update, Transaction t);
+
+  /**
+   * Execute the CallableSql.
+   */
+  int executeCallable(CallableSql callable, Transaction t);
+
+  /**
+   * Publish the draft beans matching the given query.
+   */
+  <T> List<T> publish(Query<T> query, Transaction transaction);
+
+  /**
+   * Restore the draft beans back to the matching live beans.
+   */
+  <T> List<T> draftRestore(Query<T> query, Transaction transaction);
 
-    /**
-     * Execute the Update.
-     */
-    int executeOrmUpdate(Update<?> update, Transaction t);
-    
-    /**
-     * Execute the UpdateSql.
-     */
-    int executeSqlUpdate(SqlUpdate update, Transaction t);
-    
-    /**
-     * Execute the CallableSql.
-     */
-    int executeCallable(CallableSql callable, Transaction t);
-    
 }

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

@@ -59,7 +59,7 @@ public final class RelationalQueryRequest {
      */
     public void endTransIfRequired() {
         if (createdTransaction) {
-            trans.endQueryOnly();
+            trans.commit();
         }
     }
 

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

@@ -112,4 +112,8 @@ public interface SpiOrmQueryRequest<T> {
    */
   String getDBLikeClause();
 
+  /**
+   * Mark the underlying transaction as not being query only.
+   */
+  void markNotQueryOnly();
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanCascadeInfo.java

@@ -51,8 +51,8 @@ public class BeanCascadeInfo {
     /**
      * Set to true if delete should cascade.
      */
-    public void setDelete(boolean isDelete) {
-        this.delete = isDelete;
+    public void setDelete(boolean delete) {
+        this.delete = delete;
     }
     /**
      * Return true if save should cascade.
@@ -60,5 +60,13 @@ public class BeanCascadeInfo {
     public boolean isSave() {
         return save;
     }
-    	
+
+  /**
+   * Set cascade save and delete settings.
+   */
+  public void setSaveDelete(boolean save, boolean delete) {
+    this.save = save;
+    this.delete = delete;
+  }
+
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanDescriptor.java

@@ -1,6 +1,8 @@
 package com.avaje.ebeaninternal.server.deploy;
 
 import com.avaje.ebean.OrderBy;
+import com.avaje.ebean.PersistenceContextScope;
+import com.avaje.ebean.Query;
 import com.avaje.ebean.SqlUpdate;
 import com.avaje.ebean.Transaction;
 import com.avaje.ebean.ValuePair;
@@ -10,6 +12,7 @@ import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.bean.EntityBeanIntercept;
 import com.avaje.ebean.bean.PersistenceContext;
 import com.avaje.ebean.config.EncryptKey;
+import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebean.config.dbplatform.IdGenerator;
 import com.avaje.ebean.config.dbplatform.IdType;
 import com.avaje.ebean.event.BeanFindController;
@@ -147,11 +150,29 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
   private final String baseTableVersionsBetween;
   private final boolean historySupport;
 
+  private final BeanProperty softDeleteProperty;
+  private final boolean softDelete;
+
+  private final String draftTable;
+
+  /**
+   * DB table comment.
+   */
+  private final String dbComment;
+
   /**
    * Set to true if read auditing is on for this bean type.
    */
   private final boolean readAuditing;
 
+  private final boolean draftable;
+
+  private final boolean draftableElement;
+
+  private final BeanProperty draft;
+
+  private final BeanProperty draftDirty;
+
   /**
    * Map of BeanProperty Linked so as to preserve order.
    */
@@ -306,8 +327,9 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
   private String idBinderIdSql;
 
   private String deleteByIdSql;
-
   private String deleteByIdInSql;
+  private String softDeleteByIdSql;
+  private String softDeleteByIdInSql;
 
   private final String name;
 
@@ -319,7 +341,8 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
   private final boolean updateChangesOnly;
 
   private final boolean cacheSharableBeans;
-  
+
+  private final BeanDescriptorDraftHelp<T> draftHelp;
   private final BeanDescriptorCacheHelp<T> cacheHelp;
   private final BeanDescriptorJsonHelp<T> jsonHelp;
   
@@ -372,17 +395,25 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     this.compoundUniqueConstraints = deploy.getCompoundUniqueConstraints();
 
     this.readAuditing = deploy.isReadAuditing();
+    this.draftable = deploy.isDraftable();
+    this.draftableElement = deploy.isDraftableElement();
     this.historySupport = deploy.isHistorySupport();
+    this.draftTable = deploy.getDraftTable();
     this.baseTable = InternString.intern(deploy.getBaseTable());
     this.baseTableAsOf = deploy.getBaseTableAsOf();
     this.baseTableVersionsBetween = deploy.getBaseTableVersionsBetween();
+    this.dbComment = deploy.getDbComment();
     this.autoTunable = EntityType.ORM.equals(entityType) && (beanFinder == null);
 
     // helper object used to derive lists of properties
     DeployBeanPropertyLists listHelper = new DeployBeanPropertyLists(owner, this, deploy);
 
+    this.softDeleteProperty = listHelper.getSoftDeleteProperty();
+    this.softDelete = (softDeleteProperty != null);
     this.idProperty = listHelper.getId();
     this.versionProperty = listHelper.getVersionProperty();
+    this.draft = listHelper.getDraft();
+    this.draftDirty = listHelper.getDraftDirty();
     this.propMap = listHelper.getPropertyMap();
     this.propertiesTransient = listHelper.getTransients();
     this.propertiesNonTransient = listHelper.getNonTransients();
@@ -413,6 +444,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     this.cacheSharableBeans = noRelationships && deploy.getCacheOptions().isReadOnly();
     this.cacheHelp = new BeanDescriptorCacheHelp<T>(this, owner.getCacheManager(), deploy.getCacheOptions(), cacheSharableBeans, propertiesOneImported);
     this.jsonHelp = new BeanDescriptorJsonHelp<T>(this);
+    this.draftHelp = new BeanDescriptorDraftHelp<T>(this);
     
     // Check if there are no cascade save associated beans ( subject to change
     // in initialiseOther()). Note that if we are in an inheritance hierarchy 
@@ -484,6 +516,13 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     }
   }
 
+  /**
+   * Return the ServerConfig.
+   */
+  public ServerConfig getServerConfig() {
+    return owner.getServerConfig();
+  }
+
   /**
    * Set the server. Primarily so that the Many's can lazy load.
    */
@@ -525,12 +564,15 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
    * </p>
    * @param withHistoryTables map populated if @History is supported on this entity bean
    */
-  public void initialiseId(Map<String, String> withHistoryTables) {
+  public void initialiseId(Map<String, String> withHistoryTables, Map<String,String> draftTables) {
 
     if (logger.isTraceEnabled()) {
       logger.trace("BeanDescriptor initialise " + fullName);
     }
 
+    if (draftable) {
+      draftTables.put(baseTable, draftTable);
+    }
     if (historySupport) {
       // add mapping (used to swap out baseTable for asOf queries)
       withHistoryTables.put(baseTable, baseTableAsOf);
@@ -558,16 +600,21 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
    *
    * @param asOfTableMap the map of base tables to associated 'with history' tables
    * @param asOfViewSuffix the suffix added to the table name to derive the 'with history' view name
+   * @param draftTableMap the map of base tables to associated 'draft' tables.
    */
-  public void initialiseOther(Map<String, String> asOfTableMap, String asOfViewSuffix) {
+  public void initialiseOther(Map<String, String> asOfTableMap, String asOfViewSuffix, Map<String, String> draftTableMap) {
+
+    for (int i = 0; i < propertiesManyToMany.length; i++) {
+      // register associated draft table for M2M intersection
+      propertiesManyToMany[i].registerDraftIntersectionTable(draftTableMap);
+    }
 
     if (historySupport) {
       // history support on this bean so check all associated intersection tables
       // and if they are not excluded register the associated 'with history' table
       for (int i = 0; i < propertiesManyToMany.length; i++) {
+        // register associated history table for M2M intersection
         if (!propertiesManyToMany[i].isExcludedFromHistory()) {
-          // this intersection table has history support so also register
-          // it into the asOfTableMap
           TableJoin intersectionTableJoin = propertiesManyToMany[i].getIntersectionTableJoin();
           String intersectionTableName = intersectionTableJoin.getTable();
           asOfTableMap.put(intersectionTableName, intersectionTableName + asOfViewSuffix);
@@ -597,6 +644,14 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     deleteByIdSql = "delete from " + baseTable + " where " + idEqualsSql;
     deleteByIdInSql = "delete from " + baseTable + " where " + idBinderInLHSSqlNoAlias + " ";
 
+    if (softDelete) {
+      softDeleteByIdSql = "update " + baseTable + " set " + getSoftDeleteDbSet() + " where " + idEqualsSql;
+      softDeleteByIdInSql = "update " + baseTable + " set " + getSoftDeleteDbSet() + " where " + idBinderInLHSSqlNoAlias + " ";
+    } else {
+      softDeleteByIdSql = null;
+      softDeleteByIdInSql = null;
+    }
+
     if (!isEmbedded()) {
       // parse every named update up front into sql dml
       for (DeployNamedUpdate namedUpdate : namedUpdates.values()) {
@@ -645,6 +700,7 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
       case INSERT:
         return changeLogFilter.includeInsert(request) ? insertBeanChange(request): null;
       case UPDATE:
+      case SOFT_DELETE:
         return changeLogFilter.includeUpdate(request) ? updateBeanChange(request): null;
       case DELETE:
         return changeLogFilter.includeDelete(request) ? deleteBeanChange(request) :null;
@@ -686,11 +742,11 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     cacheHelp.initialise();
   }
 
-  public SqlUpdate deleteById(Object id, List<Object> idList) {
+  public SqlUpdate deleteById(Object id, List<Object> idList, boolean softDelete) {
     if (id != null) {
-      return deleteById(id);
+      return deleteById(id, softDelete);
     } else {
-      return deleteByIdList(idList);
+      return deleteByIdList(idList, softDelete);
     }
   }
 
@@ -705,9 +761,10 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
    * Return SQL that can be used to delete a list of Id's without any optimistic
    * concurrency checking.
    */
-  private SqlUpdate deleteByIdList(List<Object> idList) {
+  private SqlUpdate deleteByIdList(List<Object> idList, boolean softDelete) {
 
-    StringBuilder sb = new StringBuilder(deleteByIdInSql);
+    String baseSql = softDelete ? softDeleteByIdInSql : deleteByIdInSql;
+    StringBuilder sb = new StringBuilder(baseSql);
     String inClause = idBinder.getIdInValueExprDelete(idList.size());
     sb.append(inClause);
 
@@ -722,9 +779,10 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
    * Return SQL that can be used to delete by Id without any optimistic
    * concurrency checking.
    */
-  private SqlUpdate deleteById(Object id) {
+  private SqlUpdate deleteById(Object id, boolean softDelete) {
 
-    DefaultSqlUpdate sqlDelete = new DefaultSqlUpdate(deleteByIdSql);
+    String baseSql = softDelete ? softDeleteByIdSql : deleteByIdSql;
+    DefaultSqlUpdate sqlDelete = new DefaultSqlUpdate(baseSql);
 
     Object[] bindValues = idBinder.getBindValues(id);
     for (int i = 0; i < bindValues.length; i++) {
@@ -810,6 +868,24 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     return inheritInfo == null || inheritInfo.isRoot();
   }
 
+  public T publish(T draftBean, T liveBean) {
+    return draftHelp.publish(draftBean, liveBean);
+  }
+
+  /**
+   * Reset properties on the draft bean based on @DraftDirty and @DraftReset.
+   */
+  public boolean draftReset(T draftBean) {
+    return draftHelp.draftReset(draftBean);
+  }
+
+  /**
+   * Return the draft dirty boolean property or null if there is not one assigned to this bean type.
+   */
+  public BeanProperty getDraftDirty() {
+    return draftDirty;
+  }
+
   /**
    * Set the bean caching on or off.
    */
@@ -831,7 +907,11 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
   /**
    * Return true if the persist request needs to notify the cache.
    */
-  public boolean isCacheNotify() {
+  public boolean isCacheNotify(boolean publish) {
+    if (draftable && !publish) {
+      // no caching when editing draft beans
+      return false;
+    }
     return cacheHelp.isCacheNotify();
   }
 
@@ -1129,6 +1209,16 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     return deleteRecurseSkippable;
   }
 
+  /**
+   * Return true if delete can use a single SQL statement.
+   *
+   * This implies cascade delete does not continue depth wise and that this is no
+   * associated L2 bean caching.
+   */
+  public boolean isDeleteByStatement() {
+    return deleteRecurseSkippable && !isBeanCaching();
+  }
+
   /**
    * Find a property annotated with @WhenCreated or @CreatedTimestamp.
    */
@@ -1556,6 +1646,15 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     return new ElComparatorProperty<T>(elGetValue, sortProp.isAscending(), nullsHigh);
   }
 
+  @Override
+  public boolean isValidExpression(String propertyName) {
+    try {
+      return (getElGetValue(propertyName) != null);
+    } catch (PersistenceException e) {
+      return false;
+    }
+  }
+
   /**
    * Get an Expression language Value object.
    */
@@ -1843,6 +1942,13 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     return EntityType.SQL.equals(entityType);
   }
 
+  /**
+   * Return the DB comment for the base table.
+   */
+  public String getDbComment() {
+    return dbComment;
+  }
+
   /**
    * Return the base table. Only properties mapped to the base table are by
    * default persisted.
@@ -1856,12 +1962,20 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
    */
   public String getBaseTable(SpiQuery.TemporalMode mode) {
     switch (mode) {
+      case DRAFT: return draftTable;
       case VERSIONS: return baseTableVersionsBetween;
       case AS_OF: return baseTableAsOf;
         default: return baseTable;
     }
   }
 
+  /**
+   * Return the associated draft table.
+   */
+  public String getDraftTable() {
+    return draftTable;
+  }
+
   /**
    * Return true if read auditing is on this entity bean.
    */
@@ -1869,6 +1983,90 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     return readAuditing;
   }
 
+  public boolean isSoftDelete() {
+    return softDelete;
+  }
+
+  public void setSoftDeleteValue(EntityBean bean) {
+    softDeleteProperty.setSoftDeleteValue(bean);
+  }
+
+  public String getSoftDeleteDbSet() {
+    return softDeleteProperty.getSoftDeleteDbSet();
+  }
+
+  public String getSoftDeletePredicate(String tableAlias) {
+    return softDeleteProperty.getSoftDeleteDbPredicate(tableAlias);
+  }
+
+  /**
+   * Return true if this entity type is draftable.
+   */
+  public boolean isDraftable() {
+    return draftable;
+  }
+
+  /**
+   * Return true if this entity type is a draftable element (child).
+   */
+  public boolean isDraftableElement() {
+    return draftableElement;
+  }
+
+  /**
+   * Set the draft to true for this entity bean instance.
+   * This bean is being loaded via asDraft() query.
+   */
+  public void setDraft(EntityBean entityBean) {
+    if (draft != null) {
+      draft.setValue(entityBean, true);
+    }
+  }
+
+  /**
+   * Return true if the bean is considered a 'draft' instance (not 'live').
+   */
+  public boolean isDraftInstance(EntityBean entityBean) {
+    if (draft != null) {
+      return Boolean.TRUE == draft.getValue(entityBean);
+    }
+    // no draft property - so return false
+    return false;
+  }
+
+  /**
+   * Return true if the bean is draftable and considered a 'live' instance.
+   */
+  public boolean isLiveInstance(EntityBean entityBean) {
+    if (draft != null) {
+      return Boolean.FALSE == draft.getValue(entityBean);
+    }
+    // no draft property - so return false
+    return false;
+  }
+
+  /**
+   * If there is a @DraftDirty property set it's value on the bean.
+   */
+  public void setDraftDirty(EntityBean entityBean, boolean value) {
+    if (draftDirty != null) {
+      // check to see if the dirty property has already
+      // been set and if so do not set the value
+      if (!entityBean._ebean_getIntercept().isChangedProperty(draftDirty.getPropertyIndex())) {
+        draftDirty.setValueIntercept(entityBean, value);
+      }
+    }
+  }
+
+  /**
+   * Optimise the draft query fetching any draftable element relationships.
+   */
+  public void draftQueryOptimise(Query<T> query) {
+    // use per query PersistenceContext to ensure fresh beans loaded
+    query.setPersistenceContextScope(PersistenceContextScope.QUERY);
+    draftHelp.draftQueryOptimise(query);
+  }
+
   /**
    * Return true if this entity bean has history support.
    */
@@ -1961,6 +2159,15 @@ public class BeanDescriptor<T> implements MetaBeanInfo, SpiBeanType<T> {
     return propertiesEmbedded;
   }
 
+  /**
+   * Set the embedded owner on any embedded bean properties.
+   */
+  public void setEmbeddedOwner(EntityBean bean) {
+    for (int i = 0; i < propertiesEmbedded.length; i++) {
+      propertiesEmbedded[i].setEmbeddedOwner(bean);
+    }
+  }
+
   public BeanProperty getIdProperty() {
     return idProperty;
   }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanDescriptorDraftHelp.java

@@ -0,0 +1,121 @@
+package com.avaje.ebeaninternal.server.deploy;
+
+import com.avaje.ebean.Query;
+import com.avaje.ebean.bean.EntityBean;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Helper for BeanDescriptor that manages draft entity beans.
+ * 
+ * @param <T> The entity bean type
+ */
+public final class BeanDescriptorDraftHelp<T> {
+
+  private final BeanDescriptor<T> desc;
+
+  private final BeanProperty draftDirty;
+
+  private final BeanProperty[] resetProperties;
+
+  public BeanDescriptorDraftHelp(BeanDescriptor<T> desc) {
+    this.desc = desc;
+    this.draftDirty = desc.getDraftDirty();
+    this.resetProperties = resetProperties();
+  }
+
+  /**
+   * Return the properties that are reset on draft beans after publish.
+   */
+  private BeanProperty[] resetProperties() {
+
+    List<BeanProperty> list = new ArrayList<BeanProperty>();
+
+    BeanProperty[] props = desc.propertiesNonMany();
+    for (BeanProperty prop : props) {
+      if (prop.isDraftReset()) {
+        list.add(prop);
+      }
+    }
+
+    return list.toArray(new BeanProperty[list.size()]);
+  }
+
+  /**
+   * Set the value of all the 'reset properties' to null on the draft bean.
+   */
+  public boolean draftReset(T draftBean) {
+
+    EntityBean draftEntityBean = (EntityBean)draftBean;
+
+    if (draftDirty != null) {
+      // set @DraftDirty property to false
+      draftDirty.setValueIntercept(draftEntityBean, false);
+    }
+
+    // set to null on all @DraftReset properties
+    for (BeanProperty resetProperty : resetProperties) {
+      resetProperty.setValueIntercept(draftEntityBean, null);
+    }
+
+    // return true if the bean is dirty (and should be persisted)
+    return draftEntityBean._ebean_getIntercept().isDirty();
+  }
+
+  /**
+   * Transfer the values from the draftBean to the liveBean.
+   * <p>
+   * This will recursive transfer values to all @DraftableElement properties.
+   * </p>
+   */
+  public T publish(T draftBean, T liveBean) {
+
+    if (liveBean == null) {
+      liveBean = (T)desc.createEntityBean();
+    }
+
+    EntityBean draft = (EntityBean)draftBean;
+    EntityBean live = (EntityBean)liveBean;
+
+    BeanProperty idProperty = desc.getIdProperty();
+    if (idProperty != null) {
+      idProperty.publish(draft, live);
+    }
+
+    BeanProperty[] props = desc.propertiesNonMany();
+    for (int i = 0; i < props.length; i++) {
+      props[i].publish(draft, live);
+    }
+
+    BeanPropertyAssocMany<?>[] many = desc.propertiesMany();
+    for (int i = 0; i < many.length; i++) {
+      if (many[i].getTargetDescriptor().isDraftable()) {
+        many[i].publishMany(draft, live);
+      }
+    }
+
+    return liveBean;
+  }
+
+  /**
+   * Fetch draftable element relationships.
+   */
+  public void draftQueryOptimise(Query<T> query) {
+
+    BeanPropertyAssocOne<?>[] one = desc.propertiesOne();
+    for (int i = 0; i < one.length; i++) {
+      if (one[i].getTargetDescriptor().isDraftableElement()) {
+        query.fetch(one[i].getName());
+      }
+    }
+
+    BeanPropertyAssocMany<?>[] many = desc.propertiesMany();
+    for (int i = 0; i < many.length; i++) {
+      if (many[i].getTargetDescriptor().isDraftableElement()) {
+        query.fetch(many[i].getName());
+      }
+    }
+
+  }
+}

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanDescriptorManager.java

@@ -5,6 +5,7 @@ import com.avaje.ebean.Model;
 import com.avaje.ebean.RawSql;
 import com.avaje.ebean.RawSqlBuilder;
 import com.avaje.ebean.annotation.ConcurrencyMode;
+import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.EntityBean;
 import com.avaje.ebean.cache.ServerCacheManager;
 import com.avaje.ebean.config.EncryptKey;
@@ -124,6 +125,8 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
   private final String serverName;
 
+  private final ServerConfig serverConfig;
+
   private Map<Class<?>, DeployBeanInfo<?>> deplyInfoMap = new HashMap<Class<?>, DeployBeanInfo<?>>();
 
   private final Map<Class<?>, BeanTable> beanTableMap = new HashMap<Class<?>, BeanTable>();
@@ -167,13 +170,17 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
    */
   private final Map<String,String> asOfTableMap = new HashMap<String, String>();
 
+  /**
+   * Map of base tables to 'draft' tables.
+   */
+  private final Map<String,String> draftTableMap = new HashMap<String, String>();
+
   /**
    * Create for a given database dbConfig.
    */
   public BeanDescriptorManager(InternalConfiguration config) {
 
-    ServerConfig serverConfig = config.getServerConfig();
-
+    this.serverConfig = config.getServerConfig();
     this.serverName = InternString.intern(serverConfig.getName());
     this.cacheManager = config.getCacheManager();
     this.xmlConfig = config.getXmlConfig();
@@ -234,6 +241,11 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     return (historySupport == null ) ? serverConfig.getAsOfViewSuffix() : historySupport.getVersionsBetweenSuffix(serverConfig.getAsOfViewSuffix());
   }
 
+  @Override
+  public ServerConfig getServerConfig() {
+    return serverConfig;
+  }
+
   @SuppressWarnings("unchecked")
   public <T> BeanDescriptor<T> getBeanDescriptor(Class<T> entityType) {
     return (BeanDescriptor<T>) descMap.get(entityType.getName());
@@ -269,6 +281,13 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     return idBinderFactory.createIdBinder(idProperty);
   }
 
+  /**
+   * Return the map of base tables to draft tables.
+   */
+  public Map<String,String> getDraftTableMap() {
+    return draftTableMap;
+  }
+
   /**
    * Deploy returning the asOfTableMap (which is required by the SQL builders).
    */
@@ -396,7 +415,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     // first (as they are needed to initialise the
     // associated properties in the second pass).
     for (BeanDescriptor<?> d : descMap.values()) {
-      d.initialiseId(asOfTableMap);
+      d.initialiseId(asOfTableMap, draftTableMap);
     }
 
     // PASS 2:
@@ -411,7 +430,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
       // also look for intersection tables with
       // associated history support and register them
       // into the asOfTableMap
-      d.initialiseOther(asOfTableMap, asOfViewSuffix);
+      d.initialiseOther(asOfTableMap, asOfViewSuffix, draftTableMap);
     }
 
     // create BeanManager for each non-embedded entity bean
@@ -898,7 +917,13 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
    */
   private void checkMappedByOneToMany(DeployBeanInfo<?> info, DeployBeanPropertyAssocMany<?> prop) {
 
-    // get the bean descriptor that holds the mappedBy property
+    DeployBeanDescriptor<?> targetDesc = getTargetDescriptor(prop);
+
+    if (targetDesc.isDraftableElement()) {
+      // automatically turning on orphan removal and CascadeType.ALL
+      prop.setModifyListenMode(BeanCollection.ModifyListenMode.REMOVALS);
+      prop.getCascadeInfo().setSaveDelete(true, true);
+    }
 
     if (prop.getMappedBy() == null) {
       if (!findMappedBy(prop)) {
@@ -912,7 +937,6 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     String mappedBy = prop.getMappedBy();
 
     // get the mappedBy property
-    DeployBeanDescriptor<?> targetDesc = getTargetDescriptor(prop);
     DeployBeanProperty mappedProp = targetDesc.getBeanProperty(mappedBy);
     if (mappedProp == null) {
 
@@ -948,6 +972,9 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     // get the bean descriptor that holds the mappedBy property
     String mappedBy = prop.getMappedBy();
     if (mappedBy == null) {
+      if (getTargetDescriptor(prop).isDraftable()) {
+        prop.setIntersectionDraftTable();
+      }
       return;
     }
 
@@ -995,6 +1022,10 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     DeployTableJoin inverseJoin = new DeployTableJoin();
     mappedIntJoin.copyTo(inverseJoin, false, intTableName);
     prop.setInverseJoin(inverseJoin);
+
+    if (targetDesc.isDraftable()) {
+      prop.setIntersectionDraftTable();
+    }
   }
 
   private <T> void setBeanControllerFinderListener(DeployBeanDescriptor<T> descriptor) {

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanDescriptorMap.java

@@ -2,6 +2,7 @@ package com.avaje.ebeaninternal.server.deploy;
 
 import com.avaje.ebean.cache.ServerCacheManager;
 import com.avaje.ebean.config.EncryptKey;
+import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebeaninternal.server.deploy.id.IdBinder;
 
 /**
@@ -12,26 +13,31 @@ import com.avaje.ebeaninternal.server.deploy.id.IdBinder;
  */
 public interface BeanDescriptorMap {
 
-    /**
-     * Return the name of the server/database.
-     */
-    String getServerName();
+  /**
+   * Return the name of the server/database.
+   */
+  String getServerName();
 
-    /**
-     * Return the Cache Manager.
-     */
-    ServerCacheManager getCacheManager();
+  /**
+   * Return the ServerConfig.
+   */
+  ServerConfig getServerConfig();
 
-    /**
-     * Return the BeanDescriptor for a given class.
-     */
-    <T> BeanDescriptor<T> getBeanDescriptor(Class<T> entityType);
+  /**
+   * Return the Cache Manager.
+   */
+  ServerCacheManager getCacheManager();
 
-    /**
-     * Return the Encrypt key given the table and column name.
-     */
-    EncryptKey getEncryptKey(String tableName, String columnName);
-    
-    IdBinder createIdBinder(BeanProperty id);
+  /**
+   * Return the BeanDescriptor for a given class.
+   */
+  <T> BeanDescriptor<T> getBeanDescriptor(Class<T> entityType);
+
+  /**
+   * Return the Encrypt key given the table and column name.
+   */
+  EncryptKey getEncryptKey(String tableName, String columnName);
+
+  IdBinder createIdBinder(BeanProperty id);
 
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanMapHelp.java

@@ -84,7 +84,7 @@ public final class BeanMapHelp<T> implements BeanCollectionHelp<T> {
       this.map = map;
     }
 
-    public void addBean(EntityBean bean) {
+    public void addEntityBean(EntityBean bean) {
       Object keyValue = beanProperty.getValue(bean);
       map.put(keyValue, bean);
     }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanProperty.java

@@ -22,6 +22,7 @@ import com.avaje.ebeaninternal.server.text.json.ReadJson;
 import com.avaje.ebeaninternal.server.text.json.WriteJson;
 import com.avaje.ebeaninternal.server.type.DataBind;
 import com.avaje.ebeaninternal.server.type.ScalarType;
+import com.avaje.ebeaninternal.server.type.ScalarTypeBoolean;
 import com.avaje.ebeaninternal.util.ValueUtil;
 import com.fasterxml.jackson.core.JsonToken;
 import org.slf4j.Logger;
@@ -210,6 +211,11 @@ public class BeanProperty implements ElPropertyValue {
    */
   final String dbColumnDefn;
 
+  /**
+   * Database DDL column comment.
+   */
+  final String dbComment;
+
   /**
    * DB Constraint (typically check constraint on enum)
    */
@@ -223,6 +229,20 @@ public class BeanProperty implements ElPropertyValue {
 
   final boolean jsonDeserialize;
 
+  final boolean draft;
+
+  final boolean draftOnly;
+
+  final boolean draftDirty;
+
+  final boolean draftReset;
+
+  final boolean softDelete;
+
+  final String softDeleteDbSet;
+
+  final String softDeleteDbPredicate;
+
   final boolean indexed;
 
   final String indexName;
@@ -249,7 +269,10 @@ public class BeanProperty implements ElPropertyValue {
     this.dbInsertable = deploy.isDbInsertable();
     this.dbUpdatable = deploy.isDbUpdateable();
     this.excludedFromHistory = deploy.isExcludedFromHistory();
-
+    this.draft = deploy.isDraft();
+    this.draftDirty = deploy.isDraftDirty();
+    this.draftOnly = deploy.isDraftOnly();
+    this.draftReset = deploy.isDraftReset();
     this.secondaryTable = deploy.isSecondaryTable();
     if (secondaryTable) {
       this.secondaryTableJoin = new TableJoin(deploy.getSecondaryTableJoin());
@@ -280,6 +303,7 @@ public class BeanProperty implements ElPropertyValue {
     this.setter = deploy.getSetter();
 
     this.dbColumn = tableAliasIntern(descriptor, deploy.getDbColumn(), false, null);
+    this.dbComment = deploy.getDbComment();
     this.sqlFormulaJoin = InternString.intern(deploy.getSqlFormulaJoin());
     this.sqlFormulaSelect = InternString.intern(deploy.getSqlFormulaSelect());
     this.formula = sqlFormulaSelect != null;
@@ -293,6 +317,16 @@ public class BeanProperty implements ElPropertyValue {
     this.elPlaceHolder = tableAliasIntern(descriptor, deploy.getElPlaceHolder(), false, null);
     this.elPlaceHolderEncrypted = tableAliasIntern(descriptor, deploy.getElPlaceHolder(), dbEncrypted, dbColumn);
 
+    this.softDelete = deploy.isSoftDelete();
+    if (softDelete) {
+      ScalarTypeBoolean.BooleanBase boolType = (ScalarTypeBoolean.BooleanBase)scalarType;
+      this.softDeleteDbSet = dbColumn+"="+boolType.getDbTrueLiteral();
+      this.softDeleteDbPredicate = "."+dbColumn+","+boolType.getDbFalseLiteral()+")="+boolType.getDbFalseLiteral();
+    } else {
+      this.softDeleteDbSet = null;
+      this.softDeleteDbPredicate = null;
+    }
+
     this.jsonSerialize = deploy.isJsonSerialize();
     this.jsonDeserialize = deploy.isJsonDeserialize();
   }
@@ -333,6 +367,13 @@ public class BeanProperty implements ElPropertyValue {
     this.formula = false;
 
     this.excludedFromHistory = source.excludedFromHistory;
+    this.draft = source.draft;
+    this.draftDirty = source.draftDirty;
+    this.draftOnly = source.draftOnly;
+    this.draftReset = source.draftReset;
+    this.softDelete = source.softDelete;
+    this.softDeleteDbSet = source.softDeleteDbSet;
+    this.softDeleteDbPredicate = source.softDeleteDbPredicate;
     this.fetchEager = source.fetchEager;
     this.unidirectionalShadow = source.unidirectionalShadow;
     this.discriminator = source.discriminator;
@@ -342,6 +383,7 @@ public class BeanProperty implements ElPropertyValue {
     this.secondaryTableJoin = source.secondaryTableJoin;
     this.secondaryTableJoinPrefix = source.secondaryTableJoinPrefix;
 
+    this.dbComment = source.dbComment;
     this.dbBind = source.getDbBind();
     this.dbEncrypted = source.isDbEncrypted();
     this.dbEncryptedType = source.getDbEncryptedType();
@@ -493,7 +535,7 @@ public class BeanProperty implements ElPropertyValue {
     if (formula) {
       ctx.appendFormulaSelect(sqlFormulaSelect);
 
-    } else if (!isTransient) {
+    } else if (!isTransient && !ignoreDraftOnlyProperty(ctx.isDraftQuery())) {
 
       if (secondaryTableJoin != null) {
         String relativePrefix = ctx.getRelativePrefix(secondaryTableJoinPrefix);
@@ -592,6 +634,42 @@ public class BeanProperty implements ElPropertyValue {
     return local;
   }
 
+  /**
+   * Copy/set the property value from the draft bean to the live bean.
+   */
+  public void publish(EntityBean draftBean, EntityBean liveBean) {
+
+    if (!version && !draftOnly) {
+      // set property value from draft to live
+      Object value = getValueIntercept(draftBean);
+      setValueIntercept(liveBean, value);
+    }
+  }
+
+  /**
+   * Return the DB literal expression to set the deleted state to true.
+   */
+  public String getSoftDeleteDbSet() {
+    return softDeleteDbSet;
+  }
+
+  /**
+   * Return the DB literal predicate used to filter out soft deleted rows from a query.
+   */
+  public String getSoftDeleteDbPredicate(String tableAlias) {
+    // use coalesce to handle null values from optional relationships
+    return "coalesce(" + tableAlias + softDeleteDbPredicate;
+  }
+
+  /**
+   * Set the soft delete property value on the bean without invoking lazy loading.
+   */
+  public void setSoftDeleteValue(EntityBean bean) {
+    // assumes boolean deleted true being set which is ok limitation for now
+    setValue(bean, true);
+    bean._ebean_getIntercept().setChangedProperty(propertyIndex);
+  }
+
   /**
    * Set the value of the property without interception or
    * PropertyChangeSupport.
@@ -600,10 +678,7 @@ public class BeanProperty implements ElPropertyValue {
     try {
       setter.set(bean, value);
     } catch (Exception ex) {
-      String beanType = bean == null ? "null" : bean.getClass().getName();
-      String msg = "set " + name + " on [" + descriptor + "] arg[" + value + "] type[" + beanType
-          + "] threw error";
-      throw new RuntimeException(msg, ex);
+      throw new RuntimeException(setterErrorMsg(bean, value, "set "), ex);
     }
   }
 
@@ -614,13 +689,18 @@ public class BeanProperty implements ElPropertyValue {
     try {
       setter.setIntercept(bean, value);
     } catch (Exception ex) {
-      String beanType = bean == null ? "null" : bean.getClass().getName();
-      String msg = "setIntercept " + name + " on [" + descriptor + "] arg[" + value + "] type[" + beanType
-          + "] threw error";
-      throw new RuntimeException(msg, ex);
+      throw new RuntimeException(setterErrorMsg(bean, value, "setIntercept "), ex);
     }
   }
 
+  /**
+   * Return an error message when calling a setter.
+   */
+  private String setterErrorMsg(EntityBean bean, Object value, String prefix) {
+    String beanType = bean == null ? "null" : bean.getClass().getName();
+    return prefix + name + " on [" + descriptor + "] arg[" + value + "] type[" + beanType + "] threw error";
+  }
+
   public Object getCacheDataValue(EntityBean bean) {
     return getValue(bean);
   }
@@ -900,8 +980,16 @@ public class BeanProperty implements ElPropertyValue {
   /**
    * Return true if this property is loadable from a resultSet.
    */
-  public boolean isLoadProperty() {
-    return !isTransient || formula;
+  public boolean isLoadProperty(boolean draftQuery) {
+    return !ignoreDraftOnlyProperty(draftQuery) && (!isTransient || formula);
+  }
+
+  /**
+   * Return true if this is a draftOnly property on a non-asDraft query and as such this
+   * property should not be included in a sql query.
+   */
+  protected boolean ignoreDraftOnlyProperty(boolean draftQuery) {
+    return draftOnly && !draftQuery;
   }
 
   /**
@@ -918,6 +1006,13 @@ public class BeanProperty implements ElPropertyValue {
     return dbColumn;
   }
 
+  /**
+   * Return the comment for the associated DB column.
+   */
+  public String getDbComment() {
+    return dbComment;
+  }
+
   /**
    * Return the database jdbc data type this is mapped to.
    */
@@ -951,7 +1046,7 @@ public class BeanProperty implements ElPropertyValue {
     return lob;
   }
 
-  private boolean isLobType(int type) {
+  public static boolean isLobType(int type) {
     switch (type) {
       case Types.CLOB:
         return true;
@@ -1000,6 +1095,43 @@ public class BeanProperty implements ElPropertyValue {
     return excludedFromHistory;
   }
 
+  /**
+   * Return true if this property only exists on the draft table.
+   */
+  public boolean isDraftOnly() {
+    return draftOnly;
+  }
+
+  /**
+   * Return true if this property is a boolean flag on a draftable bean
+   * indicating if the instance is a draft or live bean.
+   */
+  public boolean isDraft() {
+    return draft;
+  }
+
+  /**
+   * Return true if this property is a boolean flag only on the draft table
+   * indicating that when the draft is different from the published row.
+   */
+  public boolean isDraftDirty() {
+    return draftDirty;
+  }
+
+  /**
+   * Return true if this property is reset/cleared on publish (on the draft bean).
+   */
+  public boolean isDraftReset() {
+    return draftReset;
+  }
+
+  /**
+   * Return true if this property is the soft delete property.
+   */
+  public boolean isSoftDelete() {
+    return softDelete;
+  }
+
   /**
    * Return true if this property should be included in an Insert.
    */

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyAssocMany.java

@@ -23,6 +23,7 @@ import java.io.IOException;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -39,6 +40,8 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
    * Join for manyToMany intersection table.
    */
   private final TableJoin intersectionJoin;
+  private final String intersectionPublishTable;
+  private final String intersectionDraftTable;
 
   /**
    * For ManyToMany this is the Inverse join used to build reference queries.
@@ -109,6 +112,13 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
     this.mapKey = deploy.getMapKey();
     this.fetchOrderBy = deploy.getFetchOrderBy();
     this.intersectionJoin = deploy.createIntersectionTableJoin();
+    if (intersectionJoin != null) {
+      this.intersectionPublishTable = intersectionJoin.getTable();
+      this.intersectionDraftTable = deploy.getIntersectionDraftTable();
+    } else {
+      this.intersectionPublishTable = null;
+      this.intersectionDraftTable = null;
+    }
     this.inverseJoin = deploy.createInverseTableJoin();
     this.modifyListenMode = deploy.getModifyListenMode();
     this.jsonHelp = new BeanPropertyAssocManyJsonHelp(this);
@@ -790,7 +800,7 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
 
   public IntersectionRow buildManyDeleteChildren(EntityBean parentBean, ArrayList<Object> excludeDetailIds) {
 
-    IntersectionRow row = new IntersectionRow(tableJoin.getTable());
+    IntersectionRow row = new IntersectionRow(tableJoin.getTable(), targetDescriptor);
     if (excludeDetailIds != null && !excludeDetailIds.isEmpty()) {
       row.setExcludeIds(excludeDetailIds, getTargetDescriptor());
     }
@@ -798,22 +808,39 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
     return row;
   }
 
-  public IntersectionRow buildManyToManyDeleteChildren(EntityBean parentBean) {
+  public IntersectionRow buildManyToManyDeleteChildren(EntityBean parentBean, boolean publish) {
 
-    IntersectionRow row = new IntersectionRow(intersectionJoin.getTable());
+    String tableName = publish ? intersectionPublishTable : intersectionDraftTable;
+    IntersectionRow row = new IntersectionRow(tableName);
     buildExport(row, parentBean);
     return row;
   }
 
-  public IntersectionRow buildManyToManyMapBean(EntityBean parent, EntityBean other) {
-
-    IntersectionRow row = new IntersectionRow(intersectionJoin.getTable());
+  public IntersectionRow buildManyToManyMapBean(EntityBean parent, EntityBean other, boolean publish) {
 
+    String tableName = publish ? intersectionPublishTable : intersectionDraftTable;
+    IntersectionRow row = new IntersectionRow(tableName);
     buildExport(row, parent);
     buildImport(row, other);
     return row;
   }
 
+  /**
+   * Register the mapping of intersection table to associated draft table.
+   */
+  public void registerDraftIntersectionTable(Map<String, String> draftTableMap) {
+    if (hasDraftIntersection()) {
+      draftTableMap.put(intersectionPublishTable, intersectionDraftTable);
+    }
+  }
+
+  /**
+   * Return true if the relationship is a ManyToMany with the intersection having an associated draft table.
+   */
+  private boolean hasDraftIntersection() {
+    return intersectionDraftTable != null && !intersectionDraftTable.equals(intersectionPublishTable);
+  }
+
   private void buildExport(IntersectionRow row, EntityBean parentBean) {
 
     if (embeddedExportedProperties) {
@@ -876,4 +903,57 @@ public class BeanPropertyAssocMany<T> extends BeanPropertyAssoc<T> {
   public void jsonRead(ReadJson readJson, EntityBean parentBean) throws IOException {
     jsonHelp.jsonRead(readJson, parentBean);
   }
+
+  public void publishMany(EntityBean draft, EntityBean live) {
+
+    // collections will not be null due to enhancement
+    BeanCollection<T> draftVal = (BeanCollection<T>)getValueIntercept(draft);
+    BeanCollection<T> liveVal = (BeanCollection<T>)getValueIntercept(live);
+
+    // Organise the existing live beans into map keyed by id
+    Map<Object, T> liveBeansAsMap = liveBeansAsMap(liveVal);
+
+    // publish from each draft to live bean creating new live beans as required
+    draftVal.size();
+    Collection<T> actualDetails = draftVal.getActualDetails();
+    for (T bean : actualDetails) {
+      Object id = targetDescriptor.getId((EntityBean) bean);
+      T liveBean = liveBeansAsMap.remove(id);
+
+      if (isManyToMany()) {
+        if (liveBean == null) {
+          // add new relationship (Map not allowed here)
+          liveVal.addBean(targetDescriptor.createReference(Boolean.FALSE, id));
+        }
+
+      } else {
+        // recursively publish the OneToMany child bean
+        T newLive = targetDescriptor.publish(bean, liveBean);
+        if (liveBean == null) {
+          // Map not allowed here
+          liveVal.addBean(newLive);
+        }
+      }
+    }
+
+    // anything remaining should be deleted (so remove from modify aware collection)
+    Collection<T> values = liveBeansAsMap.values();
+    for (T value : values) {
+      liveVal.removeBean(value);
+    }
+  }
+
+  private Map<Object,T> liveBeansAsMap(BeanCollection<?> liveVal) {
+
+    liveVal.size();
+    Collection<?> liveBeans = liveVal.getActualDetails();
+    Map<Object,T> liveMap = new LinkedHashMap<Object, T>();
+
+    for (Object liveBean : liveBeans) {
+      Object id = targetDescriptor.getId((EntityBean) liveBean);
+      liveMap.put(id, (T)liveBean);
+    }
+    return liveMap;
+  }
+
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyAssocManyJsonHelp.java

@@ -31,7 +31,8 @@ public class BeanPropertyAssocManyJsonHelp {
    */
   public BeanPropertyAssocManyJsonHelp(BeanPropertyAssocMany<?> many) {
     this.many = many;
-    this.jsonTransient = !ClassUtil.isJacksonObjectMapperPresent() ? null : new BeanPropertyAssocManyJsonTransient();
+    boolean objectMapperPresent = many.getBeanDescriptor().getServerConfig().getClassLoadConfig().isJacksonObjectMapperPresent();
+    this.jsonTransient = !objectMapperPresent ? null : new BeanPropertyAssocManyJsonTransient();
   }
 
   /**
@@ -65,7 +66,7 @@ public class BeanPropertyAssocManyJsonHelp {
         // read the entire array
         break;
       }
-      add.addBean(detailBean);
+      add.addEntityBean(detailBean);
 
       if (parentBean != null && many.childMasterProperty != null) {
         // bind detail bean back to master via mappedBy property

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanPropertyAssocOne.java

@@ -578,17 +578,30 @@ public class BeanPropertyAssocOne<T> extends BeanPropertyAssoc<T> {
   public void setValue(EntityBean bean, Object value) {
     super.setValue(bean, value);
     if (embedded && value instanceof EntityBean) {
-      EntityBean embedded = (EntityBean) value;
-      embedded._ebean_getIntercept().setEmbeddedOwner(bean, propertyIndex);
+      setEmbeddedOwner(bean, value);
     }
   }
 
+  /**
+   * Set the owner on the embedded bean property.
+   */
+  public void setEmbeddedOwner(EntityBean owner) {
+
+    Object emb = getValue(owner);
+    if (emb != null) {
+      setEmbeddedOwner(owner, emb);
+    }
+  }
+
+  private void setEmbeddedOwner(EntityBean bean, Object value) {
+    ((EntityBean)value)._ebean_getIntercept().setEmbeddedOwner(bean, propertyIndex);
+  }
+
   @Override
   public void setValueIntercept(EntityBean bean, Object value) {
     super.setValueIntercept(bean, value);
     if (embedded && value instanceof EntityBean) {
-      EntityBean embedded = (EntityBean) value;
-      embedded._ebean_getIntercept().setEmbeddedOwner(bean, propertyIndex);
+      setEmbeddedOwner(bean, value);
     }
   }
 

src/main/java/com/avaje/ebeaninternal/server/deploy/DbReadContext.java

@@ -79,4 +79,9 @@ public interface DbReadContext {
    * Return the query mode.
    */
   SpiQuery.Mode getQueryMode();
+
+  /**
+   * Return true if the underlying query is a 'asDraft' query.
+   */
+  boolean isDraftQuery();
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/DbSqlContext.java

@@ -120,4 +120,9 @@ public interface DbSqlContext {
    */
   void appendHistorySysPeriod();
 
+  /**
+   * Return true if the query is a 'asDraft' query.
+   */
+  boolean isDraftQuery();
+
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/IntersectionRow.java

@@ -15,13 +15,21 @@ public class IntersectionRow {
 
   private final String tableName;
 
+  private final BeanDescriptor<?> targetDescriptor;
+
   private final LinkedHashMap<String, Object> values = new LinkedHashMap<String, Object>();
 
   private ArrayList<Object> excludeIds;
   private BeanDescriptor<?> excludeDescriptor;
 
+  public IntersectionRow(String tableName, BeanDescriptor<?> targetDescriptor) {
+    this.tableName = tableName;
+    this.targetDescriptor = targetDescriptor;
+  }
+
   public IntersectionRow(String tableName) {
     this.tableName = tableName;
+    this.targetDescriptor = null;
   }
 
   /**
@@ -64,22 +72,20 @@ public class IntersectionRow {
     return new DefaultSqlUpdate(server, sb.toString(), bindParams);
   }
 
-  public SqlUpdate createDelete(EbeanServer server) {
+  public SqlUpdate createDelete(EbeanServer server, boolean softDelete) {
 
     BindParams bindParams = new BindParams();
 
     StringBuilder sb = new StringBuilder();
-    sb.append("delete from ").append(tableName).append(" where ");
-
-    int count = 0;
-    for (Map.Entry<String, Object> entry : values.entrySet()) {
-      if (count++ > 0) {
-        sb.append(" and ");
-      }
-      sb.append(entry.getKey());
-      sb.append(" = ?");
-      bindParams.setParameter(count, entry.getValue());
+    if (softDelete) {
+      sb.append("update ").append(tableName).append(" set ");
+      sb.append(targetDescriptor.getSoftDeleteDbSet());
+    } else {
+      sb.append("delete from ").append(tableName);
     }
+    sb.append(" where ");
+
+    int count = setBindParams(bindParams, sb);
 
     if (excludeIds != null) {
       IdInExpression idIn = new IdInExpression(excludeIds);
@@ -108,6 +114,13 @@ public class IntersectionRow {
     StringBuilder sb = new StringBuilder();
     sb.append("delete from ").append(tableName).append(" where ");
 
+    setBindParams(bindParams, sb);
+
+    return new DefaultSqlUpdate(server, sb.toString(), bindParams);
+  }
+
+  private int setBindParams(BindParams bindParams, StringBuilder sb) {
+
     int count = 0;
     for (Map.Entry<String, Object> entry : values.entrySet()) {
       if (count++ > 0) {
@@ -120,6 +133,6 @@ public class IntersectionRow {
       bindParams.setParameter(count, entry.getValue());
     }
 
-    return new DefaultSqlUpdate(server, sb.toString(), bindParams);
+    return count;
   }
 }

src/main/java/com/avaje/ebeaninternal/server/deploy/generatedproperty/GeneratedPropertyFactory.java

@@ -3,7 +3,9 @@ package com.avaje.ebeaninternal.server.deploy.generatedproperty;
 import java.math.BigDecimal;
 import java.util.HashSet;
 
+import com.avaje.ebean.config.ClassLoadConfig;
 import com.avaje.ebean.config.CurrentUserProvider;
+import com.avaje.ebean.config.ServerConfig;
 import com.avaje.ebeaninternal.server.deploy.meta.DeployBeanProperty;
 
 /**
@@ -13,9 +15,9 @@ public class GeneratedPropertyFactory {
 
 	private final CounterFactory counterFactory = new CounterFactory();
 
-  private final InsertTimestampFactory insertFactory = new InsertTimestampFactory();
+  private final InsertTimestampFactory insertFactory;
 
-  private final UpdateTimestampFactory updateFactory = new UpdateTimestampFactory();
+  private final UpdateTimestampFactory updateFactory;
 
   private final HashSet<String> numberTypes = new HashSet<String>();
 
@@ -23,8 +25,15 @@ public class GeneratedPropertyFactory {
 
   private final GeneratedWhoCreated generatedWhoCreated;
 
-  public GeneratedPropertyFactory(CurrentUserProvider currentUserProvider) {
+  private final ClassLoadConfig classLoadConfig;
 
+  public GeneratedPropertyFactory(ServerConfig serverConfig) {
+
+    this.classLoadConfig = serverConfig.getClassLoadConfig();
+    this.insertFactory = new InsertTimestampFactory(classLoadConfig);
+    this.updateFactory = new UpdateTimestampFactory(classLoadConfig);
+
+    CurrentUserProvider currentUserProvider = serverConfig.getCurrentUserProvider();
 	  if (currentUserProvider != null) {
       generatedWhoCreated = new GeneratedWhoCreated(currentUserProvider);
       generatedWhoModified = new GeneratedWhoModified(currentUserProvider);
@@ -44,7 +53,11 @@ public class GeneratedPropertyFactory {
 		numberTypes.add(BigDecimal.class.getName());
 	}
 
-	private boolean isNumberType(String typeClassName) {
+  public ClassLoadConfig getClassLoadConfig() {
+    return classLoadConfig;
+  }
+
+  private boolean isNumberType(String typeClassName) {
 		return numberTypes.contains(typeClassName);
 	}