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

Bump ebean-types to 1.3 with of() helper methods

README.md

@@ -1,8 +1,11 @@
+[![Build Status](https://travis-ci.org/ebean-orm/ebean.svg?branch=master)](https://travis-ci.org/ebean-orm/ebean)
+[![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)
+
 # Need help?
 Post questions or issues to the Ebean google group - https://groups.google.com/forum/#!forum/ebean
 
 # Documentation
-Goto [https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Website")
+Goto [https://ebean.io/docs/](https://ebean.io/docs/)
 
 
 ## Maven cental links:
@@ -10,8 +13,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/io.ebean/ebean) - ebean
+## Other versions
 * [![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,7 +9,7 @@
 
   <groupId>io.ebean</groupId>
   <artifactId>ebean</artifactId>
-  <version>11.27.1</version>
+  <version>11.35.1</version>
   <packaging>jar</packaging>
 
   <name>ebean</name>
@@ -22,7 +22,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-11.27.1</tag>
+    <tag>ebean-11.35.1</tag>
   </scm>
 
   <profiles>
@@ -117,13 +117,19 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>4.3</version>
+      <version>4.5</version>
+    </dependency>
+
+    <dependency>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-types</artifactId>
+      <version>1.3</version>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-datasource</artifactId>
-      <version>4.2.2</version>
+      <version>4.5.1</version>
     </dependency>
 
     <dependency>
@@ -135,13 +141,13 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-migration</artifactId>
-      <version>11.11.1</version>
+      <version>11.14.1</version>
     </dependency>
 
     <dependency>
       <groupId>org.antlr</groupId>
       <artifactId>antlr4-runtime</artifactId>
-      <version>4.7.1</version>
+      <version>4.7.2</version>
     </dependency>
 
     <!-- Jackson core used internally by Ebean -->
@@ -188,6 +194,21 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- Provided scope to compile with java 11 -->
+    <dependency>
+      <groupId>org.glassfish.jaxb</groupId>
+      <artifactId>jaxb-runtime</artifactId>
+      <version>2.4.0-b180830.0438</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.annotation</groupId>
+      <artifactId>javax.annotation-api</artifactId>
+      <version>1.3.2</version>
+      <scope>provided</scope>
+    </dependency>
+
     <!-- Provided scope for Postgres JSON/JSONB support -->
     <dependency>
       <groupId>org.postgresql</groupId>
@@ -222,14 +243,14 @@
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-agentloader</artifactId>
-      <version>2.1.2</version>
+      <version>3.0.1</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-agent</artifactId>
-      <version>11.25.1</version>
+      <version>11.27.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -238,7 +259,7 @@
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.4.196</version>
+      <version>1.4.197</version>
       <scope>provided</scope>
     </dependency>
 
@@ -259,7 +280,7 @@
     <dependency>
       <groupId>com.microsoft.sqlserver</groupId>
       <artifactId>mssql-jdbc</artifactId>
-      <version>6.4.0.jre8</version>
+      <version>7.2.0.jre8</version>
       <scope>test</scope>
     </dependency>
 
@@ -309,7 +330,7 @@
       <plugin>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-maven-plugin</artifactId>
-        <version>11.25.1</version>
+        <version>11.27.1</version>
         <executions>
           <execution>
             <id>test</id>
@@ -327,9 +348,10 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-surefire-plugin</artifactId>
-        <version>2.5</version>
+        <version>2.22.1</version>
         <configuration>
           <useSystemClassLoader>false</useSystemClassLoader>
+          <trimStackTrace>false</trimStackTrace>
           <failIfNoTests>false</failIfNoTests>
           <includes>
             <include>**/Test*.java</include>

src/main/java/io/ebean/BackgroundExecutor.java

@@ -1,6 +1,8 @@
 package io.ebean;
 
+import java.util.concurrent.Callable;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -37,4 +39,21 @@ public interface BackgroundExecutor {
    * </p>
    */
   void executePeriodically(Runnable r, long delay, TimeUnit unit);
+
+  /**
+   * Schedules a Runnable for one-shot action that becomes enabled after the given delay.
+   *
+   * @return a ScheduledFuture representing pending completion of the task and
+   *         whose get() method will return null upon completion
+   */
+  ScheduledFuture<?> schedule(Runnable r, long delay, TimeUnit unit);
+
+  /**
+   * Schedules a Callable for one-shot action that becomes enabled after the given delay.
+   *
+   * @return a ScheduledFuture that can be used to extract result or cancel
+   */
+  <V> ScheduledFuture<V> schedule(Callable<V> c, long delay, TimeUnit unit);
+
+
 }

src/main/java/io/ebean/BeanState.java

@@ -3,6 +3,8 @@ package io.ebean;
 import java.util.Map;
 import java.util.Set;
 
+import javax.annotation.Nullable;
+
 /**
  * Provides access to the internal state of an entity bean.
  */
@@ -111,4 +113,10 @@ public interface BeanState {
    * Reset the bean putting it into NEW state such that a save() results in an insert.
    */
   void resetForInsert();
+
+  /**
+   * Returns a map with load erros.
+   */
+  @Nullable
+  Map<String, Exception> getLoadErrors();
 }

src/main/java/io/ebean/DatabaseFactory.java

@@ -0,0 +1,67 @@
+package io.ebean;
+
+import io.ebean.config.ContainerConfig;
+import io.ebean.config.DatabaseConfig;
+
+/**
+ * Creates Database instances.
+ * <p>
+ * This uses either DatabaseConfig or properties in the application.properties file to
+ * configure and create a Database instance.
+ * </p>
+ * <p>
+ * The Database instance can either be registered with the DB singleton or
+ * not. The DB singleton effectively holds a map of Database by a name.
+ * If the Database is registered with the DB singleton you can retrieve it
+ * later via {@link DB#byName(String)}.
+ * </p>
+ * <p>
+ * One Database can be nominated as the 'default/primary' Database. Many
+ * methods on the DB singleton such as {@link DB#find(Class)} are just a
+ * convenient way of using the 'default/primary' Database.
+ * </p>
+ */
+public class DatabaseFactory {
+
+  /**
+   * Initialise the container with clustering configuration.
+   * <p>
+   * Call this prior to creating any Database instances or alternatively set the
+   * ContainerConfig on the ServerConfig when creating the first Database instance.
+   */
+  public static synchronized void initialiseContainer(ContainerConfig containerConfig) {
+    EbeanServerFactory.initialiseContainer(containerConfig);
+  }
+
+  /**
+   * Create using ebean.properties to configure the server.
+   */
+  public static synchronized Database create(String name) {
+    return EbeanServerFactory.create(name);
+  }
+
+  /**
+   * Create using the ServerConfig object to configure the server.
+   */
+  public static synchronized Database create(DatabaseConfig config) {
+    return EbeanServerFactory.create(config);
+  }
+
+  /**
+   * Create using the ServerConfig additionally specifying a classLoader to use as the context class loader.
+   */
+  public static synchronized Database createWithContextClassLoader(DatabaseConfig config, ClassLoader classLoader) {
+    return EbeanServerFactory.createWithContextClassLoader(config, classLoader);
+  }
+
+  /**
+   * Shutdown gracefully all EbeanServers cleaning up any resources as required.
+   * <p>
+   * This is typically invoked via JVM shutdown hook and not explicitly called.
+   * </p>
+   */
+  public static synchronized void shutdown() {
+    EbeanServerFactory.shutdown();
+  }
+
+}

src/main/java/io/ebean/DtoQuery.java

@@ -30,7 +30,7 @@ import java.util.function.Predicate;
  *   String sql = "select id, name from customer where name like :name and status_code = :status";
  *
  *   List<CustomerDto> beans =
- *     Ebean.findDto(CustomrDto.class, sql)
+ *     Ebean.findDto(CustomerDto.class, sql)
  *     .setParameter("name", "Acme%")
  *     .setParameter("status", "ACTIVE")
  *     .findList();

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

@@ -120,7 +120,7 @@ public final class Ebean {
   private static final Logger logger = LoggerFactory.getLogger(Ebean.class);
 
   static {
-    EbeanVersion.getVersion(); // initalizes the version class and logs the version.
+    EbeanVersion.getVersion(); // initialises the version class and logs the version.
   }
 
   /**

src/main/java/io/ebean/Expr.java

@@ -64,11 +64,20 @@ public class Expr {
     return Ebean.getExpressionFactory().ieq(propertyName, value);
   }
 
+  /**
+   * In Range - property >= value1 and property < value2.
+   * <p>
+   * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
+   * </p>
+   */
+  public static Expression inRange(String propertyName, Object value1, Object value2) {
+    return Ebean.getExpressionFactory().inRange(propertyName, value1, value2);
+  }
+
   /**
    * Between - property between the two given values.
    */
   public static Expression between(String propertyName, Object value1, Object value2) {
-
     return Ebean.getExpressionFactory().between(propertyName, value1, value2);
   }
 
@@ -76,7 +85,6 @@ public class Expr {
    * Between - value between two given properties.
    */
   public static Expression between(String lowProperty, String highProperty, Object value) {
-
     return Ebean.getExpressionFactory().betweenProperties(lowProperty, highProperty, value);
   }
 

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

@@ -122,6 +122,11 @@ public interface ExpressionFactory {
    */
   Expression eq(String propertyName, Object value);
 
+  /**
+   * Equal To or Null - property equal to the given value or null.
+   */
+  Expression eqOrNull(String propertyName, Object value);
+
   /**
    * Not Equal To - property not equal to the given value.
    */
@@ -149,6 +154,33 @@ public interface ExpressionFactory {
    */
   Expression ineObject(String propertyName, Object value);
 
+  /**
+   * In Range - property >= value1 and property < value2.
+   * <p>
+   * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
+   * </p>
+   */
+  Expression inRange(String propertyName, Object value1, Object value2);
+
+  /**
+   * Value in Range between 2 properties.
+   *
+   * <pre>{@code
+   *
+   *    .startDate.inRangeWith(endDate, now)
+   *
+   *    // which equates to
+   *    startDate <= now and (endDate > now or endDate is null)
+   *
+   * }</pre>
+   *
+   * <p>
+   * This is a convenience expression combining a number of simple expressions.
+   * The most common use of this could be called "effective dating" where 2 date or
+   * timestamp columns represent the date range in which
+   */
+  Expression inRangeWith(String lowProperty, String highProperty, Object value);
+
   /**
    * Between - property between the two given values.
    */
@@ -159,6 +191,14 @@ public interface ExpressionFactory {
    */
   Expression betweenProperties(String lowProperty, String highProperty, Object value);
 
+  /**
+   * Greater Than Or Null - property greater than the given value or null.
+   * <p>
+   * A convenient expression combining GT and Is Null.  Most often useful for range
+   * expressions where the top range value is nullable.
+   */
+  Expression gtOrNull(String propertyName, Object value);
+
   /**
    * Greater Than - property greater than the given value.
    */
@@ -170,6 +210,14 @@ public interface ExpressionFactory {
    */
   Expression ge(String propertyName, Object value);
 
+  /**
+   * Less Than or Null - property less than the given value or null.
+   * <p>
+   * A convenient expression combining LT and Is Null.  Most often useful for range
+   * expressions where the bottom range value is nullable.
+   */
+  Expression ltOrNull(String propertyName, Object value);
+
   /**
    * Less Than - property less than the given value.
    */

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

@@ -128,6 +128,38 @@ public interface ExpressionList<T> {
    */
   <D> DtoQuery<D> asDto(Class<D> dtoClass);
 
+  /**
+   * Return the underlying query as an UpdateQuery.
+   * <p>
+   * Typically this is used with query beans to covert a query bean
+   * query into an UpdateQuery like the examples below.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  int rowsUpdated = new QCustomer()
+   *       .name.startsWith("Rob")
+   *       .asUpdate()
+   *       .set("active", false)
+   *       .update();;
+   *
+   * }</pre>
+   *
+   * <pre>{@code
+   *
+   *   int rowsUpdated = new QContact()
+   *       .notes.note.startsWith("Make Inactive")
+   *       .email.endsWith("@foo.com")
+   *       .customer.id.equalTo(42)
+   *       .asUpdate()
+   *       .set("inactive", true)
+   *       .setRaw("email = lower(email)")
+   *       .update();
+   *
+   * }</pre>
+   */
+  UpdateQuery<T> asUpdate();
+
   /**
    * Execute using "for update" clause which results in the DB locking the record.
    */
@@ -194,6 +226,32 @@ public interface ExpressionList<T> {
    */
   int update(Transaction transaction);
 
+  /**
+   * Execute the query returning true if a row is found.
+   * <p>
+   * The query is executed using max rows of 1 and will only select the id property.
+   * This method is really just a convenient way to optimise a query to perform a
+   * 'does a row exist in the db' check.
+   * </p>
+   *
+   * <h2>Example:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = query().where().eq("email", "rob@foo.com").exists();
+   *
+   * }</pre>
+   *
+   * <h2>Example using a query bean:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = new QContact().email.equalTo("rob@foo.com").exists();
+   *
+   * }</pre>
+   *
+   * @return True if the query finds a matching row in the database
+   */
+  boolean exists();
+
   /**
    * Execute the query iterating over the results.
    *
@@ -258,7 +316,7 @@ public interface ExpressionList<T> {
 
   /**
    * Execute the query returning a list of values for a single property.
-   * <p>
+   *
    * <h3>Example 1:</h3>
    * <pre>{@code
    *
@@ -269,7 +327,7 @@ public interface ExpressionList<T> {
    *      .findSingleAttributeList();
    *
    * }</pre>
-   * <p>
+   *
    * <h3>Example 2:</h3>
    * <pre>{@code
    *
@@ -291,7 +349,6 @@ public interface ExpressionList<T> {
 
   /**
    * Execute a query returning a single value of a single property/column.
-   * <p>
    * <pre>{@code
    *
    *  String name =
@@ -376,7 +433,6 @@ public interface ExpressionList<T> {
    * If maxRows is not set on the query prior to calling findPagedList() then a
    * PersistenceException is thrown.
    * </p>
-   * <p>
    * <pre>{@code
    *
    *  PagedList<Order> pagedList = Ebean.find(Order.class)
@@ -515,7 +571,6 @@ public interface ExpressionList<T> {
 
   /**
    * Extended version for setDistinct in conjunction with "findSingleAttributeList";
-   * <p>
    * <pre>{@code
    *
    *  List<CountedValue<Order.Status>> orderStatusCount =
@@ -625,7 +680,6 @@ public interface ExpressionList<T> {
 
   /**
    * Equal to expression for the value at the given path in the JSON document.
-   * <p>
    * <pre>{@code
    *
    *   where().jsonEqualTo("content", "path.other", 34)
@@ -640,7 +694,6 @@ public interface ExpressionList<T> {
 
   /**
    * Not Equal to - for the given path in a JSON document.
-   * <p>
    * <pre>{@code
    *
    *   where().jsonNotEqualTo("content", "path.other", 34)
@@ -655,7 +708,6 @@ public interface ExpressionList<T> {
 
   /**
    * Greater than - for the given path in a JSON document.
-   * <p>
    * <pre>{@code
    *
    *   where().jsonGreaterThan("content", "path.other", 34)
@@ -666,7 +718,6 @@ public interface ExpressionList<T> {
 
   /**
    * Greater than or equal to - for the given path in a JSON document.
-   * <p>
    * <pre>{@code
    *
    *   where().jsonGreaterOrEqual("content", "path.other", 34)
@@ -677,7 +728,6 @@ public interface ExpressionList<T> {
 
   /**
    * Less than - for the given path in a JSON document.
-   * <p>
    * <pre>{@code
    *
    *   where().jsonLessThan("content", "path.other", 34)
@@ -688,7 +738,6 @@ public interface ExpressionList<T> {
 
   /**
    * Less than or equal to - for the given path in a JSON document.
-   * <p>
    * <pre>{@code
    *
    *   where().jsonLessOrEqualTo("content", "path.other", 34)
@@ -699,7 +748,6 @@ public interface ExpressionList<T> {
 
   /**
    * Between - for the given path in a JSON document.
-   * <p>
    * <pre>{@code
    *
    *   where().jsonBetween("content", "orderDate", lowerDateTime, upperDateTime)
@@ -713,7 +761,6 @@ public interface ExpressionList<T> {
    * <p>
    * This returns the list so that add() can be chained.
    * </p>
-   * <p>
    * <pre>{@code
    *
    * Query<Customer> query = Ebean.find(Customer.class);
@@ -738,6 +785,11 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> eq(String propertyName, Object value);
 
+  /**
+   * Equal To or Null - property is equal to a given value or null.
+   */
+  ExpressionList<T> eqOrNull(String propertyName, Object value);
+
   /**
    * Not Equal To - property not equal to the given value.
    */
@@ -756,8 +808,35 @@ public interface ExpressionList<T> {
   ExpressionList<T> ine(String propertyName, String value);
 
   /**
-   * Between - property between the two given values.
+   * Value in Range between 2 properties.
+   *
+   * <pre>{@code
+   *
+   *    .startDate.inRangeWith(endDate, now)
+   *
+   *    // which equates to
+   *    startDate <= now and (endDate > now or endDate is null)
+   *
+   * }</pre>
+   *
+   * <p>
+   * This is a convenience expression combining a number of simple expressions.
+   * The most common use of this could be called "effective dating" where 2 date or
+   * timestamp columns represent the date range in which
    */
+  ExpressionList<T> inRangeWith(String lowProperty, String highProperty, Object value);
+
+  /**
+   * In Range - property >= value1 and property < value2.
+   * <p>
+   * Unlike Between inRange is "half open" and usually more useful for use with dates or timestamps.
+   * </p>
+   */
+  ExpressionList<T> inRange(String propertyName, Object value1, Object value2);
+
+    /**
+     * Between - property between the two given values.
+     */
   ExpressionList<T> between(String propertyName, Object value1, Object value2);
 
   /**
@@ -770,6 +849,11 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> gt(String propertyName, Object value);
 
+  /**
+   * Greater Than or Null - property greater than the given value or null.
+   */
+  ExpressionList<T> gtOrNull(String propertyName, Object value);
+
   /**
    * Greater Than or Equal to - property greater than or equal to the given
    * value.
@@ -781,6 +865,11 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> lt(String propertyName, Object value);
 
+  /**
+   * Less Than or Null - property less than the given value or null.
+   */
+  ExpressionList<T> ltOrNull(String propertyName, Object value);
+
   /**
    * Less Than or Equal to - property less than or equal to the given value.
    */
@@ -810,7 +899,6 @@ public interface ExpressionList<T> {
    * To get control over the options you can create an ExampleExpression and set
    * those options such as case insensitive etc.
    * </p>
-   * <p>
    * <pre>{@code
    *
    * // create an example bean and set the properties
@@ -819,7 +907,7 @@ public interface ExpressionList<T> {
    * example.setName("Rob%");
    * example.setNotes("%something%");
    *
-   * List&lt;Customer&gt; list = Ebean.find(Customer.class).where()
+   * List<Customer> list = Ebean.find(Customer.class).where()
    *     // pass the bean into the where() clause
    *     .exampleLike(example)
    *     // you can add other expressions to the same query
@@ -828,7 +916,7 @@ public interface ExpressionList<T> {
    * }</pre>
    * <p>
    * Similarly you can create an ExampleExpression
-   * <p>
+   * </p>
    * <pre>{@code
    *
    * Customer example = new Customer();
@@ -1050,7 +1138,6 @@ public interface ExpressionList<T> {
 
   /**
    * Add expression for ALL of the given bit flags to be set.
-   * <p>
    * <pre>{@code
    *
    * where().bitwiseAll("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
@@ -1064,7 +1151,6 @@ public interface ExpressionList<T> {
 
   /**
    * Add expression for the given bit flags to be NOT set.
-   * <p>
    * <pre>{@code
    *
    * where().bitwiseNot("flags", BwFlags.HAS_COLOUR)
@@ -1115,6 +1201,13 @@ public interface ExpressionList<T> {
    *   raw("add_days(orderDate, 10) < ?", someDate)
    *
    * }</pre>
+   *
+   * <h4>Subquery example:</h4>
+   * <pre>{@code
+   *
+   *   .raw("t0.customer_id in (select customer_id from customer_group where group_id = any(?::uuid[]))", groupIds)
+   *
+   * }</pre>
    */
   ExpressionList<T> raw(String raw, Object value);
 
@@ -1139,12 +1232,18 @@ public interface ExpressionList<T> {
    * then they are not translated. logical property name names (not fully
    * qualified) will still be translated to their physical name.
    * </p>
-   * <p>
    * <pre>{@code
    *
    *   raw("orderQty < shipQty")
    *
    * }</pre>
+   *
+   * <h4>Subquery example:</h4>
+   * <pre>{@code
+   *
+   *   .raw("t0.customer_id in (select customer_id from customer_group where group_id = any(?::uuid[]))", groupIds)
+   *
+   * }</pre>
    */
   ExpressionList<T> raw(String raw);
 
@@ -1218,12 +1317,10 @@ public interface ExpressionList<T> {
    * typically you only explicitly need to use the and() junction
    * when it is nested inside an or() or not() junction.
    * </p>
-   * <p>
    * <pre>{@code
    *
    *  // Example: Nested and()
    *
-   *  Ebean.find(Customer.class)
    *    .where()
    *    .or()
    *      .and() // nested and
@@ -1244,16 +1341,27 @@ public interface ExpressionList<T> {
    * Return a list of expressions that will be joined by OR's.
    * This is exactly the same as disjunction();
    * <p>
-   * <p>
    * Use endOr() or endJunction() to end the OR junction.
    * </p>
-   * <p>
+   *
+   * <pre>{@code
+   *
+   *  // Example: (status active OR anniversary is null)
+   *
+   *    .where()
+   *    .or()
+   *      .eq("status", Customer.Status.ACTIVE)
+   *      .isNull("anniversary")
+   *    .orderBy().asc("name")
+   *    .findList();
+   *
+   * }</pre>
+   *
    * <pre>{@code
    *
    *  // Example: Use or() to join
    *  // two nested and() expressions
    *
-   *  Ebean.find(Customer.class)
    *    .where()
    *    .or()
    *      .and()
@@ -1277,8 +1385,8 @@ public interface ExpressionList<T> {
    * Use endNot() or endJunction() to end expressions being added to the
    * NOT expression list.
    * </p>
-   * <p>
-   * <pre>@{code
+   *
+   * <pre>{@code
    *
    *    .where()
    *      .not()
@@ -1287,12 +1395,11 @@ public interface ExpressionList<T> {
    *        .endNot()
    *
    * }</pre>
-   * <p>
-   * <pre>@{code
+   *
+   * <pre>{@code
    *
    * // Example: nested not()
    *
-   * Ebean.find(Customer.class)
    *   .where()
    *     .eq("status", Customer.Status.ACTIVE)
    *     .not()

src/main/java/io/ebean/ExtendedServer.java

@@ -1,5 +1,8 @@
 package io.ebean;
 
+import io.ebeaninternal.api.SpiQuery;
+import io.ebeaninternal.api.SpiTransaction;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import javax.persistence.NonUniqueResultException;
@@ -42,6 +45,32 @@ public interface ExtendedServer {
    */
   void setClock(Clock clock);
 
+  /**
+   * Execute the query returning true if a row is found.
+   * <p>
+   * The query is executed using max rows of 1 and will only select the id property.
+   * This method is really just a convenient way to optimise a query to perform a
+   * 'does a row exist in the db' check.
+   * </p>
+   *
+   * <h2>Example:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = query().where().eq("email", "rob@foo.com").exists();
+   *
+   * }</pre>
+   *
+   * <h2>Example using a query bean:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = new QContact().email.equalTo("rob@foo.com").exists();
+   *
+   * }</pre>
+   *
+   * @return True if the query finds a matching row in the database
+   */
+  <T> boolean exists(SpiQuery<?> ormQuery, SpiTransaction transaction);
+
   /**
    * Return the number of 'top level' or 'root' entities this query should return.
    *

src/main/java/io/ebean/Finder.java

@@ -2,7 +2,6 @@ package io.ebean;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-
 import java.util.List;
 
 /**
@@ -112,26 +111,26 @@ public class Finder<I, T> {
    * <p>
    * This provides full access to the API such as explicit transaction demarcation etc.
    */
-  public EbeanServer db() {
-    return Ebean.getServer(serverName);
+  public Database db() {
+    return DB.byName(serverName);
   }
 
   /**
-   * Return typically a different EbeanServer to the default.
+   * Return typically a different Database to the default.
    * <p>
-   * This is equivalent to {@link Ebean#getServer(String)}
+   * This is equivalent to {@link DB#byName(String)}
    *
-   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is
+   * @param server The name of the Database. If this is null then the default EbeanServer is
    *               returned.
    */
-  public EbeanServer db(String server) {
-    return Ebean.getServer(server);
+  public Database db(String server) {
+    return DB.byName(server);
   }
 
   /**
    * Creates an entity reference for this ID.
    * <p>
-   * Equivalent to {@link EbeanServer#getReference(Class, Object)}
+   * Equivalent to {@link Database#getReference(Class, Object)}
    */
   @Nonnull
   public T ref(I id) {
@@ -141,7 +140,7 @@ public class Finder<I, T> {
   /**
    * Retrieves an entity by ID.
    * <p>
-   * Equivalent to {@link EbeanServer#find(Class, Object)}
+   * Equivalent to {@link Database#find(Class, Object)}
    */
   @Nullable
   public T byId(I id) {
@@ -151,7 +150,7 @@ public class Finder<I, T> {
   /**
    * Delete a bean by Id.
    * <p>
-   * Equivalent to {@link EbeanServer#delete(Class, Object)}
+   * Equivalent to {@link Database#delete(Class, Object)}
    */
   public void deleteById(I id) {
     db().delete(type, id);
@@ -181,7 +180,7 @@ public class Finder<I, T> {
    * }</pre>
    *
    * <p>
-   * Equivalent to {@link EbeanServer#update(Class)}
+   * Equivalent to {@link Database#update(Class)}
    */
   public UpdateQuery<T> update() {
     return db().update(type);
@@ -190,7 +189,7 @@ public class Finder<I, T> {
   /**
    * Creates a query.
    * <p>
-   * Equivalent to {@link EbeanServer#find(Class)}
+   * Equivalent to {@link Database#find(Class)}
    */
   public Query<T> query() {
     return db().find(type);

src/main/java/io/ebean/Model.java

@@ -76,15 +76,14 @@ import io.ebean.bean.EntityBean;
 public abstract class Model {
 
   /**
-   * Return the underlying 'default' EbeanServer.
+   * Return the underlying 'default' Database.
    * <p>
    * This provides full access to the API such as explicit transaction demarcation etc.
    * <p>
    * Example:
    * <pre>{@code
    *
-   * Transaction transaction = Customer.db().beginTransaction();
-   * try {
+   * try (Transaction transaction = Customer.db().beginTransaction()) {
    *
    *   // turn off cascade persist for this transaction
    *   transaction.setPersistCascade(false);
@@ -104,26 +103,21 @@ public abstract class Model {
    *
    *   transaction.commit();
    *
-   * } finally {
-   *   transaction.end();
    * }
    *
    * }</pre>
    */
-  public static EbeanServer db() {
-    return Ebean.getDefaultServer();
+  public static Database db() {
+    return DB.getDefault();
   }
 
   /**
-   * Return a named EbeanServer that is typically different to the default server.
-   * <p>
-   * If you are using multiple databases then each database has a name and maps to a single
-   * EbeanServer. You can use this method to get an EbeanServer for another database.
+   * Return a named Database that is typically different to the default database.
    *
-   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is returned.
+   * @param server The name of the Database. If this is null then the default Database is returned.
    */
-  public static EbeanServer db(String server) {
-    return Ebean.getServer(server);
+  public static Database db(String server) {
+    return DB.byName(server);
   }
 
   /**
@@ -146,7 +140,7 @@ public abstract class Model {
    *
    * }</pre>
    *
-   * @see EbeanServer#markAsDirty(Object)
+   * @see Database#markAsDirty(Object)
    */
   public void markAsDirty() {
     db().markAsDirty(this);
@@ -182,7 +176,7 @@ public abstract class Model {
    * 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#save(Object)
+   * @see Database#save(Object)
    */
   public void save() {
     db().save(this);
@@ -202,7 +196,7 @@ public abstract class Model {
   /**
    * Update this entity.
    *
-   * @see EbeanServer#update(Object)
+   * @see Database#update(Object)
    */
   public void update() {
     db().update(this);
@@ -211,7 +205,7 @@ public abstract class Model {
   /**
    * Insert this entity.
    *
-   * @see EbeanServer#insert(Object)
+   * @see Database#insert(Object)
    */
   public void insert() {
     db().insert(this);
@@ -232,7 +226,7 @@ public abstract class Model {
    * deleted. Note that, if JDBC batch mode is used then this always returns true.
    * </p>
    *
-   * @see EbeanServer#delete(Object)
+   * @see Database#delete(Object)
    */
   public boolean delete() {
     return db().delete(this);
@@ -245,7 +239,7 @@ public abstract class Model {
    * want to perform a hard/permanent delete.
    * </p>
    *
-   * @see EbeanServer#deletePermanent(Object)
+   * @see Database#deletePermanent(Object)
    */
   public boolean deletePermanent() {
     return db().deletePermanent(this);
@@ -275,7 +269,7 @@ public abstract class Model {
   /**
    * Refreshes this entity from the database.
    *
-   * @see EbeanServer#refresh(Object)
+   * @see Database#refresh(Object)
    */
   public void refresh() {
     db().refresh(this);

src/main/java/io/ebean/OrderBy.java

@@ -4,7 +4,6 @@ import io.ebean.util.StringHelper;
 
 import java.io.Serializable;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 
@@ -412,15 +411,15 @@ public final class OrderBy<T> implements Serializable {
 
     String[] chunks = orderByClause.split(",");
     for (String chunk : chunks) {
-      String[] pairs = chunk.split(" ");
-      Property p = parseProperty(pairs);
+      Property p = parseProperty(chunk);
       if (p != null) {
         list.add(p);
       }
     }
   }
 
-  private Property parseProperty(String[] pairs) {
+  private Property parseProperty(String chunk) {
+    String[] pairs = chunk.split(" ");
     if (pairs.length == 0) {
       return null;
     }
@@ -446,8 +445,7 @@ public final class OrderBy<T> implements Serializable {
       boolean asc = isAscending(wordList.get(1));
       return new Property(wordList.get(0), asc, wordList.get(2), wordList.get(3));
     }
-    String m = "Expecting a 1, 2 or 4 words in [" + Arrays.toString(pairs) + "] but got " + wordList;
-    throw new RuntimeException(m);
+    return new Property(chunk.trim(), true);
   }
 
   private boolean isAscending(String s) {

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

@@ -244,6 +244,38 @@ public interface Query<T> {
    */
   <D> DtoQuery<D> asDto(Class<D> dtoClass);
 
+  /**
+   * Convert the query to a UpdateQuery.
+   * <p>
+   * Typically this is used with query beans to covert a query bean
+   * query into an UpdateQuery like the examples below.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  int rowsUpdated = new QCustomer()
+   *       .name.startsWith("Rob")
+   *       .asUpdate()
+   *       .set("active", false)
+   *       .update();;
+   *
+   * }</pre>
+   *
+   * <pre>{@code
+   *
+   *   int rowsUpdated = new QContact()
+   *       .notes.note.startsWith("Make Inactive")
+   *       .email.endsWith("@foo.com")
+   *       .customer.id.equalTo(42)
+   *       .asUpdate()
+   *       .set("inactive", true)
+   *       .setRaw("email = lower(email)")
+   *       .update();
+   *
+   * }</pre>
+   */
+  UpdateQuery<T> asUpdate();
+
   /**
    * Cancel the query execution if supported by the underlying database and
    * driver.
@@ -340,6 +372,27 @@ public interface Query<T> {
    */
   Query<T> setAutoTune(boolean autoTune);
 
+  /**
+   * Execute the query allowing properties with invalid JSON to be collected and not fail the query.
+   * <pre>{@code
+   *
+   *   // fetch a bean with JSON content
+   *   EBasicJsonList bean= Ebean.find(EBasicJsonList.class)
+   *       .setId(42)
+   *       .setAllowLoadErrors()  // collect errors into bean state if we have invalid JSON
+   *       .findOne();
+   *
+   *
+   *   // get the invalid JSON errors from the bean state
+   *   Map<String, Exception> errors = server().getBeanState(bean).getLoadErrors();
+   *
+   *   // If this map is not empty tell we have invalid JSON
+   *   // and should try and fix the JSON content or inform the user
+   *
+   * }</pre>
+   */
+  Query<T> setAllowLoadErrors();
+
   /**
    * Set the default lazy loading batch size to use.
    * <p>
@@ -636,15 +689,13 @@ public interface Query<T> {
    *     .where().eq("status", Status.NEW)
    *     .order().asc("id");
    *
-   *  QueryIterator<Customer> it = query.findIterate();
-   *  try {
+   *  // use try with resources to ensure QueryIterator is closed
+   *
+   *  try (QueryIterator<Customer> it = query.findIterate()) {
    *    while (it.hasNext()) {
    *      Customer customer = it.next();
    *      // do something with customer ...
    *    }
-   *  } finally {
-   *    // close the underlying resources
-   *    it.close();
    *  }
    *
    * }</pre>
@@ -838,6 +889,37 @@ public interface Query<T> {
    */
   boolean isCountDistinct();
 
+  /**
+   * Execute the query returning true if a row is found.
+   * <p>
+   * The query is executed using max rows of 1 and will only select the id property.
+   * This method is really just a convenient way to optimise a query to perform a
+   * 'does a row exist in the db' check.
+   * </p>
+   *
+   * <h2>Example using a query bean:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists =
+   *     new QContact()
+   *       .email.equalTo("rob@foo.com")
+   *       .exists();
+   *
+   * }</pre>
+   *
+   * <h2>Example:</h2>
+   * <pre>{@code
+   *
+   *   boolean userExists = query()
+   *     .where().eq("email", "rob@foo.com")
+   *     .exists();
+   *
+   * }</pre>
+   *
+   * @return True if the query finds a matching row in the database
+   */
+  boolean exists();
+
   /**
    * Execute the query returning either a single bean or null (if no matching
    * bean is found).
@@ -1329,7 +1411,6 @@ public interface Query<T> {
    *   count:1 orderStatus:COMPLETE
    *
    * }</pre>
-   *
    */
   Query<T> setCountDistinct(CountDistinctOrder orderBy);
 
@@ -1541,11 +1622,50 @@ public interface Query<T> {
    */
   Query<T> alias(String alias);
 
+  /**
+   * Set the base table to use for this query.
+   * <p>
+   * Typically this is used when a table has partitioning and we wish to specify a specific
+   * partition/table to query against.
+   * </p>
+   * <pre>{@code
+   *
+   *   QOrder()
+   *   .setBaseTable("order_2019_05")
+   *   .status.equalTo(Status.NEW)
+   *   .findList();
+   *
+   * }</pre>
+   */
+  Query<T> setBaseTable(String baseTable);
+
   /**
    * Return the type of beans being queried.
    */
   Class<T> getBeanType();
 
+  /**
+   * Restrict the query to only return subtypes of the given inherit type.
+   *
+   * <pre>{@code
+   *
+   *   List<Animal> animals =
+   *     new QAnimal()
+   *       .name.startsWith("Fluffy")
+   *       .setInheritType(Cat.class)
+   *       .findList();
+   *
+   * }</pre>
+   *
+   * @param type An inheritance subtype of the
+   */
+  Query<T> setInheritType(Class<? extends T> type);
+
+  /**
+   * Returns the inherit type. This is normally the same as getBeanType() returns as long as no other type is set.
+   */
+  Class<? extends T> getInheritType();
+
   /**
    * Return the type of query being executed.
    */

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

@@ -10,34 +10,30 @@ import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 /**
- * Query object for performing native SQL queries that return SqlRow's.
- * <p>
- * Firstly note that you can use your own sql queries with <em>entity beans</em>
- * by using the SqlSelect annotation. This should be your first approach when
- * wanting to use your own SQL queries.
- * </p>
- * <p>
- * If ORM Mapping is too tight and constraining for your problem then SqlQuery
- * could be a good approach.
- * </p>
+ * Query object for performing native SQL queries that return SqlRow or directly read
+ * ResultSet using a RowMapper.
  * <p>
  * The returned SqlRow objects are similar to a LinkedHashMap with some type
  * conversion support added.
  * </p>
  * <p>
+ * Refer to {@link DtoQuery} for native sql queries returning DTO beans.
+ * </p>
+ * <p>
+ * Refer to {@link Database#findNative(Class, String)} for native sql queries returning entity beans.
+ * </p>
+ *
  * <pre>{@code
  *
- *   // its typically a good idea to use a named query
- *   // and put the sql in the orm.xml instead of in your code
+ *   // example using named parameters
  *
  *   String sql = "select id, name from customer where name like :name and status_code = :status";
  *
- *   SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
- *   sqlQuery.setParameter("name", "Acme%");
- *   sqlQuery.setParameter("status", "ACTIVE");
- *
- *   // execute the query returning a List of MapBean objects
- *   List<SqlRow> list = sqlQuery.findList();
+ *   List<SqlRow> list =
+ *     DB.sqlQuery(sql)
+ *       .setParameter("name", "Acme%")
+ *       .setParameter("status", "ACTIVE")
+ *       .findList();
  *
  * }</pre>
  */
@@ -104,7 +100,7 @@ public interface SqlQuery extends Serializable {
    *
    *  String sql = "select id, name, status from customer order by name desc";
    *
-   *  Ebean.createSqlQuery(sql)
+   *  DB.sqlQuery(sql)
    *    .findEachRow((resultSet, rowNum) -> {
    *
    *      // read directly from ResultSet
@@ -134,7 +130,7 @@ public interface SqlQuery extends Serializable {
    *
    *   String sql = "select max(unit_price) from o_order_detail where order_qty > ?";
    *
-   *   BigDecimal maxPrice = Ebean.createSqlQuery(sql)
+   *   BigDecimal maxPrice = DB.sqlQuery(sql)
    *     .setParameter(1, 2)
    *     .findSingleAttribute(BigDecimal.class);
    *
@@ -176,9 +172,10 @@ public interface SqlQuery extends Serializable {
    *   " order by (unit_price * order_qty) desc";
    *
    *   //
-   *   List<BigDecimal> lineAmounts = Ebean.createSqlQuery(sql)
-   *     .setParameter(1, 3)
-   *     .findSingleAttributeList(BigDecimal.class);
+   *   List<BigDecimal> lineAmounts =
+   *     DB.sqlQuery(sql)
+   *       .setParameter(1, 3)
+   *       .findSingleAttributeList(BigDecimal.class);
    *
    * }</pre>
    *
@@ -195,6 +192,33 @@ public interface SqlQuery extends Serializable {
    */
   SqlQuery setParameter(String name, Object value);
 
+  /**
+   * Set one of more positioned parameters.
+   * <p>
+   * This is a convenient alternative to multiple calls setParameter().
+   *
+   * <pre>{@code
+   *
+   *   String sql = "select id, name from customer where name like ? and status = ?";
+   *
+   *   List<SqlRow> list =
+   *     DB.sqlQuery(sql)
+   *       .setParams("Rob", Status.NEW)
+   *       .findList();
+   *
+   *
+   *   // is the same as ...
+   *
+   *   List<SqlRow> list =
+   *     DB.sqlQuery(sql)
+   *       .setParameter(1, "Rob")
+   *       .setParameter(2, "Status.NEW)
+   *       .findList();
+   *
+   * }</pre>
+   */
+  SqlQuery setParams(Object... values);
+
   /**
    * The same as bind for positioned parameters.
    */

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

@@ -16,20 +16,33 @@ package io.ebean;
  * notify Ebean of external changes and enable Ebean to maintain it's "L2"
  * server cache.
  * </p>
- * <p>
+ *
  * <pre>{@code
  *
- *   // example that uses 'named' parameters
+ *   // example using 'positioned' parameters
  *
- *   String s = "UPDATE f_topic set post_count = :count where id = :id";
+ *   String sql = "insert into audit_log (group, title, description) values (?, ?, ?);
  *
- *   SqlUpdate update = Ebean.createSqlUpdate(s);
- *   update.setParameter("id", 1);
- *   update.setParameter("count", 50);
+ *   int rows =
+ *     DB.sqlUpdate(sql)
+ *       .setParams("login", "new user", "user rob was created")
+ *       .executeNow();
  *
- *   int modifiedCount = update.execute();
+ * }</pre>
  *
- *   String msg = "There were " + modifiedCount + " rows updated";
+ * <pre>{@code
+ *
+ *   // example using 'named' parameters
+ *
+ *   String sql = "update topic set post_count = :count where id = :id";
+ *
+ *   int rows =
+ *     DB.sqlUpdate(sql)
+ *       .setParameter("id", 1)
+ *       .setParameter("count", 50)
+ *       .execute();
+ *
+ *   String msg = "There were " + rows + " rows updated";
  *
  * }</pre>
  * <p>
@@ -37,9 +50,10 @@ package io.ebean;
  * <pre>{@code
  *
  *  String sql = "insert into audit_log (id, description, modified_description) values (?,?,?)";
- *  SqlUpdate insert = Ebean.createSqlUpdate(sql);
  *
- *  try (Transaction txn = Ebean.beginTransaction()) {
+ *  SqlUpdate insert = DB.sqlUpdate(sql);
+ *
+ *  try (Transaction txn = DB.beginTransaction()) {
  *    txn.setBatchMode(true);
  *
  *    insert.setNextParameter(10000);
@@ -65,7 +79,7 @@ package io.ebean;
  * </p>
  * <pre>{@code
  *
- *   try (Transaction txn = Ebean.beginTransaction()) {
+ *   try (Transaction txn = DB.beginTransaction()) {
  *
  *     insert.setNextParameter(10000);
  *     insert.setNextParameter("hello");
@@ -217,6 +231,33 @@ public interface SqlUpdate {
    */
   SqlUpdate setTimeout(int secs);
 
+  /**
+   * Set one of more positioned parameters.
+   * <p>
+   * This is a convenient alternative to multiple setParameter() calls.
+   *
+   * <pre>{@code
+   *
+   *   String sql = "insert into audit_log (id, name, version) values (?,?,?)";
+   *
+   *   DB.sqlUpdate(sql)
+   *       .setParams(UUID.randomUUID(), "Hello", 1)
+   *       .executeNow();
+   *
+   *
+   *   // is the same as ...
+   *
+   *   DB.sqlUpdate(sql)
+   *       .setParameter(1, UUID.randomUUID())
+   *       .setParameter(2, "Hello")
+   *       .setParameter(3, 1)
+   *       .executeNow();
+   *
+   * }</pre>
+   *
+   */
+  SqlUpdate setParams(Object... values);
+
   /**
    * Set the next positioned parameter.
    *

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

@@ -244,8 +244,7 @@ public interface Transaction extends AutoCloseable {
    *
    *   // assume Customer has L2 bean caching enabled ...
    *
-   *   Transaction transaction = Ebean.beginTransaction();
-   *   try {
+   *   try (Transaction transaction = ebeanServer.beginTransaction()) {
    *
    *     // this uses L2 bean cache as the transaction
    *     // ... is considered "query only" at this point
@@ -253,7 +252,7 @@ public interface Transaction extends AutoCloseable {
    *
    *     // transaction no longer "query only" once
    *     // ... a bean has been saved etc
-   *     Ebean.save(someBean);
+   *     someBean.save();
    *
    *     // will NOT use L2 bean cache as the transaction
    *     // ... is no longer considered "query only"
@@ -273,8 +272,7 @@ public interface Transaction extends AutoCloseable {
    *     Customer.find.byId(99); // skips l2 bean cache
    *
    *
-   *   } finally {
-   *     transaction.end();
+   *     transaction.commit();
    *   }
    *
    * }</pre>
@@ -290,36 +288,66 @@ public interface Transaction extends AutoCloseable {
   boolean isSkipCache();
 
   /**
-   * Turn on or off statement batching. Statement batching can be transparent
-   * for drivers and databases that support getGeneratedKeys. Otherwise you may
-   * wish to specifically control when batching is used via this method.
-   * <p>
-   * Refer to <code>java.sql.PreparedStatement.addBatch();</code>
-   * <p>
-   * Note that you may also wish to use the setPersistCascade method to stop
-   * save and delete cascade behaviour. You may do this to have full control
-   * over the order of execution rather than the normal cascading fashion.
-   * </p>
-   * <p>
-   * Note that the <em>execution order</em> in batch mode may be different from
-   * non batch mode execution order. Also note that <em>insert behaviour</em>
-   * may be different depending on the JDBC driver and its support for
-   * getGeneratedKeys. That is, for JDBC drivers that do not support
-   * getGeneratedKeys you may not get back the generated IDs (used for inserting
-   * associated detail beans etc).
-   * </p>
+   * Turn on or off use of JDBC statement batching.
    * <p>
    * Calls to save(), delete(), insert() and execute() all support batch
-   * processing. This includes normal beans, MapBean, CallableSql and UpdateSql.
+   * processing. This includes normal beans, CallableSql and UpdateSql.
    * </p>
+   *
+   * <pre>{@code
+   *
+   * try (Transaction transaction = server.beginTransaction()) {
+   *
+   *   // turn on JDBC batch
+   *   transaction.setBatchMode(true);
+   *
+   *   // tune the batch size
+   *   transaction.setBatchSize(50);
+   *
+   *   ...
+   *
+   *   transaction.commit();
+   * }
+   *
+   * }</pre>
+   *
+   * <h3>getGeneratedKeys</h3>
    * <p>
-   * The flushing of the batched statements is automatic but you can call
-   * batchFlush when you like. Note that flushing occurs when a query is
-   * executed or when you mix UpdateSql and CallableSql with save and delete of
+   * Often with large batch inserts we want to turn off getGeneratedKeys. We do
+   * this via {@link #setBatchGetGeneratedKeys(boolean)}.
+   * Also note that some JDBC drivers do not support getGeneratedKeys in JDBC batch mode.
+   * </p>
+   * <pre>{@code
+   *
+   * try (Transaction transaction = server.beginTransaction()) {
+   *
+   *   transaction.setBatchMode(true);
+   *   transaction.setBatchSize(100);
+   *   // insert but don't bother getting back the generated keys
+   *   transaction.setBatchGetGeneratedKeys(false);
+   *
+   *
+   *   // perform lots of inserts ...
+   *   ...
+   *
+   *   transaction.commit();
+   * }
+   *
+   * }</pre>
+   *
+   * <h3>Flush</h3>
+   * <p>
+   * The batch is automatically flushed when it hits the batch size and also when we
+   * execute queries or when we mix UpdateSql and CallableSql with save and delete of
    * beans.
    * </p>
    * <p>
-   * Example: batch processing executing every 3 rows
+   * We use {@link #flush()} to explicitly flush the batch and we can use
+   * {@link #setBatchFlushOnQuery(boolean)} and {@link #setBatchFlushOnMixed(boolean)}
+   * to control the automatic flushing behaviour.
+   * </p>
+   * <p>
+   * Example: batch processing of CallableSql executing every 10 rows
    * </p>
    *
    * <pre>{@code
@@ -334,24 +362,21 @@ public interface Transaction extends AutoCloseable {
    * CallableSql cs = new CallableSql(sql);
    * cs.registerOut(2, Types.INTEGER);
    *
-   * // (optional) inform eBean this stored procedure
+   * // (optional) inform Ebean this stored procedure
    * // inserts into a table called sp_test
    * cs.addModification("sp_test", true, false, false);
    *
-   * Transaction txn = ebeanServer.beginTransaction();
-   * txn.setBatchMode(true);
-   * txn.setBatchSize(3);
-   * try {
+   * try (Transaction txn = ebeanServer.beginTransaction()) {
+   *   txn.setBatchMode(true);
+   *   txn.setBatchSize(10);
+   *
    *   for (int i = 0; i < da.length;) {
    *     cs.setParameter(1, da[i]);
    *     ebeanServer.execute(cs);
    *   }
    *
-   *   // NB: commit implicitly flushes
+   *   // Note: commit implicitly flushes
    *   txn.commit();
-   *
-   * } finally {
-   *   txn.end();
    * }
    *
    * }</pre>

src/main/java/io/ebean/UpdateQuery.java

@@ -154,9 +154,19 @@ public interface UpdateQuery<T> {
    */
   UpdateQuery<T> setProfileLocation(ProfileLocation profileLocation);
 
+  /**
+   * Set the label on the update query.
+   */
+  UpdateQuery<T> setLabel(String label);
+
   /**
    * Return the query expression list to add predicates to.
    */
   ExpressionList<T> where();
 
+  /**
+   * Execute the update returning the number of rows updated.
+   */
+  int update();
+
 }

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

@@ -98,6 +98,8 @@ public final class EntityBeanIntercept implements Serializable {
 
   private Object[] origValues;
 
+  private Exception[] loadErrors;
+
   private int lazyLoadProperty = -1;
 
   private Object ownerId;
@@ -1115,4 +1117,36 @@ public final class EntityBeanIntercept implements Serializable {
   public void setSortOrder(int sortOrder) {
     this.sortOrder = sortOrder;
   }
+
+  /**
+   * Set the load error that happened on this property.
+   */
+  public void setLoadError(int propertyIndex, Exception t) {
+    if (loadErrors == null) {
+      loadErrors = new Exception[owner._ebean_getPropertyNames().length];
+    }
+    loadErrors[propertyIndex] = t;
+    flags[propertyIndex] |= FLAG_LOADED_PROP;
+  }
+
+  /**
+   * Returns the loadErrors.
+   */
+  public Map<String, Exception> getLoadErrors() {
+    if (loadErrors == null) {
+      return null;
+    }
+    Map<String, Exception> ret = null;
+    int len = getPropertyLength();
+    for (int i = 0; i < len; i++) {
+      Exception loadError = loadErrors[i];
+      if (loadError != null) {
+        if (ret == null) {
+          ret = new LinkedHashMap<>();
+        }
+        ret.put(getProperty(i), loadError);
+      }
+    }
+    return ret;
+  }
 }

src/main/java/io/ebean/cache/ServerCacheNotification.java

@@ -19,6 +19,11 @@ public class ServerCacheNotification {
     this.dependentTables = dependentTables;
   }
 
+  @Override
+  public String toString() {
+    return "ts:" + modifyTimestamp + " tables:" + dependentTables;
+  }
+
   public long getModifyTimestamp() {
     return modifyTimestamp;
   }

src/main/java/io/ebean/cache/ServerCacheOptions.java

@@ -12,6 +12,7 @@ public class ServerCacheOptions {
   private int maxIdleSecs;
   private int maxSecsToLive;
   private int trimFrequency;
+  private boolean nearCache;
 
   /**
    * Construct with no set options.
@@ -40,6 +41,14 @@ public class ServerCacheOptions {
     this.trimFrequency = cacheTuning.trimFrequency();
   }
 
+  /**
+   * Create with nearCache option.
+   */
+  public ServerCacheOptions(boolean nearCache, CacheBeanTuning tuning) {
+    this(tuning);
+    this.nearCache = nearCache;
+  }
+
   /**
    * Apply any settings from the default settings that have not already been
    * specifically set.
@@ -70,9 +79,33 @@ public class ServerCacheOptions {
     copy.maxIdleSecs = maxIdleSecs;
     copy.maxSecsToLive = maxSecsToLive;
     copy.trimFrequency = trimFrequency;
+    copy.nearCache = this.nearCache;
     return copy;
   }
 
+  /**
+   * Return a copy of this object with nearCache option.
+   */
+  public ServerCacheOptions copy(boolean nearCache) {
+    ServerCacheOptions copy = copy();
+    copy.nearCache = nearCache;
+    return copy;
+  }
+
+  /**
+   * Return true if nearCache was explicitly turned on.
+   */
+  public boolean isNearCache() {
+    return nearCache;
+  }
+
+  /**
+   * Turn on nearCache option.
+   */
+  public void setNearCache(boolean nearCache) {
+    this.nearCache = nearCache;
+  }
+
   /**
    * Return the maximum cache size.
    */

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

@@ -0,0 +1,44 @@
+package io.ebean.config;
+
+import io.ebean.DatabaseFactory;
+
+/**
+ * The configuration used for creating a Database.
+ * <p>
+ * Used to programmatically construct an Database and optionally register it
+ * with the DB singleton.
+ * </p>
+ * <p>
+ * If you just use DB thout this programmatic configuration Ebean will read
+ * the application.properties file and take the configuration from there. This usually
+ * includes searching the class path and automatically registering any entity
+ * classes and listeners etc.
+ * </p>
+ * <pre>{@code
+ *
+ * DatabaseConfig config = new DatabaseConfig();
+ *
+ * // read the ebean.properties and load
+ * // those settings into this serverConfig object
+ * config.loadFromProperties();
+ *
+ * // explicitly register the entity beans to avoid classpath scanning
+ * config.addClass(Customer.class);
+ * config.addClass(User.class);
+ *
+ * Database db = DatabaseFactory.create(config);
+ *
+ * }</pre>
+ *
+ * <p>
+ * Note that ServerConfigProvider provides a standard Java ServiceLoader mechanism that can
+ * be used to apply configuration to the DatabaseConfig.
+ * </p>
+ *
+ * @author emcgreal
+ * @author rbygrave
+ * @see DatabaseFactory
+ */
+public class DatabaseConfig extends ServerConfig {
+
+}

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

@@ -5,7 +5,6 @@ import io.ebean.annotation.Platform;
 import io.ebean.migration.MigrationConfig;
 import io.ebean.migration.MigrationRunner;
 import io.ebean.util.StringHelper;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -33,6 +32,8 @@ public class DbMigrationConfig {
    */
   protected String migrationPath = "dbmigration";
 
+  protected String migrationInitPath = "dbinit";
+
   /**
    * Subdirectory the model xml files go into.
    */
@@ -118,6 +119,15 @@ public class DbMigrationConfig {
     this.platform = platform;
   }
 
+  /**
+   * Return the path for normal migrations or dbinit migrations.
+   *
+   * @param dbinitMigration When true return the path for dbinit migrations.
+   */
+  public String getMigrationPath(boolean dbinitMigration) {
+    return dbinitMigration ? migrationInitPath : migrationPath;
+  }
+
   /**
    * Return the resource path for db migrations.
    */
@@ -419,6 +429,7 @@ public class DbMigrationConfig {
   public void loadSettings(PropertiesWrapper properties, String serverName) {
 
     migrationPath = properties.get("migration.migrationPath", migrationPath);
+    migrationInitPath = properties.get("migration.migrationInitPath", migrationInitPath);
     modelPath = properties.get("migration.modelPath", modelPath);
     applyPrefix = properties.get("migration.applyPrefix", applyPrefix);
     applySuffix = properties.get("migration.applySuffix", applySuffix);
@@ -472,6 +483,7 @@ public class DbMigrationConfig {
     runnerConfig.setMetaTable(metaTable);
     runnerConfig.setApplySuffix(applySuffix);
     runnerConfig.setMigrationPath(migrationPath);
+    runnerConfig.setMigrationInitPath(migrationInitPath);
     runnerConfig.setRunPlaceholderMap(runPlaceholderMap);
     runnerConfig.setRunPlaceholders(runPlaceholders);
     runnerConfig.setDbUsername(getDbUsername());

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

@@ -47,6 +47,11 @@ public class PlatformConfig {
    */
   private DbUuid dbUuid = DbUuid.AUTO_VARCHAR;
 
+  /**
+   * Set to true to force InetAddress to map to Varchar (for Postgres rather than INET)
+   */
+  private boolean databaseInetAddressVarchar;
+
   /**
    * Modify the default mapping of standard types such as default precision for DECIMAL etc.
    */
@@ -181,6 +186,20 @@ public class PlatformConfig {
     this.idType = idType;
   }
 
+  /**
+   * Return true if InetAddress should map to varchar column (rather than Postgres INET).
+   */
+  public boolean isDatabaseInetAddressVarchar() {
+    return databaseInetAddressVarchar;
+  }
+
+  /**
+   * Set to true to force InetAddress to map to varchar column.
+   */
+  public void setDatabaseInetAddressVarchar(boolean databaseInetAddressVarchar) {
+    this.databaseInetAddressVarchar = databaseInetAddressVarchar;
+  }
+
   /**
    * Add a custom type mapping.
    * <p>
@@ -235,6 +254,7 @@ public class PlatformConfig {
     databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", databaseSequenceBatchSize);
     databaseBooleanTrue = p.get("databaseBooleanTrue", databaseBooleanTrue);
     databaseBooleanFalse = p.get("databaseBooleanFalse", databaseBooleanFalse);
+    databaseInetAddressVarchar = p.getBoolean("databaseInetAddressVarchar", databaseInetAddressVarchar);
 
     DbUuid dbUuid = p.getEnum(DbUuid.class, "dbuuid", null);
     if (dbUuid != null) {

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

@@ -252,6 +252,8 @@ public class ServerConfig {
 
   private boolean ddlRun;
 
+  private boolean ddlExtra = true;
+
   private boolean ddlCreateOnly;
 
   private String ddlInitSql;
@@ -366,9 +368,10 @@ public class ServerConfig {
   private UuidVersion uuidVersion = UuidVersion.VERSION4;
 
   /**
-   * The UUID state file (for Version 1 UUIDs).
+   * The UUID state file (for Version 1 UUIDs). By default, the file is created in
+   * ${HOME}/.ebean/${servername}-uuid.state
    */
-  private String uuidStateFile = "ebean-uuid.state";
+  private String uuidStateFile;
 
   /**
    * The clock used for setting the timestamps (e.g. @UpdatedTimestamp) on objects.
@@ -486,6 +489,11 @@ public class ServerConfig {
    */
   private boolean notifyL2CacheInForeground;
 
+  /**
+   * Set to true to support query plan capture.
+   */
+  private boolean collectQueryPlans;
+
   /**
    * The time in millis used to determine when a query is alerted for being slow.
    */
@@ -594,6 +602,47 @@ public class ServerConfig {
     return serviceObject.get(key);
   }
 
+  /**
+   * Put a service object into configuration such that it can be passed to a plugin.
+   *
+   * <pre>{@code
+   *
+   *   JedisPool jedisPool = ..
+   *
+   *   serverConfig.putServiceObject(jedisPool);
+   *
+   * }</pre>
+   */
+  public void putServiceObject(Object configObject) {
+    String key = serviceObjectKey(configObject);
+    serviceObject.put(key, configObject);
+  }
+
+  private String serviceObjectKey(Object configObject) {
+    return serviceObjectKey(configObject.getClass());
+  }
+
+  private String serviceObjectKey(Class<?> cls) {
+    String simpleName = cls.getSimpleName();
+    return Character.toLowerCase(simpleName.charAt(0)) + simpleName.substring(1);
+  }
+
+  /**
+   * Used by plugins to obtain service objects.
+   *
+   * <pre>{@code
+   *
+   *   JedisPool jedisPool = serverConfig.getServiceObject(JedisPool.class);
+   *
+   * }</pre>
+   *
+   * @param cls The type of the service object to obtain
+   * @return The service object given the class type
+   */
+  public <P> P getServiceObject(Class<P> cls) {
+    return (P) serviceObject.get(serviceObjectKey(cls));
+  }
+
   /**
    * Return the Jackson JsonFactory to use.
    * <p>
@@ -2069,6 +2118,16 @@ public class ServerConfig {
     this.ddlRun = ddlRun;
   }
 
+  /**
+   * Set to false if you not want to run the extra-ddl.xml scripts. (default = true)
+   * <p>
+   * Typically we want this on when we are running tests.
+   */
+  public void setDdlExtra(boolean ddlExtra) {
+    this.ddlExtra = ddlExtra;
+  }
+
+
   /**
    * Return true if the "drop all ddl" should be skipped.
    * <p>
@@ -2139,6 +2198,13 @@ public class ServerConfig {
     return ddlRun;
   }
 
+  /**
+   * Return true, if extra-ddl.xml should be executed.
+   */
+  public boolean isDdlExtra() {
+    return ddlExtra;
+  }
+
   /**
    * Return true if the class path search should be disabled.
    */
@@ -2763,20 +2829,6 @@ public class ServerConfig {
     return list;
   }
 
-  /**
-   * Deprecated - this does nothing now, we always try to read test configuration.
-   * <p>
-   * Load settings from test-ebean.properties and do nothing if the properties is not found.
-   * <p>
-   * This is typically used when test-ebean.properties is put into the test class path and used
-   * to configure Ebean for running tests.
-   * </p>
-   */
-  @Deprecated
-  public void loadTestProperties() {
-    // do nothing now ... as we always try to read test configuration and that should only
-  }
-
   /**
    * Return the properties that we used for configuration and were set via a call to loadFromProperties().
    */
@@ -2846,6 +2898,7 @@ public class ServerConfig {
 
     queryPlanTTLSeconds = p.getInt("queryPlanTTLSeconds", queryPlanTTLSeconds);
     slowQueryMillis = p.getLong("slowQueryMillis", slowQueryMillis);
+    collectQueryPlans = p.getBoolean("collectQueryPlans", collectQueryPlans);
     docStoreOnly = p.getBoolean("docStoreOnly", docStoreOnly);
     disableL2Cache = p.getBoolean("disableL2Cache", disableL2Cache);
     notifyL2CacheInForeground = p.getBoolean("notifyL2CacheInForeground", notifyL2CacheInForeground);
@@ -2928,6 +2981,7 @@ public class ServerConfig {
 
     ddlGenerate = p.getBoolean("ddl.generate", ddlGenerate);
     ddlRun = p.getBoolean("ddl.run", ddlRun);
+    ddlExtra = p.getBoolean("ddl.extra", ddlExtra);
     ddlCreateOnly = p.getBoolean("ddl.createOnly", ddlCreateOnly);
     ddlInitSql = p.get("ddl.initSql", ddlInitSql);
     ddlSeedSql = p.get("ddl.seedSql", ddlSeedSql);
@@ -3211,6 +3265,20 @@ public class ServerConfig {
     this.idGeneratorAutomatic = idGeneratorAutomatic;
   }
 
+  /**
+   * Return true if query plan capture is enabled.
+   */
+  public boolean isCollectQueryPlans() {
+    return collectQueryPlans;
+  }
+
+  /**
+   * Set to true to enable query plan capture.
+   */
+  public void setCollectQueryPlans(boolean collectQueryPlans) {
+    this.collectQueryPlans = collectQueryPlans;
+  }
+
   public enum UuidVersion {
     VERSION4,
     VERSION1,

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

@@ -27,6 +27,9 @@ public class DbPlatformTypeMapping {
 
   private static final DbPlatformType BOOLEAN_LOGICAL = new BooleanLogicalType();
 
+  private static final DbPlatformType INET_NATIVE = new DbPlatformType("inet", false);
+  private static final DbPlatformType INET_VARCHAR = new DbPlatformType("varchar", 50);
+
   private static final DbPlatformType UUID_NATIVE = new DbPlatformType("uuid", false);
   @SuppressWarnings("unused")
   private static final DbPlatformType UUID_PLACEHOLDER = new DbPlatformType("uuidPlaceholder");
@@ -106,6 +109,7 @@ public class DbPlatformTypeMapping {
       put(DbType.JSONBLOB, new DbPlatformType("jsonblob"));
       put(DbType.JSONVARCHAR, new DbPlatformType("jsonvarchar", 1000));
       put(DbType.UUID, UUID_NATIVE);
+      put(DbType.INET, INET_NATIVE);
 
     } else {
       put(DbType.VARCHAR, new DbPlatformType("varchar", 255));
@@ -121,6 +125,7 @@ public class DbPlatformTypeMapping {
       put(DbType.JSONVARCHAR, JSON_VARCHAR_PLACEHOLDER);
       // default to native UUID and override on platform configure()
       put(DbType.UUID, UUID_NATIVE);
+      put(DbType.INET, INET_VARCHAR);
     }
   }
 

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

@@ -35,6 +35,8 @@ public enum DbType {
   ARRAY(Types.ARRAY),
 
   UUID(ExtraDbTypes.UUID),
+  INET(ExtraDbTypes.INET),
+  CDIR(ExtraDbTypes.CDIR),
 
   POINT(ExtraDbTypes.POINT),
   POLYGON(ExtraDbTypes.POLYGON),

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

@@ -40,6 +40,9 @@ public interface ExtraDbTypes {
    */
   int JSONBlob = 5005;
 
+  int INET = 5020;
+  int CDIR = 5021;
+
   /**
    * Geo Point
    */

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

@@ -60,6 +60,7 @@ public class PostgresPlatform extends DatabasePlatform {
     DbPlatformType dbBytea = new DbPlatformType("bytea", false);
 
     dbTypeMap.put(DbType.UUID, new DbPlatformType("uuid", false));
+    dbTypeMap.put(DbType.INET, new DbPlatformType("inet", false));
     dbTypeMap.put(DbType.HSTORE, new DbPlatformType("hstore", false));
     dbTypeMap.put(DbType.JSON, new DbPlatformType("json", false));
     dbTypeMap.put(DbType.JSONB, new DbPlatformType("jsonb", false));

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

@@ -97,6 +97,8 @@ class Loader {
       if (fileName != null) {
         loadWithExtensionCheck(fileName);
       }
+    } else {
+        loadWithExtensionCheck(fileName);
     }
   }
 

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

@@ -50,6 +50,11 @@ public interface DbMigration {
     throw new IllegalStateException("No service implementation found for DbMigration?");
   }
 
+  /**
+   * Set to false to suppress logging to System out.
+   */
+  void setLogToSystemOut(boolean logToSystemOut);
+
   /**
    * Set the path from the current working directory to the application resources.
    * <p>
@@ -154,7 +159,7 @@ public interface DbMigration {
   List<String> getPendingDrops();
 
   /**
-   * Generate the next migration xml file and associated apply and rollback sql scripts.
+   * Generate the next migration sql script and associated model xml.
    * <p>
    * This does not run the migration or ddl scripts but just generates them.
    * </p>
@@ -186,4 +191,15 @@ public interface DbMigration {
    * @return the version of the generated migration or null
    */
   String generateMigration() throws IOException;
+
+  /**
+   * Generate an "init" migration which has all changes.
+   * <p>
+   * An "init" migration can only be executed and used on a database that has had no
+   * prior migrations run on it.
+   * </p>
+   * @return the version of the generated migration
+   */
+  String generateInitMigration() throws IOException;
+
 }

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

@@ -7,6 +7,11 @@ import java.util.List;
  */
 public interface MetaInfoManager {
 
+  /**
+   * Collect query plans.
+   */
+  List<MetaQueryPlan> collectQueryPlans(QueryPlanRequest request);
+
   /**
    * Visit the metrics resetting and collecting/reporting as desired.
    */

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

@@ -0,0 +1,23 @@
+package io.ebean.meta;
+
+public interface MetaQueryPlan {
+
+  Class<?> getBeanType();
+
+  /**
+   * Return a string representation of the query plan hash.
+   */
+  String getQueryPlanHash();
+
+  String getLabel();
+
+  String getSql();
+
+  String getBind();
+
+  String getPlan();
+
+  long getQueryTimeMicros();
+
+  long getCaptureCount();
+}

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

@@ -25,6 +25,11 @@ public enum MetricType {
    * <p>
    * SqlQuery and SqlUpdate without a label have no metrics collected.
    */
-  SQL
+  SQL,
+
+  /**
+   * L2 cache metrics.
+   */
+  L2
 
 }

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

@@ -0,0 +1,97 @@
+package io.ebean.meta;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Request used to capture query plans.
+ */
+public class QueryPlanRequest {
+
+  private List<MetaQueryPlan> plans = new ArrayList<>();
+
+  private Connection connection;
+
+  private boolean store;
+
+  private long since;
+
+  private Set<Class<?>> includedBeanTypes;
+
+  private Set<String> includedLabels;
+
+  public List<MetaQueryPlan> getPlans() {
+    return plans;
+  }
+
+  /**
+   * Return the connection to use to capture the query plans.
+   */
+  public Connection getConnection() {
+    return connection;
+  }
+
+  /**
+   * Set the connection to use to capture the query plans.
+   */
+  public void setConnection(Connection connection) {
+    this.connection = connection;
+  }
+
+  /**
+   * Return true if the captured query plan is stored.
+   */
+  public boolean isStore() {
+    return store;
+  }
+
+  /**
+   * Set to true to store the captured query plan.
+   */
+  public void setStore(boolean store) {
+    this.store = store;
+  }
+
+  /**
+   * Return the epoch time after which the query plan was capture (to be included).
+   */
+  public long getSince() {
+    return since;
+  }
+
+  /**
+   * Set the epoch time after which the query plan was captured.
+   * <p>
+   * This is used to only capture plans that have changed since a given time (like the time of last capture).
+   * </p>
+   *
+   * @param since The time after which the query plan was captured to be included
+   */
+  public void setSince(long since) {
+    this.since = since;
+  }
+
+  /**
+   * Process consume the query plan.
+   */
+  public void process(MetaQueryPlan plan) {
+    plans.add(plan);
+  }
+
+  /**
+   * Return true if the bean type should be included in the query plan capture.
+   */
+  public boolean includeType(Class<?> beanType) {
+    return includedBeanTypes == null || includedBeanTypes.isEmpty() || includedBeanTypes.contains(beanType);
+  }
+
+  /**
+   * Return true if the label should be included in the query plan capture.
+   */
+  public boolean includeLabel(String label) {
+    return includedLabels == null || includedLabels.isEmpty() || includedLabels.contains(label);
+  }
+
+}

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

@@ -1,4 +1,4 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
 
 import io.ebean.meta.MetricType;
 

src/main/java/io/ebean/metric/MetricServiceProvider.java

@@ -1,4 +1,4 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
 
 import io.ebeaninternal.server.profile.DMetricFactory;
 

src/main/java/io/ebean/metric/QueryPlanCollector.java

@@ -1,4 +1,4 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
 
 import io.ebean.meta.MetaQueryMetric;
 

src/main/java/io/ebean/metric/QueryPlanMetric.java

@@ -1,4 +1,4 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
 
 import io.ebean.meta.MetricVisitor;
 

src/main/java/io/ebean/metric/TimedMetric.java

@@ -1,4 +1,4 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
 
 import io.ebean.meta.MetricVisitor;
 
@@ -17,6 +17,16 @@ public interface TimedMetric {
    */
   void add(long micros, long beans);
 
+  /**
+   * Add a time event given the start nanos.
+   */
+  void addSinceNanos(long startNanos);
+
+  /**
+   * Add a time event given the start nanos and bean count.
+   */
+  void addSinceNanos(long startNanos, long beans);
+
   /**
    * Return true if there are no metrics collected since the last collection.
    */

src/main/java/io/ebean/metric/TimedMetricMap.java

@@ -1,4 +1,4 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
 
 import io.ebean.meta.MetricVisitor;
 
@@ -7,6 +7,16 @@ import io.ebean.meta.MetricVisitor;
  */
 public interface TimedMetricMap {
 
+  /**
+   * Add a time event given the start nanos.
+   */
+  void addSinceNanos(String key, long startNanos);
+
+  /**
+   * Add a time event given the start nanos and beans.
+   */
+  void addSinceNanos(String key, long startNanos, int beans);
+
   /**
    * Add an execution for the given key.
    */

src/main/java/io/ebean/metric/TimedMetricStats.java

@@ -1,4 +1,4 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
 
 import io.ebean.meta.MetaTimedMetric;
 

src/main/java/io/ebean/plugin/LoadErrorHandler.java

@@ -0,0 +1,14 @@
+package io.ebean.plugin;
+
+import io.ebean.bean.EntityBean;
+
+/**
+ * Errorhandler to handle load errors and may be recover correct value.
+ *
+ * @author Roland Praml, FOCONIS AG
+ *
+ */
+@FunctionalInterface
+public interface LoadErrorHandler {
+  void handleLoadError(EntityBean bean, Property prop, String fullName, Exception e);
+}

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

@@ -6,6 +6,7 @@ package io.ebean.text;
 public class TextException extends RuntimeException {
 
   private static final long serialVersionUID = 1601310159486033148L;
+  private String text;
 
   /**
    * Construct with an error message.
@@ -27,4 +28,41 @@ public class TextException extends RuntimeException {
   public TextException(Exception e) {
     super(e);
   }
+
+  /**
+   * Constructor for a detailed exception.
+   *
+   * @param message
+   *          the message. The placeholder {} will be replaced by
+   *          <code>text</code>
+   * @param text
+   *          the fault text.
+   * @param cause
+   *          the case
+   */
+  public TextException(String message, String text, Exception cause) {
+    super(message.replace("{}", String.valueOf(text)), cause);
+    this.text = text;
+  }
+
+  /**
+   * Constructor for a detailed exception.
+   *
+   * @param message
+   *          the message. The placeholder {} will be replaced by
+   *          <code>text</code>
+   * @param text
+   *          the fault text.
+   */
+  public TextException(String message, String text) {
+    super(message.replace("{}", String.valueOf(text)));
+    this.text = text;
+  }
+
+  /**
+   * Return the text, that caused the error. (e.g. the JSON). May be null.
+   */
+  public String getText() {
+    return text;
+  }
 }

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

@@ -26,9 +26,9 @@ public class CamelCaseHelper {
       } else if (Character.isDigit(c)) {
         if (i > lastUpper + 1 && !digitsCompressed) {
           sb.append("_");
+          lastUpper = i;
         }
         sb.append(c);
-        lastUpper = i;
 
       } else if (Character.isUpperCase(c)) {
         if (i > lastUpper + 1) {

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

@@ -41,6 +41,14 @@ public class BindParams implements Serializable {
   public BindParams() {
   }
 
+  /**
+   * Reset positioned parameters (usually due to bind parameter expansion).
+   */
+  public void reset() {
+    bindHash = null;
+    positionedParameters.clear();
+  }
+
   public int queryBindHash() {
     int hc = namedParameters.hashCode();
     for (Param positionedParameter : positionedParameters) {
@@ -171,8 +179,7 @@ public class BindParams implements Serializable {
   }
 
   private Param getParam(String name) {
-    Param p = namedParameters.computeIfAbsent(name, k -> new Param());
-    return p;
+    return namedParameters.computeIfAbsent(name, k -> new Param());
   }
 
   private Param getParam(int position) {

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

@@ -11,4 +11,8 @@ public interface CQueryPlanKey {
    */
   String getPartialKey();
 
+  /**
+   * Return a query plan key taking into account persist cascading.
+   */
+  CQueryPlanKey withDeleteByIds();
 }

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

@@ -3,7 +3,6 @@ package io.ebeaninternal.api;
 import io.ebean.Pairs;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;

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

@@ -439,6 +439,11 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   void setDelete();
 
+  /**
+   * Set the query to be delete by ids due to cascading delete.
+   */
+  CQueryPlanKey setDeleteByIdsPlan();
+
   /**
    * Set the query to select the id property only.
    */
@@ -749,23 +754,6 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   boolean isDisableLazyLoading();
 
-  /**
-   * Internally set by Ebean when this query must use the DISTINCT keyword.
-   * <p>
-   * This does not exclude/remove the use of the id property.
-   */
-  void setSqlDistinct(boolean sqlDistinct);
-
-  /**
-   * Return true if this query has been specified by a user or internally by Ebean to use DISTINCT.
-   */
-  boolean isDistinctQuery();
-
-  /**
-   * Return true if this was internally set to sql distinct (ie. many where predicate).
-   */
-  boolean isSqlDistinct();
-
   /**
    * Return true if this query has been specified by a user to use DISTINCT.
    */
@@ -837,6 +825,11 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   boolean isCancelled();
 
+  /**
+   * Return the base table to use if user defined on the query.
+   */
+  String getBaseTable();
+
   /**
    * Return root table alias set by {@link #alias(String)} command.
    */
@@ -861,4 +854,9 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    * Returns the count distinct order setting.
    */
   CountDistinctOrder getCountDistinctOrder();
+
+  /**
+   * Handles load errors.
+   */
+  void handleLoadError(String fullName, Exception e);
 }

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

@@ -4,6 +4,11 @@ import io.ebean.SqlUpdate;
 
 public interface SpiSqlUpdate extends SqlUpdate {
 
+  /**
+   * Return the sql taking into account bind parameter expansion.
+   */
+  String getBaseSql();
+
   /**
    * Return the Bind parameters.
    */

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

@@ -40,6 +40,7 @@ public class DdlGenerator {
 
   private final boolean generateDdl;
   private final boolean runDdl;
+  private final boolean extraDdl;
   private final boolean createOnly;
   private final boolean jaxbPresent;
   private final boolean ddlCommitOnCreateIndex;
@@ -54,6 +55,7 @@ public class DdlGenerator {
     this.server = server;
     this.jaxbPresent = serverConfig.getClassLoadConfig().isJavaxJAXBPresent();
     this.generateDdl = serverConfig.isDdlGenerate();
+    this.extraDdl = serverConfig.isDdlExtra();
     this.createOnly = serverConfig.isDdlCreateOnly();
     this.dbSchema = serverConfig.getDbSchema();
     if (!serverConfig.getTenantMode().isDdlEnabled() && serverConfig.isDdlRun()) {
@@ -166,8 +168,7 @@ public class DdlGenerator {
 
   protected void runDropSql(Connection connection) throws IOException {
     if (!createOnly) {
-      String ignoreExtraDdl = System.getProperty("ebean.ignoreExtraDdl");
-      if (!"true".equalsIgnoreCase(ignoreExtraDdl) && jaxbPresent) {
+      if (extraDdl && jaxbPresent) {
         String extraApply = ExtraDdlXmlReader.buildExtra(server.getDatabasePlatform().getName(), true);
         if (extraApply != null) {
           runScript(connection, false, extraApply, "extra-ddl");
@@ -187,8 +188,7 @@ public class DdlGenerator {
     }
     runScript(connection, false, createAllContent, getCreateFileName());
 
-    String ignoreExtraDdl = System.getProperty("ebean.ignoreExtraDdl");
-    if (!"true".equalsIgnoreCase(ignoreExtraDdl) && jaxbPresent) {
+    if (extraDdl && jaxbPresent) {
       if (currentModel.isTablePartitioning()) {
         String extraPartitioning = ExtraDdlXmlReader.buildPartitioning(server.getDatabasePlatform().getName());
         if (extraPartitioning != null && !extraPartitioning.isEmpty()) {

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

@@ -72,6 +72,8 @@ public class DefaultDbMigration implements DbMigration {
 
   private static final String GENERATED_COMMENT = "THIS IS A GENERATED FILE - DO NOT MODIFY";
 
+  private boolean logToSystemOut = true;
+
   /**
    * Set to true if DefaultDbMigration run with online EbeanServer instance.
    */
@@ -271,6 +273,15 @@ public class DefaultDbMigration implements DbMigration {
    */
   @Override
   public String generateMigration() throws IOException {
+    return generateMigrationFor(false);
+  }
+
+  @Override
+  public String generateInitMigration() throws IOException {
+    return generateMigrationFor(true);
+  }
+
+  private String generateMigrationFor(boolean dbinitMigration) throws IOException {
 
     // use this flag to stop other plugins like full DDL generation
     if (!online) {
@@ -286,14 +297,17 @@ public class DefaultDbMigration implements DbMigration {
       configurePlatforms();
     }
     try {
-      Request request = createRequest();
-      if (platforms.isEmpty()) {
-        generateExtraDdl(request.migrationDir, databasePlatform, request.isTablePartitioning());
-      } else {
-        for (Pair pair : platforms) {
-          PlatformDdlWriter platformWriter = createDdlWriter(pair.platform);
-          File subPath = platformWriter.subPath(request.migrationDir, pair.prefix);
-          generateExtraDdl(subPath, pair.platform, request.isTablePartitioning());
+      Request request = createRequest(dbinitMigration);
+      if (!dbinitMigration) {
+        // repeatable migrations
+        if (platforms.isEmpty()) {
+          generateExtraDdl(request.migrationDir, databasePlatform, request.isTablePartitioning());
+        } else {
+          for (Pair pair : platforms) {
+            PlatformDdlWriter platformWriter = createDdlWriter(pair.platform);
+            File subPath = platformWriter.subPath(request.migrationDir, pair.prefix);
+            generateExtraDdl(subPath, pair.platform, request.isTablePartitioning());
+          }
         }
       }
 
@@ -304,6 +318,11 @@ public class DefaultDbMigration implements DbMigration {
         return generateDiff(request);
       }
 
+    } catch (UnknownResourcePathException e) {
+      logError("ERROR - " + e.getMessage());
+      logError("Check the working directory or change dbMigration.setPathToResources() value?");
+      return null;
+
     } finally {
       if (!online) {
         DbOffline.reset();
@@ -321,7 +340,7 @@ public class DefaultDbMigration implements DbMigration {
     }
     setDefaults();
     try {
-      return createRequest().getPendingDrops();
+      return createRequest(false).getPendingDrops();
     } finally {
       if (!online) {
         DbOffline.reset();
@@ -375,8 +394,7 @@ public class DefaultDbMigration implements DbMigration {
   private void writeExtraDdl(File migrationDir, DdlScript script) throws IOException {
 
     String fullName = repeatableMigrationName(script.isInit(), script.getName());
-
-    logger.info("writing repeatable script {}", fullName);
+    logger.debug("writing repeatable script {}", fullName);
 
     File file = new File(migrationDir, fullName);
     try (FileWriter writer = new FileWriter(file)) {
@@ -385,6 +403,30 @@ public class DefaultDbMigration implements DbMigration {
     }
   }
 
+  @Override
+  public void setLogToSystemOut(boolean logToSystemOut) {
+    this.logToSystemOut = logToSystemOut;
+  }
+
+  private void logError(String message) {
+    if (logToSystemOut) {
+      System.out.println("DbMigration> " + message);
+    } else {
+      logger.error(message);
+    }
+  }
+
+  private void logInfo(String message, Object value) {
+    if (value != null) {
+      message = String.format(message, value);
+    }
+    if (logToSystemOut) {
+      System.out.println("DbMigration> " + message);
+    } else {
+      logger.info(message);
+    }
+  }
+
   private String repeatableMigrationName(boolean init, String scriptName) {
     StringBuilder sb = new StringBuilder();
     if (init) {
@@ -404,12 +446,12 @@ public class DefaultDbMigration implements DbMigration {
 
     List<String> pendingDrops = request.getPendingDrops();
     if (!pendingDrops.isEmpty()) {
-      logger.info("Pending un-applied drops in versions {}", pendingDrops);
+      logInfo("Pending un-applied drops in versions %s", pendingDrops);
     }
 
     Migration migration = request.createDiffMigration();
     if (migration == null) {
-      logger.info("no changes detected - no migration written");
+      logInfo("no changes detected - no migration written", null);
       return null;
     } else {
       // there were actually changes to write
@@ -428,41 +470,57 @@ public class DefaultDbMigration implements DbMigration {
 
     List<String> pendingDrops = request.getPendingDrops();
     if (!pendingDrops.isEmpty()) {
-      logger.info("... remaining pending un-applied drops in versions {}", pendingDrops);
+      logInfo("... remaining pending un-applied drops in versions %s", pendingDrops);
     }
     return version;
   }
 
-  private Request createRequest() {
-    return new Request();
+  private Request createRequest(boolean dbinitMigration) {
+    return new Request(dbinitMigration);
   }
 
   private class Request {
 
+    final boolean dbinitMigration;
     final File migrationDir;
     final File modelDir;
-    final MigrationModel migrationModel;
     final CurrentModel currentModel;
     final ModelContainer migrated;
     final ModelContainer current;
 
-    private Request() {
-      this.migrationDir = getMigrationDirectory();
-      this.modelDir = getModelDirectory(migrationDir);
-      this.migrationModel = new MigrationModel(modelDir, migrationConfig.getModelSuffix());
-      this.migrated = migrationModel.read();
+    private Request(boolean dbinitMigration) {
+      this.dbinitMigration = dbinitMigration;
       this.currentModel = new CurrentModel(server, constraintNaming);
       this.current = currentModel.read();
+      this.migrationDir = getMigrationDirectory(dbinitMigration);
+      if (dbinitMigration) {
+        this.modelDir = null;
+        this.migrated = new ModelContainer();
+      } else {
+        this.modelDir = getModelDirectory(migrationDir);
+        MigrationModel migrationModel = new MigrationModel(modelDir, migrationConfig.getModelSuffix());
+        this.migrated = migrationModel.read(dbinitMigration);
+      }
     }
 
     boolean isTablePartitioning() {
       return current.isTablePartitioning();
     }
 
+    /**
+     * Return the next migration version (based on existing migration versions).
+     */
+    String nextVersion() {
+      // always read the next version using the main migration directory (not dbinit)
+      File migDirectory = getMigrationDirectory(false);
+      File modelDir = getModelDirectory(migDirectory);
+      return LastMigration.nextVersion(migDirectory, modelDir, dbinitMigration);
+    }
+
     /**
      * Return the migration for the pending drops for a given version.
      */
-    public Migration migrationForPendingDrop(String pendingVersion) {
+    Migration migrationForPendingDrop(String pendingVersion) {
 
       Migration migration = migrated.migrationForPendingDrop(pendingVersion);
 
@@ -481,7 +539,7 @@ public class DefaultDbMigration implements DbMigration {
     /**
      * Create and return the diff of the current model to the migration model.
      */
-    public Migration createDiffMigration() {
+    Migration createDiffMigration() {
       ModelDiff diff = new ModelDiff(migrated);
       diff.compareTo(current);
       return diff.isEmpty() ? null : diff.getMigration();
@@ -490,11 +548,11 @@ public class DefaultDbMigration implements DbMigration {
 
   private String generateMigration(Request request, Migration dbMigration, String dropsFor) throws IOException {
 
-    String fullVersion = getFullVersion(request.migrationModel, dropsFor);
+    String fullVersion = getFullVersion(request.nextVersion(), dropsFor);
 
-    logger.info("generating migration:{}", fullVersion);
-    if (!writeMigrationXml(dbMigration, request.modelDir, fullVersion)) {
-      logger.warn("migration already exists, not generating DDL");
+    logInfo("generating migration:%s", fullVersion);
+    if (!request.dbinitMigration && !writeMigrationXml(dbMigration, request.modelDir, fullVersion)) {
+      logError("migration already exists, not generating DDL");
       return null;
     } else {
       if (!platforms.isEmpty()) {
@@ -528,11 +586,11 @@ public class DefaultDbMigration implements DbMigration {
    * <p>
    * The full version can contain a comment suffix after a "__" double underscore.
    */
-  private String getFullVersion(MigrationModel migrationModel, String dropsFor) {
+  private String getFullVersion(String nextVersion, String dropsFor) {
 
     String version = getVersion();
     if (version == null) {
-      version = migrationModel.getNextVersion(initialVersion);
+      version = (nextVersion != null) ? nextVersion : initialVersion;
     }
 
     String fullVersion = migrationConfig.getApplyPrefix() + version;
@@ -559,7 +617,7 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Write any extra platform ddl.
    */
-  protected void writeExtraPlatformDdl(String fullVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
+  private void writeExtraPlatformDdl(String fullVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
 
     for (Pair pair : platforms) {
       DdlWrite platformBuffer = new DdlWrite(new MConfiguration(), currentModel.read());
@@ -576,7 +634,7 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Write the migration xml.
    */
-  protected boolean writeMigrationXml(Migration dbMigration, File resourcePath, String fullVersion) {
+  private boolean writeMigrationXml(Migration dbMigration, File resourcePath, String fullVersion) {
 
     String modelFile = fullVersion + migrationConfig.getModelSuffix();
     File file = new File(resourcePath, modelFile);
@@ -592,14 +650,13 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Set default server and platform if necessary.
    */
-  protected void setDefaults() {
+  private void setDefaults() {
     if (server == null) {
       setServer(Ebean.getDefaultServer());
     }
     if (vanillaPlatform || databasePlatform == null) {
       // not explicitly set so use the platform of the server
       databasePlatform = server.getDatabasePlatform();
-      logger.trace("set platform to {}", databasePlatform.getName());
     }
     if (migrationConfig != null) {
       if (strictMode != null) {
@@ -671,20 +728,31 @@ public class DefaultDbMigration implements DbMigration {
     return val;
   }
 
+  /**
+   * Return the main migration directory.
+   */
+  File getMigrationDirectory() {
+    return getMigrationDirectory(false);
+  }
+
   /**
    * Return the file path to write the xml and sql to.
    */
-  protected File getMigrationDirectory() {
+  File getMigrationDirectory(boolean dbinitMigration) {
 
     // path to src/main/resources in typical maven project
     File resourceRootDir = new File(pathToResources);
-    String resourcePath = migrationConfig.getMigrationPath();
+    if (!resourceRootDir.exists()) {
+      String msg = String.format("Error - path to resources %s does not exist. Absolute path is %s", pathToResources, resourceRootDir.getAbsolutePath());
+      throw new UnknownResourcePathException(msg);
+    }
+    String resourcePath = migrationConfig.getMigrationPath(dbinitMigration);
 
     // expect to be a path to something like - src/main/resources/dbmigration/model
     File path = new File(resourceRootDir, resourcePath);
     if (!path.exists()) {
       if (!path.mkdirs()) {
-        logger.debug("Unable to ensure migration directory exists at {}", path.getAbsolutePath());
+        logInfo("Warning - Unable to ensure migration directory exists at %s", path.getAbsolutePath());
       }
     }
     return path;
@@ -693,14 +761,14 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Return the model directory (relative to the migration directory).
    */
-  protected File getModelDirectory(File migrationDirectory) {
+  private File getModelDirectory(File migrationDirectory) {
     String modelPath = migrationConfig.getModelPath();
     if (modelPath == null || modelPath.isEmpty()) {
       return migrationDirectory;
     }
     File modelDir = new File(migrationDirectory, migrationConfig.getModelPath());
     if (!modelDir.exists() && !modelDir.mkdirs()) {
-      logger.debug("Unable to ensure migration model directory exists at {}", modelDir.getAbsolutePath());
+      logInfo("Warning - Unable to ensure migration model directory exists at %s", modelDir.getAbsolutePath());
     }
     return modelDir;
   }
@@ -746,19 +814,19 @@ public class DefaultDbMigration implements DbMigration {
    * Holds a platform and prefix. Used to generate multiple platform specific DDL
    * for a single migration.
    */
-  public static class Pair {
+  static class Pair {
 
     /**
      * The platform to generate the DDL for.
      */
-    public final DatabasePlatform platform;
+    final DatabasePlatform platform;
 
     /**
      * A prefix included into the file/resource names indicating the platform.
      */
-    public final String prefix;
+    final String prefix;
 
-    public Pair(DatabasePlatform platform, String prefix) {
+    Pair(DatabasePlatform platform, String prefix) {
       this.platform = platform;
       this.prefix = prefix;
     }

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

@@ -0,0 +1,82 @@
+package io.ebeaninternal.dbmigration;
+
+import io.ebeaninternal.dbmigration.model.MigrationVersion;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Utility to determine the last sql migration version and next version.
+ */
+class LastMigration {
+
+  private static final String SQL = ".sql";
+
+  private static final String MODEL_XML = ".model.xml";
+
+  /**
+   * Return the next migation version given the migration directory.
+   */
+  static String nextVersion(File migDir, File modelDir, boolean dbinitMigration) {
+
+    String last = lastVersion(migDir, modelDir);
+    if (last == null) {
+      return null;
+    }
+    return (dbinitMigration) ? last : MigrationVersion.parse(last).nextVersion();
+  }
+
+  /**
+   * Return the last migation version given the migration directory.
+   */
+  static String lastVersion(File migDirectory, File modelDir) {
+
+    List<MigrationVersion> versions = new ArrayList<>();
+
+    File[] sqlFiles = migDirectory.listFiles(pathname -> includeSqlFile(pathname.getName().toLowerCase()));
+    if (sqlFiles != null) {
+      for (File file : sqlFiles) {
+        versions.add(trimAndParse(file.getName()));
+      }
+    }
+
+    if (modelDir != null) {
+      File[] xmlFiles = modelDir.listFiles(pathname -> includeModelFile(pathname.getName().toLowerCase()));
+      if (xmlFiles != null) {
+        for (File file : xmlFiles) {
+          versions.add(trimAndParse(file.getName()));
+        }
+      }
+    }
+
+    Collections.sort(versions);
+    if (!versions.isEmpty()) {
+      return versions.get(versions.size() - 1).asString();
+    }
+    return null;
+  }
+
+  private static boolean includeSqlFile(String lowerFileName) {
+    if (lowerFileName.startsWith("r") || lowerFileName.startsWith("i") || !lowerFileName.endsWith(SQL)) {
+      return false;
+    }
+    return true;
+  }
+
+  private static boolean includeModelFile(String lowerFileName) {
+    return lowerFileName.endsWith(MODEL_XML);
+  }
+
+  private static MigrationVersion trimAndParse(String name) {
+    if (name.endsWith(SQL)) {
+      name = name.substring(0, name.length() - 4);
+    }
+    if (name.endsWith(MODEL_XML)) {
+      name = name.substring(0, name.length() - 10);
+    }
+    return MigrationVersion.parse(name);
+  }
+
+}

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

@@ -0,0 +1,14 @@
+package io.ebeaninternal.dbmigration;
+
+/**
+ * Exception when db migration resource path does not exist.
+ * <p>
+ * Typically the working directory or pathToResources is incorrect.
+ * </p>
+ */
+public class UnknownResourcePathException extends RuntimeException {
+
+  public UnknownResourcePathException(String msg) {
+    super(msg);
+  }
+}

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

@@ -15,6 +15,8 @@ public class H2HistoryDdl extends DbTriggerBasedHistoryDdl {
   private static final String TRIGGER_CLASS = H2HistoryTrigger.class.getName();
 
   public H2HistoryDdl() {
+    this.sysPeriodType = "timestamp";
+    this.currentTimestamp = "now()";
   }
 
   @Override

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

@@ -1,10 +1,10 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
-import java.io.IOException;
-
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
 
+import java.io.IOException;
+
 public class HanaColumnStoreDdl extends AbstractHanaDdl {
 
   public HanaColumnStoreDdl(DatabasePlatform platform) {

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

@@ -1,8 +1,5 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
-import java.io.IOException;
-import java.util.List;
-
 import io.ebean.config.PropertiesWrapper;
 import io.ebean.config.ServerConfig;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
@@ -12,6 +9,9 @@ import io.ebeaninternal.dbmigration.migration.Column;
 import io.ebeaninternal.dbmigration.migration.DropColumn;
 import io.ebeaninternal.dbmigration.model.MTable;
 
+import java.io.IOException;
+import java.util.List;
+
 public class HanaTableDdl extends BaseTableDdl {
 
   private final HanaHistoryDdl historyDdl;

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

@@ -20,7 +20,6 @@ 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;
 
@@ -78,7 +77,7 @@ public class PlatformDdl {
   protected String dropIndexIfExists = "drop index if exists ";
 
   protected String alterColumn = "alter column";
-  
+
   protected String alterColumnSuffix = "";
 
   protected String dropUniqueConstraint = "drop constraint";
@@ -86,7 +85,7 @@ public class PlatformDdl {
   protected String addConstraint = "add constraint";
 
   protected String addColumn = "add column";
-  
+
   protected String addColumnSuffix = "";
 
   protected String columnSetType = "";
@@ -100,11 +99,11 @@ public class PlatformDdl {
   protected String columnSetNull = "set null";
 
   protected String updateNullWithDefault = "update ${table} set ${column} = ${default} where ${column} is null";
-  
+
   protected String createTable = "create table";
-  
+
   protected String dropColumn = "drop column";
-  
+
   protected String dropColumnSuffix = "";
 
   /**
@@ -674,12 +673,12 @@ public class PlatformDdl {
   public void unlockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
 
   }
-  
+
   /**
    * Returns the database-specific "create table" command prefix. For HANA this is
    * either "create column table" or "create row table", for all other databases
    * it is "create table".
-   * 
+   *
    * @return The "create table" command prefix
    */
   public String getCreateTableCommandPrefix() {

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

@@ -31,14 +31,16 @@ public class MigrationModel {
   /**
    * Read all the migrations returning the model with all
    * the migrations applied in version order.
+   *
+   * @param dbinitMigration If true we don't apply model changes, migration is from scratch.
    */
-  public ModelContainer read() {
+  public ModelContainer read(boolean dbinitMigration) {
 
-    readMigrations();
+    readMigrations(dbinitMigration);
     return model;
   }
 
-  private void readMigrations() {
+  private void readMigrations(boolean dbinitMigration) {
 
     // find all the migration xml files
     File[] xmlFiles = modelDirectory.listFiles(pathname -> pathname.getName().toLowerCase().endsWith(modelSuffix));
@@ -53,9 +55,11 @@ public class MigrationModel {
     // sort into version order before applying
     Collections.sort(resources);
 
-    for (MigrationResource migrationResource : resources) {
-      logger.debug("read {}", migrationResource);
-      model.apply(migrationResource.read(), migrationResource.getVersion());
+    if (!dbinitMigration) {
+      for (MigrationResource migrationResource : resources) {
+        logger.debug("read {}", migrationResource);
+        model.apply(migrationResource.read(), migrationResource.getVersion());
+      }
     }
 
     // remember the last version

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

@@ -147,7 +147,11 @@ public class ModelBuildPropertyVisitor extends BaseTablePropertyVisitor {
   @Override
   public void visitEmbeddedScalar(BeanProperty p, BeanPropertyAssocOne<?> embedded) {
 
-    visitScalar(p);
+    if (p instanceof BeanPropertyAssocOne) {
+      visitOneImported((BeanPropertyAssocOne)p);
+    } else {
+      visitScalar(p);
+    }
     if (embedded.isId()) {
       // compound primary key
       lastColumn.setPrimaryKey(true);

src/main/java/io/ebeaninternal/server/cache/CacheChangeBeanUpdate.java

@@ -10,14 +10,14 @@ import java.util.Map;
 class CacheChangeBeanUpdate implements CacheChange {
 
   private final BeanDescriptor<?> desc;
-  private final Object id;
+  private final String key;
   private final Map<String, Object> changes;
   private final boolean updateNaturalKey;
   private final long version;
 
-  CacheChangeBeanUpdate(BeanDescriptor<?> desc, Object id, Map<String, Object> changes, boolean updateNaturalKey, long version) {
+  CacheChangeBeanUpdate(BeanDescriptor<?> desc, String key, Map<String, Object> changes, boolean updateNaturalKey, long version) {
     this.desc = desc;
-    this.id = id;
+    this.key = key;
     this.changes = changes;
     this.updateNaturalKey = updateNaturalKey;
     this.version = version;
@@ -25,6 +25,6 @@ class CacheChangeBeanUpdate implements CacheChange {
 
   @Override
   public void apply() {
-    desc.cacheApplyBeanUpdate(id, changes, updateNaturalKey, version);
+    desc.cacheApplyBeanUpdate(key, changes, updateNaturalKey, version);
   }
 }

src/main/java/io/ebeaninternal/server/cache/CacheChangeNaturalKeyPut.java

@@ -8,17 +8,17 @@ import io.ebeaninternal.server.deploy.BeanDescriptor;
 class CacheChangeNaturalKeyPut implements CacheChange {
 
   private final BeanDescriptor<?> descriptor;
-  private final Object id;
-  private final Object newKey;
+  private final String key;
+  private final String newKey;
 
-  CacheChangeNaturalKeyPut(BeanDescriptor<?> descriptor, Object id, Object newKey) {
+  CacheChangeNaturalKeyPut(BeanDescriptor<?> descriptor, String key, String newKey) {
     this.descriptor = descriptor;
-    this.id = id;
+    this.key = key;
     this.newKey = newKey;
   }
 
   @Override
   public void apply() {
-    descriptor.cacheNaturalKeyPut(id, newKey);
+    descriptor.cacheNaturalKeyPut(key, newKey);
   }
 }

src/main/java/io/ebeaninternal/server/cache/CacheChangeSet.java

@@ -152,16 +152,16 @@ public class CacheChangeSet {
   /**
    * Update a bean entry.
    */
-  public <T> void addBeanUpdate(BeanDescriptor<T> desc, Object id, Map<String, Object> changes, boolean updateNaturalKey, long version) {
+  public <T> void addBeanUpdate(BeanDescriptor<T> desc, String key, Map<String, Object> changes, boolean updateNaturalKey, long version) {
     touchedTables.add(desc.getBaseTable());
-    entries.add(new CacheChangeBeanUpdate(desc, id, changes, updateNaturalKey, version));
+    entries.add(new CacheChangeBeanUpdate(desc, key, changes, updateNaturalKey, version));
   }
 
   /**
    * Update a natural key.
    */
-  public <T> void addNaturalKeyPut(BeanDescriptor<T> desc, Object id, Object val) {
-    entries.add(new CacheChangeNaturalKeyPut(desc, id, val));
+  public <T> void addNaturalKeyPut(BeanDescriptor<T> desc, String key, String val) {
+    entries.add(new CacheChangeNaturalKeyPut(desc, key, val));
   }
 
   /**

src/main/java/io/ebeaninternal/server/cache/DefaultCacheHolder.java

@@ -1,5 +1,6 @@
 package io.ebeaninternal.server.cache;
 
+import io.ebean.annotation.Cache;
 import io.ebean.annotation.CacheBeanTuning;
 import io.ebean.annotation.CacheQueryTuning;
 import io.ebean.cache.QueryCacheEntryValidate;
@@ -123,11 +124,15 @@ class DefaultCacheHolder {
   }
 
   private ServerCacheOptions getBeanOptions(Class<?> cls) {
+
+    Cache cache = cls.getAnnotation(Cache.class);
+    boolean nearCache = (cache != null && cache.nearCache());
+
     CacheBeanTuning tuning = cls.getAnnotation(CacheBeanTuning.class);
     if (tuning != null) {
-      return new ServerCacheOptions(tuning).applyDefaults(beanDefault);
+      return new ServerCacheOptions(nearCache, tuning).applyDefaults(beanDefault);
     }
-    return beanDefault.copy();
+    return beanDefault.copy(nearCache);
   }
 
 }

src/main/java/io/ebeaninternal/server/cluster/ClusterManager.java

@@ -29,7 +29,7 @@ public class ClusterManager implements ServerLookup {
 
   public ClusterManager(ContainerConfig config) {
     ClusterBroadcastFactory factory = createFactory();
-    if (factory != null) {
+    if (factory != null && config.isActive()) {
       broadcast = factory.create(this, config);
     } else {
       broadcast = null;

src/main/java/io/ebeaninternal/server/core/BasicTypeConverter.java

@@ -7,7 +7,6 @@ import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.sql.Timestamp;
 import java.sql.Types;
-import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;

src/main/java/io/ebeaninternal/server/core/DScriptRunner.java

@@ -4,6 +4,7 @@ import io.ebean.ScriptRunner;
 import io.ebean.migration.ddl.DdlRunner;
 import io.ebean.migration.runner.ScriptTransform;
 import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.util.UrlHelper;
 
 import javax.persistence.PersistenceException;
 import java.io.IOException;
@@ -63,7 +64,7 @@ class DScriptRunner implements ScriptRunner {
       throw new IllegalArgumentException("resource is null?");
     }
 
-    try (InputStream inputStream = resource.openStream()) {
+    try (InputStream inputStream = UrlHelper.openNoCache(resource)) {
       return readContent(new InputStreamReader(inputStream));
 
     } catch (IOException e) {

src/main/java/io/ebeaninternal/server/core/DefaultBackgroundExecutor.java

@@ -6,6 +6,8 @@ import io.ebeaninternal.server.lib.DaemonScheduleThreadPool;
 import org.slf4j.MDC;
 
 import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -64,6 +66,46 @@ public class DefaultBackgroundExecutor implements SpiBackgroundExecutor {
     }
   }
 
+  @Override
+  public ScheduledFuture<?> schedule(Runnable r, long delay, TimeUnit unit) {
+    final Map<String, String> map = MDC.getCopyOfContextMap();
+
+    if (map == null) {
+      return schedulePool.schedule(r, delay, unit);
+    } else {
+      return schedulePool.schedule(() -> {
+        MDC.setContextMap(map);
+        try {
+          r.run();
+        } finally {
+          MDC.clear();
+        }
+      }, delay, unit);
+    }
+  }
+
+  @Override
+  public <V> ScheduledFuture<V> schedule(Callable<V> c, long delay, TimeUnit unit) {
+    final Map<String, String> map = MDC.getCopyOfContextMap();
+
+    if (map == null) {
+      return schedulePool.schedule(c, delay, unit);
+    } else {
+      return schedulePool.schedule(new Callable<V>() {
+        @Override
+        public V call() throws Exception {
+          MDC.setContextMap(map);
+          try {
+            return c.call();
+          } finally {
+            MDC.clear();
+          }
+        }
+
+      }, delay, unit);
+    }
+  }
+
   @Override
   public void shutdown() {
     pool.shutdown();

src/main/java/io/ebeaninternal/server/core/DefaultBeanState.java

@@ -88,4 +88,10 @@ public class DefaultBeanState implements BeanState {
   public void resetForInsert() {
     intercept.setNew();
   }
+
+  @Override
+  public Map<String, Exception> getLoadErrors() {
+    return intercept.getLoadErrors();
+  }
+
 }

src/main/java/io/ebeaninternal/server/core/DefaultContainer.java

@@ -7,6 +7,10 @@ import io.ebean.config.TenantMode;
 import io.ebean.config.UnderscoreNamingConvention;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.h2.H2Platform;
+import io.ebean.datasource.DataSourceAlertFactory;
+import io.ebean.datasource.DataSourceConfig;
+import io.ebean.datasource.DataSourceFactory;
+import io.ebean.datasource.DataSourcePoolListener;
 import io.ebean.service.SpiContainer;
 import io.ebeaninternal.api.SpiBackgroundExecutor;
 import io.ebeaninternal.api.SpiEbeanServer;
@@ -15,10 +19,6 @@ import io.ebeaninternal.server.cluster.ClusterManager;
 import io.ebeaninternal.server.core.bootup.BootupClassPathSearch;
 import io.ebeaninternal.server.core.bootup.BootupClasses;
 import io.ebeaninternal.server.lib.ShutdownManager;
-import io.ebean.datasource.DataSourceAlertFactory;
-import io.ebean.datasource.DataSourceConfig;
-import io.ebean.datasource.DataSourceFactory;
-import io.ebean.datasource.DataSourcePoolListener;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -249,7 +249,7 @@ public class DefaultContainer implements SpiContainer {
       return null;
     }
 
-    DataSourceFactory factory = config.service(DataSourceFactory.class);
+    DataSourceFactory factory = DataSourceFactory.get();
     if (factory == null) {
       throw new IllegalStateException("No DataSourceFactory service implementation found in class path."
         + " Probably missing dependency to avaje-datasource?");

src/main/java/io/ebeaninternal/server/core/DefaultMetaInfoManager.java

@@ -6,8 +6,10 @@ import io.ebean.meta.MetaInfoManager;
 import io.ebean.meta.MetaOrmQueryMetric;
 import io.ebean.meta.MetaOrmQueryNode;
 import io.ebean.meta.MetaQueryMetric;
+import io.ebean.meta.MetaQueryPlan;
 import io.ebean.meta.MetaTimedMetric;
 import io.ebean.meta.MetricVisitor;
+import io.ebean.meta.QueryPlanRequest;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -23,6 +25,11 @@ public class DefaultMetaInfoManager implements MetaInfoManager {
     this.server = server;
   }
 
+  @Override
+  public List<MetaQueryPlan> collectQueryPlans(QueryPlanRequest request) {
+    return server.collectQueryPlans(request);
+  }
+
   @Override
   public void visitMetrics(MetricVisitor visitor) {
     server.visitMetrics(visitor);

src/main/java/io/ebeaninternal/server/core/DefaultServer.java

@@ -54,13 +54,16 @@ import io.ebean.event.BeanPersistController;
 import io.ebean.event.readaudit.ReadAuditLogger;
 import io.ebean.event.readaudit.ReadAuditPrepare;
 import io.ebean.meta.MetaInfoManager;
+import io.ebean.meta.MetaQueryPlan;
 import io.ebean.meta.MetricVisitor;
+import io.ebean.meta.QueryPlanRequest;
 import io.ebean.plugin.BeanType;
 import io.ebean.plugin.Plugin;
 import io.ebean.plugin.Property;
 import io.ebean.plugin.SpiServer;
 import io.ebean.text.csv.CsvReader;
 import io.ebean.text.json.JsonContext;
+import io.ebean.util.JdbcClose;
 import io.ebeaninternal.api.LoadBeanRequest;
 import io.ebeaninternal.api.LoadManyRequest;
 import io.ebeaninternal.api.ScopedTransaction;
@@ -120,6 +123,8 @@ import javax.persistence.NonUniqueResultException;
 import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
 import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
 import java.time.Clock;
 import java.util.Collection;
 import java.util.Collections;
@@ -1078,15 +1083,25 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
   }
 
   @Override
-  public SqlQuery createSqlQuery(String sql) {
+  public SqlQuery sqlQuery(String sql) {
     return new DefaultRelationalQuery(this, sql.trim());
   }
 
   @Override
-  public SqlUpdate createSqlUpdate(String sql) {
+  public SqlQuery createSqlQuery(String sql) {
+    return sqlQuery(sql);
+  }
+
+  @Override
+  public SqlUpdate sqlUpdate(String sql) {
     return new DefaultSqlUpdate(this, sql.trim());
   }
 
+  @Override
+  public SqlUpdate createSqlUpdate(String sql) {
+    return sqlUpdate(sql);
+  }
+
   @Override
   public CallableSql createCallableSql(String sql) {
     return new DefaultCallableSql(this, sql.trim());
@@ -1358,6 +1373,21 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     return !ids.isEmpty();
   }
 
+  @Override
+  public <T> boolean exists(SpiQuery<?> ormQuery, SpiTransaction transaction) {
+
+    ormQuery.setMaxRows(1);
+    SpiOrmQueryRequest<?> request = createQueryRequest(Type.ID_LIST, ormQuery, transaction);
+    try {
+      request.initTransIfRequired();
+      List<Object> ids = request.findIds();
+      return !ids.isEmpty();
+
+    } finally {
+      request.endTransIfRequired();
+    }
+  }
+
   @Override
   public <A, T> List<A> findIds(Query<T> query, Transaction t) {
 
@@ -1439,10 +1469,6 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     return queryFuture;
   }
 
-  public <T> FutureRowCount<T> findFutureRowCount(Query<T> q, Transaction t) {
-    return findFutureCount(q, t);
-  }
-
   @Override
   public <T> FutureIds<T> findFutureIds(Query<T> query, Transaction t) {
 
@@ -2335,10 +2361,8 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
 
   @Override
   public void slowQueryCheck(long timeMicros, int rowCount, SpiQuery<?> query) {
-    if (timeMicros > slowQueryMicros) {
-      if (slowQueryListener != null) {
-        slowQueryListener.process(new SlowQueryEvent(query.getGeneratedSql(), timeMicros / 1000L, rowCount, query.getParentNode()));
-      }
+    if (timeMicros > slowQueryMicros && slowQueryListener != null) {
+      slowQueryListener.process(new SlowQueryEvent(query.getGeneratedSql(), timeMicros / 1000L, rowCount, query.getParentNode()));
     }
   }
 
@@ -2425,4 +2449,19 @@ public final class DefaultServer implements SpiServer, SpiEbeanServer {
     }
     visitor.visitEnd();
   }
+
+  public List<MetaQueryPlan> collectQueryPlans(QueryPlanRequest request) {
+    Connection connection = null;
+    try {
+      connection = getDataSource().getConnection();
+      request.setConnection(connection);
+      beanDescriptorManager.collectQueryPlans(request);
+    } catch (SQLException e) {
+      throw new RuntimeException(e);
+
+    } finally {
+      JdbcClose.close(connection);
+    }
+    return request.getPlans();
+  }
 }

src/main/java/io/ebeaninternal/server/core/DefaultSqlUpdate.java

@@ -9,6 +9,7 @@ import io.ebeaninternal.api.SpiSqlUpdate;
 import io.ebeaninternal.api.SpiTransaction;
 
 import java.io.Serializable;
+import java.util.Collection;
 
 /**
  * A SQL Update Delete or Insert statement that can be executed. For the times
@@ -35,9 +36,14 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
   private final BindParams bindParams;
 
   /**
-   * The sql update or delete statement.
+   * The original sql update or delete statement.
    */
-  private final String sql;
+  private final String origSql;
+
+  /**
+   * The sql taking into account bind parameter expansion.
+   */
+  private String baseSql;
 
   /**
    * The actual sql with named parameters converted.
@@ -66,6 +72,8 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
    */
   private int addPos;
 
+  private int bindExpansion;
+
   private boolean getGeneratedKeys;
 
   private Object generatedKey;
@@ -89,7 +97,8 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
    */
   public DefaultSqlUpdate(SpiEbeanServer server, String sql, BindParams bindParams) {
     this.server = server;
-    this.sql = sql;
+    this.origSql = sql;
+    this.baseSql = sql;
     this.bindParams = bindParams;
   }
 
@@ -221,11 +230,21 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
   @Override
   public void setGeneratedSql(String generatedSql) {
     this.generatedSql = generatedSql;
+    this.baseSql = origSql;
+    if (bindExpansion > 0) {
+      bindParams.reset();
+      bindExpansion = 0;
+    }
   }
 
   @Override
   public String getSql() {
-    return sql;
+    return origSql;
+  }
+
+  @Override
+  public String getBaseSql() {
+    return baseSql;
   }
 
   @Override
@@ -239,27 +258,61 @@ public final class DefaultSqlUpdate implements Serializable, SpiSqlUpdate {
     return this;
   }
 
+  @Override
+  public SqlUpdate setParams(Object... values) {
+    for (Object value : values) {
+      setParameter(++addPos, value);
+    }
+    return this;
+  }
+
   @Override
   public SqlUpdate setNextParameter(Object value) {
     setParameter(++addPos, value);
     return this;
   }
 
+  private SqlUpdate setParamWithBindExpansion(int position, Collection values, String bindLiteral) {
+
+    StringBuilder sqlExpand = new StringBuilder(values.size() * 2);
+    position = position + bindExpansion;
+    int offset = 0;
+    for (Object val : values) {
+      if (offset > 0) {
+        sqlExpand.append(",");
+      }
+      sqlExpand.append("?");
+      bindParams.setParameter(position + offset++, val);
+    }
+    bindExpansion += (offset - 1);
+    baseSql = baseSql.replace(bindLiteral, sqlExpand.toString());
+    return this;
+  }
+
   @Override
   public SqlUpdate setParameter(int position, Object value) {
-    bindParams.setParameter(position, value);
+
+    if (value instanceof Collection) {
+      String bindLiteral = "?" + position;
+      int pos = baseSql.indexOf(bindLiteral);
+      if (pos > -1) {
+        return setParamWithBindExpansion(position, (Collection) value, bindLiteral);
+      }
+    }
+
+    bindParams.setParameter(bindExpansion + position, value);
     return this;
   }
 
   @Override
   public SqlUpdate setNull(int position, int jdbcType) {
-    bindParams.setNullParameter(position, jdbcType);
+    bindParams.setNullParameter(bindExpansion + position, jdbcType);
     return this;
   }
 
   @Override
   public SqlUpdate setNullParameter(int position, int jdbcType) {
-    bindParams.setNullParameter(position, jdbcType);
+    bindParams.setNullParameter(bindExpansion + position, jdbcType);
     return this;
   }
 

src/main/java/io/ebeaninternal/server/core/InternalConfiguration.java

@@ -15,6 +15,7 @@ import io.ebean.config.ServerConfig;
 import io.ebean.config.SlowQueryListener;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.DbHistorySupport;
+import io.ebean.datasource.DataSourcePool;
 import io.ebean.event.changelog.ChangeLogListener;
 import io.ebean.event.changelog.ChangeLogPrepare;
 import io.ebean.event.changelog.ChangeLogRegister;
@@ -87,7 +88,6 @@ import io.ebeanservice.docstore.api.DocStoreFactory;
 import io.ebeanservice.docstore.api.DocStoreIntegration;
 import io.ebeanservice.docstore.api.DocStoreUpdateProcessor;
 import io.ebeanservice.docstore.none.NoneDocStoreFactory;
-import io.ebean.datasource.DataSourcePool;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

src/main/java/io/ebeaninternal/server/core/MultiTenantDbCatalogSupplier.java

@@ -2,8 +2,8 @@ package io.ebeaninternal.server.core;
 
 import io.ebean.config.CurrentTenantProvider;
 import io.ebean.config.TenantCatalogProvider;
-import io.ebeaninternal.server.transaction.DataSourceSupplier;
 import io.ebean.datasource.DataSourcePool;
+import io.ebeaninternal.server.transaction.DataSourceSupplier;
 
 import javax.sql.DataSource;
 import java.io.PrintWriter;

src/main/java/io/ebeaninternal/server/core/MultiTenantDbSchemaSupplier.java

@@ -2,8 +2,8 @@ package io.ebeaninternal.server.core;
 
 import io.ebean.config.CurrentTenantProvider;
 import io.ebean.config.TenantSchemaProvider;
-import io.ebeaninternal.server.transaction.DataSourceSupplier;
 import io.ebean.datasource.DataSourcePool;
+import io.ebeaninternal.server.transaction.DataSourceSupplier;
 
 import javax.sql.DataSource;
 import java.io.PrintWriter;

src/main/java/io/ebeaninternal/server/core/OrmQueryRequest.java

@@ -118,7 +118,14 @@ public final class OrmQueryRequest<T> extends BeanRequest implements SpiOrmQuery
 
   @Override
   public boolean isDeleteByStatement() {
-    return beanDescriptor.isDeleteByStatement();
+    if (!transaction.isPersistCascade() || beanDescriptor.isDeleteByStatement()) {
+      // plain delete by query
+      return true;
+    } else {
+      // delete by ids due to cascading delete needs
+      queryPlanKey = query.setDeleteByIdsPlan();
+      return false;
+    }
   }
 
   @Override

src/main/java/io/ebeaninternal/server/core/PersistRequestBean.java

@@ -27,6 +27,7 @@ import io.ebeaninternal.server.persist.BatchedSqlException;
 import io.ebeaninternal.server.persist.DeleteMode;
 import io.ebeaninternal.server.persist.Flags;
 import io.ebeaninternal.server.persist.PersistExecute;
+import io.ebeaninternal.server.persist.SaveManyBeans;
 import io.ebeaninternal.server.transaction.BeanPersistIdMap;
 import io.ebeanservice.docstore.api.DocStoreUpdate;
 import io.ebeanservice.docstore.api.DocStoreUpdateContext;
@@ -174,7 +175,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   private int pendingPostUpdateNotify;
 
   /**
-   * Set to true when post execute has occured (so includes batch flush).
+   * Set to true when post execute has occurred (so includes batch flush).
    */
   private boolean postExecute;
 
@@ -183,6 +184,11 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
    */
   private boolean complete;
 
+  /**
+   * Many to many intersection table changes that are held for later batch processing.
+   */
+  private List<SaveManyBeans> saveManyIntersections;
+
   public PersistRequestBean(SpiEbeanServer server, T bean, Object parentBean, BeanManager<T> mgr, SpiTransaction t,
                             PersistExecute persistExecute, PersistRequest.Type type, int flags) {
 
@@ -955,6 +961,13 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
     if (isLogSummary()) {
       logSummary();
     }
+    saveQueuedManyIntersection();
+  }
+
+  private void saveQueuedManyIntersection() {
+    if (saveManyIntersections != null) {
+      saveManyIntersections.forEach(SaveManyBeans::saveIntersectionBatch);
+    }
   }
 
   /**
@@ -1119,6 +1132,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
       updatedManysOnly = true;
       setNotifyCache();
       addPostCommitListeners();
+      saveQueuedManyIntersection();
     }
     notifyCacheOnComplete();
     postUpdateNotify();
@@ -1405,6 +1419,8 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
 
       boolean updateNaturalKey = false;
 
+      String key = beanDescriptor.cacheKey(idValue);
+
       Map<String, Object> changes = new LinkedHashMap<>();
       EntityBean bean = getEntityBean();
       boolean[] dirtyProperties = getDirtyProperties();
@@ -1417,7 +1433,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
               changes.put(property.getName(), val);
               if (property.isNaturalKey()) {
                 updateNaturalKey = true;
-                changeSet.addNaturalKeyPut(beanDescriptor, idValue, val);
+                changeSet.addNaturalKeyPut(beanDescriptor, key, val.toString());
               }
             }
           }
@@ -1428,7 +1444,7 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
         changes.putAll(collectionChanges);
       }
 
-      changeSet.addBeanUpdate(beanDescriptor, idValue, changes, updateNaturalKey, getVersion());
+      changeSet.addBeanUpdate(beanDescriptor, key, changes, updateNaturalKey, getVersion());
     }
   }
 
@@ -1452,4 +1468,21 @@ public final class PersistRequestBean<T> extends PersistRequest implements BeanP
   public String getSelectLastInsertedId() {
     return beanDescriptor.getSelectLastInsertedId(publish);
   }
+
+  /**
+   * Return true if the intersection table updates should be queued and batched.
+   */
+  public boolean isQueueManyIntersection() {
+    return !postExecute;
+  }
+
+  /**
+   * The intersection table updates to the batch executed later on postExecute.
+   */
+  public void addManyIntersection(SaveManyBeans saveManyIntersection) {
+    if (this.saveManyIntersections == null) {
+      this.saveManyIntersections = new ArrayList<>();
+    }
+    this.saveManyIntersections.add(saveManyIntersection);
+  }
 }

src/main/java/io/ebeaninternal/server/core/PersistRequestUpdateSql.java

@@ -3,7 +3,10 @@ package io.ebeaninternal.server.core;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.api.SpiSqlUpdate;
 import io.ebeaninternal.api.SpiTransaction;
+import io.ebeaninternal.server.lib.util.Str;
+import io.ebeaninternal.server.persist.BatchControl;
 import io.ebeaninternal.server.persist.PersistExecute;
+import io.ebeaninternal.server.persist.TrimLogSql;
 
 /**
  * Persist request specifically for CallableSql.
@@ -24,12 +27,12 @@ public final class PersistRequestUpdateSql extends PersistRequest {
 
   private String tableName;
 
-  private String description;
-
   private boolean addBatch;
 
   private boolean forceNoBatch;
 
+  private boolean batchThisRequest;
+
   public PersistRequestUpdateSql(SpiEbeanServer server, SpiSqlUpdate sqlUpdate,
                                  SpiTransaction t, PersistExecute persistExecute, boolean forceNoBatch) {
 
@@ -58,6 +61,25 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     return executeOrQueue();
   }
 
+  /**
+   * Execute using jdbc batch.
+   */
+  public void executeAddBatch() {
+    this.addBatch = true;
+    persistExecute.executeSqlUpdate(this);
+  }
+
+  /**
+   * Add this request to BatchControl to flush later.
+   */
+  public void addToFlushQueue(boolean early) {
+    BatchControl control = transaction.getBatchControl();
+    if (control == null) {
+      control = persistExecute.createBatchControl(transaction);
+    }
+    control.addToFlushQueue(this, early);
+  }
+
   @Override
   public int executeNow() {
     return persistExecute.executeSqlUpdate(this);
@@ -104,10 +126,9 @@ public final class PersistRequestUpdateSql extends PersistRequest {
    * Specify the type of statement executed. Used to automatically register
    * with the transaction event.
    */
-  public void setType(SqlType sqlType, String tableName, String description) {
+  public void setType(SqlType sqlType, String tableName) {
     this.sqlType = sqlType;
     this.tableName = tableName;
-    this.description = description;
   }
 
   /**
@@ -117,6 +138,20 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     this.bindLog = bindLog;
   }
 
+  public void startBind(boolean batchThisRequest) {
+    this.batchThisRequest = batchThisRequest;
+    super.startBind(batchThisRequest);
+  }
+
+  /**
+   * Log the sql bind used with jdbc batch.
+   */
+  public void logSqlBatchBind() {
+    if (transaction.isLogSql()) {
+      transaction.logSql(Str.add(" -- bind(", bindLog, ")"));
+    }
+  }
+
   /**
    * Perform post execute processing.
    */
@@ -125,9 +160,8 @@ public final class PersistRequestUpdateSql extends PersistRequest {
     if (startNanos > 0) {
       persistExecute.collectSqlUpdate(label, startNanos, rowCount);
     }
-    if (transaction.isLogSummary()) {
-      String m = description + " table[" + tableName + "] rows[" + rowCount + "] bind[" + bindLog + "]";
-      transaction.logSummary(m);
+    if (transaction.isLogSql() && !batchThisRequest) {
+      transaction.logSql(Str.add(TrimLogSql.trim(updateSql.getGeneratedSql()), "; -- bind(", bindLog, ") rows(", String.valueOf(rowCount), ")"));
     }
 
     if (updateSql.isAutoTableMod()) {

src/main/java/io/ebeaninternal/server/core/Persister.java

@@ -103,6 +103,11 @@ public interface Persister {
    */
   void visitMetrics(MetricVisitor visitor);
 
+  /**
+   * Execute or queue the update.
+   */
+  void executeOrQueue(SpiSqlUpdate update, SpiTransaction t, boolean queue);
+
   /**
    * Add the statement to JDBC batch for later execution via executeBatch.
    */

src/main/java/io/ebeaninternal/server/core/ServletContextListener.java

@@ -1,35 +0,0 @@
-package io.ebeaninternal.server.core;
-
-import io.ebeaninternal.server.lib.ShutdownManager;
-
-import javax.servlet.ServletContextEvent;
-
-/**
- * Deprecated - migrate to io.ebean.event.ServletContextListener.
- * <p>
- * Listens for webserver server starting and stopping events.
- * <p>
- * Register this listener in the web.xml configuration file. This will listen
- * for startup and shutdown events.
- * </p>
- */
-@Deprecated
-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/ebeaninternal/server/core/SimpleDataSourceProvider.java

@@ -1,7 +1,7 @@
 package io.ebeaninternal.server.core;
 
-import io.ebeaninternal.server.transaction.DataSourceSupplier;
 import io.ebean.datasource.DataSourcePool;
+import io.ebeaninternal.server.transaction.DataSourceSupplier;
 
 import javax.sql.DataSource;
 import java.sql.Connection;

src/main/java/io/ebeaninternal/server/core/bootup/ManifestReader.java

@@ -1,6 +1,7 @@
 package io.ebeaninternal.server.core.bootup;
 
 import io.ebean.util.StringHelper;
+import io.ebeaninternal.util.UrlHelper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -59,7 +60,7 @@ class ManifestReader {
     try {
       Enumeration<URL> resources = classLoader.getResources(resourcePath);
       while (resources.hasMoreElements()) {
-        try (InputStream is = resources.nextElement().openStream()) {
+        try (InputStream is = UrlHelper.openNoCache(resources.nextElement())) {
           read(new Manifest(is));
         }
       }

src/main/java/io/ebeaninternal/server/deploy/AssocOneHelp.java

@@ -3,6 +3,7 @@ package io.ebeaninternal.server.deploy;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.PersistenceContext;
 import io.ebeaninternal.server.query.SqlJoinType;
+import io.ebeaninternal.server.type.DataReader;
 
 import java.sql.SQLException;
 
@@ -16,9 +17,16 @@ abstract class AssocOneHelp {
 
   protected final BeanDescriptor<?> target;
 
+  private final String path;
+
   AssocOneHelp(BeanPropertyAssocOne<?> property) {
+    this(property, null);
+  }
+
+  AssocOneHelp(BeanPropertyAssocOne<?> property, String embeddedPrefix) {
     this.property = property;
     this.target = property.targetDescriptor;
+    this.path = (embeddedPrefix == null) ? property.name : embeddedPrefix + "." + property.name;
   }
 
   /**
@@ -28,6 +36,24 @@ abstract class AssocOneHelp {
     property.targetIdBinder.loadIgnore(ctx);
   }
 
+  /**
+   * Read and return the property.
+   */
+  Object read(DataReader reader) throws SQLException {
+    return property.read(reader);
+  }
+
+  /**
+   * Read and return the property setting value into the bean.
+   */
+  Object readSet(DataReader reader, EntityBean bean) throws SQLException {
+    Object val = read(reader);
+    if (bean != null) {
+      property.setValue(bean, val);
+    }
+    return val;
+  }
+
   /**
    * Read and return the bean.
    */
@@ -48,7 +74,7 @@ abstract class AssocOneHelp {
     boolean disableLazyLoading = ctx.isDisableLazyLoading();
     Object ref = target.contextRef(pc, ctx.isReadOnly(), disableLazyLoading, id);
     if (!disableLazyLoading) {
-      ctx.register(property.name, ((EntityBean) ref)._ebean_getIntercept());
+      ctx.register(path, ((EntityBean) ref)._ebean_getIntercept());
     }
     return ref;
   }

src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpEmbedded.java

@@ -1,6 +1,7 @@
 package io.ebeaninternal.server.deploy;
 
 import io.ebean.bean.EntityBean;
+import io.ebeaninternal.server.type.DataReader;
 
 import java.sql.SQLException;
 
@@ -9,14 +10,41 @@ import java.sql.SQLException;
  */
 final class AssocOneHelpEmbedded extends AssocOneHelp {
 
-  public AssocOneHelpEmbedded(BeanPropertyAssocOne<?> property) {
+  AssocOneHelpEmbedded(BeanPropertyAssocOne<?> property) {
     super(property);
   }
 
   @Override
   void loadIgnore(DbReadContext ctx) {
-    for (int i = 0; i < property.embeddedProps.length; i++) {
-      property.embeddedProps[i].loadIgnore(ctx);
+    for (BeanProperty property : property.embeddedProps) {
+      property.loadIgnore(ctx);
+    }
+  }
+
+  @Override
+  Object readSet(DataReader reader, EntityBean bean) throws SQLException {
+    Object dbVal = read(reader);
+    if (bean != null) {
+      property.setValue(bean, dbVal);
+    }
+    return dbVal;
+  }
+
+  @Override
+  Object read(DataReader reader) throws SQLException {
+
+    EntityBean embeddedBean = property.targetDescriptor.createEntityBean();
+    boolean notNull = false;
+    for (BeanProperty property : property.embeddedProps) {
+      Object value = property.readSet(reader, embeddedBean);
+      if (value != null) {
+        notNull = true;
+      }
+    }
+    if (notNull) {
+      return embeddedBean;
+    } else {
+      return null;
     }
   }
 
@@ -39,8 +67,8 @@ final class AssocOneHelpEmbedded extends AssocOneHelp {
     EntityBean embeddedBean = property.targetDescriptor.createEntityBean();
 
     boolean notNull = false;
-    for (int i = 0; i < property.embeddedProps.length; i++) {
-      Object value = property.embeddedProps[i].readSet(ctx, embeddedBean);
+    for (BeanProperty property : property.embeddedProps) {
+      Object value = property.readSet(ctx, embeddedBean);
       if (value != null) {
         notNull = true;
       }
@@ -55,8 +83,8 @@ final class AssocOneHelpEmbedded extends AssocOneHelp {
 
   @Override
   void appendSelect(DbSqlContext ctx, boolean subQuery) {
-    for (int i = 0; i < property.embeddedProps.length; i++) {
-      property.embeddedProps[i].appendSelect(ctx, subQuery);
+    for (BeanProperty property : property.embeddedProps) {
+      property.appendSelect(ctx, subQuery);
     }
   }
 }

src/main/java/io/ebeaninternal/server/deploy/AssocOneHelpRefSimple.java

@@ -5,8 +5,8 @@ package io.ebeaninternal.server.deploy;
  */
 class AssocOneHelpRefSimple extends AssocOneHelp {
 
-  AssocOneHelpRefSimple(BeanPropertyAssocOne<?> property) {
-    super(property);
+  AssocOneHelpRefSimple(BeanPropertyAssocOne<?> property, String embeddedPrefix) {
+    super(property, embeddedPrefix);
   }
 
   /**

src/main/java/io/ebeaninternal/server/deploy/BeanCollectionHelpFactory.java

@@ -2,6 +2,8 @@ package io.ebeaninternal.server.deploy;
 
 import io.ebeaninternal.api.SpiQuery;
 import io.ebeaninternal.server.core.OrmQueryRequest;
+import io.ebeaninternal.server.el.ElPropertyValue;
+import io.ebeaninternal.server.query.CQueryCollectionAdd;
 
 
 /**
@@ -10,10 +12,10 @@ import io.ebeaninternal.server.core.OrmQueryRequest;
 public class BeanCollectionHelpFactory {
 
   @SuppressWarnings("rawtypes")
-  static final BeanListHelp LIST_HELP = new BeanListHelp();
+  private static final BeanListHelp LIST_HELP = new BeanListHelp();
 
   @SuppressWarnings("rawtypes")
-  static final BeanSetHelp SET_HELP = new BeanSetHelp();
+  private static final BeanSetHelp SET_HELP = new BeanSetHelp();
 
   /**
    * Create the helper based on the many property.
@@ -36,7 +38,7 @@ public class BeanCollectionHelpFactory {
   }
 
   @SuppressWarnings("unchecked")
-  public static <T> BeanCollectionHelp<T> create(SpiQuery.Type manyType, OrmQueryRequest<T> request) {
+  public static <T> CQueryCollectionAdd<T> create(SpiQuery.Type manyType, OrmQueryRequest<T> request) {
 
     if (manyType == SpiQuery.Type.LIST) {
       return LIST_HELP;
@@ -44,10 +46,13 @@ public class BeanCollectionHelpFactory {
     } else if (manyType == SpiQuery.Type.SET) {
       return SET_HELP;
 
-    } else {
+    } else if (manyType == SpiQuery.Type.MAP) {
       BeanDescriptor<T> target = request.getBeanDescriptor();
-      String mapKey = request.getQuery().getMapKey();
-      return new BeanMapHelp<>(target, mapKey);
+      ElPropertyValue elProperty = target.getElGetValue(request.getQuery().getMapKey());
+      return new BeanMapQueryHelp<>(elProperty);
+
+    } else {
+      return null;
     }
   }
 

src/main/java/io/ebeaninternal/server/deploy/BeanDescriptor.java

@@ -7,7 +7,6 @@ import io.ebean.SqlUpdate;
 import io.ebean.Transaction;
 import io.ebean.ValuePair;
 import io.ebean.annotation.DocStoreMode;
-import io.ebean.annotation.Formula;
 import io.ebean.bean.BeanCollection;
 import io.ebean.bean.EntityBean;
 import io.ebean.bean.EntityBeanIntercept;
@@ -30,6 +29,7 @@ import io.ebean.event.readaudit.ReadAuditLogger;
 import io.ebean.event.readaudit.ReadAuditPrepare;
 import io.ebean.event.readaudit.ReadEvent;
 import io.ebean.meta.MetricVisitor;
+import io.ebean.meta.QueryPlanRequest;
 import io.ebean.plugin.BeanDocType;
 import io.ebean.plugin.BeanType;
 import io.ebean.plugin.ExpressionPath;
@@ -724,16 +724,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
       inheritInfo.setDescriptor(this);
     }
 
-    if (isEmbedded()) {
-      // initialise all the properties
-      for (BeanProperty prop : propertiesAll()) {
-        prop.initialise(initContext);
-      }
-    } else {
-      // initialise just the Id properties
-      if (idProperty != null) {
-        idProperty.initialise(initContext);
-      }
+    // initialise just the Id property only
+    if (idProperty != null) {
+      idProperty.initialise(initContext);
     }
   }
 
@@ -759,14 +752,12 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
       }
     }
 
-    if (!isEmbedded()) {
-      // initialise all the non-id properties
-      for (BeanProperty prop : propertiesAll()) {
-        if (!prop.isId()) {
-          prop.initialise(initContext);
-        }
-        prop.registerColumn(this, null);
+    // initialise all the non-id properties
+    for (BeanProperty prop : propertiesAll()) {
+      if (!prop.isId()) {
+        prop.initialise(initContext);
       }
+      prop.registerColumn(this, null);
     }
 
     if (unidirectional != null) {
@@ -1487,30 +1478,33 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
    * Return a bean from the bean cache (or null).
    */
   public T cacheBeanGet(Object id, Boolean readOnly, PersistenceContext context) {
-    return cacheHelp.beanCacheGet(id, readOnly, context);
+    return cacheHelp.beanCacheGet(cacheKey(id), readOnly, context);
   }
 
   /**
    * Remove a collection of beans from the cache given the ids.
    */
   public void cacheApplyInvalidate(Collection<Object> ids) {
-    cacheHelp.beanCacheApplyInvalidate(ids);
+    List<String> keys = new ArrayList<>(ids.size());
+    for (Object id : ids) {
+      keys.add(cacheKey(id));
+    }
+    cacheHelp.beanCacheApplyInvalidate(keys);
+  }
+
+  /**
+   * Hit the bean cache trying to load a list/batch of entities.
+   * Return the set of entities that were successfully loaded from L2 cache.
+   */
+  public Set<EntityBeanIntercept> cacheBeanLoadAll(List<EntityBeanIntercept> list, PersistenceContext persistenceContext, int lazyLoadProperty, String propertyName) {
+    return cacheHelp.beanCacheLoadAll(list, persistenceContext, lazyLoadProperty, propertyName);
   }
 
   /**
    * Returns true if it managed to populate/load the bean from the cache.
    */
   public boolean cacheBeanLoad(EntityBean bean, EntityBeanIntercept ebi, Object id, PersistenceContext context) {
-    return cacheHelp.beanCacheLoad(bean, ebi, id, context);
-  }
-
-  /**
-   * Returns true if it managed to populate/load the bean from the cache.
-   */
-  public boolean cacheBeanLoad(EntityBeanIntercept ebi, PersistenceContext context) {
-    EntityBean bean = ebi.getOwner();
-    Object id = getId(bean);
-    return cacheBeanLoad(bean, ebi, id, context);
+    return cacheHelp.beanCacheLoad(bean, ebi, cacheKey(id), context);
   }
 
   /**
@@ -1520,8 +1514,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
     return cacheHelp.naturalKeyLookup(context, keys);
   }
 
-  public void cacheNaturalKeyPut(Object id, Object newKey) {
-    cacheHelp.cacheNaturalKeyPut(id, newKey);
+  public void cacheNaturalKeyPut(String key, String newKey) {
+    cacheHelp.cacheNaturalKeyPut(key, newKey);
   }
 
   /**
@@ -1569,8 +1563,8 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
   /**
    * Apply the update to the cache.
    */
-  public void cacheApplyBeanUpdate(Object id, Map<String, Object> changes, boolean updateNaturalKey, long version) {
-    cacheHelp.cacheBeanUpdate(id, changes, updateNaturalKey, version);
+  public void cacheApplyBeanUpdate(String key, Map<String, Object> changes, boolean updateNaturalKey, long version) {
+    cacheHelp.cacheBeanUpdate(key, changes, updateNaturalKey, version);
   }
 
   /**
@@ -1652,6 +1646,14 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
     return new DeployUpdateParser(this).parse(ormUpdateStatement);
   }
 
+  public void collectQueryPlans(QueryPlanRequest request) {
+    for (CQueryPlan queryPlan : queryPlanCache.values()) {
+      if (request.includeLabel(queryPlan.getLabel())) {
+        queryPlan.collectQueryPlan(request);
+      }
+    }
+  }
+
   /**
    * Visit all the ORM query plan metrics (includes UpdateQuery with updates and deletes).
    */
@@ -1981,7 +1983,7 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
   public T createReference(Boolean readOnly, boolean disableLazyLoad, Object id, PersistenceContext pc) {
 
     if (cacheSharableBeans && !disableLazyLoad && !Boolean.FALSE.equals(readOnly)) {
-      CachedBeanData d = cacheHelp.beanCacheGetData(id);
+      CachedBeanData d = cacheHelp.beanCacheGetData(cacheKey(id));
       if (d != null) {
         Object shareableBean = d.getSharableBean();
         if (shareableBean != null) {
@@ -2262,6 +2264,20 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
     return (idProperty == null) ? null : idProperty.getValueIntercept(bean);
   }
 
+  /**
+   * Return the cache key for the given bean (based on id value).
+   */
+  public String cacheKeyForBean(EntityBean bean) {
+    return cacheKey(idProperty.getValue(bean));
+  }
+
+  /**
+   * Return the cache key for the given id value.
+   */
+  public String cacheKey(Object id) {
+    return idBinder.cacheKey(id);
+  }
+
   @Override
   public Object beanId(Object bean) {
     return getId((EntityBean) bean);
@@ -2570,9 +2586,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
   /**
    * Return a 'dynamic property' used to read a formula.
    */
-  private STreeProperty findSqlTreeFormula(String formulaExpression) {
-
-    return dynamicProperty.computeIfAbsent(formulaExpression, (formula) -> new FormulaPropertyPath(this, formula).build());
+  private STreeProperty findSqlTreeFormula(String formula, String path) {
+    String key = formula + "-" + path;
+    return dynamicProperty.computeIfAbsent(key, (fullKey) -> new FormulaPropertyPath(this, formula, path).build());
   }
 
   /**
@@ -2581,9 +2597,9 @@ public class BeanDescriptor<T> implements BeanType<T>, STreeType {
    * The property can be a dynamic formula or a well known bean property.
    */
   @Override
-  public STreeProperty findPropertyWithDynamic(String propName) {
+  public STreeProperty findPropertyWithDynamic(String propName, String path) {
     if (propName.indexOf('(') > -1) {
-      return findSqlTreeFormula(propName);
+      return findSqlTreeFormula(propName, path);
     }
     return _findBeanProperty(propName);
   }

src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorCacheHelp.java

@@ -27,6 +27,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -282,7 +283,7 @@ final class BeanDescriptorCacheHelp<T> {
 
     if (many.isElementCollection()) {
       // held as part of the bean cache so skip
-			return false;
+      return false;
     }
 
     CachedManyIds entry = manyPropGet(parentId, many.getName());
@@ -317,7 +318,7 @@ final class BeanDescriptorCacheHelp<T> {
         try {
           // add as JSON to bean cache
           String asJson = many.jsonWriteCollection(details);
-          Map<String,Object> changes = new HashMap<>();
+          Map<String, Object> changes = new HashMap<>();
           changes.put(many.getName(), asJson);
 
           CachedBeanData newData = data.update(changes, data.getVersion());
@@ -475,7 +476,7 @@ final class BeanDescriptorCacheHelp<T> {
 
   private Class<?> theClassOf(Collection<EntityBean> beans) {
     if (beans instanceof List) {
-      return ((List<?>)beans).get(0).getClass();
+      return ((List<?>) beans).get(0).getClass();
     }
     return beans.iterator().next().getClass();
   }
@@ -494,20 +495,20 @@ final class BeanDescriptorCacheHelp<T> {
 
   void beanCachePutAllDirect(Collection<EntityBean> beans) {
 
-    Map<Object,Object> natKeys = null;
+    Map<Object, Object> natKeys = null;
     if (naturalKey != null) {
       natKeys = new LinkedHashMap<>();
     }
 
-    Map<Object,Object> map = new LinkedHashMap<>();
+    Map<Object, Object> map = new LinkedHashMap<>();
     for (EntityBean bean : beans) {
       CachedBeanData beanData = beanExtractData(desc, bean);
-      Object id = desc.getId(bean);
-      map.put(id, beanData);
+      String key = desc.cacheKeyForBean(bean);
+      map.put(key, beanData);
       if (naturalKey != null) {
         Object naturalKey = calculateNaturalKey(beanData);
         if (naturalKey != null) {
-          natKeys.put(naturalKey, id);
+          natKeys.put(naturalKey, key);
         }
       }
     }
@@ -525,32 +526,33 @@ final class BeanDescriptorCacheHelp<T> {
   }
 
   /**
-	 * Put the bean into the bean cache.
-	 */
+   * Put the bean into the bean cache.
+   */
   void beanCachePutDirect(EntityBean bean) {
 
     CachedBeanData beanData = beanExtractData(desc, bean);
 
-    Object id = desc.getId(bean);
+    String key = desc.cacheKeyForBean(bean);
     if (beanLog.isDebugEnabled()) {
-      beanLog.debug("   PUT {}({}) data:{}", cacheName, id, beanData);
+      beanLog.debug("   PUT {}({}) data:{}", cacheName, key, beanData);
     }
-    getBeanCache().put(id, beanData);
+    getBeanCache().put(key, beanData);
 
     if (naturalKey != null) {
-      Object naturalKey = calculateNaturalKey(beanData);
+      String naturalKey = calculateNaturalKey(beanData);
       if (naturalKey != null) {
         if (natLog.isDebugEnabled()) {
-          natLog.debug(" PUT {}({}, {})", cacheName, naturalKey, id);
+          natLog.debug(" PUT {}({}, {})", cacheName, naturalKey, key);
         }
-        naturalKeyCache.put(naturalKey, id);
+        naturalKeyCache.put(naturalKey, key);
       }
     }
   }
 
-  private Object calculateNaturalKey(CachedBeanData beanData) {
+  private String calculateNaturalKey(CachedBeanData beanData) {
     if (naturalKey.length == 1) {
-      return beanData.getData(naturalKey[0]);
+      Object data = beanData.getData(naturalKey[0]);
+      return (data == null) ? null : data.toString();
     }
     StringBuilder sb = new StringBuilder();
     for (String key : naturalKey) {
@@ -563,12 +565,12 @@ final class BeanDescriptorCacheHelp<T> {
     return sb.toString();
   }
 
-  CachedBeanData beanCacheGetData(Object id) {
-    return (CachedBeanData) getBeanCache().get(id);
+  CachedBeanData beanCacheGetData(String key) {
+    return (CachedBeanData) getBeanCache().get(key);
   }
 
-  T beanCacheGet(Object id, Boolean readOnly, PersistenceContext context) {
-    T bean = beanCacheGetInternal(id, readOnly, context);
+  T beanCacheGet(String key, Boolean readOnly, PersistenceContext context) {
+    T bean = beanCacheGetInternal(key, readOnly, context);
     if (bean != null) {
       setupContext(bean, context);
     }
@@ -578,19 +580,19 @@ final class BeanDescriptorCacheHelp<T> {
   /**
    * Return a bean from the bean cache.
    */
-  private T beanCacheGetInternal(Object id, Boolean readOnly, PersistenceContext context) {
+  private T beanCacheGetInternal(String key, Boolean readOnly, PersistenceContext context) {
 
-    CachedBeanData data = (CachedBeanData) getBeanCache().get(id);
+    CachedBeanData data = (CachedBeanData) getBeanCache().get(key);
     if (data == null) {
       if (beanLog.isTraceEnabled()) {
-        beanLog.trace("   GET {}({}) - cache miss", cacheName, id);
+        beanLog.trace("   GET {}({}) - cache miss", cacheName, key);
       }
       return null;
     }
     if (beanLog.isTraceEnabled()) {
-      beanLog.trace("   GET {}({}) - hit", cacheName, id);
+      beanLog.trace("   GET {}({}) - hit", cacheName, key);
     }
-    return convertToBean(id, readOnly, context, data);
+    return convertToBean(key, readOnly, context, data);
   }
 
   @SuppressWarnings("unchecked")
@@ -686,12 +688,12 @@ final class BeanDescriptorCacheHelp<T> {
   /**
    * Remove a bean from the cache given its Id.
    */
-  void beanCacheApplyInvalidate(Collection<Object> ids) {
+  void beanCacheApplyInvalidate(Collection<String> keys) {
     if (beanCache != null) {
       if (beanLog.isDebugEnabled()) {
-        beanLog.debug("   REMOVE {}({})", cacheName, ids);
+        beanLog.debug("   REMOVE {}({})", cacheName, keys);
       }
-      beanCache.removeAll(new HashSet<>(ids));
+      beanCache.removeAll(new HashSet<>(keys));
     }
     for (BeanPropertyAssocOne<?> imported : propertiesOneImported) {
       imported.cacheClear();
@@ -699,28 +701,77 @@ final class BeanDescriptorCacheHelp<T> {
   }
 
   /**
-   * Returns true if it managed to populate/load the bean from the cache.
+   * Load a batch of entities from L2 bean cache checking the lazy loaded property is loaded.
    */
-  boolean beanCacheLoad(EntityBean bean, EntityBeanIntercept ebi, Object id, PersistenceContext context) {
+  Set<EntityBeanIntercept> beanCacheLoadAll(List<EntityBeanIntercept> list, PersistenceContext context, int lazyLoadProperty, String propertyName) {
 
-    CachedBeanData cacheData = (CachedBeanData) getBeanCache().get(id);
+    Map<Object, EntityBeanIntercept> ebis = new HashMap<>();
+    for (EntityBeanIntercept ebi : list) {
+      ebis.put(desc.cacheKeyForBean(ebi.getOwner()), ebi);
+    }
+
+
+    Map<Object, Object> hits = getBeanCache().getAll(ebis.keySet());
+
+    if (beanLog.isTraceEnabled()) {
+      beanLog.trace("   LOAD ALL {}({}) - got hits ({})", cacheName, ebis.keySet(), hits.size());
+    }
+
+    Set<EntityBeanIntercept> loaded = new HashSet<>();
+
+    Iterator<Map.Entry<Object, Object>> iterator = hits.entrySet().iterator();
+    while (iterator.hasNext()) {
+      Map.Entry<Object, Object> hit = iterator.next();
+
+      Object key = hit.getKey();
+      EntityBeanIntercept ebi = ebis.remove(key);
+      CachedBeanData cacheData = (CachedBeanData) hit.getValue();
+
+      if (lazyLoadProperty > -1 && !cacheData.isLoaded(propertyName)) {
+        if (beanLog.isTraceEnabled()) {
+          beanLog.trace("   LOAD {}({}) - cache miss on property({})", cacheName, key, propertyName);
+        }
+        iterator.remove();
+
+      } else {
+        CachedBeanDataToBean.load(desc, ebi.getOwner(), cacheData, context);
+        loaded.add(ebi);
+        if (beanLog.isDebugEnabled()) {
+          beanLog.debug("   LOAD {}({}) - hit", cacheName, key);
+        }
+      }
+    }
+
+    if (!ebis.isEmpty() && beanLog.isTraceEnabled()) {
+      beanLog.trace("   LOAD {}({}) - cache miss", cacheName, ebis.keySet());
+    }
+
+    return loaded;
+  }
+
+  /**
+   * Returns true if it managed to populate/load the single bean from the cache.
+   */
+  boolean beanCacheLoad(EntityBean bean, EntityBeanIntercept ebi, String key, PersistenceContext context) {
+
+    CachedBeanData cacheData = (CachedBeanData) getBeanCache().get(key);
     if (cacheData == null) {
       if (beanLog.isTraceEnabled()) {
-        beanLog.trace("   LOAD {}({}) - cache miss", cacheName, id);
+        beanLog.trace("   LOAD {}({}) - cache miss", cacheName, key);
       }
       return false;
     }
     int lazyLoadProperty = ebi.getLazyLoadPropertyIndex();
     if (lazyLoadProperty > -1 && !cacheData.isLoaded(ebi.getLazyLoadProperty())) {
       if (beanLog.isTraceEnabled()) {
-        beanLog.trace("   LOAD {}({}) - cache miss on property({})", cacheName, id, ebi.getLazyLoadProperty());
+        beanLog.trace("   LOAD {}({}) - cache miss on property({})", cacheName, key, ebi.getLazyLoadProperty());
       }
       return false;
     }
 
     CachedBeanDataToBean.load(desc, bean, cacheData, context);
     if (beanLog.isDebugEnabled()) {
-      beanLog.debug("   LOAD {}({}) - hit", cacheName, id);
+      beanLog.debug("   LOAD {}({}) - hit", cacheName, key);
     }
     return true;
   }
@@ -736,7 +787,7 @@ final class BeanDescriptorCacheHelp<T> {
    */
   void persistDeleteIds(Collection<Object> ids, CacheChangeSet changeSet) {
     if (invalidateQueryCache) {
-     changeSet.addInvalidate(desc);
+      changeSet.addInvalidate(desc);
     } else {
       queryCacheClear(changeSet);
       if (beanCache != null) {
@@ -833,42 +884,42 @@ final class BeanDescriptorCacheHelp<T> {
     }
   }
 
-  void cacheNaturalKeyPut(Object id, Object newKey) {
+  void cacheNaturalKeyPut(String key, String newKey) {
     if (newKey != null) {
-      naturalKeyCache.put(newKey, id);
+      naturalKeyCache.put(newKey, key);
     }
   }
 
   /**
    * Apply changes to the bean cache entry.
    */
-  void cacheBeanUpdate(Object id, Map<String, Object> changes, boolean updateNaturalKey, long version) {
+  void cacheBeanUpdate(String key, Map<String, Object> changes, boolean updateNaturalKey, long version) {
 
     ServerCache cache = getBeanCache();
-    CachedBeanData existingData = (CachedBeanData) cache.get(id);
+    CachedBeanData existingData = (CachedBeanData) cache.get(key);
     if (existingData != null) {
       long currentVersion = existingData.getVersion();
       if (version > 0 && version < currentVersion) {
         if (beanLog.isDebugEnabled()) {
-          beanLog.debug("   REMOVE {}({}) - version conflict old:{} new:{}", cacheName, id, currentVersion, version);
+          beanLog.debug("   REMOVE {}({}) - version conflict old:{} new:{}", cacheName, key, currentVersion, version);
         }
-        cache.remove(id);
+        cache.remove(key);
       } else {
         if (version == 0) {
           version = currentVersion;
         }
         CachedBeanData newData = existingData.update(changes, version);
         if (beanLog.isDebugEnabled()) {
-          beanLog.debug("   UPDATE {}({})  changes:{}", cacheName, id, changes);
+          beanLog.debug("   UPDATE {}({})  changes:{}", cacheName, key, changes);
         }
-        cache.put(id, newData);
+        cache.put(key, newData);
       }
 
       if (updateNaturalKey) {
         Object oldKey = calculateNaturalKey(existingData);
         if (oldKey != null) {
           if (natLog.isDebugEnabled()) {
-            natLog.debug(".. update {} REMOVE({}) - old key for ({})", cacheName, oldKey, id);
+            natLog.debug(".. update {} REMOVE({}) - old key for ({})", cacheName, oldKey, key);
           }
           naturalKeyCache.remove(oldKey);
         }

src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorInitContext.java

@@ -8,6 +8,8 @@ class BeanDescriptorInitContext {
   private final Map<String, String> draftTables;
   private final String asOfViewSuffix;
 
+  private String embeddedPrefix;
+
   BeanDescriptorInitContext(Map<String, String> withHistoryTables, Map<String, String> draftTables, String asOfViewSuffix) {
     this.withHistoryTables = withHistoryTables;
     this.draftTables = draftTables;
@@ -29,4 +31,12 @@ class BeanDescriptorInitContext {
   void addDraftIntersection(String intersectionPublishTable, String intersectionDraftTable) {
     draftTables.put(intersectionPublishTable, intersectionDraftTable);
   }
+
+  public void setEmbeddedPrefix(String embeddedPrefix) {
+    this.embeddedPrefix = embeddedPrefix;
+  }
+
+  public String getEmbeddedPrefix() {
+    return embeddedPrefix;
+  }
 }

src/main/java/io/ebeaninternal/server/deploy/BeanDescriptorManager.java

@@ -21,6 +21,7 @@ import io.ebean.event.changelog.ChangeLogListener;
 import io.ebean.event.changelog.ChangeLogPrepare;
 import io.ebean.event.changelog.ChangeLogRegister;
 import io.ebean.meta.MetricVisitor;
+import io.ebean.meta.QueryPlanRequest;
 import io.ebean.plugin.BeanType;
 import io.ebean.util.AnnotationUtil;
 import io.ebeaninternal.api.ConcurrencyMode;
@@ -149,8 +150,6 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
   private final String serverName;
 
-  private Map<Class<?>, DeployBeanInfo<?>> deployInfoMap = new HashMap<>();
-
   private final Map<Class<?>, BeanTable> beanTableMap = new HashMap<>();
 
   private final Map<String, BeanDescriptor<?>> descMap = new HashMap<>();
@@ -195,6 +194,12 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
   private final int queryPlanTTLSeconds;
 
+  // temporary collections used during startup and then cleared
+
+  private Map<Class<?>, DeployBeanInfo<?>> deployInfoMap = new HashMap<>();
+  private Set<Class<?>> embeddedIdTypes = new HashSet<>();
+  private List<DeployBeanInfo<?>> embeddedBeans = new ArrayList<>();
+
   /**
    * Create for a given database dbConfig.
    */
@@ -365,7 +370,6 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
       createListeners();
       readEntityDeploymentInitial();
       readXmlMapping(mappings);
-      readEmbeddedDeployment();
       readEntityBeanTable();
       readEntityDeploymentAssociations();
       readInheritedIdGenerators();
@@ -384,7 +388,9 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
 
       logStatus();
 
-      deployInfoMap.clear();
+      // clear collections we no longer need
+      embeddedIdTypes = null;
+      embeddedBeans = null;
       deployInfoMap = null;
 
       return asOfTableMap;
@@ -591,8 +597,7 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     for (BeanDescriptor<?> d : descMap.values()) {
       d.initLast();
       if (!d.isEmbedded()) {
-        BeanManager<?> m = beanManagerFactory.create(d);
-        beanManagerMap.put(d.getFullName(), m);
+        beanManagerMap.put(d.getFullName(), beanManagerFactory.create(d));
         checkForValidEmbeddedId(d);
       }
     }
@@ -675,11 +680,6 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     logger.debug("Entities[{}]", entityBeanCount);
   }
 
-  private <T> BeanDescriptor<T> createEmbedded(Class<T> beanClass) {
-    DeployBeanInfo<T> info = getDeploy(beanClass);
-    return new BeanDescriptor<>(this, info.getDescriptor());
-  }
-
   /**
    * Return the bean deploy info for the given class.
    */
@@ -688,24 +688,14 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     return (DeployBeanInfo<T>) deployInfoMap.get(cls);
   }
 
-  private void registerBeanDescriptor(BeanDescriptor<?> desc) {
+  private void registerBeanDescriptor(DeployBeanInfo<?> info) {
+    BeanDescriptor desc = new BeanDescriptor<>(this, info.getDescriptor());
     descMap.put(desc.getBeanType().getName(), desc);
     if (desc.isDocStoreMapped()) {
       descQueueMap.put(desc.getDocStoreQueueId(), desc);
     }
   }
 
-  /**
-   * Read deployment information for all the embedded beans.
-   */
-  private void readEmbeddedDeployment() {
-
-    List<Class<?>> embeddedClasses = bootupClasses.getEmbeddables();
-    for (Class<?> embeddedClass : embeddedClasses) {
-      registerBeanDescriptor(createEmbedded(embeddedClass));
-    }
-  }
-
   /**
    * Read the initial deployment information for the entities.
    * <p>
@@ -718,14 +708,31 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     for (Class<?> entityClass : bootupClasses.getEntities()) {
       DeployBeanInfo<?> info = createDeployBeanInfo(entityClass);
       deployInfoMap.put(entityClass, info);
+      Class<?> embeddedIdType = info.getEmbeddedIdType();
+      if (embeddedIdType != null){
+        embeddedIdTypes.add(embeddedIdType);
+      }
     }
     for (Class<?> entityClass : bootupClasses.getEmbeddables()) {
       DeployBeanInfo<?> info = createDeployBeanInfo(entityClass);
-      readDeployAssociations(info);
       deployInfoMap.put(entityClass, info);
+      if (embeddedIdTypes.contains(entityClass)) {
+        // register embeddedId types early - scalar properties only
+        // and needed for creating BeanTables (id properties)
+        registerEmbeddedBean(info);
+      } else {
+        // delay register of other embedded beans until after
+        // the BeanTables have been created to support ManyToOne
+        embeddedBeans.add(info);
+      }
     }
   }
 
+  private void registerEmbeddedBean(DeployBeanInfo<?> info) {
+    readDeployAssociations(info);
+    registerBeanDescriptor(info);
+  }
+
   /**
    * Create the BeanTable information which has the base table and id.
    * <p>
@@ -738,6 +745,11 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
       BeanTable beanTable = createBeanTable(info);
       beanTableMap.put(beanTable.getBeanType(), beanTable);
     }
+
+    // register non-id embedded beans (after bean tables are created)
+    for (DeployBeanInfo<?> info : embeddedBeans) {
+      registerEmbeddedBean(info);
+    }
   }
 
   /**
@@ -815,13 +827,14 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
       secondaryPropsJoins(info);
     }
 
-    // Set inheritance info
     for (DeployBeanInfo<?> info : deployInfoMap.values()) {
       setInheritanceInfo(info);
     }
 
     for (DeployBeanInfo<?> info : deployInfoMap.values()) {
-      registerBeanDescriptor(new BeanDescriptor(this, info.getDescriptor()));
+      if (!info.isEmbedded()) {
+        registerBeanDescriptor(info);
+      }
     }
   }
 
@@ -1688,6 +1701,14 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
     }
   }
 
+  public void collectQueryPlans(QueryPlanRequest request) {
+    for (BeanDescriptor<?> desc : immutableDescriptorList) {
+      if (request.includeType(desc.getBeanType())) {
+        desc.collectQueryPlans(request);
+      }
+    }
+  }
+
   /**
    * Comparator to sort the BeanDescriptors by name.
    */

src/main/java/io/ebeaninternal/server/deploy/BeanEmbeddedMetaFactory.java

@@ -30,7 +30,7 @@ public class BeanEmbeddedMetaFactory {
     String columnPrefix = prop.getColumnPrefix();
     Map<String, String> propColMap = prop.getDeployEmbedded().getPropertyColumnMap();
 
-    BeanProperty[] sourceProperties = targetDesc.propertiesBaseScalar();
+    BeanProperty[] sourceProperties = targetDesc.propertiesNonTransient();
     BeanProperty[] embeddedProperties = new BeanProperty[sourceProperties.length];
 
     for (int i = 0; i < sourceProperties.length; i++) {
@@ -45,7 +45,11 @@ public class BeanEmbeddedMetaFactory {
       }
 
       BeanPropertyOverride overrides = new BeanPropertyOverride(dbColumn);
-      embeddedProperties[i] = new BeanProperty(sourceProperties[i], overrides);
+      if (sourceProperties[i] instanceof BeanPropertyAssocOne) {
+        embeddedProperties[i] = new BeanPropertyAssocOne((BeanPropertyAssocOne)sourceProperties[i], overrides);
+      } else {
+        embeddedProperties[i] = new BeanProperty(sourceProperties[i], overrides);
+      }
     }
 
     return new BeanEmbeddedMeta(embeddedProperties);

src/main/java/io/ebeaninternal/server/deploy/BeanFkeyProperty.java

@@ -56,11 +56,10 @@ public final class BeanFkeyProperty implements ElPropertyValue {
     }
   }
 
-  public BeanFkeyProperty create(String expression, boolean containsMany) {
+  public BeanFkeyProperty create(String expression, boolean pathContainsMany) {
     int len = expression.length() - name.length() - 1;
     String prefix = expression.substring(0, len);
-
-    return new BeanFkeyProperty(prefix, name, dbColumn, deployOrder, containsMany);
+    return new BeanFkeyProperty(prefix, name, dbColumn, deployOrder, containsMany || pathContainsMany);
   }
 
   /**

src/main/java/io/ebeaninternal/server/deploy/BeanMapHelp.java

@@ -24,16 +24,6 @@ public class BeanMapHelp<T> extends BaseCollectionHelp<T> {
   private final String propertyName;
   private final BeanProperty beanProperty;
 
-  /**
-   * When created for a given query that will return a map.
-   */
-  BeanMapHelp(BeanDescriptor<T> targetDescriptor, String mapKey) {
-    this.targetDescriptor = targetDescriptor;
-    this.beanProperty = targetDescriptor.getBeanProperty(mapKey);
-    this.many = null;
-    this.propertyName = null;
-  }
-
   /**
    * When help is attached to a specific many property.
    */

src/main/java/io/ebeaninternal/server/deploy/BeanMapQueryHelp.java

@@ -0,0 +1,35 @@
+package io.ebeaninternal.server.deploy;
+
+import io.ebean.bean.BeanCollection;
+import io.ebean.bean.EntityBean;
+import io.ebean.common.BeanMap;
+import io.ebeaninternal.server.el.ElPropertyValue;
+import io.ebeaninternal.server.query.CQueryCollectionAdd;
+
+class BeanMapQueryHelp<T> implements CQueryCollectionAdd<T> {
+
+  private final ElPropertyValue elGetValue;
+
+  /**
+   * Create for a findMap query.
+   */
+  BeanMapQueryHelp(ElPropertyValue elGetValue) {
+    this.elGetValue = elGetValue;
+  }
+
+  @Override
+  public BeanCollection<T> createEmptyNoParent() {
+    return new BeanMap<>();
+  }
+
+  @Override
+  public void add(BeanCollection collection, EntityBean bean, boolean withCheck) {
+    if (bean == null) {
+      ((BeanMap<?, ?>) collection).internalPutNull();
+    } else {
+      Object keyValue = elGetValue.pathGet(bean);
+      BeanMap<?, ?> map = ((BeanMap<?, ?>) collection);
+      map.internalPutWithCheck(keyValue, bean);
+    }
+  }
+}

src/main/java/io/ebeaninternal/server/deploy/BeanProperty.java

@@ -28,6 +28,7 @@ import io.ebeaninternal.server.query.STreeProperty;
 import io.ebeaninternal.server.query.SqlBeanLoad;
 import io.ebeaninternal.server.query.SqlJoinType;
 import io.ebeaninternal.server.type.DataBind;
+import io.ebeaninternal.server.type.DataReader;
 import io.ebeaninternal.server.type.LocalEncryptedType;
 import io.ebeaninternal.server.type.ScalarType;
 import io.ebeaninternal.server.type.ScalarTypeBoolean;
@@ -640,6 +641,23 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
     }
   }
 
+  @Override
+  public Object read(DataReader reader) throws SQLException {
+    return scalarType.read(reader);
+  }
+
+  public Object readSet(DataReader reader, EntityBean bean) throws SQLException {
+    try {
+      Object value = scalarType.read(reader);
+      if (bean != null) {
+        setValue(bean, value);
+      }
+      return value;
+    } catch (Exception e) {
+      throw new PersistenceException("Error readSet on " + descriptor + "." + name, e);
+    }
+  }
+
   public Object read(DbReadContext ctx) throws SQLException {
     return scalarType.read(ctx.getDataReader());
   }
@@ -809,6 +827,13 @@ public class BeanProperty implements ElPropertyValue, Property, STreeProperty {
     }
   }
 
+  /**
+   * Return the value in String format (for bean cache key).
+   */
+  public String format(Object value) {
+    return scalarType.format(value);
+  }
+
   /**
    * Read the value for this property from L2 cache entry and set it to the bean.
    * <p>