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

ENHANCEMENT: multiple indices & meta-annotation support similar to spring-framework

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,19 @@
+
+GITHUB ISSUES ARE STRICTLY CONTROLLED FOR THIS PROJECT.
+
+Refer to http://ebean-orm.github.io/support for the policies controlling the use of github issues.
+Please post issues to the Ebean group https://groups.google.com/forum/#!forum/ebean first.
+
+## Expected behavior
+
+## Actual behavior
+
+### Steps to reproduce
+
+```java
+  // some java code
+```
+
+```console
+  // some logging output
+```

.gitignore

@@ -1,5 +1,6 @@
 *.autofetch
-*.sql
+*create-all.sql
+*drop-all.sql
 *.orig
 .classpath
 .project

.travis.yml

@@ -0,0 +1,32 @@
+sudo: required
+language: java
+jdk:
+  - oraclejdk8
+
+git:
+  depth: 3
+
+addons:
+  postgresql: "9.4"
+
+services:
+  - postgresql
+
+before_script:
+  - ./.travis/setup_database
+
+env:
+  - EBEAN_DB=h2
+  - EBEAN_DB=pg
+
+install: true
+
+script:
+  - mvn clean test
+
+after_failure:
+  - ./.travis/print_surefire_reports
+
+cache:
+  directories:
+  - $HOME/.m2

.travis/print_surefire_reports

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+echo "\n=== SUREFIRE REPORTS ===\n"
+
+for file in target/surefire-reports/*.txt
+do
+    echo ${file}
+    cat ${file}
+    echo
+done

.travis/setup_database

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+echo "\n=== SETUP DATABASE ===\n"
+
+#set -e
+#set -x
+
+# Setup postgres' users and databases
+sudo -u postgres psql -c "CREATE USER unit WITH PASSWORD 'unit';"
+sudo -u postgres psql -c 'CREATE DATABASE unit WITH OWNER unit;'
+sudo -u postgres psql unit -c 'CREATE EXTENSION hstore;'
+sudo -u postgres psql unit -c 'CREATE EXTENSION pgcrypto;'
+#sudo -u postgres psql test2 -c 'CREATE EXTENSION postgis;'
+

README.md

@@ -1,14 +1,17 @@
-* [![Maven Central : avaje-ebeanorm](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm) - avaje-ebeanorm 
-* [![Maven Central : avaje-ebeanorm-agent](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm-agent) - avaje-ebeanorm-agent
-* [![Maven Central : avaje-ebeanorm-agent](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm-mavenenhancer/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebeanorm/avaje-ebeanorm-mavenenhancer) - avaje-ebeanorm-mavenenhancer
+# 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")
 
 
-Ebean ORM
-==============
-[https://ebean-orm.github.io/](http://ebean-orm.github.io/ "Ebean ORM's Website")
+## Maven cental links:
+[Maven central - ebean](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22org.avaje.ebean%22%20AND%20a%3A%22ebean%22 "maven central ebean")
 
+[Maven central - all related projects](http://search.maven.org/#search%7Cga%7C1%7Cebean "maven central all related projects")
 
-[Maven central - avaje-ebeanorm](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22org.avaje.ebeanorm%22%20AND%20a%3A%22avaje-ebeanorm%22 "maven central ebeanorm")
-
-[Maven central - all related projects](http://search.maven.org/#search%7Cga%7C1%7Cavaje-ebeanorm "maven central ebeanorm")
+## Current versions
+* [![Maven Central : ebean](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean) - ebean
+* [![Maven Central : ebean-agent](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-agent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-agent) - ebean-agent
+* [![Maven Central : ebean-maven-plugin](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-maven-plugin/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.avaje.ebean/ebean-maven-plugin) - ebean-maven-plugin
 

pom.xml

@@ -3,17 +3,17 @@
 
   <parent>
     <groupId>org.avaje</groupId>
-    <artifactId>avaje-javaparent</artifactId>
-    <version>1.2</version>
+    <artifactId>oss-parent</artifactId>
+    <version>1.1</version>
   </parent>
 
-  <groupId>org.avaje.ebeanorm</groupId>
-  <artifactId>avaje-ebeanorm</artifactId>
-  <version>6.12.1</version>
+  <groupId>org.avaje.ebean</groupId>
+  <artifactId>ebean</artifactId>
+  <version>8.2.2</version>
   <packaging>jar</packaging>
 
-  <name>avaje-ebeanorm</name>
-  <url>http://www.avaje.org</url>
+  <name>ebean</name>
+  <url>http://ebean-orm.github.io/</url>
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -36,9 +36,8 @@
   </developers>
 
   <scm>
-    <connection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm.git</connection>
-    <developerConnection>scm:git:https://github.com/ebean-orm/avaje-ebeanorm.git</developerConnection>
-    <url>https://github.com/ebean-orm/avaje-ebeanorm.git</url>
+    <developerConnection>scm:git:https://github.com/ebean-orm/ebean.git</developerConnection>
+    <tag>ebean-8.2.2</tag>
   </scm>
 
   <dependencies>
@@ -55,33 +54,61 @@
       <version>1.0</version>
     </dependency>
 
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-datasource-api</artifactId>
+      <version>1.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-datasource</artifactId>
+      <version>1.1.3</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-classpath-scanner-api</artifactId>
+      <version>2.2</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-classpath-scanner</artifactId>
+      <version>2.2.1</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje</groupId>
+      <artifactId>avaje-dbmigration</artifactId>
+      <version>1.2.1</version>
+    </dependency>
+
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
-      <version>1.7.7</version>
+      <version>[1.7.1,1.7.99)</version>
     </dependency>
 
-    <!-- provided scope for Spring boot loader classpath scanning support -->
     <dependency>
-      <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-loader</artifactId>
-      <version>1.2.7.RELEASE</version>
-      <scope>provided</scope>
-    </dependency>
-
-    <!-- provided scope for JsonNode support -->
-    <dependency>
-      <groupId>com.fasterxml.jackson.core</groupId>
-      <artifactId>jackson-databind</artifactId>
-      <version>2.5.3</version>
-      <scope>provided</scope>
+      <groupId>org.antlr</groupId>
+      <artifactId>antlr4-runtime</artifactId>
+      <version>4.5.3</version>
     </dependency>
 
     <!-- Jackson core used internally by Ebean -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
-      <version>2.5.3</version>
+      <version>2.6.5</version>
+    </dependency>
+
+    <!-- provided scope for JsonNode support -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.6.5</version>
+      <scope>provided</scope>
     </dependency>
 
     <dependency>
@@ -121,6 +148,8 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- Test scope -->
+
     <!--<dependency>-->
       <!--<groupId>oracle</groupId>-->
       <!--<artifactId>oracle-jdbc</artifactId>-->
@@ -135,13 +164,6 @@
       <!--<scope>test</scope>-->
     <!--</dependency>-->
 
-    <dependency>
-      <groupId>com.squareup.okhttp</groupId>
-      <artifactId>okhttp</artifactId>
-      <version>2.1.0</version>
-      <scope>test</scope>
-    </dependency>
-
     <dependency>
       <groupId>org.avaje</groupId>
       <artifactId>avaje-agentloader</artifactId>
@@ -150,9 +172,9 @@
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.ebeanorm</groupId>
-      <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.7.1</version>
+      <groupId>org.avaje.ebean</groupId>
+      <artifactId>ebean-agent</artifactId>
+      <version>8.1.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -161,14 +183,14 @@
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
-      <version>1.4.189</version>
+      <version>1.4.192</version>
       <scope>provided</scope>
     </dependency>
     
     <dependency>
       <groupId>org.xerial</groupId>
       <artifactId>sqlite-jdbc</artifactId>
-      <version>3.7.2</version>
+      <version>3.8.11.2</version>
       <scope>test</scope>
     </dependency>
 
@@ -201,12 +223,19 @@
       <scope>test</scope>
     </dependency>
 
+    <dependency>
+      <groupId>org.avaje.moduuid</groupId>
+      <artifactId>avaje-moduuid</artifactId>
+      <version>1.2</version>
+      <scope>test</scope>
+    </dependency>
+
   </dependencies>
 
 
-  <!-- Enhance the meta beans -->
   <build>
     <plugins>
+
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
@@ -216,18 +245,17 @@
           <target>1.6</target>
         </configuration>
       </plugin>
+
       <plugin>
-        <groupId>org.avaje.ebeanorm</groupId>
-        <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.7.1</version>
+        <groupId>org.avaje.ebean</groupId>
+        <artifactId>ebean-maven-plugin</artifactId>
+        <version>8.1.1</version>
         <executions>
-          <!--   Not going to enhance Model bean -->
           <execution>
             <id>test</id>
             <phase>process-test-classes</phase>
             <configuration>
               <classSource>target/test-classes</classSource>
-              <packages>com.avaje.tests.**</packages>
               <transformArgs>debug=1</transformArgs>
             </configuration>
             <goals>
@@ -258,7 +286,8 @@
           </systemProperties>
         </configuration>
       </plugin>
- 	 <plugin>
+
+      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-jar-plugin</artifactId>
         <version>2.5</version>
@@ -268,12 +297,13 @@
           </archive>
         </configuration>
       </plugin>
+
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>2.9.1</version>
         <configuration>
-          <doctitle>Ebean 6</doctitle>
+          <doctitle>Ebean 8</doctitle>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
@@ -292,9 +322,7 @@
           </additionalparam>
           <linksource>true</linksource>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
-
         </configuration>
-
         <executions>
           <execution>
             <id>attach-javadocs</id>
@@ -304,6 +332,7 @@
           </execution>
         </executions>
       </plugin>
+
     </plugins>
 
   </build>

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

@@ -11,4 +11,14 @@ public interface AutoTune {
    */
   void collectProfiling();
 
+  /**
+   * Output the profiling.
+   * <p>
+   * When profiling updates are applied to tuning at runtime this reports all tuning and profiling combined.
+   * When profiling is not applied at runtime then this reports the diff report with new and diff entries relative
+   * to the existing tuning.
+   * </p>
+   */
+  void reportProfiling();
+
 }

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

@@ -38,6 +38,11 @@ public interface BeanState {
    */
   void setDisableLazyLoad(boolean disableLazyLoading);
 
+  /**
+   * Return true if the bean has lazy loading disabled.
+   */
+  boolean isDisableLazyLoad();
+
   /**
    * Set the loaded state of the property given it's name.
    *
@@ -115,4 +120,9 @@ public interface BeanState {
    * for a fully loaded entity bean.
    */
   void setLoaded();
+
+  /**
+   * Reset the bean putting it into NEW state such that a save() results in an insert.
+   */
+  void resetForInsert();
 }

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

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

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

