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

platform dependent @Formula and @Where annotations

.editorconfig

@@ -0,0 +1,12 @@
+# editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+spaces_around_operators = true

.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
+```

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,42 +3,25 @@
 
   <parent>
     <groupId>org.avaje</groupId>
-    <artifactId>avaje-javaparent</artifactId>
-    <version>1.2</version>
+    <artifactId>java8-parent</artifactId>
+    <version>1.1</version>
   </parent>
 
-  <groupId>org.avaje.ebeanorm</groupId>
-  <artifactId>avaje-ebeanorm</artifactId>
-  <version>6.17.1</version>
+  <groupId>org.avaje.ebean</groupId>
+  <artifactId>ebean</artifactId>
+  <version>9.4.2</version>
   <packaging>jar</packaging>
 
-  <name>avaje-ebeanorm</name>
+  <name>ebean</name>
   <url>http://ebean-orm.github.io/</url>
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
 
-  <licenses>
-    <license>
-      <name>The Apache Software License, Version 2.0</name>
-      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <developers>
-    <developer>
-      <id>rbygrave</id>
-      <name>Rob Bygrave</name>
-      <email>robin.bygrave@gmail.com</email>
-    </developer>
-  </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:git@github.com:ebean-orm/ebean.git</developerConnection>
+    <tag>ebean-9.4.2</tag>
   </scm>
 
   <dependencies>
@@ -50,38 +33,72 @@
     </dependency>
 
     <dependency>
-      <groupId>javax.persistence</groupId>
+      <groupId>org.avaje.ebean</groupId>
       <artifactId>persistence-api</artifactId>
-      <version>1.0</version>
+      <version>2.1.3</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.avaje.ebean</groupId>
+      <artifactId>ebean-annotation</artifactId>
+      <version>1.5</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 +138,8 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- Test scope -->
+
     <!--<dependency>-->
       <!--<groupId>oracle</groupId>-->
       <!--<artifactId>oracle-jdbc</artifactId>-->
@@ -135,13 +154,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 +162,9 @@
     </dependency>
 
     <dependency>
-      <groupId>org.avaje.ebeanorm</groupId>
-      <artifactId>avaje-ebeanorm-agent</artifactId>
-      <version>4.9.1</version>
+      <groupId>org.avaje.ebean</groupId>
+      <artifactId>ebean-agent</artifactId>
+      <version>8.1.1</version>
       <scope>test</scope>
     </dependency>
 
@@ -161,14 +173,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,33 +213,29 @@
       <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>
-        <version>3.2</version>
-        <configuration>
-          <source>1.6</source>
-          <target>1.6</target>
-        </configuration>
-      </plugin>
-      <plugin>
-        <groupId>org.avaje.ebeanorm</groupId>
-        <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
-        <version>4.9.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 +266,8 @@
           </systemProperties>
         </configuration>
       </plugin>
- 	 <plugin>
+
+      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-jar-plugin</artifactId>
         <version>2.5</version>
@@ -268,12 +277,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 9</doctitle>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
           <source>1.8</source>
           <doclet>org.avaje.doclet.PygmentsDoclet</doclet>
@@ -292,9 +302,7 @@
           </additionalparam>
           <linksource>true</linksource>
           <overview>src/main/java/com/avaje/ebean/overview.html</overview>
-
         </configuration>
-
         <executions>
           <execution>
             <id>attach-javadocs</id>
@@ -304,8 +312,9 @@
           </execution>
         </executions>
       </plugin>
+
     </plugins>
 
   </build>
- 
+
 </project>

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

@@ -15,7 +15,7 @@ import java.util.concurrent.TimeUnit;
  * code if you want. It can be useful for some server caching implementations
  * (background population and trimming of the cache etc).
  * </p>
- * 
+ *
  * @author rbygrave
  */
 public interface BackgroundExecutor {

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

@@ -38,15 +38,18 @@ 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.
-   *
    * <p>
-   *   Typically this would be used to set the loaded state of a property
-   *   to false to ensure that the specific property is excluded from a
-   *   stateless update.
+   * Typically this would be used to set the loaded state of a property
+   * to false to ensure that the specific property is excluded from a
+   * stateless update.
    * </p>
-   *
    * <pre>{@code
    *
    *   // populate a bean via say JSON
@@ -59,8 +62,7 @@ public interface BeanState {
    *   user.update();
    *
    * }</pre>
-   *
-   *
+   * <p>
    * This will throw an IllegalArgumentException if the property is unknown.
    */
   void setPropertyLoaded(String propertyName, boolean loaded);
@@ -82,8 +84,8 @@ public interface BeanState {
   /**
    * Return a map of the updated properties and their new and old values.
    */
-  Map<String,ValuePair> getDirtyValues();
-  
+  Map<String, ValuePair> getDirtyValues();
+
   /**
    * Return true if the bean is readOnly.
    * <p>
@@ -115,4 +117,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/CallableSql.java

@@ -13,65 +13,66 @@ import java.sql.SQLException;
  * <p>
  * Example 1:
  * </p>
- * 
- * <pre class="code">
- * String sql = &quot;{call sp_order_mod(?,?)}&quot;;
- * 
+ * <pre>{@code
+ *
+ * String sql = "{call sp_order_mod(?,?)}";
+ *
  * CallableSql cs = Ebean.createCallableSql(sql);
- * cs.setParameter(1, &quot;turbo&quot;);
+ * cs.setParameter(1, "turbo");
  * cs.registerOut(2, Types.INTEGER);
- * 
+ *
  * Ebean.execute(cs);
- * 
+ *
  * // read the out parameter
  * Integer returnValue = (Integer) cs.getObject(2);
- * </pre>
- * 
+ *
+ * }</pre>
  * <p>
  * Example 2:<br>
  * Includes batch mode, table modification information and label. Note that the
  * label is really only to help people reading the transaction logs to identify
  * the procedure called etc.
  * </p>
- * 
- * <pre class="code">
- * String sql = &quot;{call sp_insert_order(?,?)}&quot;;
- * 
+ *
+ * <pre>{@code
+ *
+ * String sql = "{call sp_insert_order(?,?)}";
+ *
  * CallableSql cs = Ebean.createCallableSql(sql);
- * 
+ *
  * // Inform Ebean this stored procedure inserts into the
  * // oe_order table and inserts + updates the oe_order_detail table.
  * // this is used to invalidate objects in the cache
- * cs.addModification(&quot;oe_order&quot;, true, false, false);
- * cs.addModification(&quot;oe_order_detail&quot;, true, true, false);
- * 
+ * cs.addModification("oe_order", true, false, false);
+ * cs.addModification("oe_order_detail", true, true, false);
+ *
  * Transaction t = Ebean.startTransaction();
- * 
+ *
  * // execute using JDBC batching 10 statements at a time
  * t.setBatchMode(true);
  * t.setBatchSize(10);
  * try {
- *   cs.setParameter(1, &quot;Was&quot;);
- *   cs.setParameter(2, &quot;Banana&quot;);
+ *   cs.setParameter(1, "Was");
+ *   cs.setParameter(2, "Banana");
  *   Ebean.execute(cs);
- * 
- *   cs.setParameter(1, &quot;Here&quot;);
- *   cs.setParameter(2, &quot;Kumera&quot;);
+ *
+ *   cs.setParameter(1, "Here");
+ *   cs.setParameter(2, "Kumera");
  *   Ebean.execute(cs);
- * 
- *   cs.setParameter(1, &quot;More&quot;);
- *   cs.setParameter(2, &quot;Apple&quot;);
+ *
+ *   cs.setParameter(1, "More");
+ *   cs.setParameter(2, "Apple");
  *   Ebean.execute(cs);
- * 
- *   // Ebean.externalModification(&quot;oe_order&quot;,true,false,false);
- *   // Ebean.externalModification(&quot;oe_order_detail&quot;,true,true,false);
+ *
+ *   // Ebean.externalModification("oe_order",true,false,false);
+ *   // Ebean.externalModification("oe_order_detail",true,true,false);
  *   Ebean.commitTransaction();
- * 
+ *
  * } finally {
  *   Ebean.endTransaction();
  * }
- * </pre>
- * 
+ * }</pre>
+ *
  * @see com.avaje.ebean.SqlUpdate
  * @see com.avaje.ebean.Ebean#execute(CallableSql)
  */
@@ -119,21 +120,17 @@ public interface CallableSql {
    * This is designed so that you do not need to set params in index order. You
    * can set/register param 2 before param 1 etc.
    * </p>
-   * 
-   * @param position
-   *          the index position of the parameter.
-   * @param value
-   *          the value of the parameter.
+   *
+   * @param position the index position of the parameter.
+   * @param value    the value of the parameter.
    */
   CallableSql bind(int position, Object value);
 
   /**
    * Bind a positioned parameter (same as bind method).
-   * 
-   * @param position
-   *          the index position of the parameter.
-   * @param value
-   *          the value of the parameter.
+   *
+   * @param position the index position of the parameter.
+   * @param value    the value of the parameter.
    */
   CallableSql setParameter(int position, Object value);
 
@@ -147,11 +144,9 @@ public interface CallableSql {
    * This is designed so that you do not need to register params in index order.
    * You can set/register param 2 before param 1 etc.
    * </p>
-   * 
-   * @param position
-   *          the index position of the parameter (starts with 1).
-   * @param type
-   *          the jdbc type of the OUT parameter that will be read.
+   *
+   * @param position the index position of the parameter (starts with 1).
+   * @param type     the jdbc type of the OUT parameter that will be read.
    */
   CallableSql registerOut(int position, int type);
 
@@ -168,7 +163,6 @@ public interface CallableSql {
   Object getObject(int position);
 
   /**
-   * 
    * You can extend this object and override this method for more advanced
    * stored procedure calls. This would be the case when ResultSets are returned
    * etc.
@@ -190,4 +184,4 @@ public interface CallableSql {
    */
   CallableSql addModification(String tableName, boolean inserts, boolean updates, boolean deletes);
 
-}
+}

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

@@ -1,10 +1,9 @@
 package com.avaje.ebean;
 
-import java.util.ArrayList;
+import com.avaje.ebean.RawSql.ColumnMapping;
 
 import javax.persistence.PersistenceException;
-
-import com.avaje.ebean.RawSql.ColumnMapping;
+import java.util.ArrayList;
 
 /**
  * Parses columnMapping (select clause) mapping columns to bean properties.
@@ -30,7 +29,7 @@ final class DRawSqlColumnsParser {
 
   private ColumnMapping parse() {
 
-    ArrayList<ColumnMapping.Column> columns = new ArrayList<ColumnMapping.Column>();
+    ArrayList<ColumnMapping.Column> columns = new ArrayList<>();
     while (pos <= end) {
       ColumnMapping.Column c = nextColumnInfo();
       columns.add(c);
@@ -47,10 +46,10 @@ final class DRawSqlColumnsParser {
 
     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) {
-          tmp.add(split[i].trim());
+      ArrayList<String> tmp = new ArrayList<>(split.length);
+      for (String aSplit : split) {
+        if (!aSplit.trim().isEmpty()) {
+          tmp.add(aSplit.trim());
         }
       }
       split = tmp.toArray(new String[tmp.size()]);
@@ -66,15 +65,15 @@ final class DRawSqlColumnsParser {
     if (split.length == 2) {
       return new ColumnMapping.Column(indexPos++, split[0], split[1]);
     }
-    // Ok, we now expect/require the AS keyword and it should be the 
-    // second to last word in the colInfo content 
+    // Ok, we now expect/require the AS keyword and it should be the
+    // second to last word in the colInfo content
     if (!split[split.length - 2].equalsIgnoreCase("as")) {
       throw new PersistenceException("Expecting AS keyword as second to last word when parsing column " + colInfo);
     }
     // build back the 'column formula' that precedes the AS keyword
     StringBuilder sb = new StringBuilder();
     sb.append(split[0]);
-    for (int i = 1; i < split.length-2; i++) {
+    for (int i = 1; i < split.length - 2; i++) {
       sb.append(" ").append(split[i]);
     }
     return new ColumnMapping.Column(indexPos++, sb.toString(), split[split.length - 1]);

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

@@ -1,6 +1,7 @@
 package com.avaje.ebean;
 
 import com.avaje.ebean.RawSql.Sql;
+import com.avaje.ebeaninternal.server.querydefn.SimpleTextParser;
 
 /**
  * Parses sql-select queries to try and determine the location where WHERE and
@@ -8,13 +9,13 @@ import com.avaje.ebean.RawSql.Sql;
  */
 class DRawSqlParser {
 
-  public static final String $_AND_HAVING = "${andHaving}";
+  private static final String $_AND_HAVING = "${andHaving}";
 
-  public static final String $_HAVING = "${having}";
+  private static final String $_HAVING = "${having}";
 
-  public static final String $_AND_WHERE = "${andWhere}";
+  private static final String $_AND_WHERE = "${andWhere}";
 
-  public static final String $_WHERE = "${where}";
+  private static final String $_WHERE = "${where}";
 
   private final SimpleTextParser textParser;
 
@@ -46,7 +47,7 @@ class DRawSqlParser {
 
   private DRawSqlParser(String sqlString) {
     sqlString = sqlString.trim();
-    sqlString = sqlString.replace('\n',' ');
+    sqlString = sqlString.replace('\n', ' ');
     this.sql = sqlString;
     this.hasPlaceHolders = findAndRemovePlaceHolders();
     this.textParser = new SimpleTextParser(sqlString);
@@ -71,7 +72,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));
   }
 
   /**

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;
+    }
+  }
+
+  private final Action type;
+
+  private final String queueId;
+
+  private final String path;
+
+  private 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,294 @@
+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;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * 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, Consumer<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, Predicate<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/EbeanServerFactory.java

@@ -36,7 +36,7 @@ public class EbeanServerFactory {
 
   /**
    * Initialise the container with clustering configuration.
-   *
+   * <p>
    * Call this prior to creating any EbeanServer instances or alternatively set the
    * ContainerConfig on the ServerConfig when creating the first EbeanServer instance.
    */
@@ -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/ExampleExpression.java

@@ -14,44 +14,44 @@ package com.avaje.ebean;
  * To get control over the options you can create an ExampleExpression and set
  * those options such as case insensitive etc.
  * </p>
- * 
- * <pre class="code">
+ *
+ * <pre>{@code
  * // create an example bean and set the properties
  * // with the query parameters you want
  * Customer example = new Customer();
- * example.setName(&quot;Rob%&quot;);
- * example.setNotes(&quot;%something%&quot;);
- * 
+ * 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(&quot;id&quot;, 2)
+ *         .gt("id", 2)
  *         .findList();
- * 
- * </pre>
- * 
+ *
+ * }</pre>
+ *
  * Similarly you can create an ExampleExpression
- * 
- * <pre>
+ *
+ * <pre>{@code
+ *
  * Customer example = new Customer();
- * example.setName(&quot;Rob%&quot;);
- * example.setNotes(&quot;%something%&quot;);
- * 
+ * example.setName("Rob%");
+ * example.setNotes("%something%");
+ *
  * // create a ExampleExpression with more control
  * ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO)
  *     .includeZeros();
- * 
- * List&lt;Customer&gt; list =
+ *
+ * List<Customer> list =
  *     Ebean.find(Customer.class)
  *         .where()
  *         .add(qbe)
  *         .findList();
- * </pre>
- * 
- * @author Rob Bygrave
+ *
+ * }</pre>
  */
 public interface ExampleExpression extends Expression {
 
@@ -90,4 +90,4 @@ public interface ExampleExpression extends Expression {
    */
   ExampleExpression useEqualTo();
 
-}
+}

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

@@ -23,20 +23,19 @@ import java.util.Map;
  * Creates standard common expressions for using in a Query Where or Having
  * clause.
  * </p>
- * 
- * <pre class="code">
- *  // Example: Using an Expr.or() method
- * Query&lt;Order&gt; query = Ebean.createQuery(Order.class);
- * query.where( 
- * 		Expr.or(Expr.eq(&quot;status&quot;, Order.NEW),
- *     		    Expr.gt(&quot;orderDate&quot;, lastWeek));
- *     
- * List&lt;Order&gt; list = query.findList();
+ * <pre>{@code
+ *
+ * // Example: Using an Expr.or() method
+ * Query<Order> query = Ebean.createQuery(Order.class);
+ * query.where(
+ *     Expr.or(Expr.eq("status", Order.NEW),
+ *             Expr.gt("orderDate", lastWeek));
+ *
+ * List<Order> list = query.findList();
  * ...
- * </pre>
- * 
+ * }</pre>
+ *
  * @see Query#where()
- * @author Rob Bygrave
  */
 public class Expr {
 
@@ -77,10 +76,10 @@ public class Expr {
    * Between - value between two given properties.
    */
   public static Expression between(String lowProperty, String highProperty, Object value) {
-    
+
     return Ebean.getExpressionFactory().betweenProperties(lowProperty, highProperty, value);
   }
-  
+
   /**
    * Greater Than - property greater than the given value.
    */
@@ -142,8 +141,7 @@ public class Expr {
   /**
    * Create the query by Example expression specifying more options.
    */
-  public static ExampleExpression exampleLike(Object example, boolean caseInsensitive,
-      LikeType likeType) {
+  public static ExampleExpression exampleLike(Object example, boolean caseInsensitive, LikeType likeType) {
     return Ebean.getExpressionFactory().exampleLike(example, caseInsensitive, likeType);
   }
 
@@ -209,6 +207,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.
    */
@@ -243,9 +255,8 @@ public class Expr {
    * Expression where all the property names in the map are equal to the
    * corresponding value.
    * </p>
-   * 
-   * @param propertyMap
-   *          a map keyed by property names.
+   *
+   * @param propertyMap a map keyed by property names.
    */
   public static Expression allEq(Map<String, Object> propertyMap) {
     return Ebean.getExpressionFactory().allEq(propertyMap);

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;
@@ -18,20 +24,19 @@ import java.util.Map;
  * <p>
  * The ExpressionList is returned from {@link Query#where()}.
  * </p>
- * 
- * <pre class="code">
- *  // Example: fetch orders where status equals new or orderDate > lastWeek.
- *  
- * Expression newOrLastWeek = 
- *   Expr.or(Expr.eq(&quot;status&quot;, Order.Status.NEW), 
- *           Expr.gt(&quot;orderDate&quot;, lastWeek));
- * 
- * Query&lt;Order&gt; query = Ebean.createQuery(Order.class);
+ * <pre>{@code
+ * // Example: fetch orders where status equals new or orderDate > lastWeek.
+ *
+ * Expression newOrLastWeek =
+ *     Expr.or(Expr.eq("status", Order.Status.NEW),
+ *             Expr.gt("orderDate", lastWeek));
+ *
+ * Query<Order> query = Ebean.createQuery(Order.class);
  * query.where().add(newOrLastWeek);
- * List&lt;Order&gt; list = query.findList();
+ * List<Order> list = query.findList();
  * ...
- * </pre>
- * 
+ * }</pre>
+ *
  * @see Query#where()
  */
 public interface ExpressionFactory {
@@ -81,6 +86,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 +134,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 +196,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).
@@ -234,17 +281,32 @@ public interface ExpressionFactory {
    * Exists expression
    */
   Expression exists(Query<?> subQuery);
-  
+
   /**
    * Not exists expression
    */
   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.
    */
@@ -256,9 +318,8 @@ public interface ExpressionFactory {
    * Expression where all the property names in the map are equal to the
    * corresponding value.
    * </p>
-   * 
-   * @param propertyMap
-   *          a map keyed by property names.
+   *
+   * @param propertyMap a map keyed by property names.
    */
   Expression allEq(Map<String, Object> propertyMap);
 
@@ -285,6 +346,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 +405,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,15 +1,20 @@
 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 javax.persistence.NonUniqueResultException;
-import java.io.Serializable;
 import java.sql.Timestamp;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 /**
  * List of Expressions that make up a where or having clause.
@@ -28,10 +33,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.
@@ -80,14 +85,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);
@@ -95,13 +100,13 @@ 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
    * as of a time in the past.
    * <p>
-   *   To perform this query the DB must have underlying history tables.
+   * To perform this query the DB must have underlying history tables.
    * </p>
    *
    * @param asOf the date time in the past at which you want to view the data
@@ -116,7 +121,7 @@ public interface ExpressionList<T> extends Serializable {
   /**
    * Execute the query including soft deleted rows.
    */
-  Query<T> includeSoftDeletes();
+  Query<T> setIncludeSoftDeletes();
 
   /**
    * Execute as a delete query deleting the 'root level' beans that match the predicates
@@ -126,13 +131,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();
@@ -140,31 +153,31 @@ public interface ExpressionList<T> extends Serializable {
   /**
    * Execute the query process the beans one at a time.
    *
-   * @see Query#findEach(QueryEachConsumer)
+   * @see Query#findEach(Consumer)
    */
-  void findEach(QueryEachConsumer<T> consumer);
+  void findEach(Consumer<T> consumer);
 
   /**
    * Execute the query processing the beans one at a time with the ability to
    * stop processing before reading all the beans.
    *
-   * @see Query#findEachWhile(QueryEachWhileConsumer)
+   * @see Query#findEachWhile(Predicate)
    */
-  void findEachWhile(QueryEachWhileConsumer<T> consumer);
+  void findEachWhile(Predicate<T> consumer);
 
   /**
    * 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.
@@ -172,26 +185,53 @@ public interface ExpressionList<T> extends Serializable {
    * This is the number of 'top level' or 'root level' entities.
    * </p>
    */
-  int findRowCount();
+  int findCount();
 
   /**
    * 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.
+   * <p>
+   * <h3>Example 1:</h3>
+   * <pre>{@code
+   *
+   *  List<String> names =
+   *    Ebean.find(Customer.class)
+   *      .select("name")
+   *      .orderBy().asc("name")
+   *      .findSingleAttributeList();
+   *
+   * }</pre>
+   * <p>
+   * <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 or null (if no matching
@@ -202,7 +242,6 @@ public interface ExpressionList<T> extends Serializable {
    * </p>
    *
    * @throws NonUniqueResultException if more than one result was found
-   *
    * @see Query#findUnique()
    */
   @Nullable
@@ -215,10 +254,10 @@ 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> findFutureRowCount();
+  FutureRowCount<T> findFutureCount();
 
   /**
    * Execute find Id's query in a background thread.
@@ -227,7 +266,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();
@@ -239,32 +278,11 @@ 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 using pageIndex and pageSize.
-   * <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.
-   * </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.
-   * </p>
-   * 
-   * @param pageIndex
-   *          The zero based index of the page.
-   * @param pageSize
-   *          The number of beans to return per page.
-   * @return The PagedList
-   */
-  PagedList<T> findPagedList(int pageIndex, int pageSize);
-
   /**
    * Return a PagedList for this query using firstRow and maxRows.
    * <p>
@@ -275,7 +293,7 @@ public interface ExpressionList<T> extends Serializable {
    * If maxRows is not set on the query prior to calling findPagedList() then a
    * PersistenceException is thrown.
    * </p>
-   *
+   * <p>
    * <pre>{@code
    *
    *  PagedList<Order> pagedList = Ebean.find(Order.class)
@@ -292,7 +310,6 @@ public interface ExpressionList<T> extends Serializable {
    * }</pre>
    *
    * @return The PagedList
-   *
    * @see Query#findPagedList()
    */
   PagedList<T> findPagedList();
@@ -300,8 +317,8 @@ public interface ExpressionList<T> extends Serializable {
   /**
    * Return versions of a @History entity bean.
    * <p>
-   *   Generally this query is expected to be a find by id or unique predicates query.
-   *   It will execute the query against the history returning the versions of the bean.
+   * Generally this query is expected to be a find by id or unique predicates query.
+   * It will execute the query against the history returning the versions of the bean.
    * </p>
    */
   List<Version<T>> findVersions();
@@ -309,8 +326,8 @@ public interface ExpressionList<T> extends Serializable {
   /**
    * Return versions of a @History entity bean between the 2 timestamps.
    * <p>
-   *   Generally this query is expected to be a find by id or unique predicates query.
-   *   It will execute the query against the history returning the versions of the bean.
+   * Generally this query is expected to be a find by id or unique predicates query.
+   * It will execute the query against the history returning the versions of the bean.
    * </p>
    */
   List<Version<T>> findVersionsBetween(Timestamp start, Timestamp end);
@@ -323,7 +340,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);
@@ -346,30 +363,43 @@ public interface ExpressionList<T> extends Serializable {
    */
   Query<T> setDistinct(boolean distinct);
 
+  /**
+   * Set the index(es) to search for a document store which uses partitions.
+   * <p>
+   * For example, when executing a query against ElasticSearch with daily indexes we can
+   * explicitly specify the indexes to search against.
+   * </p>
+   *
+   * @param indexName The index or indexes to search against
+   * @return This query
+   * @see Query#setDocIndexName(String)
+   */
+  Query<T> setDocIndexName(String indexName);
+
   /**
    * 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);
@@ -381,6 +411,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>
@@ -397,7 +453,6 @@ public interface ExpressionList<T> extends Serializable {
 
   /**
    * Path exists - for the given path in a JSON document.
-   *
    * <pre>{@code
    *
    *   where().jsonExists("content", "path.other")
@@ -405,13 +460,12 @@ public interface ExpressionList<T> extends Serializable {
    * }</pre>
    *
    * @param propertyName the property that holds a JSON document
-   * @param path the nested path in the JSON document in dot notation
+   * @param path         the nested path in the JSON document in dot notation
    */
   ExpressionList<T> jsonExists(String propertyName, String path);
 
   /**
    * Path does not exist - for the given path in a JSON document.
-   *
    * <pre>{@code
    *
    *   where().jsonNotExists("content", "path.other")
@@ -419,13 +473,13 @@ public interface ExpressionList<T> extends Serializable {
    * }</pre>
    *
    * @param propertyName the property that holds a JSON document
-   * @param path the nested path in the JSON document in dot notation
+   * @param path         the nested path in the JSON document in dot notation
    */
   ExpressionList<T> jsonNotExists(String propertyName, String path);
 
   /**
    * Equal to expression for the value at the given path in the JSON document.
-   *
+   * <p>
    * <pre>{@code
    *
    *   where().jsonEqualTo("content", "path.other", 34)
@@ -433,14 +487,14 @@ public interface ExpressionList<T> extends Serializable {
    * }</pre>
    *
    * @param propertyName the property that holds a JSON document
-   * @param path the nested path in the JSON document in dot notation
-   * @param value the value used to test against the document path's value
+   * @param path         the nested path in the JSON document in dot notation
+   * @param value        the value used to test against the document path's value
    */
   ExpressionList<T> jsonEqualTo(String propertyName, String path, Object value);
 
   /**
    * Not Equal to - for the given path in a JSON document.
-   *
+   * <p>
    * <pre>{@code
    *
    *   where().jsonNotEqualTo("content", "path.other", 34)
@@ -448,14 +502,14 @@ public interface ExpressionList<T> extends Serializable {
    * }</pre>
    *
    * @param propertyName the property that holds a JSON document
-   * @param path the nested path in the JSON document in dot notation
-   * @param value the value used to test against the document path's value
+   * @param path         the nested path in the JSON document in dot notation
+   * @param value        the value used to test against the document path's value
    */
   ExpressionList<T> jsonNotEqualTo(String propertyName, String path, Object value);
 
   /**
    * Greater than - for the given path in a JSON document.
-   *
+   * <p>
    * <pre>{@code
    *
    *   where().jsonGreaterThan("content", "path.other", 34)
@@ -466,7 +520,7 @@ public interface ExpressionList<T> extends Serializable {
 
   /**
    * Greater than or equal to - for the given path in a JSON document.
-   *
+   * <p>
    * <pre>{@code
    *
    *   where().jsonGreaterOrEqual("content", "path.other", 34)
@@ -477,7 +531,7 @@ public interface ExpressionList<T> extends Serializable {
 
   /**
    * Less than - for the given path in a JSON document.
-   *
+   * <p>
    * <pre>{@code
    *
    *   where().jsonLessThan("content", "path.other", 34)
@@ -488,7 +542,7 @@ public interface ExpressionList<T> extends Serializable {
 
   /**
    * Less than or equal to - for the given path in a JSON document.
-   *
+   * <p>
    * <pre>{@code
    *
    *   where().jsonLessOrEqualTo("content", "path.other", 34)
@@ -499,7 +553,7 @@ public interface ExpressionList<T> extends Serializable {
 
   /**
    * Between - for the given path in a JSON document.
-   *
+   * <p>
    * <pre>{@code
    *
    *   where().jsonBetween("content", "orderDate", lowerDateTime, upperDateTime)
@@ -513,7 +567,7 @@ public interface ExpressionList<T> extends Serializable {
    * <p>
    * This returns the list so that add() can be chained.
    * </p>
-   *
+   * <p>
    * <pre>{@code
    *
    * Query<Customer> query = Ebean.find(Customer.class);
@@ -604,7 +658,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>
-   * 
+   * <p>
    * <pre>{@code
    *
    * // create an example bean and set the properties
@@ -612,26 +666,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>
-   * 
+   * <p>
    * Similarly you can create an ExampleExpression
-   * 
+   * <p>
    * <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>
@@ -719,16 +773,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.
    */
@@ -745,12 +814,40 @@ 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.
+   *
+   * @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>
@@ -762,7 +859,7 @@ public interface ExpressionList<T> extends Serializable {
    * then they are not translated. logical property name names (not fully
    * qualified) will still be translated to their physical name.
    * </p>
-   *
+   * <p>
    * <h4>Example:</h4>
    * <pre>{@code
    *
@@ -794,7 +891,7 @@ public interface ExpressionList<T> extends Serializable {
    * then they are not translated. logical property name names (not fully
    * qualified) will still be translated to their physical name.
    * </p>
-   *
+   * <p>
    * <pre>{@code
    *
    *   raw("orderQty < shipQty")
@@ -803,6 +900,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.
    */
@@ -819,22 +957,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>
+   * <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>
+   * <p>
+   * Use endOr() or endJunction() to end the OR junction.
+   * </p>
+   * <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>
+   * <p>
+   * <pre>@{code
+   *
+   *    .where()
+   *      .not()
+   *        .gt("id", 1)
+   *        .eq("anniversary", onAfter)
+   *        .endNot()
+   *
+   * }</pre>
+   * <p>
+   * <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

@@ -21,48 +21,52 @@ import java.io.Serializable;
  * is high (a lot of "Many" beans per "One" bean) then this can be more
  * efficient loaded as 2 SQL queries.
  * </p>
- * 
+ * <p>
  * <pre>{@code
  * // Normal fetch join results in a single SQL query
  * List<Order> list = Ebean.find(Order.class).fetch("details").findList();
- * 
+ *
  * // 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>
- * 
+ * <p>
  * <pre>{@code
+ *
  * // This will use 2 SQL queries to build this object graph
  * List<Order> list =
  *     Ebean.find(Order.class)
  *         .fetch("details", new FetchConfig().query())
  *         .findList();
- * 
+ *
  * // query 1) find order
  * // query 2) find orderDetails where order.id in (?,?...) // first 100 order id's
+ *
  * }</pre>
  * <p>
  * Example: Using 2 "query joins"
  * </p>
- * 
+ * <p>
  * <pre>{@code
+ *
  * // This will use 3 SQL queries to build this object graph
  * List<Order> list =
  *     Ebean.find(Order.class)
  *         .fetch("details", new FetchConfig().query())
  *         .fetch("customer", new FetchConfig().queryFirst(5))
  *         .findList();
- * 
+ *
  * // query 1) find order
  * // query 2) find orderDetails where order.id in (?,?...) // first 100 order id's
  * // query 3) find customer where id in (?,?,?,?,?) // first 5 customers
+ *
  * }</pre>
  * <p>
  * Example: Using "query joins" and partial objects
  * </p>
- * 
+ * <p>
+ *
  * <pre>{@code
  * // This will use 3 SQL queries to build this object graph
  * List<Order> list =
@@ -74,13 +78,13 @@ import java.io.Serializable;
  *         .fetch("customer.contacts")
  *         .fetch("customer.shippingAddress")
  *         .findList();
- * 
+ *
  * // query 1) find order (status, shipDate)
  * // query 2) find orderDetail (quantity, price) fetch product (sku, name) where
  * // order.id in (?,? ...)
  * // query 3) find customer (name) fetch contacts (*) fetch shippingAddress (*)
  * // where id in (?,?,?,?,?)
- * 
+ *
  * // Note: the fetch of "details.product" is automatically included into the
  * // fetch of "details"
  * //
@@ -92,20 +96,21 @@ import java.io.Serializable;
  * immediately and the lazy defines the batch size to use for further lazy
  * loading (if lazy loading is invoked).
  * </p>
- * 
+ * <p>
  * <pre>{@code
+ *
  * List<Order> list =
  *     Ebean.find(Order.class)
  *         .fetch("customer", new FetchConfig().query(10).lazy(5))
  *         .findList();
- * 
+ *
  * // query 1) find order
  * // query 2) find customer where id in (?,?,?,?,?,?,?,?,?,?) // first 10 customers
  * // .. then if lazy loading of customers is invoked
  * // .. use a batch size of 5 to load the customers
- * 
+ *
  * }</pre>
- * 
+ * <p>
  * <p>
  * Example of controlling the lazy loading query:
  * </p>
@@ -113,27 +118,23 @@ import java.io.Serializable;
  * This gives us the ability to optimise the lazy loading query for a given use
  * case.
  * </p>
- * 
+ * <p>
  * <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();
- * 
+ *
  * // 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 (?,?,?,?,?)
- * 
+ * //
+ * // .. if lazy loading of customers is invoked
+ * // .. use a batch size of 5 to load the customers
+ *
  * }</pre>
- * 
+ *
  * @author mario
  * @author rbygrave
  */
@@ -165,9 +166,8 @@ public class FetchConfig implements Serializable {
 
   /**
    * Specify that this path should be lazy loaded with a specified batch size.
-   * 
-   * @param lazyBatchSize
-   *          the batch size for lazy loading
+   *
+   * @param lazyBatchSize the batch size for lazy loading
    */
   public FetchConfig lazy(int lazyBatchSize) {
     this.lazyBatchSize = lazyBatchSize;
@@ -199,9 +199,8 @@ public class FetchConfig implements Serializable {
    * This will load all beans on this path eagerly unless a {@link #lazy(int)}
    * is also used.
    * </p>
-   * 
-   * @param queryBatchSize
-   *          the batch size used to load beans on this path
+   *
+   * @param queryBatchSize the batch size used to load beans on this path
    */
   public FetchConfig query(int queryBatchSize) {
     this.queryBatchSize = queryBatchSize;
@@ -217,9 +216,8 @@ public class FetchConfig implements Serializable {
    * If there are more parent beans than the batch size then they will not be
    * loaded eagerly but instead use lazy loading.
    * </p>
-   * 
-   * @param queryBatchSize
-   *          the number of parent beans this path is populated for
+   *
+   * @param queryBatchSize the number of parent beans this path is populated for
    */
   public FetchConfig queryFirst(int queryBatchSize) {
     this.queryBatchSize = queryBatchSize;
@@ -233,7 +231,7 @@ public class FetchConfig implements Serializable {
   public int getLazyBatchSize() {
     return lazyBatchSize;
   }
-  
+
   /**
    * Return the batch size for separate query load.
    */
@@ -249,4 +247,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/Filter.java

@@ -19,64 +19,63 @@ import java.util.Set;
  * The result of the filter method will leave the original list unmodified and
  * return a new List instance.
  * </p>
- * 
- * <pre class="code">
- * 
+ * <p>
+ * <pre>{@code
+ *
  * // get a list of entities (query execution statistics in this case)
- * 
- * List&lt;MetaQueryStatistic&gt; list =
+ *
+ * List<MetaQueryStatistic> list =
  *     Ebean.find(MetaQueryStatistic.class).findList();
- * 
+ *
  * long nowMinus24Hrs = System.currentTimeMillis() - 24 * (1000 * 60 * 60);
- * 
+ *
  * // sort and filter the list returning a filtered list...
- * 
- * List&lt;MetaQueryStatistic&gt; filteredList =
+ *
+ * List<MetaQueryStatistic> filteredList =
  *     Ebean.filter(MetaQueryStatistic.class)
- *         .sort(&quot;avgTimeMicros desc&quot;)
- *         .gt(&quot;executionCount&quot;, 0)
- *         .gt(&quot;lastQueryTime&quot;, nowMinus24Hrs)
- *         .eq(&quot;autoTuned&quot;, true)
+ *         .sort("avgTimeMicros desc")
+ *         .gt("executionCount", 0)
+ *         .gt("lastQueryTime", nowMinus24Hrs)
+ *         .eq("autoTuned", true)
  *         .maxRows(10)
  *         .filter(list);
- * 
- * </pre>
+ *
+ * }</pre>
  * <p>
  * The propertyNames can traverse the object graph (e.g. customer.name) by using
  * dot notation. If any point during the object graph traversal to get a
  * property value is null then null is returned.
  * </p>
- * 
- * <pre>
- * // examples of property names that 
+ * <p>
+ * <pre>{@code
+ *
+ * // examples of property names that
  * // ... will traverse the object graph
  * // ... where customer is a property of our bean
- * 
+ *
  * customer.name
  * customer.shippingAddress.city
- * </pre>
- * 
- * </p>
- * 
- * <pre class="code">
- * 
+ *
+ * }</pre>
+ * <p>
+ * <pre>{@code
+ *
  * // get a list of entities (query execution statistics)
- * 
- * List&lt;Order&gt; orders =
+ *
+ * List<Order> orders =
  *     Ebean.find(Order.class).findList();
- * 
+ *
  * // Apply a filter...
- * 
- * List&lt;Order&gt; filteredOrders =
+ *
+ * List<Order> filteredOrders =
  *     Ebean.filter(Order.class)
- *         .startsWith(&quot;customer.name&quot;, &quot;Rob&quot;)
- *         .eq(&quot;customer.shippingAddress.city&quot;, &quot;Auckland&quot;)
+ *         .startsWith("customer.name", "Rob")
+ *         .eq("customer.shippingAddress.city", "Auckland")
  *         .filter(orders);
- * 
- * </pre>
- * 
- * @param <T>
- *          the entity bean type
+ *
+ * }</pre>
+ *
+ * @param <T> the entity bean type
  */
 public interface Filter<T> {
 
@@ -189,9 +188,9 @@ public interface Filter<T> {
    * <p>
    * The sourceList will remain unmodified.
    * </p>
-   * 
+   *
    * @return Returns a new list with the sorting and filters applied.
    */
   List<T> filter(List<T> sourceList);
 
-}
+}

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

@@ -11,11 +11,10 @@ import java.util.List;
  * These 'finders' are a place to organise all the finder methods for that bean type
  * and specific finder methods are expected to be added (find by unique properties etc).
  * </p>
- *
  * <h3>Testing</h3>
  * <p>
- *   For testing the mocki-ebean project has the ability to replace the finder implementation
- *
+ * For testing the mocki-ebean project has the ability to replace the finder implementation
+ * <p>
  * </p>
  * <pre>{@code
  *
@@ -61,7 +60,6 @@ public class Finder<I, T> {
 
   /**
    * Create with the type of the entity bean.
-   *
    * <pre>{@code
    *
    * public class CustomerFinder extends Finder<Customer> {
@@ -96,10 +94,8 @@ public class Finder<I, T> {
 
   /**
    * Return the underlying 'default' EbeanServer.
-   *
    * <p>
    * This provides full access to the API such as explicit transaction demarcation etc.
-   *
    */
   public EbeanServer db() {
     return Ebean.getServer(serverName);
@@ -110,9 +106,8 @@ public class Finder<I, T> {
    * <p>
    * This is equivalent to {@link Ebean#getServer(String)}
    *
-   * @param server
-   *          The name of the EbeanServer. If this is null then the default EbeanServer is
-   *          returned.
+   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is
+   *               returned.
    */
   public EbeanServer db(String server) {
     return Ebean.getServer(server);
@@ -120,7 +115,6 @@ public class Finder<I, T> {
 
   /**
    * Creates an entity reference for this ID.
-   *
    * <p>
    * Equivalent to {@link EbeanServer#getReference(Class, Object)}
    */
@@ -130,7 +124,6 @@ public class Finder<I, T> {
 
   /**
    * Retrieves an entity by ID.
-   *
    * <p>
    * Equivalent to {@link EbeanServer#find(Class, Object)}
    */

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

@@ -17,31 +17,30 @@ import java.util.concurrent.TimeoutException;
  * <p>
  * A simple example:
  * </p>
- * 
  * <pre>{@code
+ *
  *  // create a query to find all orders
  * Query<Order> query = Ebean.find(Order.class);
- * 
+ *
  *  // execute the query in a background thread
  *  // immediately returning the futureList
  * FutureList<Order> futureList = query.findFutureList();
- * 
- *  // do something else ... 
- * 
+ *
+ *  // do something else ...
+ *
  * if (!futureList.isDone()){
  * 	// we can cancel the query execution. This will cancel
  * // the underlying query if that is supported by the JDBC
  * // driver and database
  * 	futureList.cancel(true);
  * }
- * 
- * 
+ *
  * if (!futureList.isCancelled()){
  * 	// wait for the query to finish and return the list
  * 	List<Order> list = futureList.get();
  * 	...
  * }
- * 
+ *
  * }</pre>
  */
 public interface FutureList<T> extends Future<List<T>> {
@@ -56,7 +55,6 @@ public interface FutureList<T> extends Future<List<T>> {
    * unchecked PersistenceException.
    *
    * @return The query list result
-   *
    * @throws PersistenceException when a InterruptedException or ExecutionException occurs.
    */
   List<T> getUnchecked();
@@ -66,8 +64,7 @@ public interface FutureList<T> extends Future<List<T>> {
    * and ExecutionException in the unchecked PersistenceException.
    *
    * @return The query list result
-   *
-   * @throws TimeoutException if the wait timed out
+   * @throws TimeoutException     if the wait timed out
    * @throws PersistenceException if a InterruptedException or ExecutionException occurs.
    */
   List<T> getUnchecked(long timeout, TimeUnit unit) throws TimeoutException;

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

@@ -8,7 +8,8 @@ import java.util.concurrent.Future;
  * <p>
  * It extends the java.util.concurrent.Future.
  * </p>
- * 
+ *
+ * @param <T> the BeanType
  * @author rbygrave
  */
 public interface FutureRowCount<T> extends Future<Integer> {

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

@@ -9,70 +9,141 @@ 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),
+
+    /**
+     * FILTER group (for internal use only).
+     */
+    FILTER("filter", "", true),
+
+    /**
+     * 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,44 +1,32 @@
 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;
 
 import javax.persistence.MappedSuperclass;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
 
 /**
  * A MappedSuperclass base class that provides convenience methods for inserting, updating and
  * deleting beans.
- * 
  * <p>
  * By having your entity beans extend this it provides a 'Active Record' style programming model for
  * Ebean users.
- * 
  * <p>
- * Note that there is a avaje-ebeanorm-mocker project that enables you to use Mockito or similar
+ * Note that there is a ebean-mocker project that enables you to use Mockito or similar
  * tools to still mock out the underlying 'default EbeanServer' for testing purposes.
- * 
  * <p>
  * You may choose not use this Model mapped superclass if you don't like the 'Active Record' style
  * or if you believe it 'pollutes' your entity beans.
- *
  * <p>
  * You can use Dependency Injection like Guice or Spring to construct and wire a EbeanServer instance
  * and have that same instance used with this Model and Finder. The way that works is that when the
  * DI container creates the EbeanServer instance it can be registered with the Ebean singleton. In this
  * way the EbeanServer instance can be injected as per normal Guice / Spring dependency injection and
  * that same instance also used to support the Model and Finder active record style.
- *
  * <p>
  * If you choose to use the Model mapped superclass you will probably also chose to additionally add
- * a {@link Find} as a public static field to complete the active record pattern and provide a
+ * a {@link Finder} as a public static field to complete the active record pattern and provide a
  * relatively nice clean way to write queries.
- *
+ * <p>
  * <h3>Typical common @MappedSuperclass</h3>
  * <pre>{@code
  *
@@ -52,34 +40,28 @@ import java.util.UUID;
  *
  *       @Version Long version;
  *
- *       @CreatedTimestamp Timestamp whenCreated;
+ *       @WhenCreated Timestamp whenCreated;
  *
- *       @UpdatedTimestamp Timestamp whenUpdated;
+ *       @WhenUpdated Timestamp whenUpdated;
  *
  *       ...
  *
  * }</pre>
- *
+ * <p>
  * <h3>Extend the Model</h3>
  * <pre>{@code
  *
  *     // Extend the mappedSuperclass
  *
- *     @Entity @Table(name="oto_account")
+ *     @Entity @Table(name="o_account")
  *     public class Customer extends BaseModel {
  *
- *       // Add a static Find
- *       // ... with Long being the type of our @Id property.
- *       // ... Note the {} at the end as Find is an abstract class.
- *
- *       public static final Find<Long,Account> find = new Find<Long,Account>(){};
- *
  *       String name;
  *       ...
  *     }
  *
  * }</pre>
- *
+ * <p>
  * <h3>Modal: save()</h3>
  * <pre>{@code
  *
@@ -91,64 +73,43 @@ import java.util.UUID;
  *     customer.save();
  *
  * }</pre>
- *
- * <h3>Find byId</h3>
- * <pre>{@code
- *
- *     // find byId
- *     Customer customer = Customer.find.byId(42);
- *
- * }</pre>
- *
- * <h3>Find where</h3>
- * <pre>{@code
- *
- *     // find where ...
- *     List<Customer> customers =
- *         Customer.find
- *         .where().gt("startDate", lastMonth)
- *         .findList();
- *
- * }</pre>
  */
 @MappedSuperclass
 public abstract class Model {
 
   /**
    * Return the underlying 'default' EbeanServer.
-   * 
    * <p>
    * This provides full access to the API such as explicit transaction demarcation etc.
-   * 
    * <p>
    * Example:
    * <pre>{@code
    *
    * Transaction transaction = Customer.db().beginTransaction();
    * try {
-   * 
+   *
    *   // turn off cascade persist for this transaction
    *   transaction.setPersistCascade(false);
-   * 
+   *
    *   // extra control over jdbc batching for this transaction
    *   transaction.setBatchGetGeneratedKeys(false);
    *   transaction.setBatchMode(true);
    *   transaction.setBatchSize(20);
-   * 
+   *
    *   Customer customer = new Customer();
    *   customer.setName(&quot;Roberto&quot;);
    *   customer.save();
-   * 
+   *
    *   Customer otherCustomer = new Customer();
    *   otherCustomer.setName("Franko");
    *   otherCustomer.save();
-   * 
+   *
    *   transaction.commit();
-   * 
+   *
    * } finally {
    *   transaction.end();
    * }
-   * 
+   *
    * }</pre>
    */
   public static EbeanServer db() {
@@ -157,13 +118,11 @@ public abstract class Model {
 
   /**
    * Return a named EbeanServer that is typically different to the default server.
-   * 
    * <p>
    * If you are using multiple databases then each database has a name and maps to a single
    * EbeanServer. You can use this method to get an EbeanServer for another database.
-   * 
-   * @param server
-   *          The name of the EbeanServer. If this is null then the default EbeanServer is returned.
+   *
+   * @param server The name of the EbeanServer. If this is null then the default EbeanServer is returned.
    */
   public static EbeanServer db(String server) {
     return Ebean.getServer(server);
@@ -177,16 +136,16 @@ public abstract class Model {
    * <p>
    * An unmodified bean that is saved or updated is normally skipped and this marks the bean as
    * dirty so that it is not skipped.
-   * 
+   * <p>
    * <pre>{@code
-   * 
+   *
    * Customer customer = Customer.find.byId(id);
-   * 
+   *
    * // mark the bean as dirty so that a save() or update() will
    * // increment the version property
    * customer.markAsDirty();
    * customer.save();
-   * 
+   *
    * }</pre>
    *
    * @see EbeanServer#markAsDirty(Object)
@@ -198,7 +157,7 @@ public abstract class Model {
   /**
    * Mark the property as unset or 'not loaded'.
    * <p>
-   *   This would be used to specify a property that we did not wish to include in a stateless update.
+   * This would be used to specify a property that we did not wish to include in a stateless update.
    * </p>
    * <pre>{@code
    *
@@ -216,12 +175,11 @@ public abstract class Model {
    * @param propertyName the name of the property on the bean to be marked as 'unset'
    */
   public void markPropertyUnset(String propertyName) {
-    ((EntityBean)this)._ebean_getIntercept().setPropertyLoaded(propertyName, false);
+    ((EntityBean) this)._ebean_getIntercept().setPropertyLoaded(propertyName, false);
   }
 
   /**
    * Insert or update this entity depending on its state.
-   * 
    * <p>
    * Ebean will detect if this is a new bean or a previously fetched bean and perform either an
    * insert or an update based on that.
@@ -271,6 +229,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.
    */
@@ -301,621 +272,4 @@ public abstract class Model {
     db().refresh(this);
   }
 
-  /**
-   * A concrete implementation of Find.
-   * <p>
-   * It should be preferred to use {@link Find} instead of Finder as that can use reflection to determine the class
-   * literal type of the entity bean.
-   * </p>
-   * @param <I> type of the Id property
-   * @param <T> type of the entity bean
-   */
-  public static class Finder<I, T> extends Find<I, T> {
-
-    /**
-     * Create with the type of the entity bean.
-     *
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   public static final Finder<Long,Customer> find = new Finder<Long,Customer>(Customer.class);
-     *   ...
-     *
-     * }</pre>
-     *
-     * <p/>
-     * The preferred approach is to instead use <code>Find</code> as below. This approach is more DRY in that it does
-     * not require the class literal Customer.class to be passed into the constructor.
-     *
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-     *   ...
-     *
-     * }</pre>
-     */
-    public Finder(Class<T> type) {
-      super(null, type);
-    }
-
-    /**
-     * Create with the type of the entity bean and specific server name.
-     */
-    public Finder(String serverName, Class<T> type) {
-      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);
-    }
-  }
-
-  /**
-   * Helper object for performing queries.
-   * 
-   * <p>
-   * Typically a Find instance is defined as a public static field on an entity bean class to provide a
-   * nice way to write queries.
-   *
-   * <h3>Example use:</h3>
-   *
-   * <pre>{@code
-   *
-   * @Entity
-   * public class Customer extends BaseModel {
-   *
-   *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-   *
-   *   ...
-   *
-   * }</pre>
-   * <p/>
-   * This enables you to write code like:
-   * <pre>{@code
-   *
-   * Customer customer = Customer.find.byId(42L);
-   *
-   * List<Customer> customers =
-   *     Customer.find
-   *         .select("name, dateOfBirth")
-   *         .findList();
-   *
-   * }</pre>
-   *
-   * <h3>Kotlin</h3>
-   * In Kotlin you would typically create Find as a companion object.
-   * <pre>{@code
-   *
-   *   // kotlin
-   *   companion object : Model.Find<Long, Product>() {}
-   *
-   * }</pre>
-   * @param <I>
-   *          The Id type. This is most often a {@link Long} but is also often a {@link UUID} or
-   *          {@link String}.
-   *
-   * @param <T>
-   *          The entity bean type
-   */
-  public static abstract class Find<I, T> {
-
-    /**
-     * The entity bean type.
-     */
-    private final Class<T> type;
-
-    /**
-     * The name of the EbeanServer, null for the default server.
-     */
-    private final String serverName;
-
-    /**
-     * Creates a finder for entity of type <code>T</code> with ID of type <code>I</code>.
-     * <p/>
-     * Typically you create Find as a public static field on each entity bean as the example below.
-     *
-     * <p/>
-     * Note that Find is an abstract class and hence <code>{}</code> is required. This is done so
-     * that the type (class literal) of the entity bean can be derived from the generics parameter.
-     *
-     * <pre>{@code
-     *
-     * @Entity
-     * public class Customer extends BaseModel {
-     *
-     *   // Note the trailing {} as Find is an abstract class.
-     *   // We do this so that we can derive the type literal Customer.class
-     *   // via reflection
-     *   public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
-     *   ...
-     *
-     * }</pre>
-     * <p/>
-     * This enables you to write code like:
-     * <pre>{@code
-     *
-     * Customer customer = Customer.find.byId(42L);
-     *
-     * List<Customer> customers =
-     *     Customer.find
-     *        .select("name, email, dateOfBirth")
-     *        .findList();
-     *
-     * }</pre>
-     *
-     * <h3>Kotlin</h3>
-     * In Kotlin you would typically create it as a companion object.
-     *
-     * <pre>{@code
-     *
-     *   // kotlin
-     *   companion object : Model.Find<Long, Product>() {}
-     *
-     * }</pre>
-     */
-    @SuppressWarnings("unchecked")
-    public Find() {
-      this.serverName = null;
-      this.type = (Class<T>)ClassUtil.getSecondArgumentType(getClass());
-    }
-
-    /**
-     * Construct passing the class literal type of the entity type.
-     */
-    protected Find(String serverName, Class<T> type) {
-      this.serverName = serverName;
-      this.type = type;
-    }
-
-    /**
-     * Return the underlying 'default' EbeanServer.
-     * 
-     * <p>
-     * This provides full access to the API such as explicit transaction demarcation etc.
-     * 
-     */
-    public EbeanServer db() {
-      return Ebean.getServer(serverName);
-    }
-
-    /**
-     * Return typically a different EbeanServer to the default.
-     * <p>
-     * This is equivilent to {@link Ebean#getServer(String)}
-     * 
-     * @param server
-     *          The name of the EbeanServer. If this is null then the default EbeanServer is
-     *          returned.
-     */
-    public EbeanServer db(String server) {
-      return Ebean.getServer(server);
-    }
-
-    /**
-     * Creates a Finder for the named EbeanServer.
-     *
-     * <p>
-     * Create and return a new Finder for a different server.
-     */
-    public Finder<I, T> on(String server) {
-      return new Finder<I, T>(server, type);
-    }
-
-    /**
-     * Delete a bean by Id.
-     * <p>
-     * Equivalent to {@link EbeanServer#delete(Class, Object)}
-     */
-    public void deleteById(I id) {
-      db().delete(type, id);
-    }
-
-    /**
-     * Retrieves all entities of the given type.
-     * 
-     * <p>
-     * This is the same as (synonym for) {@link #findList()}
-     */
-    public List<T> all() {
-      return findList();
-    }
-
-    /**
-     * Retrieves an entity by ID.
-     * 
-     * <p>
-     * Equivalent to {@link EbeanServer#find(Class, Object)}
-     */
-    @Nullable
-    public T byId(I id) {
-      return db().find(type, id);
-    }
-
-    /**
-     * Creates an entity reference for this ID.
-     * 
-     * <p>
-     * Equivalent to {@link EbeanServer#getReference(Class, Object)}
-     */
-    public T ref(I id) {
-      return db().getReference(type, id);
-    }
-
-    /**
-     * Creates a filter for sorting and filtering lists of entities locally without going back to
-     * the database.
-     * <p>
-     * Equivalent to {@link EbeanServer#filter(Class)}
-     */
-    public Filter<T> filter() {
-      return db().filter(type);
-    }
-
-    /**
-     * Creates a query.
-     * <p>
-     * Equivalent to {@link EbeanServer#find(Class)}
-     */
-    public Query<T> query() {
-      return db().find(type);
-    }
-
-    /**
-     * 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)}
-     */
-    public Query<T> apply(PathProperties pathProperties) {
-      return db().find(type).apply(pathProperties);
-    }
-
-    /**
-     * Returns the next identity value.
-     * 
-     * @see EbeanServer#nextId(Class)
-     */
-    @SuppressWarnings("unchecked")
-    public I nextId() {
-      return (I) db().nextId(type);
-    }
-
-    /**
-     * Executes a query and returns the results as a list of IDs.
-     * <p>
-     * Equivalent to {@link Query#findIds()}
-     */
-    public List<Object> findIds() {
-      return query().findIds();
-    }
-
-    /**
-     * Execute the query consuming each bean one at a time.
-     * <p>
-     * This is generally used to process large queries where unlike findList
-     * you do not want to hold all the results in memory at once but instead
-     * process them one at a time (requiring far less memory).
-     * </p>
-     * Equivalent to {@link Query#findEach(QueryEachConsumer)}
-     */
-    public void findEach(QueryEachConsumer<T> consumer) {
-      query().findEach(consumer);
-    }
-
-    /**
-     * Execute the query consuming each bean one at a time.
-     * <p>
-     * Equivalent to {@link Query#findEachWhile(QueryEachWhileConsumer)}
-     * <p>
-     * This is similar to #findEach except that you return boolean
-     * true to continue processing beans and return false to stop
-     * processing early.
-     * </p>
-     * <p>
-     * This is generally used to process large queries where unlike findList
-     * you do not want to hold all the results in memory at once but instead
-     * process them one at a time (requiring far less memory).
-     * </p>
-     * Equivalent to {@link Query#findEachWhile(QueryEachWhileConsumer)}
-     */
-    public void findEachWhile(QueryEachWhileConsumer<T> consumer) {
-      query().findEachWhile(consumer);
-    }
-
-    /**
-     * Retrieves all entities of the given type.
-     * <p>
-     * The same as {@link #all()}
-     * <p>
-     * Equivalent to {@link Query#findList()}
-     */
-    public List<T> findList() {
-      return query().findList();
-    }
-
-    /**
-     * Returns all the entities of the given type as a set.
-     * <p>
-     * Equivalent to {@link Query#findSet()}
-     */
-    public Set<T> findSet() {
-      return query().findSet();
-    }
-
-    /**
-     * Retrieves all entities of the given type as a map of objects.
-     * <p>
-     * Equivalent to {@link Query#findMap()}
-     */
-    public Map<?, 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()}
-     */
-    public FutureRowCount<T> findFutureRowCount() {
-      return query().findFutureRowCount();
-    }
-
-    /**
-     * Returns the total number of entities for this type. *
-     * <p>
-     * Equivalent to {@link Query#findRowCount()}
-     */
-    public int findRowCount() {
-      return query().findRowCount();
-    }
-
-    /**
-     * Returns the <code>ExpressionFactory</code> used by this query.
-     */
-    public ExpressionFactory getExpressionFactory() {
-      return query().getExpressionFactory();
-    }
-
-    /**
-     * Explicitly sets a comma delimited list of the properties to fetch on the 'main' entity bean,
-     * to load a partial object.
-     * <p>
-     * Equivalent to {@link Query#select(String)}
-     */
-    public Query<T> select(String fetchProperties) {
-      return query().select(fetchProperties);
-    }
-
-    /**
-     * Specifies a path to load including all its properties.
-     * <p>
-     * Equivalent to {@link Query#fetch(String)}
-     */
-    public Query<T> fetch(String path) {
-      return query().fetch(path);
-    }
-
-    /**
-     * Additionally specifies a <code>FetchConfig</code> to specify a 'query join' and/or define the
-     * lazy loading query.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, FetchConfig)}
-     */
-    public Query<T> fetch(String path, FetchConfig joinConfig) {
-      return query().fetch(path, joinConfig);
-    }
-
-    /**
-     * Specifies a path to fetch with a specific list properties to include, to load a partial
-     * object.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, String)}
-     */
-    public Query<T> fetch(String path, String fetchProperties) {
-      return query().fetch(path, fetchProperties);
-    }
-
-    /**
-     * Additionally specifies a <code>FetchConfig</code> to use a separate query or lazy loading to
-     * load this path.
-     * <p>
-     * Equivalent to {@link Query#fetch(String, String, FetchConfig)}
-     */
-    public Query<T> fetch(String assocProperty, String fetchProperties, FetchConfig fetchConfig) {
-      return query().fetch(assocProperty, fetchProperties, fetchConfig);
-    }
-
-    /**
-     * Adds expressions to the <code>where</code> clause with the ability to chain on the
-     * <code>ExpressionList</code>.
-     * <p>
-     * Equivalent to {@link Query#where()}
-     */
-    public ExpressionList<T> where() {
-      return query().where();
-    }
-
-    /**
-     * Returns the <code>order by</code> clause so that you can append an ascending or descending
-     * property to the <code>order by</code> clause.
-     * <p>
-     * This is exactly the same as {@link #orderBy}.
-     * <p>
-     * Equivalent to {@link Query#order()}
-     */
-    public OrderBy<T> order() {
-      return query().order();
-    }
-
-    /**
-     * Sets the <code>order by</code> clause, replacing the existing <code>order by</code> clause if
-     * there is one.
-     * <p>
-     * This is exactly the same as {@link #orderBy(String)}.
-     */
-    public Query<T> order(String orderByClause) {
-      return query().order(orderByClause);
-    }
-
-    /**
-     * Returns the <code>order by</code> clause so that you can append an ascending or descending
-     * property to the <code>order by</code> clause.
-     * <p>
-     * This is exactly the same as {@link #order}.
-     * <p>
-     * Equivalent to {@link Query#orderBy()}
-     */
-    public OrderBy<T> orderBy() {
-      return query().orderBy();
-    }
-
-    /**
-     * Set the <code>order by</code> clause replacing the existing <code>order by</code> clause if
-     * there is one.
-     * <p>
-     * This is exactly the same as {@link #order(String)}.
-     */
-    public Query<T> orderBy(String orderByClause) {
-      return query().orderBy(orderByClause);
-    }
-
-    /**
-     * Sets the first row to return for this query.
-     * <p>
-     * Equivalent to {@link Query#setFirstRow(int)}
-     */
-    public Query<T> setFirstRow(int firstRow) {
-      return query().setFirstRow(firstRow);
-    }
-
-    /**
-     * Sets the maximum number of rows to return in the query.
-     * <p>
-     * Equivalent to {@link Query#setMaxRows(int)}
-     */
-    public Query<T> setMaxRows(int maxRows) {
-      return query().setMaxRows(maxRows);
-    }
-
-    /**
-     * Sets the ID value to query.
-     * 
-     * <p>
-     * Use this to perform a find byId query but with additional control over the query such as
-     * using select and fetch to control what parts of the object graph are returned.
-     * <p>
-     * Equivalent to {@link Query#setId(Object)}
-     */
-    public Query<T> setId(Object id) {
-      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>
-     * Equivalent to {@link Query#setRawSql(RawSql)}
-     */
-    public Query<T> setRawSql(RawSql rawSql) {
-      return query().setRawSql(rawSql);
-    }
-
-    /**
-     * Create a query with explicit 'AutoTune' use.
-     */
-    public Query<T> setAutoTune(boolean autoTune) {
-      return query().setAutoTune(autoTune);
-    }
-
-    /**
-     * Create a query with the select with "for update" specified.
-     * 
-     * <p>
-     * This will typically create row level database locks on the selected rows.
-     */
-    public Query<T> setForUpdate(boolean forUpdate) {
-      return query().setForUpdate(forUpdate);
-    }
-
-    /**
-     * Create a query specifying whether the returned beans will be read-only.
-     */
-    public Query<T> setReadOnly(boolean readOnly) {
-      return query().setReadOnly(readOnly);
-    }
-
-    /**
-     * Create a query specifying if the beans should be loaded into the L2 cache.
-     */
-    public Query<T> setLoadBeanCache(boolean loadBeanCache) {
-      return query().setLoadBeanCache(loadBeanCache);
-    }
-
-    /**
-     * Create a query specifying if the L2 bean cache should be used.
-     */
-    public Query<T> setUseCache(boolean useBeanCache) {
-      return query().setUseCache(useBeanCache);
-    }
-
-    /**
-     * Create a query specifying if the L2 query cache should be used.
-     */
-    public Query<T> setUseQueryCache(boolean useQueryCache) {
-      return query().setUseQueryCache(useQueryCache);
-    }
-
-  }
-}
+}

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

@@ -28,9 +28,9 @@ public final class OrderBy<T> implements Serializable {
    * Create an empty OrderBy with no associated query.
    */
   public OrderBy() {
-    this.list = new ArrayList<Property>(3);
+    this.list = new ArrayList<>(3);
   }
-  
+
   private OrderBy(List<Property> list) {
     this.list = list;
   }
@@ -52,7 +52,7 @@ public final class OrderBy<T> implements Serializable {
    */
   public OrderBy(Query<T> query, String orderByClause) {
     this.query = query;
-    this.list = new ArrayList<Property>(3);
+    this.list = new ArrayList<>(3);
     parse(orderByClause);
   }
 
@@ -60,8 +60,8 @@ public final class OrderBy<T> implements Serializable {
    * Reverse the ascending/descending order on all the properties.
    */
   public void reverse() {
-    for (int i = 0; i < list.size(); i++) {
-      list.get(i).reverse();
+    for (Property aList : list) {
+      aList.reverse();
     }
   }
 
@@ -88,8 +88,8 @@ public final class OrderBy<T> implements Serializable {
    */
   public boolean containsProperty(String propertyName) {
 
-    for (int i = 0; i < list.size(); i++) {
-      if (propertyName.equals(list.get(i).getProperty())) {
+    for (Property aList : list) {
+      if (propertyName.equals(aList.getProperty())) {
         return true;
       }
     }
@@ -100,13 +100,13 @@ public final class OrderBy<T> implements Serializable {
    * Return a copy of this OrderBy with the path trimmed.
    */
   public OrderBy<T> copyWithTrim(String path) {
-    List<Property> newList = new ArrayList<Property>(list.size());
-    for (int i = 0; i < list.size(); i++) {
-      newList.add(list.get(i).copyWithTrim(path));
+    List<Property> newList = new ArrayList<>(list.size());
+    for (Property aList : list) {
+      newList.add(aList.copyWithTrim(path));
     }
-    return new OrderBy<T>(newList);
+    return new OrderBy<>(newList);
   }
-  
+
   /**
    * Return the properties for this OrderBy.
    */
@@ -141,13 +141,20 @@ public final class OrderBy<T> implements Serializable {
    */
   public OrderBy<T> copy() {
 
-    OrderBy<T> copy = new OrderBy<T>();
-    for (int i = 0; i < list.size(); i++) {
-      copy.add(list.get(i).copy());
+    OrderBy<T> copy = new OrderBy<>();
+    for (Property aList : list) {
+      copy.add(aList.copy());
     }
     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.
    */
@@ -185,7 +192,7 @@ public final class OrderBy<T> implements Serializable {
     if (!(obj instanceof OrderBy<?>)) {
       return false;
     }
-    
+
     OrderBy<?> e = (OrderBy<?>) obj;
     return e.list.equals(list);
   }
@@ -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);
     }
 
     /**
@@ -322,9 +356,8 @@ public final class OrderBy<T> implements Serializable {
     }
 
     String[] chunks = orderByClause.split(",");
-    for (int i = 0; i < chunks.length; i++) {
-
-      String[] pairs = chunks[i].split(" ");
+    for (String chunk : chunks) {
+      String[] pairs = chunk.split(" ");
       Property p = parseProperty(pairs);
       if (p != null) {
         list.add(p);
@@ -337,10 +370,10 @@ public final class OrderBy<T> implements Serializable {
       return null;
     }
 
-    ArrayList<String> wordList = new ArrayList<String>(pairs.length);
-    for (int i = 0; i < pairs.length; i++) {
-      if (!isEmptyString(pairs[i])) {
-        wordList.add(pairs[i]);
+    ArrayList<String> wordList = new ArrayList<>(pairs.length);
+    for (String pair : pairs) {
+      if (!isEmptyString(pair)) {
+        wordList.add(pair);
       }
     }
     if (wordList.isEmpty()) {
@@ -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

@@ -8,7 +8,7 @@ import java.util.concurrent.Future;
  * <p>
  * The benefit of using PagedList over just using the normal Query with
  * {@link Query#setFirstRow(int)} and {@link Query#setMaxRows(int)} is that it additionally wraps
- * functionality that can call {@link Query#findFutureRowCount()} to determine total row count,
+ * functionality that can call {@link Query#findFutureCount()} to determine total row count,
  * total page count etc.
  * </p>
  * <p>
@@ -16,8 +16,7 @@ import java.util.concurrent.Future;
  * the query. This translates into SQL that uses limit offset, rownum or row_number function to
  * limit the result set.
  * </p>
- *
- *
+ * <p>
  * <h4>Example: typical use including total row count</h4>
  * <pre>{@code
  *
@@ -43,32 +42,7 @@ import java.util.concurrent.Future;
  *     int totalRowCount = pagedList.getTotalRowCount();
  *
  * }</pre>
- *
- * <h4>Example: typical use including total row count</h4>
- * <pre>{@code
- *
- *     // We want to find the first 100 new orders
- *     //  ... 0 means first page
- *     //  ... page size is 100
- *
- *     PagedList<Order> pagedList
- *       = ebeanServer.find(Order.class)
- *       .where().eq("status", Order.Status.NEW)
- *       .order().asc("id")
- *       .findPagedList(0, 100);
- *
- *     // 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>
- *
+ * <p>
  * <h4>Example: No total row count required</h4>
  * <pre>{@code
  *
@@ -81,10 +55,8 @@ import java.util.concurrent.Future;
  *
  * }</pre>
  *
- * @param <T>
- *          the entity bean type
- * 
- * @see Query#findPagedList(int, int)
+ * @param <T> the entity bean type
+ * @see Query#findPagedList()
  */
 public interface PagedList<T> {
 
@@ -103,14 +75,13 @@ public interface PagedList<T> {
    *     int totalRowCount = pagedList.getTotalRowCount();
    *
    * }</pre>
-   *
    * <p>
    * Also note that using loadRowCount() and getTotalRowCount() rather than getFutureRowCount()
    * means that exceptions ExecutionException, InterruptedException, TimeoutException are instead
    * wrapped in the unchecked PersistenceException (which might be preferrable).
    * </p>
    */
-  void loadRowCount();
+  void loadCount();
 
   /**
    * Return the Future row count. You might get this if you wish to cancel the total row count query
@@ -138,7 +109,7 @@ public interface PagedList<T> {
    *
    * }</pre>
    */
-  Future<Integer> getFutureRowCount();
+  Future<Integer> getFutureCount();
 
   /**
    * Return the list of entities for this page.
@@ -170,7 +141,7 @@ public interface PagedList<T> {
    *
    * }</pre>
    */
-  int getTotalRowCount();
+  int getTotalCount();
 
   /**
    * Return the total number of pages based on the page size and total row count.
@@ -181,20 +152,19 @@ public interface PagedList<T> {
    */
   int getTotalPageCount();
 
-  /**
-   * Return the index position of this page. Zero based.
-   * <p>
-   * Note that if firstRows/maxRows is used rather than pageIndex/pageSize then
-   * this always returns 0.
-   * </p>
-   */
-  int getPageIndex();
-
   /**
    * Return the page size used for this query. This is the same value as maxRows used by the query.
    */
   int getPageSize();
 
+  /**
+   * Return the index position of this page (Zero based).
+   * <p>
+   * This is a calculated value based on firstRow/maxRows.
+   * </p>
+   */
+  int getPageIndex();
+
   /**
    * Return true if there is a next page.
    * <p>
@@ -217,11 +187,8 @@ public interface PagedList<T> {
    * the total row count query if it has not already been invoked.
    * </p>
    *
-   * @param to
-   *          String to put between the first and last row
-   * @param of
-   *          String to put between the last row and the total row count
-   * 
+   * @param to String to put between the first and last row
+   * @param of String to put between the last row and the total row count
    * @return String of the format XtoYofZ.
    */
   String getDisplayXtoYofZ(String to, String of);

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

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

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

@@ -71,6 +71,9 @@ class PrimaryServer {
         }
       }
     }
+    if (defaultServerName == null) {
+      defaultServerName = "db";
+    }
     return defaultServerName;
   }
 
@@ -78,6 +81,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/QueryEachConsumer.java

@@ -1,41 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to process a query result one bean at a time via a callback to this
- * visitor.
- * <p>
- * If you wish to stop further processing return false from the accept method.
- * </p>
- * <p>
- * Unlike findList() and findSet() using a QueryResultVisitor does not require
- * all the beans in the query result to be held in memory at once. This makes
- * QueryResultVisitor useful for processing large queries.
- * </p>
- *
- * <pre>{@code
- *
- * Query<Customer> query = server.find(Customer.class)
- *     .where().eq("status", Status.NEW)
- *     .order().asc("id");
- *
- * query.findEach((Customer customer) -> {
- *
- *     // do something with customer
- *     System.out.println("-- visit " + customer);
- * });
- *
- * }</pre>
- * 
- * @param <T>
- *          the type of entity bean being queried.
- */
-public interface QueryEachConsumer<T> {
-
-  /**
-   * Process the bean.
-   * 
-   * @param bean
-   *          the entity bean to process
-   */
-  void accept(T bean);
-}

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

@@ -1,45 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to process a query result one bean at a time via a callback to this
- * visitor.
- * <p>
- * If you wish to stop further processing return false from the accept method.
- * </p>
- * <p>
- * Unlike findList() and findSet() using a QueryResultVisitor does not require
- * all the beans in the query result to be held in memory at once. This makes
- * QueryResultVisitor useful for processing large queries.
- * </p>
- * <p/>
- * <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;)
- *     .setMaxRows(2);
- *
- * query.findEachWhile((Customer customer) -> {
- *
- *     // do something with customer
- *     System.out.println(&quot;-- visit &quot; + customer);
- *
- *     // return true to continue processing or false to stop
- *     return (customer.getId() < 40);
- * });
- * </pre>
- *
- * @param <T> the type of entity bean being queried.
- */
-public interface QueryEachWhileConsumer<T> {
-
-  /**
-   * Process the bean and return true if you want to continue processing more
-   * beans. Return false if you want to stop processing further.
-   *
-   * @param bean the entity bean to process
-   * @return true to continue processing more beans or false to stop.
-   */
-  boolean accept(T bean);
-}

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

@@ -10,31 +10,51 @@ import java.util.Iterator;
  * findList(), findSet() etc where all the beans are held in the List or Set
  * etc).
  * </p>
- * 
- * <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;)
+ * <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. Use "try with resources" or ensure it
+ * is closed in a finally block.
+ * </p>
+ * <h3>Try finally style</h3>
+ * <pre>{@code
+ *
+ *  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
- * 
- * @param <T>
- *          the type of entity bean in the iteration
+ *
+ *  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>
+ * <p>
+ * <h3>Try with resources style</h3>
+ * <pre>{@code
+ *
+ *  // try with resources
+ *  try (QueryIterator<Customer> it = query.findIterate()) {
+ *    while (it.hasNext()) {
+ *      Customer customer = it.next();
+ *      // do something with customer ...
+ *    }
+ *  }
+ *
+ * }</pre>
+ *
+ * @param <T> the type of entity bean in the iteration
  */
 public interface QueryIterator<T> extends Iterator<T>, java.io.Closeable {
 

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

@@ -1,10 +1,15 @@
 package com.avaje.ebean;
 
+import com.avaje.ebean.util.CamelCaseHelper;
+
 import java.io.Serializable;
 import java.sql.ResultSet;
-import java.util.*;
-
-import com.avaje.ebean.util.CamelCaseHelper;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Used to build object graphs based on a raw SQL statement (rather than
@@ -51,39 +56,38 @@ import com.avaje.ebean.util.CamelCaseHelper;
  * to hold the values for the aggregate functions (sum etc) and a @OneToOne
  * to Order.
  * </p>
- *
+ * <p>
  * <h3>Example OrderAggregate</h3>
- * 
  * <pre>{@code
  *  ...
  *  // @Sql indicates to that this bean
  *  // is based on RawSql rather than a table
- * 
+ *
  * @Entity
  * @Sql
  * public class OrderAggregate {
- * 
+ *
  *  @OneToOne
  *  Order order;
- *      
+ *
  *  Double totalAmount;
- *  
+ *
  *  Double totalItems;
- *  
+ *
  *  // getters and setters
  *  ...
  *
  * }</pre>
- *
+ * <p>
  * <h3>Example 1:</h3>
- * 
+ * <p>
  * <pre>{@code
  *
  *   String sql = " select order_id, o.status, c.id, c.name, sum(d.order_qty*d.unit_price) as totalAmount"
  *     + " from o_order o"
  *     + " join o_customer c on c.id = o.kcustomer_id "
  *     + " join o_order_detail d on d.order_id = o.id " + " group by order_id, o.status ";
- * 
+ *
  *   RawSql rawSql = RawSqlBuilder.parse(sql)
  *     // map the sql result columns to bean properties
  *     .columnMapping("order_id", "order.id")
@@ -93,35 +97,34 @@ import com.avaje.ebean.util.CamelCaseHelper;
  *     // we don't need to map this one due to the sql column alias
  *     // .columnMapping("sum(d.order_qty*d.unit_price)", "totalAmount")
  *     .create();
- * 
+ *
  *   List<OrderAggregate> list = Ebean.find(OrderAggregate.class)
  *       .setRawSql(rawSql)
  *       .where().gt("order.id", 0)
  *       .having().gt("totalAmount", 20)
  *       .findList();
- * 
+ *
  *
  * }</pre>
- * 
+ * <p>
  * <h3>Example 2:</h3>
- * 
  * <p>
  * The following example uses a FetchConfig().query() so that after the initial
  * RawSql query is executed Ebean executes a secondary query to fetch the
  * associated order status, orderDate along with the customer name.
  * </p>
- * 
+ * <p>
  * <pre>{@code
  *
  *  String sql = " select order_id, 'ignoreMe', sum(d.order_qty*d.unit_price) as totalAmount "
  *     + " from o_order_detail d"
  *     + " group by order_id ";
- * 
+ *
  *   RawSql rawSql = RawSqlBuilder.parse(sql)
  *     .columnMapping("order_id", "order.id")
  *     .columnMappingIgnore("'ignoreMe'")
  *     .create();
- * 
+ *
  *   List<OrderAggregate> orders = Ebean.find(OrderAggregate.class)
  *     .setRawSql(rawSql)
  *     .fetch("order", "status,orderDate", new FetchConfig().query())
@@ -131,13 +134,12 @@ import com.avaje.ebean.util.CamelCaseHelper;
  *     .order().desc("totalAmount")
  *     .setMaxRows(10)
  *     .findList();
- * 
+ *
  * }</pre>
- *
- *
+ * <p>
  * <h3>Example 3: tableAliasMapping</h3>
  * <p>
- *   Instead of mapping each column you can map each table alias to a path using tableAliasMapping().
+ * Instead of mapping each column you can map each table alias to a path using tableAliasMapping().
  * </p>
  * <pre>{@code
  *
@@ -162,19 +164,17 @@ import com.avaje.ebean.util.CamelCaseHelper;
  *       .findList();
  *
  * }</pre>
- *
- *
+ * <p>
  * <p>
  * Note that lazy loading also works with object graphs built with RawSql.
  * </p>
- * 
  */
 public final class RawSql implements Serializable {
 
   private static final long serialVersionUID = 1L;
 
   private final ResultSet resultSet;
-  
+
   private final Sql sql;
 
   private final ColumnMapping columnMapping;
@@ -192,7 +192,7 @@ public final class RawSql implements Serializable {
     this.sql = null;
     this.columnMapping = new ColumnMapping(propertyNames);
   }
-  
+
   protected RawSql(ResultSet resultSet, Sql sql, ColumnMapping columnMapping) {
     this.resultSet = resultSet;
     this.sql = sql;
@@ -206,7 +206,15 @@ 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,
-        String preHaving, boolean andHavingExpr, String orderByPrefix, String orderBy, boolean distinct) {
+    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,19 +292,11 @@ 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 + "]";
       }
-      return "select[" + preFrom + "] preWhere[" + preWhere + "] preHaving[" + preHaving
-          + "] orderBy[" + orderBy + "]";
+      return "select[" + preFrom + "] preWhere[" + preWhere + "] preHaving[" + preHaving + "] orderBy[" + orderBy + "]";
     }
 
     public boolean isDistinct() {
@@ -399,28 +385,24 @@ public final class RawSql implements Serializable {
     private final LinkedHashMap<String, Column> dbColumnMap;
 
     private final Map<String, String> propertyMap;
-    
+
     private final Map<String, Column> propertyColumnMap;
 
     private final boolean parsed;
 
     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;
       this.propertyColumnMap = null;
-      this.dbColumnMap = new LinkedHashMap<String, Column>();
-      for (int i = 0; i < columns.size(); i++) {
-        Column c = columns.get(i);
-        dbColumnMap.put(c.getDbColumn(), c);
+      this.dbColumnMap = new LinkedHashMap<>();
+      for (Column c : columns) {
+        dbColumnMap.put(c.getDbColumnKey(), c);
       }
     }
 
@@ -428,14 +410,13 @@ public final class RawSql implements Serializable {
      * Construct for unparsed sql.
      */
     protected ColumnMapping() {
-      this.queryHashCode = 0;
       this.immutable = false;
       this.parsed = false;
       this.propertyMap = null;
       this.propertyColumnMap = null;
-      this.dbColumnMap = new LinkedHashMap<String, Column>();
+      this.dbColumnMap = new LinkedHashMap<>();
     }
-    
+
     /**
      * Construct for ResultSet use.
      */
@@ -443,17 +424,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;
+      this.dbColumnMap = new LinkedHashMap<>();
+
       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 +441,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>();
+      HashMap<String, Column> pcMap = new HashMap<>();
+      HashMap<String, String> pMap = new HashMap<>();
 
       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();
     }
 
     /**
@@ -489,9 +474,8 @@ public final class RawSql implements Serializable {
 
     /**
      * Creates an immutable copy of this ColumnMapping.
-     * 
-     * @throws IllegalStateException
-     *           when a propertyName has not been defined for a column.
+     *
+     * @throws IllegalStateException when a propertyName has not been defined for a column.
      */
     protected ColumnMapping createImmutableCopy() {
 
@@ -513,24 +497,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.
@@ -591,7 +564,7 @@ public final class RawSql implements Serializable {
      */
     public void tableAliasMapping(String tableAlias, String path) {
 
-      String startMatch = tableAlias+".";
+      String startMatch = tableAlias + ".";
       for (Map.Entry<String, Column> entry : dbColumnMap.entrySet()) {
         if (entry.getKey().startsWith(startMatch)) {
           entry.getValue().tableAliasMapping(path);
@@ -630,9 +603,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) {
@@ -648,6 +621,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;
       }
@@ -659,6 +653,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).
        */
@@ -666,13 +668,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.
        */
@@ -699,4 +694,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

@@ -1,17 +1,17 @@
 package com.avaje.ebean;
 
-import java.sql.ResultSet;
-
 import com.avaje.ebean.RawSql.ColumnMapping;
 import com.avaje.ebean.RawSql.Sql;
 
+import java.sql.ResultSet;
+
 /**
  * Builds RawSql instances from a SQL string and column mappings.
  * <p>
  * Note that RawSql can also be defined in ebean-orm.xml files and be used as a
  * named query.
  * </p>
- * 
+ *
  * @see RawSql
  */
 public class RawSqlBuilder {
@@ -22,7 +22,7 @@ public class RawSqlBuilder {
   public static final String IGNORE_COLUMN = "$$_IGNORE_COLUMN_$$";
 
   private final ResultSet resultSet;
-  
+
   private final Sql sql;
 
   private final ColumnMapping columnMapping;
@@ -37,7 +37,7 @@ public class RawSqlBuilder {
   public static RawSql resultSet(ResultSet resultSet, String... propertyNames) {
     return new RawSql(resultSet, propertyNames);
   }
-  
+
   /**
    * Return an unparsed RawSqlBuilder. Unlike a parsed one this query can not be
    * modified - so no additional WHERE or HAVING expressions can be added to
@@ -70,7 +70,7 @@ public class RawSqlBuilder {
     ColumnMapping mapping = DRawSqlColumnsParser.parse(select);
     return new RawSqlBuilder(sql2, mapping);
   }
-  
+
   private RawSqlBuilder(Sql sql, ColumnMapping columnMapping) {
     this.sql = sql;
     this.columnMapping = columnMapping;
@@ -83,11 +83,9 @@ public class RawSqlBuilder {
    * For Unparsed SQL the columnMapping MUST be defined in the same order that
    * the columns appear in the SQL statement.
    * </p>
-   * 
-   * @param dbColumn
-   *          the DB column that we are mapping to a bean property
-   * @param propertyName
-   *          the bean property that we are mapping the DB column to.
+   *
+   * @param dbColumn     the DB column that we are mapping to a bean property
+   * @param propertyName the bean property that we are mapping the DB column to.
    */
   public RawSqlBuilder columnMapping(String dbColumn, String propertyName) {
     columnMapping.columnMapping(dbColumn, propertyName);
@@ -130,6 +128,4 @@ public class RawSqlBuilder {
     return sql;
   }
 
-
-
 }

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

@@ -1,167 +0,0 @@
-package com.avaje.ebean;
-
-class SimpleTextParser {
-
-  private final String oql;
-  private final char[] chars;
-  private final int eof;
-
-  private int pos;
-  private String word;
-  private String lowerWord;
-
-  SimpleTextParser(String oql) {
-    this.oql = oql;
-    this.chars = oql.toCharArray();
-    this.eof = oql.length();
-  }
-
-  public int getPos() {
-    return pos;
-  }
-
-  public String getWord() {
-    return word;
-  }
-
-  public String peekNextWord() {
-    int origPos = pos;
-    String nw = nextWordInternal();
-    pos = origPos;
-    return nw;
-  }
-
-  /**
-   * Match the current and the next word.
-   */
-  public boolean isMatch(String lowerMatch, String nextWordMatch) {
-
-    if (isMatch(lowerMatch)) {
-      String nw = peekNextWord();
-      if (nw != null) {
-        nw = nw.toLowerCase();
-        return nw.equals(nextWordMatch);
-      }
-    }
-    return false;
-  }
-
-  public boolean isFinished() {
-    return word == null;
-  }
-
-  public int findWordLower(String lowerMatch, int afterPos) {
-    this.pos = afterPos;
-    return findWordLower(lowerMatch);
-  }
-
-  public int findWordLower(String lowerMatch) {
-    do {
-      if (nextWord() == null) {
-        return -1;
-      }
-      if (lowerMatch.equals(lowerWord)) {
-        return pos - lowerWord.length();
-      }
-    } while (true);
-  }
-
-  /**
-   * Match the current word.
-   */
-  public boolean isMatch(String lowerMatch) {
-    return lowerMatch.equals(lowerWord);
-  }
-
-  public String nextWord() {
-    word = nextWordInternal();
-    if (word != null) {
-      lowerWord = word.toLowerCase();
-    }
-    return word;
-  }
-
-  private String nextWordInternal() {
-    trimLeadingWhitespace();
-    if (pos >= eof) {
-      return null;
-    }
-    int start = pos;
-    if (chars[pos] == '(') {
-      moveToClose();
-    } else {
-      moveToEndOfWord();
-    }
-    return oql.substring(start, pos);
-  }
-
-  private void moveToClose() {
-
-    pos++;
-    int openParenthesisCount = 0;
-
-    for (; pos < eof; pos++) {
-      char c = chars[pos];
-      if (c == '(') {
-        // count nested parenthesis
-        openParenthesisCount++;
-
-      } else if (c == ')') {
-        if (openParenthesisCount > 0) {
-          // still in nested parenthesis
-          --openParenthesisCount;
-        } else {
-          // we have found the end
-          pos++;
-          return;
-        }
-      }
-    }
-  }
-
-  private void moveToEndOfWord() {
-    char c = chars[pos];
-    boolean isOperator = isOperator(c);
-    for (; pos < eof; pos++) {
-      c = chars[pos];
-      if (isWordTerminator(c, isOperator)) {
-        return;
-      }
-    }
-  }
-
-  private boolean isWordTerminator(char c, boolean isOperator) {
-    if (Character.isWhitespace(c)) {
-      return true;
-    }
-    if (isOperator(c)) {
-      return !isOperator;
-    }
-    return c == '(' || isOperator;
-  }
-
-  private boolean isOperator(char c) {
-    switch (c) {
-    case '<':
-      return true;
-    case '>':
-      return true;
-    case '=':
-      return true;
-    case '!':
-      return true;
-
-    default:
-      return false;
-    }
-  }
-
-  private void trimLeadingWhitespace() {
-    for (; pos < eof; pos++) {
-      char c = chars[pos];
-      if (!Character.isWhitespace(c)) {
-        break;
-      }
-    }
-  }
-}

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,8 @@ package com.avaje.ebean;
 
 import java.io.Serializable;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 /**
  * Query object for performing native SQL queries that return SqlRow's.
@@ -20,46 +20,48 @@ import java.util.Set;
  * The returned SqlRow objects are similar to a LinkedHashMap with some type
  * 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
- * 
- * String sql = &quot;select id, name from customer where name like :name and status_code = :status&quot;;
- * 
- * SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
- * sqlQuery.setParameter(&quot;name&quot;, &quot;Acme%&quot;);
- * sqlQuery.setParameter(&quot;status&quot;, &quot;ACTIVE&quot;);
- * 
- * // execute the query returning a List of MapBean objects
- * List&lt;SqlRow&gt; list = sqlQuery.findList();
- * </pre>
- * 
+ * <p>
+ * <pre>{@code
+ *
+ *   // its typically a good idea to use a named query
+ *   // and put the sql in the orm.xml instead of in your code
+ *
+ *   String sql = "select id, name from customer where name like :name and status_code = :status";
+ *
+ *   SqlQuery sqlQuery = Ebean.createSqlQuery(sql);
+ *   sqlQuery.setParameter("name", "Acme%");
+ *   sqlQuery.setParameter("status", "ACTIVE");
+ *
+ *   // execute the query returning a List of MapBean objects
+ *   List<SqlRow> list = sqlQuery.findList();
+ *
+ * }</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(Consumer<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(Predicate<SqlRow> consumer);
 
   /**
    * Execute the query returning a single row or null.
@@ -70,19 +72,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 +82,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 +92,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>
@@ -133,9 +99,8 @@ public interface SqlQuery extends Serializable {
    * preparedStatement. If the timeout occurs an exception will be thrown - this
    * will be a SQLException wrapped up in a PersistenceException.
    * </p>
-   * 
-   * @param secs
-   *          the query timeout limit in seconds. Zero means there is no limit.
+   *
+   * @param secs the query timeout limit in seconds. Zero means there is no limit.
    */
   SqlQuery setTimeout(int secs);
 

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

@@ -16,19 +16,21 @@ package com.avaje.ebean;
  * notify Ebean of external changes and enable Ebean to maintain it's "L2"
  * server cache.
  * </p>
- * 
- * <pre class="code">
- * // example that uses 'named' parameters 
- * String s = &quot;UPDATE f_topic set post_count = :count where id = :id&quot;
+ * <p>
+ * <pre>{@code
+ *
+ * // example that uses 'named' parameters
+ * String s = "UPDATE f_topic set post_count = :count where id = :id";
  * SqlUpdate update = Ebean.createSqlUpdate(s);
- * update.setParameter(&quot;id&quot;, 1);
- * update.setParameter(&quot;count&quot;, 50);
- * 
+ * update.setParameter("id", 1);
+ * update.setParameter("count", 50);
+ *
  * int modifiedCount = Ebean.execute(update);
- * 
- * String msg = &quot;There where &quot; + modifiedCount + &quot;rows updated&quot;
- * </pre>
- * 
+ *
+ * String msg = "There were " + modifiedCount + " rows updated";
+ *
+ * }</pre>
+ *
  * @see Update
  * @see SqlQuery
  * @see CallableSql
@@ -47,7 +49,7 @@ public interface SqlUpdate {
    * {@link Transaction#setBatchMode(boolean)} and
    * {@link Transaction#setBatchSize(int)}.
    * </p>
-   * 
+   *
    * @see com.avaje.ebean.Ebean#execute(SqlUpdate)
    */
   int execute();
@@ -117,8 +119,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 +144,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>
+   * <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
@@ -139,23 +279,23 @@ public interface Transaction extends Closeable {
    * <p>
    * Example: batch processing executing every 3 rows
    * </p>
-   * 
+   * <p>
    * <pre>{@code
    *
    * String data = "This is a simple test of the batch processing"
    *             + " mode and the transaction execute batch method";
-   * 
+   *
    * String[] da = data.split(" ");
-   * 
+   *
    * String sql = "{call sp_t3(?,?)}";
-   * 
+   *
    * CallableSql cs = new CallableSql(sql);
    * cs.registerOut(2, Types.INTEGER);
-   * 
+   *
    * // (optional) inform eBean this stored procedure
    * // inserts into a table called sp_test
    * cs.addModification("sp_test", true, false, false);
-   * 
+   *
    * Transaction txn = ebeanServer.beginTransaction();
    * txn.setBatchMode(true);
    * txn.setBatchSize(3);
@@ -164,16 +304,15 @@ public interface Transaction extends Closeable {
    *     cs.setParameter(1, da[i]);
    *     ebeanServer.execute(cs);
    *   }
-   * 
+   *
    *   // NB: commit implicitly flushes
    *   txn.commit();
-   * 
+   *
    * } finally {
    *   txn.end();
    * }
    *
    * }</pre>
-   * 
    */
   void setBatchMode(boolean useBatch);
 
@@ -185,7 +324,6 @@ public interface Transaction extends Closeable {
    * </p>
    *
    * @param persistBatchMode the batch mode to use for this transaction
-   *
    * @see com.avaje.ebean.config.ServerConfig#setPersistBatch(com.avaje.ebean.config.PersistBatch)
    */
   void setBatch(PersistBatch persistBatchMode);
@@ -207,7 +345,6 @@ public interface Transaction extends Closeable {
    * </p>
    *
    * @param batchOnCascadeMode the batch mode to use per save(), insert(), update() or delete()
-   *
    * @see com.avaje.ebean.config.ServerConfig#setPersistBatchOnCascade(com.avaje.ebean.config.PersistBatch)
    */
   void setBatchOnCascade(PersistBatch batchOnCascadeMode);
@@ -326,9 +463,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/TxCallable.java

@@ -12,24 +12,26 @@ package com.avaje.ebean;
  * <p>
  * See also {@link TxRunnable}.
  * </p>
- * 
- * <pre class="code">
- * Ebean.execute(new TxCallable&lt;String&gt;() {
+ * <p>
+ * <pre>{@code
+ *
+ * Ebean.execute(new TxCallable<String>() {
  *   public String call() {
  *     User u1 = Ebean.find(User.class, 1);
  *     User u2 = Ebean.find(User.class, 2);
- * 
- *     u1.setName(&quot;u1 mod&quot;);
- *     u2.setName(&quot;u2 mod&quot;);
- * 
+ *
+ *     u1.setName("u1 mod");
+ *     u2.setName("u2 mod");
+ *
  *     Ebean.save(u1);
  *     Ebean.save(u2);
- * 
+ *
  *     return u1.getEmail();
  *   }
  * });
- * </pre>
- * 
+ *
+ * }</pre>
+ *
  * @see TxRunnable
  */
 public interface TxCallable<T> {

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

@@ -1,100 +0,0 @@
-package com.avaje.ebean;
-
-import java.sql.Connection;
-
-/**
- * The Transaction Isolation levels.
- * <p>
- * These match those of java.sql.Connection with the addition of DEFAULT which
- * implies the configured default of the DataSource.
- * </p>
- * <p>
- * This can be used with TxScope to define transactional scopes to execute
- * method within.
- * </p>
- * 
- * @see TxScope
- */
-public enum TxIsolation {
-
-  /**
-   * Read Committed Isolation level. This is typically the default for most
-   * configurations.
-   */
-  READ_COMMITED(Connection.TRANSACTION_READ_COMMITTED),
-
-  /**
-   * Read uncommitted Isolation level.
-   */
-  READ_UNCOMMITTED(Connection.TRANSACTION_READ_UNCOMMITTED),
-
-  /**
-   * Repeatable Read Isolation level.
-   */
-  REPEATABLE_READ(Connection.TRANSACTION_REPEATABLE_READ),
-
-  /**
-   * Serializable Isolation level.
-   */
-  SERIALIZABLE(Connection.TRANSACTION_SERIALIZABLE),
-
-  /**
-   * No Isolation level.
-   */
-  NONE(Connection.TRANSACTION_NONE),
-
-  /**
-   * The default isolation level. This typically means the default that the
-   * DataSource is using or configured to use.
-   */
-  DEFAULT(-1);
-
-  final int level;
-
-  TxIsolation(int level) {
-    this.level = level;
-  }
-
-  /**
-   * Return the level as per java.sql.Connection.
-   * <p>
-   * Note that -1 denotes the default isolation level.
-   * </p>
-   */
-  public int getLevel() {
-    return level;
-  }
-
-  /**
-   * Return the TxIsolation given the java.sql.Connection isolation level.
-   * <p>
-   * Note that -1 denotes the default isolation level.
-   * </p>
-   */
-  public static TxIsolation fromLevel(int connectionIsolationLevel) {
-
-    switch (connectionIsolationLevel) {
-    case Connection.TRANSACTION_READ_UNCOMMITTED:
-      return TxIsolation.READ_UNCOMMITTED;
-
-    case Connection.TRANSACTION_READ_COMMITTED:
-      return TxIsolation.READ_COMMITED;
-
-    case Connection.TRANSACTION_REPEATABLE_READ:
-      return TxIsolation.REPEATABLE_READ;
-
-    case Connection.TRANSACTION_SERIALIZABLE:
-      return TxIsolation.SERIALIZABLE;
-
-    case Connection.TRANSACTION_NONE:
-      return TxIsolation.NONE;
-
-    case -1:
-      return TxIsolation.DEFAULT;
-
-    default:
-      throw new RuntimeException("Unknown isolation level " + connectionIsolationLevel);
-    }
-
-  }
-}

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

@@ -8,26 +8,27 @@ package com.avaje.ebean;
  * <p>
  * See also {@link TxCallable}.
  * </p>
- * 
- * <pre class="code">
- * 
+ * <p>
+ * <pre>{@code
+ *
  * // this run method runs in a transaction scope
  * // which by default is TxScope.REQUIRED
- * 
+ *
  * Ebean.execute(new TxRunnable() {
  *   public void run() {
  *     User u1 = Ebean.find(User.class, 1);
  *     User u2 = Ebean.find(User.class, 2);
- * 
- *     u1.setName(&quot;u1 mod&quot;);
- *     u2.setName(&quot;u2 mod&quot;);
- * 
+ *
+ *     u1.setName("u1 mod");
+ *     u2.setName("u2 mod");
+ *
  *     Ebean.save(u1);
  *     Ebean.save(u2);
  *   }
  * });
- * </pre>
- * 
+ *
+ * }</pre>
+ *
  * @see TxCallable
  */
 public interface TxRunnable {

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.
    */
@@ -124,8 +105,45 @@ public final class TxScope {
    */
   public String toString() {
     return "TxScope[" + type + "] readOnly[" + readOnly + "] isolation[" + isolation
-        + "] serverName[" + serverName
-        + "] rollbackFor[" + rollbackFor + "] noRollbackFor[" + noRollbackFor + "]";
+      + "] serverName[" + serverName + "] 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;
   }
 
   /**
@@ -188,6 +206,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.
    */
@@ -248,7 +281,7 @@ public final class TxScope {
    */
   public TxScope setRollbackFor(Class<? extends Throwable> rollbackThrowable) {
     if (rollbackFor == null) {
-      rollbackFor = new ArrayList<Class<? extends Throwable>>(2);
+      rollbackFor = new ArrayList<>(2);
     }
     rollbackFor.add(rollbackThrowable);
     return this;
@@ -260,10 +293,10 @@ public final class TxScope {
   @SuppressWarnings("unchecked")
   public TxScope setRollbackFor(Class<?>[] rollbackThrowables) {
     if (rollbackFor == null) {
-      rollbackFor = new ArrayList<Class<? extends Throwable>>(rollbackThrowables.length);
+      rollbackFor = new ArrayList<>(rollbackThrowables.length);
     }
-    for (int i = 0; i < rollbackThrowables.length; i++) {
-      rollbackFor.add((Class<? extends Throwable>) rollbackThrowables[i]);
+    for (Class<?> rollbackThrowable : rollbackThrowables) {
+      rollbackFor.add((Class<? extends Throwable>) rollbackThrowable);
     }
     return this;
   }
@@ -282,7 +315,7 @@ public final class TxScope {
    */
   public TxScope setNoRollbackFor(Class<? extends Throwable> noRollback) {
     if (noRollbackFor == null) {
-      noRollbackFor = new ArrayList<Class<? extends Throwable>>(2);
+      noRollbackFor = new ArrayList<>(2);
     }
     this.noRollbackFor.add(noRollback);
     return this;
@@ -294,10 +327,10 @@ public final class TxScope {
   @SuppressWarnings("unchecked")
   public TxScope setNoRollbackFor(Class<?>[] noRollbacks) {
     if (noRollbackFor == null) {
-      noRollbackFor = new ArrayList<Class<? extends Throwable>>(noRollbacks.length);
+      noRollbackFor = new ArrayList<>(noRollbacks.length);
     }
-    for (int i = 0; i < noRollbacks.length; i++) {
-      noRollbackFor.add((Class<? extends Throwable>) noRollbacks[i]);
+    for (Class<?> noRollback : noRollbacks) {
+      noRollbackFor.add((Class<? extends Throwable>) noRollback);
     }
     return this;
   }

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

@@ -1,50 +0,0 @@
-package com.avaje.ebean;
-
-/**
- * Used to define the transactional scope for executing a method. Matches the
- * types defined in the EJB TransactionAttributeType.
- * <p>
- * Used with the Transactional annotation and the {@link TxScope} with
- * {@link Ebean#execute(TxScope, TxCallable)} and
- * {@link Ebean#execute(TxScope, TxRunnable)}.
- * </p>
- * 
- * @see TxScope
- */
-public enum TxType {
-
-  /**
-   * Uses an existing transaction and if none exists will starts a new
-   * Transaction. This is the default.
-   */
-  REQUIRED,
-
-  /**
-   * A transaction MUST already have been started. Throws
-   * TransactionRequiredException.
-   */
-  MANDATORY,
-
-  /**
-   * Uses the existing transaction if one exists, otherwise the method does not
-   * run with a transaction. Used this with caution.
-   */
-  SUPPORTS,
-
-  /**
-   * Always start a new transaction. Suspend an existing once if required.
-   */
-  REQUIRES_NEW,
-
-  /**
-   * Suspends an existing transaction if required. Method runs without a
-   * transaction.
-   */
-  NOT_SUPPORTED,
-
-  /**
-   * If there is an existing transaction throws an Exception. Method runs
-   * without a transaction.
-   */
-  NEVER
-}

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

@@ -11,43 +11,43 @@ package com.avaje.ebean;
  * <p>
  * The following is an example of named updates on an entity bean.
  * </p>
- * 
- * <pre type="class">
+ * <pre>{@code
  *  ...
- * &#064;NamedUpdates(value = {
- *   &#064;NamedUpdate(
- *      name = &quot;setTitle&quot;, 
- *      notifyCache = false, 
- *      update = &quot;update topic set title = :title, postCount = :count where id = :id&quot;),
- *  &#064;NamedUpdate(
- *      name = &quot;setPostCount&quot;, 
- *      notifyCache = false, 
- *      update = &quot;update f_topic set post_count = :postCount where id = :id&quot;),
- *  &#064;NamedUpdate(
- *      name = &quot;incrementPostCount&quot;, 
- *      notifyCache = false, 
- *      update = &quot;update Topic set postCount = postCount + 1 where id = :id&quot;) 
- *      //update = &quot;update f_topic set post_count = post_count + 1 where id = :id&quot;) 
+ * @NamedUpdates(value = {
+ *   @NamedUpdate(
+ *      name = "setTitle",
+ *      notifyCache = false,
+ *      update = "update topic set title = :title, postCount = :count where id = :id"),
+ *  @NamedUpdate(
+ *      name = "setPostCount",
+ *      notifyCache = false,
+ *      update = "update f_topic set post_count = :postCount where id = :id"),
+ *  @NamedUpdate(
+ *      name = "incrementPostCount",
+ *      notifyCache = false,
+ *      update = "update Topic set postCount = postCount + 1 where id = :id")
+ *      //update = "update f_topic set post_count = post_count + 1 where id = :id")
  *  })
- * &#064;Entity
- * &#064;Table(name = &quot;f_topic&quot;)
+ * @Entity
+ * @Table(name = "f_topic")
  * public class Topic {
  *  ...
- * </pre>
- * 
+ * }</pre>
+ *
  * <p>
  * The following show code that would use a named update on the Topic entity
  * bean.
  * </p>
- * 
- * <pre class="code">
- * Update&lt;Topic&gt; update = Ebean.createUpdate(Topic.class, &quot;incrementPostCount&quot;);
- * update.setParameter(&quot;id&quot;, 1);
+ * <p>
+ * <pre>{@code
+ *
+ * Update<Topic> update = Ebean.createUpdate(Topic.class, "incrementPostCount");
+ * update.setParameter("id", 1);
  * int rows = update.execute();
- * </pre>
- * 
- * @param <T>
- *          the type of entity beans inserted updated or deleted
+ *
+ * }</pre>
+ *
+ * @param <T> the type of entity beans inserted updated or deleted
  */
 public interface Update<T> {
 
@@ -73,9 +73,8 @@ public interface Update<T> {
    * preparedStatement. If the timeout occurs an exception will be thrown - this
    * will be a SQLException wrapped up in a PersistenceException.
    * </p>
-   * 
-   * @param secs
-   *          the timeout in seconds. Zero implies unlimited.
+   *
+   * @param secs the timeout in seconds. Zero implies unlimited.
    */
   Update<T> setTimeout(int secs);
 
@@ -92,21 +91,17 @@ public interface Update<T> {
    * <p>
    * Set a value for each ? you have in the sql.
    * </p>
-   * 
-   * @param position
-   *          the index position of the parameter starting with 1.
-   * @param value
-   *          the parameter value to bind.
+   *
+   * @param position the index position of the parameter starting with 1.
+   * @param value    the parameter value to bind.
    */
   Update<T> set(int position, Object value);
 
   /**
    * Set and ordered bind parameter (same as bind).
-   * 
-   * @param position
-   *          the index position of the parameter starting with 1.
-   * @param value
-   *          the parameter value to bind.
+   *
+   * @param position the index position of the parameter starting with 1.
+   * @param value    the parameter value to bind.
    */
   Update<T> setParameter(int position, Object value);
 
@@ -129,11 +124,9 @@ public interface Update<T> {
    * <p>
    * A more succinct version of setParameter() to be consistent with Query.
    * </p>
-   * 
-   * @param name
-   *          the parameter name.
-   * @param value
-   *          the parameter value.
+   *
+   * @param name  the parameter name.
+   * @param value the parameter value.
    */
   Update<T> set(String name, Object value);
 
@@ -148,11 +141,9 @@ public interface Update<T> {
    * <p>
    * A more succinct version of setNullParameter().
    * </p>
-   * 
-   * @param name
-   *          the parameter name.
-   * @param jdbcType
-   *          the type of the property being bound.
+   *
+   * @param name     the parameter name.
+   * @param jdbcType the type of the property being bound.
    */
   Update<T> setNull(String name, int jdbcType);
 
@@ -166,4 +157,4 @@ public interface Update<T> {
    */
   String getGeneratedSql();
 
-}
+}

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

@@ -0,0 +1,156 @@
+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>
+ * <p>
+ * <h4>Example: Simple update</h4>
+ * <p>
+ * <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>
+ * <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>
+ * <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>
+ * <p>
+ * <pre>{@code sql
+ *
+ *   update o_customer set status=?, updtime=?
+ *   where id in (
+ *     select t0.id c0
+ *     from o_customer t0
+ *     left 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.
+   * <p>
+   * <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.
+   * <p>
+   * <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>
+   * <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/ValuePair.java

@@ -29,7 +29,7 @@ public class ValuePair {
   public Object getNewValue() {
     return newValue;
   }
-  
+
   /**
    * Return the old value.
    */

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

@@ -1,55 +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;
-
-/**
- * Specify cache tuning for 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 {
-
-  /**
-   * 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/ChangeLog.java

@@ -1,34 +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;
-
-/**
- * Marks an entity bean as being included in the change logging.
- */
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface ChangeLog {
-
-  /**
-   * Specify if inserts should be explicitly Included or Excluded.
-   * <p>
-   * If not defined explicitly then the server default behaviour defined
-   * on ServerConfig is used.
-   * </p>
-   */
-  ChangeLogInsertMode inserts() default ChangeLogInsertMode.DEFAULT;
-
-  /**
-   * When specified only include update requests that have at least one
-   * of the given properties as a dirty property.
-   * <p>
-   * This provides a way to filter requests to include in the change log such that
-   * only updates that include at least one of the given properties is included
-   * in the change log.
-   * </p>
-   */
-  String[] updatesThatInclude() default {};
-}

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

@@ -1,22 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * The mode used to determine if inserts should be included or not for a given bean type.
- */
-public enum ChangeLogInsertMode {
-
-  /**
-   * Use the default behaviour as defined on ServerConfig.
-   */
-  DEFAULT,
-
-  /**
-   * Include inserts in the change log.
-   */
-  INCLUDE,
-
-  /**
-   * Exclude inserts in the change log.
-   */
-  EXCLUDE
-}

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

@@ -1,17 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * Optimistic concurrency mode used for updates and deletes.
- */
-public enum ConcurrencyMode {
-
-	/**
-	 * No concurrency checking.
-	 */
-	NONE,
-	
-	/**
-	 * Use a version column.
-	 */
-	VERSION
-}

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

@@ -1,38 +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 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).
- * </p>
- * <p>
- * The downside to this approach is that the inserted entity does not have the
- * timestamp value after the insert has occurred. You need to fetch the entity
- * back to get the inserted timestamp if you want to used it.
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @CreatedTimestamp
- *   Timestamp whenCreated;
- *
- * }</pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface CreatedTimestamp {
-
-}

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

@@ -1,19 +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;
-
-/**
- * A database table or column comment.
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
-public @interface DbComment {
-
-  /**
-   * The database table or column comment.
-   */
-  String value();
-}

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

@@ -1,17 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * Specify the DB storage type used to with <code>@DbEnumValue</code>.
- */
-public enum DbEnumType {
-
-  /**
-   * Store values as database INTEGER.
-   */
-  INTEGER,
-
-  /**
-   * Store values as database VARCHAR.
-   */
-  VARCHAR
-}

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

@@ -1,44 +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;
-
-/**
- * Specify a method on an Enum that returns the value that should be stored in the DB.
- * <p>
- * This is the preferred option for mapping Enum's to DB values (preferred over the JPA
- * standard @Enumerated and Ebean's @EnumValue annotations).
- * </p>
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   public enum Status {
- *     NEW("N"),
- *     ACTIVE("A"),
- *     INACTIVE("I");
- *
- *     String dbValue;
- *     Status(String dbValue) {
- *       this.dbValue = dbValue;
- *     }
- *
- *     @DbEnumValue
- *     public String getValue() {
- *       return dbValue;
- *     }
- *   }
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.METHOD)
-public @interface DbEnumValue {
-
-  /**
-   * Specify the database type used to store the values (VARCHAR or INTEGER).
-   */
-  DbEnumType storage() default DbEnumType.VARCHAR;
-
-}

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

@@ -1,26 +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;
-
-/**
- * Used for mapping a Map<String,String> type property to Postgres HSTORE data type.
- * <p>
- * The Map property should have keys and values of type String.
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @DbHstore
- *   Map<String, String> tags;
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DbHstore {
-
-}

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

@@ -1,44 +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;
-
-/**
- * Specify a property holding JSON content.
- * <p>
- * By default the content will be stored in a DB Clob except on Postgres where DB JSON type is used.
- * </p>
- * <h3>Example:</h3>
- * <pre>{@code
- *
- * // Store as JSON on Postgres or Clob on other databases
- * @DbJson
- * Map<String,Object> content;
- *
- * }</pre>
- *
- * <h3>Example with JSONB storage</h3>
- * <pre>{@code
- *
- * // Store as JSONB on Postgres or Clob on other databases
- * @DbJson(storage = DbJsonType.JSONB)
- * Map<String,Object> content;
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DbJson {
-
-  /**
-   * Specify the database type used to store the JSON content.
-   */
-  DbJsonType storage() default DbJsonType.JSON;
-
-  /**
-   * For VARCHAR storage specify the column length (defaults to 3000).
-   */
-  int length() default 0;
-}

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

@@ -1,39 +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;
-
-/**
- * Specify a property holding JSON content.
- * <p>
- * The content will be stored on Postgres using it's JSONB type and as Clob for other databases.
- * </p>
- * <p>
- *   This is equivalent to using <code>@DbJson(storage = DbJsonType.JSONB)</code>
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- * // Store as JSONB on Postgres or Clob on other databases
- * @DbJsonB
- * Map<String,Object> content;
- *
- * }</pre>
- *
- * <h3>Equivalent to:</h3>
- * <pre>{@code
- *
- * // Store as JSONB on Postgres or Clob on other databases
- * @DbJson(storage = DbJsonType.JSONB)
- * Map<String,Object> content;
- *
- * }</pre>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DbJsonB {
-
-}

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

@@ -1,32 +0,0 @@
-package com.avaje.ebean.annotation;
-
-/**
- * Specify the DB storage type used to store JSON content.
- */
-public enum DbJsonType {
-
-  /**
-   * Store as JSON on Postgres and for other databases store as CLOB.
-   */
-  JSON,
-
-  /**
-   * Store as JSONB on Postgres and for other databases store as CLOB.
-   */
-  JSONB,
-
-  /**
-   * Store as database VARCHAR.
-   */
-  VARCHAR,
-
-  /**
-   * Store as database CLOB.
-   */
-  CLOB,
-
-  /**
-   * Store as database BLOB.
-   */
-  BLOB
-}

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

@@ -1,19 +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;
-
-/**
- * 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/DraftDirty.java

@@ -1,20 +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;
-
-/**
- * Marks a boolean property on a @Draftable bean that only exists on the 'draft' table
- * and is used to detect when a draft has unpublished changes.
- * <p>
- * This property will automatically have it's value set to true when a draft is saved and
- * automatically have it's value set to false when the bean is published.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DraftDirty {
-
-}

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

@@ -1,19 +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;
-
-/**
- * Marks a property on a @Draftable bean that only exists on the 'draft' and not the 'live' table.
- * <p>
- * Typically this would be used on a property that is used as part of application 'workflow' such as
- * a publish workflow status or when publish timestamp.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DraftOnly {
-
-}

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

@@ -1,19 +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;
-
-/**
- * Marks a property on a @Draftable bean that is set to null on the 'draft bean' on publish.
- * <p>
- * This is expected to be put on properties that get 'reset' or 'cleared' after a publish.
- * These properties might represent a publish comment or publish timestamp.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface DraftReset {
-
-}

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

@@ -1,29 +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;
-
-/**
- * Used to indicate an entity bean that has 'draftable' support.
- * <p>
- * This means that a second set of tables is created to hold draft versions of
- * the rows and that these can then be published which effectively copies/transfers
- * the values from the 'draft' table to the 'live' table.
- * </p>
- * <p>
- * Ebean Query supports 'find as draft' which builds the resulting object graph using
- * the draft tables. This object graph is typically edited, approved in some application
- * specific manor and then published.
- * </p>
- * <p>
- * EbeanServer has a publish method which transfers/copies the draft object graph to
- * the 'live' tables.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-public @interface Draftable {
-
-}

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

@@ -1,20 +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;
-
-/**
- * Used to indicate an entity bean that has 'draftable' support but it not a 'top level'
- * (or root level) bean but instead child related to another @Draftable entity bean.
- * <p>
- * Relationships to @DraftableElements (@OneToMany, @ManyToMany etc) are automatically
- * deemed to have Cascade.ALL for save and delete (as well as orphan removal mode).
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-public @interface DraftableElement {
-
-}

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

@@ -1,31 +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;
-
-/**
- * Specify property name to db column mapping for Embedded beans.
- * <p>
- * This is designed to be easier to use than the AttributeOverride annotation in
- * standard JPA.
- * </p>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface EmbeddedColumns {
-
-  /**
-   * A list of property names mapped to DB columns.
-   * <p>
-   * For example <code>currency=IN_CURR, amount=IN_AMOUNT</code>
-   * </p>
-   * <p>
-   * Where currency and amount are properties and IN_CURR and IN_AMOUNT are the
-   * respective DB columns these properties will be mapped to.
-   * </p>
-   */
-  String columns() default "";
-
-}

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

@@ -1,24 +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;
-
-/**
- * Specify that the property is stored in encrypted form.
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Encrypted {
-
-  /**
-   * When true try to use DB encryption rather than local java encryption.
-   */
-  boolean dbEncryption() default true;
-
-  /**
-   * Used to specify the DB column length.
-   */
-  int dbLength() default 0;
-}

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

@@ -1,19 +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;
-
-/**
- * Specify explicit ConcurrencyMode for entity bean.
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface EntityConcurrencyMode {
-  
-  /**
-   * The ConcurrencyMode value.
-   */
-  ConcurrencyMode value();
-}

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

@@ -1,48 +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;
-
-/**
- * Enables you to specify a value to use to persist for an enum value.
- * 
- * <pre>{@code
- *
- * public enum Status {
- *
- *   @EnumValue("N")
- *   NEW,
- * 
- *   @EnumValue("A")
- *   ACTIVE,
- * 
- *   @EnumValue("I")
- *   INACTIVE,
- * }
- * 
- * }</pre>
- * <p>
- * This is an alternative to using the JPA standard approach or Ebean's
- * {@link DbEnumValue} annotation.
- * </p>
- * <p>
- * Note that if all the EnumValue values are parsable as Integers then Ebean
- * will persist and fetch them as integers - otherwise they will be persisted
- * and fetched as strings.
- * </p>
- */
-@Target({ ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface EnumValue {
-
-  /**
-   * Specify the value to persist for a specific enum value.
-   * <p>
-   * If all the values are parsable as Integers then Ebean will persist and
-   * fetch them as integers rather than strings.
-   * </p>
-   */
-  String value();
-}

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

@@ -1,28 +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;
-
-/*
-    Copied from gson!!!
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface Expose {
-
-  /**
-   * If {@code true}, the field marked with this annotation is written out in the JSON while
-   * serializing. If {@code false}, the field marked with this annotation is skipped from the
-   * serialized output. Defaults to {@code true}.
-   */
-  boolean serialize() default true;
-
-  /**
-   * If {@code true}, the field marked with this annotation is deserialized from the JSON.
-   * If {@code false}, the field marked with this annotation is skipped during deserialization.
-   * Defaults to {@code true}.
-   */
-  boolean deserialize() default true;
-}

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

@@ -1,12 +1,14 @@
 package com.avaje.ebean.annotation;
 
+import com.avaje.ebean.Query;
+import com.avaje.ebean.config.Platform;
+
 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;
 
-import com.avaje.ebean.Query;
-
 /**
  * Assign to a property to be based on a SQL formula.
  * <p>
@@ -24,28 +26,27 @@ import com.avaje.ebean.Query;
  * You may want to do this if the Formula is relatively expensive and only want
  * it included in the query when you explicitly state it.
  * </p>
- * 
- * <pre class="code">
- * // On the Order &quot;master&quot; bean
+ * <p>
+ * <pre>{@code
+ * // On the Order "master" bean
  * // ... a formula using the Order details
  * // ... sum(order_qty*unit_price)
- * &#064;Transient
- * &#064;Formula(select = &quot;_b${ta}.total_amount&quot;, join = &quot;join (select order_id, sum(order_qty*unit_price) as total_amount from o_order_detail group by order_id) as _b${ta} on _b${ta}.order_id = ${ta}.id&quot;)
+ * @Transient
+ * @Formula(select = "_b${ta}.total_amount", join = "join (select order_id, sum(order_qty*unit_price) as total_amount from o_order_detail group by order_id) as _b${ta} on _b${ta}.order_id = ${ta}.id")
  * Double totalAmount;
- * 
- * </pre>
+ *
+ * }</pre>
  * <p>
  * As the totalAmount formula is also Transient it is not included by default in
  * queries - it needs to be explicitly included.
  * </p>
- * 
  * <pre>{@code
  *
  * // find by Id
  * Order o1 = Ebean.find(Order.class)
  *     .select("id, totalAmount")
  *     .setId(1).findUnique();
- * 
+ *
  * // find list ... using totalAmount in the where clause
  * List<Order> list = Ebean.find(Order.class)
  *     .select("id, totalAmount")
@@ -53,7 +54,7 @@ import com.avaje.ebean.Query;
  *     .eq("status", Order.Status.NEW)
  *     .gt("totalAmount", 10)
  *     .findList();
- * 
+ *
  * // as a join from customer
  * List<Customer> l0 = Ebean.find(Customer.class)
  *     .select("id, name")
@@ -62,11 +63,12 @@ import com.avaje.ebean.Query;
  *     .gt("id", 0)
  *     .gt("orders.totalAmount", 10)
  *     .findList();
- * 
+ *
  * }</pre>
  */
-@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
+@Repeatable(Formula.List.class)
 public @interface Formula {
 
   /**
@@ -82,9 +84,8 @@ public @interface Formula {
    * as count, sum etc.
    * </p>
    * <p>
-   * The join string should start with either "left outer join" or "join".
+   * The join string should start with either "left join" or "join".
    * </p>
-   * 
    * <p>
    * You will almost certainly use the "${ta}" as a place holder for the table
    * alias of the table you are joining back to (the "base table" of the entity
@@ -94,7 +95,7 @@ public @interface Formula {
    * The example below is used to support a total count of topics created by a
    * user.
    * </p>
-   * 
+   * <p>
    * <pre>{@code
    *
    * join (select user_id, count(*) as topic_count from f_topic group by user_id) as _tc on _tc.user_id = ${ta}.id
@@ -103,4 +104,16 @@ public @interface Formula {
    */
   String join() default "";
 
+  Platform[] platforms() default {};
+
+  /**
+   * Repeatable support for {@link Formula}.
+   */
+  @Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
+  @Retention(RetentionPolicy.RUNTIME)
+  @interface List {
+
+    Formula[] value() default {};
+  }
+
 }

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

@@ -1,19 +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;
-
-/**
- * Marks an entity bean as having history support.
- * <p>
- * In Postgres for example this means there is an associated history table which is
- * typically automatically populated via database triggers.
- * </p>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface History {
-
-}

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

@@ -1,25 +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;
-
-/**
- * Marks a property as being excluded from history.
- * <p>
- * This means the property values are not maintained in the history table. Typically this
- * would be placed on relatively large properties (Clobs, Blobs, large varchar columns etc)
- * that are considered not interesting enough to maintain history on excluding them reduces
- * underlying database costs.
- * </p>
- * <p>
- * When placed on a ManyToMany this means that the intersection table does not have history
- * support.
- * </p>
- */
-@Target({ ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface HistoryExclude {
-
-}

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

@@ -1,33 +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 annotation for declaring an index on a single column.
- *
- * @author rvbiljouw
- */
-@Target({ElementType.TYPE, ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Index {
-
-  /**
-   * Name of the index. If left blank a name is derived using the built in naming convention.
-   */
-  String name() default "";
-
-  /**
-   * If set true indicates this is a unique index.
-   */
-  boolean unique() default false;
-
-  /**
-   * When placed on the class (rather than field) you can specify the columns
-   * to include in the index in order.
-   */
-  String[] columnNames() default {};
-
-}

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

@@ -1,32 +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;
-
-/**
- * Similar to Jackson JsonIgnore but provides the option to just ignore serialize or deserialize.
- * <p>
- *   This provides the same features as Expose but from the opposite perspective which is probably
- *   more common and more familiar to Jackson users.
- * </p>
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-public @interface JsonIgnore {
-
-  /**
-   * If {@code true}, the field marked with this annotation is written out in the JSON while
-   * serializing. If {@code false}, the field marked with this annotation is skipped from the
-   * serialized output. Defaults to {@code false}.
-   */
-  boolean serialize() default false;
-
-  /**
-   * If {@code true}, the field marked with this annotation is deserialized from the JSON.
-   * If {@code false}, the field marked with this annotation is skipped during deserialization.
-   * Defaults to {@code false}.
-   */
-  boolean deserialize() default false;
-}

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

@@ -1,20 +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;
-
-/**
- * Holds an array of named Update statements for a particular entity bean type.
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface NamedUpdates {
-
-  /**
-   * An array of named updates.
-   */
-  NamedUpdate[] value();
-
-}

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

@@ -1,34 +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;
-
-/**
- * Specify that the elements of a OneToMany are private owned.
- * <p>
- * This means that if they are removed from the List/Set/Map they will be
- * deleted when their parent object is saved.
- * </p>
- * <p>
- * This could also be described as deleting orphans - in that beans removed from
- * the List/Set/Map will be deleted automatically when the parent bean is saved.
- * They are considered 'orphans' when they have been removed from the collection
- * in that they are no longer associated/linked to their parent bean.
- * </p>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface PrivateOwned {
-
-  /**
-   * Set this to false if you don't want cascade REMOVE on this relationship.
-   * <p>
-   * That is, by default PrivateOwned implicitly adds a cascade REMOVE to the
-   * relationship and if you don't want that you need to set this to false.
-   * </p>
-   */
-  boolean cascadeRemove() default true;
-
-}

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

@@ -1,15 +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;
-
-/**
- * Marks an entity bean as being included in read auditing.
- */
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface ReadAudit {
-
-}

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

@@ -1,25 +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;
-
-/**
- * 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

@@ -1,24 +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;
-
-/**
- * Specify explicit sql for multiple select statements. Need to use this if you
- * have more than one SqlSelect for a given bean.
- * <p>
- * FUTURE: Support explicit sql for SqlInsert, SqlUpdate and SqlDelete.
- * </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

@@ -1,14 +1,14 @@
 package com.avaje.ebean.annotation;
 
+import com.avaje.ebean.TxIsolation;
+import com.avaje.ebean.TxType;
+import com.avaje.ebean.config.PersistBatch;
+
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import com.avaje.ebean.TxIsolation;
-import com.avaje.ebean.TxType;
-import com.avaje.ebean.config.PersistBatch;
-
 /**
  * Specify transaction scoping for a method.
  * <p>
@@ -33,22 +33,22 @@ import com.avaje.ebean.config.PersistBatch;
  * to set the default behaviour to rollback on any exception and optionally
  * change the setting to be consistent with EJB/Spring if people wish to do so.
  * </p>
- * 
+ * <p>
  * <pre>{@code
  *
  *  // a normal class
  *  public class MySimpleUserService {
- * 
+ *
  *    // this method is transactional automatically handling
  *    // transaction begin, commit and rollback etc
  *    @Transactional
  *    public void runInTrans() throws IOException {
- * 
+ *
  *      // tasks performed within the transaction
  *      ...
  *      // find some objects
  *      Customer cust = ebeanServer.find(Customer.class, 42);
- *    
+ *
  *      Order order = ...;
  *      ...
  *      // save some objects
@@ -58,7 +58,7 @@ import com.avaje.ebean.config.PersistBatch;
  *
  * }</pre>
  */
-@Target({ ElementType.METHOD, ElementType.TYPE })
+@Target({ElementType.METHOD, ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Transactional {
 
@@ -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/UpdateMode.java

@@ -1,34 +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;
-
-/**
- * Specify the update mode for the specific entity type.
- * <p>
- * Control whether all 'loaded' properties are included in an Update or whether
- * just properties that have changed will be included in the update.
- * </p>
- * <p>
- * Note that the default can be set via ebean.properties.
- * </p>
- * 
- * <pre>
- * ## Set to update all loaded properties
- * ebean.updateChangesOnly=false
- * </pre>
- */
-@Target({ ElementType.TYPE })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface UpdateMode {
-
-  /**
-   * Set to false if you want to include all the 'loaded' properties in the
-   * update. Otherwise, just the properties that have changed will be included
-   * in the update.
-   */
-  boolean updateChangesOnly() default true;
-
-}

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

@@ -1,20 +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 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)
-public @interface UpdatedTimestamp {
-
-}

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

@@ -1,38 +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 a timestamp property that is set to the datetime when the entity is
- * created/inserted.
- * <p>
- * This is effectively an alias for @CreatedTimestamp and added to hint
- * 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).
- * </p>
- * <p>
- * The downside to this approach is that the inserted entity does not have the
- * timestamp value after the insert has occurred. You need to fetch the entity
- * back to get the inserted timestamp if you want to used it.
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @WhenCreated
- *   Timestamp whenCreated;
- *
- * }</pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface WhenCreated {
-
-}

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

@@ -1,19 +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 a timestamp property that is set to the datetime when the entity was last modified.
- * <p>
- * This is effectively an alias for @UpdatedTimestamp and added to hint
- * towards a better naming convention (WhenCreated, WhenModified).
- * </p>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface WhenModified {
-
-}

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

@@ -1,6 +1,9 @@
 package com.avaje.ebean.annotation;
 
+import com.avaje.ebean.config.Platform;
+
 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;
@@ -8,38 +11,35 @@ import java.lang.annotation.Target;
 /**
  * Add an Literal to add to the where clause when a many property (List, Set or
  * Map) is loaded or refreshed.
- * 
  * <pre>{@code
  *
  * // on a OneToMany property...
- * 
+ *
  * @OneToMany
  * @Where(clause = "deleted='y'")
  * List<Topic> topics;
  *
  * }</pre>
- * 
  * <p>
  * Note that you can include "${ta}" as a place holder for the table alias if
  * you need to include the table alias in the clause.
  * </p>
- * 
  * <pre>{@code
  * // ... including the ${ta} table alias placeholder...
- * 
+ *
  * @OneToMany
  * @Where(clause = "${ta}.deleted='y'")
  * List<Topic> topics;
  *
  * }</pre>
- * 
  * <p>
  * This will be added to the where clause when lazy loading the OneToMany
  * property or when there is a join to that OneToMany property.
  * </p>
  */
-@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
+@Repeatable(Where.List.class)
 public @interface Where {
 
   /**
@@ -51,4 +51,18 @@ public @interface Where {
    */
   String clause();
 
+  /**
+   * The platform where this annotation is active. Default: any platform
+   */
+  Platform[] platforms() default {};
+
+  /**
+   * Repeatable support for {@link Where}.
+   */
+  @Target({ ElementType.FIELD, ElementType.METHOD, ElementType.TYPE })
+  @Retention(RetentionPolicy.RUNTIME)
+  @interface List {
+
+    Where[] value() default {};
+  }
 }

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

@@ -1,29 +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;
-
-/**
- * Mapped onto a entity bean property that represents the user id of
- * who created the entity>
- * <p>
- * To use this annotation you need to implement CurrentUserProvider.
- * The type of the bean property should match the type returned by
- * CurrentUserProvider.
- *</p>
-
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @WhoCreated
- *   String whoCreated;
- *
- * }</pre>
- */
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface WhoCreated {
-
-}

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

@@ -1,29 +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;
-
-/**
- * Mapped onto a entity bean property that represents the user id of
- * who last modified the entity>
- * <p>
- * To use this annotation you need to implement CurrentUserProvider.
- * The type of the bean property should match the type returned by
- * CurrentUserProvider.
- * </p>
- *
- * <h3>Example:</h3>
- * <pre>{@code
- *
- *   @WhoModified
- *   String whoModified;
- *
- * }</pre>
- */
-@Target({ElementType.FIELD, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface WhoModified {
-
-}

src/main/java/com/avaje/ebean/annotation/package.html

@@ -1,14 +0,0 @@
-<HTML>
-<HEAD>
-	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1">
-	<TITLE>Extra deployment annotations</TITLE>
-</HEAD>
-<Body BGCOLOR="#ffffff">
-Extra deployment annotations
-
-<p>
-Extra deployment annotations for entity beans.
-</p>
-
-</Body>
-</HTML>

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

@@ -1,11 +1,11 @@
 package com.avaje.ebean.bean;
 
+import com.avaje.ebean.ExpressionList;
+
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Set;
 
-import com.avaje.ebean.ExpressionList;
-
 /**
  * Lazy loading capable Maps, Lists and Sets.
  * <p>
@@ -23,14 +23,30 @@ import com.avaje.ebean.ExpressionList;
 public interface BeanCollection<E> extends Serializable {
 
   enum ModifyListenMode {
-    /** The common mode */
+    /**
+     * The common mode
+     */
     NONE,
-    /** Mode used for PrivateOwned */
+    /**
+     * Mode used for PrivateOwned
+     */
     REMOVALS,
-    /** Mode used for ManyToMany relationships */
+    /**
+     * Mode used for ManyToMany relationships
+     */
     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 +65,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 +105,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 +138,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);
-}