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

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

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,7 +9,7 @@
 
   <groupId>io.ebean</groupId>
   <artifactId>ebean</artifactId>
-  <version>11.18.3</version>
+  <version>11.34.2</version>
   <packaging>jar</packaging>
 
   <name>ebean</name>
@@ -22,7 +22,7 @@
 
   <scm>
     <developerConnection>scm:git:git@github.com:ebean-orm/ebean.git</developerConnection>
-    <tag>ebean-11.18.3</tag>
+    <tag>ebean-11.34.2</tag>
   </scm>
 
   <profiles>
@@ -117,13 +117,13 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-annotation</artifactId>
-      <version>4.1</version>
+      <version>4.5</version>
     </dependency>
 
     <dependency>
-      <groupId>org.avaje</groupId>
-      <artifactId>avaje-datasource</artifactId>
-      <version>3.2.2</version>
+      <groupId>io.ebean</groupId>
+      <artifactId>ebean-datasource</artifactId>
+      <version>4.3.4</version>
     </dependency>
 
     <dependency>
@@ -135,13 +135,13 @@
     <dependency>
       <groupId>io.ebean</groupId>
       <artifactId>ebean-migration</artifactId>
-      <version>11.7.1</version>
+      <version>11.14.1</version>
     </dependency>
 
     <dependency>
       <groupId>org.antlr</groupId>
       <artifactId>antlr4-runtime</artifactId>
-      <version>4.7.1</version>
+      <version>4.7.2</version>
     </dependency>
 
     <!-- Jackson core used internally by Ebean -->
@@ -188,6 +188,21 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- Provided scope to compile with java 11 -->
+    <dependency>
+      <groupId>org.glassfish.jaxb</groupId>
+      <artifactId>jaxb-runtime</artifactId>
+      <version>2.4.0-b180830.0438</version>
+      <scope>provided</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>javax.annotation</groupId>
+      <artifactId>javax.annotation-api</artifactId>
+      <version>1.3.2</version>
+      <scope>provided</scope>
+    </dependency>
+
     <!-- Provided scope for Postgres JSON/JSONB support -->
     <dependency>
       <groupId>org.postgresql</groupId>
@@ -222,14 +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.11.1</version>
+      <version>11.27.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -238,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>
 
@@ -259,7 +274,7 @@
     <dependency>
       <groupId>com.microsoft.sqlserver</groupId>
       <artifactId>mssql-jdbc</artifactId>
-      <version>6.4.0.jre8</version>
+      <version>7.2.0.jre8</version>
       <scope>test</scope>
     </dependency>
 
@@ -271,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>
@@ -302,7 +324,7 @@
       <plugin>
         <groupId>io.ebean</groupId>
         <artifactId>ebean-maven-plugin</artifactId>
-        <version>11.11.1</version>
+        <version>11.27.1</version>
         <executions>
           <execution>
             <id>test</id>
@@ -320,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>
@@ -360,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/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);

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.
    */

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

