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

* provide test case, that shows problem on multiple-m2m

* FIX: When saving multiple m2m beans, only last m2m wins (Regression due #1630)

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/org.avaje.ebean/ebean) - ebean
-* [![Maven Central : ebean-agent](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-agent) - ebean-agent
-* [![Maven Central : ebean-maven-plugin](https://maven-badges.herokuapp.com/maven-central/io.ebean/ebean-maven-plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-maven-plugin) - ebean-maven-plugin
+## 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
 

howto-test.md

@@ -151,3 +151,18 @@ In `InsertHandler.getPstmt` the `meta.getIdentityDbColumns()` contains
 TODO: not yet tested
 
 
+
+'hana' platform
+--------------------
+
+Requires an installed SAP HANA server - e.g. https://store.docker.com/images/sap-hana-express-edition
+
+- Create a user `EBEAN_TEST` with password `Eb3an_test` in the tenant database `HXE`
+- Adjust the connection string and/or username in `ebean.properties`
+  
+run: `mvn clean test -Ddatasource.default=hana`
+
+Current status: PASS
+Tests run: 2486, Failures: 0, Errors: 0, Skipped: 84
+
+

pom.xml

@@ -9,15 +9,20 @@
 
   <groupId>io.ebean</groupId>
   <artifactId>ebean</artifactId>
-  <version>11.14.3</version>
+  <version>11.34.3</version>
   <packaging>jar</packaging>
 
   <name>ebean</name>
   <url>http://ebean-orm.github.io/</url>
 
+  <properties>
+    <jackson-core.version>2.9.5</jackson-core.version>
+    <snakeyaml.version>1.21</snakeyaml.version>
+  </properties>
+
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-11.14.3</tag>
+    <tag>ebean-11.34.3</tag>
   </scm>
 
   <profiles>
@@ -89,7 +94,7 @@
     <dependency>
       <groupId>org.yaml</groupId>
       <artifactId>snakeyaml</artifactId>
-      <version>1.19</version>
+      <version>${snakeyaml.version}</version>
     </dependency>
 
     <!--
@@ -112,13 +117,13 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>3.8</version>
+      <version>4.5</version>
     </dependency>
 
     <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-datasource</artifactId>
-      <version>3.1.1</version>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-datasource</artifactId>
+      <version>4.5.1</version>
     </dependency>
 
     <dependency>
@@ -130,27 +135,27 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-migration</artifactId>
-      <version>11.3.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 -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
-      <version>2.9.0</version>
+      <version>${jackson-core.version}</version>
     </dependency>
 
     <!-- provided scope for JsonNode support -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
-      <version>2.9.0</version>
+      <version>${jackson-core.version}</version>
       <scope>provided</scope>
     </dependency>
 
@@ -183,11 +188,26 @@
       <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>
       <artifactId>postgresql</artifactId>
-      <version>9.4.1212</version>
+      <version>42.2.2</version>
       <scope>provided</scope>
     </dependency>
 
@@ -217,14 +237,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.10.1</version>
+      <version>11.27.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -233,7 +253,7 @@
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.4.196</version>
+      <version>1.4.197</version>
       <scope>provided</scope>
     </dependency>
 
@@ -254,7 +274,7 @@
     <dependency>
       <groupId>com.microsoft.sqlserver</groupId>
       <artifactId>mssql-jdbc</artifactId>
-      <version>6.1.3.jre8-preview</version>
+      <version>7.2.0.jre8</version>
       <scope>test</scope>
     </dependency>
 
@@ -266,6 +286,13 @@
       <scope>test</scope>
     </dependency>
 
+    <dependency>
+      <groupId>com.sap.cloud.db.jdbc</groupId>
+      <artifactId>ngdbc</artifactId>
+      <version>2.3.48</version>
+      <scope>test</scope>
+    </dependency>
+
     <dependency>
       <groupId>org.avaje.composite</groupId>
       <artifactId>avaje-composite-testing</artifactId>
@@ -297,7 +324,7 @@
       <plugin>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-maven-plugin</artifactId>
-        <version>11.10.1</version>
+        <version>11.27.1</version>
         <executions>
           <execution>
             <id>test</id>
@@ -315,9 +342,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>
@@ -355,7 +383,7 @@
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>2.9.1</version>
         <configuration>
-          <doctitle>Ebean 10</doctitle>
+          <doctitle>Ebean 11</doctitle>
           <overview>src/main/java/io/ebean/overview.html</overview>
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>

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

@@ -2,6 +2,8 @@ package io.ebean;
 
 import io.ebean.bean.EntityBean;
 
+import java.util.Collection;
+
 /**
  * Provides finder functionality for use with "Dependency Injection style" use of Ebean.
  * <p>
@@ -115,6 +117,13 @@ public abstract class BeanRepository<I, T> extends BeanFinder<I, T> {
     db().save(bean);
   }
 
+  /**
+   * Save all the beans in the collection.
+   */
+  public int saveAll(Collection<T> bean) {
+    return db().saveAll(bean);
+  }
+
   /**
    * Update this entity.
    *
@@ -154,6 +163,13 @@ public abstract class BeanRepository<I, T> extends BeanFinder<I, T> {
     return db().delete(bean);
   }
 
+  /**
+   * Delete all the beans in the collection.
+   */
+  public int deleteAll(Collection<T> beans) {
+    return db().deleteAll(beans);
+  }
+
   /**
    * Delete a bean permanently without soft delete.
    * <p>
@@ -167,6 +183,30 @@ public abstract class BeanRepository<I, T> extends BeanFinder<I, T> {
     return db().deletePermanent(bean);
   }
 
+  /**
+   * Merge this entity using the default merge options.
+   * <p>
+   * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
+   * insert or an update based on that.
+   *
+   * @see EbeanServer#merge(Object)
+   */
+  public void merge(T bean) {
+    db().merge(bean);
+  }
+
+  /**
+   * Merge this entity using the specified merge options.
+   * <p>
+   * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
+   * insert or an update based on that.
+   *
+   * @see EbeanServer#merge(Object, MergeOptions)
+   */
+  public void merge(T bean, MergeOptions options) {
+    db().merge(bean, options);
+  }
+
   /**
    * Refreshes this entity from the database.
    *

src/main/java/io/ebean/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

@@ -2,7 +2,9 @@ package io.ebean;
 
 import io.ebean.annotation.TxIsolation;
 import io.ebean.cache.ServerCacheManager;
+import io.ebean.config.BeanNotEnhancedException;
 import io.ebean.config.ServerConfig;
+import io.ebean.datasource.DataSourceConfigurationException;
 import io.ebean.plugin.Property;
 import io.ebean.text.csv.CsvReader;
 import io.ebean.text.json.JsonContext;
@@ -118,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.
   }
 
   /**
@@ -160,6 +162,15 @@ public final class Ebean {
             defaultServer = getWithCreate(defaultName.trim());
           }
         }
+      } catch (BeanNotEnhancedException e) {
+        throw e;
+
+      } catch (DataSourceConfigurationException e) {
+        String msg = "Configuration error creating DataSource for the default EbeanServer." +
+          " This typically means a missing application-test.yaml or missing ebean-test-config dependency." +
+          " See https://ebean.io/docs/trouble-shooting#datasource";
+        throw new DataSourceConfigurationException(msg, e);
+
       } catch (Throwable e) {
         logger.error("Error trying to create the default EbeanServer", e);
         throw new RuntimeException(e);
@@ -638,6 +649,25 @@ public final class Ebean {
     serverMgr.getDefaultServer().updateAll(beans);
   }
 
+  /**
+   * Merge the bean using the default merge options.
+   *
+   * @param bean The bean to merge
+   */
+  public static void merge(Object bean) {
+    serverMgr.getDefaultServer().merge(bean);
+  }
+
+  /**
+   * Merge the bean using the given merge options.
+   *
+   * @param bean    The bean to merge
+   * @param options The options to control the merge
+   */
+  public static void merge(Object bean, MergeOptions options) {
+    serverMgr.getDefaultServer().merge(bean, options);
+  }
+
   /**
    * Save all the beans from a Collection.
    */

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

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

src/main/java/io/ebean/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.
    */
@@ -133,11 +138,49 @@ public interface ExpressionFactory {
    */
   Expression ieq(String propertyName, String value);
 
+  /**
+   * Case Insensitive Not Equal To - property not equal to the given value (typically
+   * using a lower() function to make it case insensitive).
+   */
+  Expression ine(String propertyName, String value);
+
   /**
    * Case Insensitive Equal To that allows for named parameter use.
    */
   Expression ieqObject(String propertyName, Object value);
 
+  /**
+   * Case Insensitive Not Equal To that allows for named parameter use.
+   */
+  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.
    */
@@ -148,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.
    */
@@ -159,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.
    */
@@ -327,6 +386,30 @@ public interface ExpressionFactory {
    */
   Expression allEq(Map<String, Object> propertyMap);
 
+  /**
+   * Add expression for ANY of the given bit flags to be set.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAny(String propertyName, long flags);
+
+  /**
+   * Add expression for ALL of the given bit flags to be set.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAll(String propertyName, long flags);
+
+  /**
+   * Add bitwise AND expression of the given bit flags to compare with the match/mask.
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  Expression bitwiseAnd(String propertyName, long flags, long match);
+
   /**
    * Add raw expression with a single parameter.
    * <p>

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

@@ -120,6 +120,46 @@ public interface ExpressionList<T> {
    */
   Query<T> asDraft();
 
+  /**
+   * Convert the query to a DTO bean query.
+   * <p>
+   * We effectively use the underlying ORM query to build the SQL and then execute
+   * and map it into DTO beans.
+   */
+  <D> DtoQuery<D> asDto(Class<D> dtoClass);
+
+  /**
+   * 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.
    */
@@ -158,6 +198,18 @@ public interface ExpressionList<T> {
    */
   int delete();
 
+  /**
+   * Execute as a delete query deleting the 'root level' beans that match the predicates
+   * in the query.
+   * <p>
+   * Note that if the query includes joins then the generated delete statement may not be
+   * optimal depending on the database platform.
+   * </p>
+   *
+   * @return the number of rows that were deleted.
+   */
+  int delete(Transaction transaction);
+
   /**
    * Execute as a update query.
    *
@@ -166,6 +218,40 @@ public interface ExpressionList<T> {
    */
   int update();
 
+  /**
+   * Execute as a update query with the given transaction.
+   *
+   * @return the number of rows that were updated.
+   * @see UpdateQuery
+   */
+  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.
    *
@@ -230,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
    *
@@ -241,7 +327,7 @@ public interface ExpressionList<T> {
    *      .findSingleAttributeList();
    *
    * }</pre>
-   * <p>
+   *
    * <h3>Example 2:</h3>
    * <pre>{@code
    *
@@ -263,7 +349,6 @@ public interface ExpressionList<T> {
 
   /**
    * Execute a query returning a single value of a single property/column.
-   * <p>
    * <pre>{@code
    *
    *  String name =
@@ -348,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)
@@ -404,6 +488,11 @@ public interface ExpressionList<T> {
    */
   Query<T> select(String properties);
 
+  /**
+   * Apply the fetchGroup which defines what part of the object graph to load.
+   */
+  Query<T> select(FetchGroup<T> fetchGroup);
+
   /**
    * Set whether this query uses DISTINCT.
    * <p>
@@ -482,7 +571,6 @@ public interface ExpressionList<T> {
 
   /**
    * Extended version for setDistinct in conjunction with "findSingleAttributeList";
-   *
    * <pre>{@code
    *
    *  List<CountedValue<Order.Status>> orderStatusCount =
@@ -545,6 +633,11 @@ public interface ExpressionList<T> {
    */
   Query<T> setDisableReadAuditing();
 
+  /**
+   * Set a label on the query (to help identify query execution statistics).
+   */
+  Query<T> setLabel(String label);
+
   /**
    * Add expressions to the having clause.
    * <p>
@@ -587,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)
@@ -602,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)
@@ -617,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)
@@ -628,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)
@@ -639,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)
@@ -650,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)
@@ -661,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)
@@ -675,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);
@@ -700,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.
    */
@@ -712,8 +802,41 @@ public interface ExpressionList<T> {
   ExpressionList<T> ieq(String propertyName, String value);
 
   /**
-   * Between - property between the two given values.
+   * Case Insensitive Not Equal To - property not equal to the given value (typically
+   * using a lower() function to make it case insensitive).
    */
+  ExpressionList<T> ine(String propertyName, String value);
+
+  /**
+   * 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);
 
   /**
@@ -726,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.
@@ -737,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.
    */
@@ -766,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
@@ -775,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
@@ -784,7 +916,7 @@ public interface ExpressionList<T> {
    * }</pre>
    * <p>
    * Similarly you can create an ExampleExpression
-   * <p>
+   * </p>
    * <pre>{@code
    *
    * Customer example = new Customer();
@@ -873,7 +1005,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - using a subQuery.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -883,7 +1015,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - property has a value in the array of values.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -893,7 +1025,7 @@ public interface ExpressionList<T> {
 
   /**
    * In - property has a value in the collection of values.
-   *
+   * <p>
    * This is exactly the same as in() and provided due to "in" being a Kotlin keyword
    * (and hence to avoid the slightly ugly escaping when using in() in Kotlin)
    */
@@ -991,6 +1123,65 @@ public interface ExpressionList<T> {
    */
   ExpressionList<T> arrayIsNotEmpty(String propertyName);
 
+  /**
+   * Add expression for ANY of the given bit flags to be set.
+   * <pre>{@code
+   *
+   * where().bitwiseAny("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAny(String propertyName, long flags);
+
+  /**
+   * Add expression for ALL of the given bit flags to be set.
+   * <pre>{@code
+   *
+   * where().bitwiseAll("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAll(String propertyName, long flags);
+
+  /**
+   * Add expression for the given bit flags to be NOT set.
+   * <pre>{@code
+   *
+   * where().bitwiseNot("flags", BwFlags.HAS_COLOUR)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseNot(String propertyName, long flags);
+
+  /**
+   * Add bitwise AND expression of the given bit flags to compare with the match/mask.
+   * <p>
+   * <pre>{@code
+   *
+   * // Flags Bulk + Size = Size
+   * // ... meaning Bulk is not set and Size is set
+   *
+   * long selectedFlags = BwFlags.HAS_BULK + BwFlags.HAS_SIZE;
+   * long mask = BwFlags.HAS_SIZE; // Only Size flag set
+   *
+   * where().bitwiseAnd("flags", selectedFlags, mask)
+   *
+   * }</pre>
+   *
+   * @param propertyName The property that holds the flags value
+   * @param flags        The flags we are looking for
+   */
+  ExpressionList<T> bitwiseAnd(String propertyName, long flags, long match);
+
   /**
    * Add raw expression with a single parameter.
    * <p>
@@ -1010,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);
 
@@ -1034,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);
 
@@ -1113,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
@@ -1139,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()
@@ -1172,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()
@@ -1182,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

@@ -0,0 +1,481 @@
+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;
+import java.time.Clock;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * The extended API for EbeanServer.
+ * <p>
+ * This provides the finder methods that take an explicit transaction rather than obtaining
+ * the transaction from the usual mechanism (which is ThreadLocal based).
+ * </p>
+ * <p>
+ * In general we only want to use this ExtendedServer API when we want to avoid / bypass
+ * the use of the mechanism to get the current transaction and instead explicitly supply
+ * the transaction to use.
+ * </p>
+ * <p>
+ * Note that in all cases the transaction supplied can be null and in this case the EbeanServer
+ * will use the normal mechanism to obtain the transaction to use.
+ * </p>
+ */
+public interface ExtendedServer {
+
+  /**
+   * Return the NOW time from the Clock.
+   */
+  long clockNow();
+
+  /**
+   * Set the Clock to use for <code>@WhenCreated</code> and <code>@WhenModified</code>.
+   * <p>
+   * Note that we only expect to change the Clock for testing purposes.
+   * </p>
+   */
+  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.
+   *
+   * @see Query#findCount()
+   * @see Query#findFutureCount()
+   */
+  <T> int findCount(Query<T> query, Transaction transaction);
+
+  /**
+   * Return the Id values of the query as a List.
+   *
+   * @see Query#findIds()
+   */
+  @Nonnull
+  <A, T> List<A> findIds(Query<T> query, Transaction transaction);
+
+  /**
+   * Return a QueryIterator for the query.
+   * <p>
+   * Generally using {@link #findEach(Query, Consumer, Transaction)} or
+   * {@link #findEachWhile(Query, Predicate, Transaction)} is preferred
+   * to findIterate(). The reason is that those methods automatically take care of
+   * closing the queryIterator (and the underlying jdbc statement and resultSet).
+   * </p>
+   * <p>
+   * This is similar to findEach in that not all the result beans need to be held
+   * in memory at the same time and as such is good for processing large queries.
+   * </p>
+   *
+   * @see Query#findIterate()
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  @Nonnull
+  <T> QueryIterator<T> findIterate(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query visiting the each bean one at a time.
+   * <p>
+   * Unlike findList() this is suitable for processing a query that will return
+   * a very large resultSet. The reason is that not all the result beans need to be
+   * held in memory at the same time and instead processed one at a time.
+   * </p>
+   * <p>
+   * Internally this query using a PersistenceContext scoped to each bean (and the
+   * beans associated object graph).
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *     ebeanServer.find(Order.class)
+   *       .where().eq("status", Order.Status.NEW)
+   *       .order().asc("id")
+   *       .findEach((Order order) -> {
+   *
+   *         // do something with the order bean
+   *         System.out.println(" -- processing order ... " + order);
+   *       });
+   *
+   * }</pre>
+   *
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  <T> void findEach(Query<T> query, Consumer<T> consumer, Transaction transaction);
+
+  /**
+   * Execute the query visiting the each bean one at a time.
+   * <p>
+   * Compared to findEach() this provides the ability to stop processing the query
+   * results early by returning false for the Predicate.
+   * </p>
+   * <p>
+   * Unlike findList() this is suitable for processing a query that will return
+   * a very large resultSet. The reason is that not all the result beans need to be
+   * held in memory at the same time and instead processed one at a time.
+   * </p>
+   * <p>
+   * Internally this query using a PersistenceContext scoped to each bean (and the
+   * beans associated object graph).
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *     ebeanServer.find(Order.class)
+   *       .where().eq("status", Order.Status.NEW)
+   *       .order().asc("id")
+   *       .findEachWhile((Order order) -> {
+   *
+   *         // do something with the order bean
+   *         System.out.println(" -- processing order ... " + order);
+   *
+   *         boolean carryOnProcessing = ...
+   *         return carryOnProcessing;
+   *       });
+   *
+   * }</pre>
+   *
+   * @see Query#findEach(Consumer)
+   * @see Query#findEachWhile(Predicate)
+   */
+  <T> void findEachWhile(Query<T> query, Predicate<T> consumer, Transaction transaction);
+
+  /**
+   * Return versions of a @History entity bean.
+   * <p>
+   * Generally this query is expected to be a find by id or unique predicates query.
+   * It will execute the query against the history returning the versions of the bean.
+   * </p>
+   */
+  @Nonnull
+  <T> List<Version<T>> findVersions(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute a query returning a list of beans.
+   * <p>
+   * Generally you are able to use {@link Query#findList()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   * List<Customer> customers =
+   *     ebeanServer.find(Customer.class)
+   *     .where().ilike("name", "rob%")
+   *     .findList();
+   *
+   * }</pre>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched beans.
+   * @see Query#findList()
+   */
+  @Nonnull
+  <T> List<T> findList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find row count query in a background thread.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a
+   * timeout).
+   * </p>
+   *
+   * @param query       the query to execute the row count on
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the row count query
+   * @see Query#findFutureCount()
+   */
+  @Nonnull
+  <T> FutureRowCount<T> findFutureCount(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find Id's query in a background thread.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a
+   * timeout).
+   * </p>
+   *
+   * @param query       the query to execute the fetch Id's on
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the list of Id's
+   * @see Query#findFutureIds()
+   */
+  @Nonnull
+  <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute find list query in a background thread returning a FutureList object.
+   * <p>
+   * This returns a Future object which can be used to cancel, check the
+   * execution status (isDone etc) and get the value (with or without a timeout).
+   * <p>
+   * This query will execute in it's own PersistenceContext and using its own transaction.
+   * What that means is that it will not share any bean instances with other queries.
+   *
+   * @param query       the query to execute in the background
+   * @param transaction the transaction (can be null).
+   * @return a Future object for the list result of the query
+   * @see Query#findFutureList()
+   */
+  @Nonnull
+  <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction);
+
+  /**
+   * Return a PagedList for this query using firstRow and maxRows.
+   * <p>
+   * The benefit of using this over findList() is that it provides functionality to get the
+   * total row count etc.
+   * </p>
+   * <p>
+   * If maxRows is not set on the query prior to calling findPagedList() then a
+   * PersistenceException is thrown.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   *  PagedList<Order> pagedList = Ebean.find(Order.class)
+   *       .setFirstRow(50)
+   *       .setMaxRows(20)
+   *       .findPagedList();
+   *
+   *       // fetch the total row count in the background
+   *       pagedList.loadRowCount();
+   *
+   *       List<Order> orders = pagedList.getList();
+   *       int totalRowCount = pagedList.getTotalRowCount();
+   *
+   * }</pre>
+   *
+   * @return The PagedList
+   * @see Query#findPagedList()
+   */
+  @Nonnull
+  <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning a set of entity beans.
+   * <p>
+   * Generally you are able to use {@link Query#findSet()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   * <p>
+   * <pre>{@code
+   *
+   * Set<Customer> customers =
+   *     ebeanServer.find(Customer.class)
+   *     .where().ilike("name", "rob%")
+   *     .findSet();
+   *
+   * }</pre>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute
+   * @param transaction the transaction to use (can be null).
+   * @return the set of fetched beans.
+   * @see Query#findSet()
+   */
+  @Nonnull
+  <T> Set<T> findSet(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning the entity beans in a Map.
+   * <p>
+   * Generally you are able to use {@link Query#findMap()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the map of fetched beans.
+   * @see Query#findMap()
+   */
+  @Nonnull
+  <K, T> Map<K, T> findMap(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning a list of values for a single property.
+   * <p>
+   * <h3>Example 1:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    Ebean.find(Customer.class)
+   *      .select("name")
+   *      .orderBy().asc("name")
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   * <h3>Example 2:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    Ebean.find(Customer.class)
+   *      .setDistinct(true)
+   *      .select("name")
+   *      .where().eq("status", Customer.Status.NEW)
+   *      .orderBy().asc("name")
+   *      .setMaxRows(100)
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   *
+   * @return the list of values for the selected property
+   * @see Query#findSingleAttributeList()
+   */
+  @Nonnull
+  <A, T> List<A> findSingleAttributeList(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the query returning at most one entity bean or null (if no matching
+   * bean is found).
+   * <p>
+   * This will throw a NonUniqueResultException if the query finds more than one result.
+   * </p>
+   * <p>
+   * Generally you are able to use {@link Query#findOne()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param <T>         the type of entity bean to fetch.
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched beans.
+   * @throws NonUniqueResultException if more than one result was found
+   * @see Query#findOne()
+   */
+  @Nullable
+  <T> T findOne(Query<T> query, Transaction transaction);
+
+  /**
+   * Similar to findOne() but returns an Optional (rather than nullable).
+   */
+  @Nonnull
+  <T> Optional<T> findOneOrEmpty(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute as a delete query deleting the 'root level' beans that match the predicates
+   * in the query.
+   * <p>
+   * Note that if the query includes joins then the generated delete statement may not be
+   * optimal depending on the database platform.
+   * </p>
+   *
+   * @param query       the query used for the delete
+   * @param transaction the transaction to use (can be null)
+   * @param <T>         the type of entity bean to fetch.
+   * @return the number of beans/rows that were deleted
+   */
+  <T> int delete(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the update query returning the number of rows updated.
+   * <p>
+   * The update query must be created using {@link EbeanServer#update(Class)}.
+   * </p>
+   *
+   * @param query       the update query to execute
+   * @param transaction the optional transaction to use for the update (can be null)
+   * @param <T>         the type of entity bean
+   * @return The number of rows updated
+   */
+  <T> int update(Query<T> query, Transaction transaction);
+
+  /**
+   * Execute the sql query returning a list of MapBean.
+   * <p>
+   * Generally you are able to use {@link SqlQuery#findList()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the list of fetched MapBean.
+   * @see SqlQuery#findList()
+   */
+  @Nonnull
+  List<SqlRow> findList(SqlQuery query, Transaction transaction);
+
+  /**
+   * Execute the SqlQuery iterating a row at a time.
+   * <p>
+   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
+   * </p>
+   */
+  void findEach(SqlQuery query, Consumer<SqlRow> consumer, Transaction transaction);
+
+  /**
+   * Execute the SqlQuery iterating a row at a time with the ability to stop consuming part way through.
+   * <p>
+   * Returning false after processing a row stops the iteration through the query results.
+   * </p>
+   * <p>
+   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
+   * </p>
+   */
+  void findEachWhile(SqlQuery query, Predicate<SqlRow> consumer, Transaction transaction);
+
+  /**
+   * Execute the sql query returning a single MapBean or null.
+   * <p>
+   * This will throw a PersistenceException if the query found more than one
+   * result.
+   * </p>
+   * <p>
+   * Generally you are able to use {@link SqlQuery#findOne()} rather than
+   * explicitly calling this method. You could use this method if you wish to
+   * explicitly control the transaction used for the query.
+   * </p>
+   *
+   * @param query       the query to execute.
+   * @param transaction the transaction to use (can be null).
+   * @return the fetched MapBean or null if none was found.
+   * @see SqlQuery#findOne()
+   */
+  @Nullable
+  SqlRow findOne(SqlQuery query, Transaction transaction);
+
+}

src/main/java/io/ebean/FetchGroup.java

@@ -0,0 +1,114 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Defines what part of the object graph to load (select and fetch clauses).
+ * <p>
+ * Using a FetchGroup effectively sets the select() and fetch() clauses for a query. It is alternative
+ * to specifying the select() and fetch() clauses on the query allowing for more re-use of "what to load"
+ * that can be defined separately from the query and combined with other FetchGroups.
+ * </p>
+ *
+ * <h3>Select example</h3>
+ * <pre>{@code
+ *
+ * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class, "name, status");
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .findList();
+ *
+ * }</pre>
+ *
+ * <h3>Select and fetch example</h3>
+ * <pre>{@code
+ *
+ * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class)
+ *   .select("name, status")
+ *   .fetch("contacts", "firstName, lastName, email")
+ *   .build();
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .findList();
+ *
+ * }</pre>
+ *
+ * <h3>Combining FetchGroups</h3>
+ * <p>
+ *   FetchGroups can be combined together to form another FetchGroup.
+ * </p>
+ * <pre>{@code
+ *
+ *  FetchGroup<Address> FG_ADDRESS = FetchGroup.of(Address.class)
+ *    .select("line1, line2, city")
+ *    .fetch("country", "name")
+ *    .build();
+ *
+ *  FetchGroup<Customer> FG_CUSTOMER = FetchGroup.of(Customer.class)
+ *    .select("name, version")
+ *    .fetch("billingAddress", FG_ADDRESS)
+ *    .build();
+ *
+ *
+ *  Customer.query()
+ *    .select(FG_CUSTOMER)
+ *    .findList();
+ *
+ * }</pre>
+ *
+ * @param <T> The bean type the Fetch group can be applied to
+ */
+public interface FetchGroup<T> {
+
+  /**
+   * Return the FetchGroup with the given select clause.
+   * <p>
+   *   We use this for simple FetchGroup that only select() properties and do not have additional fetch() clause.
+   * </p>
+   * <pre>{@code
+   *
+   * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class, "name, status");
+   *
+   * Customer.query()
+   *   .select(fetchGroup)
+   *   .findList();
+   *
+   * }</pre>
+   *
+   * @param select The select clause of the FetchGroup
+   *
+   * @return The FetchGroup with the given select clause
+   */
+  @Nonnull
+  static <T> FetchGroup<T> of(Class<T> cls, String select) {
+    return XServiceProvider.fetchGroupOf(cls, select);
+  }
+
+  /**
+   * Return the FetchGroupBuilder with the given select clause that we can add fetch clauses to.
+   * <p>
+   * We chain select() with one or more fetch() clauses to define the object graph to load.
+   * </p>
+   * <pre>{@code
+   *
+   * FetchGroup<Customer> fetchGroup = FetchGroup.of(Customer.class)
+   *   .select("name, status")
+   *   .fetch("contacts", "firstName, lastName, email")
+   *   .build();
+   *
+   * Customer.query()
+   *   .select(fetchGroup)
+   *   .findList();
+   *
+   * }</pre>
+   *
+   * @return The FetchGroupBuilder with the given select clause which we will add fetch clauses to
+   */
+  @Nonnull
+  static <T> FetchGroupBuilder<T> of(Class<T> cls) {
+    return XServiceProvider.fetchGroupOf(cls);
+  }
+
+}

src/main/java/io/ebean/FetchGroupBuilder.java

@@ -0,0 +1,93 @@
+package io.ebean;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Builds a FetchGroup by adding fetch clauses.
+ * <p>
+ * We add select() and fetch() clauses to define the object graph we want to load.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ * FetchGroup fetchGroup = FetchGroup
+ *   .select("name, status")
+ *   .fetch("contacts", "firstName, lastName, email")
+ *   .build();
+ *
+ * Customer.query()
+ *   .select(fetchGroup)
+ *   .where()
+ *   ...
+ *   .findList();
+ *
+ * }</pre>
+ */
+public interface FetchGroupBuilder<T> {
+
+  /**
+   * Specify specific properties to select (top level properties).
+   */
+  @Nonnull
+  FetchGroupBuilder<T> select(String select);
+
+  /**
+   * Fetch all the properties at the given path.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path);
+
+  /**
+   * Fetch the path with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path using a query join with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path lazily with the nested fetch group.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path, FetchGroup<?> nestedGroup);
+
+  /**
+   * Fetch the path including specified properties.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetch(String path, String properties);
+
+  /**
+   * Fetch the path including all its properties using a query join.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path);
+
+  /**
+   * Fetch the path including specified properties using a query join.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchQuery(String path, String properties);
+
+  /**
+   * Fetch the path including all its properties lazily.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path);
+
+  /**
+   * Fetch the path including specified properties lazily.
+   */
+  @Nonnull
+  FetchGroupBuilder<T> fetchLazy(String path, String properties);
+
+  /**
+   * Build and return the FetchGroup.
+   */
+  @Nonnull
+  FetchGroup<T> build();
+}

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

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

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

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

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

@@ -2,7 +2,6 @@ package io.ebean;
 
 import io.ebean.bean.EntityBean;
 
-import javax.persistence.MappedSuperclass;
 
 /**
  * A MappedSuperclass base class that provides convenience methods for inserting, updating and
@@ -74,19 +73,17 @@ import javax.persistence.MappedSuperclass;
  *
  * }</pre>
  */
-@MappedSuperclass
 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);
@@ -106,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);
   }
 
   /**
@@ -148,7 +140,7 @@ public abstract class Model {
    *
    * }</pre>
    *
-   * @see EbeanServer#markAsDirty(Object)
+   * @see Database#markAsDirty(Object)
    */
   public void markAsDirty() {
     db().markAsDirty(this);
@@ -184,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);
@@ -204,7 +196,7 @@ public abstract class Model {
   /**
    * Update this entity.
    *
-   * @see EbeanServer#update(Object)
+   * @see Database#update(Object)
    */
   public void update() {
     db().update(this);
@@ -213,7 +205,7 @@ public abstract class Model {
   /**
    * Insert this entity.
    *
-   * @see EbeanServer#insert(Object)
+   * @see Database#insert(Object)
    */
   public void insert() {
     db().insert(this);
@@ -234,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);
@@ -247,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);
@@ -277,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

@@ -1,9 +1,11 @@
 package io.ebean;
 
+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;
 
 /**
  * Represents an Order By for a Query.
@@ -74,6 +76,15 @@ public final class OrderBy<T> implements Serializable {
     return query;
   }
 
+  /**
+   * Add a property with ascending order to this OrderBy.
+   */
+  public Query<T> asc(String propertyName, String collation) {
+
+    list.add(new Property(propertyName, true, collation));
+    return query;
+  }
+
   /**
    * Add a property with descending order to this OrderBy.
    */
@@ -83,6 +94,16 @@ public final class OrderBy<T> implements Serializable {
     return query;
   }
 
+  /**
+   * Add a property with descending order to this OrderBy.
+   */
+  public Query<T> desc(String propertyName, String collation) {
+
+    list.add(new Property(propertyName, false, collation));
+    return query;
+  }
+
+
   /**
    * Return true if the property is known to be contained in the order by clause.
    */
@@ -231,6 +252,8 @@ public final class OrderBy<T> implements Serializable {
 
     private boolean ascending;
 
+    private String collation;
+
     private String nulls;
 
     private String highLow;
@@ -247,17 +270,32 @@ public final class OrderBy<T> implements Serializable {
       this.highLow = highLow;
     }
 
+    public Property(String property, boolean ascending, String collation) {
+      this.property = property;
+      this.ascending = ascending;
+      this.collation = collation;
+    }
+
+    public Property(String property, boolean ascending, String collation, String nulls, String highLow) {
+      this.property = property;
+      this.ascending = ascending;
+      this.collation = collation;
+      this.nulls = nulls;
+      this.highLow = highLow;
+    }
+
     /**
      * Return a copy of this Property with the path trimmed.
      */
     public Property copyWithTrim(String path) {
-      return new Property(property.substring(path.length() + 1), ascending, nulls, highLow);
+      return new Property(property.substring(path.length() + 1), ascending, collation, nulls, highLow);
     }
 
     @Override
     public int hashCode() {
       int hc = property.hashCode();
       hc = hc * 92821 + (ascending ? 0 : 1);
+      hc = hc * 92821 + (collation == null ? 0 : collation.hashCode());
       hc = hc * 92821 + (nulls == null ? 0 : nulls.hashCode());
       hc = hc * 92821 + (highLow == null ? 0 : highLow.hashCode());
       return hc;
@@ -274,8 +312,9 @@ public final class OrderBy<T> implements Serializable {
       Property e = (Property) obj;
       if (ascending != e.ascending) return false;
       if (!property.equals(e.property)) return false;
-      if (nulls != null ? !nulls.equals(e.nulls) : e.nulls != null) return false;
-      return highLow != null ? highLow.equals(e.highLow) : e.highLow == null;
+      if (!Objects.equals(collation, e.collation)) return false;
+      if (!Objects.equals(nulls, e.nulls)) return false;
+      return Objects.equals(highLow, e.highLow);
     }
 
     @Override
@@ -284,7 +323,7 @@ public final class OrderBy<T> implements Serializable {
     }
 
     public String toStringFormat() {
-      if (nulls == null) {
+      if (nulls == null && collation == null) {
         if (ascending) {
           return property;
         } else {
@@ -292,11 +331,23 @@ public final class OrderBy<T> implements Serializable {
         }
       } else {
         StringBuilder sb = new StringBuilder();
-        sb.append(property);
+        if (collation != null)  {
+          if (collation.contains("${}")) {
+            // this is a complex collation, e.g. DB2 - we must replace the property
+            sb.append(StringHelper.replaceString(collation, "${}", property));
+          } else {
+            sb.append(property);
+            sb.append(" collate ").append(collation);
+          }
+        } else {
+          sb.append(property);
+        }
         if (!ascending) {
           sb.append(" ").append("desc");
         }
-        sb.append(" ").append(nulls).append(" ").append(highLow);
+        if (nulls != null) {
+          sb.append(" ").append(nulls).append(" ").append(highLow);
+        }
         return sb.toString();
       }
     }
@@ -319,7 +370,7 @@ public final class OrderBy<T> implements Serializable {
      * Return a copy of this property.
      */
     public Property copy() {
-      return new Property(property, ascending, nulls, highLow);
+      return new Property(property, ascending, collation, nulls, highLow);
     }
 
     /**
@@ -360,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;
     }
@@ -394,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/Pairs.java

@@ -1,6 +1,7 @@
 package io.ebean;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -125,7 +126,7 @@ public class Pairs {
    * Return all the value pairs.
    */
   public List<Entry> getEntries() {
-    return entries;
+    return Collections.unmodifiableList(entries);
   }
 
   /**

src/main/java/io/ebean/PrimaryServer.java

@@ -76,7 +76,6 @@ class PrimaryServer {
     if (defaultServerName == null) {
       defaultServerName = "db";
     }
-    System.setProperty("ebean_db", defaultServerName);
     return defaultServerName;
   }
 

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>
@@ -397,6 +450,11 @@ public interface Query<T> {
    */
   Query<T> select(String fetchProperties);
 
+  /**
+   * Apply the fetchGroup which defines what part of the object graph to load.
+   */
+  Query<T> select(FetchGroup<T> fetchGroup);
+
   /**
    * Specify a path to fetch eagerly including specific properties.
    * <p>
@@ -602,8 +660,6 @@ public interface Query<T> {
    * <p>
    * This query will execute against the EbeanServer that was used to create it.
    * </p>
-   *
-   * @see EbeanServer#findIds(Query, Transaction)
    */
   @Nonnull
   <A> List<A> findIds();
@@ -633,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>
@@ -740,8 +794,6 @@ public interface Query<T> {
    *     .findList();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findList(Query, Transaction)
    */
   @Nonnull
   List<T> findList();
@@ -759,8 +811,6 @@ public interface Query<T> {
    *     .findSet();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findSet(Query, Transaction)
    */
   @Nonnull
   Set<T> findSet();
@@ -782,8 +832,6 @@ public interface Query<T> {
    *     .findMap();
    *
    * }</pre>
-   *
-   * @see EbeanServer#findMap(Query, Transaction)
    */
   @Nonnull
   <K> Map<K, T> findMap();
@@ -841,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).
@@ -927,11 +1006,31 @@ public interface Query<T> {
    */
   int delete();
 
+  /**
+   * Execute as a delete query returning the number of rows deleted using the given transaction.
+   * <p>
+   * Note that if the query includes joins then the generated delete statement may not be
+   * optimal depending on the database platform.
+   * </p>
+   *
+   * @return the number of beans/rows that were deleted.
+   */
+  int delete(Transaction transaction);
+
   /**
    * Execute the UpdateQuery returning the number of rows updated.
+   *
+   * @return the number of beans/rows updated.
    */
   int update();
 
+  /**
+   * Execute the UpdateQuery returning the number of rows updated using the given transaction.
+   *
+   * @return the number of beans/rows updated.
+   */
+  int update(Transaction transaction);
+
   /**
    * Return the count of entities this query should return.
    * <p>
@@ -1312,7 +1411,6 @@ public interface Query<T> {
    *   count:1 orderStatus:COMPLETE
    *
    * }</pre>
-   *
    */
   Query<T> setCountDistinct(CountDistinctOrder orderBy);
 
@@ -1419,6 +1517,15 @@ public interface Query<T> {
    */
   Query<T> setProfileLocation(ProfileLocation profileLocation);
 
+  /**
+   * Set a label on the query.
+   * <p>
+   * This label can be used to help identify query performance metrics but we can also use
+   * profile location enhancement on Finders so for some that would be a better option.
+   * </p>
+   */
+  Query<T> setLabel(String label);
+
   /**
    * Set to true if this query should execute against the doc store.
    * <p>
@@ -1479,15 +1586,6 @@ public interface Query<T> {
    */
   String getGeneratedSql();
 
-  /**
-   * Deprecated - migrate to forUpdate().
-   *
-   * executed the select with "for update" which should lock the record
-   * "on read"
-   */
-  @Deprecated
-  Query<T> setForUpdate(boolean forUpdate);
-
   /**
    * Execute using "for update" clause which results in the DB locking the record.
    */
@@ -1524,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/RowConsumer.java

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

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

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

src/main/java/io/ebean/ScriptRunner.java

@@ -0,0 +1,65 @@
+package io.ebean;
+
+import java.net.URL;
+import java.util.Map;
+
+/**
+ * Runs DDL and SQL scripts.
+ * <p/>
+ * Typically these are scripts used for testing such as seed SQL scripts or truncate SQL scripts.
+ * <p/>
+ * Scripts are executed in their own transaction and committed on successful completion.
+ *
+ * <h3>Example of simple use</h3>
+ * <pre>{@code
+ *
+ *   EbeanServer server = Ebean.getDefaultServer();
+ *   server.script().run("/scripts/test-script.sql");
+ *
+ * }</pre>
+ *
+ *
+ * <h3>Example using place holders in the script</h3>
+ * <pre>{@code
+ *
+ *   Map<String,String> placeholders = new HashMap<>();
+ *   placeholders.put("tableName", "e_basic");
+ *
+ *   EbeanServer server = Ebean.getDefaultServer();
+ *   server.script().run("/scripts/test-script.sql");
+ *
+ * }</pre>
+ */
+public interface ScriptRunner {
+
+  /**
+   * Run a script given the resource path (that should start with "/").
+   */
+  void run(String path);
+
+  /**
+   * Run a script given the resource path (that should start with "/") and place holders.
+   *
+   * <pre>{@code
+   *
+   *   Map<String,String> placeholders = new HashMap<>();
+   *   placeholders.put("tableName", "e_basic");
+   *
+   *   EbeanServer server = Ebean.getDefaultServer();
+   *   server.script().run("/scripts/test-script.sql");
+   *
+   * }</pre>
+   */
+  void run(String path, Map<String, String> placeholderMap);
+
+  /**
+   * Run a DDL or SQL script given the resource.
+   */
+  void run(URL resource);
+
+  /**
+   * Run a DDL or SQL script given the resource and place holders.
+   */
+  void run(URL resource, Map<String, String> placeholderMap);
+
+}

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

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

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

@@ -16,18 +16,90 @@ 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
- * String s = "UPDATE f_topic set post_count = :count where id = :id";
- * SqlUpdate update = Ebean.createSqlUpdate(s);
- * update.setParameter("id", 1);
- * update.setParameter("count", 50);
+ *   // example using 'positioned' parameters
  *
- * int modifiedCount = Ebean.execute(update);
+ *   String sql = "insert into audit_log (group, title, description) values (?, ?, ?);
  *
- * String msg = "There were " + modifiedCount + " rows updated";
+ *   int rows =
+ *     DB.sqlUpdate(sql)
+ *       .setParams("login", "new user", "user rob was created")
+ *       .executeNow();
+ *
+ * }</pre>
+ *
+ * <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>
+ * <h3>Example: Using setNextParameter()</h3>
+ * <pre>{@code
+ *
+ *  String sql = "insert into audit_log (id, description, modified_description) values (?,?,?)";
+ *
+ *  SqlUpdate insert = DB.sqlUpdate(sql);
+ *
+ *  try (Transaction txn = DB.beginTransaction()) {
+ *    txn.setBatchMode(true);
+ *
+ *    insert.setNextParameter(10000);
+ *    insert.setNextParameter("hello");
+ *    insert.setNextParameter("rob");
+ *    insert.execute();
+ *
+ *    insert.setNextParameter(10001);
+ *    insert.setNextParameter("goodbye");
+ *    insert.setNextParameter("rob");
+ *    insert.execute();
+ *
+ *    insert.setNextParameter(10002);
+ *    insert.setNextParameter("chow");
+ *    insert.setNextParameter("bob");
+ *    insert.execute();
+ *
+ *    txn.commit();
+ *  }
+ * }</pre>
+ * <p>
+ * An alternative to the batch mode on the transaction is to use addBatch() and executeBatch() like:
+ * </p>
+ * <pre>{@code
+ *
+ *   try (Transaction txn = DB.beginTransaction()) {
+ *
+ *     insert.setNextParameter(10000);
+ *     insert.setNextParameter("hello");
+ *     insert.setNextParameter("rob");
+ *     insert.addBatch();
+ *
+ *     insert.setNextParameter(10001);
+ *     insert.setNextParameter("goodbye");
+ *     insert.setNextParameter("rob");
+ *     insert.addBatch();
+ *
+ *     insert.setNextParameter(10002);
+ *     insert.setNextParameter("chow");
+ *     insert.setNextParameter("bob");
+ *     insert.addBatch();
+ *
+ *     int[] rows = insert.executeBatch();
+ *
+ *     txn.commit();
+ *   }
  *
  * }</pre>
  *
@@ -40,6 +112,11 @@ public interface SqlUpdate {
   /**
    * Execute the update returning the number of rows modified.
    * <p>
+   * Note that if the transaction has batch mode on then this update will use JDBC batch and may not execute until
+   * later - at commit time or a transaction flush. In this case this method returns -1 indicating that the
+   * update has been batched for later execution.
+   * </p>
+   * <p>
    * After you have executed the SqlUpdate you can bind new variables using
    * {@link #setParameter(String, Object)} etc and then execute the SqlUpdate
    * again.
@@ -54,6 +131,23 @@ public interface SqlUpdate {
    */
   int execute();
 
+  /**
+   * Execute the statement now regardless of the JDBC batch mode of the transaction.
+   */
+  int executeNow();
+
+  /**
+   * Execute when addBatch() has been used to batch multiple bind executions.
+   *
+   * @return The row counts for each of the batched statements.
+   */
+  int[] executeBatch();
+
+  /**
+   * Add the statement to batch processing to then later execute via executeBatch().
+   */
+  void addBatch();
+
   /**
    * Return the generated key value.
    */
@@ -61,7 +155,7 @@ public interface SqlUpdate {
 
   /**
    * Execute and return the generated key. This is effectively a short cut for:
-   *
+   * <p>
    * <pre>{@code
    *
    *   sqlUpdate.execute();
@@ -137,6 +231,40 @@ 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.
+   *
+   * @param value The value to bind
+   */
+  SqlUpdate setNextParameter(Object value);
+
   /**
    * Set a parameter via its index position.
    */

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

@@ -23,6 +23,7 @@ public interface Transaction extends AutoCloseable {
    * This returns the current transaction for the 'default server'.  If you are using
    * multiple EbeanServer's then use {@link EbeanServer#currentTransaction()}.
    * </p>
+   *
    * @see Ebean#currentTransaction()
    * @see EbeanServer#currentTransaction()
    */
@@ -83,7 +84,7 @@ public interface Transaction extends AutoCloseable {
    * <p>
    * This is similar to commit() but leaves the transaction "Active".
    * </p>
-   * <h3>Functions/h3>
+   * <h3>Functions</h3>
    * <ul>
    * <li>Flush the JDBC batch buffer</li>
    * <li>Call commit on the underlying JDBC connection</li>
@@ -99,7 +100,7 @@ public interface Transaction extends AutoCloseable {
    * This performs commit and completes the transaction closing underlying resources and
    * marking the transaction as "In active".
    * </p>
-   * <h3>Functions/h3>
+   * <h3>Functions</h3>
    * <ul>
    * <li>Flush the JDBC batch buffer</li>
    * <li>Call commit on the underlying JDBC connection</li>
@@ -116,7 +117,7 @@ public interface Transaction extends AutoCloseable {
    * <p>
    * This performs rollback, closes underlying resources and marks the transaction as "In active".
    * </p>
-   * <h3>Functions/h3>
+   * <h3>Functions</h3>
    * <ul>
    * <li>Call rollback on the underlying JDBC connection</li>
    * <li>Trigger any registered TransactionCallbacks</li>
@@ -136,6 +137,18 @@ public interface Transaction extends AutoCloseable {
    */
   void rollback(Throwable e) throws PersistenceException;
 
+  /**
+   * Set when we want nested transactions to use Savepoint's.
+   * <p>
+   * This means that for a nested transaction:
+   * <ul>
+   * <li>begin transaction maps to creating a savepoint</li>
+   * <li>commit transaction maps to releasing a savepoint</li>
+   * <li>rollback transaction maps to rollback a savepoint</li>
+   * </ul>
+   */
+  void setNestedUseSavepoint();
+
   /**
    * Mark the transaction for rollback only.
    */
@@ -151,7 +164,6 @@ public interface Transaction extends AutoCloseable {
    */
   void end();
 
-
   /**
    * Synonym for end() to support AutoClosable.
    */
@@ -227,13 +239,12 @@ public interface Transaction extends AutoCloseable {
    * Refer to {@link ServerConfig#setSkipCacheAfterWrite(boolean)} for configuring the default behavior
    * for using the L2 bean cache in transactions spanning multiple query/persist requests.
    * </p>
-   * <p>
+   *
    * <pre>{@code
    *
    *   // assume Customer has L2 bean caching enabled ...
    *
-   *   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
@@ -241,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"
@@ -261,8 +272,7 @@ public interface Transaction extends AutoCloseable {
    *     Customer.find.byId(99); // skips l2 bean cache
    *
    *
-   *   } finally {
-   *     transaction.end();
+   *     transaction.commit();
    *   }
    *
    * }</pre>
@@ -278,38 +288,68 @@ 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
    *
    * String data = "This is a simple test of the batch processing"
@@ -322,49 +362,34 @@ 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>
    */
   void setBatchMode(boolean useBatch);
 
-  /**
-   * The JDBC batch mode to use for this transaction.
-   * <p>
-   * If this is NONE then JDBC batch can still be used for each request - save(), insert(), update() or delete()
-   * and this would be useful if the request cascades to detail beans.
-   * </p>
-   *
-   * @param persistBatchMode the batch mode to use for this transaction
-   * @see io.ebean.config.ServerConfig#setPersistBatch(PersistBatch)
-   */
-  void setBatch(PersistBatch persistBatchMode);
-
   /**
    * Return the batch mode at the transaction level.
    */
-  PersistBatch getBatch();
+  boolean isBatchMode();
 
   /**
-   * Set the JDBC batch mode to use for a save() or delete() request.
+   * Set the JDBC batch mode to use for a save() or delete() when cascading to children.
    * <p>
    * This only takes effect when batch mode on the transaction has not already meant that
    * JDBC batch mode is being used.
@@ -373,16 +398,19 @@ public interface Transaction extends AutoCloseable {
    * This is useful when the single save() or delete() cascades. For example, inserting a 'master' cascades
    * and inserts a collection of 'detail' beans. The detail beans can be inserted using JDBC batch.
    * </p>
+   * <p>
+   * This is effectively already turned on for all platforms apart from older Sql Server.
+   * </p>
    *
-   * @param batchOnCascadeMode the batch mode to use per save(), insert(), update() or delete()
+   * @param batchMode the batch mode to use per save(), insert(), update() or delete()
    * @see io.ebean.config.ServerConfig#setPersistBatchOnCascade(PersistBatch)
    */
-  void setBatchOnCascade(PersistBatch batchOnCascadeMode);
+  void setBatchOnCascade(boolean batchMode);
 
   /**
-   * Return the batch mode at the request level (for each save(), insert(), update() or delete()).
+   * Return the batch mode at the request level.
    */
-  PersistBatch getBatchOnCascade();
+  boolean isBatchOnCascade();
 
   /**
    * Specify the number of statements before a batch is flushed automatically.

src/main/java/io/ebean/TxScope.java

@@ -432,4 +432,11 @@ public final class TxScope {
     return this;
   }
 
+  public boolean isBatchMode() {
+    return PersistBatch.ALL.equals(batch);
+  }
+
+  public boolean isBatchOnCascade() {
+    return PersistBatch.ALL.equals(batchOnCascade);
+  }
 }

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

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

src/main/java/io/ebean/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/XServiceProvider.java

@@ -1,5 +1,6 @@
 package io.ebean;
 
+import io.ebean.service.SpiFetchGroupService;
 import io.ebean.service.SpiProfileLocationFactory;
 import io.ebean.service.SpiRawSqlService;
 
@@ -15,6 +16,16 @@ class XServiceProvider {
 
   private static SpiProfileLocationFactory profileLocationFactory = initProfileLocation();
 
+  private static SpiFetchGroupService fetchGroupService = initSpiFetchGroupService();
+
+  private static SpiFetchGroupService initSpiFetchGroupService() {
+    Iterator<SpiFetchGroupService> loader = ServiceLoader.load(SpiFetchGroupService.class).iterator();
+    if (loader.hasNext()) {
+      return loader.next();
+    }
+    throw new IllegalStateException("No service implementation found for SpiFetchGroupService?");
+  }
+
   private static SpiRawSqlService initRawSql() {
 
     Iterator<SpiRawSqlService> loader = ServiceLoader.load(SpiRawSqlService.class).iterator();
@@ -47,4 +58,17 @@ class XServiceProvider {
     return profileLocationFactory;
   }
 
+  /**
+   * Return the FetchGroup with the given select clause.
+   */
+  static <T> FetchGroup<T> fetchGroupOf(Class<T> cls, String select) {
+    return fetchGroupService.of(cls, select);
+  }
+
+  /**
+   * Return the FetchGroupBuilder with the given select clause.
+   */
+  static <T> FetchGroupBuilder<T> fetchGroupOf(Class<T> cls) {
+    return fetchGroupService.of(cls);
+  }
 }

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

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

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

@@ -52,6 +52,8 @@ public final class EntityBeanIntercept implements Serializable {
    */
   private int state;
 
+  private boolean forceUpdate;
+
   private boolean readOnly;
 
   private boolean dirty;
@@ -69,24 +71,35 @@ public final class EntityBeanIntercept implements Serializable {
   /**
    * Used when a bean is partially filled.
    */
-  private final boolean[] loadedProps;
-
-  private boolean fullyLoadedBean;
+  private static final byte FLAG_LOADED_PROP = 1;
 
   /**
    * Set of changed properties.
    */
-  private boolean[] changedProps;
+  private static final byte FLAG_CHANGED_PROP = 2;
 
   /**
    * Flags indicating if a property is a dirty embedded bean. Used to distingush
    * between an embedded bean being completely overwritten and one of its
    * embedded properties being made dirty.
    */
-  private boolean[] embeddedDirty;
+  private static final byte FLAG_EMBEDDED_DIRTY = 4;
+
+  /**
+   * Flags indicating if a property is a dirty embedded bean. Used to distingush
+   * between an embedded bean being completely overwritten and one of its
+   * embedded properties being made dirty.
+   */
+  private static final byte FLAG_ORIG_VALUE_SET = 8;
+
+  private final byte[] flags;
+
+  private boolean fullyLoadedBean;
 
   private Object[] origValues;
 
+  private Exception[] loadErrors;
+
   private int lazyLoadProperty = -1;
 
   private Object ownerId;
@@ -100,7 +113,7 @@ public final class EntityBeanIntercept implements Serializable {
    */
   public EntityBeanIntercept(Object ownerBean) {
     this.owner = (EntityBean) ownerBean;
-    this.loadedProps = new boolean[owner._ebean_getPropertyNames().length];
+    this.flags = new byte[owner._ebean_getPropertyNames().length];
   }
 
   /**
@@ -131,6 +144,20 @@ public final class EntityBeanIntercept implements Serializable {
     this.nodeUsageCollector = usageCollector;
   }
 
+  /**
+   * Return the ownerId (IdClass).
+   */
+  public Object getOwnerId() {
+    return ownerId;
+  }
+
+  /**
+   * Set the ownerId (IdClass).
+   */
+  public void setOwnerId(Object ownerId) {
+    this.ownerId = ownerId;
+  }
+
   /**
    * Return the owning bean for an embedded bean.
    */
@@ -197,8 +224,8 @@ public final class EntityBeanIntercept implements Serializable {
    * Check each property to see if the bean is partially loaded.
    */
   public boolean isPartial() {
-    for (boolean loadedProp : loadedProps) {
-      if (!loadedProp) {
+    for (byte flag : flags) {
+      if ((flag & FLAG_LOADED_PROP) == 0) {
         return true;
       }
     }
@@ -243,10 +270,10 @@ public final class EntityBeanIntercept implements Serializable {
    * Return true if only the Id property has been loaded.
    */
   public boolean hasIdOnly(int idIndex) {
-    for (int i = 0; i < loadedProps.length; i++) {
+    for (int i = 0; i < flags.length; i++) {
       if (i == idIndex) {
-        if (!loadedProps[i]) return false;
-      } else if (loadedProps[i]) {
+        if ((flags[i] & FLAG_LOADED_PROP) == 0) return false;
+      } else if ((flags[i] & FLAG_LOADED_PROP) != 0) {
         return false;
       }
     }
@@ -268,9 +295,9 @@ public final class EntityBeanIntercept implements Serializable {
     if (idPos > -1) {
       // For cases where properties are set on constructor
       // set every non Id property to unloaded (for lazy loading)
-      for (int i = 0; i < loadedProps.length; i++) {
+      for (int i = 0; i < flags.length; i++) {
         if (i != idPos) {
-          loadedProps[i] = false;
+          flags[i] &= ~FLAG_LOADED_PROP;
         }
       }
     }
@@ -292,6 +319,20 @@ public final class EntityBeanIntercept implements Serializable {
     this.readOnly = readOnly;
   }
 
+  /**
+   * Set the bean to be updated when persisted (for merge).
+   */
+  public void setForceUpdate(boolean forceUpdate) {
+    this.forceUpdate = forceUpdate;
+  }
+
+  /**
+   * Return true if the entity should be updated.
+   */
+  public boolean isUpdate() {
+    return forceUpdate || state == STATE_LOADED;
+  }
+
   /**
    * Return true if the entity has been loaded.
    */
@@ -322,7 +363,9 @@ public final class EntityBeanIntercept implements Serializable {
     this.owner._ebean_setEmbeddedLoaded();
     this.lazyLoadProperty = -1;
     this.origValues = null;
-    this.changedProps = null;
+    for (int i = 0; i < flags.length; i++) {
+      flags[i] &= ~(FLAG_CHANGED_PROP + FLAG_ORIG_VALUE_SET);
+    }
     this.dirty = false;
   }
 
@@ -445,7 +488,11 @@ public final class EntityBeanIntercept implements Serializable {
     if (position == -1) {
       throw new IllegalArgumentException("Property " + propertyName + " not found");
     }
-    loadedProps[position] = loaded;
+    if (loaded) {
+      flags[position] |= FLAG_LOADED_PROP;
+    } else {
+      flags[position] &= ~FLAG_LOADED_PROP;
+    }
   }
 
   /**
@@ -453,22 +500,22 @@ public final class EntityBeanIntercept implements Serializable {
    * constructor.
    */
   public void setPropertyUnloaded(int propertyIndex) {
-    loadedProps[propertyIndex] = false;
+    flags[propertyIndex] &= ~FLAG_LOADED_PROP;
   }
 
   /**
    * Set the property to be loaded.
    */
   public void setLoadedProperty(int propertyIndex) {
-    loadedProps[propertyIndex] = true;
+    flags[propertyIndex] |= FLAG_LOADED_PROP;
   }
 
   /**
    * Set all properties to be loaded (post insert).
    */
   public void setLoadedPropertyAll() {
-    for (int i = 0; i < loadedProps.length; i++) {
-      loadedProps[i] = true;
+    for (int i = 0; i < flags.length; i++) {
+      flags[i] |= FLAG_LOADED_PROP;
     }
   }
 
@@ -476,14 +523,14 @@ public final class EntityBeanIntercept implements Serializable {
    * Return true if the property is loaded.
    */
   public boolean isLoadedProperty(int propertyIndex) {
-    return loadedProps[propertyIndex];
+    return (flags[propertyIndex] & FLAG_LOADED_PROP) != 0;
   }
 
   /**
    * Return true if the property is considered changed.
    */
   public boolean isChangedProperty(int propertyIndex) {
-    return (changedProps != null && changedProps[propertyIndex]);
+    return (flags[propertyIndex] & FLAG_CHANGED_PROP) != 0;
   }
 
   /**
@@ -491,8 +538,7 @@ public final class EntityBeanIntercept implements Serializable {
    * embedded properties is dirty.
    */
   public boolean isDirtyProperty(int propertyIndex) {
-    return (changedProps != null && changedProps[propertyIndex]
-      || embeddedDirty != null && embeddedDirty[propertyIndex]);
+    return (flags[propertyIndex] & (FLAG_CHANGED_PROP + FLAG_EMBEDDED_DIRTY)) != 0;
   }
 
   /**
@@ -504,27 +550,22 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   public void setChangedProperty(int propertyIndex) {
-    if (changedProps == null) {
-      changedProps = new boolean[owner._ebean_getPropertyNames().length];
-    }
-    changedProps[propertyIndex] = true;
+    flags[propertyIndex] |= FLAG_CHANGED_PROP;
   }
 
   /**
    * Set that an embedded bean has had one of its properties changed.
    */
   private void setEmbeddedPropertyDirty(int propertyIndex) {
-    if (embeddedDirty == null) {
-      embeddedDirty = new boolean[owner._ebean_getPropertyNames().length];
-    }
-    embeddedDirty[propertyIndex] = true;
+    flags[propertyIndex] |= FLAG_EMBEDDED_DIRTY;
   }
 
   private void setOriginalValue(int propertyIndex, Object value) {
     if (origValues == null) {
       origValues = new Object[owner._ebean_getPropertyNames().length];
     }
-    if (origValues[propertyIndex] == null) {
+    if ((flags[propertyIndex] & FLAG_ORIG_VALUE_SET) == 0) {
+      flags[propertyIndex] |= FLAG_ORIG_VALUE_SET;
       origValues[propertyIndex] = value;
     }
   }
@@ -544,13 +585,9 @@ public final class EntityBeanIntercept implements Serializable {
    */
   public void setNewBeanForUpdate() {
 
-    if (changedProps == null) {
-      changedProps = new boolean[owner._ebean_getPropertyNames().length];
-    }
-
-    for (int i = 0; i < loadedProps.length; i++) {
-      if (loadedProps[i]) {
-        changedProps[i] = true;
+    for (int i = 0; i < flags.length; i++) {
+      if ((flags[i] & FLAG_LOADED_PROP) != 0) {
+        flags[i] |= FLAG_CHANGED_PROP;
       }
     }
     setDirty(true);
@@ -564,8 +601,8 @@ public final class EntityBeanIntercept implements Serializable {
       return null;
     }
     Set<String> props = new LinkedHashSet<>();
-    for (int i = 0; i < loadedProps.length; i++) {
-      if (loadedProps[i]) {
+    for (int i = 0; i < flags.length; i++) {
+      if ((flags[i] & FLAG_LOADED_PROP) != 0) {
         props.add(getProperty(i));
       }
     }
@@ -579,12 +616,8 @@ public final class EntityBeanIntercept implements Serializable {
     int len = getPropertyLength();
     boolean[] dirties = new boolean[len];
     for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
-        dirties[i] = true;
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
-        // an embedded property has been changed - recurse
-        dirties[i] = true;
-      }
+      // this, or an embedded property has been changed - recurse
+      dirties[i] = (flags[i] & (FLAG_CHANGED_PROP + FLAG_EMBEDDED_DIRTY)) != 0;
     }
     return dirties;
   }
@@ -604,11 +637,11 @@ public final class EntityBeanIntercept implements Serializable {
   public void addDirtyPropertyNames(Set<String> props, String prefix) {
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
         // the property has been changed on this bean
         String propName = (prefix == null ? getProperty(i) : prefix + getProperty(i));
         props.add(propName);
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         // an embedded property has been changed - recurse
         EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
         embeddedBean._ebean_getIntercept().addDirtyPropertyNames(props, getProperty(i) + ".");
@@ -624,12 +657,12 @@ public final class EntityBeanIntercept implements Serializable {
     String[] names = owner._ebean_getPropertyNames();
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
         // the property has been changed on this bean
         if (propertyNames.contains(names[i])) {
           return true;
         }
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         if (propertyNames.contains(names[i])) {
           return true;
         }
@@ -653,15 +686,16 @@ public final class EntityBeanIntercept implements Serializable {
   public void addDirtyPropertyValues(Map<String, ValuePair> dirtyValues, String prefix) {
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
         // the property has been changed on this bean
         String propName = (prefix == null ? getProperty(i) : prefix + getProperty(i));
         Object newVal = owner._ebean_getField(i);
         Object oldVal = getOrigValue(i);
+        if (!areEqual(oldVal, newVal)) {
+          dirtyValues.put(propName, new ValuePair(newVal, oldVal));
+        }
 
-        dirtyValues.put(propName, new ValuePair(newVal, oldVal));
-
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         // an embedded property has been changed - recurse
         EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
         embeddedBean._ebean_getIntercept().addDirtyPropertyValues(dirtyValues, getProperty(i) + ".");
@@ -675,13 +709,15 @@ public final class EntityBeanIntercept implements Serializable {
   public void addDirtyPropertyValues(BeanDiffVisitor visitor) {
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
         // the property has been changed on this bean
         Object newVal = owner._ebean_getField(i);
         Object oldVal = getOrigValue(i);
-        visitor.visit(i, newVal, oldVal);
+        if (!areEqual(oldVal, newVal)) {
+          visitor.visit(i, newVal, oldVal);
+        }
 
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         // an embedded property has been changed - recurse
         EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
         visitor.visitPush(i);
@@ -709,9 +745,9 @@ public final class EntityBeanIntercept implements Serializable {
     }
     int len = getPropertyLength();
     for (int i = 0; i < len; i++) {
-      if (changedProps != null && changedProps[i]) {
+      if ((flags[i] & FLAG_CHANGED_PROP) != 0) {
         sb.append(i).append(',');
-      } else if (embeddedDirty != null && embeddedDirty[i]) {
+      } else if ((flags[i] & FLAG_EMBEDDED_DIRTY) != 0) {
         // an embedded property has been changed - recurse
         EntityBean embeddedBean = (EntityBean) owner._ebean_getField(i);
         sb.append(i).append('[');
@@ -735,15 +771,12 @@ public final class EntityBeanIntercept implements Serializable {
     return sb;
   }
 
-  /**
-   * Return the set of property names for changed properties.
-   */
-  public boolean[] getChanged() {
-    return changedProps;
-  }
-
   public boolean[] getLoaded() {
-    return loadedProps;
+    boolean[] ret= new boolean[flags.length];
+    for (int i = 0; i < ret.length; i++) {
+      ret[i] = (flags[i] & FLAG_LOADED_PROP) != 0;
+    }
+    return ret;
   }
 
   /**
@@ -791,14 +824,14 @@ public final class EntityBeanIntercept implements Serializable {
    */
   private void loadBeanInternal(int loadProperty, BeanLoader loader) {
 
-    if (loadedProps == null || loadedProps[loadProperty]) {
+    if ((flags[loadProperty] & FLAG_LOADED_PROP) != 0) {
       // race condition where multiple threads calling preGetter concurrently
       return;
     }
 
     if (lazyLoadFailure) {
       // failed when batch lazy loaded by another bean in the batch
-      throw new EntityNotFoundException("Lazy loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted");
+      throw new EntityNotFoundException("(Lazy) loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted");
     }
 
     if (lazyLoadProperty == -1) {
@@ -857,7 +890,7 @@ public final class EntityBeanIntercept implements Serializable {
    * Called when a BeanCollection is initialised automatically.
    */
   public void initialisedMany(int propertyIndex) {
-    loadedProps[propertyIndex] = true;
+    flags[propertyIndex] |= FLAG_LOADED_PROP;
   }
 
   private void preGetterCallback(int propertyIndex) {
@@ -1084,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/QueryCacheEntry.java

@@ -0,0 +1,54 @@
+package io.ebean.cache;
+
+import java.util.Set;
+
+/**
+ * For query cache entries we additionally hold the dependent tables and timestamp for the query result.
+ * <p>
+ * We use the dependent tables and timestamp to validate that tables the query joins to have not been
+ * modified since the query cache entry was cached. If any dependent tables have since been modified
+ * the query cache entry is treated as invalid.
+ * </p>
+ */
+public class QueryCacheEntry {
+
+  private final Object value;
+
+  private final Set<String> dependentTables;
+
+  private final long timestamp;
+
+  /**
+   * Create with dependent tables and timestamp.
+   *
+   * @param value           The query result being cached
+   * @param dependentTables The extra tables the query is dependent on (joins to)
+   * @param timestamp       The timestamp that the query uses to check for modifications
+   */
+  public QueryCacheEntry(Object value, Set<String> dependentTables, long timestamp) {
+    this.value = value;
+    this.dependentTables = dependentTables;
+    this.timestamp = timestamp;
+  }
+
+  /**
+   * Return the actual query result.
+   */
+  public Object getValue() {
+    return value;
+  }
+
+  /**
+   * Return the tables the query result is dependent on.
+   */
+  public Set<String> getDependentTables() {
+    return dependentTables;
+  }
+
+  /**
+   * Return the timestamp used to check for modifications on the dependent tables.
+   */
+  public long getTimestamp() {
+    return timestamp;
+  }
+}

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

@@ -0,0 +1,12 @@
+package io.ebean.cache;
+
+/**
+ * Used to validate that a query cache entry is still valid based on dependent tables.
+ */
+public interface QueryCacheEntryValidate {
+
+  /**
+   * Return true if the entry is still valid based on dependent tables.
+   */
+  boolean isValid(QueryCacheEntry queryCacheEntry);
+}

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

@@ -0,0 +1,65 @@
+package io.ebean.cache;
+
+import io.ebean.config.CurrentTenantProvider;
+
+/**
+ * Configuration used to create ServerCache instances.
+ */
+public class ServerCacheConfig {
+
+  private final ServerCacheType type;
+  private final String cacheKey;
+  private final ServerCacheOptions cacheOptions;
+  private final CurrentTenantProvider tenantProvider;
+  private final QueryCacheEntryValidate queryCacheEntryValidate;
+
+  public ServerCacheConfig(ServerCacheType type, String cacheKey, ServerCacheOptions cacheOptions, CurrentTenantProvider tenantProvider, QueryCacheEntryValidate queryCacheEntryValidate) {
+    this.type = type;
+    this.cacheKey = cacheKey;
+    this.cacheOptions = cacheOptions;
+    this.tenantProvider = tenantProvider;
+    this.queryCacheEntryValidate = queryCacheEntryValidate;
+  }
+
+  /**
+   * Return the cache type.
+   */
+  public ServerCacheType getType() {
+    return type;
+  }
+
+  /**
+   * Return the name of the cache.
+   */
+  public String getCacheKey() {
+    return cacheKey;
+  }
+
+  /**
+   * Return the tuning options.
+   */
+  public ServerCacheOptions getCacheOptions() {
+    return cacheOptions;
+  }
+
+  /**
+   * Return the current tenant provider.
+   */
+  public CurrentTenantProvider getTenantProvider() {
+    return tenantProvider;
+  }
+
+  /**
+   * Return the service that provides validation for query cache entries.
+   */
+  public QueryCacheEntryValidate getQueryCacheEntryValidate() {
+    return queryCacheEntryValidate;
+  }
+
+  /**
+   * Return true if the cache is a query cache.
+   */
+  public boolean isQueryCache() {
+    return type == ServerCacheType.QUERY;
+  }
+}

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

@@ -1,7 +1,5 @@
 package io.ebean.cache;
 
-import io.ebean.config.CurrentTenantProvider;
-
 /**
  * Defines method for constructing caches for beans and queries.
  */
@@ -10,6 +8,15 @@ public interface ServerCacheFactory {
   /**
    * Create the cache for the given type with options.
    */
-  ServerCache createCache(ServerCacheType type, String cacheKey, CurrentTenantProvider tenantProvider, ServerCacheOptions cacheOptions);
+  ServerCache createCache(ServerCacheConfig config);
 
+  /**
+   * Return a ServerCacheNotify that we will send ServerCacheNotification events to.
+   * <p>
+   * This is used if a ServerCacheNotifyPlugin is not supplied.
+   * </p>
+   *
+   * @param listener The listener that should be used to process the notification events.
+   */
+  ServerCacheNotify createCacheNotify(ServerCacheNotify listener);
 }

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

@@ -0,0 +1,34 @@
+package io.ebean.cache;
+
+import java.util.Set;
+
+/**
+ * Notification event that dependent tables have been modified.
+ * <p>
+ * This is sent to other interested servers (in the cluster).
+ * </p>
+ */
+public class ServerCacheNotification {
+
+  private final long modifyTimestamp;
+
+  private final Set<String> dependentTables;
+
+  public ServerCacheNotification(long modifyTimestamp, Set<String> dependentTables) {
+    this.modifyTimestamp = modifyTimestamp;
+    this.dependentTables = dependentTables;
+  }
+
+  @Override
+  public String toString() {
+    return "ts:" + modifyTimestamp + " tables:" + dependentTables;
+  }
+
+  public long getModifyTimestamp() {
+    return modifyTimestamp;
+  }
+
+  public Set<String> getDependentTables() {
+    return dependentTables;
+  }
+}

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

@@ -0,0 +1,12 @@
+package io.ebean.cache;
+
+/**
+ * Interface for both listening to notification changes and sending them to other members of the cluster.
+ */
+public interface ServerCacheNotify {
+
+  /**
+   * Notify other server cache members of the table modifications or process the notifications.
+   */
+  void notify(ServerCacheNotification notification);
+}

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

@@ -0,0 +1,17 @@
+package io.ebean.cache;
+
+import io.ebean.config.ServerConfig;
+
+/**
+ * Plugin that provides a ServerCacheNotify implementation.
+ * <p>
+ * Is supplied this will be used to send the ServerCacheNotification event to other cluster members.
+ * </p>
+ */
+public interface ServerCacheNotifyPlugin {
+
+  /**
+   * Create a ServerCacheNotify implementation given the server configuration.
+   */
+  ServerCacheNotify create(ServerConfig serverConfig);
+}

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/common/AbstractBeanCollection.java

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

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

@@ -123,7 +123,7 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
   private void initClear() {
     synchronized (this) {
       if (map == null) {
-        if (modifyListening) {
+        if (!disableLazyLoad && modifyListening) {
           lazyLoadCollection(true);
         } else {
           map = new LinkedHashMap<>();
@@ -135,7 +135,11 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
   private void init() {
     synchronized (this) {
       if (map == null) {
-        lazyLoadCollection(false);
+        if (disableLazyLoad) {
+          map = new LinkedHashMap<>();
+        } else {
+          lazyLoadCollection(false);
+        }
       }
     }
   }
@@ -273,14 +277,16 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
     checkReadOnly();
     init();
     if (modifyListening) {
-      Object oldBean = map.put(key, value);
+      E oldBean = map.put(key, value);
       if (value != oldBean) {
         // register the add of the new and the removal of the old
         modifyAddition(value);
         modifyRemoval(oldBean);
       }
+      return oldBean;
+    } else {
+      return map.put(key, value);
     }
-    return map.put(key, value);
   }
 
   @Override
@@ -295,8 +301,9 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
           modifyRemoval(oldBean);
         }
       }
+    } else {
+      map.putAll(puts);
     }
-    map.putAll(puts);
   }
 
   @Override

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

@@ -116,7 +116,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   private void initClear() {
     synchronized (this) {
       if (set == null) {
-        if (modifyListening) {
+        if (!disableLazyLoad && modifyListening) {
           lazyLoadCollection(true);
         } else {
           set = new LinkedHashSet<>();
@@ -128,7 +128,11 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   private void init() {
     synchronized (this) {
       if (set == null) {
-        lazyLoadCollection(true);
+        if (disableLazyLoad) {
+          set = new LinkedHashSet<>();
+        } else {
+          lazyLoadCollection(true);
+        }
       }
     }
   }
@@ -377,7 +381,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
       throw new IllegalStateException("This collection is in ReadOnly mode");
     }
   }
-  
+
   @Override
   public BeanCollection<E> getShallowCopy() {
     BeanSet<E> copy = new BeanSet<>(new LinkedHashSet<>(set));

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

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

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

@@ -0,0 +1,15 @@
+package io.ebean.config;
+
+/**
+ * Throw when an processing an entity bean that is not bytecode enhanced.
+ *
+ * Refer: https://ebean.io/docs/trouble-shooting#not-enhanced
+ */
+public class BeanNotEnhancedException extends IllegalStateException {
+
+  private static final long serialVersionUID = 3008101919425876799L;
+
+  public BeanNotEnhancedException(String msg) {
+    super(msg);
+  }
+}

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

@@ -0,0 +1,15 @@
+package io.ebean.config;
+
+/**
+ * Throw when an processing thinks a bean is not registered.
+ *
+ * Refer: https://ebean.io/docs/trouble-shooting#not-registered
+ */
+public class BeanNotRegisteredException extends IllegalStateException {
+
+  private static final long serialVersionUID = -1411298126011136552L;
+
+  public BeanNotRegisteredException(String msg) {
+    super(msg);
+  }
+}

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;
 
@@ -28,39 +27,13 @@ public class DbMigrationConfig {
    */
   protected Platform platform;
 
-  /**
-   * Set to true if the DB migration should be generated on server start.
-   */
-  protected boolean generate;
-
-  /**
-   * The migration version name (typically FlywayDb compatible).
-   * <p>
-   * Example: 1.1.1_2
-   * <p>
-   * The version is expected to be the combination of the current pom version plus
-   * a 'feature' id. The combined version must be unique and ordered to work with
-   * FlywayDb so each developer sets a unique version so that the migration script
-   * generated is unique (typically just prior to being submitted as a merge request).
-   */
-  protected String version;
-
-  /**
-   * Description text that can be appended to the version to become the ddl script file name.
-   * <p>
-   * So if the name is "a foo table" then the ddl script file could be:
-   * "1.1.1_2__a-foo-table.sql"
-   * <p>
-   * When the DB migration relates to a git feature (merge request) then this description text
-   * is a short description of the feature.
-   */
-  protected String name;
-
   /**
    * Resource path for the migration xml and sql.
    */
   protected String migrationPath = "dbmigration";
 
+  protected String migrationInitPath = "dbinit";
+
   /**
    * Subdirectory the model xml files go into.
    */
@@ -75,13 +48,6 @@ public class DbMigrationConfig {
 
   protected String modelSuffix = ".model.xml";
 
-  protected boolean includeGeneratedFileComment;
-
-  /**
-   * The version of a pending drop that should be generated as the next migration.
-   */
-  protected String generatePendingDrop;
-
   /**
    * For running migration the DB table that holds migration execution status.
    */
@@ -102,6 +68,16 @@ public class DbMigrationConfig {
    */
   protected Map<String, String> runPlaceholderMap;
 
+  /**
+   * DB schema used for the migration (and testing).
+   */
+  protected String dbSchema;
+
+  /**
+   * Set to true if we consider this the 'default schema' (Postgres schema that matches DB username)
+   */
+  protected boolean defaultDbSchema;
+
   /**
    * DB user used to run the DB migration.
    */
@@ -143,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.
    */
@@ -218,52 +203,6 @@ public class DbMigrationConfig {
     this.applyPrefix = applyPrefix;
   }
 
-  /**
-   * Return true if the generated file comment should be included.
-   */
-  public boolean isIncludeGeneratedFileComment() {
-    return includeGeneratedFileComment;
-  }
-
-  /**
-   * Set to true if the generated file comment should be included.
-   */
-  public void setIncludeGeneratedFileComment(boolean includeGeneratedFileComment) {
-    this.includeGeneratedFileComment = includeGeneratedFileComment;
-  }
-
-  /**
-   * Return the migration version (or "next") to generate pending drops for.
-   */
-  public String getGeneratePendingDrop() {
-    return generatePendingDrop;
-  }
-
-  /**
-   * Set the migration version (or "next") to generate pending drops for.
-   */
-  public void setGeneratePendingDrop(String generatePendingDrop) {
-    this.generatePendingDrop = generatePendingDrop;
-  }
-
-  /**
-   * Set the migration version.
-   * <p>
-   * Note that version set via System property or environment variable <code>ddl.migration.version</code> takes precedence.
-   */
-  public void setVersion(String version) {
-    this.version = version;
-  }
-
-  /**
-   * Set the migration name.
-   * <p>
-   * Note that name set via System property or environment variable <code>ddl.migration.name</code> takes precedence.
-   */
-  public void setName(String name) {
-    this.name = name;
-  }
-
   /**
    * Return the table name that holds the migration run details
    * (used by DB Migration runner only).
@@ -373,6 +312,39 @@ public class DbMigrationConfig {
     this.dbPassword = dbPassword;
   }
 
+  /**
+   * Return the DB schema to use (for migration, testing etc).
+   */
+  public String getDbSchema() {
+    String schema = readEnvironment("ddl.migration.schema");
+    if (schema != null) {
+      return schema;
+    }
+    return dbSchema;
+  }
+
+  /**
+   * Set the Db schema to use.
+   */
+  public void setDbSchema(String dbSchema) {
+    this.dbSchema = dbSchema;
+  }
+
+  /**
+   * Set the Db schema if it hasn't already been defined.
+   */
+  public void setDefaultDbSchema(String dbSchema) {
+    this.defaultDbSchema = true;
+    this.dbSchema = dbSchema;
+  }
+
+  /**
+   * Return true if this is considered the default DB schema (Postgres schema matching DB username).
+   */
+  public boolean isDefaultDbSchema() {
+    return defaultDbSchema;
+  }
+
   /**
    * Return migration versions that should be added to history without running.
    */
@@ -402,9 +374,20 @@ public class DbMigrationConfig {
    * You can use placeholders like ${version} or ${timestamp} in properties file.
    */
   public String getDdlHeader() {
+    if (ddlHeader != null && !ddlHeader.isEmpty()) {
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${version}", EbeanVersion.getVersion());
+      ddlHeader = StringHelper.replaceString(ddlHeader, "${timestamp}", ZonedDateTime.now().format( DateTimeFormatter.ISO_INSTANT ));
+    }
     return ddlHeader;
   }
 
+  /**
+   * Set the header prepended to the DDL.
+   */
+  public void setDdlHeader(String ddlHeader) {
+    this.ddlHeader = ddlHeader;
+  }
+
   /**
    * Set migration versions that should have their checksum reset and not run.
    * <p>
@@ -446,24 +429,20 @@ 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);
     modelSuffix = properties.get("migration.modelSuffix", modelSuffix);
-    includeGeneratedFileComment = properties.getBoolean("migration.includeGeneratedFileComment", includeGeneratedFileComment);
-    generatePendingDrop = properties.get("migration.generatePendingDrop", generatePendingDrop);
 
     platform = properties.getEnum(Platform.class, "migration.platform", platform);
-
-    generate = properties.getBoolean("migration.generate", generate);
-    version = properties.get("migration.version", version);
-    name = properties.get("migration.name", name);
     patchInsertOn = properties.get("migration.patchInsertOn", patchInsertOn);
     patchResetChecksumOn = properties.get("migration.patchResetChecksumOn", patchResetChecksumOn);
 
     runMigration = properties.getBoolean("migration.run", runMigration);
     metaTable = properties.get("migration.metaTable", metaTable);
     runPlaceholders = properties.get("migration.placeholders", runPlaceholders);
+    dbSchema = properties.get("migration.dbSchema", dbSchema);
 
     //Do not set user and pass from "datasource.db.username"
     //There is a null test in MigrationRunner::getConnection to handle this
@@ -475,48 +454,6 @@ public class DbMigrationConfig {
     String adminPwd = properties.get("datasource." + serverName + ".adminpassword", dbPassword);
     dbPassword = properties.get("migration.dbpassword", adminPwd);
     ddlHeader = properties.get("ddl.header", ddlHeader);
-    if (ddlHeader != null && !ddlHeader.isEmpty()) {
-      ddlHeader = StringHelper.replaceString(ddlHeader, "${version}", EbeanVersion.getVersion());
-      ddlHeader = StringHelper.replaceString(ddlHeader, "${timestamp}", ZonedDateTime.now().format( DateTimeFormatter.ISO_INSTANT ));
-    }
-  }
-
-  /**
-   * Return the migration version (typically FlywayDb compatible).
-   * <p>
-   * Example: 1.1.1_2
-   * <p>
-   * The version is expected to be the combination of the current pom version plus
-   * a 'feature' id. The combined version must be unique and ordered to work with
-   * FlywayDb so each developer sets a unique version so that the migration script
-   * generated is unique (typically just prior to being submitted as a merge request).
-   */
-  public String getVersion() {
-    String envVersion = readEnvironment("ddl.migration.version");
-    if (!isEmpty(envVersion)) {
-      return envVersion.trim();
-    }
-    return version;
-  }
-
-  /**
-   * Return the migration name which is short description text that can be appended to
-   * the migration version to become the ddl script file name.
-   * <p>
-   * So if the name is "a foo table" then the ddl script file could be:
-   * "1.1.1_2__a-foo-table.sql"
-   * </p>
-   * <p>
-   * When the DB migration relates to a git feature (merge request) then this description text
-   * is a short description of the feature.
-   * </p>
-   */
-  public String getName() {
-    String envName = readEnvironment("ddl.migration.name");
-    if (!isEmpty(envName)) {
-      return envName.trim();
-    }
-    return name;
   }
 
   /**
@@ -546,10 +483,15 @@ public class DbMigrationConfig {
     runnerConfig.setMetaTable(metaTable);
     runnerConfig.setApplySuffix(applySuffix);
     runnerConfig.setMigrationPath(migrationPath);
+    runnerConfig.setMigrationInitPath(migrationInitPath);
     runnerConfig.setRunPlaceholderMap(runPlaceholderMap);
     runnerConfig.setRunPlaceholders(runPlaceholders);
     runnerConfig.setDbUsername(getDbUsername());
     runnerConfig.setDbPassword(getDbPassword());
+    runnerConfig.setDbSchema(getDbSchema());
+    if (defaultDbSchema) {
+      runnerConfig.setSetCurrentSchema(false);
+    }
     runnerConfig.setClassLoader(classLoader);
     if (patchInsertOn != null) {
       runnerConfig.setPatchInsertOn(patchInsertOn);

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

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

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

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

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

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

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

@@ -14,6 +14,7 @@ import io.ebean.config.dbplatform.DbEncrypt;
 import io.ebean.config.dbplatform.DbType;
 import io.ebean.config.dbplatform.IdType;
 import io.ebean.config.properties.PropertiesLoader;
+import io.ebean.datasource.DataSourceConfig;
 import io.ebean.event.BeanFindController;
 import io.ebean.event.BeanPersistController;
 import io.ebean.event.BeanPersistListener;
@@ -30,9 +31,9 @@ import io.ebean.event.readaudit.ReadAuditPrepare;
 import io.ebean.meta.MetaInfoManager;
 import io.ebean.migration.MigrationRunner;
 import io.ebean.util.StringHelper;
-import org.avaje.datasource.DataSourceConfig;
 
 import javax.sql.DataSource;
+import java.time.Clock;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -57,22 +58,24 @@ import java.util.ServiceLoader;
  * <pre>{@code
  *
  * ServerConfig c = new ServerConfig();
- * c.setName("db");
  *
  * // read the ebean.properties and load
  * // those settings into this serverConfig object
  * c.loadFromProperties();
  *
- * // add any classes found in the app.data package
- * c.addPackage("com.myapp.domain");
- *
- * // register as the 'Default' server
- * c.setDefaultServer(true);
+ * // explicitly register the entity beans to avoid classpath scanning
+ * c.addClass(Customer.class);
+ * c.addClass(User.class);
  *
  * EbeanServer server = EbeanServerFactory.create(c);
  *
  * }</pre>
  *
+ * <p>
+ * Note that ServerConfigProvider provides a standard Java ServiceLoader mechanism that can
+ * be used to apply configuration to the ServerConfig.
+ * </p>
+ *
  * @author emcgreal
  * @author rbygrave
  * @see EbeanServerFactory
@@ -183,16 +186,6 @@ public class ServerConfig {
    */
   private DatabasePlatform databasePlatform;
 
-  /**
-   * The preferred IdType (to override the default Platform type).
-   */
-  private IdType idType;
-
-  /**
-   * For DB's using sequences this is the number of sequence values prefetched.
-   */
-  private int databaseSequenceBatchSize = 20;
-
   /**
    * JDBC fetchSize hint when using findList.  Defaults to 0 leaving it up to the JDBC driver.
    */
@@ -236,6 +229,8 @@ public class ServerConfig {
 
   private int persistBatchSize = 20;
 
+  private boolean disableLazyLoading;
+
   /**
    * The default batch size for lazy loading
    */
@@ -257,6 +252,8 @@ public class ServerConfig {
 
   private boolean ddlRun;
 
+  private boolean ddlExtra = true;
+
   private boolean ddlCreateOnly;
 
   private String ddlInitSql;
@@ -303,6 +300,11 @@ public class ServerConfig {
    */
   private DataSourceConfig readOnlyDataSourceConfig = new DataSourceConfig();
 
+  /**
+   * Optional - the database schema that should be used to own the tables etc.
+   */
+  private String dbSchema;
+
   /**
    * The db migration config (migration resource path etc).
    */
@@ -330,18 +332,6 @@ public class ServerConfig {
    */
   private String dataSourceJndiName;
 
-  /**
-   * The database boolean true value (typically either 1, T, or Y).
-   */
-  private String databaseBooleanTrue;
-
-  /**
-   * The database boolean false value (typically either 0, F or N).
-   */
-  private String databaseBooleanFalse;
-
-  private boolean allQuotedIdentifiers;
-
   /**
    * The naming convention.
    */
@@ -368,9 +358,9 @@ public class ServerConfig {
   private boolean updatesDeleteMissingChildren = true;
 
   /**
-   * Database type configuration.
+   * Database platform configuration.
    */
-  private DbTypeConfig dbTypeConfig = new DbTypeConfig();
+  private PlatformConfig platformConfig = new PlatformConfig();
 
   /**
    * The UUID version to use.
@@ -378,9 +368,15 @@ 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.
+   */
+  private Clock clock = Clock.systemUTC();
 
   private List<IdGenerator> idGenerators = new ArrayList<>();
   private List<BeanFindController> findControllers = new ArrayList<>();
@@ -493,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.
    */
@@ -510,6 +511,16 @@ public class ServerConfig {
    */
   private boolean defaultOrderById = false;
 
+  /**
+   * The mappingLocations for searching xml mapping.
+   */
+  private List<String> mappingLocations = new ArrayList<>();
+
+  /**
+   * When true we do not need explicit GeneratedValue mapping.
+   */
+  private boolean idGeneratorAutomatic = true;
+
   /**
    * Construct a Server Configuration for programmatically creating an EbeanServer.
    */
@@ -517,6 +528,20 @@ public class ServerConfig {
 
   }
 
+  /**
+   * Get the clock used for setting the timestamps (e.g. @UpdatedTimestamp) on objects.
+   */
+  public Clock getClock() {
+    return clock;
+  }
+
+  /**
+   * Set the clock used for setting the timestamps (e.g. @UpdatedTimestamp) on objects.
+   */
+  public void setClock(final Clock clock) {
+    this.clock = clock;
+  }
+
   /**
    * Return the slow query time in millis.
    */
@@ -577,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>
@@ -912,6 +978,22 @@ public class ServerConfig {
     this.queryBatchSize = queryBatchSize;
   }
 
+  /**
+   * Return true if lazy loading is disabled on queries by default.
+   */
+  public boolean isDisableLazyLoading() {
+    return disableLazyLoading;
+  }
+
+  /**
+   * Set to true to disable lazy loading by default.
+   * <p>
+   * It can be turned on per query via {@link Query#setDisableLazyLoading(boolean)}.
+   */
+  public void setDisableLazyLoading(boolean disableLazyLoading) {
+    this.disableLazyLoading = disableLazyLoading;
+  }
+
   /**
    * Return the default batch size for lazy loading of beans and collections.
    */
@@ -946,7 +1028,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseSequenceBatchSize(int databaseSequenceBatchSize) {
-    this.databaseSequenceBatchSize = databaseSequenceBatchSize;
+    platformConfig.setDatabaseSequenceBatchSize(databaseSequenceBatchSize);
   }
 
   /**
@@ -1110,6 +1192,25 @@ public class ServerConfig {
     this.profilingConfig = profilingConfig;
   }
 
+  /**
+   * Return the DB schema to use.
+   */
+  public String getDbSchema() {
+    return dbSchema;
+  }
+
+  /**
+   * Set the DB schema to use. This specifies to use this schema for:
+   * <ul>
+   * <li>Running Database migrations - Create and use the DB schema</li>
+   * <li>Testing DDL - Create-all.sql DDL execution creates and uses schema</li>
+   * <li>Testing Docker - Set default schema on connection URL</li>
+   * </ul>
+   */
+  public void setDbSchema(String dbSchema) {
+    this.dbSchema = dbSchema;
+  }
+
   /**
    * Return the DB migration configuration.
    */
@@ -1128,14 +1229,14 @@ public class ServerConfig {
    * Return the Geometry SRID.
    */
   public int getGeometrySRID() {
-    return dbTypeConfig.getGeometrySRID();
+    return platformConfig.getGeometrySRID();
   }
 
   /**
    * Set the Geometry SRID.
    */
   public void setGeometrySRID(int geometrySRID) {
-    dbTypeConfig.setGeometrySRID(geometrySRID);
+    platformConfig.setGeometrySRID(geometrySRID);
   }
 
   /**
@@ -1425,15 +1526,21 @@ public class ServerConfig {
    * Return true if all DB column and table names should use quoted identifiers.
    */
   public boolean isAllQuotedIdentifiers() {
-    return allQuotedIdentifiers;
+    return platformConfig.isAllQuotedIdentifiers();
   }
 
   /**
    * Set to true if all DB column and table names should use quoted identifiers.
    */
   public void setAllQuotedIdentifiers(boolean allQuotedIdentifiers) {
-    this.allQuotedIdentifiers = allQuotedIdentifiers;
-    if (allQuotedIdentifiers && namingConvention instanceof UnderscoreNamingConvention) {
+    platformConfig.setAllQuotedIdentifiers(allQuotedIdentifiers);
+    if (allQuotedIdentifiers) {
+      adjustNamingConventionForAllQuoted();
+    }
+  }
+
+  private void adjustNamingConventionForAllQuoted() {
+    if (namingConvention instanceof UnderscoreNamingConvention) {
       // we need to use matching naming convention
       this.namingConvention = new MatchingNamingConvention();
     }
@@ -1648,7 +1755,7 @@ public class ServerConfig {
    * </p>
    */
   public String getDatabaseBooleanTrue() {
-    return databaseBooleanTrue;
+    return platformConfig.getDatabaseBooleanTrue();
   }
 
   /**
@@ -1661,7 +1768,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseBooleanTrue(String databaseTrue) {
-    this.databaseBooleanTrue = databaseTrue;
+    platformConfig.setDatabaseBooleanTrue(databaseTrue);
   }
 
   /**
@@ -1674,7 +1781,7 @@ public class ServerConfig {
    * </p>
    */
   public String getDatabaseBooleanFalse() {
-    return databaseBooleanFalse;
+    return platformConfig.getDatabaseBooleanFalse();
   }
 
   /**
@@ -1687,14 +1794,14 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseBooleanFalse(String databaseFalse) {
-    this.databaseBooleanFalse = databaseFalse;
+    this.platformConfig.setDatabaseBooleanFalse(databaseFalse);
   }
 
   /**
    * Return the number of DB sequence values that should be preallocated.
    */
   public int getDatabaseSequenceBatchSize() {
-    return databaseSequenceBatchSize;
+    return platformConfig.getDatabaseSequenceBatchSize();
   }
 
   /**
@@ -1713,7 +1820,7 @@ public class ServerConfig {
    * </p>
    */
   public void setDatabaseSequenceBatch(int databaseSequenceBatchSize) {
-    this.databaseSequenceBatchSize = databaseSequenceBatchSize;
+    this.platformConfig.setDatabaseSequenceBatchSize(databaseSequenceBatchSize);
   }
 
   /**
@@ -1740,7 +1847,7 @@ public class ServerConfig {
    * that you don't have access to.
    * </p>
    * <p>
-   * Values are oracle, h2, postgres, mysql, mssqlserver2005.
+   * Values are oracle, h2, postgres, mysql, sqlserver16, sqlserver17.
    * </p>
    */
   public void setDatabasePlatformName(String databasePlatformName) {
@@ -1769,14 +1876,14 @@ public class ServerConfig {
    * Return the preferred DB platform IdType.
    */
   public IdType getIdType() {
-    return idType;
+    return platformConfig.getIdType();
   }
 
   /**
    * Set the preferred DB platform IdType.
    */
   public void setIdType(IdType idType) {
-    this.idType = idType;
+    this.platformConfig.setIdType(idType);
   }
 
   /**
@@ -1889,15 +1996,22 @@ public class ServerConfig {
   /**
    * Return the configuration for DB types (such as UUID and custom mappings).
    */
-  public DbTypeConfig getDbTypeConfig() {
-    return dbTypeConfig;
+  public PlatformConfig getPlatformConfig() {
+    return platformConfig;
+  }
+
+  /**
+   * Set the configuration for DB platform (such as UUID and custom mappings).
+   */
+  public void setPlatformConfig(PlatformConfig platformConfig) {
+    this.platformConfig = platformConfig;
   }
 
   /**
    * Set the DB type used to store UUID.
    */
-  public void setDbUuid(DbUuid dbUuid) {
-    this.dbTypeConfig.setDbUuid(dbUuid);
+  public void setDbUuid(PlatformConfig.DbUuid dbUuid) {
+    this.platformConfig.setDbUuid(dbUuid);
   }
 
   /**
@@ -1918,6 +2032,15 @@ public class ServerConfig {
    * Return the UUID state file.
    */
   public String getUuidStateFile() {
+    if (uuidStateFile == null || uuidStateFile.isEmpty()) {
+      // by default, add servername...
+      uuidStateFile = name + "-uuid.state";
+      // and store it in the user's home directory
+      String homeDir = System.getProperty("user.home");
+      if (homeDir != null && homeDir.isEmpty()) {
+        uuidStateFile = homeDir + "/.ebean/" + uuidStateFile;
+      }
+    }
     return uuidStateFile;
   }
 
@@ -1965,6 +2088,16 @@ public class ServerConfig {
     this.durationWithNanos = durationWithNanos;
   }
 
+  /**
+   * Set to true to run DB migrations on server start.
+   * <p>
+   * This is the same as serverConfig.getMigrationConfig().setRunMigration(). We have added this method here
+   * as it is often the only thing we need to configure for migrations.
+   */
+  public void setRunMigration(boolean runMigration) {
+    migrationConfig.setRunMigration(runMigration);
+  }
+
   /**
    * Set to true to generate the "create all" DDL on startup.
    * <p>
@@ -1985,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>
@@ -2055,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.
    */
@@ -2353,7 +2503,7 @@ public class ServerConfig {
    * @param platform         Optionally specify the platform this mapping should apply to.
    */
   public void addCustomMapping(DbType type, String columnDefinition, Platform platform) {
-    dbTypeConfig.addCustomMapping(type, columnDefinition, platform);
+    platformConfig.addCustomMapping(type, columnDefinition, platform);
   }
 
   /**
@@ -2373,7 +2523,7 @@ public class ServerConfig {
    * @param columnDefinition The column definition that should be used
    */
   public void addCustomMapping(DbType type, String columnDefinition) {
-    dbTypeConfig.addCustomMapping(type, columnDefinition);
+    platformConfig.addCustomMapping(type, columnDefinition);
   }
 
   /**
@@ -2659,33 +2809,24 @@ public class ServerConfig {
    * Load the settings from the given properties
    */
   private void configureFromProperties() {
-    autoConfiguration();
-    PropertiesWrapper p = new PropertiesWrapper("ebean", name, properties);
-    loadSettings(p);
+    List<AutoConfigure> autoConfigures = autoConfiguration();
+    loadSettings(new PropertiesWrapper("ebean", name, properties, classLoadConfig));
+    for (AutoConfigure autoConfigure : autoConfigures) {
+      autoConfigure.postConfigure(this);
+    }
   }
 
   /**
    * Use a 'plugin' to provide automatic configuration. Intended for automatic testing
    * configuration with Docker containers via ebean-test-config.
    */
-  private void autoConfiguration() {
+  private List<AutoConfigure> autoConfiguration() {
+    List<AutoConfigure> list = new ArrayList<>();
     for (AutoConfigure autoConfigure : serviceLoad(AutoConfigure.class)) {
-      autoConfigure.configure(this);
+      autoConfigure.preConfigure(this);
+      list.add(autoConfigure);
     }
-  }
-
-  /**
-   * 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 list;
   }
 
   /**
@@ -2695,34 +2836,6 @@ public class ServerConfig {
     return properties;
   }
 
-  /**
-   * Return the instance to use (can be null) for the given plugin.
-   *
-   * @param properties the properties
-   * @param pluginType the type of plugin
-   * @param key        properties key
-   * @param instance   existing instance
-   */
-  protected <T> T createInstance(PropertiesWrapper properties, Class<T> pluginType, String key, T instance) {
-
-    if (instance != null) {
-      return instance;
-    }
-    String classname = properties.get(key, null);
-    return createInstance(pluginType, classname);
-  }
-
-  /**
-   * Return the instance to use (can be null) for the given plugin.
-   *
-   * @param pluginType the type of plugin
-   * @param classname  the implementation class as per properties
-   */
-  @SuppressWarnings("unchecked")
-  protected <T> T createInstance(Class<T> pluginType, String classname) {
-    return classname == null ? null : (T) classLoadConfig.newInstance(classname);
-  }
-
   /**
    * loads the data source settings to preserve existing behaviour. IMHO, if someone has set the datasource config already,
    * they don't want the settings to be reloaded and reset. This allows a descending class to override this behaviour and prevent it
@@ -2754,13 +2867,15 @@ public class ServerConfig {
    */
   protected void loadSettings(PropertiesWrapper p) {
 
+    dbSchema = p.get("dbSchema", dbSchema);
+    if (dbSchema != null) {
+      migrationConfig.setDefaultDbSchema(dbSchema);
+    }
     profilingConfig.loadSettings(p, name);
     migrationConfig.loadSettings(p, name);
-
-    boolean quotedIdentifiers = p.getBoolean("allQuotedIdentifiers", allQuotedIdentifiers);
-    if (quotedIdentifiers != allQuotedIdentifiers) {
-      // potentially also set to use matching naming convention
-      setAllQuotedIdentifiers(quotedIdentifiers);
+    platformConfig.loadSettings(p);
+    if (platformConfig.isAllQuotedIdentifiers()) {
+      adjustNamingConventionForAllQuoted();
     }
     namingConvention = createNamingConvention(p, namingConvention);
     if (namingConvention != null) {
@@ -2781,13 +2896,9 @@ public class ServerConfig {
     }
     loadDocStoreSettings(p);
 
-    int srid = p.getInt("geometrySRID", 0);
-    if (srid > 0) {
-      dbTypeConfig.setGeometrySRID(srid);
-    }
-
     queryPlanTTLSeconds = p.getInt("queryPlanTTLSeconds", queryPlanTTLSeconds);
     slowQueryMillis = p.getLong("slowQueryMillis", slowQueryMillis);
+    collectQueryPlans = p.getBoolean("collectQueryPlans", collectQueryPlans);
     docStoreOnly = p.getBoolean("docStoreOnly", docStoreOnly);
     disableL2Cache = p.getBoolean("disableL2Cache", disableL2Cache);
     notifyL2CacheInForeground = p.getBoolean("notifyL2CacheInForeground", notifyL2CacheInForeground);
@@ -2796,23 +2907,22 @@ public class ServerConfig {
     useJtaTransactionManager = p.getBoolean("useJtaTransactionManager", useJtaTransactionManager);
     useJavaxValidationNotNull = p.getBoolean("useJavaxValidationNotNull", useJavaxValidationNotNull);
     autoReadOnlyDataSource = p.getBoolean("autoReadOnlyDataSource", autoReadOnlyDataSource);
+    idGeneratorAutomatic = p.getBoolean("idGeneratorAutomatic", idGeneratorAutomatic);
 
     backgroundExecutorSchedulePoolSize = p.getInt("backgroundExecutorSchedulePoolSize", backgroundExecutorSchedulePoolSize);
     backgroundExecutorShutdownSecs = p.getInt("backgroundExecutorShutdownSecs", backgroundExecutorShutdownSecs);
     disableClasspathSearch = p.getBoolean("disableClasspathSearch", disableClasspathSearch);
-    currentUserProvider = createInstance(p, CurrentUserProvider.class, "currentUserProvider", currentUserProvider);
-    databasePlatform = createInstance(p, DatabasePlatform.class, "databasePlatform", databasePlatform);
-    encryptKeyManager = createInstance(p, EncryptKeyManager.class, "encryptKeyManager", encryptKeyManager);
-    encryptDeployManager = createInstance(p, EncryptDeployManager.class, "encryptDeployManager", encryptDeployManager);
-    encryptor = createInstance(p, Encryptor.class, "encryptor", encryptor);
-    dbEncrypt = createInstance(p, DbEncrypt.class, "dbEncrypt", dbEncrypt);
+    currentUserProvider = p.createInstance(CurrentUserProvider.class, "currentUserProvider", currentUserProvider);
+    databasePlatform = p.createInstance(DatabasePlatform.class, "databasePlatform", databasePlatform);
+    encryptKeyManager = p.createInstance(EncryptKeyManager.class, "encryptKeyManager", encryptKeyManager);
+    encryptDeployManager = p.createInstance(EncryptDeployManager.class, "encryptDeployManager", encryptDeployManager);
+    encryptor = p.createInstance(Encryptor.class, "encryptor", encryptor);
+    dbEncrypt = p.createInstance(DbEncrypt.class, "dbEncrypt", dbEncrypt);
     dbOffline = p.getBoolean("dbOffline", dbOffline);
-    serverCachePlugin = createInstance(p, ServerCachePlugin.class, "serverCachePlugin", serverCachePlugin);
+    serverCachePlugin = p.createInstance(ServerCachePlugin.class, "serverCachePlugin", serverCachePlugin);
 
-    if (packages != null) {
-      String packagesProp = p.get("search.packages", p.get("packages", null));
-      packages = getSearchJarsPackages(packagesProp);
-    }
+    String packagesProp = p.get("search.packages", p.get("packages", null));
+    packages = getSearchList(packagesProp, packages);
 
     collectQueryStatsByNode = p.getBoolean("collectQueryStatsByNode", collectQueryStatsByNode);
     collectQueryOrigins = p.getBoolean("collectQueryOrigins", collectQueryOrigins);
@@ -2828,7 +2938,6 @@ public class ServerConfig {
       throw new IllegalArgumentException("Property 'batch.mode' or 'persistBatching' is being set but no longer used. Please change to use 'persistBatchMode'");
     }
 
-    idType = p.getEnum(IdType.class, "idType", idType);
     persistBatch = p.getEnum(PersistBatch.class, "persistBatch", persistBatch);
     persistBatchOnCascade = p.getEnum(PersistBatch.class, "persistBatchOnCascade", persistBatchOnCascade);
 
@@ -2849,26 +2958,16 @@ public class ServerConfig {
     dataSourceJndiName = p.get("dataSourceJndiName", dataSourceJndiName);
     jdbcFetchSizeFindEach = p.getInt("jdbcFetchSizeFindEach", jdbcFetchSizeFindEach);
     jdbcFetchSizeFindList = p.getInt("jdbcFetchSizeFindList", jdbcFetchSizeFindList);
-    databaseSequenceBatchSize = p.getInt("databaseSequenceBatchSize", databaseSequenceBatchSize);
-    databaseBooleanTrue = p.get("databaseBooleanTrue", databaseBooleanTrue);
-    databaseBooleanFalse = p.get("databaseBooleanFalse", databaseBooleanFalse);
     databasePlatformName = p.get("databasePlatformName", databasePlatformName);
     defaultOrderById = p.getBoolean("defaultOrderById", defaultOrderById);
 
-    DbUuid dbUuid = p.getEnum(DbUuid.class, "dbuuid", null);
-    if (dbUuid != null) {
-      dbTypeConfig.setDbUuid(dbUuid);
-    }
-    if (p.getBoolean("uuidStoreAsBinary", false)) {
-      dbTypeConfig.setDbUuid(DbUuid.BINARY);
-    }
-
     uuidVersion = p.getEnum(UuidVersion.class, "uuidVersion", uuidVersion);
     uuidStateFile = p.get("uuidStateFile", uuidStateFile);
 
     localTimeWithNanos = p.getBoolean("localTimeWithNanos", localTimeWithNanos);
     jodaLocalTimeMode = p.get("jodaLocalTimeMode", jodaLocalTimeMode);
 
+    disableLazyLoading = p.getBoolean("disableLazyLoading", disableLazyLoading);
     lazyLoadBatchSize = p.getInt("lazyLoadBatchSize", lazyLoadBatchSize);
     queryBatchSize = p.getInt("queryBatchSize", queryBatchSize);
 
@@ -2882,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);
@@ -2898,16 +2998,18 @@ public class ServerConfig {
       }
     }
 
-    currentTenantProvider = createInstance(p, CurrentTenantProvider.class, "tenant.currentTenantProvider", currentTenantProvider);
-    tenantCatalogProvider = createInstance(p, TenantCatalogProvider.class, "tenant.catalogProvider", tenantCatalogProvider);
-    tenantSchemaProvider = createInstance(p, TenantSchemaProvider.class, "tenant.schemaProvider", tenantSchemaProvider);
+    currentTenantProvider = p.createInstance(CurrentTenantProvider.class, "tenant.currentTenantProvider", currentTenantProvider);
+    tenantCatalogProvider = p.createInstance(TenantCatalogProvider.class, "tenant.catalogProvider", tenantCatalogProvider);
+    tenantSchemaProvider = p.createInstance(TenantSchemaProvider.class, "tenant.schemaProvider", tenantSchemaProvider);
     tenantPartitionColumn = p.get("tenant.partitionColumn", tenantPartitionColumn);
     classes = getClasses(p);
+
+    String mappingsProp = p.get("mappingLocations", null);
+    mappingLocations = getSearchList(mappingsProp, mappingLocations);
   }
 
   private NamingConvention createNamingConvention(PropertiesWrapper properties, NamingConvention namingConvention) {
-
-    NamingConvention nc = createInstance(properties, NamingConvention.class, "namingconvention", null);
+    NamingConvention nc = properties.createInstance(NamingConvention.class, "namingConvention", null);
     return (nc != null) ? nc : namingConvention;
   }
 
@@ -2940,17 +3042,17 @@ public class ServerConfig {
     return classes;
   }
 
-  private List<String> getSearchJarsPackages(String searchPackages) {
+  private List<String> getSearchList(String searchNames, List<String> defaultValue) {
 
-    if (searchPackages != null) {
-      String[] entries = StringHelper.splitNames(searchPackages);
+    if (searchNames != null) {
+      String[] entries = StringHelper.splitNames(searchNames);
 
       List<String> hitList = new ArrayList<>(entries.length);
       Collections.addAll(hitList, entries);
 
       return hitList;
     } else {
-      return new ArrayList<>();
+      return defaultValue;
     }
   }
 
@@ -3098,71 +3200,83 @@ public class ServerConfig {
   }
 
   /**
-   * Specify how UUID is stored.
+   * Create a new PlatformConfig based of the one held but with overridden properties by reading
+   * properties with the given path and prefix.
+   * <p>
+   * Typically used in Db Migration generation for many platform targets that might have different
+   * configuration for IdType, UUID, quoted identifiers etc.
+   * </p>
+   *
+   * @param propertiesPath The properties path used for loading and setting properties
+   * @param platformPrefix The prefix used for loading and setting properties
+   * @return A copy of the PlatformConfig with overridden properties
    */
-  public enum DbUuid {
-
-
-    /**
-     * Store using native UUID in H2 and Postgres and otherwise fallback to VARCHAR(40).
-     */
-    AUTO_VARCHAR(true, false, false),
-
-    /**
-     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16).
-     */
-    AUTO_BINARY(true, true, false),
-
-    /**
-     * Store using native UUID in H2 and Postgres and otherwise fallback to BINARY(16) with optimized packing.
-     */
-    AUTO_BINARY_OPTIMIZED(true, true, true),
-
-    /**
-     * Store using DB VARCHAR(40).
-     */
-    VARCHAR(false, false, false),
-
-    /**
-     * Store using DB BINARY(16).
-     */
-    BINARY(false, true, false),
-
-    /**
-     * Store using DB BINARY(16).
-     */
-    BINARY_OPTIMIZED(false, true, true);
-
-    boolean nativeType;
-    boolean binary;
-    boolean binaryOptimized;
-
-    DbUuid(boolean nativeType, boolean binary, boolean binaryOptimized) {
-      this.nativeType = nativeType;
-      this.binary = binary;
-      this.binaryOptimized = binaryOptimized;
+  public PlatformConfig newPlatformConfig(String propertiesPath, String platformPrefix) {
+    if (properties == null) {
+      properties = new Properties();
     }
+    PropertiesWrapper p = new PropertiesWrapper(propertiesPath, platformPrefix, properties, classLoadConfig);
+    PlatformConfig config = new PlatformConfig(platformConfig);
+    config.loadSettings(p);
+    return config;
+  }
 
-    /**
-     * Return true if native UUID type is preferred.
-     */
-    public boolean useNativeType() {
-      return nativeType;
+  /**
+   * Add a mapping location to search for xml mapping via class path search.
+   */
+  public void addMappingLocation(String mappingLocation) {
+    if (mappingLocations == null) {
+      mappingLocations = new ArrayList<>();
     }
+    mappingLocations.add(mappingLocation);
+  }
 
-    /**
-     * Return true if BINARY(16) storage is preferred over VARCHAR(40).
-     */
-    public boolean useBinary() {
-      return binary;
-    }
+  /**
+   * Return mapping locations to search for xml mapping via class path search.
+   */
+  public List<String> getMappingLocations() {
+    return mappingLocations;
+  }
 
-    /**
-     * Return true, if optimized packing should be used.
-     */
-    public boolean useBinaryOptimized() {
-      return binaryOptimized;
-    }
+  /**
+   * Set mapping locations to search for xml mapping via class path search.
+   * <p>
+   * This is only used if classes have not been explicitly specified.
+   * </p>
+   */
+  public void setMappingLocations(List<String> mappingLocations) {
+    this.mappingLocations = mappingLocations;
+  }
+
+  /**
+   * When false we need explicit <code>@GeneratedValue</code> mapping to assign
+   * Identity or Sequence generated values. When true Id properties are automatically
+   * assigned Identity or Sequence without the GeneratedValue mapping.
+   */
+  public boolean isIdGeneratorAutomatic() {
+    return idGeneratorAutomatic;
+  }
+
+  /**
+   * Set to false such that Id properties require explicit <code>@GeneratedValue</code>
+   * mapping before they are assigned Identity or Sequence generation based on platform.
+   */
+  public void setIdGeneratorAutomatic(boolean idGeneratorAutomatic) {
+    this.idGeneratorAutomatic = idGeneratorAutomatic;
+  }
+
+  /**
+   * 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 {

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

@@ -0,0 +1,39 @@
+package io.ebean.config;
+
+/**
+ * Provides a ServiceLoader based mechanism to configure a ServerConfig.
+ * <p>
+ * Provide an implementation and register it via the standard Java ServiceLoader mechanism
+ * via a file at <code>META-INF/services/io.ebean.config.ServerConfigProvider</code>.
+ * </p>
+ * <p>
+ * If you are using a DI container like Spring or Guice you are unlikely to use this but instead use a
+ * spring specific configuration.  When we are not using a DI container we may use this mechanism to
+ * explicitly register the entity beans and avoid classpath scanning.
+ * </p>
+ * <pre>{@code
+ *
+ * public class EbeanConfigProvider implements ServerConfigProvider {
+ *
+ *   @Override
+ *   public void apply(ServerConfig config) {
+ *
+ *     // register the entity bean classes explicitly
+ *     config.addClass(Customer.class);
+ *     config.addClass(User.class);
+ *     ...
+ *   }
+ * }
+ *
+ * }</pre>
+ */
+public interface ServerConfigProvider {
+
+  /**
+   * Apply the configuration to the ServerConfig.
+   * <p>
+   * Typically we explicitly register entity bean classes and thus avoid classpath scanning.
+   * </p>
+   */
+  void apply(ServerConfig config);
+}

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

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

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

@@ -2,11 +2,11 @@ package io.ebean.config.dbplatform;
 
 import io.ebean.BackgroundExecutor;
 import io.ebean.Query;
+import io.ebean.annotation.PartitionMode;
 import io.ebean.annotation.PersistBatch;
 import io.ebean.annotation.Platform;
 import io.ebean.config.CustomDbTypeMapping;
-import io.ebean.config.DbTypeConfig;
-import io.ebean.config.ServerConfig;
+import io.ebean.config.PlatformConfig;
 import io.ebean.util.JdbcClose;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -17,6 +17,7 @@ import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
 import java.sql.Types;
 
 /**
@@ -51,7 +52,7 @@ public class DatabasePlatform {
   /**
    * The behaviour used when ending a read only transaction at read committed isolation level.
    */
-  protected OnQueryOnly onQueryOnly = OnQueryOnly.ROLLBACK;
+  protected OnQueryOnly onQueryOnly = OnQueryOnly.COMMIT;
 
   /**
    * The open quote used by quoted identifiers.
@@ -63,8 +64,6 @@ public class DatabasePlatform {
    */
   protected String closeQuote = "\"";
 
-  protected String concatOperator = "||";
-
   /**
    * When set to true all db column names and table names use quoted identifiers.
    */
@@ -177,9 +176,17 @@ public class DatabasePlatform {
    * findIterate() and findVisit().
    */
   protected boolean forwardOnlyHintOnFindIterate;
+  
+  /**
+   * If set then use the CONCUR_UPDATABLE hint when creating ResultSets.
+   * 
+   * This is {@code false} for HANA
+   */
+  protected boolean supportsResultSetConcurrencyModeUpdatable = true;
+
 
   /**
-   * By default we use JDBC batch when cascading (except for SQL Server).
+   * By default we use JDBC batch when cascading (except for SQL Server and HANA).
    */
   protected PersistBatch persistBatchOnCascade = PersistBatch.ALL;
 
@@ -215,16 +222,16 @@ public class DatabasePlatform {
   /**
    * Configure the platform given the server configuration.
    */
-  public void configure(ServerConfig config) {
+  public void configure(PlatformConfig config) {
     this.sequenceBatchSize = config.getDatabaseSequenceBatchSize();
     configureIdType(config.getIdType());
-    configure(config.getDbTypeConfig(), config.isAllQuotedIdentifiers());
+    configure(config, config.isAllQuotedIdentifiers());
   }
 
   /**
    * Configure UUID Storage etc based on ServerConfig settings.
    */
-  protected void configure(DbTypeConfig config, boolean allQuotedIdentifiers) {
+  protected void configure(PlatformConfig config, boolean allQuotedIdentifiers) {
     this.allQuotedIdentifiers = allQuotedIdentifiers;
     addGeoTypes(config.getGeometrySRID());
     configureIdType(config.getIdType());
@@ -382,6 +389,13 @@ public class DatabasePlatform {
     this.historySupport = historySupport;
   }
 
+  /**
+   * So no except for Postgres and CockroachDB.
+   */
+  public boolean isNativeArrayType() {
+    return false;
+  }
+
   /**
    * Return true if the DB supports native UUID.
    */
@@ -447,13 +461,6 @@ public class DatabasePlatform {
     return openQuote;
   }
 
-  /**
-   * Return the DB concat operator.
-   */
-  public String getConcatOperator() {
-    return concatOperator;
-  }
-
   /**
    * Return the JDBC type used to store booleans.
    */
@@ -517,6 +524,31 @@ public class DatabasePlatform {
   public void setForwardOnlyHintOnFindIterate(boolean forwardOnlyHintOnFindIterate) {
     this.forwardOnlyHintOnFindIterate = forwardOnlyHintOnFindIterate;
   }
+  
+  /**
+   * Return true if the ResultSet CONCUR_UPDATABLE Hint should be used on
+   * createNativeSqlTree() PreparedStatements.
+   * <p>
+   * This specifically is required for Hana which doesn't support CONCUR_UPDATABLE
+   * </p>
+   */
+  public boolean isSupportsResultSetConcurrencyModeUpdatable() {
+    return supportsResultSetConcurrencyModeUpdatable;
+  }
+  
+  /**
+   * Set to true if the ResultSet CONCUR_UPDATABLE Hint should be used by default on createNativeSqlTree() PreparedStatements.
+   */
+  public void setSupportsResultSetConcurrencyModeUpdatable(boolean supportsResultSetConcurrencyModeUpdatable) {
+    this.supportsResultSetConcurrencyModeUpdatable = supportsResultSetConcurrencyModeUpdatable;
+  }
+
+  /**
+   * Normally not needed - overridden in CockroachPlatform.
+   */
+  public boolean isDdlCommitOnCreateIndex() {
+    return false;
+  }
 
   /**
    * Return the DB identity/sequence features for this platform.
@@ -645,6 +677,39 @@ public class DatabasePlatform {
     return persistBatchOnCascade;
   }
 
+  /**
+   * Create the DB schema if it does not exist.
+   */
+  public void createSchemaIfNotExists(String dbSchema, Connection connection) throws SQLException {
+    if (!schemaExists(dbSchema, connection)) {
+      Statement query = connection.createStatement();
+      try {
+        logger.info("create schema:{}", dbSchema);
+        query.executeUpdate("create schema " + dbSchema);
+      } finally {
+        JdbcClose.close(query);
+      }
+    }
+  }
+
+  /**
+   * Return true if the schema exists.
+   */
+  public boolean schemaExists(String dbSchema, Connection connection) throws SQLException {
+    ResultSet schemas = connection.getMetaData().getSchemas();
+    try {
+      while (schemas.next()) {
+        String schema = schemas.getString(1);
+        if (schema.equalsIgnoreCase(dbSchema)) {
+          return true;
+        }
+      }
+    } finally {
+      JdbcClose.close(schemas);
+    }
+    return false;
+  }
+
   /**
    * Return true if the table exists.
    */
@@ -659,6 +724,20 @@ public class DatabasePlatform {
     }
   }
 
+  /**
+   * Return true if partitions exist for the given table.
+   */
+  public boolean tablePartitionsExist(Connection connection, String table) throws SQLException {
+    return true;
+  }
+
+  /**
+   * Return the SQL to create an initial partition for the given table.
+   */
+  public String tablePartitionInit(String tableName, PartitionMode mode, String property, String singlePrimaryKey) {
+    return null;
+  }
+
   /**
    * Escapes the like string for this DB-Platform
    */

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

@@ -8,7 +8,9 @@ import java.util.regex.Pattern;
  */
 public class DbIdentity {
 
-  private static final Pattern TABLE_REPLACE = Pattern.compile("{table}", Pattern.LITERAL);
+  private static final String TABLE_PLACEHOLDER = "{table}";
+
+  private static final Pattern TABLE_REPLACE = Pattern.compile(TABLE_PLACEHOLDER, Pattern.LITERAL);
 
   /**
    * Set if this DB supports sequences. Note some DB's support both Sequences
@@ -53,7 +55,9 @@ public class DbIdentity {
     if (selectLastInsertedIdTemplate == null) {
       return null;
     }
-
+    if (!selectLastInsertedIdTemplate.contains(TABLE_PLACEHOLDER)) {
+      return selectLastInsertedIdTemplate;
+    }
     return TABLE_REPLACE.matcher(selectLastInsertedIdTemplate).replaceAll(Matcher.quoteReplacement(table));
   }
 

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

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

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

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

src/main/java/io/ebean/config/dbplatform/hana/HanaBasicSqlLimiter.java

@@ -0,0 +1,24 @@
+package io.ebean.config.dbplatform.hana;
+
+import io.ebean.config.dbplatform.BasicSqlLimiter;
+
+public class HanaBasicSqlLimiter implements BasicSqlLimiter {
+  @Override
+  public String limit(String dbSql, int firstRow, int maxRows) {
+    StringBuilder sb = new StringBuilder(50 + dbSql.length());
+
+    sb.append(dbSql);
+
+    if (maxRows > 0) {
+      sb.append(" ").append("limit");
+      sb.append(" ").append(maxRows);
+
+      if (firstRow > 0) {
+        sb.append(" ").append("offset").append(" ");
+        sb.append(firstRow);
+      }
+    }
+
+    return sb.toString();
+  }
+}

src/main/java/io/ebean/config/dbplatform/hana/HanaHistorySupport.java

@@ -0,0 +1,27 @@
+package io.ebean.config.dbplatform.hana;
+
+import io.ebean.config.dbplatform.DbStandardHistorySupport;
+
+public class HanaHistorySupport extends DbStandardHistorySupport {
+
+  @Override
+  public String getAsOfViewSuffix(String asOfViewSuffix) {
+    return " for system_time as of ?";
+  }
+
+  @Override
+  public String getVersionsBetweenSuffix(String asOfViewSuffix) {
+    return " for system_time between ? and ?";
+  }
+
+  @Override
+  public String getSysPeriodLower(String tableAlias, String sysPeriod) {
+    return tableAlias + "." + sysPeriod + "_start";
+  }
+
+  @Override
+  public String getSysPeriodUpper(String tableAlias, String sysPeriod) {
+    return tableAlias + "." + sysPeriod + "_end";
+  }
+  
+}

src/main/java/io/ebean/config/dbplatform/hana/HanaPlatform.java

@@ -0,0 +1,96 @@
+package io.ebean.config.dbplatform.hana;
+
+import io.ebean.Query.ForUpdate;
+import io.ebean.annotation.PersistBatch;
+import io.ebean.annotation.Platform;
+import io.ebean.config.PlatformConfig;
+import io.ebean.config.dbplatform.DatabasePlatform;
+import io.ebean.config.dbplatform.DbPlatformType;
+import io.ebean.config.dbplatform.DbType;
+import io.ebean.config.dbplatform.IdType;
+import io.ebean.config.dbplatform.SqlErrorCodes;
+
+public class HanaPlatform extends DatabasePlatform {
+
+  public HanaPlatform() {
+    this.platform = Platform.HANA;
+    this.sqlLimiter = new HanaSqlLimiter();
+    this.persistBatchOnCascade = PersistBatch.NONE;
+    this.supportsResultSetConcurrencyModeUpdatable = false;
+    this.columnAliasPrefix = null;
+
+    this.historySupport = new HanaHistorySupport();
+    this.basicSqlLimiter = new HanaBasicSqlLimiter();
+
+    this.likeClauseRaw = "like ?";
+    this.maxConstraintNameLength = 127;
+    this.maxTableNameLength = 127;
+
+    this.dbDefaultValue.setNow("current_timestamp");
+
+    this.exceptionTranslator = new SqlErrorCodes().addAcquireLock("131", "133", "146")
+      .addDataIntegrity("130", "429", "461", "462").addDuplicateKey("144", "301", "349").build();
+
+    this.dbIdentity.setIdType(IdType.IDENTITY);
+    this.dbIdentity.setSelectLastInsertedIdTemplate("select current_identity_value() from sys.dummy");
+    this.dbIdentity.setSupportsGetGeneratedKeys(false);
+    this.dbIdentity.setSupportsIdentity(true);
+
+    this.dbTypeMap.put(DbType.BIGINT, new DbPlatformType("bigint", false));
+    this.dbTypeMap.put(DbType.BINARY, new DbPlatformType("varbinary", 255));
+    this.dbTypeMap.put(DbType.BIT, new DbPlatformType("smallint", false));
+    this.dbTypeMap.put(DbType.BLOB, new DbPlatformType("blob", false));
+    this.dbTypeMap.put(DbType.CHAR, new DbPlatformType("nvarchar", 255));
+    this.dbTypeMap.put(DbType.CLOB, new DbPlatformType("nclob", false));
+    this.dbTypeMap.put(DbType.INTEGER, new DbPlatformType("integer", false));
+    this.dbTypeMap.put(DbType.JSONVARCHAR, new DbPlatformType("nvarchar", 255));
+    this.dbTypeMap.put(DbType.LINESTRING, new DbPlatformType("st_geometry"));
+    this.dbTypeMap.put(DbType.LONGVARBINARY, new DbPlatformType("blob", false));
+    this.dbTypeMap.put(DbType.LONGVARCHAR, new DbPlatformType("nclob", false));
+    this.dbTypeMap.put(DbType.MULTILINESTRING, new DbPlatformType("st_geometry"));
+    this.dbTypeMap.put(DbType.MULTIPOINT, new DbPlatformType("st_geometry"));
+    this.dbTypeMap.put(DbType.MULTIPOLYGON, new DbPlatformType("st_geometry"));
+    this.dbTypeMap.put(DbType.POINT, new DbPlatformType("st_point"));
+    this.dbTypeMap.put(DbType.POLYGON, new DbPlatformType("st_geometry"));
+    this.dbTypeMap.put(DbType.SMALLINT, new DbPlatformType("smallint", false));
+    this.dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint", false));
+    this.dbTypeMap.put(DbType.UUID, new DbPlatformType("varchar", 40));
+    this.dbTypeMap.put(DbType.VARBINARY, new DbPlatformType("varbinary", 255));
+    this.dbTypeMap.put(DbType.VARCHAR, new DbPlatformType("nvarchar", 255));
+  }
+
+  @Override
+  protected void addGeoTypes(int srid) {
+    this.dbTypeMap.put(DbType.LINESTRING, new DbPlatformType("st_geometry(" + srid + ")", false));
+    this.dbTypeMap.put(DbType.MULTILINESTRING, new DbPlatformType("st_geometry(" + srid + ")", false));
+    this.dbTypeMap.put(DbType.MULTIPOINT, new DbPlatformType("st_geometry(" + srid + ")", false));
+    this.dbTypeMap.put(DbType.MULTIPOLYGON, new DbPlatformType("st_geometry(" + srid + ")", false));
+    this.dbTypeMap.put(DbType.POINT, new DbPlatformType("st_point(" + srid + ")", false));
+    this.dbTypeMap.put(DbType.POLYGON, new DbPlatformType("st_geometry(" + srid + ")", false));
+  }
+
+  @Override
+  protected String withForUpdate(String sql, ForUpdate forUpdateMode) {
+    switch (forUpdateMode) {
+      case BASE:
+        return sql + " for update";
+      case NOWAIT:
+        return sql + " for update nowait";
+      case SKIPLOCKED:
+        return sql + " for update ignore locked";
+      default:
+        throw new IllegalArgumentException("Unknown update mode: " + forUpdateMode.name());
+    }
+  }
+
+  @Override
+  protected void configure(PlatformConfig config, boolean allQuotedIdentifiers) {
+    super.configure(config, allQuotedIdentifiers);
+    if (config.getDbUuid().useBinary()) {
+      this.dbTypeMap.put(DbType.UUID, new DbPlatformType("varbinary", 16));
+    } else {
+      this.dbTypeMap.put(DbType.UUID, new DbPlatformType("varchar", 40));
+    }
+  }
+
+}

src/main/java/io/ebean/config/dbplatform/hana/HanaSqlLimiter.java

@@ -0,0 +1,35 @@
+package io.ebean.config.dbplatform.hana;
+
+import io.ebean.config.dbplatform.SqlLimitRequest;
+import io.ebean.config.dbplatform.SqlLimitResponse;
+import io.ebean.config.dbplatform.SqlLimiter;
+
+public class HanaSqlLimiter implements SqlLimiter {
+  @Override
+  public SqlLimitResponse limit(SqlLimitRequest request) {
+    String dbSql = request.getDbSql();
+
+    StringBuilder sb = new StringBuilder(50 + dbSql.length());
+    sb.append("select ");
+    if (request.isDistinct()) {
+      sb.append("distinct ");
+    }
+
+    sb.append(dbSql);
+
+    int firstRow = request.getFirstRow();
+    int maxRows = request.getMaxRows();
+
+    if (maxRows > 0) {
+      sb.append(" ").append("limit ").append(maxRows);
+      if (firstRow > 0) {
+        sb.append(" ").append("offset ");
+        sb.append(firstRow);
+      }
+    }
+
+    String sql = request.getDbPlatform().completeSql(sb.toString(), request.getOrmQuery());
+
+    return new SqlLimitResponse(sql, false);
+  }
+}

src/main/java/io/ebean/config/dbplatform/hana/package-info.java

@@ -0,0 +1,4 @@
+/**
+ * SAP HANA specific support.
+ */
+package io.ebean.config.dbplatform.hana;

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

@@ -2,6 +2,7 @@ package io.ebean.config.dbplatform.postgres;
 
 import io.ebean.BackgroundExecutor;
 import io.ebean.Query;
+import io.ebean.annotation.PartitionMode;
 import io.ebean.annotation.Platform;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.DbPlatformType;
@@ -11,6 +12,10 @@ import io.ebean.config.dbplatform.PlatformIdGenerator;
 import io.ebean.config.dbplatform.SqlErrorCodes;
 
 import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.sql.Types;
 
 /**
@@ -88,6 +93,14 @@ public class PostgresPlatform extends DatabasePlatform {
     return new DbPlatformType("geometry(" + type + "," + srid + ")");
   }
 
+  /**
+   * So we can generate varchar[], int[], uuid[] column definitions and use the associated scalar types.
+   */
+  @Override
+  public boolean isNativeArrayType() {
+    return true;
+  }
+
   /**
    * Create a Postgres specific sequence IdGenerator.
    */
@@ -108,4 +121,32 @@ public class PostgresPlatform extends DatabasePlatform {
         return sql + " for update";
     }
   }
+
+  @Override
+  public boolean tablePartitionsExist(Connection connection, String table) throws SQLException {
+
+    try (PreparedStatement statement = connection.prepareStatement("select count(*) from pg_inherits i WHERE  i.inhparent = ?::regclass")) {
+      statement.setString(1, table);
+      try (ResultSet resultSet = statement.executeQuery()) {
+        return resultSet.next() && resultSet.getInt(1) > 0;
+      }
+    }
+  }
+
+  /**
+   * Return SQL using built in partition helper functions to create some initial partitions.
+   *
+   * Only use this if extra-ddl doesn't have some initial partitions defined (which it should).
+   */
+  @Override
+  public String tablePartitionInit(String tableName, PartitionMode mode, String property, String pkey) {
+    if (property == null) {
+      property = "";
+    }
+    if (pkey == null) {
+      pkey = "";
+    }
+    return "select partition('" + mode.name().toLowerCase() + "','" + tableName + "','" + pkey + "','" + property + "',1);";
+  }
+
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -18,14 +18,14 @@ public class PropertiesLoader {
    * <p>Firstly loads from main resources</p>
    * <pre>
    *   - application.properties
-   *   - application.yml
+   *   - application.yaml
    *   - ebean.properties
    * </pre>
    * <p>
    * <p>Then loads from local files</p>
    * <pre>
    *   - application.properties
-   *   - application.yml
+   *   - application.yaml
    *   - ebean.properties
    * </pre>
    * <p>
@@ -41,7 +41,7 @@ public class PropertiesLoader {
    * <p>Loads from test resources</p>
    * <pre>
    *   - application-test.properties
-   *   - application-test.yml
+   *   - application-test.yaml
    *   - test-ebean.properties
    * </pre>
    */
@@ -56,17 +56,6 @@ public class PropertiesLoader {
     return properties;
   }
 
-  /**
-   * Set (override) a configuration property.
-   *
-   * This is expected to be only called by test configuration logic
-   * (ala automatic test configuration via ebean-test-config).
-   */
-  public static synchronized void setProperty(String key, String value) {
-    load();
-    properties.setProperty(key, value);
-  }
-
   /**
    * Return a copy of the properties with 'eval' run on all the values.
    * This resolves expressions like ${HOME} etc.

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

@@ -7,6 +7,7 @@ import io.ebean.config.dbplatform.DatabasePlatform;
 
 import java.io.IOException;
 import java.util.Iterator;
+import java.util.List;
 import java.util.ServiceLoader;
 
 /**
@@ -49,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>
@@ -93,6 +99,43 @@ public interface DbMigration {
    */
   void setStrictMode(boolean strictMode);
 
+  /**
+   * Set to true to include a generated header comment in the DDL script.
+   */
+  void setIncludeGeneratedFileComment(boolean includeGeneratedFileComment);
+
+  /**
+   * Set this to false to exclude the builtin support for table partitioning (with @DbPartition).
+   */
+  void setIncludeBuiltInPartitioning(boolean includeBuiltInPartitioning);
+
+  /**
+   * Set the header that is included in the generated DDL script.
+   */
+  void setHeader(String header);
+
+  /**
+   * Set the prefix for the version. Set this to "V" for use with Flyway.
+   */
+  void setApplyPrefix(String applyPrefix);
+
+  /**
+   * Set the version of the migration to be generated.
+   */
+  void setVersion(String version);
+
+  /**
+   * Set the name of the migration to be generated.
+   */
+  void setName(String name);
+
+  /**
+   * Generate a migration for the version specified that contains pending drops.
+   *
+   * @param generatePendingDrop The version of a prior migration that holds pending drops.
+   */
+  void setGeneratePendingDrop(String generatePendingDrop);
+
   /**
    * Add an additional platform to write the migration DDL.
    * <p>
@@ -111,7 +154,12 @@ public interface DbMigration {
   void addDatabasePlatform(DatabasePlatform databasePlatform, String prefix);
 
   /**
-   * Generate the next migration xml file and associated apply and rollback sql scripts.
+   * Return the list of versions that contain pending drops.
+   */
+  List<String> getPendingDrops();
+
+  /**
+   * 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>
@@ -143,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/event/ServletContextListener.java

@@ -1,4 +1,4 @@
-package io.ebeaninternal.server.core;
+package io.ebean.event;
 
 import io.ebeaninternal.server.lib.ShutdownManager;
 
@@ -7,8 +7,14 @@ import javax.servlet.ServletContextEvent;
 /**
  * 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.
+ * This should be used when the deployment is into a servlet container where the webapp
+ * can be shutdown or redeployed without the JVM stopping.
+ * </p>
+ * <p>
+ * If deployment is into a container where the JVM is completely shutdown (like spring boot,
+ * runnable war or when using a servlet container that only contains the single webapp and
+ * the JVM is shutdown then this isn't required. Instead we can just rely on the JVM shutdown
+ * hook that Ebean registers.
  * </p>
  */
 public class ServletContextListener implements javax.servlet.ServletContextListener {

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

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

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

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

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

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

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

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

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

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

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

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

src/main/java/io/ebean/meta/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/MetaQueryPlanStatistic.java

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

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

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

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

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

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

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

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

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,6 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
+
+import io.ebean.meta.MetricVisitor;
 
 /**
  * Internal Query plan metric holder.
@@ -11,7 +13,7 @@ public interface QueryPlanMetric {
   TimedMetric getMetric();
 
   /**
-   * Collect the non-empty query plan metrics.
+   * Visit the underlying metric.
    */
-  void collect(QueryPlanCollector collector);
+  void visit(MetricVisitor visitor);
 }

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

@@ -1,8 +1,6 @@
-package io.ebeaninternal.metric;
+package io.ebean.metric;
 
-import io.ebean.meta.MetaTimedMetric;
-
-import java.util.List;
+import io.ebean.meta.MetricVisitor;
 
 /**
  * Metric for timed events like transaction execution times.
@@ -19,18 +17,33 @@ 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.
    */
   boolean isEmpty();
 
   /**
-   * Collect the timed metric statistics.
+   * Reset the statistics.
+   */
+  void reset();
+
+  /**
+   * Collect and return a snapshot of the metrics.
    */
   TimedMetricStats collect(boolean reset);
 
   /**
-   * Add non empty metrics to the result.
+   * Visit non empty metrics.
    */
-  void collect(boolean reset, List<MetaTimedMetric> result);
+  void visit(MetricVisitor visitor);
 }

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

@@ -0,0 +1,34 @@
+package io.ebean.metric;
+
+import io.ebean.meta.MetricVisitor;
+
+/**
+ * A map of timed metrics keyed by a string.
+ */
+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.
+   */
+  void add(String key, long exeMicros);
+
+  /**
+   * Add an execution for the given key including row/bean count.
+   */
+  void add(String key, long exeMicros, int rows);
+
+  /**
+   * Visit the metric.
+   */
+  void visit(MetricVisitor visitor);
+}

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

@@ -9,6 +9,10 @@ import io.ebean.event.BeanQueryAdapter;
 import io.ebeanservice.docstore.api.mapping.DocumentMapping;
 
 import java.util.Collection;
+import java.util.List;
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
 
 /**
  * Information and methods on BeanDescriptors made available to plugins.
@@ -18,6 +22,7 @@ public interface BeanType<T> {
   /**
    * Return the short name of the bean type.
    */
+  @Nonnull
   String getName();
 
   /**
@@ -28,11 +33,13 @@ public interface BeanType<T> {
   /**
    * Return the full name of the bean type.
    */
+  @Nonnull
   String getFullName();
 
   /**
    * Return the class type this BeanDescriptor describes.
    */
+  @Nonnull
   Class<T> getBeanType();
 
   /**
@@ -43,6 +50,7 @@ public interface BeanType<T> {
   /**
    * Return all the properties for this bean type.
    */
+  @Nonnull
   Collection<? extends Property> allProperties();
 
   /**
@@ -197,6 +205,28 @@ public interface BeanType<T> {
    */
   boolean hasInheritance();
 
+  /**
+   * Return true if this object is the root level object in its entity
+   * inheritance.
+   */
+  boolean isInheritanceRoot();
+
+  /**
+   * Returns all direct children of this beantype
+   */
+  List<BeanType<?>> getInheritanceChildren();
+
+  /**
+   * Returns the parent in inheritance hiearchy
+   */
+  BeanType<?> getInheritanceParent();
+
+  /**
+   * Visit all children recursively
+   * @param visitor
+   */
+  void visitAllInheritanceChildren(Consumer<BeanType<?>> visitor);
+
   /**
    * Return the discriminator column.
    */