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

Not fixing a leak but just changing to use try with resources

README.md

@@ -11,7 +11,7 @@ Goto [https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Web
 [Maven central - all related projects](http://search.maven.org/#search%7Cga%7C1%7Cebean "maven central all related projects")
 
 ## Current versions
-* [![Maven Central : ebean](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean) - ebean
-* [![Maven Central : ebean-agent](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-agent) - ebean-agent
-* [![Maven Central : ebean-maven-plugin](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-maven-plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-maven-plugin) - ebean-maven-plugin
+* [![Maven Central : ebean](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean) - ebean
+* [![Maven Central : ebean-agent](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-agent) - ebean-agent
+* [![Maven Central : ebean-maven-plugin](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-maven-plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-maven-plugin) - ebean-maven-plugin
 

pom.xml

@@ -9,15 +9,20 @@
 
   <groupId>io.ebean</groupId>
   <artifactId>ebean</artifactId>
-  <version>11.13.1</version>
+  <version>11.17.3</version>
   <packaging>jar</packaging>
 
   <name>ebean</name>
   <url>http://ebean-orm.github.io/</url>
 
+  <properties>
+    <jackson-core.version>2.9.5</jackson-core.version>
+    <snakeyaml.version>1.21</snakeyaml.version>
+  </properties>
+
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-11.13.1</tag>
+    <tag>ebean-11.17.3</tag>
   </scm>
 
   <profiles>
@@ -89,7 +94,7 @@
     <dependency>
       <groupId>org.yaml</groupId>
       <artifactId>snakeyaml</artifactId>
-      <version>1.19</version>
+      <version>${snakeyaml.version}</version>
     </dependency>
 
     <!--
@@ -112,13 +117,13 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>3.8</version>
+      <version>3.11</version>
     </dependency>
 
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-datasource</artifactId>
-      <version>3.1.1</version>
+      <version>3.2.2</version>
     </dependency>
 
     <dependency>
@@ -130,27 +135,27 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-migration</artifactId>
-      <version>11.3.1</version>
+      <version>11.5.4</version>
     </dependency>
 
     <dependency>
       <groupId>org.antlr</groupId>
       <artifactId>antlr4-runtime</artifactId>
-      <version>4.6</version>
+      <version>4.7.1</version>
     </dependency>
 
     <!-- Jackson core used internally by Ebean -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
-      <version>2.9.0</version>
+      <version>${jackson-core.version}</version>
     </dependency>
 
     <!-- provided scope for JsonNode support -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
-      <version>2.9.0</version>
+      <version>${jackson-core.version}</version>
       <scope>provided</scope>
     </dependency>
 
@@ -224,7 +229,7 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-agent</artifactId>
-      <version>11.10.1</version>
+      <version>11.11.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -254,7 +259,7 @@
     <dependency>
       <groupId>com.microsoft.sqlserver</groupId>
       <artifactId>mssql-jdbc</artifactId>
-      <version>6.1.3.jre8-preview</version>
+      <version>6.4.0.jre8</version>
       <scope>test</scope>
     </dependency>
 
@@ -297,7 +302,7 @@
       <plugin>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-maven-plugin</artifactId>
-        <version>11.10.1</version>
+        <version>11.11.1</version>
         <executions>
           <execution>
             <id>test</id>

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

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

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

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

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

@@ -437,6 +437,19 @@ public interface EbeanServer {
    */
   <T> DtoQuery<T> findDto(Class<T> dtoType, String sql);
 
+  /**
+   * Create a named Query for DTO beans.
+   * <p>
+   * DTO beans are just normal bean like classes with public constructor(s) and setters.
+   * They do not need to be registered with Ebean before use.
+   * </p>
+   *
+   * @param dtoType    The type of the DTO bean the rows will be mapped into.
+   * @param namedQuery The name of the query
+   * @param <T>        The type of the DTO bean.
+   */
+  <T> DtoQuery<T> createNamedDtoQuery(Class<T> dtoType, String namedQuery);
+
   /**
    * Create a SqlQuery for executing native sql
    * query statements.
@@ -508,30 +521,44 @@ public interface EbeanServer {
    * etc.
    * </p>
    * <p>
+   * <h3>Using try with resources</h3>
    * <pre>{@code
    *
    *    // start a transaction (stored in a ThreadLocal)
-   *    ebeanServer.beginTransaction();
+   *
+   *    try (Transaction txn = ebeanServer.beginTransaction()) {
+   *
+   * 	    Order order = ebeanServer.find(Order.class,10);
+   * 	    ...
+   * 	    ebeanServer.save(order);
+   *
+   * 	    txn.commit();
+   *    }
+   *
+   * }</pre>
+   * <p>
+   * <h3>Using try finally block</h3>
+   * <pre>{@code
+   *
+   *    // start a transaction (stored in a ThreadLocal)
+   *    Transaction txn = ebeanServer.beginTransaction();
    *    try {
    * 	    Order order = ebeanServer.find(Order.class,10);
    *
    * 	    ebeanServer.save(order);
    *
-   * 	    ebeanServer.commitTransaction();
+   * 	    txn.commit();
    *
    *    } finally {
-   * 	    // rollback if we didn't commit
-   * 	    // i.e. an exception occurred before commitTransaction().
-   * 	    ebeanServer.endTransaction();
+   * 	    txn.end();
    *    }
    *
    * }</pre>
    * <p>
-   * <h3>Transaction options:</h3>
+   * <h3>Transaction options</h3>
    * <pre>{@code
    *
-   *     Transaction txn = ebeanServer.beginTransaction();
-   *     try {
+   *     try (Transaction txn = ebeanServer.beginTransaction()) {
    *       // explicitly turn on/off JDBC batch use
    *       txn.setBatchMode(true);
    *       txn.setBatchSize(50);
@@ -552,10 +579,6 @@ public interface EbeanServer {
    *       ...
    *
    *       txn.commit();
-   *
-   *    } finally {
-   *       // rollback if necessary
-   *       txn.end();
    *    }
    *
    * }</pre>
@@ -585,19 +608,16 @@ public interface EbeanServer {
    * <pre>{@code
    * // Start a new transaction. If there is a current transaction
    * // suspend it until this transaction ends
-   * Transaction txn = server.beginTransaction(TxScope.requiresNew());
-   * try {
+   * try (Transaction txn = server.beginTransaction(TxScope.requiresNew())) {
    *
    *   ...
    *
    *   // commit the transaction
    *   txn.commit();
    *
-   * } finally {
-   *   // end this transaction which:
-   *   //  A) will rollback transaction if it has not been committed already
+   *   // At end this transaction will:
+   *   //  A) will rollback transaction if it has not been committed
    *   //  B) will restore a previously suspended transaction
-   *   txn.end();
    * }
    *
    * }</pre>
@@ -606,20 +626,13 @@ public interface EbeanServer {
    * <pre>{@code
    *
    * // start a new transaction if there is not a current transaction
-   * Transaction txn = server.beginTransaction(TxScope.required());
-   * try {
+   * try (Transaction txn = server.beginTransaction(TxScope.required())) {
    *
    *   ...
    *
    *   // commit the transaction if it was created or
    *   // do nothing if there was already a current transaction
    *   txn.commit();
-   *
-   * } finally {
-   *   // end this transaction which will rollback the transaction
-   *   // if it was created for this try finally scope and has not
-   *   // already been committed
-   *   txn.end();
    * }
    *
    * }</pre>
@@ -1615,6 +1628,29 @@ public interface EbeanServer {
    */
   void updateAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException;
 
+  /**
+   * Merge the bean using the default merge options (no paths specified, default delete).
+   *
+   * @param bean The bean to merge
+   */
+  void merge(Object bean);
+
+  /**
+   * Merge the bean using the given merge options.
+   *
+   * @param bean    The bean to merge
+   * @param options The options to control the merge
+   */
+  void merge(Object bean, MergeOptions options);
+
+  /**
+   * Merge the bean using the given merge options and a transaction.
+   *
+   * @param bean    The bean to merge
+   * @param options The options to control the merge
+   */
+  void merge(Object bean, MergeOptions options, Transaction transaction);
+
   /**
    * Insert the bean.
    * <p>

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

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

src/main/java/io/ebean/ExpressionFactory.java

@@ -327,6 +327,30 @@ public interface ExpressionFactory {
    */
   Expression allEq(Map<String, Object> propertyMap);
 
+  /**
+   * Add expression for ANY of the given bit flags to be set.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAny(String propertyName, long flags);
+
+  /**
+   * Add expression for ALL of the given bit flags to be set.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAll(String propertyName, long flags);
+
+  /**
+   * Add bitwise AND expression of the given bit flags to compare with the match/mask.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAnd(String propertyName, long flags, long match);
+
   /**
    * Add raw expression with a single parameter.
    * <p>

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

@@ -120,6 +120,14 @@ public interface ExpressionList<T> {
    */
   Query<T> asDraft();
 
+  /**
+   * Convert the query to a DTO bean query.
+   * <p>
+   * We effectively use the underlying ORM query to build the SQL and then execute
+   * and map it into DTO beans.
+   */
+  <D> DtoQuery<D> asDto(Class<D> dtoClass);
+
   /**
    * Execute using "for update" clause which results in the DB locking the record.
    */
@@ -482,7 +490,7 @@ public interface ExpressionList<T> {
 
   /**
    * Extended version for setDistinct in conjunction with "findSingleAttributeList";
-   *
+   * <p>
    * <pre>{@code
    *
    *  List<CountedValue<Order.Status>> orderStatusCount =
@@ -545,6 +553,11 @@ public interface ExpressionList<T> {
    */
   Query<T> setDisableReadAuditing();
 
+  /**
+   * Set a label on the query (to help identify query execution statistics).
+   */
+  Query<T> setLabel(String label);
+
   /**
    * Add expressions to the having clause.
    * <p>
@@ -873,7 +886,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - using a subQuery.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -883,7 +896,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - property has a value in the array of values.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -893,7 +906,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - property has a value in the collection of values.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -991,6 +1004,53 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> arrayIsNotEmpty(String propertyName);
 
+  /**
+   * Add expression for ANY of the given bit flags to be set.
+   * <pre>{@code
+   *
+   * where().bitwiseAny("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAny(String propertyName, long flags);
+
+  /**
+   * Add expression for ALL of the given bit flags to be set.
+   * <p>
+   * <pre>{@code
+   *
+   * where().bitwiseAll("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAll(String propertyName, long flags);
+
+  /**
+   * Add bitwise AND expression of the given bit flags to compare with the match/mask.
+   * <p>
+   * <pre>{@code
+   *
+   * // Flags Bulk + Size = Size
+   * // ... meaning Bulk is not set and Size is set
+   *
+   * long selectedFlags = BwFlags.HAS_BULK + BwFlags.HAS_SIZE;
+   * long mask = BwFlags.HAS_SIZE; // Only Size flag set
+   *
+   * where().bitwiseAnd("flags", selectedFlags, mask)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAnd(String propertyName, long flags, long match);
+
   /**
    * Add raw expression with a single parameter.
    * <p>

src/main/java/io/ebean/MergeOptions.java

@@ -0,0 +1,29 @@
+package io.ebean;
+
+import java.util.Set;
+
+/**
+ * Options used to control a merge. Use MergeOptionsBuilder to create an instance.
+ * <p>
+ * Instances of MergeOptions are thread safe and safe to share across threads.
+ */
+public interface MergeOptions {
+
+  /**
+   * Returns true if Id values are supplied by the client.
+   * <p>
+   * This would be the case when for example a mobile creates data in it's own local database
+   * and then sync's. In this case often the id values are UUID.
+   */
+  boolean isClientGeneratedIds();
+
+  /**
+   * Return true if delete permanent should be used and false for 'normal' delete that allows soft deletes.
+   */
+  boolean isDeletePermanent();
+
+  /**
+   * Return the paths included in the merge.
+   */
+  Set<String> paths();
+}

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

@@ -0,0 +1,95 @@
+package io.ebean;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * Builds a MergeOptions which is immutable and thread safe.
+ */
+public class MergeOptionsBuilder {
+
+  private static final MOptions DEFAULT_OPTIONS = new MOptions();
+
+  private Set<String> paths = new LinkedHashSet<>();
+
+  private boolean clientGeneratedIds;
+
+  private boolean deletePermanent;
+
+  /**
+   * Return the default options.
+   */
+  public static MergeOptions defaultOptions() {
+    return DEFAULT_OPTIONS;
+  }
+
+  /**
+   * Add a path that will included in the merge.
+   *
+   * @param path The path relative to the root type.
+   * @return The builder to chain another addPath() or build().
+   */
+  public MergeOptionsBuilder addPath(String path) {
+    paths.add(path);
+    return this;
+  }
+
+  /**
+   * Set to true if Id values are supplied by the client.
+   * <p>
+   * This would be the case when for example a mobile creates data in it's own local database
+   * and then sync's. In this case often the id values are UUID.
+   */
+  public MergeOptionsBuilder setClientGeneratedIds() {
+    this.clientGeneratedIds = true;
+    return this;
+  }
+
+  /**
+   * Set that deletions should use delete permanent (rather than default which allows soft deletes).
+   */
+  public MergeOptionsBuilder setDeletePermanent() {
+    this.deletePermanent = true;
+    return this;
+  }
+
+  /**
+   * Build and return the MergeOptions instance.
+   */
+  public MergeOptions build() {
+    return new MOptions(paths, clientGeneratedIds, deletePermanent);
+  }
+
+  private static class MOptions implements MergeOptions {
+
+    private final boolean clientGeneratedIds;
+    private final boolean deletePermanent;
+    private final Set<String> paths;
+
+    private MOptions(){
+      this.clientGeneratedIds = false;
+      this.paths = new LinkedHashSet<>();
+      this.deletePermanent = false;
+    }
+
+    private MOptions(Set<String> paths, boolean clientGeneratedIds, boolean deletePermanent) {
+      this.paths = paths;
+      this.clientGeneratedIds = clientGeneratedIds;
+      this.deletePermanent = deletePermanent;
+    }
+
+    public Set<String> paths() {
+      return paths;
+    }
+
+    @Override
+    public boolean isClientGeneratedIds() {
+      return clientGeneratedIds;
+    }
+
+    @Override
+    public boolean isDeletePermanent() {
+      return deletePermanent;
+    }
+  }
+}

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

@@ -236,6 +236,14 @@ public interface Query<T> {
    */
   Query<T> asDraft();
 
+  /**
+   * Convert the query to a DTO bean query.
+   * <p>
+   * We effectively use the underlying ORM query to build the SQL and then execute
+   * and map it into DTO beans.
+   */
+  <D> DtoQuery<D> asDto(Class<D> dtoClass);
+
   /**
    * Cancel the query execution if supported by the underlying database and
    * driver.
@@ -1411,6 +1419,15 @@ public interface Query<T> {
    */
   Query<T> setProfileLocation(ProfileLocation profileLocation);
 
+  /**
+   * Set a label on the query.
+   * <p>
+   * This label can be used to help identify query performance metrics but we can also use
+   * profile location enhancement on Finders so for some that would be a better option.
+   * </p>
+   */
+  Query<T> setLabel(String label);
+
   /**
    * Set to true if this query should execute against the doc store.
    * <p>

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

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

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

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

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

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

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

@@ -19,15 +19,73 @@ package io.ebean;
  * <p>
  * <pre>{@code
  *
- * // example that uses 'named' parameters
- * String s = "UPDATE f_topic set post_count = :count where id = :id";
- * SqlUpdate update = Ebean.createSqlUpdate(s);
- * update.setParameter("id", 1);
- * update.setParameter("count", 50);
+ *   // example that uses 'named' parameters
  *
- * int modifiedCount = Ebean.execute(update);
+ *   String s = "UPDATE f_topic set post_count = :count where id = :id";
  *
- * String msg = "There were " + modifiedCount + " rows updated";
+ *   SqlUpdate update = Ebean.createSqlUpdate(s);
+ *   update.setParameter("id", 1);
+ *   update.setParameter("count", 50);
+ *
+ *   int modifiedCount = update.execute();
+ *
+ *   String msg = "There were " + modifiedCount + " rows updated";
+ *
+ * }</pre>
+ * <p>
+ * <h3>Example: Using setNextParameter()</h3>
+ * <pre>{@code
+ *
+ *  String sql = "insert into audit_log (id, description, modified_description) values (?,?,?)";
+ *  SqlUpdate insert = Ebean.createSqlUpdate(sql);
+ *
+ *  try (Transaction txn = Ebean.beginTransaction()) {
+ *    txn.setBatchMode(true);
+ *
+ *    insert.setNextParameter(10000);
+ *    insert.setNextParameter("hello");
+ *    insert.setNextParameter("rob");
+ *    insert.execute();
+ *
+ *    insert.setNextParameter(10001);
+ *    insert.setNextParameter("goodbye");
+ *    insert.setNextParameter("rob");
+ *    insert.execute();
+ *
+ *    insert.setNextParameter(10002);
+ *    insert.setNextParameter("chow");
+ *    insert.setNextParameter("bob");
+ *    insert.execute();
+ *
+ *    txn.commit();
+ *  }
+ * }</pre>
+ * <p>
+ * An alternative to the batch mode on the transaction is to use addBatch() and executeBatch() like:
+ * </p>
+ * <pre>{@code
+ *
+ *   try (Transaction txn = Ebean.beginTransaction()) {
+ *
+ *     insert.setNextParameter(10000);
+ *     insert.setNextParameter("hello");
+ *     insert.setNextParameter("rob");
+ *     insert.addBatch();
+ *
+ *     insert.setNextParameter(10001);
+ *     insert.setNextParameter("goodbye");
+ *     insert.setNextParameter("rob");
+ *     insert.addBatch();
+ *
+ *     insert.setNextParameter(10002);
+ *     insert.setNextParameter("chow");
+ *     insert.setNextParameter("bob");
+ *     insert.addBatch();
+ *
+ *     int[] rows = insert.executeBatch();
+ *
+ *     txn.commit();
+ *   }
  *
  * }</pre>
  *
@@ -54,6 +112,18 @@ public interface SqlUpdate {
    */
   int execute();
 
+  /**
+   * Execute when addBatch() has been used to batch multiple bind executions.
+   *
+   * @return The row counts for each of the batched statements.
+   */
+  int[] executeBatch();
+
+  /**
+   * Add the statement to batch processing to then later execute via executeBatch().
+   */
+  void addBatch();
+
   /**
    * Return the generated key value.
    */
@@ -61,7 +131,7 @@ public interface SqlUpdate {
 
   /**
    * Execute and return the generated key. This is effectively a short cut for:
-   *
+   * <p>
    * <pre>{@code
    *
    *   sqlUpdate.execute();
@@ -137,6 +207,13 @@ public interface SqlUpdate {
    */
   SqlUpdate setTimeout(int secs);
 
+  /**
+   * Set the next positioned parameter.
+   *
+   * @param value The value to bind
+   */
+  SqlUpdate setNextParameter(Object value);
+
   /**
    * Set a parameter via its index position.
    */

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

@@ -23,6 +23,7 @@ public interface Transaction extends AutoCloseable {
    * This returns the current transaction for the 'default server'.  If you are using
    * multiple EbeanServer's then use {@link EbeanServer#currentTransaction()}.
    * </p>
+   *
    * @see Ebean#currentTransaction()
    * @see EbeanServer#currentTransaction()
    */
@@ -136,6 +137,18 @@ public interface Transaction extends AutoCloseable {
    */
   void rollback(Throwable e) throws PersistenceException;
 
+  /**
+   * Set when we want nested transactions to use Savepoint's.
+   * <p>
+   * This means that for a nested transaction:
+   * <ul>
+   * <li>begin transaction maps to creating a savepoint</li>
+   * <li>commit transaction maps to releasing a savepoint</li>
+   * <li>rollback transaction maps to rollback a savepoint</li>
+   * </ul>
+   */
+  void setNestedUseSavepoint();
+
   /**
    * Mark the transaction for rollback only.
    */
@@ -151,7 +164,6 @@ public interface Transaction extends AutoCloseable {
    */
   void end();
 
-
   /**
    * Synonym for end() to support AutoClosable.
    */
@@ -227,7 +239,7 @@ public interface Transaction extends AutoCloseable {
    * Refer to {@link ServerConfig#setSkipCacheAfterWrite(boolean)} for configuring the default behavior
    * for using the L2 bean cache in transactions spanning multiple query/persist requests.
    * </p>
-   * <p>
+   *
    * <pre>{@code
    *
    *   // assume Customer has L2 bean caching enabled ...
@@ -309,7 +321,7 @@ public interface Transaction extends AutoCloseable {
    * <p>
    * Example: batch processing executing every 3 rows
    * </p>
-   * <p>
+   *
    * <pre>{@code
    *
    * String data = "This is a simple test of the batch processing"

src/main/java/io/ebean/Update.java

@@ -152,6 +152,11 @@ public interface Update<T> {
    */
   Update<T> setNullParameter(String name, int jdbcType);
 
+  /**
+   * Set a label meaning performance metrics will be collected for the execution of this update.
+   */
+  Update<T> setLabel(String label);
+
   /**
    * Return the sql that is actually executed.
    */

src/main/java/io/ebean/bean/BeanCollection.java

@@ -72,6 +72,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   boolean isSkipSave();
 
+  /**
+   * Return true if the collection holds modifications.
+   */
+  boolean holdsModifications();
+
   /**
    * Return the bean that owns this collection.
    */

src/main/java/io/ebean/bean/EntityBeanIntercept.java

@@ -52,6 +52,8 @@ public final class EntityBeanIntercept implements Serializable {
    */
   private int state;
 
+  private boolean forceUpdate;
+
   private boolean readOnly;
 
   private boolean dirty;
@@ -131,6 +133,20 @@ public final class EntityBeanIntercept implements Serializable {
     this.nodeUsageCollector = usageCollector;
   }
 
+  /**
+   * Return the ownerId (IdClass).
+   */
+  public Object getOwnerId() {
+    return ownerId;
+  }
+
+  /**
+   * Set the ownerId (IdClass).
+   */
+  public void setOwnerId(Object ownerId) {
+    this.ownerId = ownerId;
+  }
+
   /**
    * Return the owning bean for an embedded bean.
    */
@@ -292,6 +308,20 @@ public final class EntityBeanIntercept implements Serializable {
     this.readOnly = readOnly;
   }
 
+  /**
+   * Set the bean to be updated when persisted (for merge).
+   */
+  public void setForceUpdate(boolean forceUpdate) {
+    this.forceUpdate = forceUpdate;
+  }
+
+  /**
+   * Return true if the entity should be updated.
+   */
+  public boolean isUpdate() {
+    return forceUpdate || state == STATE_LOADED;
+  }
+
   /**
    * Return true if the entity has been loaded.
    */
@@ -529,6 +559,16 @@ public final class EntityBeanIntercept implements Serializable {
     }
   }
 
+  /**
+   * Set old value but force it to be set regardless if it already has a value.
+   */
+  private void setOriginalValueForce(int propertyIndex, Object value) {
+    if (origValues == null) {
+      origValues = new Object[owner._ebean_getPropertyNames().length];
+    }
+    origValues[propertyIndex] = value;
+  }
+
   /**
    * For forced update on a 'New' bean set all the loaded properties to changed.
    */
@@ -901,15 +941,19 @@ public final class EntityBeanIntercept implements Serializable {
 
     if (setDirtyState) {
       setOriginalValue(propertyIndex, origValue);
-      if (!dirty) {
-        dirty = true;
-        if (embeddedOwner != null) {
-          // Cascade dirty state from Embedded bean to parent bean
-          embeddedOwner._ebean_getIntercept().setEmbeddedDirty(embeddedOwnerIndex);
-        }
-        if (nodeUsageCollector != null) {
-          nodeUsageCollector.setModified();
-        }
+      setDirtyStatus();
+    }
+  }
+
+  private void setDirtyStatus() {
+    if (!dirty) {
+      dirty = true;
+      if (embeddedOwner != null) {
+        // Cascade dirty state from Embedded bean to parent bean
+        embeddedOwner._ebean_getIntercept().setEmbeddedDirty(embeddedOwnerIndex);
+      }
+      if (nodeUsageCollector != null) {
+        nodeUsageCollector.setModified();
       }
     }
   }
@@ -1049,10 +1093,12 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Explicitly set an old value.
+   * Explicitly set an old value with force (the old value is forced even it is already set).
    */
   public void setOldValue(int propertyIndex, Object oldValue) {
-    setChangedPropertyValue(propertyIndex, true, oldValue);
+    setChangedProperty(propertyIndex);
+    setOriginalValueForce(propertyIndex, oldValue);
+    setDirtyStatus();
   }
 
   /**

src/main/java/io/ebean/common/AbstractBeanCollection.java

@@ -6,7 +6,6 @@ import io.ebean.bean.BeanCollection;
 import io.ebean.bean.BeanCollectionLoader;
 import io.ebean.bean.EntityBean;
 
-import javax.persistence.PersistenceException;
 import java.util.Set;
 
 /**
@@ -64,7 +63,7 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     this.ebeanServerName = loader.getName();
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
-    this.readOnly = ownerBean._ebean_getIntercept().isReadOnly();
+    this.readOnly = ownerBean != null && ownerBean._ebean_getIntercept().isReadOnly();
   }
 
   @Override
@@ -96,13 +95,6 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     if (loader == null) {
       loader = (BeanCollectionLoader) Ebean.getServer(ebeanServerName);
     }
-    if (loader == null) {
-      String msg = "Lazy loading but LazyLoadEbeanServer is null?"
-        + " The LazyLoadEbeanServer needs to be set after deserialization"
-        + " to support lazy loading.";
-      throw new PersistenceException(msg);
-    }
-
     loader.loadMany(this, onlyIds);
     checkEmptyLazyLoad();
   }
@@ -215,7 +207,8 @@ abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   /**
    * Return true if there are underlying additions or removals.
    */
-  boolean holdsModifications() {
+  @Override
+  public boolean holdsModifications() {
     return modifyHolder != null && modifyHolder.hasModifications();
   }
 

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

@@ -6,10 +6,13 @@ package io.ebean.config;
 public interface AutoConfigure {
 
   /**
-   * Provide some configuration the ServerConfig prior to server creation.
-   * <p>
-   * Return true if the autoConfiguration applies to this ServerConfig.
+   * Perform configuration for the ServerConfig prior to properties load.
    */
-  void configure(ServerConfig serverConfig);
+  void preConfigure(ServerConfig serverConfig);
+
+  /**
+   * Provide some configuration the ServerConfig prior to server creation but after properties have been applied.
+   */
+  void postConfigure(ServerConfig serverConfig);
 
 }

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

@@ -402,9 +402,20 @@ public class DbMigrationConfig {
    * You can use placeholders like ${version} or ${timestamp} in properties file.
    */
   public String getDdlHeader() {
+    if (ddlHeader != null && !ddlHeader.isEmpty()) {
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${version}", EbeanVersion.getVersion());
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${timestamp}", ZonedDateTime.now().format( DateTimeFormatter.ISO_INSTANT ));
+    }
     return ddlHeader;
   }
 
+  /**
+   * Set the header prepended to the DDL.
+   */
+  public void setDdlHeader(String ddlHeader) {
+    this.ddlHeader = ddlHeader;
+  }
+
   /**
    * Set migration versions that should have their checksum reset and not run.
    * <p>
@@ -475,10 +486,6 @@ public class DbMigrationConfig {
     String adminPwd = properties.get("datasource." + serverName + ".adminpassword", dbPassword);
     dbPassword = properties.get("migration.dbpassword", adminPwd);
     ddlHeader = properties.get("ddl.header", ddlHeader);
-    if (ddlHeader != null && !ddlHeader.isEmpty()) {
-      ddlHeader = StringHelper.replaceString(ddlHeader, "${version}", EbeanVersion.getVersion());
-      ddlHeader = StringHelper.replaceString(ddlHeader, "${timestamp}", ZonedDateTime.now().format( DateTimeFormatter.ISO_INSTANT ));
-    }
   }
 
   /**

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

@@ -1,124 +0,0 @@
-package io.ebean.config;
-
-import io.ebean.config.dbplatform.DbType;
-import io.ebean.config.dbplatform.IdType;
-import io.ebean.annotation.Platform;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Configuration for DB types such as UUID, Geometry etc.
- */
-public class DbTypeConfig {
-
-  /**
-   * The Geometry SRID value (default 4326).
-   */
-  private int geometrySRID = 4326;
-
-  /**
-   * Set for DB's that support both Sequence and Identity (and the default choice is not desired).
-   */
-  private IdType idType;
-
-  /**
-   * Setting to indicate if UUID should be stored as binary(16) or varchar(40) or native DB type (for H2 and Postgres).
-   */
-  private ServerConfig.DbUuid dbUuid = ServerConfig.DbUuid.AUTO_VARCHAR;
-
-  /**
-   * Modify the default mapping of standard types such as default precision for DECIMAL etc.
-   */
-  private List<CustomDbTypeMapping> customDbTypeMappings = new ArrayList<>();
-
-  /**
-   * Return the Geometry SRID.
-   */
-  public int getGeometrySRID() {
-    return geometrySRID;
-  }
-
-  /**
-   * Set the Geometry SRID.
-   */
-  public void setGeometrySRID(int geometrySRID) {
-    this.geometrySRID = geometrySRID;
-  }
-
-  /**
-   * Return the DB type used to store UUID.
-   */
-  public ServerConfig.DbUuid getDbUuid() {
-    return dbUuid;
-  }
-
-  /**
-   * Set the DB type used to store UUID.
-   */
-  public void setDbUuid(ServerConfig.DbUuid dbUuid) {
-    this.dbUuid = dbUuid;
-  }
-
-  /**
-   * Return the IdType to use (or null for the default choice).
-   */
-  public IdType getIdType() {
-    return idType;
-  }
-
-  /**
-   * Set the IdType to use (when the DB supports both SEQUENCE and IDENTITY and the default is not desired).
-   */
-  public void setIdType(IdType idType) {
-    this.idType = idType;
-  }
-
-  /**
-   * Add a custom type mapping.
-   * <p>
-   * <pre>{@code
-   *
-   *   // set the default mapping for BigDecimal.class/decimal
-   *   serverConfig.addCustomMapping(DbType.DECIMAL, "decimal(18,6)");
-   *
-   *   // set the default mapping for String.class/varchar but only for Postgres
-   *   serverConfig.addCustomMapping(DbType.VARCHAR, "text", Platform.POSTGRES);
-   *
-   * }</pre>
-   *
-   * @param type             The DB type this mapping should apply to
-   * @param columnDefinition The column definition that should be used
-   * @param platform         Optionally specify the platform this mapping should apply to.
-   */
-  public void addCustomMapping(DbType type, String columnDefinition, Platform platform) {
-    customDbTypeMappings.add(new CustomDbTypeMapping(type, columnDefinition, platform));
-  }
-
-  /**
-   * Add a custom type mapping that applies to all platforms.
-   * <p>
-   * <pre>{@code
-   *
-   *   // set the default mapping for BigDecimal/decimal
-   *   serverConfig.addCustomMapping(DbType.DECIMAL, "decimal(18,6)");
-   *
-   *   // set the default mapping for String/varchar
-   *   serverConfig.addCustomMapping(DbType.VARCHAR, "text");
-   *
-   * }</pre>
-   *
-   * @param type             The DB type this mapping should apply to
-   * @param columnDefinition The column definition that should be used
-   */
-  public void addCustomMapping(DbType type, String columnDefinition) {
-    customDbTypeMappings.add(new CustomDbTypeMapping(type, columnDefinition));
-  }
-
-  /**
-   * Return the list of custom type mappings.
-   */
-  public List<CustomDbTypeMapping> getCustomTypeMappings() {
-    return customDbTypeMappings;
-  }
-}

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

@@ -0,0 +1,335 @@
+package io.ebean.config;
+
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.DbType;
+import io.ebean.config.dbplatform.IdType;
+import io.ebean.util.StringHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Configuration for DB types such as UUID, Geometry etc.
+ */
+public class PlatformConfig {
+
+  private boolean allQuotedIdentifiers;
+
+  /**
+   * The database boolean true value (typically either 1, T, or Y).
+   */
+  private String databaseBooleanTrue;
+
+  /**
+   * The database boolean false value (typically either 0, F or N).
+   */
+  private String databaseBooleanFalse;
+
+  /**
+   * For DB's using sequences this is the number of sequence values prefetched.
+   */
+  private int databaseSequenceBatchSize = 20;
+
+  /**
+   * Set for DB's that support both Sequence and Identity (and the default choice is not desired).
+   */
+  private IdType idType;
+
+  /**
+   * The Geometry SRID value (default 4326).
+   */
+  private int geometrySRID = 4326;
+
+  /**
+   * Setting to indicate if UUID should be stored as binary(16) or varchar(40) or native DB type (for H2 and Postgres).
+   */
+  private DbUuid dbUuid = DbUuid.AUTO_VARCHAR;
+
+  /**
+   * Modify the default mapping of standard types such as default precision for DECIMAL etc.
+   */
+  private List<CustomDbTypeMapping> customDbTypeMappings = new ArrayList<>();
+
+  /**
+   * Construct with defaults.
+   */
+  public PlatformConfig() {
+
+  }
+
+  /**
+   * Construct based on given config - typically for DbMigration generation with many platforms.
+   */
+  public PlatformConfig(PlatformConfig platformConfig) {
+    this.databaseBooleanFalse = platformConfig.databaseBooleanFalse;
+    this.databaseBooleanTrue = platformConfig.databaseBooleanTrue;
+    this.databaseSequenceBatchSize = platformConfig.databaseSequenceBatchSize;
+    this.idType = platformConfig.idType;
+    this.geometrySRID = platformConfig.geometrySRID;
+    this.dbUuid = platformConfig.dbUuid;
+  }
+
+  /**
+   * Return true if all DB column and table names should use quoted identifiers.
+   */
+  public boolean isAllQuotedIdentifiers() {
+    return allQuotedIdentifiers;
+  }
+
+  /**
+   * Set to true if all DB column and table names should use quoted identifiers.
+   */
+  public void setAllQuotedIdentifiers(boolean allQuotedIdentifiers) {
+    this.allQuotedIdentifiers = allQuotedIdentifiers;
+  }
+
+  /**
+   * Return a value used to represent TRUE in the database.
+   * <p>
+   * This is used for databases that do not support boolean natively.
+   * </p>
+   * <p>
+   * The value returned is either a Integer or a String (e.g. "1", or "T").
+   * </p>
+   */
+  public String getDatabaseBooleanTrue() {
+    return databaseBooleanTrue;
+  }
+
+  /**
+   * Set the value to represent TRUE in the database.
+   * <p>
+   * This is used for databases that do not support boolean natively.
+   * </p>
+   * <p>
+   * The value set is either a Integer or a String (e.g. "1", or "T").
+   * </p>
+   */
+  public void setDatabaseBooleanTrue(String databaseBooleanTrue) {
+    this.databaseBooleanTrue = databaseBooleanTrue;
+  }
+
+  /**
+   * Return a value used to represent FALSE in the database.
+   */
+  public String getDatabaseBooleanFalse() {
+    return databaseBooleanFalse;
+  }
+
+  /**
+   * Set the value used to represent FALSE in the database.
+   */
+  public void setDatabaseBooleanFalse(String databaseBooleanFalse) {
+    this.databaseBooleanFalse = databaseBooleanFalse;
+  }
+
+  /**
+   * Return the number of DB sequence values that should be preallocated.
+   */
+  public int getDatabaseSequenceBatchSize() {
+    return databaseSequenceBatchSize;
+  }
+
+  /**
+   * Set the number of DB sequence values that should be preallocated.
+   */
+  public void setDatabaseSequenceBatchSize(int databaseSequenceBatchSize) {
+    this.databaseSequenceBatchSize = databaseSequenceBatchSize;
+  }
+
+  /**
+   * Return the Geometry SRID.
+   */
+  public int getGeometrySRID() {
+    return geometrySRID;
+  }
+
+  /**
+   * Set the Geometry SRID.
+   */
+  public void setGeometrySRID(int geometrySRID) {
+    this.geometrySRID = geometrySRID;
+  }
+
+  /**
+   * Return the DB type used to store UUID.
+   */
+  public DbUuid getDbUuid() {
+    return dbUuid;
+  }
+
+  /**
+   * Set the DB type used to store UUID.
+   */
+  public void setDbUuid(DbUuid dbUuid) {
+    this.dbUuid = dbUuid;
+  }
+
+  /**
+   * Return the IdType to use (or null for the default choice).
+   */
+  public IdType getIdType() {
+    return idType;
+  }
+
+  /**
+   * Set the IdType to use (when the DB supports both SEQUENCE and IDENTITY and the default is not desired).
+   */
+  public void setIdType(IdType idType) {
+    this.idType = idType;
+  }
+
+  /**
+   * Add a custom type mapping.
+   * <p>
+   * <pre>{@code
+   *
+   *   // set the default mapping for BigDecimal.class/decimal
+   *   serverConfig.addCustomMapping(DbType.DECIMAL, "decimal(18,6)");
+   *
+   *   // set the default mapping for String.class/varchar but only for Postgres
+   *   serverConfig.addCustomMapping(DbType.VARCHAR, "text", Platform.POSTGRES);
+   *
+   * }</pre>
+   *
+   * @param type             The DB type this mapping should apply to
+   * @param columnDefinition The column definition that should be used
+   * @param platform         Optionally specify the platform this mapping should apply to.
+   */
+  public void addCustomMapping(DbType type, String columnDefinition, Platform platform) {
+    customDbTypeMappings.add(new CustomDbTypeMapping(type, columnDefinition, platform));
+  }
+
+  /**
+   * Add a custom type mapping that applies to all platforms.
+   * <p>
+   * <pre>{@code
+   *
+   *   // set the default mapping for BigDecimal/decimal
+   *   serverConfig.addCustomMapping(DbType.DECIMAL, "decimal(18,6)");
+   *
+   *   // set the default mapping for String/varchar
+   *   serverConfig.addCustomMapping(DbType.VARCHAR, "text");
+   *
+   * }</pre>
+   *
+   * @param type             The DB type this mapping should apply to
+   * @param columnDefinition The column definition that should be used
+   */
+  public void addCustomMapping(DbType type, String columnDefinition) {
+    customDbTypeMappings.add(new CustomDbTypeMapping(type, columnDefinition));
+  }
+
+  /**
+   * Return the list of custom type mappings.
+   */
+  public List<CustomDbTypeMapping> getCustomTypeMappings() {
+    return customDbTypeMappings;
+  }
+
+  public void loadSettings(PropertiesWrapper p) {
+
+    idType = p.getEnum(IdType.class, "idType", idType);
+    databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", databaseSequenceBatchSize);
+    databaseBooleanTrue = p.get("databaseBooleanTrue", databaseBooleanTrue);
+    databaseBooleanFalse = p.get("databaseBooleanFalse", databaseBooleanFalse);
+
+    DbUuid dbUuid = p.getEnum(DbUuid.class, "dbuuid", null);
+    if (dbUuid != null) {
+      setDbUuid(dbUuid);
+    }
+    if (p.getBoolean("uuidStoreAsBinary", false)) {
+      setDbUuid(DbUuid.BINARY);
+    }
+
+    int srid = p.getInt("geometrySRID", 0);
+    if (srid > 0) {
+      setGeometrySRID(srid);
+    }
+
+    // Mapping is specified in the form: BOOLEAN=int(1);BIT=int(1);
+    String mapping = p.get("mapping");
+    if (mapping != null && !mapping.isEmpty()) {
+      Map<String, String> map = StringHelper.delimitedToMap(mapping, ";", "=");
+      for (Entry<String, String> entry : map.entrySet()) {
+        addCustomMapping(DbType.valueOf(entry.getKey()), entry.getValue());
+      }
+    }
+
+    boolean quotedIdentifiers = p.getBoolean("allQuotedIdentifiers", allQuotedIdentifiers);
+    if (quotedIdentifiers != allQuotedIdentifiers) {
+      // potentially also set to use matching naming convention
+      setAllQuotedIdentifiers(quotedIdentifiers);
+    }
+  }
+
+  /**
+   * Specify how UUID is stored.
+   */
+  public enum DbUuid {
+
+
+    /**
+     * Store using native UUID in H2 and Postgres and otherwise fallback to VARCHAR(40).
+     */
+    AUTO_VARCHAR(true, false, false),
+
+    /**
+     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16).
+     */
+    AUTO_BINARY(true, true, false),
+
+    /**
+     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16) with optimized packing.
+     */
+    AUTO_BINARY_OPTIMIZED(true, true, true),
+
+    /**
+     * Store using DB VARCHAR(40).
+     */
+    VARCHAR(false, false, false),
+
+    /**
+     * Store using DB BINARY(16).
+     */
+    BINARY(false, true, false),
+
+    /**
+     * Store using DB BINARY(16).
+     */
+    BINARY_OPTIMIZED(false, true, true);
+
+    boolean nativeType;
+    boolean binary;
+    boolean binaryOptimized;
+
+    DbUuid(boolean nativeType, boolean binary, boolean binaryOptimized) {
+      this.nativeType = nativeType;
+      this.binary = binary;
+      this.binaryOptimized = binaryOptimized;
+    }
+
+    /**
+     * Return true if native UUID type is preferred.
+     */
+    public boolean useNativeType() {
+      return nativeType;
+    }
+
+    /**
+     * Return true if BINARY(16) storage is preferred over VARCHAR(40).
+     */
+    public boolean useBinary() {
+      return binary;
+    }
+
+    /**
+     * Return true, if optimized packing should be used.
+     */
+    public boolean useBinaryOptimized() {
+      return binaryOptimized;
+    }
+  }
+}

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

@@ -10,20 +10,23 @@ public class PropertiesWrapper {
 
   protected final String serverName;
 
+  private final ClassLoadConfig classLoadConfig;
+
   /**
    * Construct with a prefix, serverName and properties.
    */
-  public PropertiesWrapper(String prefix, String serverName, Properties properties) {
+  public PropertiesWrapper(String prefix, String serverName, Properties properties, ClassLoadConfig classLoadConfig) {
     this.serverName = serverName;
     this.prefix = prefix;
     this.properties = properties;
+    this.classLoadConfig = classLoadConfig;
   }
 
   /**
    * Construct without prefix of serverName.
    */
-  public PropertiesWrapper(Properties properties) {
-    this(null, null, properties);
+  public PropertiesWrapper(Properties properties, ClassLoadConfig classLoadConfig) {
+    this(null, null, properties, classLoadConfig);
   }
 
   /**
@@ -115,4 +118,30 @@ public class PropertiesWrapper {
     return (level == null) ? defaultValue : Enum.valueOf(enumType, level.toUpperCase());
   }
 
+  /**
+   * Return the instance to use (can be null) for the given plugin.
+   *
+   * @param pluginType the type of plugin
+   * @param key        properties key
+   * @param instance   existing instance
+   */
+  public <T> T createInstance(Class<T> pluginType, String key, T instance) {
+
+    if (instance != null) {
+      return instance;
+    }
+    String classname = 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
+   */
+  @SuppressWarnings("unchecked")
+  public <T> T createInstance(Class<T> pluginType, String classname) {
+    return classname == null ? null : (T) classLoadConfig.newInstance(classname);
+  }
 }

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

@@ -183,16 +183,6 @@ public class ServerConfig {
    */
   private DatabasePlatform databasePlatform;
 
-  /**
-   * The preferred IdType (to override the default Platform type).
-   */
-  private IdType idType;
-
-  /**
-   * For DB's using sequences this is the number of sequence values prefetched.
-   */
-  private int databaseSequenceBatchSize = 20;
-
   /**
    * JDBC fetchSize hint when using findList.  Defaults to 0 leaving it up to the JDBC driver.
    */
@@ -330,18 +320,6 @@ public class ServerConfig {
    */
   private String dataSourceJndiName;
 
-  /**
-   * The database boolean true value (typically either 1, T, or Y).
-   */
-  private String databaseBooleanTrue;
-
-  /**
-   * The database boolean false value (typically either 0, F or N).
-   */
-  private String databaseBooleanFalse;
-
-  private boolean allQuotedIdentifiers;
-
   /**
    * The naming convention.
    */
@@ -368,9 +346,9 @@ public class ServerConfig {
   private boolean updatesDeleteMissingChildren = true;
 
   /**
-   * Database type configuration.
+   * Database platform configuration.
    */
-  private DbTypeConfig dbTypeConfig = new DbTypeConfig();
+  private PlatformConfig platformConfig = new PlatformConfig();
 
   /**
    * The UUID version to use.
@@ -510,6 +488,16 @@ public class ServerConfig {
    */
   private boolean defaultOrderById = false;
 
+  /**
+   * The mappingLocations for searching xml mapping.
+   */
+  private List<String> mappingLocations = new ArrayList<>();
+
+  /**
+   * When true we do not need explicit GeneratedValue mapping.
+   */
+  private boolean idGeneratorAutomatic = true;
+
   /**
    * Construct a Server Configuration for programmatically creating an EbeanServer.
    */
@@ -946,7 +934,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseSequenceBatchSize(int databaseSequenceBatchSize) {
-    this.databaseSequenceBatchSize = databaseSequenceBatchSize;
+    platformConfig.setDatabaseSequenceBatchSize(databaseSequenceBatchSize);
   }
 
   /**
@@ -1128,14 +1116,14 @@ public class ServerConfig {
    * Return the Geometry SRID.
    */
   public int getGeometrySRID() {
-    return dbTypeConfig.getGeometrySRID();
+    return platformConfig.getGeometrySRID();
   }
 
   /**
    * Set the Geometry SRID.
    */
   public void setGeometrySRID(int geometrySRID) {
-    dbTypeConfig.setGeometrySRID(geometrySRID);
+    platformConfig.setGeometrySRID(geometrySRID);
   }
 
   /**
@@ -1425,15 +1413,21 @@ public class ServerConfig {
    * Return true if all DB column and table names should use quoted identifiers.
    */
   public boolean isAllQuotedIdentifiers() {
-    return allQuotedIdentifiers;
+    return platformConfig.isAllQuotedIdentifiers();
   }
 
   /**
    * Set to true if all DB column and table names should use quoted identifiers.
    */
   public void setAllQuotedIdentifiers(boolean allQuotedIdentifiers) {
-    this.allQuotedIdentifiers = allQuotedIdentifiers;
-    if (allQuotedIdentifiers && namingConvention instanceof UnderscoreNamingConvention) {
+    platformConfig.setAllQuotedIdentifiers(allQuotedIdentifiers);
+    if (allQuotedIdentifiers) {
+      adjustNamingConventionForAllQuoted();
+    }
+  }
+
+  private void adjustNamingConventionForAllQuoted() {
+    if (namingConvention instanceof UnderscoreNamingConvention) {
       // we need to use matching naming convention
       this.namingConvention = new MatchingNamingConvention();
     }
@@ -1648,7 +1642,7 @@ public class ServerConfig {
    * </p>
    */
   public String getDatabaseBooleanTrue() {
-    return databaseBooleanTrue;
+    return platformConfig.getDatabaseBooleanTrue();
   }
 
   /**
@@ -1661,7 +1655,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseBooleanTrue(String databaseTrue) {
-    this.databaseBooleanTrue = databaseTrue;
+    platformConfig.setDatabaseBooleanTrue(databaseTrue);
   }
 
   /**
@@ -1674,7 +1668,7 @@ public class ServerConfig {
    * </p>
    */
   public String getDatabaseBooleanFalse() {
-    return databaseBooleanFalse;
+    return platformConfig.getDatabaseBooleanFalse();
   }
 
   /**
@@ -1687,14 +1681,14 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseBooleanFalse(String databaseFalse) {
-    this.databaseBooleanFalse = databaseFalse;
+    this.platformConfig.setDatabaseBooleanFalse(databaseFalse);
   }
 
   /**
    * Return the number of DB sequence values that should be preallocated.
    */
   public int getDatabaseSequenceBatchSize() {
-    return databaseSequenceBatchSize;
+    return platformConfig.getDatabaseSequenceBatchSize();
   }
 
   /**
@@ -1713,7 +1707,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseSequenceBatch(int databaseSequenceBatchSize) {
-    this.databaseSequenceBatchSize = databaseSequenceBatchSize;
+    this.platformConfig.setDatabaseSequenceBatchSize(databaseSequenceBatchSize);
   }
 
   /**
@@ -1740,7 +1734,7 @@ public class ServerConfig {
    * that you don't have access to.
    * </p>
    * <p>
-   * Values are oracle, h2, postgres, mysql, mssqlserver2005.
+   * Values are oracle, h2, postgres, mysql, sqlserver16, sqlserver17.
    * </p>
    */
   public void setDatabasePlatformName(String databasePlatformName) {
@@ -1769,14 +1763,14 @@ public class ServerConfig {
    * Return the preferred DB platform IdType.
    */
   public IdType getIdType() {
-    return idType;
+    return platformConfig.getIdType();
   }
 
   /**
    * Set the preferred DB platform IdType.
    */
   public void setIdType(IdType idType) {
-    this.idType = idType;
+    this.platformConfig.setIdType(idType);
   }
 
   /**
@@ -1889,15 +1883,22 @@ public class ServerConfig {
   /**
    * Return the configuration for DB types (such as UUID and custom mappings).
    */
-  public DbTypeConfig getDbTypeConfig() {
-    return dbTypeConfig;
+  public PlatformConfig getPlatformConfig() {
+    return platformConfig;
+  }
+
+  /**
+   * Set the configuration for DB platform (such as UUID and custom mappings).
+   */
+  public void setPlatformConfig(PlatformConfig platformConfig) {
+    this.platformConfig = platformConfig;
   }
 
   /**
    * Set the DB type used to store UUID.
    */
-  public void setDbUuid(DbUuid dbUuid) {
-    this.dbTypeConfig.setDbUuid(dbUuid);
+  public void setDbUuid(PlatformConfig.DbUuid dbUuid) {
+    this.platformConfig.setDbUuid(dbUuid);
   }
 
   /**
@@ -1965,6 +1966,16 @@ public class ServerConfig {
     this.durationWithNanos = durationWithNanos;
   }
 
+  /**
+   * Set to true to run DB migrations on server start.
+   * <p>
+   * This is the same as serverConfig.getMigrationConfig().setRunMigration(). We have added this method here
+   * as it is often the only thing we need to configure for migrations.
+   */
+  public void setRunMigration(boolean runMigration) {
+    migrationConfig.setRunMigration(runMigration);
+  }
+
   /**
    * Set to true to generate the "create all" DDL on startup.
    * <p>
@@ -2353,7 +2364,7 @@ public class ServerConfig {
    * @param platform         Optionally specify the platform this mapping should apply to.
    */
   public void addCustomMapping(DbType type, String columnDefinition, Platform platform) {
-    dbTypeConfig.addCustomMapping(type, columnDefinition, platform);
+    platformConfig.addCustomMapping(type, columnDefinition, platform);
   }
 
   /**
@@ -2373,7 +2384,7 @@ public class ServerConfig {
    * @param columnDefinition The column definition that should be used
    */
   public void addCustomMapping(DbType type, String columnDefinition) {
-    dbTypeConfig.addCustomMapping(type, columnDefinition);
+    platformConfig.addCustomMapping(type, columnDefinition);
   }
 
   /**
@@ -2642,7 +2653,8 @@ public class ServerConfig {
    * Load settings from ebean.properties.
    */
   public void loadFromProperties() {
-    loadFromProperties(PropertiesLoader.load());
+    this.properties = PropertiesLoader.load();
+    configureFromProperties();
   }
 
   /**
@@ -2650,20 +2662,32 @@ public class ServerConfig {
    */
   public void loadFromProperties(Properties properties) {
     // keep the properties used for configuration so that these are available for plugins
-    this.properties = properties;
-    autoConfiguration();
-    PropertiesWrapper p = new PropertiesWrapper("ebean", name, properties);
-    loadSettings(p);
+    this.properties = PropertiesLoader.eval(properties);
+    configureFromProperties();
+  }
+
+  /**
+   * Load the settings from the given properties
+   */
+  private void configureFromProperties() {
+    List<AutoConfigure> autoConfigures = autoConfiguration();
+    loadSettings(new PropertiesWrapper("ebean", name, properties, classLoadConfig));
+    for (AutoConfigure autoConfigure : autoConfigures) {
+      autoConfigure.postConfigure(this);
+    }
   }
 
   /**
    * Use a 'plugin' to provide automatic configuration. Intended for automatic testing
    * configuration with Docker containers via ebean-test-config.
    */
-  private void autoConfiguration() {
+  private List<AutoConfigure> autoConfiguration() {
+    List<AutoConfigure> list = new ArrayList<>();
     for (AutoConfigure autoConfigure : serviceLoad(AutoConfigure.class)) {
-      autoConfigure.configure(this);
+      autoConfigure.preConfigure(this);
+      list.add(autoConfigure);
     }
+    return list;
   }
 
   /**
@@ -2687,34 +2711,6 @@ 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
-   */
-  protected <T> T createInstance(PropertiesWrapper properties, Class<T> pluginType, String key, T instance) {
-
-    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
-   */
-  @SuppressWarnings("unchecked")
-  protected <T> T createInstance(Class<T> pluginType, String classname) {
-    return classname == null ? null : (T) classLoadConfig.newInstance(classname);
-  }
-
   /**
    * loads the data source settings to preserve existing behaviour. IMHO, if someone has set the datasource config already,
    * they don't want the settings to be reloaded and reset. This allows a descending class to override this behaviour and prevent it
@@ -2724,6 +2720,7 @@ public class ServerConfig {
    */
   protected void loadDataSourceSettings(PropertiesWrapper p) {
     dataSourceConfig.loadSettings(p.properties, name);
+    readOnlyDataSourceConfig.loadSettings(p.properties, name);
   }
 
   /**
@@ -2747,11 +2744,9 @@ public class ServerConfig {
 
     profilingConfig.loadSettings(p, name);
     migrationConfig.loadSettings(p, name);
-
-    boolean quotedIdentifiers = p.getBoolean("allQuotedIdentifiers", allQuotedIdentifiers);
-    if (quotedIdentifiers != allQuotedIdentifiers) {
-      // potentially also set to use matching naming convention
-      setAllQuotedIdentifiers(quotedIdentifiers);
+    platformConfig.loadSettings(p);
+    if (platformConfig.isAllQuotedIdentifiers()) {
+      adjustNamingConventionForAllQuoted();
     }
     namingConvention = createNamingConvention(p, namingConvention);
     if (namingConvention != null) {
@@ -2772,11 +2767,6 @@ public class ServerConfig {
     }
     loadDocStoreSettings(p);
 
-    int srid = p.getInt("geometrySRID", 0);
-    if (srid > 0) {
-      dbTypeConfig.setGeometrySRID(srid);
-    }
-
     queryPlanTTLSeconds = p.getInt("queryPlanTTLSeconds", queryPlanTTLSeconds);
     slowQueryMillis = p.getLong("slowQueryMillis", slowQueryMillis);
     docStoreOnly = p.getBoolean("docStoreOnly", docStoreOnly);
@@ -2787,23 +2777,22 @@ public class ServerConfig {
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
     useJavaxValidationNotNull = p.getBoolean("useJavaxValidationNotNull", useJavaxValidationNotNull);
     autoReadOnlyDataSource = p.getBoolean("autoReadOnlyDataSource", autoReadOnlyDataSource);
+    idGeneratorAutomatic = p.getBoolean("idGeneratorAutomatic", idGeneratorAutomatic);
 
     backgroundExecutorSchedulePoolSize = p.getInt("backgroundExecutorSchedulePoolSize", backgroundExecutorSchedulePoolSize);
     backgroundExecutorShutdownSecs = p.getInt("backgroundExecutorShutdownSecs", backgroundExecutorShutdownSecs);
     disableClasspathSearch = p.getBoolean("disableClasspathSearch", disableClasspathSearch);
-    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);
+    currentUserProvider = p.createInstance(CurrentUserProvider.class, "currentUserProvider", currentUserProvider);
+    databasePlatform = p.createInstance(DatabasePlatform.class, "databasePlatform", databasePlatform);
+    encryptKeyManager = p.createInstance(EncryptKeyManager.class, "encryptKeyManager", encryptKeyManager);
+    encryptDeployManager = p.createInstance(EncryptDeployManager.class, "encryptDeployManager", encryptDeployManager);
+    encryptor = p.createInstance(Encryptor.class, "encryptor", encryptor);
+    dbEncrypt = p.createInstance(DbEncrypt.class, "dbEncrypt", dbEncrypt);
     dbOffline = p.getBoolean("dbOffline", dbOffline);
-    serverCachePlugin = createInstance(p, ServerCachePlugin.class, "serverCachePlugin", serverCachePlugin);
+    serverCachePlugin = p.createInstance(ServerCachePlugin.class, "serverCachePlugin", serverCachePlugin);
 
-    if (packages != null) {
-      String packagesProp = p.get("search.packages", p.get("packages", null));
-      packages = getSearchJarsPackages(packagesProp);
-    }
+    String packagesProp = p.get("search.packages", p.get("packages", null));
+    packages = getSearchList(packagesProp, packages);
 
     collectQueryStatsByNode = p.getBoolean("collectQueryStatsByNode", collectQueryStatsByNode);
     collectQueryOrigins = p.getBoolean("collectQueryOrigins", collectQueryOrigins);
@@ -2819,7 +2808,6 @@ public class ServerConfig {
       throw new IllegalArgumentException("Property 'batch.mode' or 'persistBatching' is being set but no longer used. Please change to use 'persistBatchMode'");
     }
 
-    idType = p.getEnum(IdType.class, "idType", idType);
     persistBatch = p.getEnum(PersistBatch.class, "persistBatch", persistBatch);
     persistBatchOnCascade = p.getEnum(PersistBatch.class, "persistBatchOnCascade", persistBatchOnCascade);
 
@@ -2840,20 +2828,9 @@ public class ServerConfig {
     dataSourceJndiName = p.get("dataSourceJndiName", dataSourceJndiName);
     jdbcFetchSizeFindEach = p.getInt("jdbcFetchSizeFindEach", jdbcFetchSizeFindEach);
     jdbcFetchSizeFindList = p.getInt("jdbcFetchSizeFindList", jdbcFetchSizeFindList);
-    databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", databaseSequenceBatchSize);
-    databaseBooleanTrue = p.get("databaseBooleanTrue", databaseBooleanTrue);
-    databaseBooleanFalse = p.get("databaseBooleanFalse", databaseBooleanFalse);
     databasePlatformName = p.get("databasePlatformName", databasePlatformName);
     defaultOrderById = p.getBoolean("defaultOrderById", defaultOrderById);
 
-    DbUuid dbUuid = p.getEnum(DbUuid.class, "dbuuid", null);
-    if (dbUuid != null) {
-      dbTypeConfig.setDbUuid(dbUuid);
-    }
-    if (p.getBoolean("uuidStoreAsBinary", false)) {
-      dbTypeConfig.setDbUuid(DbUuid.BINARY);
-    }
-
     uuidVersion = p.getEnum(UuidVersion.class, "uuidVersion", uuidVersion);
     uuidStateFile = p.get("uuidStateFile", uuidStateFile);
 
@@ -2889,16 +2866,18 @@ public class ServerConfig {
       }
     }
 
-    currentTenantProvider = createInstance(p, CurrentTenantProvider.class, "tenant.currentTenantProvider", currentTenantProvider);
-    tenantCatalogProvider = createInstance(p, TenantCatalogProvider.class, "tenant.catalogProvider", tenantCatalogProvider);
-    tenantSchemaProvider = createInstance(p, TenantSchemaProvider.class, "tenant.schemaProvider", tenantSchemaProvider);
+    currentTenantProvider = p.createInstance(CurrentTenantProvider.class, "tenant.currentTenantProvider", currentTenantProvider);
+    tenantCatalogProvider = p.createInstance(TenantCatalogProvider.class, "tenant.catalogProvider", tenantCatalogProvider);
+    tenantSchemaProvider = p.createInstance(TenantSchemaProvider.class, "tenant.schemaProvider", tenantSchemaProvider);
     tenantPartitionColumn = p.get("tenant.partitionColumn", tenantPartitionColumn);
     classes = getClasses(p);
+
+    String mappingsProp = p.get("mappingLocations", null);
+    mappingLocations = getSearchList(mappingsProp, mappingLocations);
   }
 
   private NamingConvention createNamingConvention(PropertiesWrapper properties, NamingConvention namingConvention) {
-
-    NamingConvention nc = createInstance(properties, NamingConvention.class, "namingconvention", null);
+    NamingConvention nc = properties.createInstance(NamingConvention.class, "namingConvention", null);
     return (nc != null) ? nc : namingConvention;
   }
 
@@ -2931,17 +2910,17 @@ public class ServerConfig {
     return classes;
   }
 
-  private List<String> getSearchJarsPackages(String searchPackages) {
+  private List<String> getSearchList(String searchNames, List<String> defaultValue) {
 
-    if (searchPackages != null) {
-      String[] entries = StringHelper.splitNames(searchPackages);
+    if (searchNames != null) {
+      String[] entries = StringHelper.splitNames(searchNames);
 
       List<String> hitList = new ArrayList<>(entries.length);
       Collections.addAll(hitList, entries);
 
       return hitList;
     } else {
-      return new ArrayList<>();
+      return defaultValue;
     }
   }
 
@@ -3089,71 +3068,68 @@ public class ServerConfig {
   }
 
   /**
-   * Specify how UUID is stored.
+   * Create a new PlatformConfig based of the one held but with overridden properties by reading
+   * properties with the given path and prefix.
+   * <p>
+   * Typically used in Db Migration generation for many platform targets that might have different
+   * configuration for IdType, UUID, quoted identifiers etc.
+   * </p>
+   *
+   * @param propertiesPath The properties path used for loading and setting properties
+   * @param platformPrefix The prefix used for loading and setting properties
+   * @return A copy of the PlatformConfig with overridden properties
    */
-  public enum DbUuid {
+  public PlatformConfig newPlatformConfig(String propertiesPath, String platformPrefix) {
 
+    PropertiesWrapper p = new PropertiesWrapper(propertiesPath, platformPrefix, properties, classLoadConfig);
 
-    /**
-     * Store using native UUID in H2 and Postgres and otherwise fallback to VARCHAR(40).
-     */
-    AUTO_VARCHAR(true, false, false),
+    PlatformConfig config = new PlatformConfig(platformConfig);
+    config.loadSettings(p);
+    return config;
+  }
 
-    /**
-     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16).
-     */
-    AUTO_BINARY(true, true, false),
-
-    /**
-     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16) with optimized packing.
-     */
-    AUTO_BINARY_OPTIMIZED(true, true, true),
-
-    /**
-     * Store using DB VARCHAR(40).
-     */
-    VARCHAR(false, false, false),
-
-    /**
-     * Store using DB BINARY(16).
-     */
-    BINARY(false, true, false),
-
-    /**
-     * Store using DB BINARY(16).
-     */
-    BINARY_OPTIMIZED(false, true, true);
-
-    boolean nativeType;
-    boolean binary;
-    boolean binaryOptimized;
-
-    DbUuid(boolean nativeType, boolean binary, boolean binaryOptimized) {
-      this.nativeType = nativeType;
-      this.binary = binary;
-      this.binaryOptimized = binaryOptimized;
+  /**
+   * Add a mapping location to search for xml mapping via class path search.
+   */
+  public void addMappingLocation(String mappingLocation) {
+    if (mappingLocations == null) {
+      mappingLocations = new ArrayList<>();
     }
+    mappingLocations.add(mappingLocation);
+  }
 
-    /**
-     * Return true if native UUID type is preferred.
-     */
-    public boolean useNativeType() {
-      return nativeType;
-    }
+  /**
+   * Return mapping locations to search for xml mapping via class path search.
+   */
+  public List<String> getMappingLocations() {
+    return mappingLocations;
+  }
 
-    /**
-     * Return true if BINARY(16) storage is preferred over VARCHAR(40).
-     */
-    public boolean useBinary() {
-      return binary;
-    }
+  /**
+   * Set mapping locations to search for xml mapping via class path search.
+   * <p>
+   * This is only used if classes have not been explicitly specified.
+   * </p>
+   */
+  public void setMappingLocations(List<String> mappingLocations) {
+    this.mappingLocations = mappingLocations;
+  }
 
-    /**
-     * Return true, if optimized packing should be used.
-     */
-    public boolean useBinaryOptimized() {
-      return binaryOptimized;
-    }
+  /**
+   * When false we need explicit <code>@GeneratedValue</code> mapping to assign
+   * Identity or Sequence generated values. When true Id properties are automatically
+   * assigned Identity or Sequence without the GeneratedValue mapping.
+   */
+  public boolean isIdGeneratorAutomatic() {
+    return idGeneratorAutomatic;
+  }
+
+  /**
+   * Set to false such that Id properties require explicit <code>@GeneratedValue</code>
+   * mapping before they are assigned Identity or Sequence generation based on platform.
+   */
+  public void setIdGeneratorAutomatic(boolean idGeneratorAutomatic) {
+    this.idGeneratorAutomatic = idGeneratorAutomatic;
   }
 
   public enum UuidVersion {

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

@@ -112,39 +112,7 @@ public class UnderscoreNamingConvention extends AbstractNamingConvention {
    * Convert and return the string to underscore from camel case.
    */
   protected String toUnderscoreFromCamel(String camelCase) {
-
-    int lastUpper = -1;
-    StringBuilder sb = new StringBuilder(camelCase.length() + 4);
-    for (int i = 0; i < camelCase.length(); i++) {
-      char c = camelCase.charAt(i);
-
-      if ('_' == c) {
-        // Underscores should just be passed through
-        sb.append(c);
-        lastUpper = i;
-      } else if (Character.isDigit(c)) {
-        if (i > lastUpper + 1 && !digitsCompressed) {
-          sb.append("_");
-        }
-        sb.append(c);
-        lastUpper = i;
-
-      } else if (Character.isUpperCase(c)) {
-        if (i > lastUpper + 1) {
-          sb.append("_");
-        }
-        sb.append(Character.toLowerCase(c));
-        lastUpper = i;
-
-      } else {
-        sb.append(c);
-      }
-    }
-    String ret = sb.toString();
-    if (forceUpperCase) {
-      ret = ret.toUpperCase();
-    }
-    return ret;
+    return CamelCaseHelper.toUnderscoreFromCamel(camelCase, digitsCompressed, forceUpperCase);
   }
 
   /**

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

@@ -5,8 +5,7 @@ import io.ebean.Query;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Platform;
 import io.ebean.config.CustomDbTypeMapping;
-import io.ebean.config.DbTypeConfig;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.PlatformConfig;
 import io.ebean.util.JdbcClose;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -215,16 +214,16 @@ public class DatabasePlatform {
   /**
    * Configure the platform given the server configuration.
    */
-  public void configure(ServerConfig config) {
+  public void configure(PlatformConfig config) {
     this.sequenceBatchSize = config.getDatabaseSequenceBatchSize();
     configureIdType(config.getIdType());
-    configure(config.getDbTypeConfig(), config.isAllQuotedIdentifiers());
+    configure(config, config.isAllQuotedIdentifiers());
   }
 
   /**
    * Configure UUID Storage etc based on ServerConfig settings.
    */
-  protected void configure(DbTypeConfig config, boolean allQuotedIdentifiers) {
+  protected void configure(PlatformConfig config, boolean allQuotedIdentifiers) {
     this.allQuotedIdentifiers = allQuotedIdentifiers;
     addGeoTypes(config.getGeometrySRID());
     configureIdType(config.getIdType());
@@ -382,6 +381,13 @@ public class DatabasePlatform {
     this.historySupport = historySupport;
   }
 
+  /**
+   * So no except for Postgres and CockroachDB.
+   */
+  public boolean isNativeArrayType() {
+    return false;
+  }
+
   /**
    * Return true if the DB supports native UUID.
    */
@@ -518,6 +524,13 @@ public class DatabasePlatform {
     this.forwardOnlyHintOnFindIterate = forwardOnlyHintOnFindIterate;
   }
 
+  /**
+   * Normally not needed - overridden in CockroachPlatform.
+   */
+  public boolean isDdlCommitOnCreateIndex() {
+    return false;
+  }
+
   /**
    * Return the DB identity/sequence features for this platform.
    *

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

@@ -1,6 +1,6 @@
 package io.ebean.config.dbplatform;
 
-import io.ebean.config.ServerConfig;
+import io.ebean.config.PlatformConfig;
 
 import java.util.EnumMap;
 import java.util.Map;
@@ -119,8 +119,8 @@ public class DbPlatformTypeMapping {
       put(DbType.JSONCLOB, JSON_CLOB_PLACEHOLDER);
       put(DbType.JSONBLOB, JSON_BLOB_PLACEHOLDER);
       put(DbType.JSONVARCHAR, JSON_VARCHAR_PLACEHOLDER);
-      // use reasonable default of varchar(40) - ideally set via DatabasePlatform.configure(DbTypeConfig)
-      put(DbType.UUID, get(DbType.VARCHAR).withLength(40));
+      // default to native UUID and override on platform configure()
+      put(DbType.UUID, UUID_NATIVE);
     }
   }
 
@@ -198,9 +198,9 @@ public class DbPlatformTypeMapping {
   /**
    * Map the UUID appropriately based on native DB support and ServerConfig.DbUuid.
    */
-  public void config(boolean nativeUuidType, ServerConfig.DbUuid dbUuid) {
+  public void config(boolean nativeUuidType, PlatformConfig.DbUuid dbUuid) {
     if (nativeUuidType && dbUuid.useNativeType()) {
-      put(DbType.UUID, UUID_NATIVE);
+      // native UUID already set by default
     } else if (dbUuid.useBinary()) {
       put(DbType.UUID, get(DbType.BINARY).withLength(16));
     } else {

src/main/java/io/ebean/config/dbplatform/cockroach/CockroachPlatform.java

@@ -0,0 +1,28 @@
+package io.ebean.config.dbplatform.cockroach;
+
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.postgres.PostgresPlatform;
+
+/**
+ * CockroachDB based platform.
+ */
+public class CockroachPlatform extends PostgresPlatform {
+
+  public CockroachPlatform() {
+    super();
+    this.platform = Platform.COCKROACH;
+    // no like escape clause supported
+    this.likeSpecialCharacters = new char[]{'%', '_'};
+    this.likeClauseRaw = "like ?";
+    this.likeClauseEscaped = "like ?";
+  }
+
+  /**
+   * Needs a commit after create index such that alter table add foreign key ... succeeds.
+   */
+  @Override
+  public boolean isDdlCommitOnCreateIndex() {
+    return true;
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/postgres/PostgresPlatform.java

@@ -88,6 +88,14 @@ public class PostgresPlatform extends DatabasePlatform {
     return new DbPlatformType("geometry(" + type + "," + srid + ")");
   }
 
+  /**
+   * So we can generate varchar[], int[], uuid[] column definitions and use the associated scalar types.
+   */
+  @Override
+  public boolean isNativeArrayType() {
+    return true;
+  }
+
   /**
    * Create a Postgres specific sequence IdGenerator.
    */

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServer16Platform.java

@@ -0,0 +1,26 @@
+package io.ebean.config.dbplatform.sqlserver;
+
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.DbPlatformType;
+import io.ebean.config.dbplatform.DbType;
+import io.ebean.config.dbplatform.IdType;
+
+/**
+ * Microsoft SQL Server platform that has non-UTF8 types (char, varchar, text) and default to Identity rather than Sequence.
+ */
+public class SqlServer16Platform extends SqlServerBasePlatform {
+
+  public SqlServer16Platform() {
+    super();
+    this.platform = Platform.SQLSERVER16;
+    // default to use Identity rather than sequences
+    this.dbIdentity.setIdType(IdType.IDENTITY);
+
+    // non-utf8 column types
+    dbTypeMap.put(DbType.CHAR, new DbPlatformType("char", 1));
+    dbTypeMap.put(DbType.VARCHAR, new DbPlatformType("varchar", 255));
+    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("text"));
+    dbTypeMap.put(DbType.CLOB, new DbPlatformType("text"));
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServer17Platform.java

@@ -0,0 +1,20 @@
+package io.ebean.config.dbplatform.sqlserver;
+
+import io.ebean.annotation.Platform;
+import io.ebean.config.dbplatform.DbPlatformType;
+import io.ebean.config.dbplatform.DbType;
+
+/**
+ * Microsoft SQL Server platform - NVarchar UTF types and Sequence preference.
+ */
+public class SqlServer17Platform extends SqlServerBasePlatform {
+
+  public SqlServer17Platform() {
+    super();
+    this.platform = Platform.SQLSERVER17;
+    this.columnAliasPrefix = null;
+    this.nativeUuidType = true;
+    this.dbTypeMap.put(DbType.UUID, new DbPlatformType("uniqueidentifier", false));
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServer2005Platform.java

@@ -3,7 +3,7 @@ package io.ebean.config.dbplatform.sqlserver;
 /**
  * SQL Server platform using the older ROW_NUMBER() mechanism.
  */
-public class SqlServer2005Platform extends SqlServerPlatform {
+public class SqlServer2005Platform extends SqlServer16Platform {
 
   public SqlServer2005Platform() {
     this.sqlLimiter = new SqlServer2005SqlLimiter();

src/main/java/io/ebean/config/dbplatform/sqlserver/SqlServerBasePlatform.java

@@ -4,7 +4,7 @@ import io.ebean.BackgroundExecutor;
 import io.ebean.Query;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Platform;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.PlatformConfig;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.DbPlatformType;
 import io.ebean.config.dbplatform.DbType;
@@ -16,11 +16,11 @@ import javax.sql.DataSource;
 import java.sql.Types;
 
 /**
- * Microsoft SQL Server platform.
+ * Base Microsoft SQL Server platform - NVarchar UTF types and Sequence preference by default.
  */
-public class SqlServerPlatform extends DatabasePlatform {
+abstract class SqlServerBasePlatform extends DatabasePlatform {
 
-  public SqlServerPlatform() {
+  SqlServerBasePlatform() {
     super();
     this.platform = Platform.SQLSERVER;
     // disable persistBatchOnCascade mode for
@@ -31,7 +31,7 @@ public class SqlServerPlatform extends DatabasePlatform {
     this.sqlLimiter = new SqlServerSqlLimiter();
     this.basicSqlLimiter = new SqlServerBasicSqlLimiter();
     this.historySupport = new SqlServerHistorySupport();
-    this.dbIdentity.setIdType(IdType.IDENTITY);
+    this.dbIdentity.setIdType(IdType.SEQUENCE);
     this.dbIdentity.setSupportsGetGeneratedKeys(true);
     this.dbIdentity.setSupportsIdentity(true);
     this.dbIdentity.setSupportsSequence(true);
@@ -63,22 +63,26 @@ public class SqlServerPlatform extends DatabasePlatform {
     dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint"));
     dbTypeMap.put(DbType.DECIMAL, new DbPlatformType("numeric", 28));
 
-    dbTypeMap.put(DbType.BLOB, new DbPlatformType("image"));
-    dbTypeMap.put(DbType.CLOB, new DbPlatformType("text"));
-    dbTypeMap.put(DbType.LONGVARBINARY, new DbPlatformType("image"));
-    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("text"));
 
     dbTypeMap.put(DbType.DATE, new DbPlatformType("date"));
     dbTypeMap.put(DbType.TIME, new DbPlatformType("time"));
     dbTypeMap.put(DbType.TIMESTAMP, new DbPlatformType("datetime2"));
 
+    // UTF8 aware types - overwritten in SqlServer16 platform
+    dbTypeMap.put(DbType.CHAR, new DbPlatformType("nchar", 1));
+    dbTypeMap.put(DbType.VARCHAR, new DbPlatformType("nvarchar", 255));
+    dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
+    dbTypeMap.put(DbType.CLOB, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
+
     dbTypeMap.put(DbType.JSON, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
     dbTypeMap.put(DbType.JSONB, new DbPlatformType("nvarchar", Integer.MAX_VALUE));
 
+    dbTypeMap.put(DbType.BLOB, new DbPlatformType("image"));
+    dbTypeMap.put(DbType.LONGVARBINARY, new DbPlatformType("image"));
   }
 
   @Override
-  public void configure(ServerConfig config) {
+  public void configure(PlatformConfig config) {
     super.configure(config);
     if (dbIdentity.getIdType() == IdType.SEQUENCE) {
       this.persistBatchOnCascade = PersistBatch.ALL;

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

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

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

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

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

@@ -1,5 +1,6 @@
 package io.ebean.config.properties;
 
+import java.util.Enumeration;
 import java.util.Properties;
 
 /**
@@ -56,14 +57,18 @@ public class PropertiesLoader {
   }
 
   /**
-   * Set (override) a configuration property.
-   *
-   * This is expected to be only called by test configuration logic
-   * (ala automatic test configuration via ebean-test-config).
+   * Return a copy of the properties with 'eval' run on all the values.
+   * This resolves expressions like ${HOME} etc.
    */
-  public static synchronized void setProperty(String key, String value) {
-    load();
-    properties.setProperty(key, value);
-  }
+  public static Properties eval(Properties properties) {
+    Properties evalCopy = new Properties();
 
+    Enumeration<?> names = properties.propertyNames();
+    while (names.hasMoreElements()) {
+      String name = (String)names.nextElement();
+      String value = PropertyEval.eval(properties.getProperty(name));
+      evalCopy.setProperty(name, value);
+    }
+    return evalCopy;
+  }
 }

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

@@ -21,9 +21,12 @@ class YamlLoader {
     this.loadContext = loadContext;
   }
 
+  @SuppressWarnings("unchecked")
   void load(InputStream is) {
     if (is != null) {
-      loadMap(yaml.load(is), null);
+      for (Object map : yaml.loadAll(is)) {
+        loadMap((Map<String, Object>)map, null);
+      }
     }
   }
 

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

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

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

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

src/main/java/io/ebean/meta/AbstractMetricVisitor.java

@@ -0,0 +1,43 @@
+package io.ebean.meta;
+
+/**
+ * An abstract MetricVisitor that handles the boolean flags - reset, collectTransactionMetrics and collectQueryMetrics.
+ */
+public abstract class AbstractMetricVisitor implements MetricVisitor {
+
+  private final boolean reset;
+  private final boolean collectTransactionMetrics;
+  private final boolean collectQueryMetrics;
+
+  public AbstractMetricVisitor(boolean reset, boolean collectTransactionMetrics, boolean collectQueryMetrics) {
+    this.reset = reset;
+    this.collectTransactionMetrics = collectTransactionMetrics;
+    this.collectQueryMetrics = collectQueryMetrics;
+  }
+
+  @Override
+  public boolean isReset() {
+    return reset;
+  }
+
+  @Override
+  public boolean isCollectTransactionMetrics() {
+    return collectTransactionMetrics;
+  }
+
+  @Override
+  public boolean isCollectQueryMetrics() {
+    return collectQueryMetrics;
+  }
+
+  @Override
+  public void visitStart() {
+    // do nothing by default
+  }
+
+  @Override
+  public void visitEnd() {
+    // do nothing by default
+  }
+}
+

src/main/java/io/ebean/meta/BasicMetricVisitor.java

@@ -0,0 +1,64 @@
+package io.ebean.meta;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A simple MetricVisitor that can collect the desired metrics into lists.
+ */
+public class BasicMetricVisitor extends AbstractMetricVisitor {
+
+  private final List<MetaTimedMetric> timed = new ArrayList<>();
+  private final List<MetaQueryMetric> dtoQuery = new ArrayList<>();
+  private final List<MetaOrmQueryMetric> ormQuery = new ArrayList<>();
+
+  /**
+   * Construct to reset and collect everything.
+   */
+  public BasicMetricVisitor() {
+    super(true, true, true);
+  }
+
+  /**
+   * Construct specifying reset and what to collect.
+   */
+  public BasicMetricVisitor(boolean reset, boolean collectTransactionMetrics, boolean collectQueryMetrics) {
+    super(reset, collectTransactionMetrics, collectQueryMetrics);
+  }
+
+  /**
+   * Return timed metrics for Transactions, labelled SqlQuery, labelled SqlUpdate.
+   */
+  public List<MetaTimedMetric> getTimedMetrics() {
+    return timed;
+  }
+
+  /**
+   * Return the DTO query metrics.
+   */
+  public List<MetaQueryMetric> getDtoQueryMetrics() {
+    return dtoQuery;
+  }
+
+  /**
+   * Return the ORM query metrics.
+   */
+  public List<MetaOrmQueryMetric> getOrmQueryMetrics() {
+    return ormQuery;
+  }
+
+  @Override
+  public void visitTimed(MetaTimedMetric metric) {
+    timed.add(metric);
+  }
+
+  @Override
+  public void visitQuery(MetaQueryMetric metric) {
+    dtoQuery.add(metric);
+  }
+
+  @Override
+  public void visitOrmQuery(MetaOrmQueryMetric metric) {
+    ormQuery.add(metric);
+  }
+}

src/main/java/io/ebean/meta/MetaInfoManager.java

@@ -8,23 +8,20 @@ import java.util.List;
 public interface MetaInfoManager {
 
   /**
-   * Collect and return the transaction execution metrics.
+   * Visit the metrics resetting and collecting/reporting as desired.
    */
-  List<MetaTimedMetric> collectTransactionStatistics(boolean reset);
+  void visitMetrics(MetricVisitor visitor);
 
   /**
-   * Collect query plan statistics (new, will migrate ORM query stats over to this).
+   * Run a visit collecting all the metrics and returning BasicMetricVisitor
+   * which holds all the metrics in simple lists.
    */
-  List<MetaQueryMetric> collectQueryStatistics(boolean reset);
+  BasicMetricVisitor visitBasic();
 
   /**
-   * Collect and return the non-empty query plan statistics for all the beans.
-   * <p>
-   * Note that this excludes the query plan statistics where there has been no
-   * executions (since the last collection with reset).
-   * </p>
+   * Just reset all the metrics. Maybe only useful for testing purposes.
    */
-  List<MetaQueryPlanStatistic> collectQueryPlanStatistics(boolean reset);
+  void resetAllMetrics();
 
   /**
    * Collect and return the ObjectGraphNode statistics.
@@ -36,6 +33,6 @@ public interface MetaInfoManager {
    *
    * @param reset Set to true to reset the underlying statistics after collection.
    */
-  List<MetaObjectGraphNodeStats> collectNodeStatistics(boolean reset);
+  List<MetaOrmQueryNode> collectNodeStatistics(boolean reset);
 
 }

src/main/java/io/ebean/meta/MetaOrmQueryMetric.java

@@ -0,0 +1,42 @@
+package io.ebean.meta;
+
+import io.ebean.ProfileLocation;
+
+import java.util.List;
+
+/**
+ * Query execution statistics for Orm queries.
+ */
+public interface MetaOrmQueryMetric extends MetaQueryMetric {
+
+  /**
+   * Return the profile location.
+   */
+  ProfileLocation getProfileLocation();
+
+  /**
+   * Return true if this query plan was tuned by AutoTune.
+   */
+  boolean isAutoTuned();
+
+  /**
+   * Return a string representation of the query plan hash.
+   */
+  String getQueryPlanHash();
+
+  /**
+   * Return the time of the last query executed using this plan.
+   */
+  long getLastQueryTime();
+
+  /**
+   * Return the 'origin' points and paths that resulted in the query being
+   * executed and the associated number of times the query was executed via that
+   * path.
+   * <p>
+   * This includes direct and lazy loading paths.
+   * </p>
+   */
+  List<MetaOrmQueryOrigin> getOrigins();
+
+}

src/main/java/io/ebean/meta/MetaOrmQueryNode.java

@@ -8,10 +8,8 @@ import io.ebean.bean.ObjectGraphNode;
  * These statistics can be used to identify origin queries that result in lots
  * of lazy loading.
  * </p>
- *
- * @see MetaInfoManager#collectNodeStatistics(boolean)
  */
-public interface MetaObjectGraphNodeStats {
+public interface MetaOrmQueryNode {
 
   /**
    * Return the ObjectGraphNode which has the origin point and relative path.

src/main/java/io/ebean/meta/MetaOrmQueryOrigin.java

@@ -9,11 +9,8 @@ import io.ebean.bean.ObjectGraphNode;
  * This basically points to the bit of original code and query that results in
  * this query directly or via lazy loading.
  * </p>
- *
- * @see MetaQueryPlanStatistic
- * @see MetaInfoManager#collectQueryPlanStatistics(boolean)
  */
-public interface MetaQueryPlanOriginCount {
+public interface MetaOrmQueryOrigin {
 
   /**
    * The 'origin' and path which this query belongs to.

src/main/java/io/ebean/meta/MetaQueryPlanStatistic.java

@@ -1,98 +0,0 @@
-package io.ebean.meta;
-
-import io.ebean.ProfileLocation;
-
-import java.util.List;
-
-/**
- * Query execution statistics Meta data.
- *
- * @see MetaInfoManager#collectQueryPlanStatistics(boolean)
- */
-public interface MetaQueryPlanStatistic {
-
-  /**
-   * Return the bean type this query plan is for.
-   */
-  Class<?> getBeanType();
-
-  /**
-   * Return the profile location.
-   */
-  ProfileLocation getProfileLocation();
-
-  /**
-   * Return true if this query plan was tuned by AutoTune.
-   */
-  boolean isAutoTuned();
-
-  /**
-   * Return a string representation of the query plan hash.
-   */
-  String getQueryPlanHash();
-
-  /**
-   * Return the sql executed.
-   */
-  String getSql();
-
-  /**
-   * Return the total number of queries executed.
-   */
-  long getExecutionCount();
-
-  /**
-   * Return the total number of beans loaded by the queries.
-   * <p>
-   * This excludes background fetching.
-   * </p>
-   */
-  long getTotalLoadedBeans();
-
-  /**
-   * Return the total time taken by executions of this query.
-   */
-  long getTotalTimeMicros();
-
-  /**
-   * Return the max execution time for this query.
-   */
-  long getMaxTimeMicros();
-
-  /**
-   * Return the time collection started (or was last reset).
-   */
-  long getCollectionStart();
-
-  /**
-   * Return the time of the last query executed using this plan.
-   */
-  long getLastQueryTime();
-
-  /**
-   * Return the average query execution time in microseconds.
-   * <p>
-   * This excludes background fetching.
-   * </p>
-   */
-  long getAvgTimeMicros();
-
-  /**
-   * Return the average number of bean loaded per query.
-   * <p>
-   * This excludes background fetching.
-   * </p>
-   */
-  long getAvgLoadedBeans();
-
-  /**
-   * Return the 'origin' points and paths that resulted in the query being
-   * executed and the associated number of times the query was executed via that
-   * path.
-   * <p>
-   * This includes direct and lazy loading paths.
-   * </p>
-   */
-  List<MetaQueryPlanOriginCount> getOrigins();
-
-}

src/main/java/io/ebean/meta/MetaTimedMetric.java

@@ -6,6 +6,11 @@ package io.ebean.meta;
  */
 public interface MetaTimedMetric {
 
+  /**
+   * Return the metric type.
+   */
+  MetricType getMetricType();
+
   /**
    * Return the metric name.
    */

src/main/java/io/ebean/meta/MetricType.java

@@ -0,0 +1,30 @@
+package io.ebean.meta;
+
+/**
+ * The type of Metric.
+ */
+public enum MetricType {
+
+  /**
+   * Transactions.
+   */
+  TXN,
+
+  /**
+   * ORM queries.
+   */
+  ORM,
+
+  /**
+   * DTO queries.
+   */
+  DTO,
+
+  /**
+   * SQL queries with a label will have metrics collected.
+   * <p>
+   * SqlQuery and SqlUpdate without a label have no metrics collected.
+   */
+  SQL
+
+}

src/main/java/io/ebean/meta/MetricVisitor.java

@@ -0,0 +1,48 @@
+package io.ebean.meta;
+
+/**
+ * Defines visitor to read and report the transaction and query metrics.
+ */
+public interface MetricVisitor {
+
+  /**
+   * Return true if the metrics should be reset.
+   */
+  boolean isReset();
+
+  /**
+   * Return true if we should visit the transaction metrics.
+   */
+  boolean isCollectTransactionMetrics();
+
+  /**
+   * Return true if we should visit the ORM and SQL query metrics.
+   */
+  boolean isCollectQueryMetrics();
+
+  /**
+   * Visit has started.
+   */
+  void visitStart();
+
+  /**
+   * Visit transaction metrics (and L2 cache metrics in future).
+   */
+  void visitTimed(MetaTimedMetric metric);
+
+  /**
+   * Visit DTO and SQL query metrics.
+   */
+  void visitQuery(MetaQueryMetric metric);
+
+  /**
+   * Visit ORM query metrics.
+   */
+  void visitOrmQuery(MetaOrmQueryMetric metric);
+
+  /**
+   * Visit has completed.
+   */
+  void visitEnd();
+
+}

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

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

src/main/java/io/ebean/util/CamelCaseHelper.java

@@ -2,6 +2,52 @@ package io.ebean.util;
 
 public class CamelCaseHelper {
 
+  /**
+   * To underscore from camel case using digits compressed true and force upper case false.
+   */
+  public static String toUnderscoreFromCamel(String camelCase) {
+    return toUnderscoreFromCamel(camelCase, true, false);
+  }
+
+  /**
+   * Convert and return the string to underscore from camel case.
+   */
+  public static String toUnderscoreFromCamel(String camelCase, boolean digitsCompressed, boolean forceUpperCase) {
+
+    int lastUpper = -1;
+    StringBuilder sb = new StringBuilder(camelCase.length() + 4);
+    for (int i = 0; i < camelCase.length(); i++) {
+      char c = camelCase.charAt(i);
+
+      if ('_' == c) {
+        // Underscores should just be passed through
+        sb.append(c);
+        lastUpper = i;
+      } else if (Character.isDigit(c)) {
+        if (i > lastUpper + 1 && !digitsCompressed) {
+          sb.append("_");
+        }
+        sb.append(c);
+        lastUpper = i;
+
+      } else if (Character.isUpperCase(c)) {
+        if (i > lastUpper + 1) {
+          sb.append("_");
+        }
+        sb.append(Character.toLowerCase(c));
+        lastUpper = i;
+
+      } else {
+        sb.append(c);
+      }
+    }
+    String ret = sb.toString();
+    if (forceUpperCase) {
+      ret = ret.toUpperCase();
+    }
+    return ret;
+  }
+
   /**
    * To camel from underscore.
    *

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

@@ -1,6 +1,5 @@
 package io.ebeaninternal.api;
 
-import io.ebean.EbeanServer;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebean.util.StringHelper;
@@ -124,11 +123,11 @@ public class LoadManyRequest extends LoadRequest {
     return loadContext.getBeanProperty();
   }
 
-  public SpiQuery<?> createQuery(EbeanServer server, int batchSize) {
+  public SpiQuery<?> createQuery(SpiEbeanServer server, int batchSize) {
 
     BeanPropertyAssocMany<?> many = getMany();
 
-    SpiQuery<?> query = (SpiQuery<?>) server.createQuery(many.getTargetType());
+    SpiQuery<?> query = many.newQuery(server);
     String orderBy = many.getLazyFetchOrderBy();
     if (orderBy != null) {
       query.orderBy(orderBy);

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

@@ -21,6 +21,11 @@ public class ScopedTransaction extends SpiTransactionProxy {
 
   private ScopeTrans current;
 
+  /**
+   * Flag set when we clear the thread scope (on commit/rollback or end).
+   */
+  private boolean scopeCleared;
+
   public ScopedTransaction(TransactionScopeManager manager) {
     this.manager = manager;
   }
@@ -47,30 +52,51 @@ public class ScopedTransaction extends SpiTransactionProxy {
    */
   public void complete(Object returnOrThrowable, int opCode) {
     current.complete(returnOrThrowable, opCode);
+    // no finally here for pop() as we come in here twice if an
+    // error is thrown on commit (due to enhancement finally block)
     pop();
   }
 
   /**
-   * Programmatic complete - finally block, try to commit.
+   * Internal programmatic complete - finally block, try to commit.
    */
   public void complete() {
-    current.complete();
-    pop();
+    try {
+      current.complete();
+    } finally {
+      pop();
+    }
+  }
+
+  private void clearScopeOnce() {
+    if (!scopeCleared) {
+      manager.set(null);
+      scopeCleared = true;
+    }
+  }
+
+  private boolean clearScope() {
+    if (stack.isEmpty()) {
+      clearScopeOnce();
+      return true;
+    }
+    return false;
   }
 
   private void pop() {
-    if (!stack.isEmpty()) {
+    if (!clearScope()) {
       current = stack.pop();
       transaction = current.getTransaction();
-    } else {
-      manager.set(null);
     }
   }
 
   @Override
   public void end() throws PersistenceException {
-    current.end();
-    pop();
+    try {
+      current.end();
+    } finally {
+      pop();
+    }
   }
 
   @Override
@@ -80,17 +106,29 @@ public class ScopedTransaction extends SpiTransactionProxy {
 
   @Override
   public void commit() {
-    current.commitTransaction();
+    try {
+      current.commitTransaction();
+    } finally {
+      clearScope();
+    }
   }
 
   @Override
   public void rollback() throws PersistenceException {
-    current.rollback(null);
+    try {
+      current.rollback(null);
+    } finally {
+      clearScope();
+    }
   }
 
   @Override
   public void rollback(Throwable e) throws PersistenceException {
-    current.rollback(e);
+    try {
+      current.rollback(e);
+    } finally {
+      clearScope();
+    }
   }
 
   @Override

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

@@ -17,7 +17,7 @@ public interface SpiDtoQuery<T> extends DtoQuery<T>, SpiSqlBinding {
   /**
    * Get the query plan for the cache.
    */
-  DtoQueryPlan getQueryPlan(String planKey);
+  DtoQueryPlan getQueryPlan(Object planKey);
 
   /**
    * Build the query plan.
@@ -27,7 +27,7 @@ public interface SpiDtoQuery<T> extends DtoQuery<T>, SpiSqlBinding {
   /**
    * Put the query plan into the cache.
    */
-  void putQueryPlan(String planKey, DtoQueryPlan plan);
+  void putQueryPlan(Object planKey, DtoQueryPlan plan);
 
   /**
    * Return true if the query is in relaxed mapping mode.
@@ -43,4 +43,10 @@ public interface SpiDtoQuery<T> extends DtoQuery<T>, SpiSqlBinding {
    * Return the associated DTO bean type.
    */
   Class<T> getType();
+
+  /**
+   * Return an underlying ORM query (if this query is built from an ORM query).
+   */
+  SpiQuery<?> getOrmQuery();
+
 }

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

@@ -1,8 +1,11 @@
 package io.ebeaninternal.api;
 
+import io.ebean.DtoQuery;
 import io.ebean.EbeanServer;
 import io.ebean.PersistenceContextScope;
 import io.ebean.Query;
+import io.ebean.RowConsumer;
+import io.ebean.RowMapper;
 import io.ebean.Transaction;
 import io.ebean.TxScope;
 import io.ebean.bean.BeanCollectionLoader;
@@ -13,7 +16,9 @@ import io.ebean.config.ServerConfig;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.event.readaudit.ReadAuditLogger;
 import io.ebean.event.readaudit.ReadAuditPrepare;
+import io.ebean.meta.MetricVisitor;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlHandler;
+import io.ebeaninternal.server.core.SpiResultSet;
 import io.ebeaninternal.server.core.timezone.DataTimeZone;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.query.CQuery;
@@ -28,6 +33,11 @@ import java.util.function.Predicate;
  */
 public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionLoader {
 
+  /**
+   * Return the log manager.
+   */
+  SpiLogManager log();
+
   /**
    * Return the server extended Json context.
    */
@@ -226,6 +236,31 @@ public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionL
    */
   void scopedTransactionExit(Object returnOrThrowable, int opCode);
 
+  /**
+   * SqlQuery find single attribute.
+   */
+  <T> T findSingleAttribute(SpiSqlQuery query, Class<T> cls);
+
+  /**
+   * SqlQuery find single attribute list.
+   */
+  <T> List<T> findSingleAttributeList(SpiSqlQuery query, Class<T> cls);
+
+  /**
+   * SqlQuery find one with mapper.
+   */
+  <T> T findOneMapper(SpiSqlQuery query, RowMapper<T> mapper);
+
+  /**
+   * SqlQuery find list with mapper.
+   */
+  <T> List<T> findListMapper(SpiSqlQuery query, RowMapper<T> mapper);
+
+  /**
+   * SqlQuery find each with consumer.
+   */
+  void findEachRow(SpiSqlQuery query, RowConsumer consumer);
+
   /**
    * DTO findList query.
    */
@@ -246,4 +281,34 @@ public interface SpiEbeanServer extends EbeanServer, BeanLoader, BeanCollectionL
    */
   <T> void findDtoEachWhile(SpiDtoQuery<T> query, Predicate<T> consumer);
 
+  /**
+   * Return / wrap the ORM query as a DTO query.
+   */
+  <D> DtoQuery<D> findDto(Class<D> dtoType, SpiQuery<?> ormQuery);
+
+  /**
+   * Execute the underlying ORM query returning as a JDBC ResultSet to map to DTO beans.
+   */
+  SpiResultSet findResultSet(SpiQuery<?> ormQuery, SpiTransaction transaction);
+
+  /**
+   * Visit all the metrics (typically reporting them).
+   */
+  void visitMetrics(MetricVisitor visitor);
+
+  /**
+   * Return true if a row for the bean type and id exists.
+   */
+  boolean exists(Class<?> beanType, Object beanId, Transaction transaction);
+
+  /**
+   * Add to JDBC batch for later execution.
+   */
+  void addBatch(SpiSqlUpdate defaultSqlUpdate, SpiTransaction transaction);
+
+  /**
+   * Execute the batched statement.
+   */
+  int[] executeBatch(SpiSqlUpdate defaultSqlUpdate, SpiTransaction transaction);
+
 }

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

@@ -1,8 +1,8 @@
 package io.ebeaninternal.api;
 
-import io.ebeaninternal.server.core.DbExpressionHandler;
 import io.ebeaninternal.server.core.SpiOrmQueryRequest;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.expression.platform.DbExpressionHandler;
 
 import java.util.List;
 

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

@@ -1,9 +1,11 @@
 package io.ebeaninternal.api;
 
 import com.fasterxml.jackson.core.JsonGenerator;
+import io.ebean.plugin.BeanType;
 import io.ebean.text.json.JsonContext;
 import io.ebean.text.json.JsonWriteOptions;
-import io.ebeaninternal.server.text.json.SpiJsonWriter;
+import io.ebeaninternal.api.json.SpiJsonReader;
+import io.ebeaninternal.api.json.SpiJsonWriter;
 
 import java.io.Writer;
 
@@ -21,4 +23,10 @@ public interface SpiJsonContext extends JsonContext {
    * Create a Json Writer for writing beans as JSON supplying a writer.
    */
   SpiJsonWriter createJsonWriter(Writer writer);
+
+  /**
+   * Create a Json Reader for reading the JSON content.
+   */
+  SpiJsonReader createJsonRead(BeanType<?> beanType, String json);
+
 }

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

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

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

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

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

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

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

@@ -179,6 +179,11 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   ProfileLocation getProfileLocation();
 
+  /**
+   * Return the label set on the query.
+   */
+  String getLabel();
+
   /**
    * Return true if this is a "find by id" query. This includes a check for a single "equal to" expression for the Id.
    */
@@ -215,6 +220,11 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   BeanDescriptor<T> getBeanDescriptor();
 
+  /**
+   * Return the query plan key.
+   */
+  Object getQueryPlanKey();
+
   /**
    * Return the RawSql that was set to use for this query.
    */
@@ -634,9 +644,9 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
   boolean isBeanCachePut();
 
   /**
-   * Return true if the bean cache is being explicitly loaded via RECACHE mode.
+   * Return true if we must hit the DB (Cache reload or select for update).
    */
-  boolean isBeanCacheReload();
+  boolean isForceHitDatabase();
 
   /**
    * Return the cache mode for using the bean cache (Get and Put).
@@ -748,6 +758,16 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   boolean isDistinct();
 
+  /**
+   * Return true if the Id property is manually included in the query (DTO queries).
+   */
+  boolean isManualId();
+
+  /**
+   * Set to true when we only include the Id property if it is explicitly included in the select().
+   */
+  void setManualId(boolean manualId);
+
   /**
    * Set default select clauses where none have been explicitly defined.
    */

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

@@ -15,6 +15,11 @@ public interface SpiSqlBinding {
    */
   String getQuery();
 
+  /**
+   * Return the label (to collect metrics on when set).
+   */
+  String getLabel();
+
   /**
    * Return the first row to fetch.
    */

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

@@ -23,4 +23,9 @@ public interface SpiSqlUpdate extends SqlUpdate {
    * Set the generated key value.
    */
   void setGeneratedKey(Object idValue);
+
+  /**
+   * Reset bind position to be ready for another bind execute.
+   */
+  void reset();
 }

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

@@ -319,4 +319,9 @@ public interface SpiTransaction extends Transaction {
    * Return the profile location for this transaction.
    */
   ProfileLocation getProfileLocation();
+
+  /**
+   * Return true when nested transactions should create Savepoints.
+   */
+  boolean isNestedUseSavepoint();
 }

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

@@ -21,7 +21,7 @@ import java.sql.SQLException;
 /**
  * Proxy for an underlying SpiTransaction (most of the API).
  */
-abstract class SpiTransactionProxy implements SpiTransaction {
+public abstract class SpiTransactionProxy implements SpiTransaction {
 
   protected SpiTransaction transaction;
 
@@ -50,6 +50,16 @@ abstract class SpiTransactionProxy implements SpiTransaction {
     return transaction.isRollbackOnly();
   }
 
+  @Override
+  public void setNestedUseSavepoint() {
+    transaction.setNestedUseSavepoint();
+  }
+
+  @Override
+  public boolean isNestedUseSavepoint() {
+    return transaction.isNestedUseSavepoint();
+  }
+
   @Override
   public long profileOffset() {
     return transaction.profileOffset();

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

@@ -43,6 +43,11 @@ public interface SpiUpdate<T> extends Update<T> {
    */
   Class<?> getBeanType();
 
+  /**
+   * Return the label (for metrics collection).
+   */
+  String getLabel();
+
   /**
    * Return the type of this - insert, update or delete.
    */

src/main/java/io/ebeaninternal/api/json/SpiJsonReader.java

@@ -0,0 +1,36 @@
+package io.ebeaninternal.api.json;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.PersistenceContext;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+
+import java.io.IOException;
+import java.util.Map;
+
+public interface SpiJsonReader {
+
+  PersistenceContext getPersistenceContext();
+
+  SpiJsonReader forJson(JsonParser moreJson, boolean resetContext);
+
+  <T> void persistenceContextPut(Object beanId, T currentBean);
+
+  Object persistenceContextPutIfAbsent(Object id, EntityBean bean, BeanDescriptor<?> beanDesc);
+
+  ObjectMapper getObjectMapper();
+
+  JsonParser getParser();
+
+  JsonToken nextToken() throws IOException;
+
+  void pushPath(String path);
+
+  void popPath();
+
+  void beanVisitor(Object bean, Map<String, Object> unmappedProperties);
+
+  Object readValueUsingObjectMapper(Class<?> propertyType) throws IOException;
+}

src/main/java/io/ebeaninternal/api/json/SpiJsonWriter.java

@@ -1,9 +1,10 @@
-package io.ebeaninternal.server.text.json;
+package io.ebeaninternal.api.json;
 
 import io.ebean.bean.EntityBean;
 import io.ebean.text.json.JsonWriter;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 
+import java.io.IOException;
 import java.util.Collection;
 
 /**
@@ -11,6 +12,11 @@ import java.util.Collection;
  */
 public interface SpiJsonWriter extends JsonWriter {
 
+  /**
+   * Flush the buffer.
+   */
+  void flush() throws IOException;
+
   /**
    * Return true if the value is a parent bean.
    */
@@ -60,7 +66,7 @@ public interface SpiJsonWriter extends JsonWriter {
    * Write value using underlying Jaskson object mapper if available.
    */
   void writeValueUsingObjectMapper(String name, Object value);
-  
+
   /**
    * Write the bean properties.
    */

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

@@ -2,10 +2,10 @@ package io.ebeaninternal.dbmigration;
 
 import io.ebean.Transaction;
 import io.ebean.config.ServerConfig;
-import io.ebeaninternal.dbmigration.model.CurrentModel;
-import io.ebeaninternal.api.SpiEbeanServer;
-import io.ebeaninternal.extraddl.model.ExtraDdlXmlReader;
 import io.ebean.migration.ddl.DdlRunner;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.dbmigration.model.CurrentModel;
+import io.ebeaninternal.extraddl.model.ExtraDdlXmlReader;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -37,6 +37,7 @@ public class DdlGenerator {
   private final boolean runDdl;
   private final boolean createOnly;
   private final boolean jaxbPresent;
+  private final boolean ddlCommitOnCreateIndex;
 
   private CurrentModel currentModel;
   private String dropAllContent;
@@ -50,8 +51,10 @@ public class DdlGenerator {
     if (!serverConfig.getTenantMode().isDdlEnabled() && serverConfig.isDdlRun()) {
       log.warn("DDL can't be run on startup with TenantMode " + serverConfig.getTenantMode());
       this.runDdl = false;
+      this.ddlCommitOnCreateIndex = false;
     } else {
       this.runDdl = serverConfig.isDdlRun();
+      this.ddlCommitOnCreateIndex = server.getDatabasePlatform().isDdlCommitOnCreateIndex();
     }
   }
 
@@ -109,6 +112,8 @@ public class DdlGenerator {
     try {
       if (expectErrors) {
         connection.setAutoCommit(true);
+      } else if (ddlCommitOnCreateIndex) {
+        runner.setCommitOnCreateIndex();
       }
       int count = runner.runAll(content, connection);
       if (expectErrors) {
@@ -168,10 +173,11 @@ public class DdlGenerator {
   protected void runResourceScript(String sqlScript) throws IOException {
 
     if (sqlScript != null) {
-      InputStream is = getClassLoader().getResourceAsStream(sqlScript);
-      if (is != null) {
-        String content = readContent(new InputStreamReader(is));
-        runScript(false, content, sqlScript);
+      try (InputStream is = getClassLoader().getResourceAsStream(sqlScript)) {
+        if (is != null) {
+          String content = readContent(new InputStreamReader(is));
+          runScript(false, content, sqlScript);
+        }
       }
     }
   }

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

@@ -5,6 +5,7 @@ import io.ebean.EbeanServer;
 import io.ebean.annotation.Platform;
 import io.ebean.config.DbConstraintNaming;
 import io.ebean.config.DbMigrationConfig;
+import io.ebean.config.PlatformConfig;
 import io.ebean.config.ServerConfig;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.db2.DB2Platform;
@@ -15,7 +16,8 @@ import io.ebean.config.dbplatform.oracle.OraclePlatform;
 import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebean.config.dbplatform.sqlanywhere.SqlAnywherePlatform;
 import io.ebean.config.dbplatform.sqlite.SQLitePlatform;
-import io.ebean.config.dbplatform.sqlserver.SqlServerPlatform;
+import io.ebean.config.dbplatform.sqlserver.SqlServer16Platform;
+import io.ebean.config.dbplatform.sqlserver.SqlServer17Platform;
 import io.ebean.dbmigration.DbMigration;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
@@ -89,6 +91,12 @@ public class DefaultDbMigration implements DbMigration {
   protected DbConstraintNaming constraintNaming;
 
   protected Boolean strictMode;
+  protected Boolean includeGeneratedFileComment;
+  protected String header;
+  protected String applyPrefix;
+  protected String version;
+  protected String name;
+  protected String generatePendingDrop;
 
   /**
    * Create for offline migration generation.
@@ -146,6 +154,36 @@ public class DefaultDbMigration implements DbMigration {
     this.strictMode = strictMode;
   }
 
+  @Override
+  public void setApplyPrefix(String applyPrefix) {
+    this.applyPrefix = applyPrefix;
+  }
+
+  @Override
+  public void setVersion(String version) {
+    this.version = version;
+  }
+
+  @Override
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public void setGeneratePendingDrop(String generatePendingDrop) {
+    this.generatePendingDrop = generatePendingDrop;
+  }
+
+  @Override
+  public void setIncludeGeneratedFileComment(boolean includeGeneratedFileComment) {
+    this.includeGeneratedFileComment = includeGeneratedFileComment;
+  }
+
+  @Override
+  public void setHeader(String header) {
+    this.header = header;
+  }
+
   /**
    * Set the specific platform to generate DDL for.
    * <p>
@@ -226,15 +264,17 @@ public class DefaultDbMigration implements DbMigration {
     if (!online) {
       DbOffline.setGenerateMigration();
       if (databasePlatform == null && !platforms.isEmpty()) {
-        // for multiple platform generation set the general platform
-        // to H2 so that it runs offline without DB connection
+        // for multiple platform generation the first platform
+        // is used to generate the "logical" model diff
         setPlatform(platforms.get(0).platform);
       }
     }
     setDefaults();
+    if (!platforms.isEmpty()) {
+      configurePlatforms();
+    }
     try {
       Request request = createRequest();
-
       if (platforms.isEmpty()) {
         generateExtraDdl(request.migrationDir, databasePlatform);
       }
@@ -253,6 +293,16 @@ public class DefaultDbMigration implements DbMigration {
     }
   }
 
+  /**
+   * Load the configuration for each of the target platforms.
+   */
+  private void configurePlatforms() {
+    for (Pair pair : platforms) {
+      PlatformConfig config = serverConfig.newPlatformConfig("dbmigration.platform", pair.prefix);
+      pair.platform.configure(config);
+    }
+  }
+
   /**
    * Generate "repeatable" migration scripts.
    * <p>
@@ -498,8 +548,28 @@ public class DefaultDbMigration implements DbMigration {
       databasePlatform = server.getDatabasePlatform();
       logger.debug("set platform to {}", databasePlatform.getName());
     }
-    if (strictMode != null && migrationConfig != null) {
-      migrationConfig.setStrictMode(strictMode);
+    if (migrationConfig != null) {
+      if (strictMode != null) {
+        migrationConfig.setStrictMode(strictMode);
+      }
+      if (applyPrefix != null) {
+        migrationConfig.setApplyPrefix(applyPrefix);
+      }
+      if (header != null) {
+        migrationConfig.setDdlHeader(header);
+      }
+      if (includeGeneratedFileComment != null) {
+        migrationConfig.setIncludeGeneratedFileComment(includeGeneratedFileComment);
+      }
+      if (version != null) {
+        migrationConfig.setVersion(version);
+      }
+      if (name != null) {
+        migrationConfig.setName(name);
+      }
+      if (generatePendingDrop != null) {
+        migrationConfig.setGeneratePendingDrop(generatePendingDrop);
+      }
     }
   }
 
@@ -554,8 +624,12 @@ public class DefaultDbMigration implements DbMigration {
         return new OraclePlatform();
       case SQLANYWHERE:
         return new SqlAnywherePlatform();
+      case SQLSERVER16:
+        return new SqlServer16Platform();
+      case SQLSERVER17:
+        return new SqlServer17Platform();
       case SQLSERVER:
-        return new SqlServerPlatform();
+        throw new IllegalArgumentException("Please choose the more specific SQLSERVER16 or SQLSERVER17 platform. Refer to issue #1340 for details");
       case DB2:
         return new DB2Platform();
       case SQLITE:

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

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

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

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

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

@@ -0,0 +1,57 @@
+package io.ebeaninternal.dbmigration.ddlgeneration.platform;
+
+import io.ebean.config.dbplatform.DatabasePlatform;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
+
+/**
+ * CockroachDB specific DDL handling.
+ */
+public class CockroachDdl extends PlatformDdl {
+
+  public CockroachDdl(DatabasePlatform platform) {
+    super(platform);
+    this.historyDdl = new PostgresHistoryDdl();
+    this.dropTableCascade = " cascade";
+    this.columnSetType = "type ";
+    this.alterTableIfExists = "if exists ";
+    this.columnSetNull = "drop not null";
+  }
+
+  @Override
+  protected String convertArrayType(String logicalArrayType) {
+    return NativeDbArray.logicalToNative(logicalArrayType);
+  }
+
+  /**
+   * Map bigint, integer and smallint all into serial.
+   */
+  @Override
+  public String asIdentityColumn(String columnDefn) {
+
+    if ("bigint".equalsIgnoreCase(columnDefn)) {
+      return "serial";
+    }
+    if ("integer".equalsIgnoreCase(columnDefn)) {
+      return "serial";
+    }
+    if ("smallint".equalsIgnoreCase(columnDefn)) {
+      return "serial";
+    }
+    return columnDefn;
+  }
+
+  @Override
+  public void addTableComment(DdlBuffer apply, String tableName, String tableComment) {
+    // do nothing
+  }
+
+  @Override
+  public void addColumnComment(DdlBuffer apply, String table, String column, String comment) {
+    // do nothing
+  }
+
+  @Override
+  public boolean isInlineComments() {
+    return false;
+  }
+}

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

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

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

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

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

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

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

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

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

@@ -7,6 +7,7 @@ import io.ebeaninternal.dbmigration.migration.AlterColumn;
 import io.ebeaninternal.dbmigration.migration.Column;
 
 import java.io.IOException;
+import java.util.Collection;
 
 /**
  * MySql specific DDL.
@@ -26,7 +27,7 @@ public class MySqlDdl extends PlatformDdl {
    */
   @Override
   public String dropIndex(String indexName, String tableName) {
-    return "drop index " + indexName + " on " + tableName;
+    return "drop index " + maxConstraintName(indexName) + " on " + tableName;
   }
 
   /**
@@ -34,7 +35,7 @@ public class MySqlDdl extends PlatformDdl {
    */
   @Override
   public String alterTableDropForeignKey(String tableName, String fkName) {
-    return "alter table " + tableName + " drop foreign key " + fkName;
+    return "alter table " + tableName + " drop foreign key " + maxConstraintName(fkName);
   }
 
   @Override
@@ -113,10 +114,39 @@ public class MySqlDdl extends PlatformDdl {
     }
     apply.append(String.format("alter table %s comment = '%s'", tableName, tableComment)).endOfStatement();
   }
-  
+
   @Override
   public void addColumnComment(DdlBuffer apply, String table, String column, String comment) throws IOException {
     // alter comment currently not supported as it requires to repeat whole column definition
   }
-  
+
+
+  /**
+   * Locks all tables for triggers that have to be updated.
+   */
+  @Override
+  public void lockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
+    if (!tables.isEmpty()) {
+      buffer.append("lock tables ");
+      int i = 0;
+      for (String table : tables) {
+        if (i > 0) {
+          buffer.append(", ");
+        }
+        buffer.append(table).append(" write");
+        i++;
+      }
+      buffer.endOfStatement();
+
+    }
+  }
+
+  /**
+   * Unlocks all tables for triggers that have to be updated.
+   */
+  @Override
+  public void unlockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
+    buffer.append("unlock tables").endOfStatement();
+  }
+
 }

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

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

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

@@ -0,0 +1,20 @@
+package io.ebeaninternal.dbmigration.ddlgeneration.platform;
+
+/**
+ * Helper for logical type conversion.
+ */
+class NativeDbArray {
+
+  /**
+   * Covert the 'logical' array type to a native one (for Postgres and Cockroach).
+   */
+  static String logicalToNative(String logicalArrayType) {
+    int colonPos = logicalArrayType.lastIndexOf(']');
+    if (colonPos == -1) {
+      return logicalArrayType;
+    } else {
+      // trim of the fallback varchar length
+      return logicalArrayType.substring(0, colonPos + 1);
+    }
+  }
+}

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

@@ -13,16 +13,19 @@ import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlHandler;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
 import io.ebeaninternal.dbmigration.ddlgeneration.platform.util.PlatformTypeConverter;
+import io.ebeaninternal.dbmigration.ddlgeneration.platform.util.VowelRemover;
 import io.ebeaninternal.dbmigration.migration.AddHistoryTable;
 import io.ebeaninternal.dbmigration.migration.AlterColumn;
 import io.ebeaninternal.dbmigration.migration.Column;
 import io.ebeaninternal.dbmigration.migration.DropHistoryTable;
 import io.ebeaninternal.dbmigration.migration.IdentityType;
 import io.ebeaninternal.dbmigration.model.MTable;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -238,7 +241,7 @@ public class PlatformDdl {
    * Return the drop foreign key clause.
    */
   public String alterTableDropForeignKey(String tableName, String fkName) {
-    return "alter table " + alterTableIfExists + tableName + " " + dropConstraintIfExists + " " + fkName;
+    return "alter table " + alterTableIfExists + tableName + " " + dropConstraintIfExists + " " + maxConstraintName(fkName);
   }
 
   /**
@@ -326,7 +329,7 @@ public class PlatformDdl {
    * Return the drop index statement.
    */
   public String dropIndex(String indexName, String tableName) {
-    return dropIndexIfExists + indexName;
+    return dropIndexIfExists + maxConstraintName(indexName);
   }
 
   /**
@@ -335,7 +338,7 @@ public class PlatformDdl {
   public String createIndex(String indexName, String tableName, String[] columns) {
 
     StringBuilder buffer = new StringBuilder();
-    buffer.append("create index ").append(indexName).append(" on ").append(tableName);
+    buffer.append("create index ").append(maxConstraintName(indexName)).append(" on ").append(tableName);
     appendColumns(columns, buffer);
 
     return buffer.toString();
@@ -363,7 +366,7 @@ public class PlatformDdl {
     StringBuilder buffer = new StringBuilder(90);
     buffer
       .append("alter table ").append(lowerTableName(request.table()))
-      .append(" add constraint ").append(request.fkName())
+      .append(" add constraint ").append(maxConstraintName(request.fkName()))
       .append(" foreign key");
     appendColumns(request.cols(), buffer);
     buffer
@@ -410,14 +413,14 @@ public class PlatformDdl {
    * Drop a unique constraint from the table (Sometimes this is an index).
    */
   public String alterTableDropUniqueConstraint(String tableName, String uniqueConstraintName) {
-    return "alter table " + tableName + " " + dropUniqueConstraint + " " + uniqueConstraintName;
+    return "alter table " + tableName + " " + dropUniqueConstraint + " " + maxConstraintName(uniqueConstraintName);
   }
 
   /**
    * Drop a unique constraint from the table.
    */
   public String alterTableDropConstraint(String tableName, String constraintName) {
-    return "alter table " + tableName + " " + dropConstraint + " " + constraintName;
+    return "alter table " + tableName + " " + dropConstraint + " " + maxConstraintName(constraintName);
   }
 
   /**
@@ -428,7 +431,7 @@ public class PlatformDdl {
   public String alterTableAddUniqueConstraint(String tableName, String uqName, String[] columns, String[] nullableColumns) {
 
     StringBuilder buffer = new StringBuilder(90);
-    buffer.append("alter table ").append(tableName).append(" add constraint ").append(uqName).append(" unique ");
+    buffer.append("alter table ").append(tableName).append(" add constraint ").append(maxConstraintName(uqName)).append(" unique ");
     appendColumns(columns, buffer);
     return buffer.toString();
   }
@@ -441,13 +444,16 @@ public class PlatformDdl {
       .append(" ").append(addColumn).append(" ").append(column.getName())
       .append(" ").append(convertedType);
 
-    if (!onHistoryTable) {
 
-      if (defaultValue != null) {
+    // Add default value also to history table if it is not excluded
+    if (defaultValue != null) {
+      if (!onHistoryTable || !isTrue(column.isHistoryExclude())) {
         buffer.append(" default ");
         buffer.append(defaultValue);
       }
+    }
 
+    if (!onHistoryTable) {
       if (isTrue(column.isNotnull())) {
         buffer.append(" not null");
       }
@@ -455,7 +461,8 @@ public class PlatformDdl {
 
       // check constraints cannot be added in one statement for h2
       if (!StringHelper.isNull(column.getCheckConstraint())) {
-        String ddl = alterTableAddCheckConstraint(tableName, column.getCheckConstraintName(), column.getCheckConstraint());
+        String ddl = alterTableAddCheckConstraint(tableName, column.getCheckConstraintName(),
+            column.getCheckConstraint());
         buffer.append(ddl).endOfStatement();
       }
     } else {
@@ -506,7 +513,7 @@ public class PlatformDdl {
    */
   public String alterTableAddCheckConstraint(String tableName, String checkConstraintName, String checkConstraint) {
 
-    return "alter table " + tableName + " " + addConstraint + " " + checkConstraintName + " " + checkConstraint;
+    return "alter table " + tableName + " " + addConstraint + " " + maxConstraintName(checkConstraintName) + " " + checkConstraint;
   }
 
   /**
@@ -622,4 +629,36 @@ public class PlatformDdl {
 
   }
 
+  /**
+   * Shortens the given name to the maximum constraint name length of the platform in a deterministic way.
+   *
+   * First, all vowels are removed, If the string is still to long, 31 bits are taken from the hash code
+   * of the string and base36 encoded (10 digits and 26 chars) string.
+   *
+   * As 36^6 > 31^2, the resulting string is never longer as 6 chars.
+   */
+  protected String maxConstraintName(String name) {
+    if (name.length() > platform.getMaxConstraintNameLength()) {
+      int hash = name.hashCode() & 0x7FFFFFFF;
+      name = VowelRemover.trim(name, 4);
+      if (name.length() > platform.getMaxConstraintNameLength()) {
+        return name.substring(0, platform.getMaxConstraintNameLength()-7) + "_" + Integer.toString(hash, 36);
+      }
+    }
+    return name;
+  }
+
+  /**
+   * Mysql-specific: Locks all tables for triggers that have to be updated.
+   */
+  public void lockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
+
+  }
+
+  /**
+   * Mysql-specific: Unlocks all tables for triggers that have to be updated.
+   */
+  public void unlockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
+
+  }
 }

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

@@ -18,13 +18,7 @@ public class PostgresDdl extends PlatformDdl {
 
   @Override
   protected String convertArrayType(String logicalArrayType) {
-    int colonPos = logicalArrayType.lastIndexOf(']');
-    if (colonPos == -1) {
-      return logicalArrayType;
-    } else {
-      // trim of the fallback varchar length
-      return logicalArrayType.substring(0, colonPos + 1);
-    }
+    return NativeDbArray.logicalToNative(logicalArrayType);
   }
 
   /**

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

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

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

@@ -43,7 +43,7 @@ public class SqlServerDdl extends PlatformDdl {
   @Override
   public String alterTableDropForeignKey(String tableName, String fkName) {
     int pos = tableName.lastIndexOf('.');
-    String objectId = fkName;
+    String objectId = maxConstraintName(fkName);
     if (pos != -1) {
       objectId = tableName.substring(0, pos + 1) + fkName;
     }
@@ -57,7 +57,8 @@ public class SqlServerDdl extends PlatformDdl {
 
   @Override
   public String dropIndex(String indexName, String tableName) {
-    return "IF EXISTS (SELECT name FROM sys.indexes WHERE object_id = OBJECT_ID('" + tableName +"','U') AND name = '" + indexName + "') drop index " + indexName + " ON " + tableName;
+    return "IF EXISTS (SELECT name FROM sys.indexes WHERE object_id = OBJECT_ID('" + tableName + "','U') AND name = '"
+        + maxConstraintName(indexName) + "') drop index " + maxConstraintName(indexName) + " ON " + tableName;
   }
   /**
    * MsSqlServer specific null handling on unique constraints.
@@ -102,7 +103,7 @@ public class SqlServerDdl extends PlatformDdl {
   @Override
   public String alterTableDropUniqueConstraint(String tableName, String uniqueConstraintName) {
     StringBuilder sb = new StringBuilder();
-    sb.append("IF (OBJECT_ID('").append(uniqueConstraintName).append("', 'UQ') IS NOT NULL) ");
+    sb.append("IF (OBJECT_ID('").append(maxConstraintName(uniqueConstraintName)).append("', 'UQ') IS NOT NULL) ");
     sb.append(super.alterTableDropUniqueConstraint(tableName, uniqueConstraintName)).append(";\n");
     sb.append(dropIndex(uniqueConstraintName, tableName));
     return sb.toString();

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

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

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

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

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

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

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

@@ -113,7 +113,8 @@ public class CurrentModel {
     }
     ddl.append(write.apply().getBuffer());
     ddl.append(write.applyForeignKeys().getBuffer());
-    ddl.append(write.applyHistory().getBuffer());
+    ddl.append(write.applyHistoryView().getBuffer());
+    ddl.append(write.applyHistoryTrigger().getBuffer());
 
     return ddl.toString();
   }

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

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

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

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

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

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

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

@@ -4,13 +4,18 @@ import io.ebean.config.DbConstraintNaming;
 import io.ebean.config.dbplatform.DbPlatformType;
 import io.ebean.config.dbplatform.DbPlatformTypeMapping;
 import io.ebeaninternal.dbmigration.model.MColumn;
+import io.ebeaninternal.dbmigration.model.MCompoundForeignKey;
 import io.ebeaninternal.dbmigration.model.MTable;
 import io.ebeaninternal.dbmigration.model.ModelContainer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
+import io.ebeaninternal.server.deploy.TableJoin;
+import io.ebeaninternal.server.deploy.TableJoinColumn;
 import io.ebeaninternal.server.type.ScalarType;
 
 import java.util.Collection;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * The context used during DDL generation.
@@ -187,4 +192,49 @@ public class ModelBuildContext {
     addTable(draftTable);
   }
 
+  /**
+   * Return a builder to add foreign keys.
+   */
+  public FkeyBuilder fkeyBuilder(MTable destTable) {
+    return new FkeyBuilder(this, destTable);
+  }
+
+  public static class FkeyBuilder {
+
+    private final AtomicInteger count = new AtomicInteger();
+
+    private final ModelBuildContext ctx;
+
+    private final MTable destTable;
+
+    private final String tableName;
+
+    FkeyBuilder(ModelBuildContext ctx, MTable destTable) {
+      this.ctx = ctx;
+      this.destTable = destTable;
+      this.tableName = destTable.getName();
+    }
+
+    /**
+     * Add a foreign key based on the table join.
+     */
+    public FkeyBuilder addForeignKey(BeanDescriptor<?> desc, TableJoin tableJoin, boolean direction) {
+
+      String baseTable = ctx.normaliseTable(desc.getBaseTable());
+      String fkName = ctx.foreignKeyConstraintName(tableName, baseTable, count.incrementAndGet());
+      String fkIndex = ctx.foreignKeyIndexName(tableName, baseTable, count.get());
+
+      MCompoundForeignKey foreignKey = new MCompoundForeignKey(fkName, desc.getBaseTable(), fkIndex);
+
+      for (TableJoinColumn column : tableJoin.columns()) {
+        String localCol = direction ? column.getForeignDbColumn() : column.getLocalDbColumn();
+        String refCol = !direction ? column.getForeignDbColumn() : column.getLocalDbColumn();
+        foreignKey.addColumnPair(localCol, refCol);
+      }
+
+      destTable.addForeignKey(foreignKey);
+      return this;
+    }
+
+  }
 }

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

@@ -0,0 +1,34 @@
+package io.ebeaninternal.dbmigration.model.build;
+
+import io.ebeaninternal.dbmigration.model.MTable;
+import io.ebeaninternal.dbmigration.model.visitor.VisitAllUsing;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import io.ebeaninternal.server.deploy.BeanTable;
+
+/**
+ * Add the element collection table to the model.
+ */
+public class ModelBuildElementTable {
+
+  /**
+   * Build and add the MTable model for the ElementCollection property.
+   */
+  public static void build(ModelBuildContext ctx, BeanPropertyAssocMany<?> manyProp) {
+
+    BeanTable beanTable = manyProp.getBeanTable();
+
+    BeanDescriptor<?> targetDescriptor = manyProp.getTargetDescriptor();
+
+    MTable table = new MTable(beanTable.getBaseTable());
+
+    VisitAllUsing.visitOne(targetDescriptor, new ModelBuildPropertyVisitor(ctx, table, targetDescriptor));
+
+    ctx.fkeyBuilder(table)
+      .addForeignKey(manyProp.getBeanDescriptor(), manyProp.getTableJoin(), true);
+
+    ctx.addTable(table);
+  }
+
+
+}

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

@@ -1,18 +1,18 @@
 package io.ebeaninternal.dbmigration.model.build;
 
 import io.ebeaninternal.dbmigration.model.MColumn;
-import io.ebeaninternal.dbmigration.model.MCompoundForeignKey;
 import io.ebeaninternal.dbmigration.model.MTable;
 import io.ebeaninternal.server.deploy.BeanDescriptor;
 import io.ebeaninternal.server.deploy.BeanProperty;
 import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
+import io.ebeaninternal.server.deploy.PropertyForeignKey;
 import io.ebeaninternal.server.deploy.TableJoin;
 import io.ebeaninternal.server.deploy.TableJoinColumn;
 
 /**
  * Add the intersection table to the model.
  */
-public class ModelBuildIntersectionTable {
+class ModelBuildIntersectionTable {
 
   private final ModelBuildContext ctx;
 
@@ -22,9 +22,7 @@ public class ModelBuildIntersectionTable {
 
   private MTable intersectionTable;
 
-  private int countForeignKey;
-
-  public ModelBuildIntersectionTable(ModelBuildContext ctx, BeanPropertyAssocMany<?> manyProp) {
+  ModelBuildIntersectionTable(ModelBuildContext ctx, BeanPropertyAssocMany<?> manyProp) {
     this.ctx = ctx;
     this.manyProp = manyProp;
     this.intersectionTableJoin = manyProp.getIntersectionTableJoin();
@@ -51,31 +49,13 @@ public class ModelBuildIntersectionTable {
 
   private void buildFkConstraints() {
 
-    BeanDescriptor<?> localDesc = manyProp.getBeanDescriptor();
-    buildFkConstraints(localDesc, intersectionTableJoin.columns(), true);
-
-    BeanDescriptor<?> targetDesc = manyProp.getTargetDescriptor();
-    buildFkConstraints(targetDesc, tableJoin.columns(), false);
-
-    intersectionTable.checkDuplicateForeignKeys();
-  }
-
-
-  private void buildFkConstraints(BeanDescriptor<?> desc, TableJoinColumn[] columns, boolean direction) {
-
-    String tableName = intersectionTableJoin.getTable();
-    String baseTable = ctx.normaliseTable(desc.getBaseTable());
-    String fkName = ctx.foreignKeyConstraintName(tableName, baseTable, ++countForeignKey);
-    String fkIndex = ctx.foreignKeyIndexName(tableName, baseTable, countForeignKey);
-
-    MCompoundForeignKey foreignKey = new MCompoundForeignKey(fkName, desc.getBaseTable(), fkIndex);
-    intersectionTable.addForeignKey(foreignKey);
-
-    for (TableJoinColumn column : columns) {
-      String localCol = direction ? column.getForeignDbColumn() : column.getLocalDbColumn();
-      String refCol = !direction ? column.getForeignDbColumn() : column.getLocalDbColumn();
-      foreignKey.addColumnPair(localCol, refCol);
+    PropertyForeignKey foreignKey = manyProp.getForeignKey();
+    if (foreignKey == null || !foreignKey.isNoConstraint()) {
+      ctx.fkeyBuilder(intersectionTable)
+        .addForeignKey(manyProp.getBeanDescriptor(), intersectionTableJoin, true)
+        .addForeignKey(manyProp.getTargetDescriptor(), tableJoin, false);
     }
+    intersectionTable.checkDuplicateForeignKeys();
   }
 
   private MTable createTable() {

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

@@ -123,27 +123,24 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
 
   @Override
   public void visitMany(BeanPropertyAssocMany<?> p) {
-    if (p.hasJoinTable()) {
-      if (p.getMappedBy() == null) {
-        // only create on other 'owning' side
+    if (p.hasJoinTable() && p.getMappedBy() == null) {
+      // only create on other 'owning' side
 
-        //TableJoin intersectionTableJoin = p.getIntersectionTableJoin();
-        // check if the intersection table has already been created
-
-        // build the create table and fkey constraints
-        // putting the DDL into ctx for later output as we are
-        // in the middle of rendering the create table DDL
-        MTable intersectionTable = new ModelBuildIntersectionTable(ctx, p).build();
-        if (p.isO2mJoinTable()) {
-          intersectionTable.clearForeignKeyIndexes();
-          Collection<MColumn> cols = intersectionTable.allColumns();
-          if (cols.size() == 2) {
-            // always the second column that we put the unique constraint on
-            MColumn col = new ArrayList<>(cols).get(1);
-            col.setUnique(determineUniqueConstraintName(col.getName()));
-          }
+      // build the create table and fkey constraints
+      // putting the DDL into ctx for later output as we are
+      // in the middle of rendering the create table DDL
+      MTable intersectionTable = new ModelBuildIntersectionTable(ctx, p).build();
+      if (p.isO2mJoinTable()) {
+        intersectionTable.clearForeignKeyIndexes();
+        Collection<MColumn> cols = intersectionTable.allColumns();
+        if (cols.size() == 2) {
+          // always the second column that we put the unique constraint on
+          MColumn col = new ArrayList<>(cols).get(1);
+          col.setUnique(determineUniqueConstraintName(col.getName()));
         }
       }
+    } else if (p.isElementCollection()) {
+      ModelBuildElementTable.build(ctx, p);
     }
   }
 

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

@@ -16,6 +16,14 @@ import java.util.List;
  */
 public class VisitAllUsing {
 
+  /**
+   * Visit a single Descriptor using the given visitor.
+   */
+  public static void visitOne(BeanDescriptor<?> descriptor, BeanPropertyVisitor visitor) {
+
+    new VisitAllUsing().visitProperties(descriptor, visitor);
+  }
+
   protected final BeanVisitor visitor;
 
   protected final List<BeanDescriptor<?>> descriptors;
@@ -36,6 +44,11 @@ public class VisitAllUsing {
     this.descriptors = descriptors;
   }
 
+  private VisitAllUsing() {
+    this.visitor = null;
+    this.descriptors = null;
+  }
+
   public void visitAllBeans() {
     for (BeanDescriptor<?> desc : descriptors) {
       if (desc.isBaseTable()) {
@@ -51,29 +64,32 @@ public class VisitAllUsing {
 
     BeanPropertyVisitor propertyVisitor = visitor.visitBean(desc);
     if (propertyVisitor != null) {
-
-      BeanProperty idProp = desc.getIdProperty();
-      if (idProp != null) {
-        visit(propertyVisitor, idProp);
-      }
-
-      BeanPropertyAssocOne<?> unidirectional = desc.getUnidirectional();
-      if (unidirectional != null) {
-        visit(propertyVisitor, unidirectional);
-      }
-
-      BeanProperty[] propertiesNonTransient = desc.propertiesNonTransient();
-      for (BeanProperty p : propertiesNonTransient) {
-        if (p.isDDLColumn()) {
-          visit(propertyVisitor, p);
-        }
-      }
-
-      visitInheritanceProperties(desc, propertyVisitor);
-      propertyVisitor.visitEnd();
+      visitProperties(desc, propertyVisitor);
     }
   }
 
+  private void visitProperties(BeanDescriptor<?> desc, BeanPropertyVisitor propertyVisitor) {
+    BeanProperty idProp = desc.getIdProperty();
+    if (idProp != null) {
+      visit(propertyVisitor, idProp);
+    }
+
+    BeanPropertyAssocOne<?> unidirectional = desc.getUnidirectional();
+    if (unidirectional != null) {
+      visit(propertyVisitor, unidirectional);
+    }
+
+    BeanProperty[] propertiesNonTransient = desc.propertiesNonTransient();
+    for (BeanProperty p : propertiesNonTransient) {
+      if (p.isDDLColumn()) {
+        visit(propertyVisitor, p);
+      }
+    }
+
+    visitInheritanceProperties(desc, propertyVisitor);
+    propertyVisitor.visitEnd();
+  }
+
   /**
    * Visit the property.
    */

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

@@ -1,5 +1,6 @@
 package io.ebeaninternal.extraddl.model;
 
+import io.ebean.annotation.Platform;
 import io.ebean.util.StringHelper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -7,6 +8,7 @@ import org.slf4j.LoggerFactory;
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
+import java.io.IOException;
 import java.io.InputStream;
 
 /**
@@ -16,6 +18,8 @@ public class ExtraDdlXmlReader {
 
   private static final Logger logger = LoggerFactory.getLogger(ExtraDdlXmlReader.class);
 
+  private static final String SQLSERVER = Platform.SQLSERVER.name().toLowerCase();
+
   /**
    * Return the combined extra DDL that should be run given the platform name.
    */
@@ -52,25 +56,47 @@ public class ExtraDdlXmlReader {
       return true;
     }
 
+    String genericMatch = genericPlatformMatch(platformName);
+
     for (String name : StringHelper.splitNames(platforms)) {
       if (name.toLowerCase().contains(platformName)) {
         return true;
+      } else if (genericMatch != null && genericMatch.equals(name.toLowerCase())) {
+        // allow sqlserver ... to match sqlserver17 and sqlserver16 platforms
+        return true;
       }
     }
     return false;
   }
 
+  /**
+   * Return a "generic" platform name that can be used. e.g. sqlserver17 -> sqlserver.
+   */
+  private static String genericPlatformMatch(String platformName) {
+    switch (platformName) {
+      case "sqlserver17":
+        return SQLSERVER;
+      case "sqlserver16":
+        return SQLSERVER;
+      default:
+        return null;
+    }
+  }
+
   /**
    * Read and return a ExtraDdl from an xml document at the given resource path.
    */
   public static ExtraDdl read(String resourcePath) {
 
-    InputStream is = ExtraDdlXmlReader.class.getResourceAsStream(resourcePath);
-    if (is == null) {
-      // we expect this and check for null
-      return null;
+    try (InputStream is = ExtraDdlXmlReader.class.getResourceAsStream(resourcePath)) {
+      if (is == null) {
+        // we expect this and check for null
+        return null;
+      }
+      return read(is);
+    } catch (IOException e) {
+      throw new IllegalStateException("Error on auto close of " + resourcePath, e);
     }
-    return read(is);
   }
 
   /**

src/main/java/io/ebeaninternal/metric/MetricFactory.java

@@ -1,5 +1,7 @@
 package io.ebeaninternal.metric;
 
+import io.ebean.meta.MetricType;
+
 /**
  * Factory to create timed metric counters.
  */
@@ -15,20 +17,16 @@ public interface MetricFactory {
   /**
    * Create a timed metric group.
    */
-  TimedMetricMap createTimedMetricMap(String name);
+  TimedMetricMap createTimedMetricMap(MetricType metricType, String name);
 
   /**
    * Create a Timed metric.
    */
-  TimedMetric createTimedMetric(String name);
+  TimedMetric createTimedMetric(MetricType metricType, String name);
 
   /**
    * Create a Timed metric.
    */
-  QueryPlanMetric createQueryPlanMetric(Class<?> type, String label, String sql);
+  QueryPlanMetric createQueryPlanMetric(MetricType metricType, Class<?> type, String label, String sql);
 
-  /**
-   * Return a instance used to collect Query plan metrics.
-   */
-  QueryPlanCollector createCollector(boolean reset);
 }