@@ -128,6 +128,38 @@ public interface ExpressionList<T> {
    */
   <D> DtoQuery<D> asDto(Class<D> dtoClass);
 
+  /**
+   * Return the underlying query as an UpdateQuery.
+   * <p>
+   * Typically this is used with query beans to covert a query bean
+   * query into an UpdateQuery like the examples below.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  int rowsUpdated = new QCustomer()
+   *       .name.startsWith("Rob")
+   *       .asUpdate()
+   *       .set("active", false)
+   *       .update();;
+   *
+   * }</pre>
+   *
+   * <pre>{@code
+   *
+   *   int rowsUpdated = new QContact()
+   *       .notes.note.startsWith("Make Inactive")
+   *       .email.endsWith("@foo.com")
+   *       .customer.id.equalTo(42)
+   *       .asUpdate()
+   *       .set("inactive", true)
+   *       .setRaw("email = lower(email)")
+   *       .update();
+   *
+   * }</pre>
+   */
+  UpdateQuery<T> asUpdate();
+
   /**
    * Execute using "for update" clause which results in the DB locking the record.
    */
@@ -166,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.
    *
@@ -174,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.
    *
@@ -238,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
    *
@@ -249,7 +327,7 @@ public interface ExpressionList<T> {
    *      .findSingleAttributeList();
    *
    * }</pre>
-   * <p>
+   *
    * <h3>Example 2:</h3>
    * <pre>{@code
    *
@@ -271,7 +349,6 @@ public interface ExpressionList<T> {
 
   /**
    * Execute a query returning a single value of a single property/column.
-   * <p>
    * <pre>{@code
    *
    *  String name =
@@ -356,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)
@@ -412,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>
@@ -490,7 +571,6 @@ public interface ExpressionList<T> {
 
   /**
    * Extended version for setDistinct in conjunction with "findSingleAttributeList";
-   * <p>
    * <pre>{@code
    *
    *  List<CountedValue<Order.Status>> orderStatusCount =
@@ -600,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)
@@ -615,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)
@@ -630,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)
@@ -641,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)
@@ -652,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)
@@ -663,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)
@@ -674,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)
@@ -688,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);
@@ -713,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.
    */
@@ -725,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);
 
   /**
@@ -739,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.
@@ -750,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.
    */
@@ -779,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
@@ -788,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
@@ -797,7 +916,7 @@ public interface ExpressionList<T> {
    * }</pre>
    * <p>
    * Similarly you can create an ExampleExpression
-   * <p>
+   * </p>
    * <pre>{@code
    *
    * Customer example = new Customer();
@@ -1019,7 +1138,6 @@ public interface ExpressionList<T> {
 
   /**
    * Add expression for ALL of the given bit flags to be set.
-   * <p>
    * <pre>{@code
    *
    * where().bitwiseAll("flags", BwFlags.HAS_BULK + BwFlags.HAS_COLOUR)
@@ -1033,7 +1151,6 @@ public interface ExpressionList<T> {
 
   /**
    * Add expression for the given bit flags to be NOT set.
-   * <p>
    * <pre>{@code
    *
    * where().bitwiseNot("flags", BwFlags.HAS_COLOUR)
@@ -1084,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);
 
@@ -1108,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);
 
@@ -1187,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
@@ -1213,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()
@@ -1246,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()
@@ -1256,12 +1395,11 @@ public interface ExpressionList<T> {
    *        .endNot()
    *
    * }</pre>
-   * <p>
-   * <pre>@{code
+   *
+   * <pre>{@code
    *
    * // Example: nested not()
    *
-   * Ebean.find(Customer.class)
    *   .where()
    *     .eq("status", Customer.Status.ACTIVE)
    *     .not()

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

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

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

@@ -78,6 +78,7 @@ public class MergeOptionsBuilder {
       this.deletePermanent = deletePermanent;
     }
 
+    @Override
     public Set<String> paths() {
       return paths;
     }

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/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>
@@ -631,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>
@@ -833,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).
@@ -919,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>
@@ -1304,7 +1411,6 @@ public interface Query<T> {
    *   count:1 orderStatus:COMPLETE
    *
    * }</pre>
-   *
    */
   Query<T> setCountDistinct(CountDistinctOrder orderBy);
 
@@ -1480,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.
    */
@@ -1525,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/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

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

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

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

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

@@ -84,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>
@@ -100,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>
@@ -117,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>
@@ -244,8 +244,7 @@ public interface Transaction extends AutoCloseable {
    *
    *   // assume Customer has L2 bean caching enabled ...
    *
-   *   Transaction transaction = Ebean.beginTransaction();
-   *   try {
+   *   try (Transaction transaction = ebeanServer.beginTransaction()) {
    *
    *     // this uses L2 bean cache as the transaction
    *     // ... is considered "query only" at this point
@@ -253,7 +252,7 @@ public interface Transaction extends AutoCloseable {
    *
    *     // transaction no longer "query only" once
    *     // ... a bean has been saved etc
-   *     Ebean.save(someBean);
+   *     someBean.save();
    *
    *     // will NOT use L2 bean cache as the transaction
    *     // ... is no longer considered "query only"
@@ -273,8 +272,7 @@ public interface Transaction extends AutoCloseable {
    *     Customer.find.byId(99); // skips l2 bean cache
    *
    *
-   *   } finally {
-   *     transaction.end();
+   *     transaction.commit();
    *   }
    *
    * }</pre>
@@ -290,36 +288,66 @@ public interface Transaction extends AutoCloseable {
   boolean isSkipCache();
 
   /**
-   * Turn on or off statement batching. Statement batching can be transparent
-   * for drivers and databases that support getGeneratedKeys. Otherwise you may
-   * wish to specifically control when batching is used via this method.
-   * <p>
-   * Refer to <code>java.sql.PreparedStatement.addBatch();</code>
-   * <p>
-   * Note that you may also wish to use the setPersistCascade method to stop
-   * save and delete cascade behaviour. You may do this to have full control
-   * over the order of execution rather than the normal cascading fashion.
-   * </p>
-   * <p>
-   * Note that the <em>execution order</em> in batch mode may be different from
-   * non batch mode execution order. Also note that <em>insert behaviour</em>
-   * may be different depending on the JDBC driver and its support for
-   * getGeneratedKeys. That is, for JDBC drivers that do not support
-   * getGeneratedKeys you may not get back the generated IDs (used for inserting
-   * associated detail beans etc).
-   * </p>
+   * Turn on or off use of JDBC statement batching.
    * <p>
    * Calls to save(), delete(), insert() and execute() all support batch
-   * processing. This includes normal beans, MapBean, CallableSql and UpdateSql.
+   * processing. This includes normal beans, CallableSql and UpdateSql.
    * </p>
+   *
+   * <pre>{@code
+   *
+   * try (Transaction transaction = server.beginTransaction()) {
+   *
+   *   // turn on JDBC batch
+   *   transaction.setBatchMode(true);
+   *
+   *   // tune the batch size
+   *   transaction.setBatchSize(50);
+   *
+   *   ...
+   *
+   *   transaction.commit();
+   * }
+   *
+   * }</pre>
+   *
+   * <h3>getGeneratedKeys</h3>
    * <p>
-   * The flushing of the batched statements is automatic but you can call
-   * batchFlush when you like. Note that flushing occurs when a query is
-   * executed or when you mix UpdateSql and CallableSql with save and delete of
+   * Often with large batch inserts we want to turn off getGeneratedKeys. We do
+   * this via {@link #setBatchGetGeneratedKeys(boolean)}.
+   * Also note that some JDBC drivers do not support getGeneratedKeys in JDBC batch mode.
+   * </p>
+   * <pre>{@code
+   *
+   * try (Transaction transaction = server.beginTransaction()) {
+   *
+   *   transaction.setBatchMode(true);
+   *   transaction.setBatchSize(100);
+   *   // insert but don't bother getting back the generated keys
+   *   transaction.setBatchGetGeneratedKeys(false);
+   *
+   *
+   *   // perform lots of inserts ...
+   *   ...
+   *
+   *   transaction.commit();
+   * }
+   *
+   * }</pre>
+   *
+   * <h3>Flush</h3>
+   * <p>
+   * The batch is automatically flushed when it hits the batch size and also when we
+   * execute queries or when we mix UpdateSql and CallableSql with save and delete of
    * beans.
    * </p>
    * <p>
-   * Example: batch processing executing every 3 rows
+   * We use {@link #flush()} to explicitly flush the batch and we can use
+   * {@link #setBatchFlushOnQuery(boolean)} and {@link #setBatchFlushOnMixed(boolean)}
+   * to control the automatic flushing behaviour.
+   * </p>
+   * <p>
+   * Example: batch processing of CallableSql executing every 10 rows
    * </p>
    *
    * <pre>{@code
@@ -334,53 +362,27 @@ 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);
 
-  /**
-   * Deprecated - migrate to {@link #setBatchMode(boolean)}.
-   * <p>
-   * Set the JDBC batch mode to use for this transaction.
-   * </p>
-   * <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)
-   */
-  @Deprecated
-  void setBatch(PersistBatch persistBatchMode);
-
-  /**
-   * Deprecated - migrate to {@link #isBatchMode()}.
-   * Return the batch mode at the transaction level.
-   */
-  @Deprecated
-  PersistBatch getBatch();
-
   /**
    * Return the batch mode at the transaction level.
    */
@@ -405,22 +407,6 @@ public interface Transaction extends AutoCloseable {
    */
   void setBatchOnCascade(boolean batchMode);
 
-  /**
-   * Set the batch mode when cascading.
-   * <p>
-   * Deprecated in favour of {@link #setBatchOnCascade(boolean)}
-   * </p>
-   */
-  @Deprecated
-  void setBatchOnCascade(PersistBatch batchOnCascadeMode);
-
-  /**
-   * Deprecated - migrate to {@link #isBatchMode()}.
-   * Return the batch mode at the request level (for each save(), insert(), update() or delete()).
-   */
-  @Deprecated
-  PersistBatch getBatchOnCascade();
-
   /**
    * Return the batch mode at the request level.
    */

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

@@ -71,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;
@@ -102,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];
   }
 
   /**
@@ -213,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;
       }
     }
@@ -259,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;
       }
     }
@@ -284,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;
         }
       }
     }
@@ -352,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;
   }
 
@@ -475,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;
+    }
   }
 
   /**
@@ -483,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;
     }
   }
 
@@ -506,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;
   }
 
   /**
@@ -521,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;
   }
 
   /**
@@ -534,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;
     }
   }
@@ -574,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);
@@ -594,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));
       }
     }
@@ -609,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;
   }
@@ -634,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) + ".");
@@ -654,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;
         }
@@ -683,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) + ".");
@@ -705,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);
@@ -739,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('[');
@@ -765,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;
   }
 
   /**
@@ -821,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) {
@@ -887,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) {
@@ -1114,4 +1117,36 @@ public final class EntityBeanIntercept implements Serializable {
   public void setSortOrder(int sortOrder) {
     this.sortOrder = sortOrder;
   }
+
+  /**
+   * Set the load error that happened on this property.
+   */
+  public void setLoadError(int propertyIndex, Exception t) {
+    if (loadErrors == null) {
+      loadErrors = new Exception[owner._ebean_getPropertyNames().length];
+    }
+    loadErrors[propertyIndex] = t;
+    flags[propertyIndex] |= FLAG_LOADED_PROP;
+  }
+
+  /**
+   * Returns the loadErrors.
+   */
+  public Map<String, Exception> getLoadErrors() {
+    if (loadErrors == null) {
+      return null;
+    }
+    Map<String, Exception> ret = null;
+    int len = getPropertyLength();
+    for (int i = 0; i < len; i++) {
+      Exception loadError = loadErrors[i];
+      if (loadError != null) {
+        if (ret == null) {
+          ret = new LinkedHashMap<>();
+        }
+        ret.put(getProperty(i), loadError);
+      }
+    }
+    return ret;
+  }
 }

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

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

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

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

src/main/java/io/ebean/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/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.
    */
@@ -107,6 +73,11 @@ public class DbMigrationConfig {
    */
   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.
    */
@@ -148,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.
    */
@@ -223,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).
@@ -400,9 +334,15 @@ public class DbMigrationConfig {
    * Set the Db schema if it hasn't already been defined.
    */
   public void setDefaultDbSchema(String dbSchema) {
-    if (this.dbSchema == null) {
-      this.dbSchema = 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;
   }
 
   /**
@@ -489,18 +429,13 @@ 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);
 
@@ -521,44 +456,6 @@ public class DbMigrationConfig {
     ddlHeader = properties.get("ddl.header", ddlHeader);
   }
 
-  /**
-   * Return the migration version (typically FlywayDb compatible).
-   * <p>
-   * Example: 1.1.1_2
-   * <p>
-   * The version is expected to be the combination of the current pom version plus
-   * a 'feature' id. The combined version must be unique and ordered to work with
-   * FlywayDb so each developer sets a unique version so that the migration script
-   * generated is unique (typically just prior to being submitted as a merge request).
-   */
-  public String getVersion() {
-    String envVersion = readEnvironment("ddl.migration.version");
-    if (!isEmpty(envVersion)) {
-      return envVersion.trim();
-    }
-    return version;
-  }
-
-  /**
-   * Return the migration name which is short description text that can be appended to
-   * the migration version to become the ddl script file name.
-   * <p>
-   * So if the name is "a foo table" then the ddl script file could be:
-   * "1.1.1_2__a-foo-table.sql"
-   * </p>
-   * <p>
-   * When the DB migration relates to a git feature (merge request) then this description text
-   * is a short description of the feature.
-   * </p>
-   */
-  public String getName() {
-    String envName = readEnvironment("ddl.migration.name");
-    if (!isEmpty(envName)) {
-      return envName.trim();
-    }
-    return name;
-  }
-
   /**
    * Return the system or environment property.
    */
@@ -586,11 +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/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,7 +31,6 @@ 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;
@@ -229,6 +229,8 @@ public class ServerConfig {
 
   private int persistBatchSize = 20;
 
+  private boolean disableLazyLoading;
+
   /**
    * The default batch size for lazy loading
    */
@@ -250,6 +252,8 @@ public class ServerConfig {
 
   private boolean ddlRun;
 
+  private boolean ddlExtra = true;
+
   private boolean ddlCreateOnly;
 
   private String ddlInitSql;
@@ -364,9 +368,10 @@ public class ServerConfig {
   private UuidVersion uuidVersion = UuidVersion.VERSION4;
 
   /**
-   * The UUID state file (for Version 1 UUIDs).
+   * The UUID state file (for Version 1 UUIDs). By default, the file is created in
+   * ${HOME}/.ebean/${servername}-uuid.state
    */
-  private String uuidStateFile = "ebean-uuid.state";
+  private String uuidStateFile;
 
   /**
    * The clock used for setting the timestamps (e.g. @UpdatedTimestamp) on objects.
@@ -484,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.
    */
@@ -592,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>
@@ -927,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.
    */
@@ -1965,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;
   }
 
@@ -2042,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>
@@ -2112,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.
    */
@@ -2736,20 +2829,6 @@ public class ServerConfig {
     return list;
   }
 
-  /**
-   * Deprecated - this does nothing now, we always try to read test configuration.
-   * <p>
-   * Load settings from test-ebean.properties and do nothing if the properties is not found.
-   * <p>
-   * This is typically used when test-ebean.properties is put into the test class path and used
-   * to configure Ebean for running tests.
-   * </p>
-   */
-  @Deprecated
-  public void loadTestProperties() {
-    // do nothing now ... as we always try to read test configuration and that should only
-  }
-
   /**
    * Return the properties that we used for configuration and were set via a call to loadFromProperties().
    */
@@ -2819,6 +2898,7 @@ public class ServerConfig {
 
     queryPlanTTLSeconds = p.getInt("queryPlanTTLSeconds", queryPlanTTLSeconds);
     slowQueryMillis = p.getLong("slowQueryMillis", slowQueryMillis);
+    collectQueryPlans = p.getBoolean("collectQueryPlans", collectQueryPlans);
     docStoreOnly = p.getBoolean("docStoreOnly", docStoreOnly);
     disableL2Cache = p.getBoolean("disableL2Cache", disableL2Cache);
     notifyL2CacheInForeground = p.getBoolean("notifyL2CacheInForeground", notifyL2CacheInForeground);
@@ -2887,6 +2967,7 @@ public class ServerConfig {
     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);
 
@@ -2900,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);
@@ -3130,9 +3212,10 @@ public class ServerConfig {
    * @return A copy of the PlatformConfig with overridden properties
    */
   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;
@@ -3182,6 +3265,20 @@ public class ServerConfig {
     this.idGeneratorAutomatic = idGeneratorAutomatic;
   }
 
+  /**
+   * Return true if query plan capture is enabled.
+   */
+  public boolean isCollectQueryPlans() {
+    return collectQueryPlans;
+  }
+
+  /**
+   * Set to true to enable query plan capture.
+   */
+  public void setCollectQueryPlans(boolean collectQueryPlans) {
+    this.collectQueryPlans = collectQueryPlans;
+  }
+
   public enum UuidVersion {
     VERSION4,
     VERSION1,

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

@@ -2,6 +2,7 @@ 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;
@@ -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;
 
@@ -454,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.
    */
@@ -524,6 +524,24 @@ 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.
@@ -706,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/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;
 
 /**
@@ -116,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/properties/Loader.java

@@ -63,6 +63,7 @@ class Loader {
    */
   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,6 +84,7 @@ 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);
@@ -95,11 +97,13 @@ class Loader {
       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);

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>
    */

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>
@@ -98,6 +104,11 @@ public interface DbMigration {
    */
   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.
    */
@@ -143,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>
@@ -175,4 +191,15 @@ public interface DbMigration {
    * @return the version of the generated migration or null
    */
   String generateMigration() throws IOException;
+
+  /**
+   * Generate an "init" migration which has all changes.
+   * <p>
+   * An "init" migration can only be executed and used on a database that has had no
+   * prior migrations run on it.
+   * </p>
+   * @return the version of the generated migration
+   */
+  String generateInitMigration() throws IOException;
+
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -73,4 +73,14 @@ public interface ExpressionPath {
    * Return the Id values for the given bean value.
    */
   Object[] getAssocIdValues(EntityBean bean);
+
+  /**
+   * Return the underlying bean property.
+   */
+  public Property getProperty();
+
+  /**
+   * The ElPrefix plus name.
+   */
+  String getElName();
 }

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

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

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

@@ -1,5 +1,7 @@
 package io.ebean.plugin;
 
+import javax.annotation.Nonnull;
+
 /**
  * Property of a entity bean that can be read.
  */
@@ -8,8 +10,15 @@ public interface Property {
   /**
    * Return the name of the property.
    */
+  @Nonnull
   String getName();
 
+  /**
+   * Return the type of the property.
+   */
+  @Nonnull
+  Class<?> getPropertyType();
+
   /**
    * Return the value of the property on the given bean.
    */

src/main/java/io/ebean/service/SpiFetchGroupService.java

@@ -0,0 +1,26 @@
+package io.ebean.service;
+
+import io.ebean.FetchGroup;
+import io.ebean.FetchGroupBuilder;
+
+/**
+ * Service that parses FetchGroup expressions.
+ */
+public interface SpiFetchGroupService {
+
+  /**
+   * Return the FetchGroup with the given select clause.
+   *
+   * @param beanType The type of entity bean the fetch group is for
+   * @param select   The properties to select (top level properties)
+   */
+  <T> FetchGroup<T> of(Class<T> beanType, String select);
+
+  /**
+   * Create and return a FetchGroupBuilder starting with a select() clause.
+   *
+   * @param beanType The type of entity bean the fetch group is for
+   * @return The FetchGroupBuilder to add additional select and fetch clauses
+   */
+  <T> FetchGroupBuilder<T> of(Class<T> beanType);
+}

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

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

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

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

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

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

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

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

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

@@ -168,13 +168,8 @@ public class LoadBeanRequest extends LoadRequest {
         // necessary but allow processing to continue until it is accessed by client code
         Object id = desc.getId(ebi.getOwner());
         if (!loadedIds.contains(id)) {
-          if (desc.isSoftDelete()) {
-            // assume this is logically deleted (hence not found)
-            desc.setSoftDeleteValue(ebi.getOwner());
-          } else {
-            logger.info("Lazy loading unsuccessful for type:" + desc.getName() + " id:" + id + " - expecting when bean has been deleted");
-            ebi.setLazyLoadFailure(id);
-          }
+          // assume this is logically deleted (hence not found)
+          desc.markAsDeleted(ebi.getOwner());
         }
       }
     }

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

@@ -3,7 +3,6 @@ package io.ebeaninternal.api;
 import io.ebean.Pairs;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -25,7 +24,7 @@ public class NaturalKeyQueryData<T> {
   private List<Pairs.Entry> inPairs;
 
   // IN clause - only one allowed
-  private Collection<?> inValues;
+  private List<Object> inValues;
   private String inProperty;
 
   // normal EQ expressions
@@ -52,36 +51,36 @@ public class NaturalKeyQueryData<T> {
   /**
    * Match for In Pairs expression. We only allow one IN clause.
    */
-  public boolean matchInPairs(Pairs pairs) {
+  public List<Pairs.Entry> matchInPairs(String property0, String property1, List<Pairs.Entry> inPairs) {
     if (hasIn) {
       // only 1 IN allowed (to project naturalIds)
-      return false;
+      return null;
     }
-    if (matchProperty(pairs.getProperty0()) && matchProperty(pairs.getProperty1())) {
+    if (matchProperty(property0) && matchProperty(property1)) {
       this.hasIn = true;
-      this.inProperty0 = pairs.getProperty0();
-      this.inProperty1 = pairs.getProperty1();
-      this.inPairs = pairs.getEntries();
-      return true;
+      this.inProperty0 = property0;
+      this.inProperty1 = property1;
+      this.inPairs = new ArrayList<>(inPairs); // will be modified
+      return this.inPairs;
     }
-    return false;
+    return null;
   }
 
   /**
    * Match for IN expression. We only allow one IN clause.
    */
-  public boolean matchIn(String propName, Collection<?> sourceValues) {
+  public List<Object> matchIn(String propName, List<Object> sourceValues) {
     if (hasIn) {
       // only 1 IN allowed (to project naturalIds)
-      return false;
+      return null;
     }
     if (matchProperty(propName)) {
       this.hasIn = true;
       this.inProperty = propName;
-      this.inValues = sourceValues;
-      return true;
+      this.inValues = new ArrayList<>(sourceValues);
+      return this.inValues;
     }
-    return false;
+    return null;
   }
 
   /**

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

@@ -1,7 +1,6 @@
 package io.ebeaninternal.api;
 
 import io.ebean.TxScope;
-import io.ebean.annotation.PersistBatch;
 
 import java.util.ArrayList;
 
@@ -38,9 +37,9 @@ public class ScopeTrans {
    */
   private final ArrayList<Class<? extends Throwable>> rollbackFor;
 
-  private PersistBatch restoreBatch;
+  private Boolean restoreBatch;
 
-  private PersistBatch restoreBatchOnCascade;
+  private Boolean restoreBatchOnCascade;
 
   private int restoreBatchSize;
 
@@ -68,20 +67,20 @@ public class ScopeTrans {
 
     if (transaction != null) {
       if (!created && txScope.isBatchSet() || txScope.isBatchOnCascadeSet() || txScope.isBatchSizeSet()) {
-        restoreBatch = transaction.getBatch();
-        restoreBatchOnCascade = transaction.getBatchOnCascade();
+        restoreBatch = transaction.isBatchMode();
+        restoreBatchOnCascade = transaction.isBatchOnCascade();
         restoreBatchSize = transaction.getBatchSize();
         restoreBatchGeneratedKeys = transaction.getBatchGetGeneratedKeys();
         restoreBatchFlushOnQuery = transaction.isBatchFlushOnQuery();
       }
       if (txScope.isBatchSet()) {
-        transaction.setBatch(txScope.getBatch());
+        transaction.setBatchMode(txScope.isBatchMode());
       }
       if (!txScope.isFlushOnQuery()) {
         transaction.setBatchFlushOnQuery(false);
       }
       if (txScope.isBatchOnCascadeSet()) {
-        transaction.setBatchOnCascade(txScope.getBatchOnCascade());
+        transaction.setBatchOnCascade(txScope.isBatchOnCascade());
       }
       if (txScope.isBatchSizeSet()) {
         transaction.setBatchSize(txScope.getBatchSize());
@@ -139,7 +138,7 @@ public class ScopeTrans {
       nestedCommit = true;
       transaction.setBatchFlushOnQuery(restoreBatchFlushOnQuery);
       if (restoreBatch != null) {
-        transaction.setBatch(restoreBatch);
+        transaction.setBatchMode(restoreBatch);
       }
       if (restoreBatchOnCascade != null) {
         transaction.setBatchOnCascade(restoreBatchOnCascade);

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

@@ -37,6 +37,7 @@ public interface SpiDtoQuery<T> extends DtoQuery<T>, SpiSqlBinding {
   /**
    * Return the label for the query.
    */
+  @Override
   String getLabel();
 
   /**

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

@@ -312,4 +312,8 @@ public interface SpiEbeanServer extends ExtendedServer, EbeanServer, BeanLoader,
    */
   int[] executeBatch(SpiSqlUpdate defaultSqlUpdate, SpiTransaction transaction);
 
+  /**
+   * Execute the sql update regardless of transaction batch mode.
+   */
+  int executeNow(SpiSqlUpdate sqlUpdate);
 }

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

@@ -134,27 +134,40 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
     /**
      * Includes soft deletes rows in the result.
      */
-    SOFT_DELETED,
+    SOFT_DELETED(false),
 
     /**
      * Query runs against draft tables.
      */
-    DRAFT,
+    DRAFT(false),
 
     /**
      * Query runs against current data (normal).
      */
-    CURRENT,
+    CURRENT(false),
 
     /**
      * Query runs potentially returning many versions of the same bean.
      */
-    VERSIONS,
+    VERSIONS(true),
 
     /**
      * Query runs 'As Of' a given date time.
      */
-    AS_OF;
+    AS_OF(true);
+
+    private final boolean history;
+
+    TemporalMode(boolean history) {
+      this.history = history;
+    }
+
+    /**
+     * Return true if this is a history query.
+     */
+    public boolean isHistory() {
+      return history;
+    }
 
     /**
      * Return the mode of the query of if null return CURRENT mode.
@@ -426,6 +439,11 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   void setDelete();
 
+  /**
+   * Set the query to be delete by ids due to cascading delete.
+   */
+  CQueryPlanKey setDeleteByIdsPlan();
+
   /**
    * Set the query to select the id property only.
    */
@@ -736,23 +754,6 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   boolean isDisableLazyLoading();
 
-  /**
-   * Internally set by Ebean when this query must use the DISTINCT keyword.
-   * <p>
-   * This does not exclude/remove the use of the id property.
-   */
-  void setSqlDistinct(boolean sqlDistinct);
-
-  /**
-   * Return true if this query has been specified by a user or internally by Ebean to use DISTINCT.
-   */
-  boolean isDistinctQuery();
-
-  /**
-   * Return true if this was internally set to sql distinct (ie. many where predicate).
-   */
-  boolean isSqlDistinct();
-
   /**
    * Return true if this query has been specified by a user to use DISTINCT.
    */
@@ -824,6 +825,11 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    */
   boolean isCancelled();
 
+  /**
+   * Return the base table to use if user defined on the query.
+   */
+  String getBaseTable();
+
   /**
    * Return root table alias set by {@link #alias(String)} command.
    */
@@ -848,4 +854,9 @@ public interface SpiQuery<T> extends Query<T>, TxnProfileEventCodes {
    * Returns the count distinct order setting.
    */
   CountDistinctOrder getCountDistinctOrder();
+
+  /**
+   * Handles load errors.
+   */
+  void handleLoadError(String fullName, Exception e);
 }

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

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

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

@@ -7,7 +7,6 @@ import io.ebean.bean.PersistenceContext;
 import io.ebean.event.changelog.BeanChange;
 import io.ebean.event.changelog.ChangeSet;
 import io.ebeaninternal.server.core.PersistDeferredRelationship;
-import io.ebeaninternal.server.core.PersistRequest;
 import io.ebeaninternal.server.core.PersistRequestBean;
 import io.ebeaninternal.server.persist.BatchControl;
 import io.ebeaninternal.server.transaction.ProfileStream;

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

@@ -3,12 +3,10 @@ package io.ebeaninternal.api;
 import io.ebean.ProfileLocation;
 import io.ebean.TransactionCallback;
 import io.ebean.annotation.DocStoreMode;
-import io.ebean.annotation.PersistBatch;
 import io.ebean.bean.PersistenceContext;
 import io.ebean.event.changelog.BeanChange;
 import io.ebean.event.changelog.ChangeSet;
 import io.ebeaninternal.server.core.PersistDeferredRelationship;
-import io.ebeaninternal.server.core.PersistRequest;
 import io.ebeaninternal.server.core.PersistRequestBean;
 import io.ebeaninternal.server.persist.BatchControl;
 import io.ebeaninternal.server.transaction.ProfileStream;
@@ -255,36 +253,16 @@ public abstract class SpiTransactionProxy implements SpiTransaction {
     return transaction.isBatchMode();
   }
 
-  @Override
-  public void setBatch(PersistBatch persistBatchMode) {
-    transaction.setBatch(persistBatchMode);
-  }
-
-  @Override
-  public PersistBatch getBatch() {
-    return transaction.getBatch();
-  }
-
   @Override
   public void setBatchOnCascade(boolean batchMode) {
     transaction.setBatchOnCascade(batchMode);
   }
 
-  @Override
-  public void setBatchOnCascade(PersistBatch batchOnCascadeMode) {
-    transaction.setBatchOnCascade(batchOnCascadeMode);
-  }
-
   @Override
   public boolean isBatchOnCascade() {
     return transaction.isBatchOnCascade();
   }
 
-  @Override
-  public PersistBatch getBatchOnCascade() {
-    return transaction.getBatchOnCascade();
-  }
-
   @Override
   public void setBatchSize(int batchSize) {
     transaction.setBatchSize(batchSize);

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

@@ -9,6 +9,7 @@ import io.ebeaninternal.server.transaction.TransactionManager;
 import io.ebeanservice.docstore.api.DocStoreUpdates;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -29,16 +30,21 @@ public class TransactionEvent implements Serializable {
    */
   private final transient boolean local;
 
+  private final long startMillis;
+
   private TransactionEventTable eventTables;
 
-  private transient TransactionEventBeans eventBeans;
+  private transient List<PersistRequestBean<?>> listenerNotify;
 
   private transient DeleteByIdMap deleteByIdMap;
 
+  private transient CacheChangeSet changeSet;
+
   /**
    * Create the TransactionEvent, one per Transaction.
    */
-  public TransactionEvent() {
+  public TransactionEvent(long startMillis) {
+    this.startMillis = startMillis;
     this.local = true;
   }
 
@@ -71,8 +77,8 @@ public class TransactionEvent implements Serializable {
   /**
    * Return the list of PersistRequestBean's for this transaction.
    */
-  public List<PersistRequestBean<?>> getPersistRequestBeans() {
-    return (eventBeans == null) ? null : eventBeans.getRequests();
+  public List<PersistRequestBean<?>> getListenerNotify() {
+    return (listenerNotify == null) ? null : listenerNotify;
   }
 
   public TransactionEventTable getEventTables() {
@@ -94,17 +100,13 @@ public class TransactionEvent implements Serializable {
   }
 
   /**
-   * Add a inserted updated or deleted bean to the event.
+   * Add post commit listeners. Watch this for large transactions.
    */
-  public void add(PersistRequestBean<?> request) {
-
-    if (request.isNotify()) {
-      // either a BeanListener or Cache is interested
-      if (eventBeans == null) {
-        eventBeans = new TransactionEventBeans();
-      }
-      eventBeans.add(request);
+  public void addListenerNotify(PersistRequestBean<?> request) {
+    if (listenerNotify == null) {
+      listenerNotify = new ArrayList<>();
     }
+    listenerNotify.add(request);
   }
 
   /**
@@ -112,11 +114,13 @@ public class TransactionEvent implements Serializable {
    */
   public CacheChangeSet buildCacheChanges(TransactionManager manager) {
 
-    if (eventBeans == null && deleteByIdMap == null && eventTables == null) {
+    if (changeSet == null && deleteByIdMap == null && eventTables == null) {
       return null;
     }
 
-    CacheChangeSet changeSet = new CacheChangeSet(manager.clockNowMillis());
+    if (changeSet == null) {
+      changeSet = new CacheChangeSet(manager.clockNowMillis());
+    }
     if (eventTables != null && !eventTables.isEmpty()) {
       // notify cache with table based changes
       BeanDescriptorManager dm = manager.getBeanDescriptorManager();
@@ -124,9 +128,6 @@ public class TransactionEvent implements Serializable {
         dm.cacheNotify(tableIUD, changeSet);
       }
     }
-    if (eventBeans != null) {
-      eventBeans.notifyCache(changeSet);
-    }
     if (deleteByIdMap != null) {
       deleteByIdMap.notifyCache(changeSet);
     }
@@ -137,12 +138,25 @@ public class TransactionEvent implements Serializable {
    * Add any relevant PersistRequestBean's to DocStoreUpdates for later processing.
    */
   public void addDocStoreUpdates(DocStoreUpdates docStoreUpdates) {
-
-    List<PersistRequestBean<?>> persistRequestBeans = getPersistRequestBeans();
-    if (persistRequestBeans != null) {
-      for (PersistRequestBean<?> persistRequestBean : persistRequestBeans) {
+    List<PersistRequestBean<?>> requests = getListenerNotify();
+    if (requests != null) {
+      for (PersistRequestBean<?> persistRequestBean : requests) {
         persistRequestBean.addDocStoreUpdates(docStoreUpdates);
       }
     }
   }
+
+  /**
+   * Return the CacheChangeSet that we add cache notification messages to.
+   *
+   * We want to add to this change set as we process requests allowing the
+   * PersistRequestBean to be garbage collected for large transactions.
+   */
+  public CacheChangeSet obtainCacheChangeSet() {
+    if (changeSet == null) {
+      changeSet = new CacheChangeSet(startMillis);
+    }
+    return changeSet;
+  }
+
 }

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

@@ -1,44 +0,0 @@
-package io.ebeaninternal.api;
-
-import io.ebeaninternal.server.cache.CacheChangeSet;
-import io.ebeaninternal.server.core.PersistRequestBean;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Lists of inserted updated and deleted beans that have a BeanPersistListener.
- * <p>
- * These beans will be sent to the appropriate BeanListeners after a successful
- * commit of the transaction.
- * </p>
- */
-public class TransactionEventBeans {
-
-  final ArrayList<PersistRequestBean<?>> requests = new ArrayList<>();
-
-  /**
-   * Return the list of PersistRequests that BeanListeners are interested in.
-   */
-  public List<PersistRequestBean<?>> getRequests() {
-    return requests;
-  }
-
-  /**
-   * Add a bean for BeanListener notification.
-   */
-  public void add(PersistRequestBean<?> request) {
-
-    requests.add(request);
-  }
-
-  /**
-   * Collect the cache changes.
-   */
-  public void notifyCache(CacheChangeSet changeSet) {
-    for (PersistRequestBean<?> request : requests) {
-      request.notifyCache(changeSet);
-    }
-  }
-
-}

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

@@ -1,11 +1,16 @@
 package io.ebeaninternal.dbmigration;
 
+import io.ebean.config.DbMigrationConfig;
 import io.ebean.config.ServerConfig;
+import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.migration.ddl.DdlRunner;
+import io.ebean.migration.runner.ScriptTransform;
 import io.ebean.util.JdbcClose;
 import io.ebeaninternal.api.SpiEbeanServer;
 import io.ebeaninternal.dbmigration.model.CurrentModel;
+import io.ebeaninternal.dbmigration.model.MTable;
 import io.ebeaninternal.extraddl.model.ExtraDdlXmlReader;
+import io.ebeaninternal.server.deploy.PartitionMeta;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -35,10 +40,12 @@ public class DdlGenerator {
 
   private final boolean generateDdl;
   private final boolean runDdl;
+  private final boolean extraDdl;
   private final boolean createOnly;
   private final boolean jaxbPresent;
   private final boolean ddlCommitOnCreateIndex;
   private final String dbSchema;
+  private final ScriptTransform scriptTransform;
 
   private CurrentModel currentModel;
   private String dropAllContent;
@@ -48,6 +55,7 @@ public class DdlGenerator {
     this.server = server;
     this.jaxbPresent = serverConfig.getClassLoadConfig().isJavaxJAXBPresent();
     this.generateDdl = serverConfig.isDdlGenerate();
+    this.extraDdl = serverConfig.isDdlExtra();
     this.createOnly = serverConfig.isDdlCreateOnly();
     this.dbSchema = serverConfig.getDbSchema();
     if (!serverConfig.getTenantMode().isDdlEnabled() && serverConfig.isDdlRun()) {
@@ -58,6 +66,7 @@ public class DdlGenerator {
       this.runDdl = serverConfig.isDdlRun();
       this.ddlCommitOnCreateIndex = server.getDatabasePlatform().isDdlCommitOnCreateIndex();
     }
+    this.scriptTransform = createScriptTransform(serverConfig.getMigrationConfig());
   }
 
   /**
@@ -123,7 +132,9 @@ public class DdlGenerator {
 
   private void createSchemaIfRequired(Connection connection) {
     try {
-      server.getDatabasePlatform().createSchemaIfNotExists(dbSchema, connection);
+      for (String schema : dbSchema.split(",")) {
+        server.getDatabasePlatform().createSchemaIfNotExists(schema, connection);
+      }
     } catch (SQLException e) {
       throw new PersistenceException("Failed to create DB Schema", e);
     }
@@ -141,7 +152,7 @@ public class DdlGenerator {
       } else if (ddlCommitOnCreateIndex) {
         runner.setCommitOnCreateIndex();
       }
-      int count = runner.runAll(content, connection);
+      int count = runner.runAll(scriptTransform.transform(content), connection);
       if (expectErrors) {
         connection.setAutoCommit(false);
       }
@@ -157,11 +168,10 @@ public class DdlGenerator {
 
   protected void runDropSql(Connection connection) throws IOException {
     if (!createOnly) {
-      String ignoreExtraDdl = System.getProperty("ebean.ignoreExtraDdl");
-      if (!"true".equalsIgnoreCase(ignoreExtraDdl) && jaxbPresent) {
+      if (extraDdl && jaxbPresent) {
         String extraApply = ExtraDdlXmlReader.buildExtra(server.getDatabasePlatform().getName(), true);
         if (extraApply != null) {
-          runScript(connection, false, extraApply, "extra-dll");
+          runScript(connection, false, extraApply, "extra-ddl");
         }
       }
 
@@ -178,12 +188,51 @@ public class DdlGenerator {
     }
     runScript(connection, false, createAllContent, getCreateFileName());
 
-    String ignoreExtraDdl = System.getProperty("ebean.ignoreExtraDdl");
-    if (!"true".equalsIgnoreCase(ignoreExtraDdl) && jaxbPresent) {
+    if (extraDdl && jaxbPresent) {
+      if (currentModel.isTablePartitioning()) {
+        String extraPartitioning = ExtraDdlXmlReader.buildPartitioning(server.getDatabasePlatform().getName());
+        if (extraPartitioning != null && !extraPartitioning.isEmpty()) {
+          runScript(connection, false, extraPartitioning, "builtin-partitioning-ddl");
+        }
+      }
+
       String extraApply = ExtraDdlXmlReader.buildExtra(server.getDatabasePlatform().getName(), false);
       if (extraApply != null) {
-        runScript(connection, false, extraApply, "extra-dll");
+        runScript(connection, false, extraApply, "extra-ddl");
       }
+
+      if (currentModel.isTablePartitioning()) {
+        checkInitialTablePartitions(connection);
+      }
+    }
+  }
+
+  /**
+   * Check if table partitions exist and if not create some. The expectation is that
+   * extra-ddl.xml should have some partition initialisation but this helps people get going.
+   */
+  private void checkInitialTablePartitions(Connection connection) {
+
+    DatabasePlatform databasePlatform = server.getDatabasePlatform();
+    try {
+      StringBuilder sb = new StringBuilder();
+      for (MTable table : currentModel.getPartitionedTables()) {
+        String tableName = table.getName();
+        if (!databasePlatform.tablePartitionsExist(connection, tableName)) {
+          log.info("No table partitions for table {}", tableName);
+          PartitionMeta meta = table.getPartitionMeta();
+          String initPart = databasePlatform.tablePartitionInit(tableName, meta.getMode(), meta.getProperty(), table.singlePrimaryKey());
+          sb.append(initPart).append("\n");
+        }
+      }
+
+      String initialPartitionSql = sb.toString();
+      if (!initialPartitionSql.isEmpty()) {
+        runScript(connection, false, initialPartitionSql, "initial table partitions");
+      }
+
+    } catch (SQLException e) {
+      log.error("Error checking initial table partitions", e);
     }
   }
 
@@ -299,8 +348,15 @@ public class DdlGenerator {
         buf.append(s).append("\n");
       }
       return buf.toString();
-
     }
   }
 
+  /**
+   * Create the ScriptTransform for placeholder key/value replacement.
+   */
+  private ScriptTransform createScriptTransform(DbMigrationConfig config) {
+
+    return ScriptTransform.build(config.getRunPlaceholders(), config.getRunPlaceholderMap());
+  }
+
 }

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

@@ -10,6 +10,7 @@ import io.ebean.config.ServerConfig;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebean.config.dbplatform.db2.DB2Platform;
 import io.ebean.config.dbplatform.h2.H2Platform;
+import io.ebean.config.dbplatform.hana.HanaPlatform;
 import io.ebean.config.dbplatform.hsqldb.HsqldbPlatform;
 import io.ebean.config.dbplatform.mysql.MySqlPlatform;
 import io.ebean.config.dbplatform.oracle.OraclePlatform;
@@ -57,7 +58,7 @@ import java.util.List;
  *
  *       DbMigration migration = DbMigration.create();
  *       migration.setPathToResources("src/main/resources");
- *       migration.setPlatform(DbPlatformName.ORACLE);
+ *       migration.setPlatform(Platform.POSTGRES);
  *
  *       migration.generateMigration();
  *
@@ -65,12 +66,14 @@ import java.util.List;
  */
 public class DefaultDbMigration implements DbMigration {
 
-  protected static final Logger logger = LoggerFactory.getLogger(DefaultDbMigration.class);
+  protected static final Logger logger = LoggerFactory.getLogger("io.ebean.GenerateMigration");
 
   private static final String initialVersion = "1.0";
 
   private static final String GENERATED_COMMENT = "THIS IS A GENERATED FILE - DO NOT MODIFY";
 
+  private boolean logToSystemOut = true;
+
   /**
    * Set to true if DefaultDbMigration run with online EbeanServer instance.
    */
@@ -84,6 +87,8 @@ public class DefaultDbMigration implements DbMigration {
 
   protected DatabasePlatform databasePlatform;
 
+  private boolean vanillaPlatform;
+
   protected List<Pair> platforms = new ArrayList<>();
 
   protected ServerConfig serverConfig;
@@ -98,6 +103,8 @@ public class DefaultDbMigration implements DbMigration {
   protected String name;
   protected String generatePendingDrop;
 
+  protected boolean includeBuiltInPartitioning = true;
+
   /**
    * Create for offline migration generation.
    */
@@ -179,6 +186,11 @@ public class DefaultDbMigration implements DbMigration {
     this.includeGeneratedFileComment = includeGeneratedFileComment;
   }
 
+  @Override
+  public void setIncludeBuiltInPartitioning(boolean includeBuiltInPartitioning) {
+    this.includeBuiltInPartitioning = includeBuiltInPartitioning;
+  }
+
   @Override
   public void setHeader(String header) {
     this.header = header;
@@ -192,6 +204,7 @@ public class DefaultDbMigration implements DbMigration {
    */
   @Override
   public void setPlatform(Platform platform) {
+    vanillaPlatform = true;
     setPlatform(getPlatform(platform));
   }
 
@@ -255,10 +268,20 @@ public class DefaultDbMigration implements DbMigration {
    *       migration.generateMigration();
    *
    * }</pre>
+   *
    * @return the generated migration or null
    */
   @Override
   public String generateMigration() throws IOException {
+    return generateMigrationFor(false);
+  }
+
+  @Override
+  public String generateInitMigration() throws IOException {
+    return generateMigrationFor(true);
+  }
+
+  private String generateMigrationFor(boolean dbinitMigration) throws IOException {
 
     // use this flag to stop other plugins like full DDL generation
     if (!online) {
@@ -274,9 +297,18 @@ public class DefaultDbMigration implements DbMigration {
       configurePlatforms();
     }
     try {
-      Request request = createRequest();
-      if (platforms.isEmpty()) {
-        generateExtraDdl(request.migrationDir, databasePlatform);
+      Request request = createRequest(dbinitMigration);
+      if (!dbinitMigration) {
+        // repeatable migrations
+        if (platforms.isEmpty()) {
+          generateExtraDdl(request.migrationDir, databasePlatform, request.isTablePartitioning());
+        } else {
+          for (Pair pair : platforms) {
+            PlatformDdlWriter platformWriter = createDdlWriter(pair.platform);
+            File subPath = platformWriter.subPath(request.migrationDir, pair.prefix);
+            generateExtraDdl(subPath, pair.platform, request.isTablePartitioning());
+          }
+        }
       }
 
       String pendingVersion = generatePendingDrop();
@@ -286,6 +318,29 @@ public class DefaultDbMigration implements DbMigration {
         return generateDiff(request);
       }
 
+    } catch (UnknownResourcePathException e) {
+      logError("ERROR - " + e.getMessage());
+      logError("Check the working directory or change dbMigration.setPathToResources() value?");
+      return null;
+
+    } finally {
+      if (!online) {
+        DbOffline.reset();
+      }
+    }
+  }
+
+  /**
+   * Return the versions containing pending drops.
+   */
+  @Override
+  public List<String> getPendingDrops() {
+    if (!online) {
+      DbOffline.setGenerateMigration();
+    }
+    setDefaults();
+    try {
+      return createRequest(false).getPendingDrops();
     } finally {
       if (!online) {
         DbOffline.reset();
@@ -306,21 +361,28 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Generate "repeatable" migration scripts.
    * <p>
-   * These take scrips from extra-dll.xml (typically views) and outputs "repeatable"
+   * These take scrips from extra-ddl.xml (typically views) and outputs "repeatable"
    * migration scripts (starting with "R__") to be run by FlywayDb or Ebean's own
    * migration runner.
    * </p>
    */
-  private void generateExtraDdl(File migrationDir, DatabasePlatform dbPlatform) throws IOException {
+  private void generateExtraDdl(File migrationDir, DatabasePlatform dbPlatform, boolean tablePartitioning) throws IOException {
 
     if (dbPlatform != null) {
-      ExtraDdl extraDdl = ExtraDdlXmlReader.read("/extra-ddl.xml");
-      if (extraDdl != null) {
-        List<DdlScript> ddlScript = extraDdl.getDdlScript();
-        for (DdlScript script : ddlScript) {
-          if (!script.isDrop() && ExtraDdlXmlReader.matchPlatform(dbPlatform.getName(), script.getPlatforms())) {
-            writeExtraDdl(migrationDir, script);
-          }
+      if (tablePartitioning && includeBuiltInPartitioning) {
+        generateExtraDdlFor(migrationDir, dbPlatform, ExtraDdlXmlReader.readBuiltinTablePartitioning());
+      }
+      generateExtraDdlFor(migrationDir, dbPlatform, ExtraDdlXmlReader.readBuiltin());
+      generateExtraDdlFor(migrationDir, dbPlatform, ExtraDdlXmlReader.read());
+    }
+  }
+
+  private void generateExtraDdlFor(File migrationDir, DatabasePlatform dbPlatform, ExtraDdl extraDdl) throws IOException {
+    if (extraDdl != null) {
+      List<DdlScript> ddlScript = extraDdl.getDdlScript();
+      for (DdlScript script : ddlScript) {
+        if (!script.isDrop() && ExtraDdlXmlReader.matchPlatform(dbPlatform.getName(), script.getPlatforms())) {
+          writeExtraDdl(migrationDir, script);
         }
       }
     }
@@ -331,9 +393,8 @@ public class DefaultDbMigration implements DbMigration {
    */
   private void writeExtraDdl(File migrationDir, DdlScript script) throws IOException {
 
-    String fullName = repeatableMigrationName(script.getName());
-
-    logger.info("writing repeatable script {}", fullName);
+    String fullName = repeatableMigrationName(script.isInit(), script.getName());
+    logger.debug("writing repeatable script {}", fullName);
 
     File file = new File(migrationDir, fullName);
     try (FileWriter writer = new FileWriter(file)) {
@@ -342,8 +403,40 @@ public class DefaultDbMigration implements DbMigration {
     }
   }
 
-  private String repeatableMigrationName(String scriptName) {
-    return "R__" + scriptName.replace(' ', '_') + migrationConfig.getApplySuffix();
+  @Override
+  public void setLogToSystemOut(boolean logToSystemOut) {
+    this.logToSystemOut = logToSystemOut;
+  }
+
+  private void logError(String message) {
+    if (logToSystemOut) {
+      System.out.println("DbMigration> " + message);
+    } else {
+      logger.error(message);
+    }
+  }
+
+  private void logInfo(String message, Object value) {
+    if (value != null) {
+      message = String.format(message, value);
+    }
+    if (logToSystemOut) {
+      System.out.println("DbMigration> " + message);
+    } else {
+      logger.info(message);
+    }
+  }
+
+  private String repeatableMigrationName(boolean init, String scriptName) {
+    StringBuilder sb = new StringBuilder();
+    if (init) {
+      sb.append("I__");
+    } else {
+      sb.append("R__");
+    }
+    sb.append(scriptName.replace(' ', '_'));
+    sb.append(migrationConfig.getApplySuffix());
+    return sb.toString();
   }
 
   /**
@@ -353,12 +446,12 @@ public class DefaultDbMigration implements DbMigration {
 
     List<String> pendingDrops = request.getPendingDrops();
     if (!pendingDrops.isEmpty()) {
-      logger.info("Pending un-applied drops in versions {}", pendingDrops);
+      logInfo("Pending un-applied drops in versions %s", pendingDrops);
     }
 
     Migration migration = request.createDiffMigration();
     if (migration == null) {
-      logger.info("no changes detected - no migration written");
+      logInfo("no changes detected - no migration written", null);
       return null;
     } else {
       // there were actually changes to write
@@ -377,37 +470,57 @@ public class DefaultDbMigration implements DbMigration {
 
     List<String> pendingDrops = request.getPendingDrops();
     if (!pendingDrops.isEmpty()) {
-      logger.info("... remaining pending un-applied drops in versions {}", pendingDrops);
+      logInfo("... remaining pending un-applied drops in versions %s", pendingDrops);
     }
     return version;
   }
 
-  private Request createRequest() {
-    return new Request();
+  private Request createRequest(boolean dbinitMigration) {
+    return new Request(dbinitMigration);
   }
 
   private class Request {
 
+    final boolean dbinitMigration;
     final File migrationDir;
     final File modelDir;
-    final MigrationModel migrationModel;
     final CurrentModel currentModel;
     final ModelContainer migrated;
     final ModelContainer current;
 
-    private Request() {
-      this.migrationDir = getMigrationDirectory();
-      this.modelDir = getModelDirectory(migrationDir);
-      this.migrationModel = new MigrationModel(modelDir, migrationConfig.getModelSuffix());
-      this.migrated = migrationModel.read();
+    private Request(boolean dbinitMigration) {
+      this.dbinitMigration = dbinitMigration;
       this.currentModel = new CurrentModel(server, constraintNaming);
       this.current = currentModel.read();
+      this.migrationDir = getMigrationDirectory(dbinitMigration);
+      if (dbinitMigration) {
+        this.modelDir = null;
+        this.migrated = new ModelContainer();
+      } else {
+        this.modelDir = getModelDirectory(migrationDir);
+        MigrationModel migrationModel = new MigrationModel(modelDir, migrationConfig.getModelSuffix());
+        this.migrated = migrationModel.read(dbinitMigration);
+      }
+    }
+
+    boolean isTablePartitioning() {
+      return current.isTablePartitioning();
+    }
+
+    /**
+     * Return the next migration version (based on existing migration versions).
+     */
+    String nextVersion() {
+      // always read the next version using the main migration directory (not dbinit)
+      File migDirectory = getMigrationDirectory(false);
+      File modelDir = getModelDirectory(migDirectory);
+      return LastMigration.nextVersion(migDirectory, modelDir, dbinitMigration);
     }
 
     /**
      * Return the migration for the pending drops for a given version.
      */
-    public Migration migrationForPendingDrop(String pendingVersion) {
+    Migration migrationForPendingDrop(String pendingVersion) {
 
       Migration migration = migrated.migrationForPendingDrop(pendingVersion);
 
@@ -426,7 +539,7 @@ public class DefaultDbMigration implements DbMigration {
     /**
      * Create and return the diff of the current model to the migration model.
      */
-    public Migration createDiffMigration() {
+    Migration createDiffMigration() {
       ModelDiff diff = new ModelDiff(migrated);
       diff.compareTo(current);
       return diff.isEmpty() ? null : diff.getMigration();
@@ -435,11 +548,11 @@ public class DefaultDbMigration implements DbMigration {
 
   private String generateMigration(Request request, Migration dbMigration, String dropsFor) throws IOException {
 
-    String fullVersion = getFullVersion(request.migrationModel, dropsFor);
+    String fullVersion = getFullVersion(request.nextVersion(), dropsFor);
 
-    logger.info("generating migration:{}", fullVersion);
-    if (!writeMigrationXml(dbMigration, request.modelDir, fullVersion)) {
-      logger.warn("migration already exists, not generating DDL");
+    logInfo("generating migration:%s", fullVersion);
+    if (!request.dbinitMigration && !writeMigrationXml(dbMigration, request.modelDir, fullVersion)) {
+      logError("migration already exists, not generating DDL");
       return null;
     } else {
       if (!platforms.isEmpty()) {
@@ -465,7 +578,7 @@ public class DefaultDbMigration implements DbMigration {
     if (nextDrop != null) {
       return nextDrop;
     }
-    return migrationConfig.getGeneratePendingDrop();
+    return generatePendingDrop;
   }
 
   /**
@@ -473,16 +586,17 @@ public class DefaultDbMigration implements DbMigration {
    * <p>
    * The full version can contain a comment suffix after a "__" double underscore.
    */
-  private String getFullVersion(MigrationModel migrationModel, String dropsFor) {
+  private String getFullVersion(String nextVersion, String dropsFor) {
 
-    String version = migrationConfig.getVersion();
+    String version = getVersion();
     if (version == null) {
-      version = migrationModel.getNextVersion(initialVersion);
+      version = (nextVersion != null) ? nextVersion : initialVersion;
     }
 
     String fullVersion = migrationConfig.getApplyPrefix() + version;
-    if (migrationConfig.getName() != null) {
-      fullVersion += "__" + toUnderScore(migrationConfig.getName());
+    String name = getName();
+    if (name != null) {
+      fullVersion += "__" + toUnderScore(name);
 
     } else if (dropsFor != null) {
       fullVersion += "__" + toUnderScore("dropsFor_" + MigrationVersion.trim(dropsFor));
@@ -503,15 +617,13 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Write any extra platform ddl.
    */
-  protected void writeExtraPlatformDdl(String fullVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
+  private void writeExtraPlatformDdl(String fullVersion, CurrentModel currentModel, Migration dbMigration, File writePath) throws IOException {
 
     for (Pair pair : platforms) {
       DdlWrite platformBuffer = new DdlWrite(new MConfiguration(), currentModel.read());
       PlatformDdlWriter platformWriter = createDdlWriter(pair.platform);
       File subPath = platformWriter.subPath(writePath, pair.prefix);
       platformWriter.processMigration(dbMigration, platformBuffer, subPath, fullVersion);
-
-      generateExtraDdl(subPath, pair.platform);
     }
   }
 
@@ -522,14 +634,14 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Write the migration xml.
    */
-  protected boolean writeMigrationXml(Migration dbMigration, File resourcePath, String fullVersion) {
+  private boolean writeMigrationXml(Migration dbMigration, File resourcePath, String fullVersion) {
 
     String modelFile = fullVersion + migrationConfig.getModelSuffix();
     File file = new File(resourcePath, modelFile);
     if (file.exists()) {
       return false;
     }
-    String comment = migrationConfig.isIncludeGeneratedFileComment() ? GENERATED_COMMENT : null;
+    String comment = Boolean.TRUE.equals(includeGeneratedFileComment) ? GENERATED_COMMENT : null;
     MigrationXmlWriter xmlWriter = new MigrationXmlWriter(comment);
     xmlWriter.write(dbMigration, file);
     return true;
@@ -538,15 +650,13 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Set default server and platform if necessary.
    */
-  protected void setDefaults() {
+  private void setDefaults() {
     if (server == null) {
       setServer(Ebean.getDefaultServer());
     }
-    if (databasePlatform == null && platforms.isEmpty()) {
-      // not explicitly set not set a list of platforms so
-      // default to the platform of the default server
+    if (vanillaPlatform || databasePlatform == null) {
+      // not explicitly set so use the platform of the server
       databasePlatform = server.getDatabasePlatform();
-      logger.debug("set platform to {}", databasePlatform.getName());
     }
     if (migrationConfig != null) {
       if (strictMode != null) {
@@ -558,35 +668,91 @@ public class DefaultDbMigration implements DbMigration {
       if (header != null) {
         migrationConfig.setDdlHeader(header);
       }
-      if (includeGeneratedFileComment != null) {
-        migrationConfig.setIncludeGeneratedFileComment(includeGeneratedFileComment);
-      }
-      if (version != null) {
-        migrationConfig.setVersion(version);
-      }
-      if (name != null) {
-        migrationConfig.setName(name);
-      }
-      if (generatePendingDrop != null) {
-        migrationConfig.setGeneratePendingDrop(generatePendingDrop);
-      }
     }
   }
 
+  /**
+   * 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).
+   */
+  private 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>
+   */
+  private String getName() {
+    String envName = readEnvironment("ddl.migration.name");
+    if (!isEmpty(envName)) {
+      return envName.trim();
+    }
+    return name;
+  }
+
+  /**
+   * Return true if the string is null or empty.
+   */
+  private boolean isEmpty(String val) {
+    return val == null || val.trim().isEmpty();
+  }
+
+  /**
+   * Return the system or environment property.
+   */
+  private String readEnvironment(String key) {
+
+    String val = System.getProperty(key);
+    if (val == null) {
+      val = System.getenv(key);
+    }
+    return val;
+  }
+
+  /**
+   * Return the main migration directory.
+   */
+  File getMigrationDirectory() {
+    return getMigrationDirectory(false);
+  }
+
   /**
    * Return the file path to write the xml and sql to.
    */
-  protected File getMigrationDirectory() {
+  File getMigrationDirectory(boolean dbinitMigration) {
 
     // path to src/main/resources in typical maven project
     File resourceRootDir = new File(pathToResources);
-    String resourcePath = migrationConfig.getMigrationPath();
+    if (!resourceRootDir.exists()) {
+      String msg = String.format("Error - path to resources %s does not exist. Absolute path is %s", pathToResources, resourceRootDir.getAbsolutePath());
+      throw new UnknownResourcePathException(msg);
+    }
+    String resourcePath = migrationConfig.getMigrationPath(dbinitMigration);
 
     // expect to be a path to something like - src/main/resources/dbmigration/model
     File path = new File(resourceRootDir, resourcePath);
     if (!path.exists()) {
       if (!path.mkdirs()) {
-        logger.debug("Unable to ensure migration directory exists at {}", path.getAbsolutePath());
+        logInfo("Warning - Unable to ensure migration directory exists at %s", path.getAbsolutePath());
       }
     }
     return path;
@@ -595,14 +761,14 @@ public class DefaultDbMigration implements DbMigration {
   /**
    * Return the model directory (relative to the migration directory).
    */
-  protected File getModelDirectory(File migrationDirectory) {
+  private File getModelDirectory(File migrationDirectory) {
     String modelPath = migrationConfig.getModelPath();
     if (modelPath == null || modelPath.isEmpty()) {
       return migrationDirectory;
     }
     File modelDir = new File(migrationDirectory, migrationConfig.getModelPath());
     if (!modelDir.exists() && !modelDir.mkdirs()) {
-      logger.debug("Unable to ensure migration model directory exists at {}", modelDir.getAbsolutePath());
+      logInfo("Warning - Unable to ensure migration model directory exists at %s", modelDir.getAbsolutePath());
     }
     return modelDir;
   }
@@ -634,6 +800,8 @@ public class DefaultDbMigration implements DbMigration {
         return new DB2Platform();
       case SQLITE:
         return new SQLitePlatform();
+      case HANA:
+        return new HanaPlatform();
       case GENERIC:
         return new DatabasePlatform();
 
@@ -646,19 +814,19 @@ public class DefaultDbMigration implements DbMigration {
    * Holds a platform and prefix. Used to generate multiple platform specific DDL
    * for a single migration.
    */
-  public static class Pair {
+  static class Pair {
 
     /**
      * The platform to generate the DDL for.
      */
-    public final DatabasePlatform platform;
+    final DatabasePlatform platform;
 
     /**
      * A prefix included into the file/resource names indicating the platform.
      */
-    public final String prefix;
+    final String prefix;
 
-    public Pair(DatabasePlatform platform, String prefix) {
+    Pair(DatabasePlatform platform, String prefix) {
       this.platform = platform;
       this.prefix = prefix;
     }

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

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

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

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

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

@@ -28,7 +28,11 @@ public class BaseDdlHandler implements DdlHandler {
   protected final TableDdl tableDdl;
 
   public BaseDdlHandler(ServerConfig serverConfig, PlatformDdl platformDdl) {
-    this.tableDdl = new BaseTableDdl(serverConfig, platformDdl);
+    this(serverConfig, platformDdl, new BaseTableDdl(serverConfig, platformDdl));
+  }
+  
+  protected BaseDdlHandler(ServerConfig serverConfig, PlatformDdl platformDdl, TableDdl tableDdl) {
+    this.tableDdl = tableDdl;
   }
 
   @Override

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

@@ -0,0 +1,225 @@
+package io.ebeaninternal.dbmigration.ddlgeneration.platform;
+
+import io.ebean.config.ServerConfig;
+import io.ebean.config.dbplatform.DatabasePlatform;
+import io.ebean.config.dbplatform.DbPlatformType;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlHandler;
+import io.ebeaninternal.dbmigration.migration.AlterColumn;
+
+import java.io.IOException;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public abstract class AbstractHanaDdl extends PlatformDdl {
+
+  private static final Pattern ARRAY_PATTERN = Pattern.compile("(\\w+)\\s*\\[\\s*\\]\\s*(\\(\\d+\\))?", Pattern.CASE_INSENSITIVE);
+
+  public AbstractHanaDdl(DatabasePlatform platform) {
+    super(platform);
+    this.addColumn = "add (";
+    this.addColumnSuffix = ")";
+    this.alterColumn = "alter (";
+    this.alterColumnSuffix = ")";
+    this.columnDropDefault = " default null";
+    this.columnSetDefault = " default";
+    this.columnSetNotnull = " not null";
+    this.columnSetNull = " null";
+    this.dropColumn = "drop (";
+    this.dropColumnSuffix = ")";
+    this.dropConstraintIfExists = "drop constraint ";
+    this.dropIndexIfExists = "drop index ";
+    this.dropSequenceIfExists = "drop sequence ";
+    this.dropTableCascade = " cascade";
+    this.dropTableIfExists = "drop table ";
+    this.fallbackArrayType = "nvarchar(1000)";
+    this.historyDdl = new HanaHistoryDdl();
+    this.identitySuffix = " generated by default as identity";
+  }
+
+  @Override
+  public String alterColumnBaseAttributes(AlterColumn alter) {
+    String tableName = alter.getTableName();
+    String columnName = alter.getColumnName();
+    String currentType = alter.getCurrentType();
+    String type = alter.getType() != null ? alter.getType() : currentType;
+    type = convert(type, false);
+    currentType = convert(currentType, false);
+    boolean notnull = (alter.isNotnull() != null) ? alter.isNotnull() : Boolean.TRUE.equals(alter.isCurrentNotnull());
+    String notnullClause = notnull ? " not null" : "";
+    String defaultValue = DdlHelp.isDropDefault(alter.getDefaultValue()) ? "null"
+      : (alter.getDefaultValue() != null ? alter.getDefaultValue() : alter.getCurrentDefaultValue());
+    String defaultValueClause = (defaultValue == null || defaultValue.isEmpty()) ? "" : " default " + defaultValue;
+
+    try {
+      DdlBuffer buffer = new BaseDdlBuffer(null);
+      if (!isConvertible(currentType, type)) {
+        // add an intermediate conversion if possible
+        if (isNumberType(currentType)) {
+          // numbers can always be converted to decimal
+          buffer.append("alter table ").append(tableName).append(" ").append(alterColumn).append(" ").append(columnName)
+            .append(" decimal ").append(defaultValueClause).append(notnullClause).append(alterColumnSuffix)
+            .endOfStatement();
+
+        } else if (isStringType(currentType)) {
+          // strings can always be converted to nclob
+          buffer.append("alter table ").append(tableName).append(" ").append(alterColumn).append(" ").append(columnName)
+            .append(" nclob ").append(defaultValueClause).append(notnullClause).append(alterColumnSuffix)
+            .endOfStatement();
+        }
+      }
+
+      buffer.append("alter table ").append(tableName).append(" ").append(alterColumn).append(" ").append(columnName)
+        .append(" ").append(type).append(defaultValueClause).append(notnullClause).append(alterColumnSuffix);
+
+      return buffer.getBuffer();
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  public String alterColumnDefaultValue(String tableName, String columnName, String defaultValue) {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public String alterColumnNotnull(String tableName, String columnName, boolean notnull) {
+    return null;
+  }
+
+  @Override
+  public DdlHandler createDdlHandler(ServerConfig serverConfig) {
+    return new HanaDdlHandler(serverConfig, this);
+  }
+
+  @Override
+  public String alterColumnType(String tableName, String columnName, String type) {
+    return null;
+  }
+
+  @Override
+  protected String convertArrayType(String logicalArrayType) {
+    Matcher matcher = ARRAY_PATTERN.matcher(logicalArrayType);
+    if (matcher.matches()) {
+      return convert(matcher.group(1), false) + " array" + (matcher.group(2) == null ? "" : matcher.group(2));
+    } else {
+      return fallbackArrayType;
+    }
+  }
+
+  @Override
+  public String alterTableAddUniqueConstraint(String tableName, String uqName, String[] columns, String[] nullableColumns) {
+    if (nullableColumns == null || nullableColumns.length == 0) {
+      return super.alterTableAddUniqueConstraint(tableName, uqName, columns, nullableColumns);
+    } else {
+      return "-- cannot create unique index \"" + uqName + "\" on table \"" + tableName + "\" with nullable columns";
+    }
+  }
+
+  @Override
+  public String alterTableDropUniqueConstraint(String tableName, String uniqueConstraintName) {
+    DdlBuffer buffer = new BaseDdlBuffer(null);
+    try {
+      buffer.append("delimiter $$").newLine();
+      buffer.append("do").newLine();
+      buffer.append("begin").newLine();
+      buffer.append("declare exit handler for sql_error_code 397 begin end").endOfStatement();
+      buffer.append("exec 'alter table ").append(tableName).append(" ").append(dropUniqueConstraint).append(" ")
+        .append(maxConstraintName(uniqueConstraintName)).append("'").endOfStatement();
+      buffer.append("end").endOfStatement();
+      buffer.append("$$");
+      return buffer.getBuffer();
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  public String alterTableDropConstraint(String tableName, String constraintName) {
+    return alterTableDropUniqueConstraint(tableName, constraintName);
+  }
+
+  /**
+   * It is rather complex to delete a column on HANA as there must not exist any
+   * foreign keys. That's why we call a user stored procedure here
+   */
+  @Override
+  public void alterTableDropColumn(DdlBuffer buffer, String tableName, String columnName) throws IOException {
+    buffer.append("CALL usp_ebean_drop_column('").append(tableName).append("', '").append(columnName).append("')")
+      .endOfStatement();
+  }
+
+  /**
+   * Check if a data type can be converted to another data type. Data types can't
+   * be converted if the target type has a lower precision than the source type.
+   *
+   * @param sourceType The source data type
+   * @param targetType the target data type
+   * @return {@code true} if the type can be converted, {@code false} otherwise
+   */
+  private boolean isConvertible(String sourceType, String targetType) {
+    if (Objects.equals(sourceType, targetType)) {
+      return true;
+    }
+
+    if (sourceType == null || targetType == null) {
+      return true;
+    }
+
+    if ("bigint".equals(sourceType)) {
+      if ("integer".equals(targetType) || "smallint".equals(targetType) || "tinyint".equals(targetType)) {
+        return false;
+      }
+    } else if ("integer".equals(sourceType)) {
+      if ("smallint".equals(targetType) || "tinyint".equals(targetType)) {
+        return false;
+      }
+    } else if ("smallint".equals(sourceType)) {
+      if ("tinyint".equals(targetType)) {
+        return false;
+      }
+    } else if ("double".equals(sourceType)) {
+      if ("real".equals(targetType)) {
+        return false;
+      }
+    }
+
+    DbPlatformType dbPlatformSourceType = DbPlatformType.parse(sourceType);
+
+    if ("float".equals(dbPlatformSourceType.getName())) {
+      if ("real".equals(targetType)) {
+        return false;
+      }
+    } else if ("varchar".equals(dbPlatformSourceType.getName()) || "nvarchar".equals(dbPlatformSourceType.getName())) {
+      DbPlatformType dbPlatformTargetType = DbPlatformType.parse(targetType);
+      if ("varchar".equals(dbPlatformTargetType.getName()) || "nvarchar".equals(dbPlatformTargetType.getName())) {
+        if (dbPlatformSourceType.getDefaultLength() > dbPlatformTargetType.getDefaultLength()) {
+          return false;
+        }
+      }
+    } else if ("decimal".equals(dbPlatformSourceType.getName())) {
+      DbPlatformType dbPlatformTargetType = DbPlatformType.parse(targetType);
+      if ("decimal".equals(dbPlatformTargetType.getName())) {
+        if (dbPlatformSourceType.getDefaultLength() > dbPlatformTargetType.getDefaultLength()
+          || dbPlatformSourceType.getDefaultScale() > dbPlatformTargetType.getDefaultScale()) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+
+  private boolean isNumberType(String type) {
+    return type != null
+      && ("bigint".equals(type) || "integer".equals(type) || "smallint".equals(type) || "tinyint".equals(type)
+      || type.startsWith("float") || "real".equals(type) || "double".equals(type) || type.startsWith("decimal"));
+  }
+
+  private boolean isStringType(String type) {
+    return type != null
+      && (type.startsWith("varchar") || type.startsWith("nvarchar") || "clob".equals(type) || "nclob".equals(type));
+  }
+}

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

@@ -257,15 +257,19 @@ public class BaseTableDdl implements TableDdl {
       useSequence = (IdType.SEQUENCE == useDbIdentityType);
     }
 
+    String partitionMode = createTable.getPartitionMode();
+
     DdlBuffer apply = writer.apply();
-    apply.append("create table ").append(tableName).append(" (");
+    apply.append(platformDdl.getCreateTableCommandPrefix()).append(" ").append(tableName).append(" (");
     writeTableColumns(apply, columns, useIdentity);
     writeCheckConstraints(apply, createTable);
     writeUniqueConstraints(apply, createTable);
     writeCompoundUniqueConstraints(apply, createTable);
     if (!pk.isEmpty()) {
       // defined on the columns
-      writePrimaryKeyConstraint(apply, createTable.getPkName(), toColumnNames(pk));
+      if (partitionMode == null || !platformDdl.suppressPrimaryKeyOnPartition()) {
+        writePrimaryKeyConstraint(apply, createTable.getPkName(), toColumnNames(pk));
+      }
     }
     if (platformDdl.isInlineForeignKeys()) {
       writeInlineForeignKeys(writer, createTable);
@@ -273,6 +277,9 @@ public class BaseTableDdl implements TableDdl {
 
     apply.newLine().append(")");
     addTableCommentInline(apply, createTable);
+    if (partitionMode != null) {
+      platformDdl.addTablePartition(apply, partitionMode, createTable.getPartitionColumn());
+    }
     apply.endOfStatement();
 
     addComments(apply, createTable);
@@ -902,7 +909,7 @@ public class BaseTableDdl implements TableDdl {
     if (hasValue(ddl)) {
       writer.apply().append(ddl).endOfStatement();
 
-      if (isTrue(alter.isWithHistory()) && alter.getType() != null && historySupport == historySupport.TRIGGER_BASED) {
+      if (isTrue(alter.isWithHistory()) && alter.getType() != null && historySupport == HistorySupport.TRIGGER_BASED) {
         // mysql and sql server column type change allowing nulls in the history table column
         regenerateHistoryTriggers(alter.getTableName(), HistoryTableUpdate.Change.ALTER, alter.getColumnName());
         AlterColumn alterHistoryColumn = new AlterColumn();

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

@@ -175,7 +175,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
 
   protected void createHistoryTable(DdlBuffer apply, MTable table) throws IOException {
 
-    apply.append("create table ").append(table.getName()).append(historySuffix).append("(").newLine();
+    apply.append(platformDdl.getCreateTableCommandPrefix()).append(" ").append(table.getName()).append(historySuffix).append("(").newLine();
 
     Collection<MColumn> cols = table.allColumns();
     for (MColumn column : cols) {
@@ -238,8 +238,8 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
   }
 
   protected void dropSysPeriodColumns(DdlBuffer buffer, String baseTableName) throws IOException {
-    buffer.append("alter table ").append(baseTableName).append(" drop column ").append(sysPeriodStart).endOfStatement();
-    buffer.append("alter table ").append(baseTableName).append(" drop column ").append(sysPeriodEnd).endOfStatement();
+    platformDdl.alterTableDropColumn(buffer, baseTableName, sysPeriodStart);
+    platformDdl.alterTableDropColumn(buffer, baseTableName, sysPeriodEnd);
   }
 
   protected void appendInsertIntoHistory(DdlBuffer buffer, String historyTable, List<String> columns) throws IOException {

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

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

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

@@ -0,0 +1,51 @@
+package io.ebeaninternal.dbmigration.ddlgeneration.platform;
+
+import io.ebean.config.dbplatform.DatabasePlatform;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
+
+import java.io.IOException;
+
+public class HanaColumnStoreDdl extends AbstractHanaDdl {
+
+  public HanaColumnStoreDdl(DatabasePlatform platform) {
+    super(platform);
+    this.createTable = "create column table";
+  }
+
+  @Override
+  public String createIndex(String indexName, String tableName, String[] columns) {
+    if (columns == null || columns.length == 0) {
+      return "-- cannot create index: no columns given";
+    }
+
+    if (columns.length == 1) {
+      return "-- explicit index \"" + indexName + "\" for single column \"" + columns[0] + "\" of table \"" + tableName
+          + "\" is not necessary";
+    }
+
+    StringBuilder buffer = new StringBuilder();
+    buffer.append("create inverted hash index ").append(maxConstraintName(indexName)).append(" on ").append(tableName);
+    appendColumns(columns, buffer);
+
+    return buffer.toString();
+  }
+
+  @Override
+  public String dropIndex(String indexName, String tableName) {
+    DdlBuffer buffer = new BaseDdlBuffer(null);
+    try {
+      buffer.append("delimiter $$").newLine();
+      buffer.append("do").newLine();
+      buffer.append("begin").newLine();
+      buffer.append("declare exit handler for sql_error_code 261 begin end").endOfStatement();
+      buffer.append("exec '").append(dropIndexIfExists).append(maxConstraintName(indexName)).append("'")
+          .endOfStatement();
+      buffer.append("end").endOfStatement();
+      buffer.append("$$");
+      return buffer.getBuffer();
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+}

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

@@ -0,0 +1,11 @@
+package io.ebeaninternal.dbmigration.ddlgeneration.platform;
+
+import io.ebean.config.ServerConfig;
+import io.ebeaninternal.dbmigration.ddlgeneration.BaseDdlHandler;
+
+public class HanaDdlHandler extends BaseDdlHandler {
+
+  public HanaDdlHandler(ServerConfig serverConfig, PlatformDdl platformDdl) {
+    super(serverConfig, platformDdl, new HanaTableDdl(serverConfig, platformDdl));
+  }
+}

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

@@ -0,0 +1,157 @@
+package io.ebeaninternal.dbmigration.ddlgeneration.platform;
+
+import io.ebean.config.ServerConfig;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
+import io.ebeaninternal.dbmigration.migration.AddHistoryTable;
+import io.ebeaninternal.dbmigration.migration.DropHistoryTable;
+import io.ebeaninternal.dbmigration.model.MColumn;
+import io.ebeaninternal.dbmigration.model.MTable;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class HanaHistoryDdl implements PlatformHistoryDdl {
+
+  private String systemPeriodStart;
+  private String systemPeriodEnd;
+  private PlatformDdl platformDdl;
+  private String historySuffix;
+  private final AtomicInteger counter = new AtomicInteger(0);
+  private Map<String, String> createdHistoryTables = new ConcurrentHashMap<>();
+
+  @Override
+  public void configure(ServerConfig serverConfig, PlatformDdl platformDdl) {
+    this.systemPeriodStart = serverConfig.getAsOfSysPeriod() + "_start";
+    this.systemPeriodEnd = serverConfig.getAsOfSysPeriod() + "_end";
+    this.platformDdl = platformDdl;
+    this.historySuffix = serverConfig.getHistoryTableSuffix();
+  }
+
+  @Override
+  public void createWithHistory(DdlWrite writer, MTable table) throws IOException {
+    String tableName = table.getName();
+    String historyTableName = tableName + historySuffix;
+    DdlBuffer apply = writer.applyHistoryView();
+    if (apply.isEmpty()) {
+      createdHistoryTables.clear();
+    }
+
+    apply.append(platformDdl.getCreateTableCommandPrefix()).append(" ").append(historyTableName).append(" (").newLine();
+
+    // create history table
+    Collection<MColumn> cols = table.allColumns();
+    for (MColumn column : cols) {
+      if (!column.isDraftOnly()) {
+        writeColumnDefinition(apply, column.getName(), column.getType(), column.getDefaultValue(), column.isNotnull(),
+          column.isIdentity() ? platformDdl.identitySuffix : null);
+        apply.append(",").newLine();
+      }
+    }
+    writeColumnDefinition(apply, systemPeriodStart, "TIMESTAMP", null, false, null);
+    apply.append(",").newLine();
+    writeColumnDefinition(apply, systemPeriodEnd, "TIMESTAMP", null, false, null);
+    apply.newLine().append(")").endOfStatement();
+
+    // enable system versioning
+    apply.append("alter table ").append(tableName).append(" add (").newLine();
+    apply.append("    ").append(systemPeriodStart).append(" TIMESTAMP NOT NULL GENERATED ALWAYS AS ROW START, ").newLine();
+    apply.append("    ").append(systemPeriodEnd).append(" TIMESTAMP NOT NULL GENERATED ALWAYS AS ROW END").newLine();
+    apply.append(")").endOfStatement();
+
+    apply.append("alter table ").append(tableName).append(" add period for system_time(").append(systemPeriodStart)
+      .append(",").append(systemPeriodEnd).append(")").endOfStatement();
+
+    enableSystemVersioning(apply, tableName, historyTableName, true, false);
+
+    createdHistoryTables.put(tableName, historyTableName);
+
+    dropHistoryTable(writer.dropAll(), tableName, historyTableName);
+  }
+
+  @Override
+  public void dropHistoryTable(DdlWrite writer, DropHistoryTable dropHistoryTable) throws IOException {
+    dropHistoryTable(writer.applyDropDependencies(), dropHistoryTable.getBaseTable(),
+      dropHistoryTable.getBaseTable() + historySuffix);
+  }
+
+  protected void dropHistoryTable(DdlBuffer apply, String baseTable, String historyTable) throws IOException {
+    // disable system versioning
+    disableSystemVersioning(apply, baseTable);
+
+    apply.append("alter table ").append(baseTable).append(" drop period for system_time").endOfStatement();
+
+    // drop the period columns
+    apply.append("alter table ").append(baseTable).append(" drop (").append(systemPeriodStart).append(",")
+      .append(systemPeriodEnd).append(")").endOfStatement();
+
+    // drop the history table
+    apply.append("drop table ").append(historyTable).append(" cascade").endOfStatement();
+  }
+
+  @Override
+  public void addHistoryTable(DdlWrite writer, AddHistoryTable addHistoryTable) throws IOException {
+    MTable table = writer.getTable(addHistoryTable.getBaseTable());
+    if (table == null) {
+      throw new IllegalStateException("MTable " + addHistoryTable.getBaseTable() + " not found in writer? (required for history DDL)");
+    }
+    createWithHistory(writer, table);
+  }
+
+  @Override
+  public void updateTriggers(DdlWrite write, HistoryTableUpdate baseTable) {
+    // nothing to do
+  }
+
+  protected void writeColumnDefinition(DdlBuffer buffer, String columnName, String type, String defaultValue,
+                                       boolean isNotNull, String generated) throws IOException {
+
+    String platformType = platformDdl.convert(type, false);
+    buffer.append(" ").append(platformDdl.lowerColumnName(columnName));
+    buffer.append(" ").append(platformType);
+    if (defaultValue != null) {
+      buffer.append(" default ").append(defaultValue);
+    }
+    if (isNotNull) {
+      buffer.append(" not null");
+    }
+    if (generated != null) {
+      buffer.append(" ").append(generated);
+    }
+  }
+
+  public void disableSystemVersioning(DdlBuffer apply, String tableName) throws IOException {
+    disableSystemVersioning(apply, tableName, false);
+  }
+
+  public void disableSystemVersioning(DdlBuffer apply, String tableName, boolean uniqueStatement) throws IOException {
+    apply.append("alter table ").append(tableName).append(" drop system versioning");
+    if (uniqueStatement) {
+      // needed for the DB migration test to prevent the statement from being filtered
+      // out as a duplicate
+      apply.append(" /* ").append(String.valueOf(counter.getAndIncrement())).append(" */");
+    }
+    apply.endOfStatement();
+  }
+
+  public void enableSystemVersioning(DdlBuffer apply, String tableName, String historyTableName, boolean validated,
+                                     boolean uniqueStatement) throws IOException {
+    apply.append("alter table ").append(tableName).append(" add system versioning history table ").append(historyTableName);
+    if (!validated) {
+      apply.append(" not validated");
+    }
+    if (uniqueStatement) {
+      // needed for the DB migration test to prevent the statement from being filtered
+      // out as a duplicate
+      apply.append(" /* ").append(String.valueOf(counter.getAndIncrement())).append(" */");
+    }
+    apply.endOfStatement();
+  }
+
+  public boolean isSystemVersioningEnabled(String tableName) {
+    return !createdHistoryTables.containsKey(tableName);
+  }
+}

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

@@ -0,0 +1,11 @@
+package io.ebeaninternal.dbmigration.ddlgeneration.platform;
+
+import io.ebean.config.dbplatform.DatabasePlatform;
+
+public class HanaRowStoreDdl extends AbstractHanaDdl {
+
+  public HanaRowStoreDdl(DatabasePlatform platform) {
+    super(platform);
+    this.createTable = "create row table";
+  }
+}

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

@@ -0,0 +1,134 @@
+package io.ebeaninternal.dbmigration.ddlgeneration.platform;
+
+import io.ebean.config.PropertiesWrapper;
+import io.ebean.config.ServerConfig;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
+import io.ebeaninternal.dbmigration.migration.AddColumn;
+import io.ebeaninternal.dbmigration.migration.AlterColumn;
+import io.ebeaninternal.dbmigration.migration.Column;
+import io.ebeaninternal.dbmigration.migration.DropColumn;
+import io.ebeaninternal.dbmigration.model.MTable;
+
+import java.io.IOException;
+import java.util.List;
+
+public class HanaTableDdl extends BaseTableDdl {
+
+  private final HanaHistoryDdl historyDdl;
+  private final boolean generateUniqueDdl;
+
+  public HanaTableDdl(ServerConfig serverConfig, PlatformDdl platformDdl) {
+    super(serverConfig, platformDdl);
+    this.historyDdl = (HanaHistoryDdl) platformDdl.historyDdl;
+    if (serverConfig.getProperties() != null) {
+      PropertiesWrapper wrapper = new PropertiesWrapper("ebean", "hana", serverConfig.getProperties(), serverConfig.getClassLoadConfig());
+      this.generateUniqueDdl = wrapper.getBoolean("generateUniqueDdl", false);
+    } else {
+      this.generateUniqueDdl = false;
+    }
+  }
+
+  @Override
+  protected void alterColumnDefaultValue(DdlWrite writer, AlterColumn alter) throws IOException {
+    String ddl = platformDdl.alterColumnBaseAttributes(alter);
+    if (hasValue(ddl)) {
+      writer.apply().append(ddl).endOfStatement();
+    }
+  }
+
+  @Override
+  public void generate(DdlWrite writer, AddColumn addColumn) throws IOException {
+    String tableName = addColumn.getTableName();
+    MTable table = writer.getTable(tableName);
+    if (table == null) {
+      super.generate(writer, addColumn);
+      return;
+    }
+
+    boolean manageSystemVersioning = isTrue(table.isWithHistory()) && historyDdl.isSystemVersioningEnabled(tableName);
+
+    if (manageSystemVersioning) {
+      historyDdl.disableSystemVersioning(writer.apply(), table.getName(), this.generateUniqueDdl);
+    }
+
+    super.generate(writer, addColumn);
+
+    if (manageSystemVersioning) {
+      // make same changes to the history table
+      String historyTable = historyTable(tableName);
+      List<Column> columns = addColumn.getColumn();
+      for (Column column : columns) {
+        alterTableAddColumn(writer.apply(), historyTable, column, true, true);
+      }
+
+      historyDdl.enableSystemVersioning(writer.apply(), table.getName(), historyTable, false, this.generateUniqueDdl);
+    }
+  }
+
+  @Override
+  public void generate(DdlWrite writer, AlterColumn alterColumn) throws IOException {
+    String tableName = alterColumn.getTableName();
+    MTable table = writer.getTable(tableName);
+    if (table == null) {
+      super.generate(writer, alterColumn);
+      return;
+    }
+
+    boolean manageSystemVersioning = isTrue(table.isWithHistory()) && historyDdl.isSystemVersioningEnabled(tableName);
+
+    if (manageSystemVersioning) {
+      historyDdl.disableSystemVersioning(writer.apply(), tableName, this.generateUniqueDdl);
+    }
+
+    super.generate(writer, alterColumn);
+
+    if (manageSystemVersioning) {
+      // make same changes to the history table
+      String historyTable = historyTable(tableName);
+      if (hasValue(alterColumn.getType()) || hasValue(alterColumn.getDefaultValue()) || alterColumn.isNotnull() != null) {
+        AlterColumn alterHistoryColumn = new AlterColumn();
+        alterHistoryColumn.setTableName(historyTable);
+        alterHistoryColumn.setColumnName(alterColumn.getColumnName());
+        alterHistoryColumn.setType(alterColumn.getType());
+        alterHistoryColumn.setDefaultValue(alterColumn.getDefaultValue());
+        alterHistoryColumn.setNotnull(alterColumn.isNotnull());
+        alterHistoryColumn.setCurrentType(alterColumn.getCurrentType());
+        alterHistoryColumn.setCurrentDefaultValue(alterColumn.getCurrentDefaultValue());
+        alterHistoryColumn.setCurrentNotnull(alterColumn.isCurrentNotnull());
+        String histColumnDdl = platformDdl.alterColumnBaseAttributes(alterHistoryColumn);
+
+        // write the apply to history table
+        writer.apply().append(histColumnDdl).endOfStatement();
+      }
+
+      historyDdl.enableSystemVersioning(writer.apply(), tableName, historyTable, false, this.generateUniqueDdl);
+    }
+  }
+
+  @Override
+  public void generate(DdlWrite writer, DropColumn dropColumn) throws IOException {
+    String tableName = dropColumn.getTableName();
+    MTable table = writer.getTable(tableName);
+    if (table == null) {
+      super.generate(writer, dropColumn);
+      return;
+    }
+
+    boolean manageSystemVersioning = isTrue(table.isWithHistory()) && historyDdl.isSystemVersioningEnabled(tableName);
+
+    if (manageSystemVersioning) {
+      historyDdl.disableSystemVersioning(writer.apply(), tableName, this.generateUniqueDdl);
+    }
+
+    super.generate(writer, dropColumn);
+
+    if (manageSystemVersioning) {
+      // also drop from the history table
+      String historyTable = historyTable(tableName);
+      alterTableDropColumn(writer.apply(), historyTable, dropColumn.getColumnName());
+
+      historyDdl.enableSystemVersioning(writer.apply(), tableName, historyTable, false, this.generateUniqueDdl);
+    }
+  }
+
+}

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

@@ -38,6 +38,16 @@ public class MySqlDdl extends PlatformDdl {
     return "alter table " + tableName + " drop foreign key " + maxConstraintName(fkName);
   }
 
+  /**
+   * It is rather complex to delete a column on MySql as there must not exist any foreign keys.
+   * That's why we call a user stored procedure here
+   */
+  @Override
+  public void alterTableDropColumn(DdlBuffer buffer, String tableName, String columnName) throws IOException {
+
+    buffer.append("CALL usp_ebean_drop_column('").append(tableName).append("', '").append(columnName).append("')").endOfStatement();
+  }
+
   @Override
   public String alterTableDropConstraint(String tableName, String constraintName) {
     // drop constraint not supported in MySQL 5.7 and 8.0 but starting with MariaDB 10.2.1 CHECK is evaluated
@@ -61,7 +71,7 @@ public class MySqlDdl extends PlatformDdl {
   @Override
   public String alterColumnDefaultValue(String tableName, String columnName, String defaultValue) {
 
-    String suffix = DdlHelp.isDropDefault(defaultValue) ? columnDropDefault : columnSetDefault + " " + defaultValue;
+    String suffix = DdlHelp.isDropDefault(defaultValue) ? columnDropDefault : columnSetDefault + " " + convertDefaultValue(defaultValue);
 
     // use alter
     return "alter table " + tableName + " alter " + columnName + " " + suffix;

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

@@ -20,7 +20,6 @@ import io.ebeaninternal.dbmigration.migration.Column;
 import io.ebeaninternal.dbmigration.migration.DropHistoryTable;
 import io.ebeaninternal.dbmigration.migration.IdentityType;
 import io.ebeaninternal.dbmigration.model.MTable;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -79,12 +78,16 @@ public class PlatformDdl {
 
   protected String alterColumn = "alter column";
 
+  protected String alterColumnSuffix = "";
+
   protected String dropUniqueConstraint = "drop constraint";
 
   protected String addConstraint = "add constraint";
 
   protected String addColumn = "add column";
 
+  protected String addColumnSuffix = "";
+
   protected String columnSetType = "";
 
   protected String columnSetDefault = "set default";
@@ -97,6 +100,12 @@ public class PlatformDdl {
 
   protected String updateNullWithDefault = "update ${table} set ${column} = ${default} where ${column} is null";
 
+  protected String createTable = "create table";
+
+  protected String dropColumn = "drop column";
+
+  protected String dropColumnSuffix = "";
+
   /**
    * Set false for MsSqlServer to allow multiple nulls for OneToOne mapping.
    */
@@ -246,6 +255,9 @@ public class PlatformDdl {
    * Convert the standard type to the platform specific type.
    */
   public String convert(String type, boolean identity) {
+    if (type == null) {
+      return null;
+    }
     if (type.contains("[]")) {
       return convertArrayType(type);
     }
@@ -455,6 +467,7 @@ public class PlatformDdl {
       if (isTrue(column.isNotnull())) {
         buffer.append(" not null");
       }
+      buffer.append(addColumnSuffix);
       buffer.endOfStatement();
 
       // check constraints cannot be added in one statement for h2
@@ -464,14 +477,15 @@ public class PlatformDdl {
         buffer.append(ddl).endOfStatement();
       }
     } else {
+      buffer.append(addColumnSuffix);
       buffer.endOfStatement();
     }
 
   }
 
   public void alterTableDropColumn(DdlBuffer buffer, String tableName, String columnName) throws IOException {
-    buffer.append("alter table ").append(tableName).append(" drop column ").append(columnName)
-    .endOfStatement();
+    buffer.append("alter table ").append(tableName).append(" ").append(dropColumn).append(" ").append(columnName)
+    .append(dropColumnSuffix).endOfStatement();
   }
 
   /**
@@ -491,19 +505,19 @@ public class PlatformDdl {
    */
   public String alterColumnType(String tableName, String columnName, String type) {
 
-    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + columnSetType + convert(type, false);
+    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + columnSetType + convert(type, false) + alterColumnSuffix;
   }
 
   /**
    * Alter a column adding or removing the not null constraint.
    * <p>
-   * Note that that MySql and SQL Server instead use alterColumnBaseAttributes()
+   * Note that that MySql, SQL Server, and HANA instead use alterColumnBaseAttributes()
    * </p>
    */
   public String alterColumnNotnull(String tableName, String columnName, boolean notnull) {
 
     String suffix = notnull ? columnSetNotnull : columnSetNull;
-    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + suffix;
+    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + suffix + alterColumnSuffix;
   }
 
   /**
@@ -519,17 +533,17 @@ public class PlatformDdl {
    */
   public String alterColumnDefaultValue(String tableName, String columnName, String defaultValue) {
     String suffix = DdlHelp.isDropDefault(defaultValue) ? columnDropDefault : columnSetDefault + " " + convertDefaultValue(defaultValue);
-    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + suffix;
+    return "alter table " + tableName + " " + alterColumn + " " + columnName + " " + suffix + alterColumnSuffix;
   }
 
   /**
    * Alter column setting both the type and not null constraint.
    * <p>
-   * Used by MySql and SQL Server as these require both column attributes to be set together.
+   * Used by MySql, SQL Server, and HANA as these require both column attributes to be set together.
    * </p>
    */
   public String alterColumnBaseAttributes(AlterColumn alter) {
-    // by default do nothing, only used by mysql and sql server as they can only
+    // by default do nothing, only used by mysql, sql server, and HANA as they can only
     // modify the column with the full column definition
     return null;
   }
@@ -659,4 +673,23 @@ public class PlatformDdl {
   public void unlockTables(DdlBuffer buffer, Collection<String> tables) throws IOException {
 
   }
+
+  /**
+   * Returns the database-specific "create table" command prefix. For HANA this is
+   * either "create column table" or "create row table", for all other databases
+   * it is "create table".
+   *
+   * @return The "create table" command prefix
+   */
+  public String getCreateTableCommandPrefix() {
+    return createTable;
+  }
+
+  public boolean suppressPrimaryKeyOnPartition() {
+    return false;
+  }
+
+  public void addTablePartition(DdlBuffer apply, String partitionMode, String partitionColumn) throws IOException {
+    // only supported by postgres initially
+  }
 }

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

@@ -1,6 +1,9 @@
 package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 
 import io.ebean.config.dbplatform.DatabasePlatform;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
+
+import java.io.IOException;
 
 /**
  * Postgres specific DDL.
@@ -16,6 +19,11 @@ public class PostgresDdl extends PlatformDdl {
     this.columnSetNull = "drop not null";
   }
 
+  @Override
+  public boolean suppressPrimaryKeyOnPartition() {
+    return true;
+  }
+
   @Override
   protected String convertArrayType(String logicalArrayType) {
     return NativeDbArray.logicalToNative(logicalArrayType);
@@ -38,4 +46,9 @@ public class PostgresDdl extends PlatformDdl {
     }
     return columnDefn;
   }
+
+  @Override
+  public void addTablePartition(DdlBuffer apply, String partitionMode, String partitionColumn) throws IOException {
+    apply.append(" partition by range (").append(partitionColumn).append(")");
+  }
 }

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

@@ -3,7 +3,9 @@ package io.ebeaninternal.dbmigration.ddlgeneration.platform;
 import io.ebean.annotation.ConstraintMode;
 import io.ebean.config.dbplatform.DatabasePlatform;
 import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
 import io.ebeaninternal.dbmigration.migration.AlterColumn;
+import io.ebeaninternal.server.persist.platform.MultiValueBind;
 
 import java.io.IOException;
 
@@ -137,13 +139,7 @@ public class SqlServerDdl extends PlatformDdl {
     // a rather complex statement.
     StringBuilder sb = new StringBuilder();
     if (DdlHelp.isDropDefault(defaultValue)) {
-      sb.append("delimiter $$\n");
-      sb.append("DECLARE @Tmp nvarchar(200);");
-      sb.append("select @Tmp = t1.name  from sys.default_constraints t1\n");
-      sb.append("  join sys.columns t2 on t1.object_id = t2.default_object_id\n");
-      sb.append("  where t1.parent_object_id = OBJECT_ID('").append(tableName)
-        .append("') and t2.name = '").append(columnName).append("';\n");
-      sb.append("if @Tmp is not null EXEC('alter table ").append(tableName).append(" drop constraint ' + @Tmp)$$");
+      sb.append("EXEC usp_ebean_drop_default_constraint ").append(tableName).append(", ").append(columnName);
     } else {
       sb.append("alter table ").append(tableName);
       sb.append(" add default ").append(convertDefaultValue(defaultValue)).append(" for ").append(columnName);
@@ -200,25 +196,50 @@ public class SqlServerDdl extends PlatformDdl {
 
   /**
    * It is rather complex to delete a column on SqlServer as there must not exist any references
-   * (constraints, default values, indices and foreign keys). The list is not yet complete, as
-   * indices over multiple columns will not yet deleted.
-   * (This may be changed to delete all refering objects by using the sys.* tables later)
+   * (constraints, default values, indices and foreign keys). That's why we call a user stored procedure here
    */
   @Override
   public void alterTableDropColumn(DdlBuffer buffer, String tableName, String columnName) throws IOException {
-    buffer.append("-- drop column ").append(tableName).append(".").append(columnName).endOfStatement();
 
-    buffer.append(alterTableDropUniqueConstraint(tableName, naming.uniqueConstraintName(tableName, columnName)));
-    buffer.endOfStatement();
-    buffer.append(alterColumnDefaultValue(tableName, columnName, DdlHelp.DROP_DEFAULT));
-    buffer.endOfStatement();
-    buffer.append(alterTableDropConstraint(tableName, naming.checkConstraintName(tableName, columnName)));
-    buffer.endOfStatement();
-    buffer.append(dropIndex(naming.indexName(tableName, columnName), tableName));
-    buffer.endOfStatement();
-    buffer.append(alterTableDropForeignKey(tableName, naming.foreignKeyConstraintName(tableName, columnName)));
-    buffer.endOfStatement();
-    super.alterTableDropColumn(buffer, tableName, columnName);
+    buffer.append("EXEC usp_ebean_drop_column ").append(tableName).append(", ").append(columnName).endOfStatement();
+  }
+
+  /**
+   * This writes the multi value datatypes needed for {@link MultiValueBind}
+   */
+  @Override
+  public void generateProlog(DdlWrite write) throws IOException {
+    super.generateProlog(write);
+
+    generateTVPDefinitions(write, "bigint");
+    generateTVPDefinitions(write, "float");
+    generateTVPDefinitions(write, "bit");
+    generateTVPDefinitions(write, "date");
+    generateTVPDefinitions(write, "time");
+    //generateTVPDefinitions(write, "datetime2");
+    generateTVPDefinitions(write, "uniqueidentifier");
+    generateTVPDefinitions(write, "nvarchar(max)");
+
+  }
+
+  private void generateTVPDefinitions(DdlWrite write, String definition) throws IOException {
+    int pos = definition.indexOf('(');
+    String name = pos == -1 ? definition : definition.substring(0, pos);
+
+    dropTVP(write.dropAll(), name);
+    //TVPs are included in "I__create_procs.sql"
+    //createTVP(write.apply(), name, definition);
+  }
+
+  private void dropTVP(DdlBuffer ddl, String name) throws IOException {
+    ddl.append("if exists (select name  from sys.types where name = 'ebean_").append(name)
+        .append("_tvp') drop type ebean_").append(name).append("_tvp").endOfStatement();
+  }
+
+  private void createTVP(DdlBuffer ddl, String name, String definition) throws IOException {
+    ddl.append("if not exists (select name  from sys.types where name = 'ebean_").append(name)
+    .append("_tvp') create type ebean_").append(name).append("_tvp as table (c1 ").append(definition).append(")")
+        .endOfStatement();
   }
 
 }