@@ -46,6 +46,7 @@ class DRawSqlParser {
 
   private DRawSqlParser(String sqlString) {
     sqlString = sqlString.trim();
+    sqlString = sqlString.replace('\n',' ');
     this.sql = sqlString;
     this.hasPlaceHolders = findAndRemovePlaceHolders();
     this.textParser = new SimpleTextParser(sqlString);
@@ -70,7 +71,7 @@ class DRawSqlParser {
 
     preFrom = trimSelectKeyword(preFrom);
 
-    return new Sql(sql.hashCode(), preFrom, preWhere, whereExprAnd, preHaving, havingExprAnd, orderByPrefix, orderBySql, (distinctPos > -1));
+    return new Sql(sql, preFrom, preWhere, whereExprAnd, preHaving, havingExprAnd, orderByPrefix, orderBySql, (distinctPos > -1));
   }
 
   /**
@@ -120,8 +121,7 @@ class DRawSqlParser {
       // trim of distinct keyword
       String distinct = preWhereExprSql.substring(0, 9);
       if (!distinct.equalsIgnoreCase("distinct ")) {
-        throw new RuntimeException("Expecting [" + preWhereExprSql
-            + "] to start with \"select distinct\"");
+        throw new RuntimeException("Expecting [" + preWhereExprSql + "] to start with \"select distinct\"");
       }
       preWhereExprSql = preWhereExprSql.substring(9);
     }

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

@@ -0,0 +1,94 @@
+package com.avaje.ebean;
+
+/**
+ * Bean holding the details to update the document store.
+ */
+public final class DocStoreQueueEntry {
+
+  /**
+   * Action to either update or delete a document from the index.
+   */
+  public enum Action {
+
+    /**
+     * Action is to update a document in the doc store.
+     */
+    INDEX(1),
+
+    /**
+     * Action is to delete a document from the doc store..
+     */
+    DELETE(2),
+
+    /**
+     * An update is required based on a change to a nested/embedded object at a given path.
+     */
+    NESTED(3);
+
+    int value;
+
+    Action(int value) {
+      this.value = value;
+    }
+
+    /**
+     * Return the value associated with this action type.
+     */
+    public int getValue() {
+      return value;
+    }
+  }
+
+  final Action type;
+
+  final String queueId;
+
+  final String path;
+
+  final Object beanId;
+
+  /**
+   * Construct for an INDEX or DELETE action.
+   */
+  public DocStoreQueueEntry(Action type, String queueId, Object beanId) {
+    this(type, queueId, null, beanId);
+  }
+
+  /**
+   * Construct for an NESTED/embedded path invalidation action.
+   */
+  public DocStoreQueueEntry(Action type, String queueId, String path, Object beanId) {
+    this.type = type;
+    this.queueId = queueId;
+    this.path = path;
+    this.beanId = beanId;
+  }
+
+  /**
+   * Return the event type.
+   */
+  public Action getType() {
+    return type;
+  }
+
+  /**
+   * Return the associate queueId.
+   */
+  public String getQueueId() {
+    return queueId;
+  }
+
+  /**
+   * Return the path if this is a nested update.
+   */
+  public String getPath() {
+    return path;
+  }
+
+  /**
+   * Return the bean id (which matches the document id).
+   */
+  public Object getBeanId() {
+    return beanId;
+  }
+}

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

@@ -0,0 +1,304 @@
+package com.avaje.ebean;
+
+import com.avaje.ebeanservice.docstore.api.DocQueryRequest;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Document storage operations.
+ */
+public interface DocumentStore {
+
+  /**
+   * Update the associated document store using the result of the query.
+   * <p>
+   * This will execute the query against the database creating a document for each
+   * bean graph and sending this to the document store.
+   * </p>
+   * <p>
+   * Note that the select and fetch paths of the query is set for you to match the
+   * document structure needed based on <code>@DocStore</code> and <code>@DocStoreEmbedded</code>
+   * so what this query requires is the predicates only.
+   * </p>
+   * <p>
+   * This query will be executed using findEach so it is safe to use a query
+   * that will fetch a lot of beans. The default bulkBatchSize is used.
+   * </p>
+   *
+   * @param query The query that selects object to send to the document store.
+   */
+  <T> void indexByQuery(Query<T> query);
+
+  /**
+   * Update the associated document store index using the result of the query additionally specifying a
+   * bulkBatchSize to use for sending the messages to ElasticSearch.
+   *
+   * @param query         The query that selects object to send to the document store.
+   * @param bulkBatchSize The batch size to use when bulk sending to the document store.
+   */
+  <T> void indexByQuery(Query<T> query, int bulkBatchSize);
+
+  /**
+   * Update the document store for all beans of this type.
+   * <p>
+   * This is the same as indexByQuery where the query has no predicates and so fetches all rows.
+   * </p>
+   */
+  void indexAll(Class<?> beanType);
+
+  /**
+   * Return the bean by fetching it's content from the document store.
+   * If the document is not found null is returned.
+   * <p>
+   * Typically this is called indirectly by findUnique() on the query.
+   * </p>
+   * <pre>{@code
+   *
+   * Customer customer =
+   *   server.find(Customer.class)
+   *     .setUseDocStore(true)
+   *     .setId(42)
+   *     .findUnique();
+   *
+   * }</pre>
+   */
+  @Nullable
+  <T> T find(DocQueryRequest<T> request);
+
+  /**
+   * Execute the find list query. This request is prepared to execute secondary queries.
+   * <p>
+   * Typically this is called indirectly by findList() on the query that has setUseDocStore(true).
+   * </p>
+   * <pre>{@code
+   *
+   * List<Customer> newCustomers =
+   *  server.find(Customer.class)
+   *    .setUseDocStore(true)
+   *    .where().eq("status, Customer.Status.NEW)
+   *    .findList();
+   *
+   * }</pre>
+   */
+  <T> List<T> findList(DocQueryRequest<T> request);
+
+  /**
+   * Execute the query against the document store returning the paged list.
+   * <p>
+   * The query should have <code>firstRow</code> or <code>maxRows</code> set prior to calling this method.
+   * </p>
+   * <p>
+   * Typically this is called indirectly by findPagedList() on the query that has setUseDocStore(true).
+   * </p>
+   *
+   * <pre>{@code
+   *
+   * PagedList<Customer> newCustomers =
+   *  server.find(Customer.class)
+   *    .setUseDocStore(true)
+   *    .where().eq("status, Customer.Status.NEW)
+   *    .setMaxRows(50)
+   *    .findPagedList();
+   *
+   * }</pre>
+   *
+   */
+  <T> PagedList<T> findPagedList(DocQueryRequest<T> request);
+
+  /**
+   * Execute the query against the document store with the expectation of a large set of results
+   * that are processed in a scrolling resultSet fashion.
+   * <p>
+   * For example, with the ElasticSearch doc store this uses SCROLL.
+   * </p>
+   * <p>
+   * Typically this is called indirectly by findEach() on the query that has setUseDocStore(true).
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  server.find(Order.class)
+   *    .setUseDocStore(true)
+   *    .where()... // perhaps add predicates
+   *    .findEach(new QueryEachConsumer<Order>() {
+   *      @Override
+   *      public void accept(Order bean) {
+   *        // process the bean
+   *      }
+   *    });
+   *
+   * }</pre>
+   */
+  <T> void findEach(DocQueryRequest<T> query, QueryEachConsumer<T> consumer);
+
+  /**
+   * Execute the query against the document store with the expectation of a large set of results
+   * that are processed in a scrolling resultSet fashion.
+   * <p>
+   * Unlike findEach() this provides the opportunity to stop iterating through the large query.
+   * </p>
+   * <p>
+   * For example, with the ElasticSearch doc store this uses SCROLL.
+   * </p>
+   * <p>
+   * Typically this is called indirectly by findEachWhile() on the query that has setUseDocStore(true).
+   * </p>
+   *
+   *
+   * <pre>{@code
+   *
+   *  server.find(Order.class)
+   *    .setUseDocStore(true)
+   *    .where()... // perhaps add predicates
+   *    .findEachWhile(new QueryEachWhileConsumer<Order>() {
+   *      @Override
+   *      public void accept(Order bean) {
+   *        // process the bean
+   *
+   *        // return true to continue, false to stop
+   *        // boolean shouldContinue = ...
+   *        return shouldContinue;
+   *      }
+   *    });
+   *
+   * }</pre>
+   */
+  <T> void findEachWhile(DocQueryRequest<T> query, QueryEachWhileConsumer<T> consumer);
+
+  /**
+   * Process the queue entries sending updates to the document store or queuing them for later processing.
+   */
+  long process(List<DocStoreQueueEntry> queueEntries) throws IOException;
+
+  /**
+   * Drop the index from the document store (similar to DDL drop table).
+   *
+   * <pre>{@code
+   *
+   *   DocumentStore documentStore = server.docStore();
+   *
+   *   documentStore.dropIndex("product_copy");
+   *
+   * }</pre>
+   *
+   */
+  void dropIndex(String indexName);
+
+  /**
+   * Create an index given a mapping file as a resource in the classPath (similar to DDL create table).
+   *
+   * <pre>{@code
+   *
+   *   DocumentStore documentStore = server.docStore();
+   *
+   *   // uses product_copy.mapping.json resource
+   *   // ... to define mappings for the index
+   *
+   *   documentStore.createIndex("product_copy", null);
+   *
+   * }</pre>
+   *
+   * @param indexName       the name of the new index
+   * @param alias           the alias of the index
+   */
+  void createIndex(String indexName, String alias);
+
+  /**
+   * Modify the settings on an index.
+   * <p>
+   * For example, this can be used be used to set elasticSearch refresh_interval
+   * on an index before a bulk update.
+   * </p>
+   * <pre>{@code
+   *
+   *   // refresh_interval -1 ... disable refresh while bulk loading
+   *
+   *   Map<String,Object> settings = new LinkedHashMap<>();
+   *   settings.put("refresh_interval", "-1");
+   *
+   *   documentStore.indexSettings("product", settings);
+   *
+   * }</pre>
+   *
+   * <pre>{@code
+   *
+   *   // refresh_interval 1s ... restore after bulk loading
+   *
+   *   Map<String,Object> settings = new LinkedHashMap<>();
+   *   settings.put("refresh_interval", "1s");
+   *
+   *   documentStore.indexSettings("product", settings);
+   *
+   * }</pre>
+   *
+   * @param indexName the name of the index to update settings on
+   * @param settings  the settings to set on the index
+   */
+  void indexSettings(String indexName, Map<String, Object> settings);
+
+  /**
+   * Copy the index to a new index.
+   * <p>
+   * This copy process does not use the database but instead will copy from the source index to a destination index.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  long copyCount = documentStore.copyIndex(Product.class, "product_copy");
+   *
+   * }</pre>
+   *
+   * @param beanType The bean type of the source index
+   * @param newIndex The name of the index to copy to
+   * @return the number of documents copied to the new index
+   */
+  long copyIndex(Class<?> beanType, String newIndex);
+
+  /**
+   * Copy entries from an index to a new index but limiting to documents that have been
+   * modified since the sinceEpochMillis time.
+   * <p>
+   * To support this the document needs to have a <code>@WhenModified</code> property.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  long copyCount = documentStore.copyIndex(Product.class, "product_copy", sinceMillis);
+   *
+   * }</pre>
+   *
+   * @param beanType The bean type of the source index
+   * @param newIndex The name of the index to copy to
+   * @return the number of documents copied to the new index
+   */
+  long copyIndex(Class<?> beanType, String newIndex, long sinceEpochMillis);
+
+  /**
+   * Copy from a source index to a new index taking only the documents
+   * matching the given query.
+   *
+   * <pre>{@code
+   *
+   *  // predicates to select the source documents to copy
+   *  Query<Product> query = server.find(Product.class)
+   *    .where()
+   *      .ge("whenModified", new Timestamp(since))
+   *      .ge("name", "A")
+   *      .lt("name", "D")
+   *      .query();
+   *
+   *  // copy from the source index to "product_copy" index
+   *  long copyCount = documentStore.copyIndex(query, "product_copy", 1000);
+   *
+   * }</pre>
+   *
+   * @param query         The query to select the source documents to copy
+   * @param newIndex      The target index to copy the documents to
+   * @param bulkBatchSize The ElasticSearch bulk batch size, if 0 uses the default.
+   * @return The number of documents copied to the new index.
+   */
+  long copyIndex(Query<?> query, String newIndex, int bulkBatchSize);
+}

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

@@ -1,24 +1,21 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.cache.ServerCacheManager;
+import com.avaje.ebean.config.ServerConfig;
+import com.avaje.ebean.text.csv.CsvReader;
+import com.avaje.ebean.text.json.JsonContext;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.persistence.OptimisticLockException;
+import javax.persistence.PersistenceException;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-import javax.persistence.OptimisticLockException;
-import javax.persistence.PersistenceException;
-
-import org.jetbrains.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.avaje.ebean.annotation.CacheStrategy;
-import com.avaje.ebean.cache.ServerCacheManager;
-import com.avaje.ebean.config.ServerConfig;
-import com.avaje.ebean.text.csv.CsvReader;
-import com.avaje.ebean.text.json.JsonContext;
-
 /**
  * This Ebean object is effectively a singleton that holds a map of registered
  * {@link EbeanServer}s. It additionally provides a convenient way to use the
@@ -164,7 +161,7 @@ public final class Ebean {
           // look to see if there is a default server defined
           String defaultName = PrimaryServer.getDefaultServerName();
           logger.debug("defaultName:" + defaultName);
-          if (defaultName != null && defaultName.trim().length() > 0) {
+          if (defaultName != null && !defaultName.trim().isEmpty()) {
             defaultServer = getWithCreate(defaultName.trim());
           }
         }
@@ -185,7 +182,7 @@ public final class Ebean {
     }
 
     private EbeanServer get(String name) {
-      if (name == null || name.length() == 0) {
+      if (name == null || name.isEmpty()) {
         return defaultServer;
       }
       // non-synchronized read
@@ -502,6 +499,13 @@ public final class Ebean {
     serverMgr.getDefaultServer().endTransaction();
   }
 
+  /**
+   * Mark the current transaction as rollback only.
+   */
+  public static void setRollbackOnly() {
+    serverMgr.getDefaultServer().currentTransaction().setRollbackOnly();
+  }
+
   /**
    * Return a map of the differences between two objects of the same type.
    * <p>
@@ -642,58 +646,6 @@ public final class Ebean {
     return serverMgr.getDefaultServer().saveAll(beans);
   }
 
-  /**
-   * Delete the associations (from the intersection table) of a ManyToMany given
-   * the owner bean and the propertyName of the ManyToMany collection.
-   * <p>
-   * Typically these deletions occur automatically when persisting a ManyToMany
-   * collection and this provides a way to invoke those deletions directly.
-   * </p>
-   * 
-   * @return the number of associations deleted (from the intersection table).
-   */
-  public static int deleteManyToManyAssociations(Object ownerBean, String propertyName) {
-    return serverMgr.getDefaultServer().deleteManyToManyAssociations(ownerBean, propertyName);
-  }
-
-  /**
-   * Save the associations of a ManyToMany given the owner bean and the
-   * propertyName of the ManyToMany collection.
-   * <p>
-   * Typically the saving of these associations (inserting into the intersection
-   * table) occurs automatically when persisting a ManyToMany. This provides a
-   * way to invoke those insertions directly.
-   * </p>
-   * <p>
-   * You can use this when the collection is new and in this case all the
-   * entries in the collection are treated as additions are result in inserts
-   * into the intersection table.
-   * </p>
-   */
-  public static void saveManyToManyAssociations(Object ownerBean, String propertyName) {
-    serverMgr.getDefaultServer().saveManyToManyAssociations(ownerBean, propertyName);
-  }
-
-  /**
-   * Save the associated collection or bean given the property name.
-   * <p>
-   * This is similar to performing a save cascade on a specific property
-   * manually/programmatically.
-   * </p>
-   * <p>
-   * Note that you can turn on/off cascading for a transaction via
-   * {@link Transaction#setPersistCascade(boolean)}
-   * </p>
-   * 
-   * @param ownerBean
-   *          the bean instance holding the property we want to save
-   * @param propertyName
-   *          the property we want to save
-   */
-  public static void saveAssociation(Object ownerBean, String propertyName) {
-    serverMgr.getDefaultServer().saveAssociation(ownerBean, propertyName);
-  }
-
   /**
    * Delete the bean.
    * <p>
@@ -704,6 +656,10 @@ public final class Ebean {
    * you automatically.
    * </p>
    * <p>
+   * If the bean is configured with <code>@SoftDelete</code> then this will perform a soft
+   * delete rather than a hard/permanent delete.
+   * </p>
+   * <p>
    * If the Bean does not have a version property (or loaded version property) and
    * the bean does not exist then this returns false indicating that nothing was
    * deleted. Note that, if JDBC batch mode is used then this always returns true.
@@ -713,6 +669,13 @@ public final class Ebean {
     return serverMgr.getDefaultServer().delete(bean);
   }
 
+  /**
+   * Delete the bean in permanent fashion (will not use soft delete).
+   */
+  public static boolean deletePermanent(Object bean) throws OptimisticLockException {
+    return serverMgr.getDefaultServer().deletePermanent(bean);
+  }
+
   /**
    * Delete the bean given its type and id.
    */
@@ -720,11 +683,25 @@ public final class Ebean {
     return serverMgr.getDefaultServer().delete(beanType, id);
   }
 
+  /**
+   * Delete permanent the bean given its type and id.
+   */
+  public static int deletePermanent(Class<?> beanType, Object id) {
+    return serverMgr.getDefaultServer().deletePermanent(beanType, id);
+  }
+
   /**
    * Delete several beans given their type and id values.
    */
-  public static void deleteAll(Class<?> beanType, Collection<?> ids) {
-    serverMgr.getDefaultServer().deleteAll(beanType, ids);
+  public static int deleteAll(Class<?> beanType, Collection<?> ids) {
+    return serverMgr.getDefaultServer().deleteAll(beanType, ids);
+  }
+
+  /**
+   * Delete permanent several beans given their type and id values.
+   */
+  public static int deleteAllPermanent(Class<?> beanType, Collection<?> ids) {
+    return serverMgr.getDefaultServer().deleteAllPermanent(beanType, ids);
   }
 
   /**
@@ -734,6 +711,13 @@ public final class Ebean {
     return serverMgr.getDefaultServer().deleteAll(beans);
   }
 
+  /**
+   * Delete permanent all the beans in the Collection (will not use soft delete).
+   */
+  public static int deleteAllPermanent(Collection<?> beans) throws OptimisticLockException {
+    return serverMgr.getDefaultServer().deleteAllPermanent(beans);
+  }
+
   /**
    * Refresh the values of a bean.
    * <p>
@@ -903,19 +887,6 @@ public final class Ebean {
     return serverMgr.getDefaultServer().createSqlQuery(sql);
   }
 
-  /**
-   * Create a named sql query.
-   * <p>
-   * The query statement will be defined in a deployment orm xml file.
-   * </p>
-   * 
-   * @param namedQuery
-   *          the name of the query
-   */
-  public static SqlQuery createNamedSqlQuery(String namedQuery) {
-    return serverMgr.getDefaultServer().createNamedSqlQuery(namedQuery);
-  }
-
   /**
    * Create a sql update for executing native dml statements.
    * <p>
@@ -925,10 +896,6 @@ public final class Ebean {
    * <p>
    * See {@link SqlUpdate} for example usage.
    * </p>
-   * <p>
-   * Where possible it would be expected practice to put the statement in a orm
-   * xml file (named update) and use {@link #createNamedSqlUpdate(String)} .
-   * </p>
    */
   public static SqlUpdate createSqlUpdate(String sql) {
     return serverMgr.getDefaultServer().createSqlUpdate(sql);
@@ -943,144 +910,6 @@ public final class Ebean {
     return serverMgr.getDefaultServer().createCallableSql(sql);
   }
 
-  /**
-   * Create a named sql update.
-   * <p>
-   * The statement (an Insert Update or Delete statement) will be defined in a
-   * deployment orm xml file.
-   * </p>
-   * 
-   * <pre>{@code
-   *
-   *   // Use a namedQuery
-   *   UpdateSql update = Ebean.createNamedSqlUpdate("update.topic.count");
-   * 
-   *   update.setParameter("count", 1);
-   *   update.setParameter("topicId", 50);
-   * 
-   *   int modifiedCount = update.execute();
-   *
-   * }</pre>
-   */
-  public static SqlUpdate createNamedSqlUpdate(String namedQuery) {
-    return serverMgr.getDefaultServer().createNamedSqlUpdate(namedQuery);
-  }
-
-  /**
-   * Return a named Query that will have defined fetch paths, predicates etc.
-   * <p>
-   * The query is created from a statement that will be defined in a deployment
-   * orm xml file or NamedQuery annotations. The query will typically already
-   * define fetch paths, predicates, order by clauses etc so often you will just
-   * need to bind required parameters and then execute the query.
-   * </p>
-   * 
-   * <pre>{@code
-   *
-   *   // example
-   *   Query<Order> query = Ebean.createNamedQuery(Order.class, "new.for.customer");
-   *   query.setParameter("customerId", 23);
-   *   List<Order> newOrders = query.findList();
-   *
-   * }</pre>
-   * 
-   * @param beanType
-   *          the class of entity to be fetched
-   * @param namedQuery
-   *          the name of the query
-   */
-  public static <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
-
-    return serverMgr.getDefaultServer().createNamedQuery(beanType, namedQuery);
-  }
-
-  /**
-   * Create a query using the query language.
-   * <p>
-   * Note that you are allowed to add additional clauses using where() as well
-   * as use fetch() and setOrderBy() after the query has been created.
-   * </p>
-   * <p>
-   * Note that this method signature used to map to named queries and that has
-   * moved to {@link #createNamedQuery(Class, String)}.
-   * </p>
-   * 
-   * <pre>{@code
-   * 
-   *   String q = "find order fetch details where status = :st";
-   * 
-   *   List<Order> newOrders = Ebean.>findOrder.class, q)
-   *     .setParameter("st", Order.Status.NEW)
-   *     .findList();
-   *
-   * }</pre>
-   * 
-   * @param query
-   *          the object query
-   */
-  public static <T> Query<T> createQuery(Class<T> beanType, String query) {
-    return serverMgr.getDefaultServer().createQuery(beanType, query);
-  }
-
-  /**
-   * Create a named orm update. The update statement is specified via the
-   * NamedUpdate annotation.
-   * <p>
-   * The orm update differs from the SqlUpdate in that it uses the bean name and
-   * bean property names rather than table and column names.
-   * </p>
-   * <p>
-   * Note that named update statements can be specified in raw sql (with column
-   * and table names) or using bean name and bean property names. This can be
-   * specified with the isSql flag.
-   * </p>
-   * <p>
-   * Example named updates:
-   * </p>
-   * 
-   * <pre>{@code
-   *   package app.data;
-   * 
-   *   import ...
-   * 
-   *   @NamedUpdates(value = {
-   *    @NamedUpdate( name = "setTitle",
-   * 	    isSql = false,
-   * 		  notifyCache = false,
-   * 		  update = "update topic set title = :title, postCount = :postCount where id = :id"),
-   * 	  @NamedUpdate( name = "setPostCount",
-   * 		  notifyCache = false,
-   * 		  update = "update f_topic set post_count = :postCount where id = :id"),
-   * 	  @NamedUpdate( name = "incrementPostCount",
-   * 		  notifyCache = false,
-   * 		  isSql = false,
-   * 		  update = "update Topic set postCount = postCount + 1 where id = :id") })
-   *   @Entity
-   *   @Table(name = "f_topic")
-   *   public class Topic { ...
-   *
-   * }</pre>
-   * 
-   * <p>
-   * Example using a named update:
-   * </p>
-   * 
-   * <pre>{@code
-   *
-   *   Update<Topic> update = Ebean.createNamedUpdate(Topic.class, "setPostCount");
-   *   update.setParameter("postCount", 10);
-   *   update.setParameter("id", 3);
-   * 
-   *   int rows = update.execute();
-   *   System.out.println("rows updated: " + rows);
-   *
-   * }</pre>
-   */
-  public static <T> Update<T> createNamedUpdate(Class<T> beanType, String namedUpdate) {
-
-    return serverMgr.getDefaultServer().createNamedUpdate(beanType, namedUpdate);
-  }
-
   /**
    * Create a orm update where you will supply the insert/update or delete
    * statement (rather than using a named one that is already defined using the
@@ -1123,6 +952,21 @@ public final class Ebean {
     return serverMgr.getDefaultServer().createCsvReader(beanType);
   }
 
+  /**
+   * Create a named query.
+   * <p>
+   * For RawSql the named query is expected to be in ebean.xml.
+   * </p>
+   *
+   * @param beanType   The type of entity bean
+   * @param namedQuery The name of the query
+   * @param <T>        The type of entity bean
+   * @return The query
+   */
+  public static <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) {
+    return serverMgr.getDefaultServer().createNamedQuery(beanType, namedQuery);
+  }
+
   /**
    * Create a query for a type of entity bean.
    * <p>
@@ -1138,39 +982,7 @@ public final class Ebean {
    * {@link Query#findSet()} etc will execute against the same EbeanServer from
    * which is was created.
    * </p>
-   * 
-   * <pre>{@code
-   *   // Find order 2 additionally fetching the customer, details and details.product
-   *   // name.
-   * 
-   *   Order order = Ebean.find(Order.class)
-   *     .fetch("customer")
-   *     .fetch("details")
-   *     .fetch("detail.product", "name")
-   *     .setId(2)
-   *     .findUnique();
-   * 
-   *   // Find order 2 additionally fetching the customer, details and details.product
-   *   // name.
-   *   // Note: same query as above but using the query language
-   *   // Note: using a named query would be preferred practice
-   * 
-   *   String oql = "find order fetch customer fetch details fetch details.product (name) where id = :orderId ";
-   * 
-   *   Query<Order> query = Ebean.find(Order.class);
-   *   query.setQuery(oql);
-   *   query.setParameter("orderId", 2);
-   * 
-   *   Order order = query.findUnique();
-   * 
-   *   // Using a named query
-   *   Query<Order> query = Ebean.find(Order.class, "with.details");
-   *   query.setParameter("orderId", 2);
-   * 
-   *   Order order = query.findUnique();
-   * 
-   * }</pre>
-   * 
+   *
    * @param beanType
    *          the class of entity to be fetched
    * @return A ORM Query object for this beanType
@@ -1180,6 +992,47 @@ public final class Ebean {
     return serverMgr.getDefaultServer().createQuery(beanType);
   }
 
+  /**
+   * Parse the Ebean query language statement returning the query which can then
+   * be modified (add expressions, change order by clause, change maxRows, change
+   * fetch and select paths etc).
+   *
+   * <h3>Example</h3>
+   *
+   * <pre>{@code
+   *
+   *
+   *   // Find order additionally fetching the customer, details and details.product name.
+   *
+   *   String eql = "fetch customer fetch details fetch details.product (name) where id = :orderId ";
+   *
+   *   Query<Order> query = Ebean.createQuery(Order.class, eql);
+   *   query.setParameter("orderId", 2);
+   *
+   *   Order order = query.findUnique();
+   *
+   *   // This is the same as:
+   *
+   *   Order order = Ebean.find(Order.class)
+   *     .fetch("customer")
+   *     .fetch("details")
+   *     .fetch("detail.product", "name")
+   *     .setId(2)
+   *     .findUnique();
+   *
+   * }</pre>
+   *
+   * @param beanType The type of bean to fetch
+   * @param eql The Ebean query
+   * @param <T> The type of the entity bean
+   *
+   * @return The query with expressions defined as per the parsed query statement
+   */
+  public static <T> Query<T> createQuery(Class<T> beanType, String eql) {
+
+    return serverMgr.getDefaultServer().createQuery(beanType, eql);
+  }
+
   /**
    * Create a query for a type of entity bean.
    * <p>
@@ -1197,6 +1050,28 @@ public final class Ebean {
     return serverMgr.getDefaultServer().find(beanType);
   }
 
+  /**
+   * Create an Update query to perform a bulk update.
+   * <p>
+   * <pre>{@code
+   *
+   *  int rows = Ebean.update(Customer.class)
+   *      .set("status", Customer.Status.ACTIVE)
+   *      .set("updtime", new Timestamp(System.currentTimeMillis()))
+   *      .where()
+   *        .gt("id", 1000)
+   *        .update();
+   *
+   * }</pre>
+   *
+   * @param beanType The type of entity bean to update
+   * @param <T>      The type of entity bean
+   * @return The update query to use
+   */
+  public static <T> UpdateQuery<T> update(Class<T> beanType) {
+    return serverMgr.getDefaultServer().update(beanType);
+  }
+
   /**
    * Create a filter for sorting and filtering lists of entities locally without
    * going back to the database.
@@ -1466,29 +1341,6 @@ public final class Ebean {
     return serverMgr.getDefaultServer().getBackgroundExecutor();
   }
 
-  /**
-   * Run the cache warming queries on all bean types that have one defined for
-   * the default/primary EbeanServer.
-   * <p>
-   * A cache warming query can be defined via {@link CacheStrategy}.
-   * </p>
-   */
-  public static void runCacheWarming() {
-    serverMgr.getDefaultServer().runCacheWarming();
-  }
-
-  /**
-   * Run the cache warming query for a specific bean type for the
-   * default/primary EbeanServer.
-   * <p>
-   * A cache warming query can be defined via {@link CacheStrategy}.
-   * </p>
-   */
-  public static void runCacheWarming(Class<?> beanType) {
-
-    serverMgr.getDefaultServer().runCacheWarming(beanType);
-  }
-
   /**
    * Return the JsonContext for reading/writing JSON.
    */

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

@@ -133,7 +133,7 @@ public class EbeanServerFactory {
   /**
    * Create the container instance using the configuration.
    */
-  private static SpiContainer createContainer(ContainerConfig containerConfig) {
+  protected static SpiContainer createContainer(ContainerConfig containerConfig) {
 
     String implClassName = System.getProperty("ebean.container", DEFAULT_CONTAINER);
 

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

@@ -209,6 +209,20 @@ public class Expr {
     return Ebean.getExpressionFactory().icontains(propertyName, value);
   }
 
+  /**
+   * For collection properties that are empty (have not existing elements).
+   */
+  public static Expression isEmpty(String propertyName) {
+    return Ebean.getExpressionFactory().isEmpty(propertyName);
+  }
+
+  /**
+   * For collection properties that are not empty (have existing elements).
+   */
+  public static Expression isNotEmpty(String propertyName) {
+    return Ebean.getExpressionFactory().isNotEmpty(propertyName);
+  }
+
   /**
    * In - property has a value in the array of values.
    */

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

@@ -1,10 +1,8 @@
 package com.avaje.ebean;
 
-import java.io.Serializable;
-
 /**
  * An expression that is part of a WHERE or HAVING clause.
  */
-public interface Expression extends Serializable {
+public interface Expression {
 
 }

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

@@ -1,5 +1,11 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.search.Match;
+import com.avaje.ebean.search.MultiMatch;
+import com.avaje.ebean.search.TextCommonTerms;
+import com.avaje.ebean.search.TextQueryString;
+import com.avaje.ebean.search.TextSimple;
+
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -81,6 +87,38 @@ public interface ExpressionFactory {
    */
   Expression jsonBetween(String propertyName, String path, Object lowerValue, Object upperValue);
 
+  /**
+   * Array contains all the given values.
+   * <p>
+   * Array support is effectively limited to Postgres at this time.
+   * </p>
+   */
+  Expression arrayContains(String propertyName, Object... values);
+
+  /**
+   * Array does not contain the given values.
+   * <p>
+   * Array support is effectively limited to Postgres at this time.
+   * </p>
+   */
+  Expression arrayNotContains(String propertyName, Object... values);
+
+  /**
+   * Array is empty - for the given array property.
+   * <p>
+   * Array support is effectively limited to Postgres at this time.
+   * </p>
+   */
+  Expression arrayIsEmpty(String propertyName);
+
+  /**
+   * Array is not empty - for the given array property.
+   * <p>
+   * Array support is effectively limited to Postgres at this time.
+   * </p>
+   */
+  Expression arrayIsNotEmpty(String propertyName);
+
   /**
    * Equal To - property equal to the given value.
    */
@@ -97,6 +135,11 @@ public interface ExpressionFactory {
    */
   Expression ieq(String propertyName, String value);
 
+  /**
+   * Case Insensitive Equal To that allows for named parameter use.
+   */
+  Expression ieqObject(String propertyName, Object value);
+
   /**
    * Between - property between the two given values.
    */
@@ -154,6 +197,11 @@ public interface ExpressionFactory {
    */
   ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType);
 
+  /**
+   * Like with support for named parameters.
+   */
+  Expression like(String propertyName, Object value, boolean caseInsensitive, LikeType likeType);
+
   /**
    * Like - property like value where the value contains the SQL wild card
    * characters % (percentage) and _ (underscore).
@@ -240,11 +288,26 @@ public interface ExpressionFactory {
    */
   Expression notExists(Query<?> subQuery);
 
+  /**
+   * Is empty expression for collection properties.
+   */
+  Expression isEmpty(String propertyName);
+
+  /**
+   * Is not empty expression for collection properties.
+   */
+  Expression isNotEmpty(String propertyName);
+
   /**
    * Id Equal to - ID property is equal to the value.
    */
   Expression idEq(Object value);
 
+  /**
+   * Id IN a list of Id values.
+   */
+  Expression idIn(Object... idValues);
+
   /**
    * Id IN a list of Id values.
    */
@@ -285,6 +348,31 @@ public interface ExpressionFactory {
    */
   Expression raw(String raw);
 
+  /**
+   * Create a Text Match expression (currently doc store/Elastic only).
+   */
+  Expression textMatch(String propertyName, String search, Match options);
+
+  /**
+   * Create a Text Multi match expression (currently doc store/Elastic only).
+   */
+  Expression textMultiMatch(String query, MultiMatch options);
+
+  /**
+   * Create a text simple query expression (currently doc store/Elastic only).
+   */
+  Expression textSimple(String search, TextSimple options);
+
+  /**
+   * Create a text query string expression (currently doc store/Elastic only).
+   */
+  Expression textQueryString(String search, TextQueryString options);
+
+  /**
+   * Create a text common terms expression (currently doc store/Elastic only).
+   */
+  Expression textCommonTerms(String search, TextCommonTerms options);
+
   /**
    * And - join two expressions with a logical and.
    */
@@ -319,4 +407,13 @@ public interface ExpressionFactory {
    * Return a list of expressions that will be joined by OR's.
    */
   <T> Junction<T> disjunction(Query<T> query, ExpressionList<T> parent);
+
+  /**
+   * Return a Text query junction for MUST, SHOULD or MUST NOT.
+   * <p>
+   * This is doc store Elastic only.
+   * </p>
+   */
+  <T> Junction<T> junction(Junction.Type type, Query<T> query, ExpressionList<T> parent);
+
 }

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

@@ -1,9 +1,13 @@
 package com.avaje.ebean;
 
-import com.avaje.ebean.text.PathProperties;
+import com.avaje.ebean.search.Match;
+import com.avaje.ebean.search.MultiMatch;
+import com.avaje.ebean.search.TextCommonTerms;
+import com.avaje.ebean.search.TextQueryString;
+import com.avaje.ebean.search.TextSimple;
 import org.jetbrains.annotations.Nullable;
 
-import java.io.Serializable;
+import javax.persistence.NonUniqueResultException;
 import java.sql.Timestamp;
 import java.util.Collection;
 import java.util.List;
@@ -27,10 +31,10 @@ import java.util.Set;
  * more methods than you would initially expect (the ones duplicated from
  * Query).
  * </p>
- * 
+ *
  * @see Query#where()
  */
-public interface ExpressionList<T> extends Serializable {
+public interface ExpressionList<T> {
 
   /**
    * Return the query that owns this expression list.
@@ -79,14 +83,14 @@ public interface ExpressionList<T> extends Serializable {
 
   /**
    * Add an orderBy clause to the query.
-   * 
+   *
    * @see Query#orderBy(String)
    */
   Query<T> orderBy(String orderBy);
 
   /**
    * Add an orderBy clause to the query.
-   * 
+   *
    * @see Query#orderBy(String)
    */
   Query<T> setOrderBy(String orderBy);
@@ -94,7 +98,7 @@ public interface ExpressionList<T> extends Serializable {
   /**
    * Apply the path properties to the query replacing the select and fetch clauses.
    */
-  Query<T> apply(PathProperties pathProperties);
+  Query<T> apply(FetchPath fetchPath);
 
   /**
    * Perform an 'As of' query using history tables to return the object graph
@@ -107,6 +111,16 @@ public interface ExpressionList<T> extends Serializable {
    */
   Query<T> asOf(Timestamp asOf);
 
+  /**
+   * Execute the query against the draft set of tables.
+   */
+  Query<T> asDraft();
+
+  /**
+   * Execute the query including soft deleted rows.
+   */
+  Query<T> setIncludeSoftDeletes();
+
   /**
    * Execute as a delete query deleting the 'root level' beans that match the predicates
    * in the query.
@@ -115,13 +129,21 @@ public interface ExpressionList<T> extends Serializable {
    * optimal depending on the database platform.
    * </p>
    *
-   * @return the number of beans/rows that were deleted.
+   * @return the number of rows that were deleted.
    */
   int delete();
 
+  /**
+   * Execute as a update query.
+   *
+   * @return the number of rows that were updated.
+   * @see UpdateQuery
+   */
+  int update();
+
   /**
    * Execute the query iterating over the results.
-   * 
+   *
    * @see Query#findIterate()
    */
   QueryIterator<T> findIterate();
@@ -143,17 +165,17 @@ public interface ExpressionList<T> extends Serializable {
 
   /**
    * Execute the query returning a list.
-   * 
+   *
    * @see Query#findList()
    */
   List<T> findList();
 
   /**
    * Execute the query returning the list of Id's.
-   * 
+   *
    * @see Query#findIds()
    */
-  List<Object> findIds();
+  <A> List<A> findIds();
 
   /**
    * Return the count of entities this query should return.
@@ -161,30 +183,71 @@ public interface ExpressionList<T> extends Serializable {
    * This is the number of 'top level' or 'root level' entities.
    * </p>
    */
+  int findCount();
+
+  /**
+   * Deprecated in favor of findCount().
+   *
+   * @deprecated
+   */
   int findRowCount();
 
   /**
    * Execute the query returning a set.
-   * 
+   *
    * @see Query#findSet()
    */
   Set<T> findSet();
 
   /**
    * Execute the query returning a map.
-   * 
+   *
    * @see Query#findMap()
    */
-  Map<?, T> findMap();
+  <K> Map<K, T> findMap();
 
   /**
-   * Return a typed map specifying the key property and type.
+   * Execute the query returning a list of values for a single property.
+   *
+   * <h3>Example 1:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    Ebean.find(Customer.class)
+   *      .select("name")
+   *      .orderBy().asc("name")
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   *
+   * <h3>Example 2:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    Ebean.find(Customer.class)
+   *      .setDistinct(true)
+   *      .select("name")
+   *      .where().eq("status", Customer.Status.NEW)
+   *      .orderBy().asc("name")
+   *      .setMaxRows(100)
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   *
+   * @return the list of values for the selected property
    */
-  <K> Map<K, T> findMap(String keyProperty, Class<K> keyType);
+  <A> List<A> findSingleAttributeList();
 
   /**
-   * Execute the query returning a single bean.
-   * 
+   * Execute the query returning a single bean or null (if no matching
+   * bean is found).
+   * <p>
+   * If more than 1 row is found for this query then a NonUniqueResultException is
+   * thrown.
+   * </p>
+   *
+   * @throws NonUniqueResultException if more than one result was found
+   *
    * @see Query#findUnique()
    */
   @Nullable
@@ -197,9 +260,16 @@ public interface ExpressionList<T> extends Serializable {
    * execution status (isDone etc) and get the value (with or without a
    * timeout).
    * </p>
-   * 
+   *
    * @return a Future object for the row count query
    */
+  FutureRowCount<T> findFutureCount();
+
+  /**
+   * Deprecated in favor of findFutureCount().
+   *
+   * @deprecated
+   */
   FutureRowCount<T> findFutureRowCount();
 
   /**
@@ -209,7 +279,7 @@ public interface ExpressionList<T> extends Serializable {
    * execution status (isDone etc) and get the value (with or without a
    * timeout).
    * </p>
-   * 
+   *
    * @return a Future object for the list of Id's
    */
   FutureIds<T> findFutureIds();
@@ -221,31 +291,42 @@ public interface ExpressionList<T> extends Serializable {
    * execution status (isDone etc) and get the value (with or without a
    * timeout).
    * </p>
-   * 
+   *
    * @return a Future object for the list result of the query
    */
   FutureList<T> findFutureList();
 
   /**
-   * Return a PagedList for this query.
+   * Return a PagedList for this query using firstRow and maxRows.
    * <p>
-   * The benefit of using this over just using the normal {@link Query#setFirstRow(int)} and
-   * {@link Query#setMaxRows(int)} is that it additionally wraps an optional call to
-   * {@link Query#findFutureRowCount()} to determine total row count, total page count etc.
+   * The benefit of using this over findList() is that it provides functionality to get the
+   * total row count etc.
    * </p>
    * <p>
-   * Internally this works using {@link Query#setFirstRow(int)} and {@link Query#setMaxRows(int)} on
-   * the query. This translates into SQL that uses limit offset, rownum or row_number
-   * function to limit the result set.
+   * If maxRows is not set on the query prior to calling findPagedList() then a
+   * PersistenceException is thrown.
    * </p>
-   * 
-   * @param pageIndex
-   *          The zero based index of the page.
-   * @param pageSize
-   *          The number of beans to return per page.
+   *
+   * <pre>{@code
+   *
+   *  PagedList<Order> pagedList = Ebean.find(Order.class)
+   *       .setFirstRow(50)
+   *       .setMaxRows(20)
+   *       .findPagedList();
+   *
+   *       // fetch the total row count in the background
+   *       pagedList.loadRowCount();
+   *
+   *       List<Order> orders = pagedList.getList();
+   *       int totalRowCount = pagedList.getTotalRowCount();
+   *
+   * }</pre>
+   *
    * @return The PagedList
+   *
+   * @see Query#findPagedList()
    */
-  PagedList<T> findPagedList(int pageIndex, int pageSize);
+  PagedList<T> findPagedList();
 
   /**
    * Return versions of a @History entity bean.
@@ -273,7 +354,7 @@ public interface ExpressionList<T> extends Serializable {
   /**
    * Specify specific properties to fetch on the main/root bean (aka partial
    * object).
-   * 
+   *
    * @see Query#select(String)
    */
   Query<T> select(String properties);
@@ -298,28 +379,28 @@ public interface ExpressionList<T> extends Serializable {
 
   /**
    * Set the first row to fetch.
-   * 
+   *
    * @see Query#setFirstRow(int)
    */
   Query<T> setFirstRow(int firstRow);
 
   /**
    * Set the maximum number of rows to fetch.
-   * 
+   *
    * @see Query#setMaxRows(int)
    */
   Query<T> setMaxRows(int maxRows);
 
   /**
    * Set the name of the property which values become the key of a map.
-   * 
+   *
    * @see Query#setMapKey(String)
    */
   Query<T> setMapKey(String mapKey);
 
   /**
    * Set to true to use the query for executing this query.
-   * 
+   *
    * @see Query#setUseCache(boolean)
    */
   Query<T> setUseCache(boolean useCache);
@@ -331,6 +412,32 @@ public interface ExpressionList<T> extends Serializable {
    */
   Query<T> setUseQueryCache(boolean useCache);
 
+  /**
+   * Set to true if this query should execute against the doc store.
+   * <p>
+   * When setting this you may also consider disabling lazy loading.
+   * </p>
+   */
+  Query<T> setUseDocStore(boolean useDocsStore);
+
+  /**
+   * Set true if you want to disable lazy loading.
+   * <p>
+   * That is, once the object graph is returned further lazy loading is disabled.
+   * </p>
+   */
+  Query<T> setDisableLazyLoading(boolean disableLazyLoading);
+
+  /**
+   * Disable read auditing for this query.
+   * <p>
+   * This is intended to be used when the query is not a user initiated query and instead
+   * part of the internal processing in an application to load a cache or document store etc.
+   * In these cases we don't want the query to be part of read auditing.
+   * </p>
+   */
+  Query<T> setDisableReadAuditing();
+
   /**
    * Add expressions to the having clause.
    * <p>
@@ -554,7 +661,7 @@ public interface ExpressionList<T> extends Serializable {
    * To get control over the options you can create an ExampleExpression and set
    * those options such as case insensitive etc.
    * </p>
-   * 
+   *
    * <pre>{@code
    *
    * // create an example bean and set the properties
@@ -562,26 +669,26 @@ public interface ExpressionList<T> extends Serializable {
    * Customer example = new Customer();
    * example.setName("Rob%");
    * example.setNotes("%something%");
-   * 
+   *
    * List&lt;Customer&gt; list = Ebean.find(Customer.class).where()
    *     // pass the bean into the where() clause
    *     .exampleLike(example)
    *     // you can add other expressions to the same query
    *     .gt("id", 2).findList();
-   * 
+   *
    * }</pre>
-   * 
+   *
    * Similarly you can create an ExampleExpression
-   * 
+   *
    * <pre>{@code
    *
    * Customer example = new Customer();
    * example.setName("Rob%");
    * example.setNotes("%something%");
-   * 
+   *
    * // create a ExampleExpression with more control
    * ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO).includeZeros();
-   * 
+   *
    * List<Customer> list = Ebean.find(Customer.class).where().add(qbe).findList();
    *
    * }</pre>
@@ -669,16 +776,31 @@ public interface ExpressionList<T> extends Serializable {
    */
   ExpressionList<T> notIn(String propertyName, Query<?> subQuery);
 
+  /**
+   * Is empty expression for collection properties.
+   */
+  ExpressionList<T> isEmpty(String propertyName);
+
+  /**
+   * Is not empty expression for collection properties.
+   */
+  ExpressionList<T> isNotEmpty(String propertyName);
+
   /**
    * Exists expression
    */
   ExpressionList<T> exists(Query<?> subQuery);
-  
+
   /**
    * Not exists expression
    */
   ExpressionList<T> notExists(Query<?> subQuery);
 
+  /**
+   * Id IN a list of id values.
+   */
+  ExpressionList<T> idIn(Object... idValues);
+
   /**
    * Id IN a list of id values.
    */
@@ -695,12 +817,41 @@ public interface ExpressionList<T> extends Serializable {
    * Expression where all the property names in the map are equal to the
    * corresponding value.
    * </p>
-   * 
+   *
    * @param propertyMap
    *          a map keyed by property names.
    */
   ExpressionList<T> allEq(Map<String, Object> propertyMap);
 
+  /**
+   * Array property contains entries with the given values.
+   */
+  ExpressionList<T> arrayContains(String propertyName, Object... values);
+
+  /**
+   * Array does not contain the given values.
+   * <p>
+   * Array support is effectively limited to Postgres at this time.
+   * </p>
+   */
+  ExpressionList<T> arrayNotContains(String propertyName, Object... values);
+
+  /**
+   * Array is empty - for the given array property.
+   * <p>
+   * Array support is effectively limited to Postgres at this time.
+   * </p>
+   */
+  ExpressionList<T> arrayIsEmpty(String propertyName);
+
+  /**
+   * Array is not empty - for the given array property.
+   * <p>
+   * Array support is effectively limited to Postgres at this time.
+   * </p>
+   */
+  ExpressionList<T> arrayIsNotEmpty(String propertyName);
+
   /**
    * Add raw expression with a single parameter.
    * <p>
@@ -735,7 +886,7 @@ public interface ExpressionList<T> extends Serializable {
    * qualified) will still be translated to their physical name.
    * </p>
    */
-  ExpressionList<T> raw(String raw, Object[] values);
+  ExpressionList<T> raw(String raw, Object... values);
 
   /**
    * Add raw expression with no parameters.
@@ -753,6 +904,47 @@ public interface ExpressionList<T> extends Serializable {
    */
   ExpressionList<T> raw(String raw);
 
+  /**
+   * Add a match expression.
+   *
+   * @param propertyName The property name for the match
+   * @param search The search value
+   */
+  ExpressionList<T> match(String propertyName, String search);
+
+  /**
+   * Add a match expression with options.
+   *
+   * @param propertyName The property name for the match
+   * @param search The search value
+   */
+  ExpressionList<T> match(String propertyName, String search, Match options);
+
+  /**
+   * Add a multi-match expression.
+   */
+  ExpressionList<T>  multiMatch(String search, String... properties);
+
+  /**
+   * Add a multi-match expression using options.
+   */
+  ExpressionList<T> multiMatch(String search, MultiMatch options);
+
+  /**
+   * Add a simple query string expression.
+   */
+  ExpressionList<T> textSimple(String search, TextSimple options);
+
+  /**
+   * Add a query string expression.
+   */
+  ExpressionList<T> textQueryString(String search, TextQueryString options);
+
+  /**
+   * Add common terms expression.
+   */
+  ExpressionList<T> textCommonTerms(String search, TextCommonTerms options);
+
   /**
    * And - join two expressions with a logical and.
    */
@@ -769,22 +961,185 @@ public interface ExpressionList<T> extends Serializable {
   ExpressionList<T> not(Expression exp);
 
   /**
-   * Return a list of expressions that will be joined by AND's.
+   * Start a list of expressions that will be joined by AND's
+   * returning the expression list the expressions are added to.
+   * <p>
+   * This is exactly the same as conjunction();
+   * </p>
+   * <p>
+   * Use endAnd() or endJunction() to end the AND junction.
+   * </p>
+   * <p>
+   * Note that a where() clause defaults to an AND junction so
+   * typically you only explicitly need to use the and() junction
+   * when it is nested inside an or() or not() junction.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  // Example: Nested and()
+   *
+   *  Ebean.find(Customer.class)
+   *    .where()
+   *    .or()
+   *      .and() // nested and
+   *        .startsWith("name", "r")
+   *        .eq("anniversary", onAfter)
+   *        .endAnd()
+   *      .and()
+   *        .eq("status", Customer.Status.ACTIVE)
+   *        .gt("id", 0)
+   *        .endAnd()
+   *      .orderBy().asc("name")
+   *      .findList();
+   * }</pre>
+   */
+  Junction<T> and();
+
+  /**
+   * Return a list of expressions that will be joined by OR's.
+   * This is exactly the same as disjunction();
+   *
+   * <p>
+   *   Use endOr() or endJunction() to end the OR junction.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *  // Example: Use or() to join
+   *  // two nested and() expressions
+   *
+   *  Ebean.find(Customer.class)
+   *    .where()
+   *    .or()
+   *      .and()
+   *        .startsWith("name", "r")
+   *        .eq("anniversary", onAfter)
+   *        .endAnd()
+   *      .and()
+   *        .eq("status", Customer.Status.ACTIVE)
+   *        .gt("id", 0)
+   *        .endAnd()
+   *      .orderBy().asc("name")
+   *      .findList();
+   *
+   * }</pre>
+   */
+  Junction<T> or();
+
+  /**
+   * Return a list of expressions that will be wrapped by NOT.
+   * <p>
+   *   Use endNot() or endJunction() to end expressions being added to the
+   *   NOT expression list.
+   * </p>
+   *
+   * <pre>@{code
+   *
+   *    .where()
+   *      .not()
+   *        .gt("id", 1)
+   *        .eq("anniversary", onAfter)
+   *        .endNot()
+   *
+   * }</pre>
+   *
+   * <pre>@{code
+   *
+   * // Example: nested not()
+   *
+   * Ebean.find(Customer.class)
+   *   .where()
+   *     .eq("status", Customer.Status.ACTIVE)
+   *     .not()
+   *       .gt("id", 1)
+   *       .eq("anniversary", onAfter)
+   *       .endNot()
+   *     .orderBy()
+   *       .asc("name")
+   *     .findList();
+   *
+   * }</pre>
+   */
+  Junction<T> not();
+
+  /**
+   * Start (and return) a list of expressions that will be joined by AND's.
+   * <p>
+   * This is the same as and().
+   * </p>
    */
   Junction<T> conjunction();
 
   /**
-   * Return a list of expressions that will be joined by OR's.
+   * Start (and return) a list of expressions that will be joined by OR's.
+   * <p>
+   * This is the same as or().
+   * </p>
    */
   Junction<T> disjunction();
 
   /**
-   * End a Conjunction or Disjunction returning the parent expression list.
+   * Start a list of expressions that will be joined by MUST.
    * <p>
-   * Alternatively you can always use where() to return the top level expression
-   * list.
+   * This automatically makes the query a useDocStore(true) query that
+   * will execute against the document store (ElasticSearch etc).
+   * </p>
+   * <p>
+   * This is logically similar to and().
+   * </p>
+   */
+  Junction<T> must();
+
+  /**
+   * Start a list of expressions that will be joined by SHOULD.
+   * <p>
+   * This automatically makes the query a useDocStore(true) query that
+   * will execute against the document store (ElasticSearch etc).
+   * </p>
+   * <p>
+   * This is logically similar to or().
+   * </p>
+   */
+  Junction<T> should();
+
+  /**
+   * Start a list of expressions that will be joined by MUST NOT.
+   * <p>
+   * This automatically makes the query a useDocStore(true) query that
+   * will execute against the document store (ElasticSearch etc).
+   * </p>
+   * <p>
+   * This is logically similar to not().
+   * </p>
+   */
+  Junction<T> mustNot();
+
+  /**
+   * End a junction returning the parent expression list.
+   * <p>
+   * Ends a and(), or(), not(), must(), mustNot() or should() junction
+   * such that you get the parent expression.
+   * </p>
+   * <p>
+   * Alternatively you can always use where() to return the top level expression list.
    * </p>
    */
   ExpressionList<T> endJunction();
 
+  /**
+   * End a AND junction - synonym for endJunction().
+   */
+  ExpressionList<T> endAnd();
+
+  /**
+   * End a AND junction - synonym for endJunction().
+   */
+  ExpressionList<T> endOr();
+
+  /**
+   * End a NOT junction - synonym for endJunction().
+   */
+  ExpressionList<T> endNot();
+
 }

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

@@ -29,8 +29,7 @@ import java.io.Serializable;
  * // Find Orders join details using a single SQL query
  * }</pre>
  * <p>
- * Example: Using a "query join" instead of a "fetch join" we instead use 2 SQL
- * queries
+ * Example: Using a "query join" instead of a "fetch join" we instead use 2 SQL queries
  * </p>
  * 
  * <pre>{@code
@@ -117,7 +116,7 @@ import java.io.Serializable;
  * <pre>{@code
  * List<Order> list = Ebean.find(Order.class)
  *   .fetch("customer","name", new FetchConfig().lazy(5))
- *   .fetch("customer.contacts",&quotcontactName, phone, email&quot)
+ *   .fetch("customer.contacts","contactName, phone, email")
  *   .fetch("customer.shippingAddress")
  *   .where().eq("status",Order.Status.NEW)
  *   .findList();
@@ -125,12 +124,7 @@ import java.io.Serializable;
  * // query 1) find order where status = Order.Status.NEW
  * //  
  * // .. if lazy loading of customers is invoked 
- * // .. use a batch size of 5 to load the customers 
- *  
- *       find  customer (name) 
- *       fetch customer.contacts (contactName, phone, email) 
- *       fetch customer.shippingAddress (*) 
- *       where id in (?,?,?,?,?)
+ * // .. use a batch size of 5 to load the customers
  * 
  * }</pre>
  * 
@@ -249,4 +243,22 @@ public class FetchConfig implements Serializable {
     return queryAll;
   }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    FetchConfig that = (FetchConfig) o;
+    if (lazyBatchSize != that.lazyBatchSize) return false;
+    if (queryBatchSize != that.queryBatchSize) return false;
+    return queryAll == that.queryAll;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = lazyBatchSize;
+    result = 92821 * result + queryBatchSize;
+    result = 92821 * result + (queryAll ? 1 : 0);
+    return result;
+  }
 }

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

@@ -0,0 +1,26 @@
+package com.avaje.ebean;
+
+import java.util.Set;
+
+/**
+ * Provides paths and properties for an object graph that can be used to control what parts of the object graph
+ * is fetching (select and fetch clauses) and also can be used to control JSON marshalling (what parts of the object
+ * graph are included in the JSON).
+ */
+public interface FetchPath {
+
+  /**
+   * Return true if the path is included in this FetchPath.
+   */
+  boolean hasPath(String path);
+
+  /**
+   * Return the properties at the given path.
+   */
+  Set<String> getProperties(String path);
+
+  /**
+   * Apply the fetch path to the query.
+   */
+  <T> void apply(Query<T> query);
+}

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

@@ -9,8 +9,6 @@ import java.util.concurrent.Future;
  * It extends the java.util.concurrent.Future with the ability to get the Id's
  * while the query is still executing in the background.
  * </p>
- * 
- * @author rbygrave
  */
 public interface FutureIds<T> extends Future<List<Object>> {
 
@@ -19,16 +17,4 @@ public interface FutureIds<T> extends Future<List<Object>> {
    */
   Query<T> getQuery();
 
-  /**
-   * Return the list of Id's which could be partially populated.
-   * <p>
-   * That is the query getting the id's could still be running and adding id's
-   * to this list.
-   * </p>
-   * <p>
-   * To get the list of Id's ensuring the query has finished use the
-   * {@link Future#get()} method instead of this one.
-   * </p>
-   */
-  List<Object> getPartialIds();
 }

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

@@ -9,70 +9,139 @@ package com.avaje.ebean;
  * <p>
  * Note: where() always takes you to the top level WHERE expression list.
  * </p>
- * 
- * <pre class="code">
+ *
+ * <pre>{@code
  * Query q =
  *     Ebean.find(Person.class)
- *         .where().disjunction()
- *         .like(&quot;name&quot;, &quot;Rob%&quot;)
- *         .eq(&quot;status&quot;, Status.NEW)
- * 
- *         // where() returns us to the top level expression list
- *         .where().gt(&quot;id&quot;, 10);
- * 
+ *       .where()
+ *         .or()
+ *           .like("name", "Rob%")
+ *           .eq("status", Status.NEW)
+ *
+ *       // where() returns us to the top level expression list
+ *       .where().gt("id", 10);
+ *
  * // read as...
  * // where ( ((name like Rob%) or (status = NEW)) AND (id &gt; 10) )
- * </pre>
- * 
+ * }</pre>
+ *
  * <p>
  * Note: endJunction() takes you to the parent expression list
  * </p>
- * 
- * <pre class="code">
+ *
+ * <pre>{@code
  * Query q =
  *     Ebean.find(Person.class)
- *         .where().disjunction()
- *         .like(&quot;name&quot;, &quot;Rob%&quot;)
- *         .eq(&quot;status&quot;, Status.NEW)
- *         .endJunction()
- * 
- *         // endJunction().. takes us to the 'parent' expression list
- *         // which in this case is the top level (same as where())
- * 
- *         .gt(&quot;id&quot;, 10);
- * 
+ *       .where()
+ *         .or()
+ *           .like("name", "Rob%")
+ *           .eq("status", Status.NEW)
+ *           .endJunction()
+ *
+ *           // endJunction().. takes us to the 'parent' expression list
+ *           // which in this case is the top level (same as where())
+ *
+ *         .gt("id", 10);
+ *
  * // read as...
- * // where ( ((name like Rob%) or (status = NEW)) AND (id &gt; 10) )
- * </pre>
- * 
+ * // where ( ((name like Rob%) or (status = NEW)) AND (id > 10) )
+ * }</pre>
+ *
  * <p>
  * Example of a nested disjunction.
  * </p>
- * 
- * <pre class="code">
- * Query&lt;Customer&gt; q = 
+ *
+ * <pre>{@code
+ * Query<Customer> q =
  *  Ebean.find(Customer.class)
  *      .where()
- *          .disjunction()
- *              .conjunction()
- *                  .startsWith(&quot;name&quot;, &quot;r&quot;)
- *                  .eq(&quot;anniversary&quot;, onAfter)
- *                  .endJunction()
- *              .conjunction()
- *                  .eq(&quot;status&quot;, Customer.Status.ACTIVE)
- *                  .gt(&quot;id&quot;, 0)
- *                  .endJunction()
- *      .order().asc(&quot;name&quot;);
- * 
+ *        .or()
+ *          .and()
+ *            .startsWith("name", "r")
+ *            .eq("anniversary", onAfter)
+ *            .endAnd()
+ *          .and()
+ *            .eq("status", Customer.Status.ACTIVE)
+ *            .gt("id", 0)
+ *            .endAnd()
+ *      .order().asc("name");
+ *
  * q.findList();
  * String s = q.getGeneratedSql();
- * 
+ *
  *  // this produces an expression like:
- *  
- *  ( name like ? and c.anniversary = ? ) or (c.status = ?  and c.id &gt; ? )
- * 
- * </pre>
+ *  ( name like ? and c.anniversary = ? ) or (c.status = ?  and c.id > ? )
+ *
+ * }</pre>
  */
 public interface Junction<T> extends Expression, ExpressionList<T> {
 
+  /**
+   * The type of Junction used in full text expressions.
+   */
+  enum Type {
+
+    /**
+     * AND group.
+     */
+    AND(" and ", "", false),
+
+    /**
+     * OR group.
+     */
+    OR(" or ", "", false),
+
+    /**
+     * NOT group.
+     */
+    NOT(" and ", "not ", false),
+
+    /**
+     * Text search AND group.
+     */
+    MUST("must", "", true),
+
+    /**
+     * Text search NOT group.
+     */
+    MUST_NOT("must_not", "", true),
+
+    /**
+     * Text search OR group.
+     */
+    SHOULD("should", "", true);
+
+    private String prefix;
+    private String literal;
+    private boolean text;
+
+    Type(String literal, String prefix, boolean text) {
+      this.literal = literal;
+      this.prefix = prefix;
+      this.text = text;
+    }
+
+    /**
+     * Return the literal value for this type.
+     */
+    public String literal() {
+      return literal;
+    }
+
+    /**
+     * Return the prefix value for this type.
+     */
+    public String prefix() {
+      return prefix;
+    }
+
+    /**
+     * Return true if this is a text type.
+     */
+    public boolean isText() {
+      return text;
+    }
+
+  }
+
 }

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

@@ -1,7 +1,6 @@
 package com.avaje.ebean;
 
 import com.avaje.ebean.bean.EntityBean;
-import com.avaje.ebean.text.PathProperties;
 import com.avaje.ebean.util.ClassUtil;
 import org.jetbrains.annotations.Nullable;
 
@@ -271,6 +270,19 @@ public abstract class Model {
     return db().delete(this);
   }
 
+  /**
+   * Delete a bean permanently without soft delete.
+   * <p>
+   * This is used when the bean contains a <code>@SoftDelete</code> property and we
+   * want to perform a hard/permanent delete.
+   * </p>
+   *
+   * @see EbeanServer#deletePermanent(Object)
+   */
+  public boolean deletePermanent() {
+    return db().deletePermanent(this);
+  }
+
   /**
    * Perform an update using this entity against the specified server.
    */
@@ -350,29 +362,6 @@ public abstract class Model {
       super(serverName, type);
     }
 
-    /**
-     * Please migrate to use {@link Find} or constructor <code>Finder(Class)</code> that
-     * does not have the idType parameter.
-     * <p/>
-     * Create with the type of the ID property and entity bean and specific server name.
-     *
-     * @deprecated
-     */
-    public Finder(Class<I> idType, Class<T> type) {
-      super(null, type);
-    }
-
-    /**
-     * Please migrate to use the constructor <code>Finder(String, Class)</code> that
-     * does not have the idType parameter.
-     * <p/>
-     * Create with the type of the ID property and entity bean and specific server name.
-     *
-     * @deprecated
-     */
-    public Finder(String serverName, Class<I> idType, Class<T> type) {
-      super(serverName, type);
-    }
   }
 
   /**
@@ -506,7 +495,7 @@ public abstract class Model {
     /**
      * Return typically a different EbeanServer to the default.
      * <p>
-     * This is equivilent to {@link Ebean#getServer(String)}
+     * This is equivalent to {@link Ebean#getServer(String)}
      * 
      * @param server
      *          The name of the EbeanServer. If this is null then the default EbeanServer is
@@ -588,10 +577,10 @@ public abstract class Model {
     /**
      * Creates a query applying the path properties to set the select and fetch clauses.
      * <p>
-     * Equivalent to {@link Query#apply(com.avaje.ebean.text.PathProperties)}
+     * Equivalent to {@link Query#apply(FetchPath)}
      */
-    public Query<T> apply(PathProperties pathProperties) {
-      return db().find(type).apply(pathProperties);
+    public Query<T> apply(FetchPath fetchPath) {
+      return db().find(type).apply(fetchPath);
     }
 
     /**
@@ -609,7 +598,7 @@ public abstract class Model {
      * <p>
      * Equivalent to {@link Query#findIds()}
      */
-    public List<Object> findIds() {
+    public <A> List<A> findIds() {
       return query().findIds();
     }
 
@@ -671,46 +660,43 @@ public abstract class Model {
      * <p>
      * Equivalent to {@link Query#findMap()}
      */
-    public Map<?, T> findMap() {
+    public <K> Map<K, T> findMap() {
       return query().findMap();
     }
 
-    /**
-     * Executes the query and returns the results as a map of the objects specifying the map key
-     * property.
-     * <p>
-     * Equivalent to {@link Query#findMap(String, Class)}
-     */
-    public <K> Map<K, T> findMap(String keyProperty, Class<K> keyType) {
-      return query().findMap(keyProperty, keyType);
-    }
-
-    /**
-     * Return a PagedList of all entities of the given type (use where() to specify predicates as
-     * needed).
-     * <p>
-     * Equivalent to {@link Query#findPagedList(int, int)}
-     */
-    public PagedList<T> findPagedList(int pageIndex, int pageSize) {
-      return query().findPagedList(pageIndex, pageSize);
-    }
-
     /**
      * Executes a find row count query in a background thread.
      * <p>
-     * Equivalent to {@link Query#findFutureRowCount()}
+     * Equivalent to {@link Query#findFutureCount()}
+     */
+    public FutureRowCount<T> findFutureCount() {
+      return query().findFutureCount();
+    }
+
+    /**
+     * Deprecated in favor of findFutureCount().
+     * <p>
+     * Equivalent to {@link Query#findFutureCount()}
      */
     public FutureRowCount<T> findFutureRowCount() {
-      return query().findFutureRowCount();
+      return query().findFutureCount();
     }
 
     /**
      * Returns the total number of entities for this type. *
      * <p>
-     * Equivalent to {@link Query#findRowCount()}
+     * Equivalent to {@link Query#findCount()}
+     */
+    public int findCount() {
+      return query().findCount();
+    }
+
+    /**
+     * Deprecated in favor of findCount().
+     * @deprecated
      */
     public int findRowCount() {
-      return query().findRowCount();
+      return query().findCount();
     }
 
     /**
@@ -854,15 +840,6 @@ public abstract class Model {
       return query().setId(id);
     }
 
-    /**
-     * Create and return a new query using the OQL.
-     * <p>
-     * Equivalent to {@link EbeanServer#createQuery(Class, String)}
-     */
-    public Query<T> setQuery(String oql) {
-      return db().createQuery(type, oql);
-    }
-
     /**
      * Create and return a new query based on the <code>RawSql</code>.
      * <p>

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

@@ -148,6 +148,13 @@ public final class OrderBy<T> implements Serializable {
     return copy;
   }
 
+  /**
+   * Add to the order by by parsing a raw expression.
+   */
+  public void add(String rawExpression) {
+    parse(rawExpression);
+  }
+
   /**
    * Add a property to the order by.
    */
@@ -206,8 +213,9 @@ public final class OrderBy<T> implements Serializable {
    * order by clause and replace.
    * </p>
    */
-  public void clear() {
+  public OrderBy<T> clear() {
     list.clear();
+    return this;
   }
 
   /**
@@ -221,24 +229,39 @@ public final class OrderBy<T> implements Serializable {
 
     private boolean ascending;
 
+    private String nulls;
+
+    private String highLow;
+
     public Property(String property, boolean ascending) {
       this.property = property;
       this.ascending = ascending;
     }
 
+    public Property(String property, boolean ascending, String nulls, String highLow) {
+      this.property = property;
+      this.ascending = ascending;
+      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);
+      return new Property(property.substring(path.length() + 1), ascending, nulls, highLow);
     }
 
+    @Override
     public int hashCode() {
       int hc = property.hashCode();
       hc = hc * 31 + (ascending ? 0 : 1);
+      hc = hc * 31 + (nulls == null ? 0 : nulls.hashCode());
+      hc = hc * 31 + (highLow == null ? 0 : highLow.hashCode());
       return hc;
     }
-    
+
+    @Override
     public boolean equals(Object obj) {
       if (obj == this) {
         return true;
@@ -246,10 +269,11 @@ public final class OrderBy<T> implements Serializable {
       if (!(obj instanceof Property)) {
         return false;
       }
-      
       Property e = (Property) obj;
-      return e.ascending == ascending 
-          && e.property.equals(property);
+      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;
     }
 
     public String toString() {
@@ -257,10 +281,20 @@ public final class OrderBy<T> implements Serializable {
     }
 
     public String toStringFormat() {
-      if (ascending) {
-        return property;
+      if (nulls == null) {
+        if (ascending) {
+          return property;
+        } else {
+          return property + " desc";
+        }
       } else {
-        return property + " desc";
+        StringBuilder sb = new StringBuilder();
+        sb.append(property);
+        if (!ascending) {
+          sb.append(" ").append("desc");
+        }
+        sb.append(" ").append(nulls).append(" ").append(highLow);
+        return  sb.toString();
       }
     }
 
@@ -282,7 +316,7 @@ public final class OrderBy<T> implements Serializable {
      * Return a copy of this property.
      */
     public Property copy() {
-      return new Property(property, ascending);
+      return new Property(property, ascending, nulls, highLow);
     }
 
     /**
@@ -323,7 +357,6 @@ public final class OrderBy<T> implements Serializable {
 
     String[] chunks = orderByClause.split(",");
     for (int i = 0; i < chunks.length; i++) {
-
       String[] pairs = chunks[i].split(" ");
       Property p = parseProperty(pairs);
       if (p != null) {
@@ -353,8 +386,12 @@ public final class OrderBy<T> implements Serializable {
       boolean asc = isAscending(wordList.get(1));
       return new Property(wordList.get(0), asc);
     }
-    String m = "Expecting a max of 2 words in [" + Arrays.toString(pairs)
-        + "] but got " + wordList.size();
+    if (wordList.size() == 4) {
+      // nulls high or nulls low as 3rd and 4th
+      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);
   }
 
@@ -371,6 +408,6 @@ public final class OrderBy<T> implements Serializable {
   }
 
   private boolean isEmptyString(String s) {
-    return s == null || s.length() == 0;
+    return s == null || s.isEmpty();
   }
 }

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

@@ -17,6 +17,33 @@ import java.util.concurrent.Future;
  * limit the result set.
  * </p>
  *
+ *
+ * <h4>Example: typical use including total row count</h4>
+ * <pre>{@code
+ *
+ *     // We want to find the first 50 new orders
+ *     //  ... so we don't really need setFirstRow(0)
+ *
+ *     PagedList<Order> pagedList
+ *       = ebeanServer.find(Order.class)
+ *       .where().eq("status", Order.Status.NEW)
+ *       .order().asc("id")
+ *       .setFirstRow(0)
+ *       .setMaxRows(50)
+ *       .findPagedList();
+ *
+ *     // Optional: initiate the loading of the total
+ *     // row count in a background thread
+ *     pagedList.loadRowCount();
+ *
+ *     // fetch and return the list in the foreground thread
+ *     List<Order> orders = pagedList.getList();
+ *
+ *     // get the total row count (from the future)
+ *     int totalRowCount = pagedList.getTotalRowCount();
+ *
+ * }</pre>
+ *
  * <h4>Example: typical use including total row count</h4>
  * <pre>{@code
  *
@@ -57,7 +84,7 @@ import java.util.concurrent.Future;
  * @param <T>
  *          the entity bean type
  * 
- * @see Query#findPagedList(int, int)
+ * @see Query#findPagedList()
  */
 public interface PagedList<T> {
 
@@ -83,6 +110,13 @@ public interface PagedList<T> {
    * wrapped in the unchecked PersistenceException (which might be preferrable).
    * </p>
    */
+  void loadCount();
+
+  /**
+   * Deprecated in favor of loadCount().
+   *
+   * @deprecated
+   */
   void loadRowCount();
 
   /**
@@ -111,6 +145,13 @@ public interface PagedList<T> {
    *
    * }</pre>
    */
+  Future<Integer> getFutureCount();
+
+  /**
+   * Deprecated in favor of getFutureCount().
+   *
+   * @deprecated
+   */
   Future<Integer> getFutureRowCount();
 
   /**
@@ -143,6 +184,13 @@ public interface PagedList<T> {
    *
    * }</pre>
    */
+  int getTotalCount();
+
+  /**
+   * Deprecated in favor of getTotalCount().
+   *
+   * @deprecated
+   */
   int getTotalRowCount();
 
   /**
@@ -155,12 +203,7 @@ public interface PagedList<T> {
   int getTotalPageCount();
 
   /**
-   * Return the index position of this page. Zero based.
-   */
-  int getPageIndex();
-
-  /**
-   * Return the page size used for this query.
+   * Return the page size used for this query. This is the same value as maxRows used by the query.
    */
   int getPageSize();
 

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

@@ -0,0 +1,18 @@
+package com.avaje.ebean;
+
+import javax.persistence.PersistenceException;
+
+/**
+ * Captures and wraps IOException's occurring during ElasticSearch processing etc.
+ */
+public class PersistenceIOException extends PersistenceException {
+
+  public PersistenceIOException(String msg, Exception cause) {
+    super(msg, cause);
+  }
+
+  public PersistenceIOException(Exception cause) {
+    super(cause);
+  }
+
+}

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

@@ -58,15 +58,18 @@ class PrimaryServer {
    */
   private static String determineDefaultServerName() {
 
-    String defaultServerName = System.getProperty("datasource.default");
+    String defaultServerName = System.getenv("EBEAN_DB");
     if (isEmpty(defaultServerName)) {
-      defaultServerName = System.getProperty("ebean.default.datasource");
-    }
-    if (isEmpty(defaultServerName)) {
-      defaultServerName = globalProperties.getProperty("datasource.default");
-    }
-    if (isEmpty(defaultServerName)) {
-      defaultServerName = globalProperties.getProperty("ebean.default.datasource");
+      defaultServerName = System.getProperty("datasource.default");
+      if (isEmpty(defaultServerName)) {
+        defaultServerName = System.getProperty("ebean.default.datasource");
+        if (isEmpty(defaultServerName)) {
+          defaultServerName = globalProperties.getProperty("datasource.default");
+          if (isEmpty(defaultServerName)) {
+            defaultServerName = globalProperties.getProperty("ebean.default.datasource");
+          }
+        }
+      }
     }
     return defaultServerName;
   }
@@ -75,6 +78,6 @@ class PrimaryServer {
    * Return true if the string is null or empty.
    */
   private static boolean isEmpty(String value) {
-    return value == null || value.trim().length() == 0;
+    return value == null || value.trim().isEmpty();
   }
 }

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

@@ -10,28 +10,35 @@ import java.util.Iterator;
  * findList(), findSet() etc where all the beans are held in the List or Set
  * etc).
  * </p>
+ * <p>
+ * Note that findIterate (and findEach and findEachWhile) uses a "per graph"
+ * persistence context scope and adjusts jdbc fetch buffer size for large
+ * queries. As such it is better to use findList for small queries.
+ * </p>
+ * <p>
+ * Remember that with {@link QueryIterator} you must call {@link QueryIterator#close()}
+ * when you have finished iterating the results (typically in a finally block).
+ * </p>
+ *
+ * <pre>{@code
  * 
- * <pre class="code">
- * 
- * Query&lt;Customer&gt; query = server.find(Customer.class)
- *     .fetch(&quot;contacts&quot;, new FetchConfig().query(2))
- *     .where().gt(&quot;id&quot;, 0)
- *     .orderBy(&quot;id&quot;)
+ *  Query<Customer> query = server.find(Customer.class)
+ *     .where().gt("id", 0)
+ *     .orderBy("id")
  *     .setMaxRows(2);
- * 
- * QueryIterator&lt;Customer&gt; it = query.findIterate();
- * try {
- *   while (it.hasNext()) {
- *     Customer customer = it.next();
- *     // do something with customer...
- *   }
- * } finally {
- *   // close the associated resources
- *   it.close();
- * }
- * </pre>
- * 
- * @author rbygrave
+ *
+ *  QueryIterator<Customer> it = query.findIterate();
+ *  try {
+ *    while (it.hasNext()) {
+ *      Customer customer = it.next();
+ *      // do something with customer ...
+ *    }
+ *  } finally {
+ *    // close the underlying resources
+ *    it.close();
+ *  }
+ *
+ * }</pre>
  * 
  * @param <T>
  *          the type of entity bean in the iteration

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

@@ -206,6 +206,14 @@ public final class RawSql implements Serializable {
     return sql;
   }
 
+  /**
+   * Return the key;
+   */
+  public Key getKey() {
+    boolean parsed = sql != null && sql.parsed;
+    String unParsedSql = (sql == null) ? "" : sql.unparsedSql;
+    return new Key(parsed, unParsedSql, columnMapping);
+  }
   
   /**
    * Return the resultSet if this is a ResultSet based RawSql.
@@ -221,16 +229,6 @@ public final class RawSql implements Serializable {
     return columnMapping;
   }
 
-  /**
-   * Return the hash for this query.
-   */
-  public int queryHash() {
-    if (resultSet != null) {
-      return 31 * columnMapping.queryHash();
-    }
-    return 31 * sql.queryHash() + columnMapping.queryHash();
-  }
-
   /**
    * Represents the sql part of the query. For parsed RawSql the sql is broken
    * up so that Ebean can insert extra WHERE and HAVING expressions into the
@@ -260,13 +258,10 @@ public final class RawSql implements Serializable {
 
     private final boolean distinct;
 
-    private final int queryHashCode;
-
     /**
      * Construct for unparsed SQL.
      */
     protected Sql(String unparsedSql) {
-      this.queryHashCode = unparsedSql.hashCode();
       this.parsed = false;
       this.unparsedSql = unparsedSql;
       this.preFrom = null;
@@ -282,12 +277,11 @@ public final class RawSql implements Serializable {
     /**
      * Construct for parsed SQL.
      */
-    protected Sql(int queryHashCode, String preFrom, String preWhere, boolean andWhereExpr,
+    protected Sql(String unparsedSql, String preFrom, String preWhere, boolean andWhereExpr,
         String preHaving, boolean andHavingExpr, String orderByPrefix, String orderBy, boolean distinct) {
 
-      this.queryHashCode = queryHashCode;
+      this.unparsedSql = unparsedSql;
       this.parsed = true;
-      this.unparsedSql = null;
       this.preFrom = preFrom;
       this.preHaving = preHaving;
       this.preWhere = preWhere;
@@ -298,13 +292,6 @@ public final class RawSql implements Serializable {
       this.distinct = distinct;
     }
 
-    /**
-     * Return a hash for this query.
-     */
-    public int queryHash() {
-      return queryHashCode;
-    }
-
     public String toString() {
       if (!parsed) {
         return "unparsed[" + unparsedSql + "]";
@@ -406,13 +393,10 @@ public final class RawSql implements Serializable {
 
     private final boolean immutable;
 
-    private final int queryHashCode;
-
     /**
      * Construct from parsed sql where the columns have been identified.
      */
     protected ColumnMapping(List<Column> columns) {
-      this.queryHashCode = 0;
       this.immutable = false;
       this.parsed = true;
       this.propertyMap = null;
@@ -420,7 +404,7 @@ public final class RawSql implements Serializable {
       this.dbColumnMap = new LinkedHashMap<String, Column>();
       for (int i = 0; i < columns.size(); i++) {
         Column c = columns.get(i);
-        dbColumnMap.put(c.getDbColumn(), c);
+        dbColumnMap.put(c.getDbColumnKey(), c);
       }
     }
 
@@ -428,7 +412,6 @@ public final class RawSql implements Serializable {
      * Construct for unparsed sql.
      */
     protected ColumnMapping() {
-      this.queryHashCode = 0;
       this.immutable = false;
       this.parsed = false;
       this.propertyMap = null;
@@ -443,17 +426,13 @@ public final class RawSql implements Serializable {
       this.immutable = false;
       this.parsed = false;
       this.propertyMap = null;
-      //this.propertyColumnMap = null;
       this.dbColumnMap = new LinkedHashMap<String, Column>();
-      
-      int hc = 31;
+
       int pos = 0;
       for (String prop : propertyNames) {
-        hc = 31 * hc + prop.hashCode();
         dbColumnMap.put(prop, new Column(pos++, prop, null, prop));
       }
       propertyColumnMap = dbColumnMap;
-      this.queryHashCode = hc;
     }
 
     /**
@@ -464,20 +443,28 @@ public final class RawSql implements Serializable {
       this.parsed = parsed;
       this.dbColumnMap = dbColumnMap;
 
-      int hc = ColumnMapping.class.getName().hashCode();
-
       HashMap<String, Column> pcMap = new HashMap<String, Column>();
       HashMap<String, String> pMap = new HashMap<String, String>();
 
       for (Column c : dbColumnMap.values()) {
         pMap.put(c.getPropertyName(), c.getDbColumn());
         pcMap.put(c.getPropertyName(), c);
-        hc = 31 * hc + ((c.getPropertyName() == null) ? 0 : c.getPropertyName().hashCode());
-        hc = 31 * hc + ((c.getDbColumn() == null) ? 0 : c.getDbColumn().hashCode());
       }
       this.propertyMap = Collections.unmodifiableMap(pMap);
       this.propertyColumnMap = Collections.unmodifiableMap(pcMap);
-      this.queryHashCode = hc;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      ColumnMapping that = (ColumnMapping) o;
+      return dbColumnMap.equals(that.dbColumnMap);
+    }
+
+    @Override
+    public int hashCode() {
+      return dbColumnMap.hashCode();
     }
 
     /**
@@ -513,24 +500,13 @@ public final class RawSql implements Serializable {
       } else {
         Column column = dbColumnMap.get(dbColumn);
         if (column == null) {
-          String msg = "DB Column [" + dbColumn + "] not found in mapping. Expecting one of ["
-              + dbColumnMap.keySet() + "]";
+          String msg = "DB Column [" + dbColumn + "] not found in mapping. Expecting one of [" + dbColumnMap.keySet() + "]";
           throw new IllegalArgumentException(msg);
         }
         column.setPropertyName(propertyName);
       }
     }
 
-    /**
-     * Return the query hash for this column mapping.
-     */
-    public int queryHash() {
-      if (queryHashCode == 0) {
-        throw new RuntimeException("Bug: queryHashCode == 0");
-      }
-      return queryHashCode;
-    }
-
     /**
      * Returns true if the Columns where supplied by parsing the sql select
      * clause.
@@ -585,6 +561,9 @@ public final class RawSql implements Serializable {
      * <p>
      * For example modify all mappings with table alias "c" to have the path prefix "customer".
      * </p>
+     * <p>
+     * For the "Root type" you don't need to specify a tableAliasMapping.
+     * </p>
      */
     public void tableAliasMapping(String tableAlias, String path) {
 
@@ -627,9 +606,9 @@ public final class RawSql implements Serializable {
         }
       }
 
-      private static String derivePropertyName(String dbAlias, String dbColumn) {
+      protected static String derivePropertyName(String dbAlias, String dbColumn) {
         if (dbAlias != null) {
-          return dbAlias;
+          return CamelCaseHelper.toCamelFromUnderscore(dbAlias);
         }
         int dotPos = dbColumn.indexOf('.');
         if (dotPos > -1) {
@@ -645,6 +624,27 @@ public final class RawSql implements Serializable {
         }
       }
 
+      @Override
+      public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Column that = (Column) o;
+        if (indexPos != that.indexPos) return false;
+        if (!dbColumn.equals(that.dbColumn)) return false;
+        if (dbAlias != null ? !dbAlias.equals(that.dbAlias) : that.dbAlias != null) return false;
+        return propertyName != null ? propertyName.equals(that.propertyName) : that.propertyName == null;
+      }
+
+      @Override
+      public int hashCode() {
+        int result = indexPos;
+        result = 31 * result + dbColumn.hashCode();
+        result = 31 * result + (dbAlias != null ? dbAlias.hashCode() : 0);
+        result = 31 * result + (propertyName != null ? propertyName.hashCode() : 0);
+        return result;
+      }
+
       public String toString() {
         return dbColumn + "->" + propertyName;
       }
@@ -656,6 +656,14 @@ public final class RawSql implements Serializable {
         return indexPos;
       }
 
+      /**
+       * Return the DB column alias if specified otherwise DB column.
+       * This is used as the key for mapping a column to a logical property.
+       */
+      public String getDbColumnKey() {
+        return (dbAlias != null) ? dbAlias : dbColumn;
+      }
+
       /**
        * Return the DB column name including table alias (if it has one).
        */
@@ -663,13 +671,6 @@ public final class RawSql implements Serializable {
         return dbColumn;
       }
 
-      /**
-       * Return the DB column alias (if it has one).
-       */
-      public String getDbAlias() {
-        return dbAlias;
-      }
-
       /**
        * Return the bean property this column is mapped to.
        */
@@ -696,4 +697,39 @@ public final class RawSql implements Serializable {
       }
     }
   }
+
+  /**
+   * A key for the RawSql object using for the query plan.
+   */
+  public static final class Key {
+
+    private final boolean parsed;
+    private final ColumnMapping columnMapping;
+    private final String unParsedSql;
+
+    Key(boolean parsed, String unParsedSql, ColumnMapping columnMapping) {
+      this.parsed = parsed;
+      this.unParsedSql = unParsedSql;
+      this.columnMapping = columnMapping;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+
+      Key that = (Key) o;
+      return parsed == that.parsed
+          && columnMapping.equals(that.columnMapping)
+          && unParsedSql.equals(that.unParsedSql);
+    }
+
+    @Override
+    public int hashCode() {
+      int result = (parsed ? 1 : 0);
+      result = 31 * result + columnMapping.hashCode();
+      result = 31 * result + unParsedSql.hashCode();
+      return result;
+    }
+  }
 }

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

@@ -106,6 +106,9 @@ public class RawSqlBuilder {
    * <p>
    * For example modify all mappings with table alias "c" to have the path prefix "customer".
    * </p>
+   * <p>
+   * For the "Root type" you don't need to specify a tableAliasMapping.
+   * </p>
    */
   public RawSqlBuilder tableAliasMapping(String tableAlias, String path) {
     columnMapping.tableAliasMapping(tableAlias, path);

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

@@ -1,47 +0,0 @@
-package com.avaje.ebean;
-
-import java.util.List;
-import java.util.concurrent.Future;
-
-/**
- * The SqlFutureList represents the result of a background SQL query execution.
- * 
- * <p>
- * It extends the java.util.concurrent.Future.
- * </p>
- * 
- * <pre class="code">
- *  // create a query
- * String sql = ... ;
- * SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
- * 
- *  // execute the query in a background thread
- * SqlFutureList sqlFuture = sqlQuery.findFutureList();
- * 
- *  // do something else ... we will sleep
- * Thread.sleep(3000);
- * System.out.println("end of sleep");
- * 
- * if (!futureList.isDone()){
- * 	// we can cancel the query execution
- * 	futureList.cancel(true);
- * }
- * 
- * System.out.println("and... done:"+futureList.isDone());
- * 
- * if (!futureList.isCancelled()){
- * 	// wait for the query to finish and return the list
- * 	List&lt;SqlRow&gt; list = futureList.get();
- * 	System.out.println("list:"+list);
- * }
- * 
- * </pre>
- * 
- * @author rob
- * 
- */
-public interface SqlFutureList extends Future<List<SqlRow>> {
-
-  SqlQuery getQuery();
-
-}

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

@@ -2,8 +2,6 @@ package com.avaje.ebean;
 
 import java.io.Serializable;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 /**
  * Query object for performing native SQL queries that return SqlRow's.
@@ -21,45 +19,48 @@ import java.util.Set;
  * conversion support added.
  * </p>
  * 
- * <pre class="code">
- * // its typically a good idea to use a named query
- * // and put the sql in the orm.xml instead of in your code
+ * <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
  * 
- * String sql = &quot;select id, name from customer where name like :name and status_code = :status&quot;;
+ *   String sql = "select id, name from customer where name like :name and status_code = :status";
  * 
- * SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
- * sqlQuery.setParameter(&quot;name&quot;, &quot;Acme%&quot;);
- * sqlQuery.setParameter(&quot;status&quot;, &quot;ACTIVE&quot;);
+ *   SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
+ *   sqlQuery.setParameter("name", "Acme%");
+ *   sqlQuery.setParameter("status", "ACTIVE");
  * 
- * // execute the query returning a List of MapBean objects
- * List&lt;SqlRow&gt; list = sqlQuery.findList();
- * </pre>
+ *   // execute the query returning a List of MapBean objects
+ *   List<SqlRow> list = sqlQuery.findList();
+ *
+ * }</pre>
  * 
  */
 public interface SqlQuery extends Serializable {
 
-  /**
-   * Cancel the query if support by the underlying database and driver.
-   * <p>
-   * This must be called from a different thread to the one executing the query.
-   * </p>
-   */
-  void cancel();
-
   /**
    * Execute the query returning a list.
    */
   List<SqlRow> findList();
 
   /**
-   * Execute the query returning a set.
+   * Execute the SqlQuery iterating a row at a time.
+   * <p>
+   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
+   * </p>
    */
-  Set<SqlRow> findSet();
+  void findEach(QueryEachConsumer<SqlRow> consumer);
 
   /**
-   * Execute the query returning a map.
+   * Execute the SqlQuery iterating a row at a time with the ability to stop consuming part way through.
+   * <p>
+   * Returning false after processing a row stops the iteration through the query results.
+   * </p>
+   * <p>
+   * This streaming type query is useful for large query execution as only 1 row needs to be held in memory.
+   * </p>
    */
-  Map<?, SqlRow> findMap();
+  void findEachWhile(QueryEachWhileConsumer<SqlRow> consumer);
 
   /**
    * Execute the query returning a single row or null.
@@ -70,19 +71,6 @@ public interface SqlQuery extends Serializable {
    */
   SqlRow findUnique();
 
-  /**
-   * Execute find list SQL query in a background thread.
-   * <p>
-   * This returns a Future object which can be used to cancel, check the
-   * execution status (isDone etc) and get the value (with or without a
-   * timeout).
-   * </p>
-   * 
-   * @return a Future object for the list result of the query
-   * @deprecated
-   */
-  SqlFutureList findFutureList();
-
   /**
    * The same as bind for named parameters.
    */
@@ -93,19 +81,6 @@ public interface SqlQuery extends Serializable {
    */
   SqlQuery setParameter(int position, Object value);
 
-  /**
-   * Set a listener to process the query on a row by row basis.
-   * <p>
-   * It this case the rows are not loaded into the persistence context and
-   * instead can be processed by the query listener.
-   * </p>
-   * <p>
-   * Use this when you want to process a large query and do not want to hold the
-   * entire query result in memory.
-   * </p>
-   */
-  SqlQuery setListener(SqlQueryListener queryListener);
-
   /**
    * Set the index of the first row of the results to return.
    */
@@ -116,16 +91,6 @@ public interface SqlQuery extends Serializable {
    */
   SqlQuery setMaxRows(int maxRows);
 
-  /**
-   * Set the index after which fetching continues in a background thread.
-   */
-  SqlQuery setBackgroundFetchAfter(int backgroundFetchAfter);
-
-  /**
-   * Set the column to use to determine the keys for a Map.
-   */
-  SqlQuery setMapKey(String mapKey);
-
   /**
    * Set a timeout on this query.
    * <p>

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

@@ -1,33 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Provides a mechanism for processing a SqlQuery one SqlRow at a time.
- * <p>
- * This is useful when the query will return a large number of results and you
- * want to process the beans one at a time rather than have all of the beans in
- * memory at once.
- * </p>
- * 
- * <pre class="code">
- * SqlQueryListener listener = ...;
- *    
- * SqlQuery query  = Ebean.createSqlQuery(&quot;my.large.query&quot;);
- *    
- * // set the listener that will process each row one at a time
- * query.setListener(listener);
- *    
- * // execute the query. Note that the returned
- * // list will be empty ... so don't bother assigning it...
- * query.findList();
- * </pre>
- */
-public interface SqlQueryListener {
-
-  /**
-   * Process the bean that has just been read.
-   * <p>
-   * Note this bean will not be added to the List Set or Map.
-   * </p>
-   */
-  void process(SqlRow bean);
-}

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

@@ -26,7 +26,7 @@ package com.avaje.ebean;
  * 
  * int modifiedCount = Ebean.execute(update);
  * 
- * String msg = "There where " + modifiedCount + "rows updated"
+ * String msg = "There were " + modifiedCount + " rows updated"
  * </pre>
  * 
  * @see Update
@@ -117,8 +117,7 @@ public interface SqlUpdate {
   SqlUpdate setParameter(int position, Object value);
 
   /**
-   * Set a null parameter via its index position. Exactly the same as
-   * {@link #setNull(int, int)}.
+   * Set a null parameter via its index position.
    */
   SqlUpdate setNull(int position, int jdbcType);
 
@@ -143,4 +142,4 @@ public interface SqlUpdate {
    */
   SqlUpdate setNullParameter(String name, int jdbcType);
 
-}
+}

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

@@ -1,6 +1,9 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.annotation.DocStoreMode;
+import com.avaje.ebean.config.DocStoreConfig;
 import com.avaje.ebean.config.PersistBatch;
+import com.avaje.ebean.config.ServerConfig;
 
 import javax.persistence.PersistenceException;
 import javax.persistence.RollbackException;
@@ -51,13 +54,52 @@ public interface Transaction extends Closeable {
    */
   void setReadOnly(boolean readOnly);
 
+  /**
+   * Commits the transaction at this point with the expectation that another
+   * commit (or rollback or end) will occur later to complete the transaction.
+   * <p>
+   * This is similar to commit() but leaves the transaction "Active".
+   * </p>
+   * <h3>Functions/h3>
+   * <ul>
+   *   <li>Flush the JDBC batch buffer</li>
+   *   <li>Call commit on the underlying JDBC connection</li>
+   *   <li>Trigger any registered TransactionCallbacks</li>
+   *   <li>Perform post-commit processing updating L2 cache, ElasticSearch etc</li>
+   * </ul>
+   */
+  void commitAndContinue() throws RollbackException;
+
   /**
    * Commit the transaction.
+   * <p>
+   * This performs commit and completes the transaction closing underlying resources and
+   * marking the transaction as "In active".
+   * </p>
+   * <h3>Functions/h3>
+   * <ul>
+   *   <li>Flush the JDBC batch buffer</li>
+   *   <li>Call commit on the underlying JDBC connection</li>
+   *   <li>Trigger any registered TransactionCallbacks</li>
+   *   <li>Perform post-commit processing updating L2 cache, ElasticSearch etc</li>
+   *   <li>Close any underlying resources, closing the underlying JDBC connection</li>
+   *   <li>Mark the transaction as "Inactive"</li>
+   * </ul>
    */
   void commit() throws RollbackException;
 
   /**
    * Rollback the transaction.
+   * <p>
+   * This performs rollback, closes underlying resources and marks the transaction as "In active".
+   * </p>
+   * <h3>Functions/h3>
+   * <ul>
+   *   <li>Call rollback on the underlying JDBC connection</li>
+   *   <li>Trigger any registered TransactionCallbacks</li>
+   *   <li>Close any underlying resources, closing the underlying JDBC connection</li>
+   *   <li>Mark the transaction as "Inactive"</li>
+   * </ul>
    */
   void rollback() throws PersistenceException;
 
@@ -71,6 +113,16 @@ public interface Transaction extends Closeable {
    */
   void rollback(Throwable e) throws PersistenceException;
 
+  /**
+   * Mark the transaction for rollback only.
+   */
+  void setRollbackOnly();
+
+  /**
+   * Return true if the transaction is marked as rollback only.
+   */
+  boolean isRollbackOnly();
+
   /**
    * If the transaction is active then perform rollback. Otherwise do nothing.
    */
@@ -81,6 +133,29 @@ public interface Transaction extends Closeable {
    */
   boolean isActive();
 
+  /**
+   * Set the behavior for document store updates on this transaction.
+   * <p>
+   *   For example, set the mode to DocStoreEvent.IGNORE for this transaction and
+   *   then any changes via this transaction are not sent to the doc store. This
+   *   would be used when doing large bulk inserts into the database and we want
+   *   to control how that is sent to the document store.
+   * </p>
+   */
+  void setDocStoreMode(DocStoreMode mode);
+
+  /**
+   * Set the batch size to use for sending messages to the document store.
+   * <p>
+   *   You might set this if you know the changes in this transaction result in especially large or
+   *   especially small payloads and want to adjust the batch size to match.
+   * </p>
+   * <p>
+   *   Setting this overrides the default of {@link DocStoreConfig#getBulkBatchSize()}
+   * </p>
+   */
+  void setDocStoreBatchSize(int batchSize);
+
   /**
    * Explicitly turn off or on the cascading nature of save() and delete(). This
    * gives the developer exact control over what beans are saved and deleted
@@ -100,13 +175,78 @@ public interface Transaction extends Closeable {
    * Set to true when you want all loaded properties to be included in the update
    * (rather than just the changed properties).
    * <p>
-   *   You might set this when using JDBC batch in order to get multiple updates
-   *   with slightly different sets of changed properties into the same statement
-   *   and hence better JDBC batch performance.
+   * You might set this when using JDBC batch in order to get multiple updates
+   * with slightly different sets of changed properties into the same statement
+   * and hence better JDBC batch performance.
    * </p>
    */
   void setUpdateAllLoadedProperties(boolean updateAllLoadedProperties);
 
+  /**
+   * Set if the L2 cache should be skipped for "find by id" and "find by natural key" queries.
+   * <p>
+   * By default {@link ServerConfig#isSkipCacheAfterWrite()} is true and that means that for
+   * "find by id" and "find by natural key" queries which normally hit L2 bean cache automatically
+   * - will not do so after a persist/write on the transaction.
+   * </p>
+   * <p>
+   * This method provides explicit control over whether "find by id" and "find by natural key"
+   * will skip the L2 bean cache or not (regardless of whether the transaction is considered "read only").
+   * </p>
+   * <p>
+   * Refer to {@link ServerConfig#setSkipCacheAfterWrite(boolean)} for configuring the default behavior
+   * for using the L2 bean cache in transactions spanning multiple query/persist requests.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *   // assume Customer has L2 bean caching enabled ...
+   *
+   *   Transaction transaction = Ebean.beginTransaction();
+   *   try {
+   *
+   *     // this uses L2 bean cache as the transaction
+   *     // ... is considered "query only" at this point
+   *     Customer.find.byId(42);
+   *
+   *     // transaction no longer "query only" once
+   *     // ... a bean has been saved etc
+   *     Ebean.save(someBean);
+   *
+   *     // will NOT use L2 bean cache as the transaction
+   *     // ... is no longer considered "query only"
+   *     Customer.find.byId(55);
+   *
+   *
+   *
+   *     // explicit control - please use L2 bean cache
+   *
+   *     transaction.setSkipCache(false);
+   *     Customer.find.byId(77); // hit the l2 bean cache
+   *
+   *
+   *     // explicit control - please don't use L2 bean cache
+   *
+   *     transaction.setSkipCache(true);
+   *     Customer.find.byId(99); // skips l2 bean cache
+   *
+   *
+   *   } finally {
+   *     transaction.end();
+   *   }
+   *
+   * }</pre>
+   *
+   * @see ServerConfig#isSkipCacheAfterWrite()
+   */
+  void setSkipCache(boolean skipCache);
+
+  /**
+   * Return true if the L2 cache should be skipped. More accurately if true then find by id
+   * and find by natural key queries should NOT automatically use the L2 bean cache.
+   */
+  boolean isSkipCache();
+
   /**
    * Turn on or off statement batching. Statement batching can be transparent
    * for drivers and databases that support getGeneratedKeys. Otherwise you may
@@ -326,9 +466,8 @@ public interface Transaction extends Closeable {
 
   /**
    * Add an arbitrary user object to the transaction. The objects added have no
-   * impact on any internals of ebena and are solely meant as a convenient
-   * method push user information to e.g. the
-   * {@link com.avaje.ebean.event.TransactionEventListener}.
+   * impact on any internals of ebean and are solely meant as a convenient
+   * method push user information (although somewhat replaced by TransactionCallback).
    */
   void putUserObject(String name, Object value);
 

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

@@ -16,7 +16,7 @@ import java.util.ArrayList;
  * This object is used internally with the enhancement of a method with
  * Transactional annotation.
  * </p>
- * 
+ *
  * @see TxCallable
  * @see TxRunnable
  * @see Ebean#execute(TxScope, TxCallable)
@@ -36,33 +36,14 @@ public final class TxScope {
 
   int batchSize;
 
+  boolean skipGeneratedKeys;
+
   boolean readOnly;
 
   ArrayList<Class<? extends Throwable>> rollbackFor;
 
   ArrayList<Class<? extends Throwable>> noRollbackFor;
 
-  /**
-   * Return true if PersistBatch has been set.
-   */
-  public boolean isBatchSet() {
-    return batch != null && batch != PersistBatch.INHERIT;
-  }
-
-  /**
-   * Return true if batch on cascade has been set.
-   */
-  public boolean isBatchOnCascadeSet() {
-    return batchOnCascade != null && batchOnCascade != PersistBatch.INHERIT;
-  }
-
-  /**
-   * Return true if batch size has been set.
-   */
-  public boolean isBatchSizeSet() {
-    return batchSize > 0;
-  }
-
   /**
    * Helper method to create a TxScope with REQUIRES.
    */
@@ -128,6 +109,44 @@ public final class TxScope {
         + "] rollbackFor[" + rollbackFor + "] noRollbackFor[" + noRollbackFor + "]";
   }
 
+  /**
+   * Return true if PersistBatch has been set.
+   */
+  public boolean isBatchSet() {
+    return batch != null && batch != PersistBatch.INHERIT;
+  }
+
+  /**
+   * Return true if batch on cascade has been set.
+   */
+  public boolean isBatchOnCascadeSet() {
+    return batchOnCascade != null && batchOnCascade != PersistBatch.INHERIT;
+  }
+
+  /**
+   * Return true if batch size has been set.
+   */
+  public boolean isBatchSizeSet() {
+    return batchSize > 0;
+  }
+
+  /**
+   * Check for batchSize being set without batch mode and use this to imply PersistBatch.ALL.
+   */
+  public void checkBatchMode() {
+    if (batchSize > 0 && notSet(batch) && notSet(batchOnCascade)) {
+      // Use setting the batchSize as implying PersistBatch.ALL for @Transactional
+      batch = PersistBatch.ALL;
+    }
+  }
+
+  /**
+   * Return true if the mode is considered not set.
+   */
+  private boolean notSet(PersistBatch batchMode) {
+    return batchMode == null || batchMode == PersistBatch.INHERIT;
+  }
+
   /**
    * Return the transaction type.
    */
@@ -188,6 +207,21 @@ public final class TxScope {
     return this;
   }
 
+  /**
+   * Set if the transaction should skip reading generated keys for inserts.
+   */
+  public TxScope setSkipGeneratedKeys() {
+    this.skipGeneratedKeys = true;
+    return this;
+  }
+
+  /**
+   * Return true if getGeneratedKeys should be skipped for this transaction.
+   */
+  public boolean isSkipGeneratedKeys() {
+    return skipGeneratedKeys;
+  }
+
   /**
    * Return if the transaction should be treated as read only.
    */

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

@@ -0,0 +1,160 @@
+package com.avaje.ebean;
+
+/**
+ * An update query typically intended to perform a bulk update of many rows that match the query.
+ * <p>
+ * Also note that you can also just use a raw SQL update via {@link SqlUpdate} which is pretty light and simple.
+ * This UpdateQuery is more for the cases where we want to build the where expression of the update using the
+ * {@link ExpressionList} "Criteria API" that is used with a normal ORM query.
+ * </p>
+ *
+ * <h4>Example: Simple update</h4>
+ *
+ * <pre>{@code
+ *
+ *  int rows = ebeanServer
+ *      .update(Customer.class)
+ *      .set("status", Customer.Status.ACTIVE)
+ *      .set("updtime", new Timestamp(System.currentTimeMillis()))
+ *      .where()
+ *      .gt("id", 1000)
+ *      .update();
+ *
+ * }</pre>
+ * <pre>{@code sql
+ *
+ *   update o_customer set status=?, updtime=? where id > ?
+ *
+ * }</pre>
+ *
+ * <p>
+ * Note that if the where() clause contains a join then the SQL update changes to use a
+ * <code> WHERE ID IN () </code> form.
+ * </p>
+ *
+ * <h4>Example: Update with a JOIN</h4>
+ * <p>
+ *   In this example the expression <code>.eq("billingAddress.country", nz)</code> requires a join
+ *   to the address table.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ *   int rows = ebeanServer
+ *       .update(Customer.class)
+ *       .set("status", Customer.Status.ACTIVE)
+ *       .set("updtime", new Timestamp(System.currentTimeMillis()))
+ *       .where()
+ *         .eq("status", Customer.Status.NEW)
+ *         .eq("billingAddress.country", nz)
+ *         .gt("id", 1000)
+ *         .update();
+ * }</pre>
+ *
+ * <pre>{@code sql
+ *
+ *   update o_customer set status=?, updtime=?
+ *   where id in (
+ *     select t0.id c0
+ *     from o_customer t0
+ *     left outer join o_address t1 on t1.id = t0.billing_address_id
+ *     where t0.status = ?
+ *       and t1.country_code = ?
+ *       and t0.id > ? )
+ *
+ * }</pre>
+ *
+ * @param <T> The type of entity bean being updated
+ *
+ * @see SqlUpdate
+ */
+public interface UpdateQuery<T> {
+
+  /**
+   * Set the value of a property.
+   *
+   *
+   * <pre>{@code
+   *
+   *   int rows = ebeanServer
+   *      .update(Customer.class)
+   *      .set("status", Customer.Status.ACTIVE)
+   *      .set("updtime", new Timestamp(System.currentTimeMillis()))
+   *      .where()
+   *      .gt("id", 1000)
+   *      .update();
+   *
+   * }</pre>
+   *
+   * @param property The bean property to be set
+   * @param value The value to set the property to
+   */
+  UpdateQuery<T> set(String property, Object value);
+
+  /**
+   * Set the property to be null.
+   *
+   * <pre>{@code
+   *
+   *   int rows = ebeanServer
+   *      .update(Customer.class)
+   *      .setNull("notes")
+   *      .where()
+   *      .gt("id", 1000)
+   *      .update();
+   *
+   * }</pre>
+   *
+   * @param property The property to be set to null.
+   */
+  UpdateQuery<T> setNull(String property);
+
+  /**
+   *
+   * Set using a property expression that does not need any bind values.
+   * <p>
+   * The property expression typically contains database functions.
+   * </p>
+   *
+   * <pre>{@code
+   *
+   *   int rows = ebeanServer
+   *      .update(Customer.class)
+   *      .setRaw("status = coalesce(status, 'A')")
+   *      .where()
+   *      .gt("id", 1000)
+   *      .update();
+   *
+   * }</pre>
+   *
+   * @param propertyExpression A property expression
+   */
+  UpdateQuery<T> setRaw(String propertyExpression);
+
+  /**
+   * Set using a property expression that can contain <code>?</code> bind value placeholders.
+   * <p>
+   * For each <code>?</code> in the property expression there should be a matching bind value supplied.
+   * </p>
+   * <pre>{@code
+   *
+   *   int rows = ebeanServer
+   *      .update(Customer.class)
+   *      .setRaw("status = coalesce(status, ?)", Customer.Status.ACTIVE)
+   *      .where()
+   *      .gt("id", 1000)
+   *      .update();
+   *
+   * }</pre>
+   *
+   * @param propertyExpression A raw property expression
+   * @param values The values to bind with the property expression
+   */
+  UpdateQuery<T> setRaw(String propertyExpression, Object... values);
+
+  /**
+   * Return the query expression list to add predicates to.
+   */
+  ExpressionList<T> where();
+
+}

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

@@ -0,0 +1,61 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the default cache use specific entity type.
+ */
+@Target({ ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Cache {
+
+  /**
+   * Set this to true to enable the use of query cache.
+   * <p>
+   * By default query caching is disabled as the query cache invalidates
+   * frequently and so it is typically used for specific bean types and cases.
+   * </p>
+   */
+  boolean enableQueryCache() default false;
+
+  /**
+   * Set this to false to disable the use of bean cache.
+   * <p>
+   * By default bean caching is expected so this defaults to true.  We might
+   * set this to false on a bean type that we want to use query caching but no
+   * bean caching (and this is expected to be a rare case).
+   * </p>
+   * <p>
+   * When bean caching is enabled by default "find by id" and "find by unique natural key"
+   * queries will try to use the bean cache. We use {@link com.avaje.ebean.Query#setUseCache(boolean)}
+   * with <code>false</code> for the case when we do NOT want to use the bean cache.
+   * </p>
+   */
+  boolean enableBeanCache() default true;
+
+  /**
+   * Specify the property that is a natural unique identifier for the bean.
+   * <p>
+   * When a findUnique() query is used with this property as the sole expression
+   * then there will be a lookup into the L2 natural key cache.
+   * </p>
+   */
+  String naturalKey() default "";
+
+  /**
+   * When set to true the beans returned from a query will default to be
+   * readOnly.
+   * <p>
+   * If the bean is readOnly and has no relationships then it may be sharable.
+   * </p>
+   * <p>
+   * If you try to modify a readOnly bean it will throw an
+   * IllegalStateException.
+   * </p>
+   */
+  boolean readOnly() default false;
+
+}

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

@@ -0,0 +1,56 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Cache tuning hints for the L2 bean cache of a specific entity type.
+ * <p>
+ * Note that this is not useful when distributed L2 bean caches are used like
+ * ElasticSearch, Hazelcast, Ignite etc.
+ * </p>
+ */
+@Target({ ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CacheBeanTuning {
+
+  /**
+   * The maximum size for the cache.
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxSize() default 0;
+
+  /**
+   * The maximum time (in seconds) that a cache entry is allowed to stay in the
+   * cache when it has not been accessed.
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxIdleSecs() default 0;
+
+  /**
+   * The maximum time (in seconds) a cache entry is allowed to stay in the
+   * cache.
+   * <p>
+   * This is not generally required as the cache entries are automatically
+   * evicted when related data changes are committed.
+   * </p>
+   * <p>
+   * This defaults to 0 which means unlimited.
+   * </p>
+   */
+  int maxSecsToLive() default 0;
+
+  /**
+   * The frequency (in seconds) that cache trimming should occur.
+   * <p>
+   * This is a hint for cache implementations that use background cache trimming.
+   * </p>
+   */
+  int trimFrequency() default 0;
+}

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

@@ -6,14 +6,14 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * Specify cache tuning for a specific entity type.
+ * Specify cache tuning for query caching on a specific entity type.
  * <p>
  * If this is not specified then the system default settings are used.
  * </p>
  */
 @Target({ ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)
-public @interface CacheTuning {
+public @interface CacheQueryTuning {
 
   /**
    * The maximum size for the cache.

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

@@ -1,58 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import com.avaje.ebean.Query;
-
-/**
- * Specify the default cache use specific entity type.
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface CacheStrategy {
-
-  /**
-   * When set to true the bean cache will be used unless explicitly stated not
-   * to in a query via {@link Query#setUseCache(boolean)}.
-   */
-  boolean useBeanCache() default true;
-
-  /**
-   * A single property that is a natural unique identifier for the bean.
-   * <p>
-   * When a findUnique query is used with this property as the sole expression
-   * then there will be a lookup into the L2 natural key cache.
-   * </p>
-   */
-  String naturalKey() default "";
-
-  /**
-   * When set to true the beans returned from a query will default to be
-   * readOnly.
-   * <p>
-   * If the bean is readOnly and has no relationships then it may be sharable.
-   * </p>
-   * <p>
-   * If you try to modify a readOnly bean it will throw an
-   * IllegalStateException.
-   * </p>
-   */
-  boolean readOnly() default false;
-
-  /**
-   * Specify a query that can be used to warm the cache.
-   * <p>
-   * All the beans fetched by this query will be loaded into the bean cache and
-   * the query itself will be loaded into the query cache.
-   * </p>
-   * <p>
-   * The warming query will typically be executed at startup time after a short
-   * delay (defaults to a 30 seconds delay).
-   * </p>
-   */
-  String warmingQuery() default "";
-
-}

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

@@ -9,6 +9,10 @@ import java.lang.annotation.Target;
  * For a timestamp property that is set to the datetime when the entity is
  * created/inserted.
  * <p>
+ * This is effectively an alias for @WhenCreated which was added as it hints
+ * towards a better naming convention (WhenCreated, WhenModified).
+ * </p>
+ * <p>
  * An alternative to using this annotation would be to use insertable=false,
  * updateable=false with @Column and have the DB insert the current time
  * (default value on the DB column is SYSTIME etc).

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

@@ -0,0 +1,40 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify a collection property that will be stored into a DB ARRAY type.
+ * <p>
+ * If the target database does not support ARRAY type (so not Postgres)
+ * then the collection will be stored in JSON format into a VARCHAR column.
+ * </p>
+ *
+ * <h3>Example:</h3>
+ * <pre>{@code
+ *
+ * // Store as ARRAY of UUID on Postgres
+ * @DbArray
+ * List<UUID> uids = new ArrayList<>();
+ *
+ * // Store as ARRAY on Postgres
+ * @DbArray
+ * List<String> phoneNumbers = new ArrayList<>();
+ *
+ * // Store as ARRAY of INTEGER on Postgres
+ * @DbArray
+ * List<Long> someLongs = new ArrayList<>();
+ *
+ * }</pre>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DbArray {
+
+  /**
+   * For VARCHAR storage specify the column length (defaults to 1000).
+   */
+  int length() default 0;
+}

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

@@ -6,14 +6,14 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * Specify explicit ConcurrencyMode for entity bean.
+ * A database table or column comment.
  */
-@Target({ ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)
-public @interface EntityConcurrencyMode {
-  
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
+public @interface DbComment {
+
   /**
-   * The ConcurrencyMode value.
+   * The database table or column comment.
    */
-  ConcurrencyMode value();
-}
+  String value();
+}

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

@@ -23,4 +23,8 @@ import java.lang.annotation.Target;
 @Target(ElementType.FIELD)
 public @interface DbHstore {
 
+  /**
+   * For VARCHAR storage specify the column length (defaults to 1000).
+   */
+  int length() default 0;
 }

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

@@ -36,4 +36,8 @@ import java.lang.annotation.Target;
 @Target(ElementType.FIELD)
 public @interface DbJsonB {
 
+  /**
+   * For VARCHAR storage specify the column length.
+   */
+  int length() default 0;
 }

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

@@ -0,0 +1,32 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Used to indicate that a particular string property should be treated as a 'code' and not analysed for text searching.
+ * <p>
+ * By default all Id properties and all Enum properties are treated as 'code' and not analysed.
+ * </p>
+ */
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocCode {
+
+  /**
+   * Set to true to have the property additionally stored separately from _source.
+   */
+  boolean store() default false;
+
+  /**
+   * Set a boost value specific to this property.
+   */
+  float boost() default 1;
+
+  /**
+   * Set a value to use instead of null.
+   */
+  String nullValue() default "";
+}

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

@@ -0,0 +1,37 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the property is included in the parent document store index.
+ *
+ * <pre>{@code
+ *
+ *
+ * @DocStore
+ * @Entity @Table(name = "o_order")
+ * public class Order {
+ *
+ *   ...
+ *   // include some customer details including
+ *   // nested billingAddress
+ *   @DocEmbedded(doc = "id,status,name,billingAddress(*,country(*)")
+ *   @ManyToOne
+ *   Customer customer;
+ *
+ *
+ * }</pre>
+ */
+@Target({ ElementType.FIELD })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocEmbedded {
+
+  /**
+   * The properties on the embedded bean to include in the index.
+   */
+  String doc() default "";
+
+}

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

@@ -6,15 +6,19 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * Holds an array of named Update statements for a particular entity bean type.
+ * Specify the entity type maps to a document store (like ElasticSearch).
  */
 @Target({ ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)
-public @interface NamedUpdates {
+public @interface DocMapping {
 
   /**
-   * An array of named updates.
+   * The property name the mapping applies to.
    */
-  NamedUpdate[] value();
+  String name();
 
+  /**
+   * Mapping options.
+   */
+  DocProperty options();
 }

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

@@ -0,0 +1,110 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the entity type maps to a document store (like ElasticSearch).
+ */
+@Target({ ElementType.FIELD })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocProperty {
+
+  /**
+   * Set this to true to indicate that this property should be un-analysed.
+   */
+  boolean code() default false;
+
+  /**
+   * Set this to true to get an additional un-analysed 'raw' field to use for sorting etc.
+   */
+  boolean sortable() default false;
+
+  /**
+   * Set to true to have the property additionally stored separately from _source.
+   */
+  boolean store() default false;
+
+  /**
+   * Set a boost value specific to this property.
+   */
+  float boost() default 1;
+
+  /**
+   * Set a value to use instead of null.
+   */
+  String nullValue() default "";
+
+  /**
+   * Set this to false to exclude this from the _all property.
+   */
+  boolean includeInAll() default true;
+
+  /**
+   * The analyzer to use.
+   */
+  String analyzer() default "";
+
+  /**
+   * The analyzer to use for searches.
+   */
+  String searchAnalyzer() default "";
+
+  /**
+   * The index options for this property.
+   */
+  Option options() default Option.DEFAULT;
+
+  /**
+   * Set this to false such that doc values are not stored separately for this property.
+   */
+  boolean docValues() default true;
+
+  /**
+   * Set a copyTo field.
+   */
+  String copyTo() default "";
+
+  /**
+   * Set to false to disable the field from indexing, it will only be get/set in _source.
+   */
+  boolean enabled() default true;
+
+  /**
+   * Set to false such that norms are not stored.
+   */
+  boolean norms() default true;
+
+  /**
+   * Index options for a property.
+   */
+  enum Option {
+
+    /**
+     * Only index the doc number.
+     */
+    DOCS,
+
+    /**
+     * Doc number and term frequencies are indexed.
+     */
+    FREQS,
+
+    /**
+     * Doc number, term frequencies and term positions are indexed.
+     */
+    POSITIONS,
+
+    /**
+     * Doc number, term frequencies, term positions and start/end offsets are indexed.
+     */
+    OFFSETS,
+
+    /**
+     * Use the default which means analysed string properties use POSITIONS as the default and all other types use DOCS.
+     */
+    DEFAULT
+  }
+}

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

@@ -0,0 +1,34 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Used to indicate that a particular string property should support sorting. What this typically means is that
+ * for ElasticSearch an additional 'raw' field is added that stores the un-analysed value. This un-analysed value
+ * can be used for sorting etc and the original field used for text searching.
+ * <p>
+ * For example, customer name and product name are good candidates for marking with @DocSortable.
+ * </p>
+ */
+@Target({ ElementType.FIELD })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocSortable {
+
+  /**
+   * Set to true to have the property additionally stored separately from _source.
+   */
+  boolean store() default false;
+
+  /**
+   * Set a boost value specific to this property.
+   */
+  float boost() default 1;
+
+  /**
+   * Set a value to use instead of null.
+   */
+  String nullValue() default "";
+}

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

@@ -0,0 +1,88 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specify the entity type maps to a document store (like ElasticSearch).
+ */
+@Target({ ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DocStore {
+
+  /**
+   * A unique Id used when queuing reindex events.
+   */
+  String queueId() default "";
+
+  /**
+   * The ElasticSearch index name. If left unspecified the short name of the bean type is used.
+   */
+  String indexName() default "";
+
+  /**
+   * The ElasticSearch index type. If left unspecified the short name of the bean type is used.
+   */
+  String indexType() default "";
+
+  /**
+   * The number of shards this index should use.
+   */
+  int shards() default 0;
+
+  /**
+   * The number of replicas this index should use.
+   */
+  int replicas() default 0;
+
+  /**
+   * Additional mapping that can be defined on the properties.
+   */
+  DocMapping[] mapping() default {};
+
+  /**
+   * Specify the behavior when bean Insert, Update, Delete events occur.
+   */
+  DocStoreMode persist() default DocStoreMode.DEFAULT;
+
+  /**
+   * Specify the behavior when bean Insert occurs.
+   */
+  DocStoreMode insert() default DocStoreMode.DEFAULT;
+
+  /**
+   * Specify the behavior when bean Update occurs.
+   */
+  DocStoreMode update() default DocStoreMode.DEFAULT;
+
+  /**
+   * Specify the behavior when bean Delete occurs.
+   */
+  DocStoreMode delete() default DocStoreMode.DEFAULT;
+
+  /**
+   * Specify to include only some properties in the doc store document.
+   * <p>
+   * If this is left as default then all scalar properties are included,
+   * all @ManyToOne properties are included with just the nested id property
+   * and no @OneToMany properties are included.
+   * </p>
+   * <p>
+   * Note that typically DocStoreEmbedded is used on @ManyToOne and @OneToMany
+   * properties to indicate what part of the nested document should be included.
+   * </p>
+   *
+   * <h3>Example:</h3>
+   * <pre>{@code
+   *
+   * // only include the customer id and name
+   * @DocStore(doc = "id,name")
+   * @Entity @Table(name = "o_order")
+   * public class Customer {
+   *
+   * }</pre>
+   */
+  String doc() default "";
+}

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

@@ -0,0 +1,38 @@
+package com.avaje.ebean.annotation;
+
+/**
+ * Defines the behavior options when a Insert, Update or Delete event occurs
+ * on a bean with an associated ElasticSearch index.
+ * <p>
+ * For some indexes or some transactions it can be beneficial to queue the event
+ * for later processing rather than look to update ElasticSearch at that time.
+ * </p>
+ */
+public enum DocStoreMode {
+
+  /**
+   * Add the event to the queue for processing later (delaying the update to the document store).
+   */
+  QUEUE,
+
+  /**
+   * Update the document store when transaction succeeds.
+   */
+  UPDATE,
+
+  /**
+   * Ignore the event and not update the document store.
+   * <p>
+   *   This can be used on a index or for a transaction where you want to have more
+   *   manual programmatic control over the updating of the document store.  Say you want to
+   *   IGNORE on a particular transaction and instead manually queue a bulk update.
+   * </p>
+   */
+  IGNORE,
+
+  /**
+   * The actual mode of QUEUE, UPDATE or IGNORE is set from the default configuration.
+   */
+  DEFAULT
+
+}

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

@@ -0,0 +1,19 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a boolean property on a @Draftable bean that indicates if the bean instance is a 'draft' or 'live' bean.
+ * The property is transient and has no underlying DB column.
+ * <p>
+ * For beans returned from an <code>asDraft()</code> query this property will be set to true.
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Draft {
+
+}

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

@@ -1,90 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * For mapping the values of an Enum to and from Database values.
- * <p>
- * Also refer to the {@link EnumValue} approach which probably the preferred now
- * (preferred over using this EnumMapping annotation).
- * </p>
- * <p>
- * Both of the approaches defined in the JPA have significant problems!!!
- * </p>
- * <p>
- * Using the ordinal value is VERY RISKY because that depends on the compile
- * order of the enum values. Aka if you change the order of the enum values you
- * have changed their ordinal values and now your DB values are WRONG - a HUGE
- * disaster!!!.
- * </p>
- * <p>
- * Using the String values of enums is fairly restrictive because in a Database
- * these values are usually truncated into short codes (e.g. "A" short for
- * "ACTIVE") so space used in the database is minimised. Making your enum names
- * match the database values would give them very short less meaningful names -
- * not a great solution.
- * </p>
- * <p>
- * You can use this annotation to control the mapping of your enums to database
- * values.
- * </p>
- * <p>
- * The design of this using nameValuePairs is not optimal for safety or
- * refactoring so if you have a better solution I'm all ears. The other
- * solutions would probably involve modifying each enumeration with a method
- * which may be ok.
- * </p>
- * <p>
- * An example mapping the UserState enum.
- * </p>
- * 
- * <pre class="code">
- * ...
- * &#064;EnumMapping(nameValuePairs=&quot;NEW=N, ACTIVE=A, INACTIVE=I&quot;)
- *  public enum UserState {
- *  NEW,
- *  ACTIVE,
- *  INACTIVE;
- *  }
- * </pre>
- * 
- * @see EnumValue
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface EnumMapping {
-
-  /**
-   * A comma delimited list of name=value pairs.
-   * <p>
-   * e.g. "ACTIVE=A, INACTIVE=I, NEW=N".
-   * </p>
-   * <p>
-   * Where ACTIVE, INACTIVE and NEW are the enumeration values and "A", "I" and
-   * "N" are the database values.
-   * </p>
-   * <p>
-   * This is not really an optimal approach so if you have a better one I'm all
-   * ears - thanks.
-   * </p>
-   */
-  String nameValuePairs();
-
-  /**
-   * Defaults to mapping values to database VARCHAR type. If this is set to true
-   * then the values will be converted to INTEGER and mapped to the database
-   * integer type.
-   * <p>
-   * e.g. "ACTIVE=1, INACTIVE=0, NEW=2".
-   * </p>
-   */
-  boolean integerType() default false;
-
-  /**
-   * The length of DB column if mapping to string values.
-   */
-  int length() default 0;
-}

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

@@ -1,17 +1,19 @@
 package com.avaje.ebean.annotation;
 
 import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * An annotation for declaring an index on a single column.
+ * An annotation for declaring an index.
  *
  * @author rvbiljouw
  */
 @Target({ElementType.TYPE, ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
+@Repeatable(Indices.class)
 public @interface Index {
 
   /**
@@ -27,6 +29,9 @@ public @interface Index {
   /**
    * When placed on the class (rather than field) you can specify the columns
    * to include in the index in order.
+   * 
+   * Wnen placed on a field, and columnNames are specified, the field-column has to be included.
+   * You can use "${fa}" for alias
    */
   String[] columnNames() default {};
 

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

@@ -0,0 +1,20 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+/**
+ * An annotation for declaring multiple indices at class or field level.
+ * 
+ * @author Roland Praml, FOCONIS AG
+ */
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Indices {
+
+  /**
+   * Array with {@link Index} definitions.
+   */
+  Index[] value() default {};
+}

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

@@ -1,37 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * An Update statement for a particular entity bean type.
- * <p>
- * The update can either be a sql insert,update or delete statement with tables
- * and columns etc or the equivalent statement but with table names and columns
- * expressed as bean types and bean properties.
- * </p>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface NamedUpdate {
-
-  /**
-   * The name of the update.
-   */
-  String name();
-
-  /**
-   * The insert, update or delete statement.
-   */
-  String update();
-
-  /**
-   * Set this to false if you do not want the cache to be notified. If true the
-   * cache will invalidate appropriate objects from the cache (after a
-   * successful transaction commit).
-   */
-  boolean notifyCache() default true;
-
-}

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

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

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

@@ -6,19 +6,13 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * Specify explicit sql for multiple select statements. Need to use this if you
- * have more than one SqlSelect for a given bean.
+ * Mark and entity bean that is used solely via RawSql.
  * <p>
- * FUTURE: Support explicit sql for SqlInsert, SqlUpdate and SqlDelete.
+ * This means the entity bean has no base table specified (via @Table).
  * </p>
  */
 @Target({ ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Sql {
 
-  /**
-   * The sql select statements.
-   */
-  SqlSelect[] select() default { @SqlSelect };
-
 }

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

@@ -1,298 +0,0 @@
-package com.avaje.ebean.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import com.avaje.ebean.Query;
-
-/**
- * Specify an explicit sql select statement to use for querying an entity bean.
- * <p>
- * The reason for using explicit sql is that you want better control over the
- * exact sql or sql that Ebean does not generate for you (such as group by,
- * union, intersection, window functions, recursive queries).
- * </p>
- * <p>
- * An example of two sql select queries deployed on the ReportTopic entity bean.
- * The first one has no name specified so it becomes the default query. The
- * second query extends the first adding a where clause with a named parameter.
- * </p>
- * 
- * <pre class="code">
- * ...
- * &#064;Entity
- *   &#064;Sql(select = {
- *     &#064;SqlSelect(query = 
- *       &quot;select t.id, t.title, count(p.id) as score &quot;+
- *       &quot;from f_topic t &quot;+
- *       &quot;join f_topic_post p on p.topic_id = t.id &quot;+
- *       &quot;group by t.id, t.title&quot;),
- *     &#064;SqlSelect(
- *       name = &quot;with.title&quot;,
- *       extend = &quot;default&quot;,
- *       debug = true,
- *       where = &quot;title like :likeTitle&quot;)
- *  })
- *  public class ReportTopic
- *    &#064;Id Integer id;
- *    String title;
- *    Double score;
- *    ...
- * </pre>
- * 
- * <p>
- * An example using the first "default" query.
- * </p>
- * 
- * <pre class="code">
- * 
- * List&lt;ReportTopic&gt; list =
- *     Ebean.find(ReportTopic.class)
- *         .having().gt(&quot;score&quot;, 0)
- *         .findList();
- * 
- * </pre>
- * 
- * <p>
- * The resulting sql, note the having clause has been added.
- * </p>
- * 
- * <pre class="code">
- * select t.id, t.title, count(p.id) as score 
- * from f_topic t join f_topic_post p on p.topic_id = t.id 
- * group by t.id, t.title  
- * having count(p.id) &gt; ?
- * </pre>
- * 
- * <p>
- * An example using the second query. Note the named parameter "likeTitle" must
- * be set.
- * </p>
- * 
- * <pre class="code">
- * List&lt;ReportTopic&gt; list =
- *     Ebean.find(ReportTopic.class, &quot;with.title&quot;)
- *         .set(&quot;likeTitle&quot;, &quot;a%&quot;)
- *         .findList();
- * </pre>
- * 
- * <p>
- * Ebean tries to parse the sql in the query to determine 4 things
- * <li>Location for inserting WHERE expressions (if required)</li>
- * <li>Location for inserting HAVING expressions (if required)</li>
- * <li>Mapping of columns to bean properties</li>
- * <li>The order by clause</li>
- * </p>
- * <p>
- * If Ebean is unable to parse out this information (perhaps because the sql
- * contains multiple select from keywords etc) then you need to manually specify
- * it.
- * </p>
- * <p>
- * Insert ${where} or ${andWhere} into the location where Ebean can insert any
- * expressions added to the where clause. Use ${andWhere} if the sql already has
- * the WHERE keyword and Ebean will instead start with a AND keyword.
- * </p>
- * <p>
- * Insert ${having} or ${andHaving} into the location where Ebean can insert any
- * expressions added to the having clause. Use ${andHaving} if the sql already
- * has a HAVING keyword and Ebean will instead start with a AND keyword.
- * </p>
- * <p>
- * Use the columnMapping property if Ebean is unable to determine the columns
- * and map them to bean properties.
- * </p>
- * <p>
- * Example with ${andWhere} & ${having}.
- * </p>
- * 
- * <pre class="code">
- *    &#064;SqlSelect(
- *          name = &quot;explicit.where&quot;,
- *          query = 
- *              &quot;select t.id, t.title, count(p.id) as score &quot;+
- *              &quot;from f_topic t, f_topic_post p &quot;+
- *              &quot;where p.topic_id = t.id ${andWhere} &quot;+
- *              &quot;group by t.id, t.title ${having}&quot;),
- * </pre>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-@Deprecated
-public @interface SqlSelect {
-
-  /**
-   * The name of the query. If left blank this is assumed to be the default
-   * query for this bean type.
-   * <p>
-   * This will default to "default" and in that case becomes the default query
-   * used for the bean.
-   * </p>
-   */
-  String name() default "default";
-
-  /**
-   * The tableAlias used when adding where expressions to the query.
-   */
-  String tableAlias() default "";
-
-  /**
-   * The sql select statement.
-   * <p>
-   * If this query <em>extends</em> another then this string is appended to the
-   * parent query string. Often when using <em>extend</em> you will leave the
-   * query part blank and just specify a where and/or having clauses.
-   * </p>
-   * <p>
-   * This sql <em>CAN NOT</em> contain named parameters. You have to put these
-   * in the separate where and/or having sections.
-   * </p>
-   * <p>
-   * Ebean automatically tries to determine the location in the sql string for
-   * putting in additional where or having clauses. If Ebean is unable to
-   * successfully determine this then you have to explicitly specify these
-   * locations by including
-   * <em>${where} or ${andWhere} and  ${having} or ${andHaving}</em> in the sql.
-   * </p>
-   * <p>
-   * <b>${where}</b> location of where clause (and will add WHERE ... ) <br/>
-   * Use this when there is no where clause in the sql. If expressions are added
-   * to the where clause Ebean will put them in at this location starting with
-   * the WHERE keyword.
-   * <p>
-   * <p>
-   * <b>${andWhere}</b> <br/>
-   * Use this instead of ${where} if there IS an existing where clause in the
-   * sql. Ebean will add the expressions starting with the AND keyword.
-   * <p>
-   * <b>${having}</b> location of having clause (and will add HAVING... ) <br/>
-   * </p>
-   * <p>
-   * <b>${andHaving}</b> <br/>
-   * Use this instead of ${having} when there IS an existing HAVING clause.
-   * Ebean will add the expressions starting with the AND keyword.
-   * </p>
-   * <p>
-   * You can include one of ${where} OR ${andWhere} but not both.
-   * </p>
-   * <p>
-   * You can include one of ${having} OR ${andHaving} but not both.
-   * </p>
-   */
-  String query() default "";
-
-  /**
-   * Specify the name of a sql-select query that this one 'extends'.
-   * <p>
-   * When a query is extended the sql query contents are appended together. The
-   * where and having clauses are NOT appended but overridden.
-   * </p>
-   */
-  String extend() default "";
-
-  /**
-   * Specify a where clause typically containing named parameters.
-   * <p>
-   * If a where clause is specified with named parameters then they will need to
-   * be set on the query via {@link Query#setParameter(String, Object)}.
-   * </p>
-   * <p>
-   * In the example below the query specifies a where clause that includes a
-   * named parameter "likeTitle".
-   * </p>
-   * 
-   * <pre class="code">
-   * ...
-   * &#064;Entity
-   * &#064;Sql(select = {
-   *  ...
-   *  &#064;SqlSelect(
-   *  name = &quot;with.title&quot;,
-   *  extend = &quot;default&quot;,
-   *  debug = true,
-   *  where = &quot;title like :likeTitle&quot;)
-   *  })
-   *  public class ReportTopic
-   *  ...
-   * </pre>
-   * 
-   * <p>
-   * Example use of the above named query.
-   * </p>
-   * 
-   * <pre class="code">
-   * 
-   * Query&lt;ReportTopic&gt; query0 = Ebean.createQuery(ReportTopic.class, &quot;with.title&quot;);
-   * 
-   * query0.set(&quot;likeTitle&quot;, &quot;Bana%&quot;);
-   * 
-   * List&lt;ReportTopic&gt; list0 = query0.findList();
-   * </pre>
-   * 
-   */
-  String where() default "";
-
-  /**
-   * Specify a having clause typically containing named parameters.
-   * <p>
-   * If a having clause is specified with named parameters then they will need
-   * to be set on the query via {@link Query#setParameter(String, Object)}.
-   * </p>
-   */
-  String having() default "";
-
-  /**
-   * (Optional) Explicitly specify column to property mapping.
-   * <p>
-   * This is required when Ebean is unable to parse the sql. This could occur if
-   * the sql contains multiple select keywords etc.
-   * </p>
-   * <p>
-   * Specify the columns and property names they map to in the format.
-   * </p>
-   * 
-   * <pre class="code">
-   *  column1 propertyName1, column2 propertyName2, ...
-   * </pre>
-   * 
-   * <p>
-   * Optionally put a AS keyword between the column and property.
-   * </p>
-   * 
-   * <pre class="code">
-   *   // the AS keyword is optional
-   *  column1 AS propertyName1, column2 propertyName2, ...
-   * </pre>
-   * 
-   * <p>
-   * <b>column</b> should contain the table alias if there is one
-   * </p>
-   * <p>
-   * <b>propertyName</b> should match the property name.
-   * </p>
-   * 
-   * <p>
-   * Example mapping 5 columns to properties.
-   * </p>
-   * 
-   * <pre class="code">
-   * columnMapping=&quot;t.id, t.bug_body description, t.bug_title as title, count(p.id) as scoreValue&quot;,
-   * </pre>
-   * 
-   * <p>
-   * Without this set Ebean will parse the sql looking for the select clause and
-   * try to map the columns to property names. It is expected that Ebean will
-   * not be able to successfully parse some sql and for those cases you should
-   * specify the column to property mapping explicitly.
-   * </p>
-   * 
-   */
-  String columnMapping() default "";
-
-  /**
-   * Set this to true to have debug output when Ebean parses the sql-select.
-   */
-  boolean debug() default false;
-}

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

@@ -90,6 +90,16 @@ public @interface Transactional {
    */
   int batchSize() default 0;
 
+  /**
+   * Set to false when we want to skip getting generatedKeys.
+   * <p>
+   * This is typically used in the case of large batch inserts where we get a
+   * performance benefit from not calling getGeneratedKeys (as we are going to
+   * insert a lot of rows and have no need for the Id values after the insert).
+   * </p>
+   */
+  boolean getGeneratedKeys() default true;
+
   /**
    * The transaction isolation level this transaction should have.
    * <p>

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

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

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

@@ -0,0 +1,38 @@
+package com.avaje.ebean.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotate an entity bean with @View to indicates the bean is based on a view.
+ * <p>
+ * As such typically the view is defined in <code>extra-ddl.xml</code> using
+ * <code>create or replace view ...</code>.
+ * </p>
+ * <p>
+ * When using extra-ddl.xml Ebean will run the resulting DDL script after the
+ * <code>create-all</code> DDL (which is typically used during development) and for
+ * DB Migration will copy the scripts as <code>repeatable migration scripts</code> that
+ * will be run by FlywayDb (or Ebean's own migration runner) when their MD5 hash changes.
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface View {
+
+  /**
+   * The name of the view this entity bean is based on.
+   */
+  String name();
+
+  /**
+   * Tables this view is dependent on.
+   * <p>
+   * This is used with l2 caching to invalidate the query cache. Changes to these
+   * tables invalidate the query cache for the entity based on this view.
+   * </p>
+   */
+  String[] dependentTables() default {};
+}

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

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

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

@@ -31,6 +31,16 @@ public interface BeanCollection<E> extends Serializable {
     ALL
   }
 
+  /**
+   * Set the disableLazyLoad state.
+   */
+  void setDisableLazyLoad(boolean disableLazyLoad);
+
+  /**
+   * Load bean from another collection.
+   */
+  void loadFrom(BeanCollection<?> other);
+
   /**
    * Add a bean to the list/set with modifyListen notification.
    */
@@ -49,10 +59,12 @@ public interface BeanCollection<E> extends Serializable {
   void reset(EntityBean ownerBean, String propertyName);
 
   /**
-   * Return true if the collection is empty and untouched. Used to detect if a
-   * collection was 'cleared' deliberately or just un-initialised.
+   * Return true if the collection is uninitialised or is empty without any held modifications.
+   * <p>
+   * Returning true means can safely skip cascade save for this bean collection.
+   * </p>
    */
-  boolean isEmptyAndUntouched();
+  boolean isSkipSave();
 
   /**
    * Return the bean that owns this collection.
@@ -87,11 +99,6 @@ public interface BeanCollection<E> extends Serializable {
    */
   void setFilterMany(ExpressionList<?> filterMany);
 
-  /**
-   * Set a listener to be notified when the BeanCollection is first touched.
-   */
-  void setBeanCollectionTouched(BeanCollectionTouched notify);
-
   /**
    * Return true if the collection has been registered with the batch loading context.
    */
@@ -125,6 +132,11 @@ public interface BeanCollection<E> extends Serializable {
    */
   void internalAdd(Object bean);
 
+  /**
+   * Add the bean with a check to see if it is already contained.
+   */
+  void internalAddWithCheck(Object bean);
+
   /**
    * Return the number of elements in the List Set or Map.
    */

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

@@ -1,20 +0,0 @@
-package com.avaje.ebean.bean;
-
-/**
- * Used to specify a listener to be notified when a BeanCollection is first
- * used.
- * <p>
- * To use this you can set a BeanCollectionTouched onto a BeanCollection before
- * it has been used. When the BeanCollection is first used by the client code
- * then the BeanCollectionTouched is notified. It can only be notified once.
- * </p>
- * 
- * @author rbygrave
- */
-public interface BeanCollectionTouched {
-
-  /**
-   * Notify the listener that the bean collection has been used.
-   */
-  void notifyTouched(BeanCollection<?> c);
-}

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

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

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

@@ -1,5 +1,10 @@
 package com.avaje.ebean.bean;
 
+import com.avaje.ebean.Ebean;
+import com.avaje.ebean.ValuePair;
+
+import javax.persistence.EntityNotFoundException;
+import javax.persistence.PersistenceException;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import java.beans.PropertyChangeSupport;
@@ -11,12 +16,6 @@ import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 
-import javax.persistence.EntityNotFoundException;
-import javax.persistence.PersistenceException;
-
-import com.avaje.ebean.Ebean;
-import com.avaje.ebean.ValuePair;
-
 /**
  * This is the object added to every entity bean using byte code enhancement.
  * <p>
@@ -40,6 +39,8 @@ public final class EntityBeanIntercept implements Serializable {
 
   private transient BeanLoader beanLoader;
 
+  private transient PreGetterCallback preGetterCallback;
+
   private String ebeanServerName;
 
   /**
@@ -92,6 +93,8 @@ public final class EntityBeanIntercept implements Serializable {
 
   private int lazyLoadProperty = -1;
 
+  private Object ownerId;
+
   /**
    * Create a intercept with a given entity.
    * <p>
@@ -185,6 +188,21 @@ public final class EntityBeanIntercept implements Serializable {
     return embeddedOwnerIndex;
   }
 
+  /**
+   * Clear the getter callback.
+   */
+  public void clearGetterCallback() {
+    this.preGetterCallback = null;
+  }
+
+  /**
+   * Register the callback to be triggered when getter is called.
+   * This is used primarily to automatically flush the JDBC batch.
+   */
+  public void registerGetterCallback(PreGetterCallback getterCallback) {
+    this.preGetterCallback = getterCallback;
+  }
+
   /**
    * Set the embedded beans owning bean.
    */
@@ -218,6 +236,18 @@ public final class EntityBeanIntercept implements Serializable {
     this.fullyLoadedBean = fullyLoadedBean;
   }
 
+  /**
+   * Check each property to see if the bean is partially loaded.
+   */
+  public boolean isPartial() {
+    for (int i = 0; i < loadedProps.length; i++) {
+      if (!loadedProps[i]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Return true if this bean has been directly modified (it has oldValues) or
    * if any embedded beans are either new or dirty (and hence need saving).
@@ -312,6 +342,13 @@ public final class EntityBeanIntercept implements Serializable {
     return state == STATE_LOADED;
   }
 
+  /**
+   * Set the bean into NEW state.
+   */
+  public void setNew() {
+    this.state = STATE_NEW;
+  }
+
   /**
    * Set the loaded state to true.
    * <p>
@@ -342,18 +379,11 @@ public final class EntityBeanIntercept implements Serializable {
   }
 
   /**
-   * Check if the lazy load succeeded. If not then mark this bean as having
-   * failed lazy loading due to the underlying row being deleted.
-   * <p>
-   * We mark the bean this way rather than immediately fail as we might be batch
-   * lazy loading and this bean might not be used by the client code at all.
-   * Instead we will fail as soon as the client code tries to use this bean.
-   * </p>
+   * Set lazy load failure flag.
    */
-  public void checkLazyLoadFailure() {
-    if (lazyLoadProperty != -1) {
-      this.lazyLoadFailure = true;
-    }
+  public void setLazyLoadFailure(Object ownerId) {
+    this.lazyLoadFailure = true;
+    this.ownerId = ownerId;
   }
 
   /**
@@ -475,7 +505,7 @@ public final class EntityBeanIntercept implements Serializable {
   public void setLoadedProperty(int propertyIndex) {
     loadedProps[propertyIndex] = true;
   }
-  
+
   /**
    * Return true if the property is loaded.
    */
@@ -507,7 +537,7 @@ public final class EntityBeanIntercept implements Serializable {
     setDirty(true);
   }
   
-  private void setChangedProperty(int propertyIndex) {
+  public void setChangedProperty(int propertyIndex) {
     if (changedProps == null) {
       changedProps = new boolean[owner._ebean_getPropertyNames().length];
     }
@@ -566,6 +596,23 @@ public final class EntityBeanIntercept implements Serializable {
     return props;
   }
 
+  /**
+   * Return the array of flags indicating the dirty properties.
+   */
+  public boolean[] getDirtyProperties() {
+    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;
+      }
+    }
+    return dirties;
+  }
+
   /**
    * Return the set of dirty properties.
    */
@@ -748,7 +795,7 @@ public final class EntityBeanIntercept implements Serializable {
 
     if (lazyLoadFailure) {
       // failed when batch lazy loaded by another bean in the batch
-      throw new EntityNotFoundException("Bean has been deleted - lazy loading failed");
+      throw new EntityNotFoundException("Lazy loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted");
     }
 
     if (lazyLoadProperty == -1) {
@@ -763,7 +810,7 @@ public final class EntityBeanIntercept implements Serializable {
 
       if (lazyLoadFailure) {
         // failed when lazy loading this bean
-        throw new EntityNotFoundException("Bean has been deleted - lazy loading failed");
+        throw new EntityNotFoundException("Lazy loading failed on type:" + owner.getClass().getName() + " id:" + ownerId + " - Bean has been deleted.");
       }
 
       // bean should be loaded and intercepting now. setLoaded() has
@@ -809,19 +856,31 @@ public final class EntityBeanIntercept implements Serializable {
   public void initialisedMany(int propertyIndex) {
     loadedProps[propertyIndex] = true;
   }
-  
+
+  private final void preGetterCallback() {
+    if (preGetterCallback != null) {
+      preGetterCallback.preGetterTrigger();
+    }
+  }
+
+  /**
+   * Called prior to Id property getter.
+   */
+  public void preGetId() {
+    preGetterCallback();
+  }
+
   /**
    * Method that is called prior to a getter method on the actual entity.
    */
   public void preGetter(int propertyIndex) {
+    preGetterCallback();
     if (state == STATE_NEW || disableLazyLoad) {
       return;
     }
-    
     if (!isLoadedProperty(propertyIndex)) {
       loadBean(propertyIndex);
     }
-
     if (nodeUsageCollector != null) {
       nodeUsageCollector.addUsed(getProperty(propertyIndex));
     }

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

@@ -10,31 +10,31 @@ package com.avaje.ebean.bean;
 public interface PersistenceContext {
 
   /**
-   * Put the entity bean into the PersistanceContext.
+   * Put the entity bean into the PersistenceContext.
    */
-  void put(Object id, Object bean);
+  void put(Class<?> rootType, Object id, Object bean);
 
   /**
-   * Put the entity bean into the PersistanceContext if one is not already
+   * Put the entity bean into the PersistenceContext if one is not already
    * present (for this id).
    * <p>
    * Returns an existing entity bean (if one is already there) and otherwise
    * returns null.
    * </p>
    */
-  Object putIfAbsent(Object id, Object bean);
+  Object putIfAbsent(Class<?> rootType, Object id, Object bean);
 
   /**
    * Return an object given its type and unique id.
    */
-  Object get(Class<?> beanType, Object uid);
+  Object get(Class<?> rootType, Object uid);
 
   /**
    * Get the bean from the persistence context also checked to see if it had
    * been previously deleted (if so then you also can't hit the L2 cache to
    * fetch the bean for this particular persistence context).
    */
-  WithOption getWithOption(Class<?> beanType, Object uid);
+  WithOption getWithOption(Class<?> rootType, Object uid);
 
   /**
    * Clear all the references.
@@ -44,22 +44,22 @@ public interface PersistenceContext {
   /**
    * Clear all the references for a given type of entity bean.
    */
-  void clear(Class<?> beanType);
+  void clear(Class<?> rootType);
 
   /**
    * Clear the reference to a specific entity bean.
    */
-  void clear(Class<?> beanType, Object uid);
+  void clear(Class<?> rootType, Object uid);
 
   /**
    * Clear the reference as a result of an entity being deleted.
    */
-  void deleted(Class<?> beanType, Object id);
+  void deleted(Class<?> rootType, Object id);
 
   /**
    * Return the number of beans of the given type in the persistence context.
    */
-  int size(Class<?> beanType);
+  int size(Class<?> rootType);
 
   /**
    * Wrapper on a bean to also indicate if a bean has been deleted.

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

@@ -0,0 +1,21 @@
+package com.avaje.ebean.bean;
+
+import javax.persistence.Entity;
+
+/**
+ * Utility to find the root bean type.
+ */
+public class PersistenceContextUtil {
+
+  /**
+   * Find and return the root bean type for the given class.
+   */
+  public static Class<?> root(Class<?> beanType) {
+    Class<?> parent = beanType.getSuperclass();
+    while (parent != null && parent.isAnnotationPresent(Entity.class)) {
+      beanType = parent;
+      parent = parent.getSuperclass();
+    }
+    return beanType;
+  }
+}

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

@@ -0,0 +1,13 @@
+package com.avaje.ebean.bean;
+
+/**
+ * A callback that can be registered to fire on getter method calls.
+ * It's primary purpose is to automatically flush JDBC batch buffer.
+ */
+public interface PreGetterCallback {
+
+  /**
+   * Trigger the callback.
+   */
+  void preGetterTrigger();
+}

src/main/java/com/avaje/ebean/cache/ServerCache.java

@@ -1,7 +1,5 @@
 package com.avaje.ebean.cache;
 
-import com.avaje.ebean.EbeanServer;
-
 /**
  * Represents part of the "L2" server side cache.
  * <p>
@@ -17,27 +15,6 @@ import com.avaje.ebean.EbeanServer;
  */
 public interface ServerCache {
 
-  /**
-   * Just after a cache is created this init method is called. This is so that a
-   * cache implementation can make use of the BackgroundExecutor service to
-   * trim/cleanup itself or use the EbeanServer to populate itself.
-   * <p>
-   * This method is called after the cache is constructed but before the cache
-   * is made available for use.
-   * </p>
-   */
-  void init(EbeanServer ebeanServer);
-
-  /**
-   * Return the configuration options for this cache.
-   */
-  ServerCacheOptions getOptions();
-
-  /**
-   * Update the configuration options for this cache.
-   */
-  void setOptions(ServerCacheOptions options);
-
   /**
    * Return the value given the key.
    */

src/main/java/com/avaje/ebean/cache/ServerCacheFactory.java

@@ -1,26 +1,13 @@
 package com.avaje.ebean.cache;
 
-import com.avaje.ebean.EbeanServer;
-
 /**
  * Defines method for constructing caches for beans and queries.
  */
 public interface ServerCacheFactory {
 
-  /**
-   * Just after the ServerCacheFactory is constructed this method is called
-   * passing the EbeanServer.
-   * <p>
-   * This is so that a cache implementation can utilise the EbeanServer to
-   * populate itself or use the BackgroundExecutor service to schedule periodic
-   * cache trimming/cleanup.
-   * </p>
-   */
-  void init(EbeanServer ebeanServer);
-
   /**
    * Create the cache for the given type with options.
    */
-  ServerCache createCache(String cacheKey, ServerCacheOptions cacheOptions);
+  ServerCache createCache(ServerCacheType type, String cacheKey, ServerCacheOptions cacheOptions);
 
 }

src/main/java/com/avaje/ebean/cache/ServerCacheManager.java

@@ -1,24 +1,18 @@
 package com.avaje.ebean.cache;
 
-import com.avaje.ebean.EbeanServer;
-
 /**
  * The cache service for server side caching of beans and query results.
  */
 public interface ServerCacheManager {
 
   /**
-   * This method is called just after the construction of the
-   * ServerCacheManager.
+   * Return true if the L2 caching is local.
    * <p>
-   * The EbeanServer is provided so that cache implementations can make use of
-   * EbeanServer and BackgroundExecutor for automatically populating and
-   * background trimming of the cache.
+   * Local L2 caching means that the cache updates should occur in foreground
+   * rather than background processing.
    * </p>
    */
-  void init(EbeanServer server);
-
-  void setCaching(Class<?> beanType, boolean useCache);
+  boolean isLocalL2Caching();
 
   /**
    * Return true if there is an active bean cache for this type of bean.
@@ -35,6 +29,9 @@ public interface ServerCacheManager {
    */
   ServerCache getBeanCache(Class<?> beanType);
 
+  /**
+   * Return the cache for associated many properties of a bean type.
+   */
   ServerCache getCollectionIdsCache(Class<?> beanType, String propertyName);
 
   /**

src/main/java/com/avaje/ebean/cache/ServerCacheOptions.java

@@ -1,6 +1,7 @@
 package com.avaje.ebean.cache;
 
-import com.avaje.ebean.annotation.CacheTuning;
+import com.avaje.ebean.annotation.CacheQueryTuning;
+import com.avaje.ebean.annotation.CacheBeanTuning;
 
 /**
  * Options for controlling a cache.
@@ -22,23 +23,23 @@ public class ServerCacheOptions {
   /**
    * Create from the cacheTuning deployment annotation.
    */
-  public ServerCacheOptions(CacheTuning cacheTuning) {
+  public ServerCacheOptions(CacheBeanTuning tuning) {
+    this.maxSize = tuning.maxSize();
+    this.maxIdleSecs = tuning.maxIdleSecs();
+    this.maxSecsToLive = tuning.maxSecsToLive();
+    this.trimFrequency = tuning.trimFrequency();
+  }
+
+  /**
+   * Create from the cacheTuning deployment annotation.
+   */
+  public ServerCacheOptions(CacheQueryTuning cacheTuning) {
     this.maxSize = cacheTuning.maxSize();
     this.maxIdleSecs = cacheTuning.maxIdleSecs();
     this.maxSecsToLive = cacheTuning.maxSecsToLive();
     this.trimFrequency = cacheTuning.trimFrequency();
   }
 
-  /**
-   * Create merging default options with the deployment specified ones.
-   */
-  public ServerCacheOptions(ServerCacheOptions defaults) {
-    this.maxSize = defaults.getMaxSize();
-    this.maxIdleSecs = defaults.getMaxIdleSecs();
-    this.maxSecsToLive = defaults.getMaxIdleSecs();
-    this.trimFrequency = defaults.getTrimFrequency();
-  }
-
   /**
    * Apply any settings from the default settings that have not already been
    * specifically set.

src/main/java/com/avaje/ebean/cache/ServerCachePlugin.java

@@ -0,0 +1,15 @@
+package com.avaje.ebean.cache;
+
+import com.avaje.ebean.BackgroundExecutor;
+import com.avaje.ebean.config.ServerConfig;
+
+/**
+ * The plugin interface that creates a ServerCacheFactory.
+ */
+public interface ServerCachePlugin {
+
+  /**
+   * Create the ServerCacheFactory given the server config and background executor service.
+   */
+  ServerCacheFactory create(ServerConfig config, BackgroundExecutor executor);
+}

src/main/java/com/avaje/ebean/cache/ServerCacheType.java

@@ -0,0 +1,27 @@
+package com.avaje.ebean.cache;
+
+/**
+ * The type of L2 caches.
+ */
+public enum ServerCacheType {
+
+  /**
+   * Bean cache.
+   */
+  BEAN,
+
+  /**
+   * Natural key cache.
+   */
+  NATURAL_KEY,
+
+  /**
+   * Collection Ids for Many properties.
+   */
+  COLLECTION_IDS,
+
+  /**
+   * Query cache.
+   */
+  QUERY
+}

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

@@ -1,16 +1,14 @@
 package com.avaje.ebean.common;
 
-import java.util.Set;
-
-import javax.persistence.PersistenceException;
-
 import com.avaje.ebean.Ebean;
 import com.avaje.ebean.ExpressionList;
 import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.BeanCollectionTouched;
 import com.avaje.ebean.bean.EntityBean;
 
+import javax.persistence.PersistenceException;
+import java.util.Set;
+
 /**
  * Base class for List Set and Map implementations of BeanCollection.
  * 
@@ -22,6 +20,8 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
 
   protected boolean readOnly;
 
+  protected boolean disableLazyLoad;
+
   /**
    * The EbeanServer this is associated with. (used for lazy fetch).
    */
@@ -36,8 +36,6 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
 
   protected String ebeanServerName;
 
-  protected transient BeanCollectionTouched beanCollectionTouched;
-
   /**
    * The owning bean (used for lazy fetch).
    */
@@ -55,12 +53,6 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
   protected boolean modifyRemoveListening;
   protected boolean modifyListening;
 
-  /**
-   * Flag used to tell if empty collections have been cleared etc or just
-   * uninitialised.
-   */
-  protected boolean touched;
-
   /**
    * Constructor not non-lazy loading collection.
    */
@@ -94,6 +86,11 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     this.filterMany = filterMany;
   }
 
+  @Override
+  public void setDisableLazyLoad(boolean disableLazyLoad) {
+    this.disableLazyLoad = disableLazyLoad;
+  }
+
   protected void lazyLoadCollection(boolean onlyIds) {
     if (loader == null) {
       loader = (BeanCollectionLoader) Ebean.getServer(ebeanServerName);
@@ -109,25 +106,6 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
     checkEmptyLazyLoad();
   }
 
-  /**
-   * Set touched. If setFlag is false then typically an isEmpty() call and still
-   * considering that to be untouched.
-   */
-  protected void touched(boolean setFlag) {
-    if (setFlag) {
-      touched = true;
-    }
-    if (beanCollectionTouched != null) {
-      // only call this once
-      beanCollectionTouched.notifyTouched(this);
-      beanCollectionTouched = null;
-    }
-  }
-
-  public void setBeanCollectionTouched(BeanCollectionTouched notify) {
-    this.beanCollectionTouched = notify;
-  }
-
   public boolean isRegisteredWithLoadContext() {
     return registeredWithLoadContext;
   }
@@ -219,4 +197,11 @@ public abstract class AbstractBeanCollection<E> implements BeanCollection<E> {
       return modifyHolder.getModifyRemovals();
     }
   }
+
+  /**
+   * Return true if there are underlying additions or removals.
+   */
+  public boolean holdsModifications() {
+    return modifyHolder != null && modifyHolder.hasModifications();
+  }
 }

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

@@ -1,5 +1,10 @@
 package com.avaje.ebean.common;
 
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.bean.BeanCollectionAdd;
+import com.avaje.ebean.bean.BeanCollectionLoader;
+import com.avaje.ebean.bean.EntityBean;
+
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -8,17 +13,13 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 
-import com.avaje.ebean.bean.BeanCollectionAdd;
-import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
-
 /**
  * List capable of lazy loading.
  */
 public final class BeanList<E> extends AbstractBeanCollection<E> implements List<E>, BeanCollectionAdd {
 
   private static final long serialVersionUID = 1L;
-  
+
   /**
    * The underlying List implementation.
    */
@@ -51,12 +52,11 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
     this.list = null;
-    this.touched = false;
   }
 
   @Override
-  public boolean isEmptyAndUntouched() {
-    return !touched && (list == null || list.isEmpty());
+  public boolean isSkipSave() {
+    return list == null || (list.isEmpty() && !holdsModifications());
   }
 
   @SuppressWarnings("unchecked")
@@ -64,6 +64,15 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     list.add((E) bean);
   }
 
+  @Override
+  @SuppressWarnings("unchecked")
+  public void loadFrom(BeanCollection<?> other) {
+    if (list == null) {
+      list = new ArrayList<E>();
+    }
+    list.addAll((Collection<? extends E>) other.getActualDetails());
+  }
+
   @SuppressWarnings("unchecked")
   public void internalAdd(Object bean) {
     if (list == null) {
@@ -74,6 +83,13 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
     }
   }
 
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    if (list == null || !list.contains(bean)) {
+      internalAdd(bean);
+    }
+  }
+
   public boolean checkEmptyLazyLoad() {
     if (list == null) {
       list = new ArrayList<E>();
@@ -86,30 +102,24 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   private void initClear() {
     synchronized (this) {
       if (list == null) {
-        if (modifyListening) {
+        if (!disableLazyLoad && modifyListening) {
           lazyLoadCollection(true);
         } else {
           list = new ArrayList<E>();
         }
       }
-      touched(true);
     }
   }
 
-  private void initAsUntouched() {
-    init(false);
-  }
-  
   private void init() {
-    init(true);
-  }
-  
-  private void init(boolean setTouched) {
     synchronized (this) {
       if (list == null) {
-        lazyLoadCollection(false);
+        if (disableLazyLoad) {
+          list = new ArrayList<E>();
+        } else {
+          lazyLoadCollection(false);
+        }
       }
-      touched(setTouched);
     }
   }
 
@@ -134,7 +144,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   public Collection<E> getActualDetails() {
     return list;
   }
-  
+
   @Override
   public Collection<?> getActualEntries() {
     return list;
@@ -279,7 +289,7 @@ public final class BeanList<E> extends AbstractBeanCollection<E> implements List
   }
 
   public boolean isEmpty() {
-    initAsUntouched();
+    init();
     return list.isEmpty();
   }
 

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

@@ -1,5 +1,6 @@
 package com.avaje.ebean.common;
 
+import com.avaje.ebean.bean.BeanCollection;
 import com.avaje.ebean.bean.BeanCollectionLoader;
 import com.avaje.ebean.bean.EntityBean;
 
@@ -44,11 +45,18 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
     this.map = null;
-    this.touched = false;
   }
 
-  public boolean isEmptyAndUntouched() {
-    return !touched && (map == null || map.isEmpty());
+  public boolean isSkipSave() {
+    return map == null || (map.isEmpty() && !holdsModifications());
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public void loadFrom(BeanCollection<?> other) {
+    BeanMap<K,E> otherMap = (BeanMap<K,E>)other;
+    internalPutNull();
+    map.putAll(otherMap.getActualMap());
   }
 
   public void internalPutNull() {
@@ -66,7 +74,18 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
       map.put((K) key, (E) bean);
     }
   }
-  
+
+  public void internalPutWithCheck(Object key, Object bean) {
+    if (map == null || !map.containsKey(key)) {
+      internalPut(key, bean);
+    }
+  }
+
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    throw new RuntimeException("Not allowed for map");
+  }
+
   public void internalAdd(Object bean) {
     throw new RuntimeException("Not allowed for map");
   }
@@ -105,24 +124,14 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
           map = new LinkedHashMap<K, E>();
         }
       }
-      touched(true);
     }
   }
 
-  private void initAsUntouched() {
-    init(false);
-  }
-  
   private void init() {
-    init(true);
-  }
-  
-  private void init(boolean setTouched) {
     synchronized (this) {
       if (map == null) {
         lazyLoadCollection(false);
       }
-      touched(setTouched);
     }
   }
 
@@ -229,7 +238,7 @@ public final class BeanMap<K, E> extends AbstractBeanCollection<E> implements Ma
   }
 
   public boolean isEmpty() {
-    initAsUntouched();
+    init();
     return map.isEmpty();
   }
 

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

@@ -1,15 +1,16 @@
 package com.avaje.ebean.common;
 
+import com.avaje.ebean.bean.BeanCollection;
+import com.avaje.ebean.bean.BeanCollectionAdd;
+import com.avaje.ebean.bean.BeanCollectionLoader;
+import com.avaje.ebean.bean.EntityBean;
+
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Set;
 
-import com.avaje.ebean.bean.BeanCollectionAdd;
-import com.avaje.ebean.bean.BeanCollectionLoader;
-import com.avaje.ebean.bean.EntityBean;
-
 /**
  * Set capable of lazy loading.
  */
@@ -45,11 +46,10 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
     this.ownerBean = ownerBean;
     this.propertyName = propertyName;
     this.set = null;
-    this.touched = false;
   }
 
-  public boolean isEmptyAndUntouched() {
-    return !touched && (set == null || set.isEmpty());
+  public boolean isSkipSave() {
+    return set == null || (set.isEmpty() && !holdsModifications());
   }
 
   @SuppressWarnings("unchecked")
@@ -57,6 +57,22 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
     set.add((E) bean);
   }
 
+  @Override
+  @SuppressWarnings("unchecked")
+  public void loadFrom(BeanCollection<?> other) {
+    if (set == null) {
+      set = new LinkedHashSet<E>();
+    }
+    set.addAll((Collection<? extends E>) other.getActualDetails());
+  }
+
+  @Override
+  public void internalAddWithCheck(Object bean) {
+    if (set == null || !set.contains(bean)) {
+      internalAdd(bean);
+    }
+  }
+
   @SuppressWarnings("unchecked")
   public void internalAdd(Object bean) {
     if (set == null) {
@@ -100,24 +116,14 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
           set = new LinkedHashSet<E>();
         }
       }
-      touched(true);
     }
   }
 
-  private void initAsUntouched() {
-    init(false);
-  }
-  
   private void init() {
-    init(true);
-  }
-  
-  private void init(boolean setTouched) {
     synchronized (this) {
       if (set == null) {
         lazyLoadCollection(true);
       }
-      touched(setTouched);
     }
   }
 
@@ -243,7 +249,7 @@ public final class BeanSet<E> extends AbstractBeanCollection<E> implements Set<E
   }
 
   public boolean isEmpty() {
-    initAsUntouched();
+    init();
     return set.isEmpty();
   }
 

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

@@ -71,4 +71,11 @@ class ModifyHolder<E> implements Serializable {
   Set<E> getModifyRemovals() {
     return modifyDeletions;
   }
+
+  /**
+   * Return true if there additions or removals.
+   */
+  boolean hasModifications() {
+    return !modifyDeletions.isEmpty() || !modifyAdditions.isEmpty();
+  }
 }

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

@@ -274,7 +274,7 @@ public abstract class AbstractNamingConvention implements NamingConvention {
    * Checks string is null or empty .
    */
   protected boolean isEmpty(String s) {
-    return s == null || s.trim().length() == 0;
+    return s == null || s.trim().isEmpty();
   }
 
   /**

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

@@ -21,9 +21,13 @@ public class AutoTuneConfig {
 
   private double profilingRate = 0.01;
 
+  private int profilingUpdateFrequency;
+
   private int garbageCollectionWait = 100;
   
-  private boolean skipCollectionOnShutdown;
+  private boolean skipGarbageCollectionOnShutdown;
+
+  private boolean skipProfileReportingOnShutdown;
 
   public AutoTuneConfig() {
   }
@@ -56,6 +60,20 @@ public class AutoTuneConfig {
     this.profilingFile = profilingFile;
   }
 
+  /**
+   * Return the frequency in seconds the profiling should be collected and automatically applied to the tuning.
+   */
+  public int getProfilingUpdateFrequency() {
+    return profilingUpdateFrequency;
+  }
+
+  /**
+   * Set the frequency in seconds the profiling should be collected and automatically applied to the tuning.
+   */
+  public void setProfilingUpdateFrequency(int profilingUpdateFrequency) {
+    this.profilingUpdateFrequency = profilingUpdateFrequency;
+  }
+
   /**
    * Return the mode used when autoTune has not been explicit defined on a
    * query.
@@ -184,17 +202,33 @@ public class AutoTuneConfig {
   }
 
   /**
-   * Return true if profiling collection should be skipped on shutdown.
+   * Return true if triggering garbage collection should be skipped on shutdown.
+   * You might set this when System.GC() slows a application shutdown too much.
    */
-  public boolean isSkipCollectionOnShutdown() {
-    return skipCollectionOnShutdown;
+  public boolean isSkipGarbageCollectionOnShutdown() {
+    return skipGarbageCollectionOnShutdown;
   }
 
   /**
-   * Set to true if profiling collection should be skipped on shutdown.
+   * Set to true if triggering garbage collection should be skipped on shutdown.
+   * You might set this when System.GC() slows a application shutdown too much.
    */
-  public void setSkipCollectionOnShutdown(boolean skipCollectionOnShutdown) {
-    this.skipCollectionOnShutdown = skipCollectionOnShutdown;
+  public void setSkipGarbageCollectionOnShutdown(boolean skipGarbageCollectionOnShutdown) {
+    this.skipGarbageCollectionOnShutdown = skipGarbageCollectionOnShutdown;
+  }
+
+  /**
+   * Return true if profile reporting should be skipped on shutdown.
+   */
+  public boolean isSkipProfileReportingOnShutdown() {
+    return skipProfileReportingOnShutdown;
+  }
+
+  /**
+   * Set to true if profile reporting should be skipped on shutdown.
+   */
+  public void setSkipProfileReportingOnShutdown(boolean skipProfileReportingOnShutdown) {
+    this.skipProfileReportingOnShutdown = skipProfileReportingOnShutdown;
   }
 
   /**
@@ -206,13 +240,15 @@ public class AutoTuneConfig {
     queryTuningAddVersion = p.getBoolean("autoTune.queryTuningAddVersion", queryTuningAddVersion);
     queryTuningFile = p.get("autoTune.queryTuningFile", queryTuningFile);
 
-    skipCollectionOnShutdown = p.getBoolean("autoTune.skipCollectionOnShutdown", skipCollectionOnShutdown);
-    
+    skipGarbageCollectionOnShutdown = p.getBoolean("autoTune.skipGarbageCollectionOnShutdown", skipGarbageCollectionOnShutdown);
+    skipProfileReportingOnShutdown = p.getBoolean("autoTune.skipProfileReportingOnShutdown", skipProfileReportingOnShutdown);
+
     mode = p.getEnum(AutoTuneMode.class, "autoTune.mode", mode);
 
     profiling = p.getBoolean("autoTune.profiling", profiling);
     profilingBase = p.getInt("autoTune.profilingBase", profilingBase);
     profilingRate = p.getDouble("autoTune.profilingRate", profilingRate);
     profilingFile = p.get("autoTune.profilingFile", profilingFile);
+    profilingUpdateFrequency = p.getInt("autoTune.profilingUpdateFrequency", profilingUpdateFrequency);
   }
 }

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

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

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

@@ -1,7 +1,5 @@
 package com.avaje.ebean.config;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Properties;
 
 /**
@@ -12,453 +10,51 @@ import java.util.Properties;
  */
 public class ContainerConfig {
 
+  protected boolean clusterActive;
+
+  protected Properties properties;
+
   /**
-   * Communication mode used for clustering.
+   * Return true if clustering is active.
    */
-  public enum ClusterMode {
-
-    /**
-     * No clustering.
-     */
-    NONE,
-
-    /**
-     * Use Multicast networking for cluster wide communication.
-     */
-    MULTICAST,
-
-    /**
-     * Use TCP Sockets for cluster wide communication.
-     */
-    SOCKET
+  public boolean isClusterActive() {
+    return clusterActive;
   }
 
   /**
-   * The cluster mode to use.
+   * Set to true for clustering to be active.
    */
-  ClusterMode mode = ClusterMode.NONE;
-
-  /**
-   * Configuration if using TCP sockets for clustering communication.
-   */
-  SocketConfig socketConfig = new SocketConfig();
-
-  /**
-   * Configuration if using Multicast for clustering communication.
-   */
-  MulticastConfig multicastConfig = new MulticastConfig();
-
-
-  // -------------------------------------------------------------------------------------------
-  // MulticastConfig
-
-  /**
-   * The configuration for clustering using Multicast networking.
-   */
-  public static class MulticastConfig {
-
-    int managerSleepMillis = 80;
-    int lastSendTimeFreqSecs = 300;//5mins
-    int lastStatusTimeFreqSecs = 600;//10mins
-    int maxResendOutgoingAttempts = 200;
-    int maxResendIncomingRequests = 50;
-
-    int listenPort;
-    String listenAddress;
-    int sendPort;
-    String sendAddress;
-
-    // Note 1500 is Ethernet MTU and this must be less than UDP max packet size of 65507
-    int maxSendPacketSize = 1500;
-
-    // Whether to send packets even when there are no other members online
-    boolean sendWithNoMembers = true;
-
-    // When multiple instances are on same box you need to broadcast back locally
-    boolean disableLoopback;
-    int listenTimeToLive = -1;
-    int listenTimeout = 1000;
-    int listenBufferSize = 65500;
-    // For multihomed environment the address the listener should bind to
-    String listenBindAddress;
-
-    /**
-     * Return the manager sleep millis.
-     */
-    public int getManagerSleepMillis() {
-      return managerSleepMillis;
-    }
-
-    /**
-     * Set the manager sleep millis.
-     */
-    public void setManagerSleepMillis(int managerSleepMillis) {
-      this.managerSleepMillis = managerSleepMillis;
-    }
-
-    /**
-     * Return the last send time frequency.
-     */
-    public int getLastSendTimeFreqSecs() {
-      return lastSendTimeFreqSecs;
-    }
-
-    /**
-     * Set the last send time frequency.
-     */
-    public void setLastSendTimeFreqSecs(int lastSendTimeFreqSecs) {
-      this.lastSendTimeFreqSecs = lastSendTimeFreqSecs;
-    }
-
-    /**
-     * Return the last status time frequency.
-     */
-    public int getLastStatusTimeFreqSecs() {
-      return lastStatusTimeFreqSecs;
-    }
-
-    /**
-     * Set the last status time frequency.
-     */
-    public void setLastStatusTimeFreqSecs(int lastStatusTimeFreqSecs) {
-      this.lastStatusTimeFreqSecs = lastStatusTimeFreqSecs;
-    }
-
-    /**
-     * Return the maximum number of times we will try to re-send a given packet before giving up sending
-     */
-    public int getMaxResendOutgoingAttempts() {
-      return maxResendOutgoingAttempts;
-    }
-
-    /**
-     * Set the maximum retry attempts for outgoing messages.
-     */
-    public void setMaxResendOutgoingAttempts(int maxResendOutgoingAttempts) {
-      this.maxResendOutgoingAttempts = maxResendOutgoingAttempts;
-    }
-
-    /**
-     * Return the maximum number of times we will ask for a packet to be resent to us before giving up asking.
-     */
-    public int getMaxResendIncomingRequests() {
-      return maxResendIncomingRequests;
-    }
-
-    /**
-     * Set the maximum retry attempts for incoming messages.
-     */
-    public void setMaxResendIncomingRequests(int maxResendIncomingRequests) {
-      this.maxResendIncomingRequests = maxResendIncomingRequests;
-    }
-
-    /**
-     * Return the listen port.
-     */
-    public int getListenPort() {
-      return listenPort;
-    }
-
-    /**
-     * Set the listen port.
-     */
-    public void setListenPort(int port) {
-      this.listenPort = port;
-    }
-
-    /**
-     * Return the listen address.
-     */
-    public String getListenAddress() {
-      return listenAddress;
-    }
-
-    /**
-     * Set the listen address.
-     */
-    public void setListenAddress(String listenAddress) {
-      this.listenAddress = listenAddress;
-    }
-
-    /**
-     * Return the send port.
-     */
-    public int getSendPort() {
-      return sendPort;
-    }
-
-    /**
-     * Set the send port.
-     */
-    public void setSendPort(int sendPort) {
-      this.sendPort = sendPort;
-    }
-
-    /**
-     * Return the send address.
-     */
-    public String getSendAddress() {
-      return sendAddress;
-    }
-
-    /**
-     * Set the send address.
-     */
-    public void setSendAddress(String sendAddress) {
-      this.sendAddress = sendAddress;
-    }
-
-    /**
-     * Return the maximum send packet size.
-     */
-    public int getMaxSendPacketSize() {
-      return maxSendPacketSize;
-    }
-
-    /**
-     * Set the maximum send packet size.  Note 1500 is Ethernet MTU and this must be less than UDP max packet size of 65507.
-     */
-    public void setMaxSendPacketSize(int maxSendPacketSize) {
-      this.maxSendPacketSize = maxSendPacketSize;
-    }
-
-    /**
-     * Return true if send messages when no other members in the cluster are up.
-     */
-    public boolean isSendWithNoMembers() {
-      return sendWithNoMembers;
-    }
-
-    /**
-     * Set true if send messages when no other members in the cluster are up.
-     */
-    public void setSendWithNoMembers(boolean sendWithNoMembers) {
-      this.sendWithNoMembers = sendWithNoMembers;
-    }
-
-    /**
-     * Return true if loopback is disabled. When multiple instances are on same box you need to broadcast back locally.
-     */
-    public boolean isDisableLoopback() {
-      return disableLoopback;
-    }
-
-    /**
-     * Set if loopback is disabled. When multiple instances are on same box you need to broadcast back locally.
-     */
-    public void setDisableLoopback(boolean disableLoopback) {
-      this.disableLoopback = disableLoopback;
-    }
-
-    /**
-     * Return the listen time to live.
-     */
-    public int getListenTimeToLive() {
-      return listenTimeToLive;
-    }
-
-    /**
-     * Set the listen time to live.
-     */
-    public void setListenTimeToLive(int listenTimeToLive) {
-      this.listenTimeToLive = listenTimeToLive;
-    }
-
-    /**
-     * Return the listen timeout.
-     */
-    public int getListenTimeout() {
-      return listenTimeout;
-    }
-
-    /**
-     * set the listen timeout.
-     */
-    public void setListenTimeout(int listenTimeout) {
-      this.listenTimeout = listenTimeout;
-    }
-
-    /**
-     * Return the listen buffer size.
-     */
-    public int getListenBufferSize() {
-      return listenBufferSize;
-    }
-
-    /**
-     * Set the listen buffer size.
-     */
-    public void setListenBufferSize(int listenBufferSize) {
-      this.listenBufferSize = listenBufferSize;
-    }
-
-    /**
-     * Return the listener bind address (optional). For multihomed environment the address the listener should bind to.
-     */
-    public String getListenBindAddress() {
-      return listenBindAddress;
-    }
-
-    /**
-     * Set the listener bind address (optional). For multihomed environment the address the listener should bind to.
-     */
-    public void setListenBindAddress(String listenBindAddress) {
-      this.listenBindAddress = listenBindAddress;
-    }
+  public void setClusterActive(boolean clusterActive) {
+    this.clusterActive = clusterActive;
   }
 
-  // -------------------------------------------------------------------------------------------
-  // SocketConfig
-
   /**
-   * Configuration for clustering using TCP sockets.
-   * <p>
-   * This is good for when there are relatively small number of cluster members.
+   * Return the deployment properties.
    */
-  public static class SocketConfig {
-
-    /**
-     * This local server in host:port format.
-     */
-    String localHostPort;
-
-    /**
-     * All the cluster members in host:port format.
-     */
-    List<String> members = new ArrayList<String>();
-
-    /**
-     * core threads for the associated thread pool.
-     */
-    int coreThreads = 2;
-
-    /**
-     * Max threads for the associated thread pool.
-     */
-    int maxThreads = 16;
-
-    String threadPoolName = "EbeanCluster";
-
-    /**
-     * Return the host and port for this server instance.
-     */
-    public String getLocalHostPort() {
-      return localHostPort;
-    }
-
-    /**
-     * Set the host and port for this server instance.
-     */
-    public void setLocalHostPort(String localHostPort) {
-      this.localHostPort = localHostPort;
-    }
-
-    /**
-     * Return all the host and port for all the members of the cluster.
-     */
-    public List<String> getMembers() {
-      return members;
-    }
-
-    /**
-     * Set all the host and port for all the members of the cluster.
-     */
-    public void setMembers(List<String> members) {
-      this.members = members;
-    }
-
-    /**
-     * Return the number of core threads to use.
-     */
-    public int getCoreThreads() {
-      return coreThreads;
-    }
-
-    /**
-     * Set the number of core threads to use.
-     */
-    public void setCoreThreads(int coreThreads) {
-      this.coreThreads = coreThreads;
-    }
-
-    /**
-     * Return the number of max threads to use.
-     */
-    public int getMaxThreads() {
-      return maxThreads;
-    }
-
-    /**
-     * Set the number of max threads to use.
-     */
-    public void setMaxThreads(int maxThreads) {
-      this.maxThreads = maxThreads;
-    }
-
-    /**
-     * Return the thread pool name.
-     */
-    public String getThreadPoolName() {
-      return threadPoolName;
-    }
-
-    /**
-     * Set the thread pool name.
-     */
-    public void setThreadPoolName(String threadPoolName) {
-      this.threadPoolName = threadPoolName;
-    }
+  public Properties getProperties() {
+    return properties;
   }
 
-  // -------------------------------------------------------------------------------------------
-  // Members
+  /**
+   * Set the deployment properties.
+   */
+  public void setProperties(Properties properties) {
+    this.properties = properties;
+  }
 
   /**
    * Load the settings from properties.
    */
   public void loadFromProperties(Properties properties) {
-    //TODO
+    this.properties = properties;
+    this.clusterActive = getProperty(properties, "ebean.cluster.active", clusterActive);
   }
 
   /**
-   * Return the cluster mode.
+   * Return the boolean property setting.
    */
-  public ClusterMode getMode() {
-    return mode;
+  protected boolean getProperty(Properties properties, String key, boolean defaultValue) {
+    return "true".equalsIgnoreCase(properties.getProperty(key, Boolean.toString(defaultValue)));
   }
 
-  /**
-   * Set the cluster mode.
-   */
-  public void setMode(ClusterMode mode) {
-    this.mode = mode;
-  }
-
-  /**
-   * Return the socket communication configuration.
-   */
-  public SocketConfig getSocketConfig() {
-    return socketConfig;
-  }
-
-  /**
-   * Set the socket communication configuration.
-   */
-  public void setSocketConfig(SocketConfig socketConfig) {
-    this.socketConfig = socketConfig;
-  }
-
-  /**
-   * Return the multicast communication configuration.
-   */
-  public MulticastConfig getMulticastConfig() {
-    return multicastConfig;
-  }
-
-  /**
-   * Set the multicast communication configuration.
-   */
-  public void setMulticastConfig(MulticastConfig multicastConfig) {
-    this.multicastConfig = multicastConfig;
-  }
 }

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

@@ -1,556 +0,0 @@
-package com.avaje.ebean.config;
-
-import java.sql.Connection;
-import java.util.Map;
-import java.util.Properties;
-
-import com.avaje.ebean.Transaction;
-import com.avaje.ebean.util.StringHelper;
-
-/**
- * Used to config a DataSource when using the internal Ebean DataSource
- * implementation.
- * <p>
- * If a DataSource instance is already defined via
- * {@link ServerConfig#setDataSource(javax.sql.DataSource)} or defined as JNDI
- * dataSource via {@link ServerConfig#setDataSourceJndiName(String)} then those
- * will used and not this DataSourceConfig.
- * </p>
- */
-public class DataSourceConfig {
-
-  private String url;
-
-  private String username;
-
-  private String password;
-
-  private String driver;
-
-  private int minConnections = 2;
-
-  private int maxConnections = 20;
-
-  private int isolationLevel = Transaction.READ_COMMITTED;
-
-  private boolean autoCommit;
-  
-  private String heartbeatSql;
-  
-  private int heartbeatFreqSecs = 30;
-  
-  private int heartbeatTimeoutSeconds = 3;
-  
-  private boolean captureStackTrace;
-
-  private int maxStackTraceSize = 5;
-
-  private int leakTimeMinutes = 30;
-
-  private int maxInactiveTimeSecs = 720;
-  
-  private int maxAgeMinutes = 0;
-  
-  private int trimPoolFreqSecs = 59;
-
-  private int pstmtCacheSize = 20;
-  
-  private int cstmtCacheSize = 20;
-
-  private int waitTimeoutMillis = 1000;
-  
-  private String poolListener;
-
-  private boolean offline;
-  
-  protected Map<String, String> customProperties;
-
-  /**
-   * Return the connection URL.
-   */
-  public String getUrl() {
-    return url;
-  }
-
-  /**
-   * Set the connection URL.
-   */
-  public void setUrl(String url) {
-    this.url = url;
-  }
-
-  /**
-   * Return the database username.
-   */
-  public String getUsername() {
-    return username;
-  }
-
-  /**
-   * Set the database username.
-   */
-  public void setUsername(String username) {
-    this.username = username;
-  }
-
-  /**
-   * Return the database password.
-   */
-  public String getPassword() {
-    return password;
-  }
-
-  /**
-   * Set the database password.
-   */
-  public void setPassword(String password) {
-    this.password = password;
-  }
-
-  /**
-   * Return the database driver.
-   */
-  public String getDriver() {
-    return driver;
-  }
-
-  /**
-   * Set the database driver.
-   */
-  public void setDriver(String driver) {
-    this.driver = driver;
-  }
-
-  /**
-   * Return the transaction isolation level.
-   */
-  public int getIsolationLevel() {
-    return isolationLevel;
-  }
-
-  /**
-   * Set the transaction isolation level.
-   */
-  public void setIsolationLevel(int isolationLevel) {
-    this.isolationLevel = isolationLevel;
-  }
-  
-  /**
-   * Return autoCommit setting.
-   */
-  public boolean isAutoCommit() {
-    return autoCommit;
-  }
-
-  /**
-   * Set to true to turn on autoCommit.
-   */
-  public void setAutoCommit(boolean autoCommit) {
-    this.autoCommit = autoCommit;
-  }
-
-  /**
-   * Return the minimum number of connections the pool should maintain.
-   */
-  public int getMinConnections() {
-    return minConnections;
-  }
-
-  /**
-   * Set the minimum number of connections the pool should maintain.
-   */
-  public void setMinConnections(int minConnections) {
-    this.minConnections = minConnections;
-  }
-
-  /**
-   * Return the maximum number of connections the pool can reach.
-   */
-  public int getMaxConnections() {
-    return maxConnections;
-  }
-
-  /**
-   * Set the maximum number of connections the pool can reach.
-   */
-  public void setMaxConnections(int maxConnections) {
-    this.maxConnections = maxConnections;
-  }
-
-  /**
-   * Return a SQL statement used to test the database is accessible.
-   * <p>
-   * Note that if this is not set then it can get defaulted from the
-   * DatabasePlatform.
-   * </p>
-   */
-  public String getHeartbeatSql() {
-    return heartbeatSql;
-  }
-
-  /**
-   * Set a SQL statement used to test the database is accessible.
-   * <p>
-   * Note that if this is not set then it can get defaulted from the
-   * DatabasePlatform.
-   * </p>
-   */
-  public void setHeartbeatSql(String heartbeatSql) {
-    this.heartbeatSql = heartbeatSql;
-  }
-
-  
-  /**
-   * Return the heartbeat frequency in seconds.
-   * <p>
-   * This is the expected frequency in which the DataSource should be checked to
-   * make sure it is healthy and trim idle connections.
-   * </p>
-   */
-  public int getHeartbeatFreqSecs() {
-    return heartbeatFreqSecs;
-  }
-
-  /**
-   * Set the expected heartbeat frequency in seconds.
-   */
-  public void setHeartbeatFreqSecs(int heartbeatFreqSecs) {
-    this.heartbeatFreqSecs = heartbeatFreqSecs;
-  }
-  
-  /**
-   * Return the heart beat timeout in seconds.
-   */
-  public int getHeartbeatTimeoutSeconds() {
-    return heartbeatTimeoutSeconds;
-  }
-
-  /**
-   * Set the heart beat timeout in seconds.
-   */
-  public void setHeartbeatTimeoutSeconds(int heartbeatTimeoutSeconds) {
-    this.heartbeatTimeoutSeconds = heartbeatTimeoutSeconds;
-  }
-
-  /**
-   * Return true if a stack trace should be captured when obtaining a connection
-   * from the pool.
-   * <p>
-   * This can be used to diagnose a suspected connection pool leak.
-   * </p>
-   * <p>
-   * Obviously this has a performance overhead.
-   * </p>
-   */
-  public boolean isCaptureStackTrace() {
-    return captureStackTrace;
-  }
-
-  /**
-   * Set to true if a stack trace should be captured when obtaining a connection
-   * from the pool.
-   * <p>
-   * This can be used to diagnose a suspected connection pool leak.
-   * </p>
-   * <p>
-   * Obviously this has a performance overhead.
-   * </p>
-   */
-  public void setCaptureStackTrace(boolean captureStackTrace) {
-    this.captureStackTrace = captureStackTrace;
-  }
-
-  /**
-   * Return the max size for reporting stack traces on busy connections.
-   */
-  public int getMaxStackTraceSize() {
-    return maxStackTraceSize;
-  }
-
-  /**
-   * Set the max size for reporting stack traces on busy connections.
-   */
-  public void setMaxStackTraceSize(int maxStackTraceSize) {
-    this.maxStackTraceSize = maxStackTraceSize;
-  }
-
-  /**
-   * Return the time in minutes after which a connection could be considered to
-   * have leaked.
-   */
-  public int getLeakTimeMinutes() {
-    return leakTimeMinutes;
-  }
-
-  /**
-   * Set the time in minutes after which a connection could be considered to
-   * have leaked.
-   */
-  public void setLeakTimeMinutes(int leakTimeMinutes) {
-    this.leakTimeMinutes = leakTimeMinutes;
-  }
-
-  /**
-   * Return the size of the PreparedStatement cache (per connection).
-   */
-  public int getPstmtCacheSize() {
-    return pstmtCacheSize;
-  }
-
-  /**
-   * Set the size of the PreparedStatement cache (per connection).
-   */
-  public void setPstmtCacheSize(int pstmtCacheSize) {
-    this.pstmtCacheSize = pstmtCacheSize;
-  }
-
-  /**
-   * Return the size of the CallableStatement cache (per connection).
-   */
-  public int getCstmtCacheSize() {
-    return cstmtCacheSize;
-  }
-
-  /**
-   * Set the size of the CallableStatement cache (per connection).
-   */
-  public void setCstmtCacheSize(int cstmtCacheSize) {
-    this.cstmtCacheSize = cstmtCacheSize;
-  }
-
-  /**
-   * Return the time in millis to wait for a connection before timing out once
-   * the pool has reached its maximum size.
-   */
-  public int getWaitTimeoutMillis() {
-    return waitTimeoutMillis;
-  }
-
-  /**
-   * Set the time in millis to wait for a connection before timing out once the
-   * pool has reached its maximum size.
-   */
-  public void setWaitTimeoutMillis(int waitTimeoutMillis) {
-    this.waitTimeoutMillis = waitTimeoutMillis;
-  }
-
-  /**
-   * Return the time in seconds a connection can be idle after which it can be
-   * trimmed from the pool.
-   * <p>
-   * This is so that the pool after a busy period can trend over time back
-   * towards the minimum connections.
-   * </p>
-   */
-  public int getMaxInactiveTimeSecs() {
-    return maxInactiveTimeSecs;
-  }
-
-  /**
-   * Return the maximum age a connection is allowed to be before it is closed.
-   * <p>
-   * This can be used to close really old connections.
-   * </p>
-   */
-  public int getMaxAgeMinutes() {
-    return maxAgeMinutes;
-  }
-  
-  /**
-   * Set the maximum age a connection can be in minutes.
-   */
-  public void setMaxAgeMinutes(int maxAgeMinutes) {
-    this.maxAgeMinutes = maxAgeMinutes;
-  }
-
-  /**
-   * Set the time in seconds a connection can be idle after which it can be
-   * trimmed from the pool.
-   * <p>
-   * This is so that the pool after a busy period can trend over time back
-   * towards the minimum connections.
-   * </p>
-   */
-  public void setMaxInactiveTimeSecs(int maxInactiveTimeSecs) {
-    this.maxInactiveTimeSecs = maxInactiveTimeSecs;
-  }
-
-  
-  /**
-   * Return the minimum time gap between pool trim checks.
-   * <p>
-   * This defaults to 59 seconds meaning that the pool trim check will run every
-   * minute assuming the heart beat check runs every 30 seconds.
-   * </p>
-   */
-  public int getTrimPoolFreqSecs() {
-    return trimPoolFreqSecs;
-  }
-
-  /**
-   * Set the minimum trim gap between pool trim checks.
-   */
-  public void setTrimPoolFreqSecs(int trimPoolFreqSecs) {
-    this.trimPoolFreqSecs = trimPoolFreqSecs;
-  }
-
-  /**
-   * Return the pool listener.
-   */
-  public String getPoolListener() {
-    return poolListener;
-  }
-
-  /**
-   * Set a pool listener.
-   */
-  public void setPoolListener(String poolListener) {
-    this.poolListener = poolListener;
-  }
-
-  /**
-   * Return true if the DataSource should be left offline.
-   * <p>
-   * This is to support DDL generation etc without having a real database.
-   * </p>
-   */
-  public boolean isOffline() {
-    return offline;
-  }
-
-  /**
-   * Set to true if the DataSource should be left offline.
-   * <p>
-   * This is to support DDL generation etc without having a real database.
-   * </p>
-   * <p>
-   * Note that you MUST specify the database platform name (oracle, postgres,
-   * h2, mysql etc) using {@link ServerConfig#setDatabasePlatformName(String)}
-   * when you do this.
-   * </p>
-   */
-  public void setOffline(boolean offline) {
-    this.offline = offline;
-  }
-  
-  /**
-   * Return a map of custom properties for the jdbc driver connection.
-   */
-  public Map<String, String> getCustomProperties() {
-    return customProperties;
-  }
-
-  /**
-   * Set custom properties for the jdbc driver connection.
-   * 
-   * @param customProperties
-   */
-  public void setCustomProperties(Map<String, String> customProperties) {
-    this.customProperties = customProperties;
-  }
-
-  /**
-   * Load the settings by reading the ebean.properties file.
-   *
-   * @param serverName name of the server
-   */
-  public void loadSettings(String serverName) {
-    loadSettings(new PropertiesWrapper("datasource", serverName, PropertyMap.defaultProperties()));
-  }
-
-  /**
-   * Load the settings from the properties supplied.
-   * <p>
-   * You can use this when you have your own properties to use for configuration.
-   * </p>
-   *
-   * @param properties the properties to configure the datasource
-   * @param serverName the name of the specific datasource (optional)
-   */
-  public void loadSettings(Properties properties, String serverName) {
-    PropertiesWrapper dbProps = new PropertiesWrapper("datasource", serverName, properties);
-    loadSettings(dbProps);
-  }
-
-  /**
-   * Load the settings from the PropertiesWrapper.
-   */
-  public void loadSettings(PropertiesWrapper properties) {
-
-    username = properties.get("username", username);
-    password = properties.get("password", password);
-    driver = properties.get("driver", properties.get("databaseDriver", driver));
-    url = properties.get("url", properties.get("databaseUrl", url));
-
-    autoCommit = properties.getBoolean("autoCommit", autoCommit);
-    captureStackTrace = properties.getBoolean("captureStackTrace", captureStackTrace);
-    maxStackTraceSize = properties.getInt("maxStackTraceSize", maxStackTraceSize);
-    leakTimeMinutes = properties.getInt("leakTimeMinutes", leakTimeMinutes);
-    maxInactiveTimeSecs = properties.getInt("maxInactiveTimeSecs", maxInactiveTimeSecs);
-    trimPoolFreqSecs = properties.getInt("trimPoolFreqSecs", trimPoolFreqSecs);
-    maxAgeMinutes = properties.getInt("maxAgeMinutes", maxAgeMinutes);
-
-    minConnections = properties.getInt("minConnections", minConnections);
-    maxConnections = properties.getInt("maxConnections", maxConnections);
-    pstmtCacheSize = properties.getInt("pstmtCacheSize", pstmtCacheSize);
-    cstmtCacheSize = properties.getInt("cstmtCacheSize", cstmtCacheSize);
-
-    waitTimeoutMillis = properties.getInt("waitTimeout", waitTimeoutMillis);
-
-    heartbeatSql = properties.get("heartbeatSql", heartbeatSql);
-    heartbeatTimeoutSeconds =  properties.getInt("heartbeatTimeoutSeconds", heartbeatTimeoutSeconds);
-    poolListener = properties.get("poolListener", poolListener);
-    offline = properties.getBoolean("offline", offline);
-
-    String isoLevel = properties.get("isolationlevel", getTransactionIsolationLevel(isolationLevel));
-    this.isolationLevel = getTransactionIsolationLevel(isoLevel);
-
-    String customProperties = properties.get("customProperties", null);
-    if (customProperties != null && customProperties.length() > 0) {
-      this.customProperties = StringHelper.delimitedToMap(customProperties, ";", "=");
-    }
-
-  }
-
-  /**
-   * Return the isolation level description from the associated Connection int value.
-   */
-  public String getTransactionIsolationLevel(int level) {
-    switch (level) {
-      case Connection.TRANSACTION_NONE : return "NONE";
-      case Connection.TRANSACTION_READ_COMMITTED : return "READ_COMMITTED";
-      case Connection.TRANSACTION_READ_UNCOMMITTED : return "READ_UNCOMMITTED";
-      case Connection.TRANSACTION_REPEATABLE_READ : return "REPEATABLE_READ";
-      case Connection.TRANSACTION_SERIALIZABLE : return "SERIALIZABLE";
-      default: throw new RuntimeException("Transaction Isolation level [" + level + "] is not known.");
-    }
-  }
-
-  /**
-   * Return the isolation level for a given string description.
-   */
-  public int getTransactionIsolationLevel(String level) {
-    level = level.toUpperCase();
-    if (level.startsWith("TRANSACTION")) {
-      level = level.substring("TRANSACTION".length());
-    }
-    level = level.replace("_", "");
-    if ("NONE".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_NONE;
-    }
-    if ("READCOMMITTED".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_READ_COMMITTED;
-    }
-    if ("READUNCOMMITTED".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_READ_UNCOMMITTED;
-    }
-    if ("REPEATABLEREAD".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_REPEATABLE_READ;
-    }
-    if ("SERIALIZABLE".equalsIgnoreCase(level)) {
-      return Connection.TRANSACTION_SERIALIZABLE;
-    }
-
-    throw new RuntimeException("Transaction Isolation level [" + level + "] is not known.");
-  }
-}

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

@@ -1,39 +1,503 @@
 package com.avaje.ebean.config;
 
+import com.avaje.ebean.EbeanServer;
+import com.avaje.ebean.config.dbplatform.DbPlatformName;
+import com.avaje.ebean.dbmigration.DbMigration;
+import org.avaje.dbmigration.MigrationConfig;
+import org.avaje.dbmigration.MigrationRunner;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+
 /**
  * Configuration for the DB migration processing.
  */
 public class DbMigrationConfig {
 
+  protected static final Logger logger = LoggerFactory.getLogger(DbMigrationConfig.class);
+
+  /**
+   * The database platform to generate migration DDL for.
+   */
+  protected DbPlatformName platform;
+
+  /**
+   * Set to true if the DB migration should be generated on server start.
+   */
+  protected boolean generate;
+
+  /**
+   * The migration version name (typically FlywayDb compatible).
+   * <p>
+   * Example: 1.1.1_2
+   * <p>
+   * The version is expected to be the combination of the current pom version plus
+   * a 'feature' id. The combined version must be unique and ordered to work with
+   * FlywayDb so each developer sets a unique version so that the migration script
+   * generated is unique (typically just prior to being submitted as a merge request).
+   */
+  protected String version;
+
+  /**
+   * Description text that can be appended to the version to become the ddl script file name.
+   * <p>
+   * So if the name is "a foo table" then the ddl script file could be:
+   * "1.1.1_2__a-foo-table.sql"
+   * <p>
+   * When the DB migration relates to a git feature (merge request) then this description text
+   * is a short description of the feature.
+   */
+  protected String name;
+
   /**
    * Resource path for the migration xml and sql.
-   * Typically you would change 'app' to be a better/more unique.
    */
-  private String resourcePath = "dbmigration/app";
+  protected String migrationPath = "dbmigration";
+
+  /**
+   * Subdirectory the model xml files go into.
+   */
+  protected String modelPath = "model";
+
+  protected String applySuffix = ".sql";
+
+  /**
+   * Set this to "V" to be compatible with FlywayDB.
+   */
+  protected String applyPrefix = "";
+
+  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.
+   */
+  protected String metaTable = "db_migration";
+
+  /**
+   * Flag set to true means to run any outstanding migrations on startup.
+   */
+  protected boolean runMigration;
+
+  /**
+   * Comma and equals delimited key/value placeholders to replace in DDL scripts.
+   */
+  protected String runPlaceholders;
+
+  /**
+   * Map of key/value placeholders to replace in DDL scripts.
+   */
+  protected Map<String,String> runPlaceholderMap;
+
+  /**
+   * DB user used to run the DB migration.
+   */
+  protected String dbUsername;
+
+  /**
+   * DB password used to run the DB migration.
+   */
+  protected String dbPassword;
+
+  /**
+   * Return the DB platform to generate migration DDL for.
+   *
+   * We typically need to explicitly specify this as migration can often be generated
+   * when running against H2.
+   */
+  public DbPlatformName getPlatform() {
+    return platform;
+  }
+
+  /**
+   * Set the DB platform to generate migration DDL for.
+   */
+  public void setPlatform(DbPlatformName platform) {
+    this.platform = platform;
+  }
 
   /**
    * Return the resource path for db migrations.
    */
-  public String getResourcePath() {
-    return resourcePath;
+  public String getMigrationPath() {
+    return migrationPath;
   }
 
   /**
    * Set the resource path for db migrations.
    * <p>
-   * Typically this would be something like "dbmigration/myapp" where myapp gives it a
-   * unique resource path in the case there are multiple EbeanServer applications in the
-   * single classpath.
+   * The default of "dbmigration" is reasonable in most cases. You may look to set this
+   * to be something like "dbmigration/myapp" where myapp gives it a unique resource path
+   * in the case there are multiple EbeanServer applications in the single classpath.
    * </p>
    */
-  public void setResourcePath(String resourcePath) {
-    this.resourcePath = resourcePath;
+  public void setMigrationPath(String migrationPath) {
+    this.migrationPath = migrationPath;
+  }
+
+  /**
+   * Return the relative path for the model files (defaults to model).
+   */
+  public String getModelPath() {
+    return modelPath;
+  }
+
+  /**
+   * Set the relative path for the model files.
+   */
+  public void setModelPath(String modelPath) {
+    this.modelPath = modelPath;
+  }
+
+  /**
+   * Return the model suffix (defaults to model.xml)
+   */
+  public String getModelSuffix() {
+    return modelSuffix;
+  }
+
+  /**
+   * Set the model suffix.
+   */
+  public void setModelSuffix(String modelSuffix) {
+    this.modelSuffix = modelSuffix;
+  }
+
+  /**
+   * Return the apply script suffix (defaults to sql).
+   */
+  public String getApplySuffix() {
+    return applySuffix;
+  }
+
+  /**
+   * Set the apply script suffix (defaults to sql).
+   */
+  public void setApplySuffix(String applySuffix) {
+    this.applySuffix = applySuffix;
+  }
+
+  /**
+   * Return the apply prefix.
+   */
+  public String getApplyPrefix() {
+    return applyPrefix;
+  }
+
+  /**
+   * Set the apply prefix. This might be set to "V" for use with FlywayDB.
+   */
+  public void setApplyPrefix(String applyPrefix) {
+    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).
+   */
+  public String getMetaTable() {
+    return metaTable;
+  }
+
+  /**
+   * Set the table name that holds the migration run details
+   * (used by DB Migration runner only).
+   */
+  public void setMetaTable(String metaTable) {
+    this.metaTable = metaTable;
+  }
+
+  /**
+   * Return a comma and equals delimited placeholders that are substituted in SQL scripts when running migration
+   * (used by DB Migration runner only).
+   */
+  public String getRunPlaceholders() {
+    // environment properties take precedence
+    String placeholders = readEnvironment("ddl.migration.placeholders");
+    if (placeholders != null) {
+      return placeholders;
+    }
+    return runPlaceholders;
+  }
+
+  /**
+   * Set a comma and equals delimited placeholders that are substituted in SQL scripts when running migration
+   * (used by DB Migration runner only).
+   */
+  public void setRunPlaceholders(String runPlaceholders) {
+    this.runPlaceholders = runPlaceholders;
+  }
+
+  /**
+   * Return a map of placeholder values that are substituted in SQL scripts when running migration
+   * (used by DB Migration runner only).
+   */
+  public Map<String, String> getRunPlaceholderMap() {
+    return runPlaceholderMap;
+  }
+
+  /**
+   * Set a map of placeholder values that are substituted when running migration
+   * (used by DB Migration runner only).
+   */
+  public void setRunPlaceholderMap(Map<String, String> runPlaceholderMap) {
+    this.runPlaceholderMap = runPlaceholderMap;
+  }
+
+  /**
+   * Return true if the DB migration should be run on startup.
+   */
+  public boolean isRunMigration() {
+    // environment properties take precedence
+    String run = readEnvironment("ddl.migration.run");
+    if (run != null) {
+      return "true".equalsIgnoreCase(run.trim());
+    }
+    return runMigration;
+  }
+
+  /**
+   * Set to true to run the DB migration on startup.
+   */
+  public void setRunMigration(boolean runMigration) {
+    this.runMigration = runMigration;
+  }
+
+  /**
+   * Return the DB username to use for running DB migrations.
+   */
+  public String getDbUsername() {
+    // environment properties take precedence
+    String user = readEnvironment("ddl.migration.user");
+    if (user != null) {
+      return user;
+    }
+    return dbUsername;
+  }
+
+  /**
+   * Set the DB username to use for running DB migrations.
+   */
+  public void setDbUsername(String dbUsername) {
+    this.dbUsername = dbUsername;
+  }
+
+  /**
+   * Return the DB password to use for running DB migrations.
+   */
+  public String getDbPassword() {
+    String user = readEnvironment("ddl.migration.password");
+    if (user != null) {
+      return user;
+    }
+    return dbPassword;
+  }
+
+  /**
+   * Set the DB password to use for running DB migrations.
+   */
+  public void setDbPassword(String dbPassword) {
+    this.dbPassword = dbPassword;
   }
 
   /**
    * Load the settings from the PropertiesWrapper.
    */
-  public void loadSettings(PropertiesWrapper properties) {
-    resourcePath = properties.get("migration.resourcePath", resourcePath);
+  public void loadSettings(PropertiesWrapper properties, String serverName) {
+
+    migrationPath = properties.get("migration.migrationPath", migrationPath);
+    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(DbPlatformName.class, "migration.platform", platform);
+
+    generate = properties.getBoolean("migration.generate", generate);
+    version = properties.get("migration.version", version);
+    name = properties.get("migration.name", name);
+
+    runMigration = properties.getBoolean("migration.run", runMigration);
+    metaTable = properties.get("migration.metaTable", metaTable);
+    runPlaceholders = properties.get("migration.placeholders", runPlaceholders);
+
+    String adminUser = properties.get("datasource."+serverName+".username", dbUsername);
+    adminUser = properties.get("datasource."+serverName+".adminusername", adminUser);
+    dbUsername = properties.get("migration.dbusername", adminUser);
+
+    String adminPwd = properties.get("datasource."+serverName+".password", dbPassword);
+    adminPwd = properties.get("datasource."+serverName+".adminpassword", adminPwd);
+    dbPassword = properties.get("migration.dbpassword", adminPwd);
+  }
+
+  /**
+   * Return true if the migration should be generated.
+   * <p>
+   * It is expected that when an environment variable <code>ddl.migration.enabled</code>
+   * is set to <code>true</code> then the DB migration will generate the migration DDL.
+   * </p>
+   */
+  public boolean isGenerateOnStart() {
+
+    // environment properties take precedence
+    String envGenerate = readEnvironment("ddl.migration.generate");
+    if (envGenerate != null) {
+      return "true".equalsIgnoreCase(envGenerate.trim());
+    }
+    return generate;
+  }
+
+  /**
+   * Called by EbeanServer on start.
+   *
+   * <p>
+   * If enabled this generates the migration xml and DDL scripts.
+   * </p>
+   */
+  public void generateOnStart(EbeanServer server) {
+
+    if (isGenerateOnStart()) {
+      if (platform == null) {
+        logger.warn("No platform set for migration DDL generation");
+      } else {
+        // generate the migration xml and platform specific DDL
+        DbMigration migration = new DbMigration(server);
+        migration.setPlatform(platform);
+        try {
+          migration.generateMigration();
+        } catch (Exception e) {
+          throw new RuntimeException("Error generating DB migration", e);
+        }
+      }
+    }
+  }
+
+  /**
+   * Return the migration version (typically FlywayDb compatible).
+   * <p>
+   * Example: 1.1.1_2
+   * <p>
+   * The version is expected to be the combination of the current pom version plus
+   * a 'feature' id. The combined version must be unique and ordered to work with
+   * FlywayDb so each developer sets a unique version so that the migration script
+   * generated is unique (typically just prior to being submitted as a merge request).
+   */
+  public String getVersion() {
+    String envVersion = readEnvironment("ddl.migration.version");
+    if (!isEmpty(envVersion)) {
+      return envVersion.trim();
+    }
+    return version;
+  }
+
+  /**
+   * Return the migration name which is short description text that can be appended to
+   * the migration version to become the ddl script file name.
+   * <p>
+   * So if the name is "a foo table" then the ddl script file could be:
+   * "1.1.1_2__a-foo-table.sql"
+   * </p>
+   * <p>
+   * When the DB migration relates to a git feature (merge request) then this description text
+   * is a short description of the feature.
+   * </p>
+   */
+  public String getName() {
+    String envName = readEnvironment("ddl.migration.name");
+    if (!isEmpty(envName)) {
+      return envName.trim();
+    }
+    return name;
+  }
+
+  /**
+   * Return the system or environment property.
+   */
+  protected String readEnvironment(String key) {
+
+    String val = System.getProperty(key);
+    if (val == null) {
+      val = System.getenv(key);
+    }
+    return val;
+  }
+
+  /**
+   * Return true if the string is null or empty.
+   */
+  protected boolean isEmpty(String val) {
+    return val == null || val.trim().isEmpty();
+  }
+
+  /**
+   * Create the MigrationRunner to run migrations if necessary.
+   */
+  public MigrationRunner createRunner(ClassLoader classLoader) {
+
+    MigrationConfig runnerConfig = new MigrationConfig();
+    runnerConfig.setMetaTable(metaTable);
+    runnerConfig.setApplySuffix(applySuffix);
+    runnerConfig.setMigrationPath(migrationPath);
+    runnerConfig.setRunPlaceholderMap(runPlaceholderMap);
+    runnerConfig.setRunPlaceholders(runPlaceholders);
+    runnerConfig.setDbUsername(getDbUsername());
+    runnerConfig.setDbPassword(getDbPassword());
+    runnerConfig.setClassLoader(classLoader);
+    return new MigrationRunner(runnerConfig);
   }
 }

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

@@ -0,0 +1,259 @@
+package com.avaje.ebean.config;
+
+import com.avaje.ebean.annotation.DocStoreMode;
+
+/**
+ * Configuration for the Document store integration (e.g. ElasticSearch).
+ */
+public class DocStoreConfig {
+
+  /**
+   * True when the Document store integration is active/on.
+   */
+  protected boolean active;
+
+  /**
+   * Set to true means Ebean will generate mapping files on startup.
+   */
+  protected boolean generateMapping;
+
+  /**
+   * When true the Document store should drop and re-create document indexes.
+   */
+  protected boolean dropCreate;
+
+  /**
+   * When true the Document store should create any document indexes that don't already exist.
+   */
+  protected boolean create;
+
+  /**
+   * The URL of the Document store server. For example: http://localhost:9200.
+   */
+  protected String url;
+
+  /**
+   * The default mode used by indexes.
+   */
+  protected DocStoreMode persist = DocStoreMode.UPDATE;
+
+  /**
+   * The default batch size to use for the Bulk API calls.
+   */
+  protected int bulkBatchSize = 1000;
+
+  /**
+   * Resource path for the Document store mapping files.
+   */
+  protected String mappingPath;
+
+  /**
+   * Suffix used for mapping files.
+   */
+  protected String mappingSuffix;
+
+  /**
+   * Location of resources that mapping files are generated into.
+   */
+  protected String pathToResources = "src/main/resources";
+
+  /**
+   * Return true if the Document store (ElasticSearch) integration is active.
+   */
+  public boolean isActive() {
+    String systemValue = System.getProperty("ebean.docstore.active");
+    if (systemValue != null) {
+      return Boolean.parseBoolean(systemValue);
+    }
+    return active;
+  }
+
+  /**
+   * Set to true to make the Document store (ElasticSearch) integration active.
+   */
+  public void setActive(boolean active) {
+    this.active = active;
+  }
+
+  /**
+   * Return the URL to the Document store.
+   */
+  public String getUrl() {
+    String systemValue = System.getProperty("ebean.docstore.url");
+    if (systemValue != null) {
+      return systemValue;
+    }
+    return url;
+  }
+
+  /**
+   * Set the URL to the Document store server.
+   * <p>
+   * For a local ElasticSearch server this would be: http://localhost:9200
+   */
+  public void setUrl(String url) {
+    this.url = url;
+  }
+
+  /**
+   * Return true if Ebean should generate mapping files on server startup.
+   */
+  public boolean isGenerateMapping() {
+    String systemValue = System.getProperty("ebean.docstore.generateMapping");
+    if (systemValue != null) {
+      return Boolean.parseBoolean(systemValue);
+    }
+    return generateMapping;
+  }
+
+  /**
+   * Set to true if Ebean should generate mapping files on server startup.
+   */
+  public void setGenerateMapping(boolean generateMapping) {
+    this.generateMapping = generateMapping;
+  }
+
+  /**
+   * Return true if the document store should recreate mapped indexes.
+   */
+  public boolean isDropCreate() {
+    String systemValue = System.getProperty("ebean.docstore.dropCreate");
+    if (systemValue != null) {
+      return Boolean.parseBoolean(systemValue);
+    }
+    return dropCreate;
+  }
+
+  /**
+   * Set to true if the document store should recreate mapped indexes.
+   */
+  public void setDropCreate(boolean dropCreate) {
+    this.dropCreate = dropCreate;
+  }
+
+  /**
+   * Create true if the document store should create mapped indexes that don't yet exist.
+   * This is only used if dropCreate is false.
+   */
+  public boolean isCreate() {
+    String systemValue = System.getProperty("ebean.docstore.create");
+    if (systemValue != null) {
+      return Boolean.parseBoolean(systemValue);
+    }
+    return create;
+  }
+
+  /**
+   * Set to true if the document store should create mapped indexes that don't yet exist.
+   * This is only used if dropCreate is false.
+   */
+  public void setCreate(boolean create) {
+    this.create = create;
+  }
+
+  /**
+   * Return the default batch size to use for calls to the Bulk API.
+   */
+  public int getBulkBatchSize() {
+    return bulkBatchSize;
+  }
+
+  /**
+   * Set the default batch size to use for calls to the Bulk API.
+   * <p>
+   * The batch size can be set on a transaction via {@link com.avaje.ebean.Transaction#setDocStoreBatchSize(int)}.
+   * </p>
+   */
+  public void setBulkBatchSize(int bulkBatchSize) {
+    this.bulkBatchSize = bulkBatchSize;
+  }
+
+  /**
+   * Return the mapping path.
+   */
+  public String getMappingPath() {
+    return mappingPath;
+  }
+
+  /**
+   * Set the mapping path.
+   */
+  public void setMappingPath(String mappingPath) {
+    this.mappingPath = mappingPath;
+  }
+
+  /**
+   * Return the mapping suffix.
+   */
+  public String getMappingSuffix() {
+    return mappingSuffix;
+  }
+
+  /**
+   * Set the mapping suffix.
+   */
+  public void setMappingSuffix(String mappingSuffix) {
+    this.mappingSuffix = mappingSuffix;
+  }
+
+  /**
+   * Return the relative file system path to resources when generating mapping files.
+   */
+  public String getPathToResources() {
+    return pathToResources;
+  }
+
+  /**
+   * Set the relative file system path to resources when generating mapping files.
+   */
+  public void setPathToResources(String pathToResources) {
+    this.pathToResources = pathToResources;
+  }
+
+  /**
+   * Return the default behavior for when Insert, Update and Delete events occur on beans that have an associated
+   * Document store.
+   */
+  public DocStoreMode getPersist() {
+    return persist;
+  }
+
+  /**
+   * Set the default behavior for when Insert, Update and Delete events occur on beans that have an associated
+   * Document store.
+   * <ul>
+   * <li>DocStoreEvent.UPDATE - build and send message to Bulk API</li>
+   * <li>DocStoreEvent.QUEUE - add an entry with the index type and id only into a queue for later processing</li>
+   * <li>DocStoreEvent.IGNORE - ignore. Most likely used when some scheduled batch job handles updating the index</li>
+   * </ul>
+   * <p>
+   * You might choose to use QUEUE if that particular index data is updating very frequently or the cost of indexing
+   * is expensive.  Setting it to QUEUE can mean many changes can be batched together potentially coalescing multiple
+   * updates for an index entry into a single update.
+   * </p>
+   * <p>
+   * You might choose to use IGNORE when you have your own external process for updating the indexes. In this case
+   * you don't want Ebean to do anything when the data changes.
+   * </p>
+   */
+  public void setPersist(DocStoreMode persist) {
+    this.persist = persist;
+  }
+
+  /**
+   * Load settings specified in properties files.
+   */
+  public void loadSettings(PropertiesWrapper properties) {
+
+    active = properties.getBoolean("docstore.active", active);
+    url = properties.get("docstore.url", url);
+    persist = properties.getEnum(DocStoreMode.class, "docstore.persist", persist);
+    bulkBatchSize = properties.getInt("docstore.bulkBatchSize", bulkBatchSize);
+    generateMapping = properties.getBoolean("docstore.generateMapping", generateMapping);
+    dropCreate = properties.getBoolean("docstore.dropCreate", dropCreate);
+    create = properties.getBoolean("docstore.create", create);
+    mappingPath = properties.get("docstore.mappingPath", mappingPath);
+    mappingSuffix = properties.get("docstore.mappingSuffix", mappingSuffix);
+    pathToResources = properties.get("docstore.pathToResources", pathToResources);
+  }
+}

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

@@ -0,0 +1,22 @@
+package com.avaje.ebean.config;
+
+/**
+ * A customer Id generator that can be registered with Ebean and
+ * assigned to @Id properties using the name attribute of @GeneratedValue.
+ */
+public interface IdGenerator {
+
+  /**
+   * Return the next Id value.
+   */
+  Object nextValue();
+
+  /**
+   * Return the name of the IdGenerator.
+   * <p>
+   * The name is used to assign the IdGenerator to a property using
+   * <code>@GeneratedValue(name="myGeneratorName")</code>
+   * </p>
+   */
+  String getName();
+}

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

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

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

@@ -31,6 +31,11 @@ public final class PropertyMap implements Serializable {
     return (propertyMap == null) ? new Properties() : propertyMap.asProperties();
   }
 
+  public static boolean loadTestProperties() {
+    String disable = System.getProperty("disableTestProperties");
+    return (disable == null || !disable.equalsIgnoreCase("true"));
+  }
+
   public String toString() {
     return map.toString();
   }

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

@@ -18,6 +18,9 @@ final class PropertyMapLoader {
    * Load the <code>test-ebean.properties</code>.
    */
   public static PropertyMap loadTestProperties() {
+    if (!PropertyMap.loadTestProperties()) {
+      return new PropertyMap();
+    }
     return load(null, "test-ebean.properties");
   }
 
@@ -31,7 +34,7 @@ final class PropertyMapLoader {
     if (fileName == null) {
       fileName = System.getProperty("ebean.props.file");
       if (fileName == null) {
-        loadTestProperties = true;
+        loadTestProperties = PropertyMap.loadTestProperties();
         fileName = "ebean.properties";
       }
     }

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

@@ -146,6 +146,6 @@ public final class TableName {
    * @return true, if is valid
    */
   public boolean isValid() {
-    return name != null && name.length() > 0;
+    return name != null && !name.isEmpty();
   }
 }

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

@@ -1,5 +1,7 @@
 package com.avaje.ebean.config;
 
+import com.avaje.ebean.util.CamelCaseHelper;
+
 /**
  * Converts between Camel Case and Underscore based names for both table and
  * column names (and is the default naming convention in Ebean).
@@ -141,21 +143,6 @@ public class UnderscoreNamingConvention extends AbstractNamingConvention {
    * Convert and return the from string from underscore to camel case.
    */
   protected String toCamelFromUnderscore(String underscore) {
-
-    StringBuilder result = new StringBuilder(underscore.length());
-    String[] vals = underscore.split("_");
-
-    for (int i = 0; i < vals.length; i++) {
-      String lower = vals[i].toLowerCase();
-      if (i > 0) {
-        char c = Character.toUpperCase(lower.charAt(0));
-        result.append(c);
-        result.append(lower.substring(1));
-      } else {
-        result.append(lower);
-      }
-    }
-
-    return result.toString();
+    return CamelCaseHelper.toCamelFromUnderscore(underscore);
   }
 }